AbstractRemoteServiceTest.java

/****************************************************************************
 * Copyright (c) 2004 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.tests.remoteservice;

import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Properties;

import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.remoteservice.Constants;
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.IRemoteServiceID;
import org.eclipse.ecf.remoteservice.IRemoteServiceListener;
import org.eclipse.ecf.remoteservice.IRemoteServiceProxy;
import org.eclipse.ecf.remoteservice.IRemoteServiceReference;
import org.eclipse.ecf.remoteservice.IRemoteServiceRegistration;
import org.eclipse.ecf.remoteservice.events.IRemoteCallEvent;
import org.eclipse.ecf.remoteservice.events.IRemoteServiceEvent;
import org.eclipse.ecf.remoteservice.events.IRemoteServiceRegisteredEvent;
import org.eclipse.ecf.tests.ContainerAbstractTestCase;
import org.eclipse.equinox.concurrent.future.IFuture;
import org.osgi.framework.InvalidSyntaxException;

/**
 *
 */
public abstract class AbstractRemoteServiceTest extends
		ContainerAbstractTestCase {

	protected static final int SLEEPTIME = new Integer(System.getProperty(
			"org.eclipse.ecf.tests.remoteservice.AbstractRemoteServiceTest.SLEEPTIME", "5000"))
			.intValue();

	protected IRemoteServiceContainerAdapter[] adapters = null;

	protected IRemoteServiceID[] ids;

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ecf.tests.ContainerAbstractTestCase#getClientContainerName()
	 */
	protected abstract String getClientContainerName();

	protected void setClientCount(int count) {
		super.setClientCount(count);
		adapters = new IRemoteServiceContainerAdapter[count];
		ids = new IRemoteServiceID[count];
	}

	protected void setupRemoteServiceAdapters() throws Exception {
		if (server != null)
			server.getAdapter(IRemoteServiceContainerAdapter.class);
		final int clientCount = getClientCount();
		for (int i = 0; i < clientCount; i++) {
			adapters[i] = (IRemoteServiceContainerAdapter) getClients()[i]
					.getAdapter(IRemoteServiceContainerAdapter.class);
		}
	}

	protected IRemoteServiceContainerAdapter[] getRemoteServiceAdapters() {
		return adapters;
	}

	protected IRemoteServiceListener createRemoteServiceListener(
			final boolean server) {
		return new IRemoteServiceListener() {
			public void handleServiceEvent(IRemoteServiceEvent event) {
				System.out.println((server ? "server" : "client")
						+ "handleServiceEvent(" + event + ")");
				if (event instanceof IRemoteServiceRegisteredEvent) {
					if (server) {
						ids[0] = event.getReference().getID();
					} else {
						ids[1] = event.getReference().getID();
					}
				}
			}
		};
	}

	protected void addRemoteServiceListeners() {
		for (int i = 0; i < adapters.length; i++) {
			adapters[i]
					.addRemoteServiceListener(createRemoteServiceListener(i == 0));
		}
	}

	protected IRemoteServiceRegistration registerService(
			IRemoteServiceContainerAdapter adapter, String serviceInterface,
			Object service, Dictionary serviceProperties, int sleepTime) {
		final IRemoteServiceRegistration result = adapter
				.registerRemoteService(new String[] { serviceInterface },
						service, serviceProperties);
		sleep(sleepTime);
		return result;
	}

	protected IRemoteServiceReference[] getRemoteServiceReferences(
			IRemoteServiceContainerAdapter adapter, ID target, ID[] idFilter,
			String clazz, String filter) throws ContainerConnectException {
		try {
			return adapter.getRemoteServiceReferences(target, idFilter, clazz,
					filter);
		} catch (final InvalidSyntaxException e) {
			fail("should not happen");
		}
		return null;
	}

	protected IRemoteService getRemoteService(
			IRemoteServiceContainerAdapter adapter, ID target, ID[] idFilter,
			String clazz, String filter, int sleepTime)
			throws ContainerConnectException {
		final IRemoteServiceReference[] refs = getRemoteServiceReferences(
				adapter, target, idFilter, clazz, filter);
		if (refs == null || refs.length == 0)
			return null;
		return adapter.getRemoteService(refs[0]);
	}

	protected String getFilterFromServiceProperties(Dictionary serviceProperties) {
		StringBuffer filter = null;
		if (serviceProperties != null && serviceProperties.size() > 0) {
			filter = new StringBuffer("(&");
			for (final Enumeration e = serviceProperties.keys(); e
					.hasMoreElements();) {
				final Object key = e.nextElement();
				final Object val = serviceProperties.get(key);
				if (key != null && val != null) {
					filter.append("(").append(key).append("=").append(val)
							.append(")");
				}
			}
			filter.append(")");
		}
		return (filter == null) ? null : filter.toString();
	}

	protected IRemoteService registerAndGetRemoteService(
			IRemoteServiceContainerAdapter server,
			IRemoteServiceContainerAdapter client, ID target, ID[] idFilter,
			String serviceName, Dictionary serviceProperties, int sleepTime)
			throws ContainerConnectException {
		registerService(server, serviceName, createService(),
				serviceProperties, sleepTime);
		return getRemoteService(client, target, idFilter, serviceName,
				getFilterFromServiceProperties(serviceProperties), sleepTime);
	}

	protected IRemoteCall createRemoteCall(final String method,
			final Object[] params) {
		return new IRemoteCall() {
			public String getMethod() {
				return method;
			}

			public Object[] getParameters() {
				return params;
			}

			public long getTimeout() {
				return 5000;
			}
		};
	}

	protected Object createService() {
		return new IConcatService() {
			public String concat(String string1, String string2) {
				final String result = string1.concat(string2);
				System.out.println("SERVICE.concat(" + string1 + "," + string2
						+ ") returning " + result);
				return string1.concat(string2);
			}
		};
	}

	public void testRemoteServiceAdapters() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		assertNotNull(adapters);
		for (int i = 0; i < adapters.length; i++)
			assertNotNull(adapters[i]);
		Thread.sleep(SLEEPTIME);
	}

	public void testRemoteServiceNamespace() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		assertNotNull(adapters);
		for (int i = 0; i < adapters.length; i++) {
			Namespace namespace = adapters[i].getRemoteServiceNamespace();
			assertNotNull(namespace);
		}
		Thread.sleep(SLEEPTIME);
	}

	public void testRegisterService() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		// adapter [0] is the service 'server'
		final IRemoteServiceRegistration reg = registerService(adapters[0],
				IConcatService.class.getName(), createService(),
				customizeProperties(null), 0);
		assertNotNull(reg);
		IRemoteServiceID remoteServiceID = reg.getID();
		assertNotNull(remoteServiceID);
		assertNotNull(remoteServiceID.getContainerID());
		Thread.sleep(SLEEPTIME);
	}

	public void testUnregisterService() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		// adapter [0] is the service 'server'
		final IRemoteServiceRegistration reg = registerService(adapters[0],
				IConcatService.class.getName(), createService(),
				customizeProperties(null), SLEEPTIME);
		assertNotNull(reg);
		assertNotNull(reg.getContainerID());

		reg.unregister();
		Thread.sleep(SLEEPTIME);
	}

	protected ID getConnectTargetID() {
		return null;
	}

	protected ID[] getIDFilter() {
		return null;
	}

	public void testGetServiceReferences() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		// Register service on client[0]
		registerService(adapters[0], IConcatService.class.getName(),
				createService(), customizeProperties(null), SLEEPTIME);

		final IRemoteServiceReference[] refs = getRemoteServiceReferences(
				adapters[1], getConnectTargetID(), getIDFilter(),
				IConcatService.class.getName(), null);

		assertTrue(refs != null);
		assertTrue(refs.length > 0);
		Thread.sleep(SLEEPTIME);
	}

	public void testGetServiceReferencesWithFilter() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		final Properties props = new Properties();
		props.put("foo", "bar");
		props.put("foo1", "bar");
		registerService(adapters[0], IConcatService.class.getName(),
				createService(), customizeProperties(props), SLEEPTIME);

		final IRemoteServiceReference[] refs = getRemoteServiceReferences(
				adapters[1], getConnectTargetID(), getIDFilter(),
				IConcatService.class.getName(),
				getFilterFromServiceProperties(props));

		assertTrue(refs != null);
		assertTrue(refs.length > 0);
		Thread.sleep(SLEEPTIME);
	}

	public void testGetServiceReferencesWithFilterFail() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		final Properties props = new Properties();
		props.put("foo", "bar");
		props.put("foo1", "bar");
		registerService(adapters[0], IConcatService.class.getName(),
				createService(), customizeProperties(props), SLEEPTIME);

		// Create dictionary that is *not* the same as props, so the filter
		// should miss
		final Properties missProps = new Properties();
		missProps.put("bar", "foo");
		final String missFilter = getFilterFromServiceProperties(missProps);

		final IRemoteServiceReference[] refs = getRemoteServiceReferences(
				adapters[1], getConnectTargetID(), getIDFilter(),
				IConcatService.class.getName(), missFilter);

		assertTrue(refs == null);
		Thread.sleep(SLEEPTIME);
	}

	public void testGetService() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();
		assertNotNull(service);
		Thread.sleep(SLEEPTIME);
	}

	public void testGetProxy() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();
		assertNotNull(service);
		Object proxy = service.getProxy();
		assertTrue(proxy instanceof IRemoteServiceProxy);
		Thread.sleep(SLEEPTIME);
	}

	public void testGetProxyNoRemoteServiceProxy() throws Exception {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		Properties props = new Properties();
		props.put(Constants.SERVICE_PREVENT_RSPROXY,"true");
		final IRemoteService service = registerAndGetRemoteService(adapters[0], adapters[1],
				getClient(0).getConnectedID(), getIDFilter(),
				IConcatService.class.getName(), customizeProperties(props), SLEEPTIME);
		assertNotNull(service);
		Object proxy = service.getProxy();
		assertTrue(!(proxy instanceof IRemoteServiceProxy));
		Thread.sleep(SLEEPTIME);
	}

	protected IRemoteCall createRemoteConcat(String first, String second) {
		return createRemoteCall("concat", new Object[] { first, second });
	}

	protected IRemoteService registerAndGetRemoteService()
			throws ContainerConnectException {
		final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
		return registerAndGetRemoteService(adapters[0], adapters[1],
				getClient(0).getConnectedID(), getIDFilter(),
				IConcatService.class.getName(), customizeProperties(null), SLEEPTIME);
	}

	protected IRemoteCallListener createRemoteCallListener() {
		return new IRemoteCallListener() {
			public void handleEvent(IRemoteCallEvent event) {
				System.out.println("CLIENT.handleEvent(" + event + ")");
			}
		};
	}

	public void testCallSynch() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();

		if (service == null)
			return;

		traceCallStart("callSynch");
		final Object result = service.callSync(createRemoteConcat("Eclipse ",
				"is cool"));
		traceCallEnd("callSynch", result);

		assertNotNull(result);
		assertTrue(result.equals("Eclipse ".concat("is cool")));
		Thread.sleep(SLEEPTIME);
	}

	protected void traceCallStart(String callType) {
		System.out.println(callType + " start");
	}

	protected void traceCallEnd(String callType, Object result) {
		System.out.println(callType + " end");
		System.out.println("  result=" + result);
	}

	protected void traceCallEnd(String callType) {
		System.out.println(callType + " end.");
	}

	public void testBadCallSynch() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();

		if (service == null)
			return;
		// Following should throw exception because "concat1" method does not
		// exist
		try {
			service.callSync(createRemoteCall("concat1", new Object[] {
					"first", "second" }));
			fail();
		} catch (final ECFException e) {
			// Exception should occur
		}

		// Following should throw exception because wrong number of params for
		// concat
		try {
			service.callSync(createRemoteCall("concat",
					new Object[] { "first" }));
			fail();
		} catch (final ECFException e) {
			// Exception should occur
		}
		Thread.sleep(SLEEPTIME);
	}

	public void testCallAsynch() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();
		if (service == null)
			return;
		traceCallStart("callAsynch");
		service.callAsync(createRemoteConcat("ECF ", "is cool"),
				createRemoteCallListener());
		traceCallEnd("callAsynch");
		Thread.sleep(SLEEPTIME);
	}

	public void testFireAsynch() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();
		if (service == null)
			return;
		traceCallStart("fireAsynch");
		service.fireAsync(createRemoteConcat("Eclipse ", "sucks"));
		traceCallEnd("fireAsynch");
		Thread.sleep(SLEEPTIME);
	}

	public void testProxy() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();
		if (service == null)
			return;
		final IConcatService proxy = (IConcatService) service.getProxy();
		assertNotNull(proxy);
		traceCallStart("getProxy");
		final String result = proxy.concat("ECF ", "sucks");
		traceCallEnd("getProxy", result);
		Thread.sleep(SLEEPTIME);
	}

	public void testAsyncResult() throws Exception {
		final IRemoteService service = registerAndGetRemoteService();
		if (service == null)
			return;
		traceCallStart("callAsynchResult");
		final IFuture result = service.callAsync(createRemoteConcat(
				"ECF AsynchResults ", "are cool"));
		traceCallEnd("callAsynchResult", result);
		assertNotNull(result);
		Thread.sleep(SLEEPTIME);
	}

	protected Dictionary customizeProperties(Dictionary props) {
		return props;
	}
}