Java tutorial
/* * Copyright (C) 2009 The Android Open Source Project * Copyright 2014 gitblit.com. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.gitblit.transport.ssh.commands; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStream; import java.io.InterruptedIOException; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.StringWriter; import java.util.concurrent.Future; import java.util.concurrent.atomic.AtomicReference; import org.apache.sshd.common.SshException; import org.apache.sshd.server.Command; import org.apache.sshd.server.Environment; import org.apache.sshd.server.ExitCallback; import org.apache.sshd.server.SessionAware; import org.apache.sshd.server.session.ServerSession; import org.kohsuke.args4j.Argument; import org.kohsuke.args4j.CmdLineException; import org.kohsuke.args4j.Option; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.gitblit.Keys; import com.gitblit.utils.StringUtils; import com.gitblit.utils.WorkQueue; import com.gitblit.utils.WorkQueue.CancelableRunnable; import com.gitblit.utils.cli.CmdLineParser; import com.google.common.base.Charsets; import com.google.common.util.concurrent.Atomics; public abstract class BaseCommand implements Command, SessionAware { private static final Logger log = LoggerFactory.getLogger(BaseCommand.class); private static final int PRIVATE_STATUS = 1 << 30; public final static int STATUS_CANCEL = PRIVATE_STATUS | 1; public final static int STATUS_NOT_FOUND = PRIVATE_STATUS | 2; public final static int STATUS_NOT_ADMIN = PRIVATE_STATUS | 3; protected InputStream in; protected OutputStream out; protected OutputStream err; protected ExitCallback exit; protected ServerSession session; /** Ssh command context */ private SshCommandContext ctx; /** Text of the command line which lead up to invoking this instance. */ private String commandName = ""; /** Unparsed command line options. */ private String[] argv; /** The task, as scheduled on a worker thread. */ private final AtomicReference<Future<?>> task; private WorkQueue workQueue; public BaseCommand() { task = Atomics.newReference(); } @Override public void setSession(final ServerSession session) { this.session = session; } @Override public void destroy() { log.debug("destroying " + getClass().getName()); Future<?> future = task.getAndSet(null); if (future != null && !future.isDone()) { future.cancel(true); } session = null; ctx = null; } protected static PrintWriter toPrintWriter(final OutputStream o) { return new PrintWriter(new BufferedWriter(new OutputStreamWriter(o, Charsets.UTF_8))); } @Override public abstract void start(Environment env) throws IOException; protected void provideStateTo(final BaseCommand cmd) { cmd.setContext(ctx); cmd.setWorkQueue(workQueue); cmd.setInputStream(in); cmd.setOutputStream(out); cmd.setErrorStream(err); cmd.setExitCallback(exit); } public WorkQueue getWorkQueue() { return workQueue; } public void setWorkQueue(WorkQueue workQueue) { this.workQueue = workQueue; } public void setContext(SshCommandContext ctx) { this.ctx = ctx; } public SshCommandContext getContext() { return ctx; } @Override public void setInputStream(final InputStream in) { this.in = in; } @Override public void setOutputStream(final OutputStream out) { this.out = out; } @Override public void setErrorStream(final OutputStream err) { this.err = err; } @Override public void setExitCallback(final ExitCallback callback) { this.exit = callback; } protected String getName() { return commandName; } void setName(final String prefix) { this.commandName = prefix; } public String[] getArguments() { return argv; } public void setArguments(final String[] argv) { this.argv = argv; } /** * Parses the command line argument, injecting parsed values into fields. * <p> * This method must be explicitly invoked to cause a parse. * * @throws UnloggedFailure * if the command line arguments were invalid. * @see Option * @see Argument */ protected void parseCommandLine() throws UnloggedFailure { parseCommandLine(this); } /** * Parses the command line argument, injecting parsed values into fields. * <p> * This method must be explicitly invoked to cause a parse. * * @param options * object whose fields declare Option and Argument annotations to * describe the parameters of the command. Usually {@code this}. * @throws UnloggedFailure * if the command line arguments were invalid. * @see Option * @see Argument */ protected void parseCommandLine(Object options) throws UnloggedFailure { final CmdLineParser clp = newCmdLineParser(options); try { clp.parseArgument(argv); } catch (IllegalArgumentException err) { if (!clp.wasHelpRequestedByOption()) { throw new UnloggedFailure(1, "fatal: " + err.getMessage()); } } catch (CmdLineException err) { if (!clp.wasHelpRequestedByOption()) { throw new UnloggedFailure(1, "fatal: " + err.getMessage()); } } if (clp.wasHelpRequestedByOption()) { CommandMetaData meta = getClass().getAnnotation(CommandMetaData.class); String title = meta.name().toUpperCase() + ": " + meta.description(); String b = com.gitblit.utils.StringUtils.leftPad("", title.length() + 2, '?'); StringWriter msg = new StringWriter(); msg.write('\n'); msg.write(b); msg.write('\n'); msg.write(' '); msg.write(title); msg.write('\n'); msg.write(b); msg.write("\n\n"); msg.write("USAGE\n"); msg.write("\n"); msg.write(' '); msg.write(commandName); msg.write('\n'); msg.write(" "); clp.printSingleLineUsage(msg, null); msg.write("\n\n"); String txt = getUsageText(); if (!StringUtils.isEmpty(txt)) { msg.write(txt); msg.write("\n\n"); } msg.write("ARGUMENTS & OPTIONS\n"); msg.write("\n"); clp.printUsage(msg, null); msg.write('\n'); String examples = usage().trim(); if (!StringUtils.isEmpty(examples)) { msg.write('\n'); msg.write("EXAMPLES\n"); msg.write("\n"); msg.write(examples); msg.write('\n'); } throw new UnloggedFailure(1, msg.toString()); } } /** Construct a new parser for this command's received command line. */ protected CmdLineParser newCmdLineParser(Object options) { return new CmdLineParser(options); } public String usage() { Class<? extends BaseCommand> clazz = getClass(); if (clazz.isAnnotationPresent(UsageExamples.class)) { return examples(clazz.getAnnotation(UsageExamples.class).examples()); } else if (clazz.isAnnotationPresent(UsageExample.class)) { return examples(clazz.getAnnotation(UsageExample.class)); } return ""; } protected String getUsageText() { return ""; } protected String examples(UsageExample... examples) { int sshPort = getContext().getGitblit().getSettings().getInteger(Keys.git.sshPort, 29418); String username = getContext().getClient().getUsername(); String hostname = "localhost"; String ssh = String.format("ssh -l %s -p %d %s", username, sshPort, hostname); StringBuilder sb = new StringBuilder(); for (UsageExample example : examples) { sb.append(example.description()).append("\n\n"); String syntax = example.syntax(); syntax = syntax.replace("${ssh}", ssh); syntax = syntax.replace("${username}", username); syntax = syntax.replace("${cmd}", commandName); sb.append(" ").append(syntax).append("\n\n"); } return sb.toString(); } protected void showHelp() throws UnloggedFailure { argv = new String[] { "--help" }; parseCommandLine(); } private final class TaskThunk implements CancelableRunnable { private final CommandRunnable thunk; private final String taskName; private TaskThunk(final CommandRunnable thunk) { this.thunk = thunk; StringBuilder m = new StringBuilder(); m.append(ctx.getCommandLine()); this.taskName = m.toString(); } @Override public void cancel() { synchronized (this) { try { onExit(STATUS_CANCEL); } finally { ctx = null; } } } @Override public void run() { synchronized (this) { final Thread thisThread = Thread.currentThread(); final String thisName = thisThread.getName(); int rc = 0; try { thisThread.setName("SSH " + taskName); thunk.run(); out.flush(); err.flush(); } catch (Throwable e) { try { out.flush(); } catch (Throwable e2) { } try { err.flush(); } catch (Throwable e2) { } rc = handleError(e); } finally { try { onExit(rc); } finally { thisThread.setName(thisName); } } } } @Override public String toString() { return taskName; } } /** Runnable function which can throw an exception. */ public interface CommandRunnable { void run() throws Exception; } /** Runnable function which can retrieve a project name related to the task */ public interface RepositoryCommandRunnable extends CommandRunnable { String getRepository(); } /** * Spawn a function into its own thread. * <p> * Typically this should be invoked within * {@link Command#start(Environment)}, such as: * * <pre> * startThread(new Runnable() { * public void run() { * runImp(); * } * }); * </pre> * * @param thunk * the runnable to execute on the thread, performing the * command's logic. */ protected void startThread(final Runnable thunk) { startThread(new CommandRunnable() { @Override public void run() throws Exception { thunk.run(); } }); } /** * Terminate this command and return a result code to the remote client. * <p> * Commands should invoke this at most once. * * @param rc exit code for the remote client. */ protected void onExit(final int rc) { exit.onExit(rc); } private int handleError(final Throwable e) { if ((e.getClass() == IOException.class && "Pipe closed".equals(e.getMessage())) || (e.getClass() == SshException.class && "Already closed".equals(e.getMessage())) || e.getClass() == InterruptedIOException.class) { // This is sshd telling us the client just dropped off while // we were waiting for a read or a write to complete. Either // way its not really a fatal error. Don't log it. // return 127; } if (e instanceof UnloggedFailure) { } else { final StringBuilder m = new StringBuilder(); m.append("Internal server error"); String user = ctx.getClient().getUsername(); if (user != null) { m.append(" (user "); m.append(user); m.append(")"); } m.append(" during "); m.append(ctx.getCommandLine()); log.error(m.toString(), e); } if (e instanceof Failure) { final Failure f = (Failure) e; try { err.write((f.getMessage() + "\n").getBytes(Charsets.UTF_8)); err.flush(); } catch (IOException e2) { } catch (Throwable e2) { log.warn("Cannot send failure message to client", e2); } return f.exitCode; } else { try { err.write("fatal: internal server error\n".getBytes(Charsets.UTF_8)); err.flush(); } catch (IOException e2) { } catch (Throwable e2) { log.warn("Cannot send internal server error message to client", e2); } return 128; } } /** * Spawn a function into its own thread. * <p> * Typically this should be invoked within * {@link Command#start(Environment)}, such as: * * <pre> * startThread(new CommandRunnable() { * public void run() throws Exception { * runImp(); * } * }); * </pre> * <p> * If the function throws an exception, it is translated to a simple message * for the client, a non-zero exit code, and the stack trace is logged. * * @param thunk * the runnable to execute on the thread, performing the * command's logic. */ protected void startThread(final CommandRunnable thunk) { final TaskThunk tt = new TaskThunk(thunk); task.set(workQueue.getDefaultQueue().submit(tt)); } /** Thrown from {@link CommandRunnable#run()} with client message and code. */ public static class Failure extends Exception { private static final long serialVersionUID = 1L; final int exitCode; /** * Create a new failure. * * @param exitCode * exit code to return the client, which indicates the * failure status of this command. Should be between 1 and * 255, inclusive. * @param msg * message to also send to the client's stderr. */ public Failure(final int exitCode, final String msg) { this(exitCode, msg, null); } /** * Create a new failure. * * @param exitCode * exit code to return the client, which indicates the * failure status of this command. Should be between 1 and * 255, inclusive. * @param msg * message to also send to the client's stderr. * @param why * stack trace to include in the server's log, but is not * sent to the client's stderr. */ public Failure(final int exitCode, final String msg, final Throwable why) { super(msg, why); this.exitCode = exitCode; } } /** Thrown from {@link CommandRunnable#run()} with client message and code. */ public static class UnloggedFailure extends Failure { private static final long serialVersionUID = 1L; /** * Create a new failure. * * @param msg * message to also send to the client's stderr. */ public UnloggedFailure(final String msg) { this(1, msg); } /** * Create a new failure. * * @param exitCode * exit code to return the client, which indicates the * failure status of this command. Should be between 1 and * 255, inclusive. * @param msg * message to also send to the client's stderr. */ public UnloggedFailure(final int exitCode, final String msg) { this(exitCode, msg, null); } /** * Create a new failure. * * @param exitCode * exit code to return the client, which indicates the * failure status of this command. Should be between 1 and * 255, inclusive. * @param msg * message to also send to the client's stderr. * @param why * stack trace to include in the server's log, but is not * sent to the client's stderr. */ public UnloggedFailure(final int exitCode, final String msg, final Throwable why) { super(exitCode, msg, why); } } }