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

 /*
  * 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.util.Collections;
 import java.util.List;

 import org.kohsuke.args4j.Argument;
 import org.kohsuke.args4j.Option;

 import ro.fortsoft.pf4j.ExtensionPoint;
 import ro.fortsoft.pf4j.PluginDependency;
 import ro.fortsoft.pf4j.PluginDescriptor;
 import ro.fortsoft.pf4j.PluginState;
 import ro.fortsoft.pf4j.PluginWrapper;
 import ro.fortsoft.pf4j.Version;

 import com.gitblit.manager.IGitblit;
 import com.gitblit.models.PluginRegistry.InstallState;
 import com.gitblit.models.PluginRegistry.PluginRegistration;
 import com.gitblit.models.PluginRegistry.PluginRelease;
 import com.gitblit.utils.FlipTable;
 import com.gitblit.utils.FlipTable.Borders;
 import com.gitblit.utils.StringUtils;
 import com.google.common.base.Joiner;

 /**
  * The plugin dispatcher and commands for runtime plugin management.
  *
  * @author James Moger
  *
  */
 @CommandMetaData(name = "plugin", description = "Plugin management commands", admin = true)
 public class PluginDispatcher extends DispatchCommand {

 	@Override
 	protected void setup() {
 		register(ListPlugins.class);
 		register(StartPlugin.class);
 		register(StopPlugin.class);
 		register(EnablePlugin.class);
 		register(DisablePlugin.class);
 		register(ShowPlugin.class);
 		register(RefreshPlugins.class);
 		register(AvailablePlugins.class);
 		register(InstallPlugin.class);
 		register(UpgradePlugin.class);
 		register(UninstallPlugin.class);
 	}

 	@CommandMetaData(name = "list", aliases = { "ls" }, description = "List plugins")
 	public static class ListPlugins extends ListCommand<PluginWrapper> {

 		@Override
 		protected List<PluginWrapper> getItems() throws UnloggedFailure {
 			IGitblit gitblit = getContext().getGitblit();
 			List<PluginWrapper> list = gitblit.getPlugins();
 			return list;
 		}

 		@Override
 		protected void asTable(List<PluginWrapper> list) {
 			String[] headers;
 			if (verbose) {
 				String [] h = { "#", "Id", "Description", "Version", "Requires", "State", "Path" };
 				headers = h;
 			} else {
 				String [] h = { "#", "Id", "Version", "State", "Path"};
 				headers = h;
 			}
 			Object[][] data = new Object[list.size()][];
 			for (int i = 0; i < list.size(); i++) {
 				PluginWrapper p = list.get(i);
 				PluginDescriptor d = p.getDescriptor();
 				if (verbose) {
 					data[i] = new Object[] { "" + (i + 1), d.getPluginId(), d.getPluginDescription(), d.getVersion(), d.getRequires(), p.getPluginState(), p.getPluginPath() };
 				} else {
 					data[i] = new Object[] { "" + (i + 1), d.getPluginId(), d.getVersion(), p.getPluginState(), p.getPluginPath() };
 				}
 			}

 			stdout.println(FlipTable.of(headers, data, Borders.BODY_HCOLS));
 		}

 		@Override
 		protected void asTabbed(List<PluginWrapper> list) {
 			for (PluginWrapper pw : list) {
 				PluginDescriptor d = pw.getDescriptor();
 				if (verbose) {
 					outTabbed(d.getPluginId(), d.getPluginDescription(), d.getVersion(), d.getRequires(), pw.getPluginState(), pw.getPluginPath());
 				} else {
 					outTabbed(d.getPluginId(), d.getVersion(), pw.getPluginState(), pw.getPluginPath());
 				}
 			}
 		}
 	}

 	static abstract class PluginCommand extends SshCommand {

 		protected PluginWrapper getPlugin(String id) throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			PluginWrapper pluginWrapper = null;
 			try {
 				int index = Integer.parseInt(id);
 				List<PluginWrapper> plugins = gitblit.getPlugins();
 				if (index > plugins.size()) {
 					throw new UnloggedFailure(1, "Invalid plugin index specified!");
 				}
 				pluginWrapper = plugins.get(index - 1);
 			} catch (NumberFormatException e) {
 				pluginWrapper = gitblit.getPlugin(id);
 				if (pluginWrapper == null) {
 					PluginRegistration reg = gitblit.lookupPlugin(id);
 					if (reg == null) {
 						throw new UnloggedFailure("Invalid plugin specified!");
 					}
 					pluginWrapper = gitblit.getPlugin(reg.id);
 				}
 			}

 			return pluginWrapper;
 		}
 	}

 	@CommandMetaData(name = "start", description = "Start a plugin")
 	public static class StartPlugin extends PluginCommand {

 		@Argument(index = 0, required = true, metaVar = "ALL|<ID>|<INDEX>", usage = "the plugin to start")
 		protected String id;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			if (id.equalsIgnoreCase("ALL")) {
 				gitblit.startPlugins();
 				stdout.println("All plugins started");
 			} else {
 				PluginWrapper pluginWrapper = getPlugin(id);
 				if (pluginWrapper == null) {
 					throw new UnloggedFailure(String.format("Plugin %s is not installed!", id));
 				}

 				PluginState state = gitblit.startPlugin(pluginWrapper.getPluginId());
 				if (PluginState.STARTED.equals(state)) {
 					stdout.println(String.format("Started %s", pluginWrapper.getPluginId()));
 				} else {
 					throw new UnloggedFailure(1, String.format("Failed to start %s", pluginWrapper.getPluginId()));
 				}
 			}
 		}
 	}

 	@CommandMetaData(name = "stop", description = "Stop a plugin")
 	public static class StopPlugin extends PluginCommand {

 		@Argument(index = 0, required = true, metaVar = "ALL|<ID>|<INDEX>", usage = "the plugin to stop")
 		protected String id;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			if (id.equalsIgnoreCase("ALL")) {
 				gitblit.stopPlugins();
 				stdout.println("All plugins stopped");
 			} else {
 				PluginWrapper pluginWrapper = getPlugin(id);
 				if (pluginWrapper == null) {
 					throw new UnloggedFailure(String.format("Plugin %s is not installed!", id));
 				}

 				PluginState state = gitblit.stopPlugin(pluginWrapper.getPluginId());
 				if (PluginState.STOPPED.equals(state)) {
 					stdout.println(String.format("Stopped %s", pluginWrapper.getPluginId()));
 				} else {
 					throw new UnloggedFailure(1, String.format("Failed to stop %s", pluginWrapper.getPluginId()));
 				}
 			}
 		}
 	}

 	@CommandMetaData(name = "enable", description = "Enable a plugin")
 	public static class EnablePlugin extends PluginCommand {

 		@Argument(index = 0, required = true, metaVar = "<ID>|<INDEX>", usage = "the plugin to enable")
 		protected String id;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			PluginWrapper pluginWrapper = getPlugin(id);
 			if (pluginWrapper == null) {
 				throw new UnloggedFailure("Invalid plugin specified!");
 			}

 			if (gitblit.enablePlugin(pluginWrapper.getPluginId())) {
 				stdout.println(String.format("Enabled %s", pluginWrapper.getPluginId()));
 			} else {
 				throw new UnloggedFailure(1, String.format("Failed to enable %s", pluginWrapper.getPluginId()));
 			}
 		}
 	}

 	@CommandMetaData(name = "disable", description = "Disable a plugin")
 	public static class DisablePlugin extends PluginCommand {

 		@Argument(index = 0, required = true, metaVar = "<ID>|<INDEX>", usage = "the plugin to disable")
 		protected String id;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			PluginWrapper pluginWrapper = getPlugin(id);
 			if (pluginWrapper == null) {
 				throw new UnloggedFailure("Invalid plugin specified!");
 			}

 			if (gitblit.disablePlugin(pluginWrapper.getPluginId())) {
 				stdout.println(String.format("Disabled %s", pluginWrapper.getPluginId()));
 			} else {
 				throw new UnloggedFailure(1, String.format("Failed to disable %s", pluginWrapper.getPluginId()));
 			}
 		}
 	}

 	@CommandMetaData(name = "show", description = "Show the details of a plugin")
 	public static class ShowPlugin extends PluginCommand {

 		@Argument(index = 0, required = true, metaVar = "<ID>|<INDEX>", usage = "the plugin to show")
 		protected String id;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			PluginWrapper pw = getPlugin(id);
 			if (pw == null) {
 				PluginRegistration registration = gitblit.lookupPlugin(id);
 				if (registration == null) {
 					throw new Failure(1, String.format("Unknown plugin %s", id));
 				}
 				show(registration);
 			} else {
 				show(pw);
 			}
 		}

 		protected String buildFieldTable(PluginWrapper pw, PluginRegistration reg) {
 			Version system = getContext().getGitblit().getSystemVersion();
 			PluginRelease current = reg == null ? null : reg.getCurrentRelease(system);
 			if (current == null) {
 				current = new PluginRelease();
 				current.version = "";
 				current.requires = "";
 			}

 			final String id = pw == null ? reg.id : pw.getPluginId();
 			final String description = reg == null ? pw.getDescriptor().getPluginDescription() : reg.description;
 			final String version = pw == null ? current.version : pw.getDescriptor().getVersion().toString();
 			final String requires = pw == null ? current.requires : pw.getDescriptor().getRequires().toString();
 			final String provider = pw == null ? reg.provider : pw.getDescriptor().getProvider();
 			final String registry = reg == null ? "" : reg.registry;
 			final String path = pw == null ? "" : pw.getPluginPath();
 			final String projectUrl = reg == null ? "" : reg.projectUrl;
 			final String state;
 			if (pw == null) {
 				// plugin could be installed
 				state = InstallState.NOT_INSTALLED.toString();
 			} else if (reg == null) {
 				// unregistered, installed plugin
 				state = Joiner.on(", ").join(InstallState.INSTALLED, pw.getPluginState());
 			} else {
 				// registered, installed plugin
 				state = Joiner.on(", ").join(reg.getInstallState(system), pw.getPluginState());
 			}

 			StringBuilder sb = new StringBuilder();
 			sb.append("ID          : ").append(id).append('\n');
 			sb.append("Version     : ").append(version).append('\n');
 			sb.append("Requires    : ").append(requires).append('\n');
 			sb.append("State       : ").append(state).append('\n');
 			sb.append("Path        : ").append(path).append('\n');
 			sb.append('\n');
 			sb.append("Description : ").append(description).append('\n');
 			sb.append("Provider    : ").append(provider).append('\n');
 			sb.append("Project URL : ").append(projectUrl).append('\n');
 			sb.append("Registry    : ").append(registry).append('\n');

 			return sb.toString();
 		}

 		protected String buildReleaseTable(PluginRegistration reg) {
 			List<PluginRelease> releases = reg.releases;
 			Collections.sort(releases);
 			String releaseTable;
 			if (releases.isEmpty()) {
 				releaseTable = FlipTable.EMPTY;
 			} else {
 				String[] headers = { "Version", "Date", "Requires" };
 				Object[][] data = new Object[releases.size()][];
 				for (int i = 0; i < releases.size(); i++) {
 					PluginRelease release = releases.get(i);
 					data[i] = new Object[] { (release.version.equals(reg.installedRelease) ? ">" : " ") + release.version,
 							release.date, release.requires };
 				}
 				releaseTable = FlipTable.of(headers, data, Borders.COLS);
 			}
 			return releaseTable;
 		}

 		/**
 		 * Show an uninstalled plugin.
 		 *
 		 * @param reg
 		 */
 		protected void show(PluginRegistration reg) {
 			// REGISTRATION
 			final String fields = buildFieldTable(null, reg);
 			final String releases = buildReleaseTable(reg);

 			String[] headers = { reg.id };
 			Object[][] data = new Object[3][];
 			data[0] = new Object[] { fields };
 			data[1] = new Object[] { "RELEASES" };
 			data[2] = new Object[] { releases };
 			stdout.println(FlipTable.of(headers, data));
 		}

 		/**
 		 * Show an installed plugin.
 		 *
 		 * @param pw
 		 */
 		protected void show(PluginWrapper pw) {
 			IGitblit gitblit = getContext().getGitblit();
 			PluginRegistration reg = gitblit.lookupPlugin(pw.getPluginId());

 			// FIELDS
 			final String fields = buildFieldTable(pw, reg);

 			// EXTENSIONS
 			StringBuilder sb = new StringBuilder();
 			List<Class<?>> exts = gitblit.getExtensionClasses(pw.getPluginId());
 			String extensions;
 			if (exts.isEmpty()) {
 				extensions = FlipTable.EMPTY;
 			} else {
 				StringBuilder description = new StringBuilder();
 				for (int i = 0; i < exts.size(); i++) {
 					Class<?> ext = exts.get(i);
 					if (ext.isAnnotationPresent(CommandMetaData.class)) {
 						CommandMetaData meta = ext.getAnnotation(CommandMetaData.class);
 						description.append(meta.name());
 						if (meta.description().length() > 0) {
 							description.append(": ").append(meta.description());
 						}
 						description.append('\n');
 					}
 					description.append(ext.getName()).append("\n  └ ");
 					description.append(getExtensionPoint(ext).getName());
 					description.append("\n\n");
 				}
 				extensions = description.toString();
 			}

 			// DEPENDENCIES
 			sb.setLength(0);
 			List<PluginDependency> deps = pw.getDescriptor().getDependencies();
 			String dependencies;
 			if (deps.isEmpty()) {
 				dependencies = FlipTable.EMPTY;
 			} else {
 				String[] headers = { "Id", "Version" };
 				Object[][] data = new Object[deps.size()][];
 				for (int i = 0; i < deps.size(); i++) {
 					PluginDependency dep = deps.get(i);
 					data[i] = new Object[] { dep.getPluginId(), dep.getPluginVersion() };
 				}
 				dependencies = FlipTable.of(headers, data, Borders.COLS);
 			}

 			// RELEASES
 			String releases;
 			if (reg == null) {
 				releases = FlipTable.EMPTY;
 			} else {
 				releases = buildReleaseTable(reg);
 			}

 			String[] headers = { pw.getPluginId() };
 			Object[][] data = new Object[7][];
 			data[0] = new Object[] { fields };
 			data[1] = new Object[] { "EXTENSIONS" };
 			data[2] = new Object[] { extensions };
 			data[3] = new Object[] { "DEPENDENCIES" };
 			data[4] = new Object[] { dependencies };
 			data[5] = new Object[] { "RELEASES" };
 			data[6] = new Object[] { releases };
 			stdout.println(FlipTable.of(headers, data));
 		}

 		/* Find the ExtensionPoint */
 		protected Class<?> getExtensionPoint(Class<?> clazz) {
 			Class<?> superClass = clazz.getSuperclass();
 			if (ExtensionPoint.class.isAssignableFrom(superClass)) {
 				return superClass;
 			}
 			return getExtensionPoint(superClass);
 		}
 	}

 	@CommandMetaData(name = "refresh", description = "Refresh the plugin registry data")
 	public static class RefreshPlugins extends SshCommand {

 		@Option(name = "--noverify", usage = "Disable checksum verification")
 		private boolean disableChecksum;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			gitblit.refreshRegistry(!disableChecksum);
 		}
 	}

 	@CommandMetaData(name = "available", description = "List the available plugins")
 	public static class AvailablePlugins extends ListFilterCommand<PluginRegistration> {

 		@Option(name = "--refresh", aliases = { "-r" }, usage = "refresh the plugin registry")
 		protected boolean refresh;

 		@Option(name = "--updates", aliases = { "-u" }, usage = "show available updates")
 		protected boolean updates;

 		@Option(name = "--noverify", usage = "Disable checksum verification")
 		private boolean disableChecksum;

 		@Override
 		protected List<PluginRegistration> getItems() throws UnloggedFailure {
 			IGitblit gitblit = getContext().getGitblit();
 			if (refresh) {
 				gitblit.refreshRegistry(!disableChecksum);
 			}

 			List<PluginRegistration> list;
 			if (updates) {
 				list = gitblit.getRegisteredPlugins(InstallState.UPDATE_AVAILABLE);
 			} else {
 				list = gitblit.getRegisteredPlugins();
 			}
 			return list;
 		}

 		@Override
 		protected boolean matches(String filter, PluginRegistration t) {
 			return t.id.matches(filter) || (t.description != null && t.description.matches(filter));
 		}

 		@Override
 		protected void asTable(List<PluginRegistration> list) {
 			String[] headers;
 			if (verbose) {
 				String [] h = { "Id", "Description", "Installed", "Current", "Requires", "State", "Registry" };
 				headers = h;
 			} else {
 				String [] h = { "Id", "Installed", "Current", "Requires", "State" };
 				headers = h;
 			}
 			Version system = getContext().getGitblit().getSystemVersion();
 			Object[][] data = new Object[list.size()][];
 			for (int i = 0; i < list.size(); i++) {
 				PluginRegistration p = list.get(i);
 				PluginRelease curr = p.getCurrentRelease(system);
 				if (curr == null) {
 					curr = new PluginRelease();
 				}
 				if (verbose) {
 					data[i] = new Object[] {p.id, p.description, p.installedRelease, curr.version, curr.requires, p.getInstallState(system), p.registry};
 				} else {
 					data[i] = new Object[] {p.id, p.installedRelease, curr.version, curr.requires, p.getInstallState(system)};
 				}
 			}

 			stdout.println(FlipTable.of(headers, data, Borders.BODY_HCOLS));
 		}

 		@Override
 		protected void asTabbed(List<PluginRegistration> list) {
 			Version system = getContext().getGitblit().getSystemVersion();
 			for (PluginRegistration p : list) {
 				PluginRelease curr = p.getCurrentRelease(system);
 				if (curr == null) {
 					curr = new PluginRelease();
 				}
 				if (verbose) {
 					outTabbed(p.id, p.description, p.installedRelease, curr.version, curr.requires, p.getInstallState(system), p.provider, p.registry);
 				} else {
 					outTabbed(p.id, p.installedRelease, curr.version, curr.requires, p.getInstallState(system));
 				}
 			}
 		}
 	}

 	@CommandMetaData(name = "install", description = "Download and installs a plugin")
 	public static class InstallPlugin extends SshCommand {

 		@Argument(index = 0, required = true, metaVar = "<URL>|<ID>", usage = "the id or the url of the plugin to download and install")
 		protected String urlOrId;

 		@Option(name = "--version", usage = "The specific version to install")
 		private String version;

 		@Option(name = "--noverify", usage = "Disable checksum verification")
 		private boolean disableChecksum;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			try {
 				String ulc = urlOrId.toLowerCase();
 				if (ulc.startsWith("http://") || ulc.startsWith("https://")) {
 					if (gitblit.installPlugin(urlOrId, !disableChecksum)) {
 						stdout.println(String.format("Installed %s", urlOrId));
 					} else {
 						throw new UnloggedFailure(1, String.format("Failed to install %s", urlOrId));
 					}
 				} else {
 					PluginRelease pr = gitblit.lookupRelease(urlOrId, version);
 					if (pr == null) {
 						throw new UnloggedFailure(1,  String.format("Plugin \"%s\" is not in the registry!", urlOrId));
 					}

 					// enforce minimum system requirement
 					if (!StringUtils.isEmpty(pr.requires)) {
 						Version requires = Version.createVersion(pr.requires);
 						Version system = gitblit.getSystemVersion();
 						boolean isValid = system.isZero() || system.atLeast(requires);
 						if (!isValid) {
 							String msg = String.format("Plugin \"%s:%s\" requires Gitblit %s",
 									urlOrId, pr.version, pr.requires);
 							throw new UnloggedFailure(1, msg);
 						}
 					}

 					if (gitblit.installPlugin(pr.url, !disableChecksum)) {
 						stdout.println(String.format("Installed %s", urlOrId));
 					} else {
 						throw new UnloggedFailure(1, String.format("Failed to install %s", urlOrId));
 					}
 				}
 			} catch (IOException e) {
 				log.error("Failed to install " + urlOrId, e);
 				throw new UnloggedFailure(1, String.format("Failed to install %s", urlOrId), e);
 			}
 		}
 	}

 	@CommandMetaData(name = "upgrade", description = "Upgrade a plugin")
 	public static class UpgradePlugin extends PluginCommand {

 		@Argument(index = 0, required = true, metaVar = "<ID>|<INDEX>", usage = "the plugin to upgrade")
 		protected String id;

 		@Option(name = "--version", usage = "The specific version to install")
 		private String version;

 		@Option(name = "--noverify", usage = "Disable checksum verification")
 		private boolean disableChecksum;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			PluginWrapper pluginWrapper = getPlugin(id);
 			if (pluginWrapper == null) {
 				throw new UnloggedFailure("Invalid plugin specified!");
 			}

 			PluginRelease pr = gitblit.lookupRelease(pluginWrapper.getPluginId(), version);
 			if (pr == null) {
 				throw new UnloggedFailure(1,  String.format("Plugin \"%s\" is not in the registry!", pluginWrapper.getPluginId()));
 			}

 			// enforce minimum system requirement
 			if (!StringUtils.isEmpty(pr.requires)) {
 				Version requires = Version.createVersion(pr.requires);
 				Version system = gitblit.getSystemVersion();
 				boolean isValid = system.isZero() || system.atLeast(requires);
 				if (!isValid) {
 					throw new Failure(1, String.format("Plugin \"%s:%s\" requires Gitblit %s",
 							pluginWrapper.getPluginId(), pr.version, pr.requires));
 				}
 			}

 			try {
 				if (gitblit.upgradePlugin(pluginWrapper.getPluginId(), pr.url, !disableChecksum)) {
 					stdout.println(String.format("Upgraded %s", pluginWrapper.getPluginId()));
 				} else {
 					throw new UnloggedFailure(1, String.format("Failed to upgrade %s", pluginWrapper.getPluginId()));
 				}
 			} catch (IOException e) {
 				log.error("Failed to upgrade " + pluginWrapper.getPluginId(), e);
 				throw new UnloggedFailure(1, String.format("Failed to upgrade %s", pluginWrapper.getPluginId()), e);
 			}
 		}
 	}

 	@CommandMetaData(name = "uninstall", aliases = { "rm", "del" }, description = "Uninstall a plugin")
 	public static class UninstallPlugin extends PluginCommand {

 		@Argument(index = 0, required = true, metaVar = "<ID>|<INDEX>", usage = "the plugin to uninstall")
 		protected String id;

 		@Override
 		public void run() throws Failure {
 			IGitblit gitblit = getContext().getGitblit();
 			PluginWrapper pluginWrapper = getPlugin(id);
 			if (pluginWrapper == null) {
 				throw new UnloggedFailure(String.format("Plugin %s is not installed!", id));
 			}

 			if (gitblit.uninstallPlugin(pluginWrapper.getPluginId())) {
 				stdout.println(String.format("Uninstalled %s", pluginWrapper.getPluginId()));
 			} else {
 				throw new UnloggedFailure(1, String.format("Failed to uninstall %s", pluginWrapper.getPluginId()));
 			}
 		}
 	}
 }
	/*
	* 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.util.Collections;
	import java.util.List;

	import org.kohsuke.args4j.Argument;
	import org.kohsuke.args4j.Option;

	import ro.fortsoft.pf4j.ExtensionPoint;
	import ro.fortsoft.pf4j.PluginDependency;
	import ro.fortsoft.pf4j.PluginDescriptor;
	import ro.fortsoft.pf4j.PluginState;
	import ro.fortsoft.pf4j.PluginWrapper;
	import ro.fortsoft.pf4j.Version;

	import com.gitblit.manager.IGitblit;
	import com.gitblit.models.PluginRegistry.InstallState;
	import com.gitblit.models.PluginRegistry.PluginRegistration;
	import com.gitblit.models.PluginRegistry.PluginRelease;
	import com.gitblit.utils.FlipTable;
	import com.gitblit.utils.FlipTable.Borders;
	import com.gitblit.utils.StringUtils;
	import com.google.common.base.Joiner;

	/**
	* The plugin dispatcher and commands for runtime plugin management.
	*
	* @author James Moger
	*
	*/
	@CommandMetaData(name = "plugin", description = "Plugin management commands", admin = true)
	public class PluginDispatcher extends DispatchCommand {

	@Override
	protected void setup() {
	register(ListPlugins.class);
	register(StartPlugin.class);
	register(StopPlugin.class);
	register(EnablePlugin.class);
	register(DisablePlugin.class);
	register(ShowPlugin.class);
	register(RefreshPlugins.class);
	register(AvailablePlugins.class);
	register(InstallPlugin.class);
	register(UpgradePlugin.class);
	register(UninstallPlugin.class);
	}

	@CommandMetaData(name = "list", aliases = { "ls" }, description = "List plugins")
	public static class ListPlugins extends ListCommand<PluginWrapper> {

	@Override
	protected List<PluginWrapper> getItems() throws UnloggedFailure {
	IGitblit gitblit = getContext().getGitblit();
	List<PluginWrapper> list = gitblit.getPlugins();
	return list;
	}

	@Override
	protected void asTable(List<PluginWrapper> list) {
	String[] headers;
	if (verbose) {
	String [] h = { "#", "Id", "Description", "Version", "Requires", "State", "Path" };
	headers = h;
	} else {
	String [] h = { "#", "Id", "Version", "State", "Path"};
	headers = h;
	}
	Object[][] data = new Object[list.size()][];
	for (int i = 0; i < list.size(); i++) {
	PluginWrapper p = list.get(i);
	PluginDescriptor d = p.getDescriptor();
	if (verbose) {
	data[i] = new Object[] { "" + (i + 1), d.getPluginId(), d.getPluginDescription(), d.getVersion(), d.getRequires(), p.getPluginState(), p.getPluginPath() };
	} else {
	data[i] = new Object[] { "" + (i + 1), d.getPluginId(), d.getVersion(), p.getPluginState(), p.getPluginPath() };
	}
	}

	stdout.println(FlipTable.of(headers, data, Borders.BODY_HCOLS));
	}

	@Override
	protected void asTabbed(List<PluginWrapper> list) {
	for (PluginWrapper pw : list) {
	PluginDescriptor d = pw.getDescriptor();
	if (verbose) {
	outTabbed(d.getPluginId(), d.getPluginDescription(), d.getVersion(), d.getRequires(), pw.getPluginState(), pw.getPluginPath());
	} else {
	outTabbed(d.getPluginId(), d.getVersion(), pw.getPluginState(), pw.getPluginPath());
	}
	}
	}
	}

	static abstract class PluginCommand extends SshCommand {

	protected PluginWrapper getPlugin(String id) throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	PluginWrapper pluginWrapper = null;
	try {
	int index = Integer.parseInt(id);
	List<PluginWrapper> plugins = gitblit.getPlugins();
	if (index > plugins.size()) {
	throw new UnloggedFailure(1, "Invalid plugin index specified!");
	}
	pluginWrapper = plugins.get(index - 1);
	} catch (NumberFormatException e) {
	pluginWrapper = gitblit.getPlugin(id);
	if (pluginWrapper == null) {
	PluginRegistration reg = gitblit.lookupPlugin(id);
	if (reg == null) {
	throw new UnloggedFailure("Invalid plugin specified!");
	}
	pluginWrapper = gitblit.getPlugin(reg.id);
	}
	}

	return pluginWrapper;
	}
	}

	@CommandMetaData(name = "start", description = "Start a plugin")
	public static class StartPlugin extends PluginCommand {

	@Argument(index = 0, required = true, metaVar = "ALL\|<ID>\|<INDEX>", usage = "the plugin to start")
	protected String id;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	if (id.equalsIgnoreCase("ALL")) {
	gitblit.startPlugins();
	stdout.println("All plugins started");
	} else {
	PluginWrapper pluginWrapper = getPlugin(id);
	if (pluginWrapper == null) {
	throw new UnloggedFailure(String.format("Plugin %s is not installed!", id));
	}

	PluginState state = gitblit.startPlugin(pluginWrapper.getPluginId());
	if (PluginState.STARTED.equals(state)) {
	stdout.println(String.format("Started %s", pluginWrapper.getPluginId()));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to start %s", pluginWrapper.getPluginId()));
	}
	}
	}
	}

	@CommandMetaData(name = "stop", description = "Stop a plugin")
	public static class StopPlugin extends PluginCommand {

	@Argument(index = 0, required = true, metaVar = "ALL\|<ID>\|<INDEX>", usage = "the plugin to stop")
	protected String id;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	if (id.equalsIgnoreCase("ALL")) {
	gitblit.stopPlugins();
	stdout.println("All plugins stopped");
	} else {
	PluginWrapper pluginWrapper = getPlugin(id);
	if (pluginWrapper == null) {
	throw new UnloggedFailure(String.format("Plugin %s is not installed!", id));
	}

	PluginState state = gitblit.stopPlugin(pluginWrapper.getPluginId());
	if (PluginState.STOPPED.equals(state)) {
	stdout.println(String.format("Stopped %s", pluginWrapper.getPluginId()));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to stop %s", pluginWrapper.getPluginId()));
	}
	}
	}
	}

	@CommandMetaData(name = "enable", description = "Enable a plugin")
	public static class EnablePlugin extends PluginCommand {

	@Argument(index = 0, required = true, metaVar = "<ID>\|<INDEX>", usage = "the plugin to enable")
	protected String id;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	PluginWrapper pluginWrapper = getPlugin(id);
	if (pluginWrapper == null) {
	throw new UnloggedFailure("Invalid plugin specified!");
	}

	if (gitblit.enablePlugin(pluginWrapper.getPluginId())) {
	stdout.println(String.format("Enabled %s", pluginWrapper.getPluginId()));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to enable %s", pluginWrapper.getPluginId()));
	}
	}
	}

	@CommandMetaData(name = "disable", description = "Disable a plugin")
	public static class DisablePlugin extends PluginCommand {

	@Argument(index = 0, required = true, metaVar = "<ID>\|<INDEX>", usage = "the plugin to disable")
	protected String id;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	PluginWrapper pluginWrapper = getPlugin(id);
	if (pluginWrapper == null) {
	throw new UnloggedFailure("Invalid plugin specified!");
	}

	if (gitblit.disablePlugin(pluginWrapper.getPluginId())) {
	stdout.println(String.format("Disabled %s", pluginWrapper.getPluginId()));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to disable %s", pluginWrapper.getPluginId()));
	}
	}
	}

	@CommandMetaData(name = "show", description = "Show the details of a plugin")
	public static class ShowPlugin extends PluginCommand {

	@Argument(index = 0, required = true, metaVar = "<ID>\|<INDEX>", usage = "the plugin to show")
	protected String id;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	PluginWrapper pw = getPlugin(id);
	if (pw == null) {
	PluginRegistration registration = gitblit.lookupPlugin(id);
	if (registration == null) {
	throw new Failure(1, String.format("Unknown plugin %s", id));
	}
	show(registration);
	} else {
	show(pw);
	}
	}

	protected String buildFieldTable(PluginWrapper pw, PluginRegistration reg) {
	Version system = getContext().getGitblit().getSystemVersion();
	PluginRelease current = reg == null ? null : reg.getCurrentRelease(system);
	if (current == null) {
	current = new PluginRelease();
	current.version = "";
	current.requires = "";
	}

	final String id = pw == null ? reg.id : pw.getPluginId();
	final String description = reg == null ? pw.getDescriptor().getPluginDescription() : reg.description;
	final String version = pw == null ? current.version : pw.getDescriptor().getVersion().toString();
	final String requires = pw == null ? current.requires : pw.getDescriptor().getRequires().toString();
	final String provider = pw == null ? reg.provider : pw.getDescriptor().getProvider();
	final String registry = reg == null ? "" : reg.registry;
	final String path = pw == null ? "" : pw.getPluginPath();
	final String projectUrl = reg == null ? "" : reg.projectUrl;
	final String state;
	if (pw == null) {
	// plugin could be installed
	state = InstallState.NOT_INSTALLED.toString();
	} else if (reg == null) {
	// unregistered, installed plugin
	state = Joiner.on(", ").join(InstallState.INSTALLED, pw.getPluginState());
	} else {
	// registered, installed plugin
	state = Joiner.on(", ").join(reg.getInstallState(system), pw.getPluginState());
	}

	StringBuilder sb = new StringBuilder();
	sb.append("ID : ").append(id).append('\n');
	sb.append("Version : ").append(version).append('\n');
	sb.append("Requires : ").append(requires).append('\n');
	sb.append("State : ").append(state).append('\n');
	sb.append("Path : ").append(path).append('\n');
	sb.append('\n');
	sb.append("Description : ").append(description).append('\n');
	sb.append("Provider : ").append(provider).append('\n');
	sb.append("Project URL : ").append(projectUrl).append('\n');
	sb.append("Registry : ").append(registry).append('\n');

	return sb.toString();
	}

	protected String buildReleaseTable(PluginRegistration reg) {
	List<PluginRelease> releases = reg.releases;
	Collections.sort(releases);
	String releaseTable;
	if (releases.isEmpty()) {
	releaseTable = FlipTable.EMPTY;
	} else {
	String[] headers = { "Version", "Date", "Requires" };
	Object[][] data = new Object[releases.size()][];
	for (int i = 0; i < releases.size(); i++) {
	PluginRelease release = releases.get(i);
	data[i] = new Object[] { (release.version.equals(reg.installedRelease) ? ">" : " ") + release.version,
	release.date, release.requires };
	}
	releaseTable = FlipTable.of(headers, data, Borders.COLS);
	}
	return releaseTable;
	}

	/**
	* Show an uninstalled plugin.
	*
	* @param reg
	*/
	protected void show(PluginRegistration reg) {
	// REGISTRATION
	final String fields = buildFieldTable(null, reg);
	final String releases = buildReleaseTable(reg);

	String[] headers = { reg.id };
	Object[][] data = new Object[3][];
	data[0] = new Object[] { fields };
	data[1] = new Object[] { "RELEASES" };
	data[2] = new Object[] { releases };
	stdout.println(FlipTable.of(headers, data));
	}

	/**
	* Show an installed plugin.
	*
	* @param pw
	*/
	protected void show(PluginWrapper pw) {
	IGitblit gitblit = getContext().getGitblit();
	PluginRegistration reg = gitblit.lookupPlugin(pw.getPluginId());

	// FIELDS
	final String fields = buildFieldTable(pw, reg);

	// EXTENSIONS
	StringBuilder sb = new StringBuilder();
	List<Class<?>> exts = gitblit.getExtensionClasses(pw.getPluginId());
	String extensions;
	if (exts.isEmpty()) {
	extensions = FlipTable.EMPTY;
	} else {
	StringBuilder description = new StringBuilder();
	for (int i = 0; i < exts.size(); i++) {
	Class<?> ext = exts.get(i);
	if (ext.isAnnotationPresent(CommandMetaData.class)) {
	CommandMetaData meta = ext.getAnnotation(CommandMetaData.class);
	description.append(meta.name());
	if (meta.description().length() > 0) {
	description.append(": ").append(meta.description());
	}
	description.append('\n');
	}
	description.append(ext.getName()).append("\n └ ");
	description.append(getExtensionPoint(ext).getName());
	description.append("\n\n");
	}
	extensions = description.toString();
	}

	// DEPENDENCIES
	sb.setLength(0);
	List<PluginDependency> deps = pw.getDescriptor().getDependencies();
	String dependencies;
	if (deps.isEmpty()) {
	dependencies = FlipTable.EMPTY;
	} else {
	String[] headers = { "Id", "Version" };
	Object[][] data = new Object[deps.size()][];
	for (int i = 0; i < deps.size(); i++) {
	PluginDependency dep = deps.get(i);
	data[i] = new Object[] { dep.getPluginId(), dep.getPluginVersion() };
	}
	dependencies = FlipTable.of(headers, data, Borders.COLS);
	}

	// RELEASES
	String releases;
	if (reg == null) {
	releases = FlipTable.EMPTY;
	} else {
	releases = buildReleaseTable(reg);
	}

	String[] headers = { pw.getPluginId() };
	Object[][] data = new Object[7][];
	data[0] = new Object[] { fields };
	data[1] = new Object[] { "EXTENSIONS" };
	data[2] = new Object[] { extensions };
	data[3] = new Object[] { "DEPENDENCIES" };
	data[4] = new Object[] { dependencies };
	data[5] = new Object[] { "RELEASES" };
	data[6] = new Object[] { releases };
	stdout.println(FlipTable.of(headers, data));
	}

	/* Find the ExtensionPoint */
	protected Class<?> getExtensionPoint(Class<?> clazz) {
	Class<?> superClass = clazz.getSuperclass();
	if (ExtensionPoint.class.isAssignableFrom(superClass)) {
	return superClass;
	}
	return getExtensionPoint(superClass);
	}
	}

	@CommandMetaData(name = "refresh", description = "Refresh the plugin registry data")
	public static class RefreshPlugins extends SshCommand {

	@Option(name = "--noverify", usage = "Disable checksum verification")
	private boolean disableChecksum;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	gitblit.refreshRegistry(!disableChecksum);
	}
	}

	@CommandMetaData(name = "available", description = "List the available plugins")
	public static class AvailablePlugins extends ListFilterCommand<PluginRegistration> {

	@Option(name = "--refresh", aliases = { "-r" }, usage = "refresh the plugin registry")
	protected boolean refresh;

	@Option(name = "--updates", aliases = { "-u" }, usage = "show available updates")
	protected boolean updates;

	@Option(name = "--noverify", usage = "Disable checksum verification")
	private boolean disableChecksum;

	@Override
	protected List<PluginRegistration> getItems() throws UnloggedFailure {
	IGitblit gitblit = getContext().getGitblit();
	if (refresh) {
	gitblit.refreshRegistry(!disableChecksum);
	}

	List<PluginRegistration> list;
	if (updates) {
	list = gitblit.getRegisteredPlugins(InstallState.UPDATE_AVAILABLE);
	} else {
	list = gitblit.getRegisteredPlugins();
	}
	return list;
	}

	@Override
	protected boolean matches(String filter, PluginRegistration t) {
	return t.id.matches(filter) \|\| (t.description != null && t.description.matches(filter));
	}

	@Override
	protected void asTable(List<PluginRegistration> list) {
	String[] headers;
	if (verbose) {
	String [] h = { "Id", "Description", "Installed", "Current", "Requires", "State", "Registry" };
	headers = h;
	} else {
	String [] h = { "Id", "Installed", "Current", "Requires", "State" };
	headers = h;
	}
	Version system = getContext().getGitblit().getSystemVersion();
	Object[][] data = new Object[list.size()][];
	for (int i = 0; i < list.size(); i++) {
	PluginRegistration p = list.get(i);
	PluginRelease curr = p.getCurrentRelease(system);
	if (curr == null) {
	curr = new PluginRelease();
	}
	if (verbose) {
	data[i] = new Object[] {p.id, p.description, p.installedRelease, curr.version, curr.requires, p.getInstallState(system), p.registry};
	} else {
	data[i] = new Object[] {p.id, p.installedRelease, curr.version, curr.requires, p.getInstallState(system)};
	}
	}

	stdout.println(FlipTable.of(headers, data, Borders.BODY_HCOLS));
	}

	@Override
	protected void asTabbed(List<PluginRegistration> list) {
	Version system = getContext().getGitblit().getSystemVersion();
	for (PluginRegistration p : list) {
	PluginRelease curr = p.getCurrentRelease(system);
	if (curr == null) {
	curr = new PluginRelease();
	}
	if (verbose) {
	outTabbed(p.id, p.description, p.installedRelease, curr.version, curr.requires, p.getInstallState(system), p.provider, p.registry);
	} else {
	outTabbed(p.id, p.installedRelease, curr.version, curr.requires, p.getInstallState(system));
	}
	}
	}
	}

	@CommandMetaData(name = "install", description = "Download and installs a plugin")
	public static class InstallPlugin extends SshCommand {

	@Argument(index = 0, required = true, metaVar = "<URL>\|<ID>", usage = "the id or the url of the plugin to download and install")
	protected String urlOrId;

	@Option(name = "--version", usage = "The specific version to install")
	private String version;

	@Option(name = "--noverify", usage = "Disable checksum verification")
	private boolean disableChecksum;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	try {
	String ulc = urlOrId.toLowerCase();
	if (ulc.startsWith("http://") \|\| ulc.startsWith("https://")) {
	if (gitblit.installPlugin(urlOrId, !disableChecksum)) {
	stdout.println(String.format("Installed %s", urlOrId));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to install %s", urlOrId));
	}
	} else {
	PluginRelease pr = gitblit.lookupRelease(urlOrId, version);
	if (pr == null) {
	throw new UnloggedFailure(1, String.format("Plugin \"%s\" is not in the registry!", urlOrId));
	}

	// enforce minimum system requirement
	if (!StringUtils.isEmpty(pr.requires)) {
	Version requires = Version.createVersion(pr.requires);
	Version system = gitblit.getSystemVersion();
	boolean isValid = system.isZero() \|\| system.atLeast(requires);
	if (!isValid) {
	String msg = String.format("Plugin \"%s:%s\" requires Gitblit %s",
	urlOrId, pr.version, pr.requires);
	throw new UnloggedFailure(1, msg);
	}
	}

	if (gitblit.installPlugin(pr.url, !disableChecksum)) {
	stdout.println(String.format("Installed %s", urlOrId));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to install %s", urlOrId));
	}
	}
	} catch (IOException e) {
	log.error("Failed to install " + urlOrId, e);
	throw new UnloggedFailure(1, String.format("Failed to install %s", urlOrId), e);
	}
	}
	}

	@CommandMetaData(name = "upgrade", description = "Upgrade a plugin")
	public static class UpgradePlugin extends PluginCommand {

	@Argument(index = 0, required = true, metaVar = "<ID>\|<INDEX>", usage = "the plugin to upgrade")
	protected String id;

	@Option(name = "--version", usage = "The specific version to install")
	private String version;

	@Option(name = "--noverify", usage = "Disable checksum verification")
	private boolean disableChecksum;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	PluginWrapper pluginWrapper = getPlugin(id);
	if (pluginWrapper == null) {
	throw new UnloggedFailure("Invalid plugin specified!");
	}

	PluginRelease pr = gitblit.lookupRelease(pluginWrapper.getPluginId(), version);
	if (pr == null) {
	throw new UnloggedFailure(1, String.format("Plugin \"%s\" is not in the registry!", pluginWrapper.getPluginId()));
	}

	// enforce minimum system requirement
	if (!StringUtils.isEmpty(pr.requires)) {
	Version requires = Version.createVersion(pr.requires);
	Version system = gitblit.getSystemVersion();
	boolean isValid = system.isZero() \|\| system.atLeast(requires);
	if (!isValid) {
	throw new Failure(1, String.format("Plugin \"%s:%s\" requires Gitblit %s",
	pluginWrapper.getPluginId(), pr.version, pr.requires));
	}
	}

	try {
	if (gitblit.upgradePlugin(pluginWrapper.getPluginId(), pr.url, !disableChecksum)) {
	stdout.println(String.format("Upgraded %s", pluginWrapper.getPluginId()));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to upgrade %s", pluginWrapper.getPluginId()));
	}
	} catch (IOException e) {
	log.error("Failed to upgrade " + pluginWrapper.getPluginId(), e);
	throw new UnloggedFailure(1, String.format("Failed to upgrade %s", pluginWrapper.getPluginId()), e);
	}
	}
	}

	@CommandMetaData(name = "uninstall", aliases = { "rm", "del" }, description = "Uninstall a plugin")
	public static class UninstallPlugin extends PluginCommand {

	@Argument(index = 0, required = true, metaVar = "<ID>\|<INDEX>", usage = "the plugin to uninstall")
	protected String id;

	@Override
	public void run() throws Failure {
	IGitblit gitblit = getContext().getGitblit();
	PluginWrapper pluginWrapper = getPlugin(id);
	if (pluginWrapper == null) {
	throw new UnloggedFailure(String.format("Plugin %s is not installed!", id));
	}

	if (gitblit.uninstallPlugin(pluginWrapper.getPluginId())) {
	stdout.println(String.format("Uninstalled %s", pluginWrapper.getPluginId()));
	} else {
	throw new UnloggedFailure(1, String.format("Failed to uninstall %s", pluginWrapper.getPluginId()));
	}
	}
	}
	}