| /******************************************************************************* |
| * Copyright (c) 2009 EclipseSource 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: |
| * EclipseSource - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.ecf.tests.osgi.services.remoteserviceadmin; |
| |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Vector; |
| |
| import org.eclipse.ecf.core.ContainerFactory; |
| import org.eclipse.ecf.core.ContainerTypeDescription; |
| import org.eclipse.ecf.core.IContainer; |
| import org.eclipse.ecf.core.identity.ID; |
| import org.eclipse.ecf.remoteservice.Constants; |
| import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter; |
| import org.eclipse.ecf.remoteservice.IRemoteServiceReference; |
| import org.osgi.framework.ServiceRegistration; |
| import org.osgi.service.remoteserviceadmin.EndpointDescription; |
| import org.osgi.service.remoteserviceadmin.ExportReference; |
| import org.osgi.service.remoteserviceadmin.RemoteConstants; |
| import org.osgi.service.remoteserviceadmin.RemoteServiceAdminEvent; |
| import org.osgi.service.remoteserviceadmin.RemoteServiceAdminListener; |
| |
| public abstract class AbstractRemoteServiceRegisterTest extends |
| AbstractDistributionTest { |
| |
| protected static final int REGISTER_WAIT = 2000; |
| private ServiceRegistration registration; |
| protected Vector<RemoteServiceAdminEvent> remoteServiceAdminEvents = new Vector<RemoteServiceAdminEvent>(); |
| |
| protected abstract String getServerContainerTypeName(); |
| |
| protected void tearDown() throws Exception { |
| remoteServiceAdminEvents.clear(); |
| // Then unregister |
| if(registration != null) { |
| registration.unregister(); |
| registration = null; |
| } |
| Thread.sleep(REGISTER_WAIT); |
| |
| super.tearDown(); |
| |
| IContainer [] containers = getContainerManager().getAllContainers(); |
| for(int i=0; i < containers.length; i++) { |
| containers[i].dispose(); |
| } |
| getContainerManager().removeAllContainers(); |
| |
| } |
| |
| protected void registerWaitAndUnregister(Properties props, boolean verifyRegistration) throws Exception { |
| // Actually register with default service (IConcatService) |
| registration = registerDefaultService(props); |
| // Wait a while |
| Thread.sleep(REGISTER_WAIT); |
| // Verify |
| if (verifyRegistration) { |
| verifyRemoteServiceRegisteredWithServer(); |
| } |
| } |
| |
| private void verifyRemoteServiceRegisteredWithServer() throws Exception { |
| verifyRemoteServiceRegistered(getServerContainerAdapter(), getDefaultServiceClasses()[0]); |
| } |
| |
| protected void verifyRemoteServiceRegistered(IRemoteServiceContainerAdapter adapter, String className) throws Exception { |
| IRemoteServiceReference [] refs = adapter.getRemoteServiceReferences((ID[]) null, className, null); |
| assertNotNull(refs); |
| assertTrue(refs.length > 0); |
| String[] objectClasses = (String[]) refs[0].getProperty(Constants.OBJECTCLASS); |
| assertTrue(objectClasses != null); |
| assertTrue(objectClasses.length > 0); |
| assertTrue(objectClasses[0].equals(className)); |
| } |
| |
| private IRemoteServiceContainerAdapter getServerContainerAdapter() { |
| if (this.server != null) return (IRemoteServiceContainerAdapter) this.server.getAdapter(IRemoteServiceContainerAdapter.class); |
| IContainer [] containers = getContainerManager().getAllContainers(); |
| String containerType = getServerContainerTypeName(); |
| for(int i=0; i < containers.length; i++) { |
| ContainerTypeDescription ctd = getContainerManager().getContainerTypeDescription(containers[i].getID()); |
| if (ctd != null && ctd.getName().equals(containerType)) return (IRemoteServiceContainerAdapter) containers[i].getAdapter(IRemoteServiceContainerAdapter.class); |
| } |
| return null; |
| } |
| |
| public void testRegisterOnCreatedServer() throws Exception { |
| Properties props = getServiceProperties(); |
| registerWaitAndUnregister(props, true); |
| } |
| |
| private Properties getServiceProperties() { |
| Properties props = new Properties(); |
| // Set config to the server container name/provider config name (e.g. ecf.generic.server) |
| props.put(RemoteConstants.SERVICE_EXPORTED_CONFIGS, getServerContainerTypeName()); |
| // Set the service exported interfaces to all |
| props.put(RemoteConstants.SERVICE_EXPORTED_INTERFACES, "*"); |
| return props; |
| } |
| |
| public void testRegisterOnCreatedServerWithIdentity() throws Exception { |
| Properties props = getServiceProperties(); |
| // set the container factory arguments to the server identity (e.g. ecftcp://localhost:3282/server) |
| props.put(org.eclipse.ecf.osgi.services.remoteserviceadmin.RemoteConstants.SERVICE_EXPORTED_CONTAINER_FACTORY_ARGS, new String[] { getServerIdentity() } ); |
| |
| props.put("customsvcprop1","foo"); |
| props.put("customsvcprop2", "bar"); |
| registerWaitAndUnregister(props, true); |
| } |
| |
| public void testRegisterOnExistingServer() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| Properties props = getServiceProperties(); |
| |
| registerWaitAndUnregister(props, true); |
| } |
| |
| public void testRegisterOnExistingServerWithIntents() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| Properties props = getServiceProperties(); |
| // Add intents |
| props.put(RemoteConstants.SERVICE_INTENTS, "passByValue"); |
| registerWaitAndUnregister(props, true); |
| } |
| |
| public void testRegisterOnExistingServerWithMissingIntents() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| Properties props = getServiceProperties(); |
| // Add intent that no one actually exposes |
| props.put(RemoteConstants.SERVICE_INTENTS, "foobar"); |
| registerWaitAndUnregister(props, false); |
| } |
| |
| public void testRegisterOnExistingServerWithExportedIntents() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| Properties props = getServiceProperties(); |
| // Add intents |
| props.put(RemoteConstants.SERVICE_EXPORTED_INTENTS, "passByValue"); |
| registerWaitAndUnregister(props, true); |
| } |
| |
| public void testRegisterOnExistingServerWithMissingExportedIntents() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| Properties props = getServiceProperties(); |
| // Add intent that no one actually exposes |
| props.put(RemoteConstants.SERVICE_EXPORTED_INTENTS, "foobar"); |
| registerWaitAndUnregister(props, false); |
| } |
| |
| public void testRegisterOnExistingServerWithExportedExtraIntents() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| Properties props = getServiceProperties(); |
| // Add intents |
| props.put(RemoteConstants.SERVICE_EXPORTED_INTENTS_EXTRA, "passByValue"); |
| registerWaitAndUnregister(props, true); |
| } |
| |
| public void testRegisterOnExistingServerWithMissingExportedExtraIntents() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| Properties props = getServiceProperties(); |
| // Add intent that no one actually exposes |
| props.put(RemoteConstants.SERVICE_EXPORTED_INTENTS_EXTRA, "foobar"); |
| registerWaitAndUnregister(props, false); |
| } |
| |
| public void testRegisterOnExistingServerWithContainerID() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| |
| final Properties props = getServiceProperties(); |
| props.put(org.eclipse.ecf.osgi.services.remoteserviceadmin.RemoteConstants.SERVICE_EXPORTED_CONTAINER_ID, this.server.getID()); |
| registerWaitAndUnregister(props, true); |
| } |
| |
| public void testRegisterOnExistingServerWithIdentity() throws Exception { |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),getServerIdentity()); |
| |
| Properties props = getServiceProperties(); |
| |
| registerWaitAndUnregister(props, true); |
| } |
| |
| protected boolean containsEventType(int eventType) { |
| for(RemoteServiceAdminEvent event: remoteServiceAdminEvents) if (event.getType() == eventType) return true; |
| return false; |
| } |
| |
| protected RemoteServiceAdminListener createRemoteServiceAdminListener() { |
| return new RemoteServiceAdminListener() { |
| public void remoteAdminEvent(RemoteServiceAdminEvent event) { |
| System.out.println("remoteAdminEvent event="+event); |
| remoteServiceAdminEvents.add(event); |
| } |
| }; |
| } |
| |
| public void testRemoteServiceAdminListener() throws Exception { |
| RemoteServiceAdminListener listener = createRemoteServiceAdminListener(); |
| ServiceRegistration listenerReg = getContext().registerService(RemoteServiceAdminListener.class.getName(), listener, null); |
| |
| Properties props = getServiceProperties(); |
| registration = registerDefaultService(props); |
| // Wait a while |
| Thread.sleep(REGISTER_WAIT); |
| |
| assertTrue(remoteServiceAdminEvents.size() > 0); |
| assertTrue(containsEventType(RemoteServiceAdminEvent.EXPORT_REGISTRATION)); |
| |
| // Now bring down |
| registration.unregister(); |
| registration = null; |
| |
| // Wait a while |
| Thread.sleep(REGISTER_WAIT); |
| |
| assertTrue(remoteServiceAdminEvents.size() > 2); |
| assertTrue(containsEventType(RemoteServiceAdminEvent.EXPORT_UNREGISTRATION)); |
| |
| // finally unregister the listenerReg |
| listenerReg.unregister(); |
| } |
| |
| public void testRegisterAndUpdateProperties() throws Exception { |
| remoteServiceAdminEvents.clear(); |
| // register RemoteServiceAdminListener |
| ServiceRegistration listenerReg = getContext().registerService(RemoteServiceAdminListener.class.getName(), createRemoteServiceAdminListener(), null); |
| // Create server container |
| this.server = ContainerFactory.getDefault().createContainer(getServerContainerTypeName(),new Object[] {createServerID()}); |
| // Create props |
| Properties props = getServiceProperties(); |
| // Put "1" for "testonekey" |
| props.put("testonekey", "1"); |
| // Actually register with default service (IConcatService) as a remote service |
| registration = registerDefaultService(props); |
| ExportReference exportRef = null; |
| Thread.sleep(15000); |
| for(RemoteServiceAdminEvent e: remoteServiceAdminEvents) |
| if (e.getType() == RemoteServiceAdminEvent.EXPORT_REGISTRATION) exportRef = e.getExportReference(); |
| |
| assertTrue(exportRef != null); |
| // remoteServiceAdminEvents should have the Export registration |
| assertTrue(remoteServiceAdminEvents.size() > 0); |
| // Get ExportReference |
| EndpointDescription oldED = exportRef.getExportedEndpoint(); |
| assertNotNull(oldED); |
| Map<String,?> oldEDProperties = oldED.getProperties(); |
| assertNotNull(oldEDProperties); |
| assertTrue("1".equals(oldEDProperties.get("testonekey"))); |
| assertTrue(oldEDProperties.get("testtwokey")==null); |
| |
| // Change testonekey value to "two" and set a new property "testtwokey" to "2" |
| props.put("testonekey", "two"); |
| props.put("testtwokey", "2"); |
| // Set/update the properties on the registration |
| this.registration.setProperties(props); |
| |
| // Now get new EndpointDescription and test that new properties have been changed in EndpointDescription |
| EndpointDescription updatedED = exportRef.getExportedEndpoint(); |
| assertNotNull(updatedED); |
| Map<String,?> updatedEDProperties = updatedED.getProperties(); |
| assertNotNull(updatedEDProperties); |
| assertTrue("two".equals(updatedEDProperties.get("testonekey"))); |
| assertTrue("2".equals(updatedEDProperties.get("testtwokey"))); |
| |
| Thread.sleep(15000); |
| |
| listenerReg.unregister(); |
| } |
| |
| } |