<classpathentry kind="src" path="src"/>

	public static String AbstractRemoteServiceAccessHandler_DISCONNECT_MENU_TEXT;

	public static String AbstractRemoteServiceAccessHandler_MSG_BOX_RECEIVED_EXCEPTION_TEXT;

	public static String AbstractRemoteServiceAccessHandler_MSG_BOX_RECEIVED_EXCEPTION_TITLE;

	public static String AbstractRemoteServiceAccessHandler_MSG_BOX_RECEIVED_RESP_TEXT;

	public static String AbstractRemoteServiceAccessHandler_MSG_BOX_RECEIVED_RESP_TITLE;

	public static String AbstractRemoteServiceAccessHandler_NOT_AVAILABLE_MENU_TEXT;

Bundle-Activator: org.eclipse.ecf.internal.remoteservices.ui.Activator

/*******************************************************************************

 * Copyright (c) 2008 Versant Corp.

 * 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:

 *     Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation

 ******************************************************************************/

package org.eclipse.ecf.internal.remoteservices.ui.handlers;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.ecf.core.ContainerConnectException;

import org.eclipse.ecf.core.IContainer;

import org.eclipse.ecf.core.identity.ID;

import org.eclipse.ecf.internal.remoteservices.ui.RemoteServiceHandlerUtil;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.widgets.Display;

public class ConnectRemoteServicehandler extends AbstractHandler {

	public Object execute(final ExecutionEvent event) throws ExecutionException {

		final ID createConnectId = RemoteServiceHandlerUtil.getActiveConnectIDChecked(event);

		// decouple the long running connect call from the ui thread

		Job job = new Job(NLS.bind("Connecting {0}", createConnectId.getName())) {

			protected IStatus run(IProgressMonitor monitor) {

				try {

					final IContainer container = RemoteServiceHandlerUtil.getActiveIRemoteServiceContainerChecked(event);

					container.connect(createConnectId, null);

				} catch (ContainerConnectException e) {

					showException(e);

					return Status.CANCEL_STATUS;

				} catch (ExecutionException e) {

					showException(e);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		job.setUser(true);

		job.schedule();

		return null;

	}

	private void showException(final Throwable t) {

		Display.getDefault().asyncExec(new Runnable() {

			public void run() {

				String msg = t.toString();

				if (t.getCause() != null) {

					msg += t.getCause().toString();

				}

				MessageDialog.openError(null, t.getLocalizedMessage(), NLS.bind("Exception: {0}", msg));

			}

		});

	}

}

/*******************************************************************************

 * Copyright (c) 2008 Versant Corp.

 * 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:

 *     Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation

 ******************************************************************************/

package org.eclipse.ecf.internal.remoteservices.ui.property;

import org.eclipse.core.expressions.PropertyTester;

import org.eclipse.ecf.core.IContainer;

import org.eclipse.ecf.core.IContainerManager;

import org.eclipse.ecf.core.identity.ID;

import org.eclipse.ecf.core.identity.IDCreateException;

import org.eclipse.ecf.core.identity.IDFactory;

import org.eclipse.ecf.discovery.IServiceInfo;

import org.eclipse.ecf.discovery.ui.DiscoveryPropertyTesterUtil;

import org.eclipse.ecf.internal.remoteservices.ui.Activator;

import org.eclipse.ecf.remoteservice.Constants;

public class ConnectedTester extends PropertyTester {

	private IContainerManager containerManager;

	public ConnectedTester() {

		containerManager = Activator.getDefault().getContainerManager();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object, java.lang.String, java.lang.Object[], java.lang.Object)

	 */

	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {

		// consumers expect connected or disconnected

		if(!(expectedValue instanceof Boolean)) {

			return false;

		}

		boolean expected = ((Boolean) expectedValue).booleanValue();

		// get the container instance

		IServiceInfo serviceInfo = DiscoveryPropertyTesterUtil.getIServiceInfoReceiver(receiver);

		final String connectNamespace = getConnectNamespace(serviceInfo);

		final String connectId = getConnectID(serviceInfo);

		try {

			ID createConnectId = IDFactory.getDefault().createID(connectNamespace, connectId);

			IContainer container = containerManager.getContainer(createConnectId);

			if(container == null) {

				//Trace.trace(...);

				return expected == false;

			}

			ID connectedId = container.getConnectedID();

			boolean isConnected = connectedId == null ? false : true;

			return expected == isConnected;

		} catch (IDCreateException e) {

			//Trace.trace(...);

			return expected == false;

		}

	}

	private String getConnectNamespace(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_CONNECT_ID_NAMESPACE_PROPERTY);

	}

	private String getConnectID(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_CONNECT_ID_PROPERTY);

	}

}

/*******************************************************************************

 * Copyright (c) 2008 Versant Corp.

 * 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:

 *     Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation

 ******************************************************************************/

package org.eclipse.ecf.internal.remoteservices.ui.handlers;

import java.lang.reflect.InvocationTargetException;

import java.util.Arrays;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.commands.IHandler;

import org.eclipse.ecf.core.IContainer;

import org.eclipse.ecf.core.identity.ID;

import org.eclipse.ecf.core.util.IAsyncResult;

import org.eclipse.ecf.internal.remoteservices.ui.RemoteServiceHandlerUtil;

import org.eclipse.ecf.remoteservice.IRemoteCall;

import org.eclipse.ecf.remoteservice.IRemoteCallListener;

import org.eclipse.ecf.remoteservice.IRemoteService;

import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter;

import org.eclipse.ecf.remoteservice.IRemoteServiceReference;

import org.eclipse.ecf.remoteservice.events.IRemoteCallCompleteEvent;

import org.eclipse.ecf.remoteservice.events.IRemoteCallEvent;

import org.eclipse.ecf.remoteservices.ui.MethodInvocationDialog;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.window.Window;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

public class ReflectiveRemoteServiceHandler extends AbstractHandler implements

		IHandler {

	/*

	 * (non-Javadoc)

	 * @see

	 * org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands

	 * .ExecutionEvent)

	 */

	public Object execute(ExecutionEvent event) throws ExecutionException {

		final String clazz = event.getParameter("org.eclipse.ecf.remoteservices.ui.commands.reflectiveMethodDialogParameter");

		final IRemoteServiceContainerAdapter adapter = RemoteServiceHandlerUtil.getActiveIRemoteServiceContainerAdapterChecked(event);

		final IRemoteServiceReference[] references = RemoteServiceHandlerUtil.getActiveIRemoteServiceReferencesChecked(event);

		final IRemoteService remoteService = adapter.getRemoteService(references[0]);

		try {

			executeMethodInvocationDialog(Class.forName(clazz), remoteService);

		} catch (ClassNotFoundException e) {

			throw new ExecutionException(e.getMessage(), e);

		}

		return null;

	}

	private void executeMethodInvocationDialog(final Class cls, final IRemoteService remoteService) {

		final MethodInvocationDialog mid = new MethodInvocationDialog(

				(Shell) null, cls);

		if (mid.open() == Window.OK) {

			final int timeout = (mid.getTimeout() > 0) ? mid.getTimeout()

					: 30000;

			final String methodName = mid.getMethod().getName();

			final Object[] methodArgs = mid.getMethodArguments();

			final IRemoteCall remoteCall = new IRemoteCall() {

				public String getMethod() {

					return methodName;

				}

				public Object[] getParameters() {

					return methodArgs;

				}

				public long getTimeout() {

					return timeout;

				}

			};

			final int invokeType = mid.getInvocationType();

			try {

				switch (invokeType) {

				case MethodInvocationDialog.ASYNC_FIRE_AND_GO:

					remoteService.callAsynch(remoteCall);

					break;

				case MethodInvocationDialog.ASYNC_FUTURE_RESULT:

					invokeFuture(cls, remoteService, remoteCall);

					break;

				case MethodInvocationDialog.ASYNC_LISTENER:

					invokeAsyncListener(cls, remoteService, remoteCall);

					break;

				case MethodInvocationDialog.OSGI_SERVICE_PROXY:

					throw new UnsupportedOperationException();

					// invokeOSGiProxy(interfaceClass, remoteCall);

					// break;

				case MethodInvocationDialog.REMOTE_SERVICE_PROXY:

					throw new UnsupportedOperationException();

					// invokeProxy(interfaceClass, remoteService, remoteCall);

					// break;

				case MethodInvocationDialog.SYNCHRONOUS:

					throw new UnsupportedOperationException();

					// invokeSync(cls, remoteService, remoteCall);

					// break;

				default:

					break;

				}

			} catch (final Exception e) {

				showException(e);

			}

		}

	}

	protected void showException(final Throwable t, final IContainer container,

			ID targetID) {

		Display.getDefault().asyncExec(new Runnable() {

			public void run() {

				String msg = t.toString();

				if (t.getCause() != null) {

					msg += t.getCause().toString();

				}

				MessageDialog.openInformation(null, "Received Exception", NLS

						.bind("Exception: {0}", msg));

				container.disconnect();

			}

		});

	}

	protected void invokeFuture(Class cls, IRemoteService remoteService,

			IRemoteCall remoteCall) throws InterruptedException,

			InvocationTargetException {

		// Make async call with future result

		final IAsyncResult asyncResult = remoteService.callAsynch(remoteCall);

		// Call blocking get and show result

		showResult(cls.getName(), remoteCall, asyncResult.get());

	}

	private void invokeAsyncListener(final Class interfaceClass,

			final IRemoteService remoteService, final IRemoteCall remoteCall) {

		// Make async call

		remoteService.callAsynch(remoteCall, new IRemoteCallListener() {

			public void handleEvent(IRemoteCallEvent event) {

				if (event instanceof IRemoteCallCompleteEvent) {

					final IRemoteCallCompleteEvent complete = (IRemoteCallCompleteEvent) event;

					if (complete.hadException()) {

						showException(complete.getException());

					} else

						showResult(interfaceClass.getName(), remoteCall,

								complete.getResponse());

				}

			}

		});

	}

	protected void showException(final Throwable t) {

		Display.getDefault().asyncExec(new Runnable() {

			public void run() {

				String msg = t.toString();

				if (t.getCause() != null) {

					msg += t.getCause().toString();

				}

				MessageDialog.openInformation(null, "Received Exception", NLS

						.bind("Exception: {0}", msg));

			}

		});

	}

	protected void showResult(final String serviceInterface,

			final IRemoteCall remoteCall, final Object result) {

		final Object display = (result != null && result.getClass().isArray()) ? Arrays

				.asList((Object[]) result)

				: result;

		final Object[] bindings = new Object[] { serviceInterface,

				remoteCall.getMethod(),

				Arrays.asList(remoteCall.getParameters()), display };

		Display.getDefault().asyncExec(new Runnable() {

			public void run() {

				MessageDialog

						.openInformation(

								null,

								"Received Response",

								NLS

										.bind(

												"Service Interface:\n{0}\n\nMethod: {1}\nParameters: {2}\n\nResult:  {3}",

												bindings));

			}

		});

	}

}

/*******************************************************************************

 * Copyright (c) 2008 Versant Corp.

 * 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:

 *     Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation

 ******************************************************************************/

package org.eclipse.ecf.internal.remoteservices.ui;

import org.eclipse.ecf.core.IContainerManager;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

import org.osgi.util.tracker.ServiceTracker;

public class Activator extends AbstractUIPlugin {

	private volatile ServiceTracker containerManagerTracker;

	// The shared instance

	private volatile static Activator plugin;

	/**

	 * The constructor

	 */

	public Activator() {

		plugin = this;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)

	 */

	public void stop(BundleContext context) throws Exception {

		plugin = null;

		if(containerManagerTracker != null) {

			containerManagerTracker.close();

			containerManagerTracker = null;

		}

		super.stop(context);

	}

	/**

	 * Returns the shared instance

	 *

	 * @return the shared instance

	 */

	public static Activator getDefault() {

		return plugin;

	}

	public IContainerManager getContainerManager() {

		BundleContext context = getBundle().getBundleContext();

		if (containerManagerTracker == null) {

			containerManagerTracker = new ServiceTracker(context, IContainerManager.class.getName(), null);

			containerManagerTracker.open();

		}

		return (IContainerManager) containerManagerTracker.getService();

	}

}

/*******************************************************************************

 * Copyright (c) 2008 Versant Corp.

 * 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:

 *     Markus Kuppe (mkuppe <at> versant <dot> com) - initial API and implementation

 ******************************************************************************/

package org.eclipse.ecf.internal.remoteservices.ui;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.ecf.core.ContainerCreateException;

import org.eclipse.ecf.core.ContainerFactory;

import org.eclipse.ecf.core.IContainer;

import org.eclipse.ecf.core.IContainerManager;

import org.eclipse.ecf.core.identity.ID;

import org.eclipse.ecf.core.identity.IDCreateException;

import org.eclipse.ecf.core.identity.IDFactory;

import org.eclipse.ecf.discovery.IServiceInfo;

import org.eclipse.ecf.discovery.ui.DiscoveryHandlerUtil;

import org.eclipse.ecf.remoteservice.Constants;

import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter;

import org.eclipse.ecf.remoteservice.IRemoteServiceReference;

import org.osgi.framework.InvalidSyntaxException;

public class RemoteServiceHandlerUtil {

	public static IRemoteServiceContainerAdapter getActiveIRemoteServiceContainerAdapterChecked(ExecutionEvent event) throws ExecutionException {

		final ID activeConnectId = getActiveConnectIDChecked(event);

		final IContainerManager containerManager = Activator.getDefault().getContainerManager();

		final IContainer container = containerManager.getContainer(activeConnectId);

		final IRemoteServiceContainerAdapter adapter = (IRemoteServiceContainerAdapter) container.getAdapter(IRemoteServiceContainerAdapter.class);

		return adapter;

	}

	public static IRemoteServiceReference[] getActiveIRemoteServiceReferencesChecked(ExecutionEvent event) throws ExecutionException {

		IServiceInfo serviceInfo = DiscoveryHandlerUtil.getActiveIServiceInfoChecked(event);

		IRemoteServiceContainerAdapter adapter = getActiveIRemoteServiceContainerAdapterChecked(event);

		try {

			return getRemoteServiceReferencesForRemoteServiceAdapter(adapter, serviceInfo);

		} catch (IDCreateException e) {

			throw new ExecutionException(e.getMessage(), e);

		} catch (InvalidSyntaxException e) {

			throw new ExecutionException(e.getMessage(), e);

		}

	}

	public static ID getActiveConnectIDChecked(ExecutionEvent event) throws ExecutionException {

		IServiceInfo serviceInfo = DiscoveryHandlerUtil.getActiveIServiceInfoChecked(event);

		final String connectNamespace = getConnectNamespace(serviceInfo);

		final String connectId = getConnectID(serviceInfo);

		try {

			return IDFactory.getDefault().createID(connectNamespace, connectId);

		} catch (IDCreateException e) {

			throw new ExecutionException(e.getMessage(), e);

		}

	}

	public static IContainer getActiveIRemoteServiceContainerChecked(ExecutionEvent event) throws ExecutionException {

		final IServiceInfo serviceInfo = DiscoveryHandlerUtil.getActiveIServiceInfoChecked(event);

		final ID createConnectId = getActiveConnectIDChecked(event);

		//TODO remove parameters once https://bugs.eclipse.org/bugs/show_bug.cgi?id=256586 is fixed

		final Object[] parameters = new Object[]{createConnectId};

		try {

			return ContainerFactory.getDefault().createContainer(getContainerFactory(serviceInfo), parameters);

		} catch (ContainerCreateException e) {

			throw new ExecutionException(e.getMessage(), e);

		}

	}

	private static IRemoteServiceReference[] getRemoteServiceReferencesForRemoteServiceAdapter(IRemoteServiceContainerAdapter adapter, IServiceInfo serviceInfo) throws InvalidSyntaxException, IDCreateException {

		ID serviceID = null;

		String serviceNamespace = getServiceNamespace(serviceInfo);

		String serviceid = getServiceID(serviceInfo);

		if (serviceNamespace != null && serviceid != null) {

			serviceID = IDFactory.getDefault().createID(serviceNamespace, serviceid);

		}

		ID[] targets = (serviceID == null) ? null : new ID[] {serviceID};

		return adapter.getRemoteServiceReferences(targets, getRemoteServiceClass(serviceInfo), getFilter(serviceInfo));

	}

	private static String getServiceNamespace(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_SERVICE_ID_NAMESPACE_PROPERTY);

	}

	private static String getServiceID(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_SERVICE_ID_PROPERTY);

	}

	private static String getRemoteServiceClass(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_OBJECTCLASS_PROPERTY);

	}

	private static String getFilter(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_FILTER_PROPERTY);

	}

	private static String getConnectNamespace(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_CONNECT_ID_NAMESPACE_PROPERTY);

	}

	private static String getConnectID(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_CONNECT_ID_PROPERTY);

	}

	private static String getContainerFactory(IServiceInfo serviceInfo) {

		return serviceInfo.getServiceProperties().getPropertyString(Constants.DISCOVERY_CONTAINER_FACTORY_PROPERTY);

	}

}

<?xml version="1.0" encoding="UTF-8"?>

<?eclipse version="3.2"?>

<plugin>

   <extension

         point="org.eclipse.ui.commands">

      <command

            defaultHandler="org.eclipse.ecf.internal.remoteservices.ui.handlers.ConnectRemoteServicehandler"

            id="org.eclipse.ecf.remoteservices.ui.commands.connectCommand"

            name="Connect Command">

      </command>

      <command

            defaultHandler="org.eclipse.ecf.internal.remoteservices.ui.handlers.ReflectiveRemoteServiceHandler"

            id="org.eclipse.ecf.remoteservices.ui.commands.reflectiveMethodDialogHandler"

            name="Reflective Method Invocation Command">

         <commandParameter

               id="org.eclipse.ecf.remoteservices.ui.commands.reflectiveMethodDialogParameter"

               name="name"

               optional="true">

         </commandParameter>

      </command>

   </extension>

   <extension

         point="org.eclipse.ui.menus">

      <menuContribution

            locationURI="popup:org.eclipse.ecf.discovery.ui.DiscoveryView?after=additions">

         <command

               commandId="org.eclipse.ecf.remoteservices.ui.commands.connectCommand"

               id="org.eclipse.ecf.remoteservices.ui.menus.connectCommand"

               mnemonic="S">

            <visibleWhen>

               <with

                     variable="activeMenuSelection">

                  <iterate

                        ifEmpty="false"

                        operator="and">

                     <test

                           args="remotesvcs"

                           property="org.eclipse.ecf.discovery.isServiceType"

                           value="true">

                     </test>

                     <test

                           property="org.eclipse.ecf.remoteservices.isConnected"

                           value="false">

                     </test>

                  </iterate>

               </with>

            </visibleWhen>

         </command>

      </menuContribution>

   </extension>

	 <extension

         point="org.eclipse.core.expressions.propertyTesters">

      <propertyTester

            class="org.eclipse.ecf.internal.remoteservices.ui.property.ConnectedTester"

            id="org.eclipse.ecf.remoteservices.ui.property.ConnectedPropertyTester"

            namespace="org.eclipse.ecf.remoteservices"

            properties="isConnected"

            type="org.eclipse.ecf.discovery.model.IServiceInfo">

      </propertyTester>

   </extension>

</plugin>