From f76fee63ed9cb3a30d3c0c092d860b1cb93a481b Mon Sep 17 00:00:00 2001
From: Gerard Smyth <gerard.smyth@gmail.com>
Date: Thu, 08 May 2014 13:09:30 -0400
Subject: [PATCH] Updated the SyndicationServlet to provide an additional option to return details of the tags in the repository instead of the commits. This uses a new 'ot' request parameter to indicate the object type of the content to return, which can be ither TAG or COMMIT. If this is not provided, then COMMIT is assumed to maintain backwards compatability. If tags are returned, then the paging parameters, 'l' and 'pg' are still supported, but searching options are currently ignored.
---
src/main/java/com/gitblit/transport/ssh/commands/BaseCommand.java | 851 ++++++++++++++++++++++++++++++++------------------------
1 files changed, 485 insertions(+), 366 deletions(-)
diff --git a/src/main/java/com/gitblit/transport/ssh/commands/BaseCommand.java b/src/main/java/com/gitblit/transport/ssh/commands/BaseCommand.java
index a04c505..d996ea9 100644
--- a/src/main/java/com/gitblit/transport/ssh/commands/BaseCommand.java
+++ b/src/main/java/com/gitblit/transport/ssh/commands/BaseCommand.java
@@ -1,23 +1,28 @@
-// Copyright (C) 2009 The Android Open Source Project
-//
-// 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.
-
+/*
+ * 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;
@@ -26,413 +31,527 @@
import org.apache.sshd.server.Command;
import org.apache.sshd.server.Environment;
import org.apache.sshd.server.ExitCallback;
-import org.kohsuke.args4j.Argument;
+import org.apache.sshd.server.SessionAware;
+import org.apache.sshd.server.session.ServerSession;
import org.kohsuke.args4j.CmdLineException;
-import org.kohsuke.args4j.Option;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.gitblit.transport.ssh.AbstractSshCommand;
-import com.gitblit.transport.ssh.SshContext;
+import com.gitblit.Keys;
import com.gitblit.utils.IdGenerator;
+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 extends AbstractSshCommand {
- private static final Logger log = LoggerFactory
- .getLogger(BaseCommand.class);
+public abstract class BaseCommand implements Command, SessionAware {
- /** Text of the command line which lead up to invoking this instance. */
- private String commandName = "";
+ private static final Logger log = LoggerFactory.getLogger(BaseCommand.class);
- /** Unparsed command line options. */
- private String[] argv;
+ private static final int PRIVATE_STATUS = 1 << 30;
- /** Ssh context */
- protected SshContext ctx;
+ public final static int STATUS_CANCEL = PRIVATE_STATUS | 1;
- /** The task, as scheduled on a worker thread. */
- private final AtomicReference<Future<?>> task;
+ public final static int STATUS_NOT_FOUND = PRIVATE_STATUS | 2;
- private final WorkQueue.Executor executor;
+ public final static int STATUS_NOT_ADMIN = PRIVATE_STATUS | 3;
- public BaseCommand() {
- task = Atomics.newReference();
- IdGenerator gen = new IdGenerator();
- WorkQueue w = new WorkQueue(gen);
- this.executor = w.getDefaultQueue();
- }
+ protected InputStream in;
- public void setContext(SshContext ctx) {
- this.ctx = ctx;
- }
+ protected OutputStream out;
- public void setInputStream(final InputStream in) {
- this.in = in;
- }
+ protected OutputStream err;
- public void setOutputStream(final OutputStream out) {
- this.out = out;
- }
+ protected ExitCallback exit;
- public void setErrorStream(final OutputStream err) {
- this.err = err;
- }
+ protected ServerSession session;
- public void setExitCallback(final ExitCallback callback) {
- this.exit = callback;
- }
+ /** Ssh command context */
+ private SshCommandContext ctx;
- protected void provideBaseStateTo(final Command cmd) {
- if (cmd instanceof BaseCommand) {
- ((BaseCommand)cmd).setContext(ctx);
- }
- cmd.setInputStream(in);
- cmd.setOutputStream(out);
- cmd.setErrorStream(err);
- cmd.setExitCallback(exit);
- }
+ /** Text of the command line which lead up to invoking this instance. */
+ private String commandName = "";
- protected String getName() {
- return commandName;
- }
+ /** Unparsed command line options. */
+ private String[] argv;
- void setName(final String prefix) {
- this.commandName = prefix;
- }
+ /** The task, as scheduled on a worker thread. */
+ private final AtomicReference<Future<?>> task;
- public String[] getArguments() {
- return argv;
- }
+ private final WorkQueue.Executor executor;
- public void setArguments(final String[] argv) {
- this.argv = argv;
- }
+ public BaseCommand() {
+ task = Atomics.newReference();
+ IdGenerator gen = new IdGenerator();
+ WorkQueue w = new WorkQueue(gen);
+ this.executor = w.getDefaultQueue();
+ }
- /**
- * 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);
- }
+ @Override
+ public void setSession(final ServerSession session) {
+ this.session = session;
+ }
- /**
- * 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());
- }
- }
+ @Override
+ public void destroy() {
+ log.debug("destroying " + getClass().getName());
+ session = null;
+ ctx = null;
+ }
- if (clp.wasHelpRequestedByOption()) {
- StringWriter msg = new StringWriter();
- clp.printDetailedUsage(commandName, msg);
- msg.write(usage());
- throw new UnloggedFailure(1, msg.toString());
- }
- }
+ protected static PrintWriter toPrintWriter(final OutputStream o) {
+ return new PrintWriter(new BufferedWriter(new OutputStreamWriter(o, Charsets.UTF_8)));
+ }
- /** Construct a new parser for this command's received command line. */
- protected CmdLineParser newCmdLineParser(Object options) {
- return new CmdLineParser(options);
- }
+ @Override
+ public abstract void start(Environment env) throws IOException;
- protected String usage() {
- return "";
- }
+ protected void provideStateTo(final BaseCommand cmd) {
+ cmd.setContext(ctx);
+ cmd.setInputStream(in);
+ cmd.setOutputStream(out);
+ cmd.setErrorStream(err);
+ cmd.setExitCallback(exit);
+ }
- private final class TaskThunk implements CancelableRunnable {
- private final CommandRunnable thunk;
- private final String taskName;
+ public void setContext(SshCommandContext ctx) {
+ this.ctx = ctx;
+ }
- private TaskThunk(final CommandRunnable thunk) {
- this.thunk = thunk;
+ public SshCommandContext getContext() {
+ return ctx;
+ }
- StringBuilder m = new StringBuilder();
- m.append(ctx.getCommandLine());
- this.taskName = m.toString();
- }
+ @Override
+ public void setInputStream(final InputStream in) {
+ this.in = in;
+ }
- @Override
- public void cancel() {
- synchronized (this) {
- try {
- //onExit(/*STATUS_CANCEL*/);
- } finally {
- ctx = null;
- }
- }
- }
+ @Override
+ public void setOutputStream(final OutputStream out) {
+ this.out = out;
+ }
- @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();
+ @Override
+ public void setErrorStream(final OutputStream err) {
+ this.err = err;
+ }
- 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 void setExitCallback(final ExitCallback callback) {
+ this.exit = callback;
+ }
- @Override
- public String toString() {
- return taskName;
- }
- }
+ protected String getName() {
+ return commandName;
+ }
- /** Runnable function which can throw an exception. */
- public static interface CommandRunnable {
- public void run() throws Exception;
- }
+ void setName(final String prefix) {
+ this.commandName = prefix;
+ }
+ public String[] getArguments() {
+ return argv;
+ }
- /** Runnable function which can retrieve a project name related to the task */
- public static interface RepositoryCommandRunnable extends CommandRunnable {
- public String getRepository();
- }
+ public void setArguments(final String[] argv) {
+ this.argv = argv;
+ }
- /**
- * 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();
- }
- });
- }
+ /**
+ * 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);
+ }
- /**
- * Terminate this command and return a result code to the remote client.
- * <p>
- * Commands should invoke this at most once. Once invoked, the command may
- * lose access to request based resources as any callbacks previously
- * registered with {@link RequestCleanup} will fire.
- *
- * @param rc exit code for the remote client.
- */
- protected void onExit(final int rc) {
- exit.onExit(rc);
-// if (cleanup != null) {
-// cleanup.run();
-// }
- }
+ /**
+ * 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());
+ }
+ }
- 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 (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');
+ }
- if (e instanceof UnloggedFailure) {
- } else {
- final StringBuilder m = new StringBuilder();
- m.append("Internal server error");
-// if (userProvider.get().isIdentifiedUser()) {
-// final IdentifiedUser u = (IdentifiedUser) userProvider.get();
-// m.append(" (user ");
-// m.append(u.getAccount().getUserName());
-// m.append(" account ");
-// m.append(u.getAccountId());
-// m.append(")");
-// }
-// m.append(" during ");
-// m.append(contextProvider.get().getCommandLine());
- log.error(m.toString(), e);
- }
+ throw new UnloggedFailure(1, msg.toString());
+ }
+ }
- 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;
+ /** Construct a new parser for this command's received command line. */
+ protected CmdLineParser newCmdLineParser(Object options) {
+ return new CmdLineParser(options);
+ }
- } 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;
- }
- }
+ 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 "";
+ }
- /**
- * 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(executor.submit(tt));
- }
+ protected String getUsageText() {
+ return "";
+ }
- /** Thrown from {@link CommandRunnable#run()} with client message and code. */
- public static class Failure extends Exception {
- private static final long serialVersionUID = 1L;
+ 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);
- final int exitCode;
+ 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();
+ }
- /**
- * 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);
- }
+ protected void showHelp() throws UnloggedFailure {
+ argv = new String [] { "--help" };
+ parseCommandLine();
+ }
- /**
- * 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;
- }
- }
+ private final class TaskThunk implements CancelableRunnable {
+ private final CommandRunnable thunk;
+ private final String taskName;
- /** Thrown from {@link CommandRunnable#run()} with client message and code. */
- public static class UnloggedFailure extends Failure {
- private static final long serialVersionUID = 1L;
+ private TaskThunk(final CommandRunnable thunk) {
+ this.thunk = thunk;
- /**
- * Create a new failure.
- *
- * @param msg message to also send to the client's stderr.
- */
- public UnloggedFailure(final String msg) {
- this(1, msg);
- }
+ StringBuilder m = new StringBuilder();
+ m.append(ctx.getCommandLine());
+ this.taskName = m.toString();
+ }
- /**
- * 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);
- }
+ @Override
+ public void cancel() {
+ synchronized (this) {
+ try {
+ onExit(STATUS_CANCEL);
+ } finally {
+ ctx = 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);
- }
- }
+ @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(executor.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);
+ }
+ }
}
--
Gitblit v1.9.1