| /**************************************************************************** | |
| * Copyright (c) 2008 Composent, Inc. and others. | |
| * | |
| * This program and the accompanying materials are made | |
| * available under the terms of the Eclipse Public License 2.0 | |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ | |
| * | |
| * Contributors: | |
| * Composent, Inc. - initial API and implementation | |
| * | |
| * SPDX-License-Identifier: EPL-2.0 | |
| *****************************************************************************/ | |
| 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, Integer.valueOf(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); | |
| } | |
| } |