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/DispatchCommand.java | 539 +++++++++++++++++++++++++++++++++++++++++++----------------
1 files changed, 394 insertions(+), 145 deletions(-)
diff --git a/src/main/java/com/gitblit/transport/ssh/commands/DispatchCommand.java b/src/main/java/com/gitblit/transport/ssh/commands/DispatchCommand.java
index b6944ea..86b3369 100644
--- a/src/main/java/com/gitblit/transport/ssh/commands/DispatchCommand.java
+++ b/src/main/java/com/gitblit/transport/ssh/commands/DispatchCommand.java
@@ -1,17 +1,19 @@
-// 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.IOException;
@@ -22,155 +24,402 @@
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 com.gitblit.transport.ssh.CommandMetaData;
+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;
-import com.google.common.collect.Sets;
-public class DispatchCommand extends BaseCommand {
+/**
+ * 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 {
- @Argument(index = 0, required = false, metaVar = "COMMAND", handler = SubcommandHandler.class)
- private String commandName;
+ private Logger log = LoggerFactory.getLogger(getClass());
- @Argument(index = 1, multiValued = true, metaVar = "ARG")
- private List<String> args = new ArrayList<String>();
+ @Argument(index = 0, required = false, metaVar = "COMMAND", handler = SubcommandHandler.class)
+ private String commandName;
- private Set<Class<? extends Command>> commands;
- private Map<String, Class<? extends Command>> map;
- private Map<String, Command> root;
+ @Argument(index = 1, multiValued = true, metaVar = "ARG")
+ private List<String> args = new ArrayList<String>();
- public DispatchCommand() {
- commands = new HashSet<Class<? extends Command>>();
- }
+ 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;
- public void registerDispatcher(String name, Command cmd) {
- if (root == null) {
- root = Maps.newHashMap();
- }
- root.put(name, cmd);
- }
-
- public void registerCommand(Class<? extends Command> cmd) {
- if (!cmd.isAnnotationPresent(CommandMetaData.class)) {
- throw new RuntimeException(MessageFormat.format("{0} must be annotated with {1}!",
- cmd.getName(), CommandMetaData.class.getName()));
- }
- commands.add(cmd);
- }
-
- private Map<String, Class<? extends Command>> getMap() {
- if (map == null) {
- map = Maps.newHashMapWithExpectedSize(commands.size());
- for (Class<? extends Command> cmd : commands) {
- CommandMetaData meta = cmd.getAnnotation(CommandMetaData.class);
- map.put(meta.name(), cmd);
- }
- }
- 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());
- }
-
- Command cmd = getCommand();
- if (cmd instanceof BaseCommand) {
- BaseCommand bc = (BaseCommand) cmd;
- if (getName().isEmpty()) {
- bc.setName(commandName);
- } else {
- bc.setName(getName() + " " + commandName);
- }
- bc.setArguments(args.toArray(new String[args.size()]));
- } else if (!args.isEmpty()) {
- throw new UnloggedFailure(1, commandName + " does not take arguments");
- }
-
- 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 Command getCommand() throws UnloggedFailure {
- if (root != null && root.containsKey(commandName)) {
- return root.get(commandName);
+ protected DispatchCommand() {
+ commands = new HashSet<Class<? extends BaseCommand>>();
+ dispatchers = Maps.newHashMap();
+ aliasToCommand = Maps.newHashMap();
+ commandToAliases = Maps.newHashMap();
+ instantiated = new ArrayList<BaseCommand>();
}
- final Class<? extends Command> c = getMap().get(commandName);
- if (c == null) {
- String msg =
- (getName().isEmpty() ? "Gitblit" : getName()) + ": "
- + commandName + ": not found";
- throw new UnloggedFailure(1, msg);
- }
- Command cmd = null;
- try {
- cmd = c.newInstance();
- } catch (Exception e) {
- throw new UnloggedFailure(1, MessageFormat.format("Failed to instantiate {0} command", commandName));
- }
- return cmd;
- }
+ @Override
+ public void destroy() {
+ super.destroy();
+ commands.clear();
+ aliasToCommand.clear();
+ commandToAliases.clear();
+ map = null;
- @Override
-protected String usage() {
- final StringBuilder usage = new StringBuilder();
- usage.append("Available commands");
- if (!getName().isEmpty()) {
- usage.append(" of ");
- usage.append(getName());
- }
- usage.append(" are:\n");
- usage.append("\n");
+ for (BaseCommand command : instantiated) {
+ command.destroy();
+ }
+ instantiated.clear();
- int maxLength = -1;
- Map<String, Class<? extends Command>> m = getMap();
- for (String name : m.keySet()) {
- maxLength = Math.max(maxLength, name.length());
- }
- String format = "%-" + maxLength + "s %s";
- for (String name : Sets.newTreeSet(m.keySet())) {
- final Class<? extends Command> c = m.get(name);
- usage.append(" ");
- CommandMetaData meta = c.getAnnotation(CommandMetaData.class);
- if (meta != null) {
- usage.append(String.format(format, name,
- Strings.nullToEmpty(meta.description())));
- }
- usage.append("\n");
- }
- usage.append("\n");
+ for (DispatchCommand dispatcher : dispatchers.values()) {
+ dispatcher.destroy();
+ }
+ dispatchers.clear();
+ }
- usage.append("See '");
- if (getName().indexOf(' ') < 0) {
- usage.append(getName());
- usage.append(' ');
- }
- usage.append("COMMAND --help' for more information.\n");
- usage.append("\n");
- return usage.toString();
- }
+ /**
+ * 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.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();
+ }
}
--
Gitblit v1.9.1