/****************************************************************************
* Copyright (c) 2008 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.generic;
import java.util.Dictionary;
import java.util.Hashtable;
import org.eclipse.ecf.remoteservice.IRemoteService;
import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter;
import org.eclipse.ecf.remoteservice.IRemoteServiceListener;
import org.eclipse.ecf.remoteservice.IRemoteServiceProxy;
import org.eclipse.ecf.remoteservice.IRemoteServiceReference;
import org.eclipse.ecf.remoteservice.RemoteServiceHelper;
import org.eclipse.ecf.remoteservice.events.IRemoteServiceEvent;
import org.eclipse.ecf.remoteservice.events.IRemoteServiceRegisteredEvent;
import org.eclipse.ecf.remoteservice.util.tracker.RemoteServiceTracker;
import org.eclipse.ecf.tests.remoteservice.AbstractRemoteServiceTest;
import org.eclipse.ecf.tests.remoteservice.IConcatService;
import org.eclipse.equinox.concurrent.future.IFuture;
import org.eclipse.osgi.util.NLS;
/**
*
*/
public class SSLRemoteServiceProxyTest extends AbstractRemoteServiceTest {
RemoteServiceTracker remoteServiceTracker;
protected String getClientContainerName() {
return SSLGeneric.CONSUMER_CONTAINER_TYPE;
}
protected String getServerIdentity() {
return NLS.bind(SSLGeneric.HOST_CONTAINER_ENDPOINT_ID, new Integer(genericServerPort));
}
protected String getServerContainerName() {
return SSLGeneric.HOST_CONTAINER_TYPE;
}
/*
* (non-Javadoc)
*
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception {
super.setUp();
setClientCount(2);
createServerAndClients();
setupRemoteServiceAdapters();
connectClients();
addRemoteServiceListeners();
}
/*
* (non-Javadoc)
*
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception {
cleanUpServerAndClients();
if (remoteServiceTracker != null) {
remoteServiceTracker.close();
}
super.tearDown();
}
protected IRemoteService getRemoteService(IRemoteServiceContainerAdapter adapter, String clazz, String filter) {
remoteServiceTracker = new RemoteServiceTracker(adapter, null, clazz, null);
assertNotNull(remoteServiceTracker);
remoteServiceTracker.open();
return remoteServiceTracker.getRemoteService();
}
public void testRemoteServiceProxy() throws Exception {
final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
// client [0]/adapter[0] is the service 'server'
// client [1]/adapter[1] is the service target (client)
final Dictionary props = new Hashtable();
// Register
adapters[0].registerRemoteService(new String[] {IConcatService.class.getName()}, createService(), props);
// Give some time for propagation
sleep(3000);
final RemoteServiceTracker st = new RemoteServiceTracker(adapters[1], null, IConcatService.class.getName(), null);
assertNotNull(st);
st.open();
IRemoteService rs = st.getRemoteService();
final IConcatService concatService = (IConcatService) rs.getProxy();
assertNotNull(concatService);
// test for proxy implementing IRemoteServiceProxy
if (concatService instanceof IRemoteServiceProxy) {
IRemoteService remoteService = ((IRemoteServiceProxy) concatService).getRemoteService();
assertNotNull(remoteService);
IRemoteServiceReference remoteServiceReference = ((IRemoteServiceProxy) concatService).getRemoteServiceReference();
assertNotNull(remoteServiceReference);
System.out.println("remote service reference found from proxy="+remoteServiceReference);
System.out.println("remoteserviceproxy call start");
Object result = RemoteServiceHelper.syncExec(remoteService, "concat" , new Object[] { "IRemoteServiceProxy ","is very cool" }, 20000);
System.out.println("remoteserviceproxy call end. result=" + result);
} else {
System.out.println("proxy call start");
final String result = concatService.concat("OSGi ", "is cool");
System.out.println("proxy call end. result=" + result);
}
sleep(3000);
st.close();
sleep(3000);
}
IRemoteService remoteService;
boolean done;
public void testServiceListener() throws Exception {
final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
done = false;
final Object lock = new Object();
adapters[1].addRemoteServiceListener(new IRemoteServiceListener() {
public void handleServiceEvent(IRemoteServiceEvent event) {
if (event instanceof IRemoteServiceRegisteredEvent) {
IRemoteServiceRegisteredEvent e = (IRemoteServiceRegisteredEvent) event;
IRemoteServiceReference ref = e.getReference();
remoteService = adapters[1].getRemoteService(ref);
assertNotNull(remoteService);
synchronized (lock) {
done = true;
lock.notify();
}
}
}
});
// Now register service on server (adapters[0]). This should result in notification on client (adapters[1])
// in above handleServiceEvent
adapters[0].registerRemoteService(new String[] { IConcatService.class.getName() }, createService(),
customizeProperties(null));
// wait until block above called asynchronously
int count = 0;
synchronized (lock) {
while (!done && count++ < 10) {
try {
lock.wait(1000);
} catch (InterruptedException e) {
fail();
}
}
}
assertTrue(done);
if (remoteService == null) return;
// We've got the remote service, so we're good to go
assertTrue(remoteService != null);
traceCallStart("callAsynchResult");
final IFuture result = remoteService
.callAsync(createRemoteConcat("ECF AsynchResults ", "are cool"));
traceCallEnd("callAsynch");
assertNotNull(result);
Thread.sleep(SLEEPTIME);
}
}