src/main/java/com/gitblit/transport/ssh/commands/DispatchCommand.java - gitblit - Git at Google

 /*
  * 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.IOException;
 import java.io.StringWriter;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;

 import org.apache.sshd.server.Command;
 import org.apache.sshd.server.Environment;
 import org.kohsuke.args4j.Argument;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import ro.fortsoft.pf4j.ExtensionPoint;

 import com.gitblit.models.UserModel;
 import com.gitblit.utils.StringUtils;
 import com.gitblit.utils.cli.SubcommandHandler;
 import com.google.common.base.Charsets;
 import com.google.common.base.Joiner;
 import com.google.common.base.Strings;
 import com.google.common.collect.Maps;

 /**
  * Parses an SSH command-line and dispatches the command to the appropriate
  * BaseCommand instance.
  *
  * @since 1.5.0
  */
 public abstract class DispatchCommand extends BaseCommand implements ExtensionPoint {

 	private Logger log = LoggerFactory.getLogger(getClass());

 	@Argument(index = 0, required = false, metaVar = "COMMAND", handler = SubcommandHandler.class)
 	private String commandName;

 	@Argument(index = 1, multiValued = true, metaVar = "ARG")
 	private List<String> args = new ArrayList<String>();

 	private final Set<Class<? extends BaseCommand>> commands;
 	private final Map<String, DispatchCommand> dispatchers;
 	private final Map<String, String> aliasToCommand;
 	private final Map<String, List<String>> commandToAliases;
 	private final List<BaseCommand> instantiated;
 	private Map<String, Class<? extends BaseCommand>> map;

 	protected DispatchCommand() {
 		commands = new HashSet<Class<? extends BaseCommand>>();
 		dispatchers = Maps.newHashMap();
 		aliasToCommand = Maps.newHashMap();
 		commandToAliases = Maps.newHashMap();
 		instantiated = new ArrayList<BaseCommand>();
 	}

 	@Override
 	public void destroy() {
 		super.destroy();
 		commands.clear();
 		aliasToCommand.clear();
 		commandToAliases.clear();
 		map = null;

 		for (BaseCommand command : instantiated) {
 			command.destroy();
 		}
 		instantiated.clear();

 		for (DispatchCommand dispatcher : dispatchers.values()) {
 			dispatcher.destroy();
 		}
 		dispatchers.clear();
 	}

 	/**
 	 * Setup this dispatcher. Commands and nested dispatchers are normally
 	 * registered within this method.
 	 *
 	 * @since 1.5.0
 	 */
 	protected abstract void setup();

 	/**
 	 * Register a command or a dispatcher by it's class.
 	 *
 	 * @param clazz
 	 */
 	@SuppressWarnings("unchecked")
 	protected final void register(Class<? extends BaseCommand> clazz) {
 		if (DispatchCommand.class.isAssignableFrom(clazz)) {
 			registerDispatcher((Class<? extends DispatchCommand>) clazz);
 			return;
 		}

 		registerCommand(clazz);
 	}

 	/**
 	 * Register a command or a dispatcher instance.
 	 *
 	 * @param cmd
 	 */
 	protected final void register(BaseCommand cmd) {
 		if (cmd instanceof DispatchCommand) {
 			registerDispatcher((DispatchCommand) cmd);
 			return;
 		}
 		registerCommand(cmd);
 	}

 	private void registerDispatcher(Class<? extends DispatchCommand> clazz) {
 		try {
 			DispatchCommand dispatcher = clazz.newInstance();
 			registerDispatcher(dispatcher);
 		} catch (Exception e) {
 			log.error("failed to instantiate {}", clazz.getName());
 		}
 	}

 	private void registerDispatcher(DispatchCommand dispatcher) {
 		Class<? extends DispatchCommand> dispatcherClass = dispatcher.getClass();
 		if (!dispatcherClass.isAnnotationPresent(CommandMetaData.class)) {
 			throw new RuntimeException(MessageFormat.format("{0} must be annotated with {1}!", dispatcher.getName(),
 					CommandMetaData.class.getName()));
 		}

 		UserModel user = getContext().getClient().getUser();
 		CommandMetaData meta = dispatcherClass.getAnnotation(CommandMetaData.class);
 		if (meta.admin() && !user.canAdmin()) {
 			log.debug(MessageFormat.format("excluding admin dispatcher {0} for {1}",
 					meta.name(), user.username));
 			return;
 		}

 		try {
 			dispatcher.setContext(getContext());
 			dispatcher.setWorkQueue(getWorkQueue());
 			dispatcher.setup();
 			if (dispatcher.commands.isEmpty() && dispatcher.dispatchers.isEmpty()) {
 				log.debug(MessageFormat.format("excluding empty dispatcher {0} for {1}",
 						meta.name(), user.username));
 				return;
 			}

 			log.debug("registering {} dispatcher", meta.name());
 			dispatchers.put(meta.name(), dispatcher);
 			for (String alias : meta.aliases()) {
 				aliasToCommand.put(alias, meta.name());
 				if (!commandToAliases.containsKey(meta.name())) {
 					commandToAliases.put(meta.name(), new ArrayList<String>());
 				}
 				commandToAliases.get(meta.name()).add(alias);
 			}
 		} catch (Exception e) {
 			log.error("failed to register {} dispatcher", meta.name());
 		}
 	}

 	/**
 	 * Registers a command as long as the user is permitted to execute it.
 	 *
 	 * @param clazz
 	 */
 	private void registerCommand(Class<? extends BaseCommand> clazz) {
 		if (!clazz.isAnnotationPresent(CommandMetaData.class)) {
 			throw new RuntimeException(MessageFormat.format("{0} must be annotated with {1}!", clazz.getName(),
 					CommandMetaData.class.getName()));
 		}

 		UserModel user = getContext().getClient().getUser();
 		CommandMetaData meta = clazz.getAnnotation(CommandMetaData.class);
 		if (meta.admin() && !user.canAdmin()) {
 			log.debug(MessageFormat.format("excluding admin command {0} for {1}", meta.name(), user.username));
 			return;
 		}
 		commands.add(clazz);
 	}

 	/**
 	 * Registers a command as long as the user is permitted to execute it.
 	 *
 	 * @param cmd
 	 */
 	private void registerCommand(BaseCommand cmd) {
 		if (!cmd.getClass().isAnnotationPresent(CommandMetaData.class)) {
 			throw new RuntimeException(MessageFormat.format("{0} must be annotated with {1}!", cmd.getName(),
 					CommandMetaData.class.getName()));
 		}

 		UserModel user = getContext().getClient().getUser();
 		CommandMetaData meta = cmd.getClass().getAnnotation(CommandMetaData.class);
 		if (meta.admin() && !user.canAdmin()) {
 			log.debug(MessageFormat.format("excluding admin command {0} for {1}", meta.name(), user.username));
 			return;
 		}
 		commands.add(cmd.getClass());
 		instantiated.add(cmd);
 	}

 	private Map<String, Class<? extends BaseCommand>> getMap() {
 		if (map == null) {
 			map = Maps.newHashMapWithExpectedSize(commands.size());
 			for (Class<? extends BaseCommand> cmd : commands) {
 				CommandMetaData meta = cmd.getAnnotation(CommandMetaData.class);
 				if (map.containsKey(meta.name()) || aliasToCommand.containsKey(meta.name())) {
 					log.warn("{} already contains the \"{}\" command!", getName(), meta.name());
 				} else {
 					map.put(meta.name(), cmd);
 				}
 				for (String alias : meta.aliases()) {
 					if (map.containsKey(alias) || aliasToCommand.containsKey(alias)) {
 						log.warn("{} already contains the \"{}\" command!", getName(), alias);
 					} else {
 						aliasToCommand.put(alias, meta.name());
 						if (!commandToAliases.containsKey(meta.name())) {
 							commandToAliases.put(meta.name(), new ArrayList<String>());
 						}
 						commandToAliases.get(meta.name()).add(alias);
 					}
 				}
 			}

 			for (Map.Entry<String, DispatchCommand> entry : dispatchers.entrySet()) {
 				map.put(entry.getKey(), entry.getValue().getClass());
 			}
 		}
 		return map;
 	}

 	@Override
 	public void start(Environment env) throws IOException {
 		try {
 			parseCommandLine();
 			if (Strings.isNullOrEmpty(commandName)) {
 				StringWriter msg = new StringWriter();
 				msg.write(usage());
 				throw new UnloggedFailure(1, msg.toString());
 			}

 			BaseCommand cmd = getCommand();
 			if (getName().isEmpty()) {
 				cmd.setName(commandName);
 			} else {
 				cmd.setName(getName() + " " + commandName);
 			}
 			cmd.setArguments(args.toArray(new String[args.size()]));

 			provideStateTo(cmd);
 			// atomicCmd.set(cmd);
 			cmd.start(env);

 		} catch (UnloggedFailure e) {
 			String msg = e.getMessage();
 			if (!msg.endsWith("\n")) {
 				msg += "\n";
 			}
 			err.write(msg.getBytes(Charsets.UTF_8));
 			err.flush();
 			exit.onExit(e.exitCode);
 		}
 	}

 	private BaseCommand getCommand() throws UnloggedFailure {
 		Map<String, Class<? extends BaseCommand>> map = getMap();
 		String name = commandName;
 		if (aliasToCommand.containsKey(commandName)) {
 			name = aliasToCommand.get(name);
 		}
 		if (dispatchers.containsKey(name)) {
 			return dispatchers.get(name);
 		}
 		final Class<? extends BaseCommand> c = map.get(name);
 		if (c == null) {
 			String msg = (getName().isEmpty() ? "Gitblit" : getName()) + ": " + commandName + ": not found";
 			throw new UnloggedFailure(1, msg);
 		}

 		for (BaseCommand cmd : instantiated) {
 			// use an already instantiated command
 			if (cmd.getClass().equals(c)) {
 				return cmd;
 			}
 		}

 		BaseCommand cmd = null;
 		try {
 			cmd = c.newInstance();
 			instantiated.add(cmd);
 		} catch (Exception e) {
 			throw new UnloggedFailure(1, MessageFormat.format("Failed to instantiate {0} command", commandName));
 		}
 		return cmd;
 	}

 	private boolean hasVisibleCommands() {
 		boolean visible = false;
 		for (Class<? extends BaseCommand> cmd : commands) {
 			visible  |= !cmd.getAnnotation(CommandMetaData.class).hidden();
 			if (visible) {
 				return true;
 			}
 		}
 		for (DispatchCommand cmd : dispatchers.values()) {
 			visible |= cmd.hasVisibleCommands();
 			if (visible) {
 				return true;
 			}
 		}
 		return false;
 	}

 	public String getDescription() {
 		return getClass().getAnnotation(CommandMetaData.class).description();
 	}

 	@Override
 	public String usage() {
 		Set<String> cmds = new TreeSet<String>();
 		Set<String> dcs = new TreeSet<String>();
 		Map<String, String> displayNames = Maps.newHashMap();
 		int maxLength = -1;
 		Map<String, Class<? extends BaseCommand>> m = getMap();
 		for (String name : m.keySet()) {
 			Class<? extends BaseCommand> c = m.get(name);
 			CommandMetaData meta = c.getAnnotation(CommandMetaData.class);
 			if (meta.hidden()) {
 				continue;
 			}

 			String displayName = name  + (meta.admin() ? "*" : "");
 			if (commandToAliases.containsKey(meta.name())) {
 				displayName = name  + (meta.admin() ? "*" : "")+ " (" + Joiner.on(',').join(commandToAliases.get(meta.name())) + ")";
 			}
 			displayNames.put(name, displayName);

 			maxLength = Math.max(maxLength, displayName.length());
 			if (DispatchCommand.class.isAssignableFrom(c)) {
 				DispatchCommand d = dispatchers.get(name);
 				if (d.hasVisibleCommands()) {
 					dcs.add(name);
 				}
 			} else {
 				cmds.add(name);
 			}
 		}
 		String format = "%-" + maxLength + "s   %s";

 		final StringBuilder usage = new StringBuilder();
 		if (!StringUtils.isEmpty(getName())) {
 			String title = getName().toUpperCase() + ": " + getDescription();
 			String b = com.gitblit.utils.StringUtils.leftPad("", title.length() + 2, '═');
 			usage.append('\n');
 			usage.append(b).append('\n');
 			usage.append(' ').append(title).append('\n');
 			usage.append(b).append('\n');
 			usage.append('\n');
 		}

 		if (!cmds.isEmpty()) {
 			usage.append("Available commands");
 			if (!getName().isEmpty()) {
 				usage.append(" of ");
 				usage.append(getName());
 			}
 			usage.append(" are:\n");
 			usage.append("\n");
 			for (String name : cmds) {
 				final Class<? extends Command> c = m.get(name);
 				String displayName = displayNames.get(name);
 				CommandMetaData meta = c.getAnnotation(CommandMetaData.class);
 				usage.append("   ");
 				usage.append(String.format(format, displayName, Strings.nullToEmpty(meta.description())));
 				usage.append("\n");
 			}
 			usage.append("\n");
 		}

 		if (!dcs.isEmpty()) {
 			usage.append("Available command dispatchers");
 			if (!getName().isEmpty()) {
 				usage.append(" of ");
 				usage.append(getName());
 			}
 			usage.append(" are:\n");
 			usage.append("\n");
 			for (String name : dcs) {
 				final Class<? extends BaseCommand> c = m.get(name);
 				String displayName = displayNames.get(name);
 				CommandMetaData meta = c.getAnnotation(CommandMetaData.class);
 				usage.append("   ");
 				usage.append(String.format(format, displayName, Strings.nullToEmpty(meta.description())));
 				usage.append("\n");
 			}
 			usage.append("\n");
 		}

 		usage.append("See '");
 		if (!StringUtils.isEmpty(getName())) {
 			usage.append(getName());
 			usage.append(' ');
 		}
 		usage.append("COMMAND --help' for more information.\n");
 		usage.append("\n");
 		return usage.toString();
 	}
 }
	/*
	* 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.IOException;
	import java.io.StringWriter;
	import java.text.MessageFormat;
	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeSet;

	import org.apache.sshd.server.Command;
	import org.apache.sshd.server.Environment;
	import org.kohsuke.args4j.Argument;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import ro.fortsoft.pf4j.ExtensionPoint;

	import com.gitblit.models.UserModel;
	import com.gitblit.utils.StringUtils;
	import com.gitblit.utils.cli.SubcommandHandler;
	import com.google.common.base.Charsets;
	import com.google.common.base.Joiner;
	import com.google.common.base.Strings;
	import com.google.common.collect.Maps;

	/**
	* Parses an SSH command-line and dispatches the command to the appropriate
	* BaseCommand instance.
	*
	* @since 1.5.0
	*/
	public abstract class DispatchCommand extends BaseCommand implements ExtensionPoint {

	private Logger log = LoggerFactory.getLogger(getClass());

	@Argument(index = 0, required = false, metaVar = "COMMAND", handler = SubcommandHandler.class)
	private String commandName;

	@Argument(index = 1, multiValued = true, metaVar = "ARG")
	private List<String> args = new ArrayList<String>();

	private final Set<Class<? extends BaseCommand>> commands;
	private final Map<String, DispatchCommand> dispatchers;
	private final Map<String, String> aliasToCommand;
	private final Map<String, List<String>> commandToAliases;
	private final List<BaseCommand> instantiated;
	private Map<String, Class<? extends BaseCommand>> map;

	protected DispatchCommand() {
	commands = new HashSet<Class<? extends BaseCommand>>();
	dispatchers = Maps.newHashMap();
	aliasToCommand = Maps.newHashMap();
	commandToAliases = Maps.newHashMap();
	instantiated = new ArrayList<BaseCommand>();
	}

	@Override
	public void destroy() {
	super.destroy();
	commands.clear();
	aliasToCommand.clear();
	commandToAliases.clear();
	map = null;

	for (BaseCommand command : instantiated) {
	command.destroy();
	}
	instantiated.clear();

	for (DispatchCommand dispatcher : dispatchers.values()) {
	dispatcher.destroy();
	}
	dispatchers.clear();
	}

	/**
	* Setup this dispatcher. Commands and nested dispatchers are normally
	* registered within this method.
	*
	* @since 1.5.0
	*/
	protected abstract void setup();

	/**
	* Register a command or a dispatcher by it's class.
	*
	* @param clazz
	*/
	@SuppressWarnings("unchecked")
	protected final void register(Class<? extends BaseCommand> clazz) {
	if (DispatchCommand.class.isAssignableFrom(clazz)) {
	registerDispatcher((Class<? extends DispatchCommand>) clazz);
	return;
	}

	registerCommand(clazz);
	}

	/**
	* Register a command or a dispatcher instance.
	*
	* @param cmd
	*/
	protected final void register(BaseCommand cmd) {
	if (cmd instanceof DispatchCommand) {
	registerDispatcher((DispatchCommand) cmd);
	return;
	}
	registerCommand(cmd);
	}

	private void registerDispatcher(Class<? extends DispatchCommand> clazz) {
	try {
	DispatchCommand dispatcher = clazz.newInstance();
	registerDispatcher(dispatcher);
	} catch (Exception e) {
	log.error("failed to instantiate {}", clazz.getName());
	}
	}

	private void registerDispatcher(DispatchCommand dispatcher) {
	Class<? extends DispatchCommand> dispatcherClass = dispatcher.getClass();
	if (!dispatcherClass.isAnnotationPresent(CommandMetaData.class)) {
	throw new RuntimeException(MessageFormat.format("{0} must be annotated with {1}!", dispatcher.getName(),
	CommandMetaData.class.getName()));
	}

	UserModel user = getContext().getClient().getUser();
	CommandMetaData meta = dispatcherClass.getAnnotation(CommandMetaData.class);
	if (meta.admin() && !user.canAdmin()) {
	log.debug(MessageFormat.format("excluding admin dispatcher {0} for {1}",
	meta.name(), user.username));
	return;
	}

	try {
	dispatcher.setContext(getContext());
	dispatcher.setWorkQueue(getWorkQueue());
	dispatcher.setup();
	if (dispatcher.commands.isEmpty() && dispatcher.dispatchers.isEmpty()) {
	log.debug(MessageFormat.format("excluding empty dispatcher {0} for {1}",
	meta.name(), user.username));
	return;
	}

	log.debug("registering {} dispatcher", meta.name());
	dispatchers.put(meta.name(), dispatcher);
	for (String alias : meta.aliases()) {
	aliasToCommand.put(alias, meta.name());
	if (!commandToAliases.containsKey(meta.name())) {
	commandToAliases.put(meta.name(), new ArrayList<String>());
	}
	commandToAliases.get(meta.name()).add(alias);
	}
	} catch (Exception e) {
	log.error("failed to register {} dispatcher", meta.name());
	}
	}

	/**
	* Registers a command as long as the user is permitted to execute it.
	*
	* @param clazz
	*/
	private void registerCommand(Class<? extends BaseCommand> clazz) {
	if (!clazz.isAnnotationPresent(CommandMetaData.class)) {
	throw new RuntimeException(MessageFormat.format("{0} must be annotated with {1}!", clazz.getName(),
	CommandMetaData.class.getName()));
	}

	UserModel user = getContext().getClient().getUser();
	CommandMetaData meta = clazz.getAnnotation(CommandMetaData.class);
	if (meta.admin() && !user.canAdmin()) {
	log.debug(MessageFormat.format("excluding admin command {0} for {1}", meta.name(), user.username));
	return;
	}
	commands.add(clazz);
	}

	/**
	* Registers a command as long as the user is permitted to execute it.
	*
	* @param cmd
	*/
	private void registerCommand(BaseCommand cmd) {
	if (!cmd.getClass().isAnnotationPresent(CommandMetaData.class)) {
	throw new RuntimeException(MessageFormat.format("{0} must be annotated with {1}!", cmd.getName(),
	CommandMetaData.class.getName()));
	}

	UserModel user = getContext().getClient().getUser();
	CommandMetaData meta = cmd.getClass().getAnnotation(CommandMetaData.class);
	if (meta.admin() && !user.canAdmin()) {
	log.debug(MessageFormat.format("excluding admin command {0} for {1}", meta.name(), user.username));
	return;
	}
	commands.add(cmd.getClass());
	instantiated.add(cmd);
	}

	private Map<String, Class<? extends BaseCommand>> getMap() {
	if (map == null) {
	map = Maps.newHashMapWithExpectedSize(commands.size());
	for (Class<? extends BaseCommand> cmd : commands) {
	CommandMetaData meta = cmd.getAnnotation(CommandMetaData.class);
	if (map.containsKey(meta.name()) \|\| aliasToCommand.containsKey(meta.name())) {
	log.warn("{} already contains the \"{}\" command!", getName(), meta.name());
	} else {
	map.put(meta.name(), cmd);
	}
	for (String alias : meta.aliases()) {
	if (map.containsKey(alias) \|\| aliasToCommand.containsKey(alias)) {
	log.warn("{} already contains the \"{}\" command!", getName(), alias);
	} else {
	aliasToCommand.put(alias, meta.name());
	if (!commandToAliases.containsKey(meta.name())) {
	commandToAliases.put(meta.name(), new ArrayList<String>());
	}
	commandToAliases.get(meta.name()).add(alias);
	}
	}
	}

	for (Map.Entry<String, DispatchCommand> entry : dispatchers.entrySet()) {
	map.put(entry.getKey(), entry.getValue().getClass());
	}
	}
	return map;
	}

	@Override
	public void start(Environment env) throws IOException {
	try {
	parseCommandLine();
	if (Strings.isNullOrEmpty(commandName)) {
	StringWriter msg = new StringWriter();
	msg.write(usage());
	throw new UnloggedFailure(1, msg.toString());
	}

	BaseCommand cmd = getCommand();
	if (getName().isEmpty()) {
	cmd.setName(commandName);
	} else {
	cmd.setName(getName() + " " + commandName);
	}
	cmd.setArguments(args.toArray(new String[args.size()]));

	provideStateTo(cmd);
	// atomicCmd.set(cmd);
	cmd.start(env);

	} catch (UnloggedFailure e) {
	String msg = e.getMessage();
	if (!msg.endsWith("\n")) {
	msg += "\n";
	}
	err.write(msg.getBytes(Charsets.UTF_8));
	err.flush();
	exit.onExit(e.exitCode);
	}
	}

	private BaseCommand getCommand() throws UnloggedFailure {
	Map<String, Class<? extends BaseCommand>> map = getMap();
	String name = commandName;
	if (aliasToCommand.containsKey(commandName)) {
	name = aliasToCommand.get(name);
	}
	if (dispatchers.containsKey(name)) {
	return dispatchers.get(name);
	}
	final Class<? extends BaseCommand> c = map.get(name);
	if (c == null) {
	String msg = (getName().isEmpty() ? "Gitblit" : getName()) + ": " + commandName + ": not found";
	throw new UnloggedFailure(1, msg);
	}

	for (BaseCommand cmd : instantiated) {
	// use an already instantiated command
	if (cmd.getClass().equals(c)) {
	return cmd;
	}
	}

	BaseCommand cmd = null;
	try {
	cmd = c.newInstance();
	instantiated.add(cmd);
	} catch (Exception e) {
	throw new UnloggedFailure(1, MessageFormat.format("Failed to instantiate {0} command", commandName));
	}
	return cmd;
	}

	private boolean hasVisibleCommands() {
	boolean visible = false;
	for (Class<? extends BaseCommand> cmd : commands) {
	visible \|= !cmd.getAnnotation(CommandMetaData.class).hidden();
	if (visible) {
	return true;
	}
	}
	for (DispatchCommand cmd : dispatchers.values()) {
	visible \|= cmd.hasVisibleCommands();
	if (visible) {
	return true;
	}
	}
	return false;
	}

	public String getDescription() {
	return getClass().getAnnotation(CommandMetaData.class).description();
	}

	@Override
	public String usage() {
	Set<String> cmds = new TreeSet<String>();
	Set<String> dcs = new TreeSet<String>();
	Map<String, String> displayNames = Maps.newHashMap();
	int maxLength = -1;
	Map<String, Class<? extends BaseCommand>> m = getMap();
	for (String name : m.keySet()) {
	Class<? extends BaseCommand> c = m.get(name);
	CommandMetaData meta = c.getAnnotation(CommandMetaData.class);
	if (meta.hidden()) {
	continue;
	}

	String displayName = name + (meta.admin() ? "*" : "");
	if (commandToAliases.containsKey(meta.name())) {
	displayName = name + (meta.admin() ? "*" : "")+ " (" + Joiner.on(',').join(commandToAliases.get(meta.name())) + ")";
	}
	displayNames.put(name, displayName);

	maxLength = Math.max(maxLength, displayName.length());
	if (DispatchCommand.class.isAssignableFrom(c)) {
	DispatchCommand d = dispatchers.get(name);
	if (d.hasVisibleCommands()) {
	dcs.add(name);
	}
	} else {
	cmds.add(name);
	}
	}
	String format = "%-" + maxLength + "s %s";

	final StringBuilder usage = new StringBuilder();
	if (!StringUtils.isEmpty(getName())) {
	String title = getName().toUpperCase() + ": " + getDescription();
	String b = com.gitblit.utils.StringUtils.leftPad("", title.length() + 2, '═');
	usage.append('\n');
	usage.append(b).append('\n');
	usage.append(' ').append(title).append('\n');
	usage.append(b).append('\n');
	usage.append('\n');
	}

	if (!cmds.isEmpty()) {
	usage.append("Available commands");
	if (!getName().isEmpty()) {
	usage.append(" of ");
	usage.append(getName());
	}
	usage.append(" are:\n");
	usage.append("\n");
	for (String name : cmds) {
	final Class<? extends Command> c = m.get(name);
	String displayName = displayNames.get(name);
	CommandMetaData meta = c.getAnnotation(CommandMetaData.class);
	usage.append(" ");
	usage.append(String.format(format, displayName, Strings.nullToEmpty(meta.description())));
	usage.append("\n");
	}
	usage.append("\n");
	}

	if (!dcs.isEmpty()) {
	usage.append("Available command dispatchers");
	if (!getName().isEmpty()) {
	usage.append(" of ");
	usage.append(getName());
	}
	usage.append(" are:\n");
	usage.append("\n");
	for (String name : dcs) {
	final Class<? extends BaseCommand> c = m.get(name);
	String displayName = displayNames.get(name);
	CommandMetaData meta = c.getAnnotation(CommandMetaData.class);
	usage.append(" ");
	usage.append(String.format(format, displayName, Strings.nullToEmpty(meta.description())));
	usage.append("\n");
	}
	usage.append("\n");
	}

	usage.append("See '");
	if (!StringUtils.isEmpty(getName())) {
	usage.append(getName());
	usage.append(' ');
	}
	usage.append("COMMAND --help' for more information.\n");
	usage.append("\n");
	return usage.toString();
	}
	}