framework/bundles/org.eclipse.ecf.console/src/org/eclipse/ecf/internal/console/ECFCommandProvider.java

/*******************************************************************************
* Copyright (c) 2009 Composent, Inc. and others. All rights reserved. This
* program and the accompanying materials are made available under the terms of
* the Eclipse Public License v1.0 which accompanies this distribution, and is
* available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
*   Composent, Inc. - initial API and implementation
******************************************************************************/
package org.eclipse.ecf.internal.console;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.eclipse.ecf.core.ContainerTypeDescription;
import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.IContainerFactory;
import org.eclipse.ecf.core.IContainerManager;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.osgi.framework.BundleContext;
import org.osgi.util.tracker.ServiceTracker;

public class ECFCommandProvider implements
		org.eclipse.osgi.framework.console.CommandProvider {

	public static final String NEW_LINE = System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$

	private BundleContext context;
	private ServiceTracker containerManagerTracker;
	
	public ECFCommandProvider(BundleContext context) {
		this.context = context;
	}
	
	private IContainerManager getContainerManager() {
		if (containerManagerTracker == null) {
			containerManagerTracker = new ServiceTracker(this.context,IContainerManager.class.getName(),null);
			containerManagerTracker.open();
		}
		return (IContainerManager) containerManagerTracker.getService();
	}
	
	private IContainerFactory getContainerFactory() {
		return getContainerManager().getContainerFactory();
	}
	
	public void dispose() {
		if (containerManagerTracker != null) {
			containerManagerTracker.close();
			containerManagerTracker = null;
		}
		this.context = null;
	}

	private IContainer createContainer(CommandInterpreter interpreter, String containerTypeDescriptionName, String[] args) {
		IContainerFactory containerFactory = getContainerFactory();
		try {
			if (containerTypeDescriptionName == null) return containerFactory.createContainer();
			else if (args == null) return containerFactory.createContainer(containerTypeDescriptionName);
			else return containerFactory.createContainer(containerTypeDescriptionName,args);
		} catch (Exception e) {
			printException(interpreter,"Could not create container with type="+containerTypeDescriptionName,e);
			return null;
		}
	}
	
	private void printException(CommandInterpreter interpreter, String message, Throwable t) {
		interpreter.println("--Exception--");
		if (message != null) interpreter.println(message);
		if (t != null) interpreter.printStackTrace(t);
		interpreter.println("--End Exception--");
	}

	private String[] getArgs(CommandInterpreter interpreter) {
		List result = new ArrayList();
		String arg = null;
		while ((arg = interpreter.nextArgument()) != null) result.add(arg);
		return (String[]) result.toArray(new String[] {});
	}
	
	private String[] getRemainingArgs(String[] args, int startPosition) {
		int targetLength = args.length-startPosition;
		String[] result = new String[targetLength];
		System.arraycopy(args, startPosition, result, 0, targetLength);
		return result;
	}
	
	public void _createcontainer(CommandInterpreter interpreter) {
		String[] args = getArgs(interpreter);
		String factoryName = (args.length==0)?null:args[0];
		String[] targetArgs = (args.length==0)?null:getRemainingArgs(args,1);
		IContainer c = createContainer(interpreter, factoryName, targetArgs);
		if (c != null) {
			interpreter.print("container created. ");
			printID(interpreter, c.getID());
		}
	}
	
	private void printContainer(CommandInterpreter interpreter, IContainer container, boolean verbose) {
		interpreter.println("--Container--");
		printID(interpreter, container.getID());
		if (verbose) {
			interpreter.print("\tclass=");
			interpreter.println(container.getClass().getName());
			ID connectedID = container.getConnectedID();
			if (connectedID != null) {
				interpreter.print("\tConnected to: ");
				printID(interpreter, connectedID);
			} else interpreter.println("\tNot connected.");
			Namespace ns = container.getConnectNamespace();
			if (ns != null) {
				interpreter.print("\tConnect namespace: ");
				interpreter.println(ns.getName());
			} else interpreter.println("\tNo connect namespace.");
			ContainerTypeDescription desc = getContainerManager().getContainerTypeDescription(container.getID());
			if (desc != null) printDescription(interpreter, desc);
		}
		interpreter.println("--End Container--");
	}
	
	private void printDescription(CommandInterpreter interpreter, ContainerTypeDescription desc) {
		interpreter.print("\tFactory name=");
		interpreter.println(desc.getName());
		interpreter.print("\tFactory description=");
		interpreter.println(desc.getDescription());
		String[] arr = desc.getSupportedIntents();
		if (arr != null) {
			interpreter.print("\tSupported intents=");
			interpreter.println(Arrays.asList(arr));
		}
		arr = desc.getSupportedConfigs();
		if (arr != null) {
			interpreter.print("\tSupported configs=");
			interpreter.println(Arrays.asList(arr));
		}
		arr = desc.getSupportedAdapterTypes();
		if (arr != null) {
			interpreter.print("\tSupported adapters=");
			interpreter.println(Arrays.asList(arr));
		}
		interpreter.println("\tHidden="+desc.isHidden());
		interpreter.println("\tServer="+desc.isServer());
	}
	
	public void _listcontainers(CommandInterpreter interpreter) {
		String[] args = getArgs(interpreter);
		boolean verbose = (args.length < 1)?false:new Boolean(args[0]).booleanValue();
		IContainer[] containers = getContainerManager().getAllContainers();
		if (containers == null || containers.length == 0) interpreter.println("No containers found.");
		for(int i=0; i < containers.length; i++) {
			printContainer(interpreter, containers[i], verbose);
		}
	}

	public void _listfactories(CommandInterpreter interpreter) {
		List descs = getContainerManager().getContainerFactory().getDescriptions();
		if (descs == null || descs.size() == 0) interpreter.println("No factories.");
		for(Iterator i=descs.iterator(); i.hasNext(); ) {
			ContainerTypeDescription desc = (ContainerTypeDescription) i.next();
			printDescription(interpreter, desc);
		}
	}

	private void printID(CommandInterpreter interpreter, ID id) {
		interpreter.print("\tID:");
		if (id == null) {
			interpreter.println("null");
			return;
		}
		interpreter.print("ns="+id.getNamespace().getName());
		interpreter.print(";name=");
		interpreter.print(id.getName());
		interpreter.println();
	}

	public void _destroycontainer(CommandInterpreter interpreter) {
		String[] args = getArgs(interpreter);
		if (args == null || args.length != 2) {
			interpreter.println("Incorrect number of arguments for container destroy");
			return;
		}
		ID id = createID(interpreter, args[0],args[1]);
		if (id == null) return;
		IContainer container = getContainerManager().removeContainer(id);
		if (container == null) {
			interpreter.println("Container not found to remove");
			return;
		}
		// Dispose the container instance
		container.dispose();
		interpreter.println("Container destroyed.");
	}
	
	private ID createID(CommandInterpreter interpreter, String namespace, String val) {
		try {
		return IDFactory.getDefault().createID(namespace, val);
		} catch (Exception e) {
			interpreter.printStackTrace(e);
			return null;
		}
	}

	public String getHelp() {
		StringBuffer help = new StringBuffer();
		help.append(NEW_LINE);
		help.append("---");
		help.append("Eclipse Communication Framework (ECF) Commands");
		help.append("---");
		help.append(NEW_LINE);
		help.append("\tlistfactories -- List all container factories.");
		help.append(NEW_LINE);
		help.append("\tlistcontainers [verbose] -- List all existing containers.");
		help.append(NEW_LINE);
		help.append("\tcreatecontainer [<containerFactoryName> [<arg0> <arg1>...]] -- Create new container.");
		help.append(NEW_LINE);
		help.append("\tdestroycontainer <namespace> <id> -- Remove and dispose container specified by namespace/id combination.");
		help.append(NEW_LINE);
		return help.toString();
	}

}