| /******************************************************************************* |
| * Copyright (c) 2018 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.osgi.services.remoteserviceadmin; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.ecf.core.ContainerConnectException; |
| import org.eclipse.ecf.core.ContainerTypeDescription; |
| import org.eclipse.ecf.core.IContainer; |
| import org.eclipse.ecf.core.identity.ID; |
| import org.eclipse.ecf.core.identity.IDCreateException; |
| import org.eclipse.ecf.core.identity.Namespace; |
| import org.eclipse.ecf.core.provider.ContainerInstantiatorUtils; |
| import org.eclipse.ecf.core.provider.ContainerIntentException; |
| import org.eclipse.ecf.core.security.IConnectContext; |
| import org.eclipse.ecf.internal.osgi.services.remoteserviceadmin.DebugOptions; |
| import org.eclipse.ecf.internal.osgi.services.remoteserviceadmin.IDUtil; |
| import org.eclipse.ecf.internal.osgi.services.remoteserviceadmin.LogUtility; |
| import org.eclipse.ecf.remoteservice.IRemoteServiceContainer; |
| import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter; |
| import org.eclipse.ecf.remoteservice.RemoteServiceContainer; |
| import org.osgi.framework.ServiceReference; |
| |
| /** |
| * Abstract superclass for host container selectors...i.e. implementers of |
| * {@link IHostContainerSelector}. |
| * |
| */ |
| public abstract class AbstractHostContainerSelector extends |
| AbstractContainerSelector { |
| |
| private static final String REQUIRE_SERVER_PROP = "org.eclipse.ecf.osgi.service.remoteserviceadmin.hostcontainerselector.requireserver"; //$NON-NLS-1$ |
| private static final String EXCLUDED_DESCRIPTIONS_PROP = "org.eclipse.ecf.osgi.service.remoteserviceadmin.hostcontainerselector.excludeddescriptions"; //$NON-NLS-1$ |
| private boolean defaultRequireServer = new Boolean(System.getProperty(REQUIRE_SERVER_PROP,"true")); //$NON-NLS-1$ |
| private List<String> excludedDescriptions; |
| |
| protected String[] defaultConfigTypes; |
| |
| public AbstractHostContainerSelector(String[] defaultConfigTypes) { |
| this.defaultConfigTypes = defaultConfigTypes; |
| String propValue = System.getProperty(EXCLUDED_DESCRIPTIONS_PROP); |
| String[] excludedVals = (propValue==null)?new String[0]:propValue.trim().split(","); //$NON-NLS-1$ |
| this.excludedDescriptions = Arrays.asList(excludedVals); |
| } |
| |
| /** |
| * @param serviceReference service reference |
| * @param overridingProperties overriding properties |
| * @param serviceExportedInterfaces service exported interfaces to select for |
| * @param serviceExportedConfigs service exported configs to select for |
| * @param serviceIntents service exported intents to select for |
| * @return Collection of existing host containers |
| * @since 2.0 |
| */ |
| protected Collection selectExistingHostContainers( |
| ServiceReference serviceReference, |
| Map<String, Object> overridingProperties, |
| String[] serviceExportedInterfaces, |
| String[] serviceExportedConfigs, String[] serviceIntents) { |
| List results = new ArrayList(); |
| // Get all existing containers |
| IContainer[] containers = getContainers(); |
| // If nothing there, then return empty array |
| if (containers == null || containers.length == 0) |
| return results; |
| |
| for (int i = 0; i < containers.length; i++) { |
| ID cID = containers[i].getID(); |
| trace("selectExistingHostContainers","Considering existing container="+cID); //$NON-NLS-1$ //$NON-NLS-2$ |
| // Check to make sure it's a rs container adapter. If it's not go |
| // onto next one |
| IRemoteServiceContainerAdapter adapter = hasRemoteServiceContainerAdapter(containers[i]); |
| if (adapter == null) { |
| trace("selectExistingHostContainers","Existing container="+cID+" does not implement IRemoteServiceContainerAdapter"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| continue; |
| } |
| // Get container type description and intents |
| ContainerTypeDescription description = getContainerTypeDescription(containers[i]); |
| // If it has no description go onto next |
| if (description == null) { |
| trace("selectExistingHostContainers","Existing container="+cID+" does not have container type description"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| continue; |
| } |
| // http://bugs.eclipse.org/331532 |
| if (!description.isServer()) { |
| trace("selectExistingHostContainers","Existing container="+cID+" is not server"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| continue; |
| } |
| |
| if (matchExistingHostContainer(serviceReference, |
| overridingProperties, containers[i], adapter, description, |
| serviceExportedConfigs, serviceIntents)) { |
| trace("selectExistingHostContainers", "INCLUDING containerID=" //$NON-NLS-1$ //$NON-NLS-2$ |
| + containers[i].getID() |
| + " configs=" //$NON-NLS-1$ |
| + ((serviceExportedConfigs == null) ? "null" : Arrays //$NON-NLS-1$ |
| .asList(serviceExportedConfigs).toString()) |
| + " intents=" //$NON-NLS-1$ |
| + ((serviceIntents == null) ? "null" : Arrays.asList( //$NON-NLS-1$ |
| serviceIntents).toString())); |
| results.add(new RemoteServiceContainer(containers[i], adapter)); |
| } else { |
| trace("selectExistingHostContainers", "EXCLUDING containerID=" //$NON-NLS-1$ //$NON-NLS-2$ |
| + containers[i].getID() |
| + " configs=" //$NON-NLS-1$ |
| + ((serviceExportedConfigs == null) ? "null" : Arrays //$NON-NLS-1$ |
| .asList(serviceExportedConfigs).toString()) |
| + " intents=" //$NON-NLS-1$ |
| + ((serviceIntents == null) ? "null" : Arrays.asList( //$NON-NLS-1$ |
| serviceIntents).toString())); |
| } |
| } |
| return results; |
| } |
| |
| /** |
| * @param serviceReference serviceReference |
| * @param properties properties |
| * @param container container to match |
| * @return boolean true if match false otherwise |
| * @since 2.0 |
| */ |
| protected boolean matchHostContainerToConnectTarget( |
| ServiceReference serviceReference, Map<String, Object> properties, |
| IContainer container) { |
| String target = (String) properties |
| .get(RemoteConstants.ENDPOINT_CONNECTTARGET_ID); |
| if (target == null) |
| return true; |
| // If a targetID is specified, make sure it either matches what the |
| // container |
| // is already connected to, or that we connect an unconnected container |
| ID connectedID = container.getConnectedID(); |
| // If the container is not already connected to anything |
| // then we connect it to the given target |
| if (connectedID == null) { |
| // connect to the target and we have a match |
| try { |
| connectHostContainer(serviceReference, properties, container, |
| target); |
| } catch (Exception e) { |
| logException("doConnectContainer containerID=" //$NON-NLS-1$ |
| + container.getID() + " target=" + target, e); //$NON-NLS-1$ |
| return false; |
| } |
| return true; |
| } else { |
| ID targetID = createTargetID(container, target); |
| // We check here if the currently connectedID equals the target. |
| // If it does we have a match |
| if (connectedID.equals(targetID)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * @param serviceReference service reference |
| * @param properties properties |
| * @param container container |
| * @param adapter remote service container adapter |
| * @param description container type description |
| * @param requiredConfigTypes required config types |
| * @param requiredServiceIntents required service intents |
| * @return boolean true if match, false otherwise |
| * @since 2.0 |
| */ |
| protected boolean matchExistingHostContainer( |
| ServiceReference serviceReference, Map<String, Object> properties, |
| IContainer container, IRemoteServiceContainerAdapter adapter, |
| ContainerTypeDescription description, String[] requiredConfigTypes, |
| String[] requiredServiceIntents) { |
| |
| return matchHostSupportedConfigTypes(requiredConfigTypes, description) |
| && matchHostSupportedIntents(requiredServiceIntents, |
| description, container) |
| && matchHostContainerID(serviceReference, properties, container) |
| && matchHostContainerToConnectTarget(serviceReference, |
| properties, container); |
| } |
| |
| /** |
| * @param serviceReference serviceReference |
| * @param properties properties |
| * @param container container |
| * @return boolean true if match, false otherwise |
| * @since 2.0 |
| */ |
| protected boolean matchHostContainerID(ServiceReference serviceReference, |
| Map<String, Object> properties, IContainer container) { |
| |
| ID containerID = container.getID(); |
| // No match if the container has no ID |
| if (containerID == null) |
| return false; |
| |
| // Then get containerid if specified directly by user in properties |
| ID requiredContainerID = (ID) properties |
| .get(RemoteConstants.SERVICE_EXPORTED_CONTAINER_ID); |
| // If the CONTAINER_I |
| if (requiredContainerID != null) { |
| return requiredContainerID.equals(containerID); |
| } |
| // Else get the container factory arguments, create an ID from the |
| // arguments |
| // and check if the ID matches that |
| Namespace ns = containerID.getNamespace(); |
| Object cid = properties |
| .get(RemoteConstants.SERVICE_EXPORTED_CONTAINER_FACTORY_ARGS); |
| // If no arguments are present, then any container ID should match |
| if (cid == null) |
| return true; |
| ID cID = null; |
| if (cid instanceof ID) { |
| cID = (ID) cid; |
| } else if (cid instanceof String) { |
| cID = IDUtil.createID(ns, (String) cid); |
| } else if (cid instanceof Object[]) { |
| Object cido = ((Object[]) cid)[0]; |
| cID = IDUtil.createID(ns, new Object[] { cido }); |
| } |
| if (cID == null) |
| return true; |
| return containerID.equals(cID); |
| } |
| |
| /** |
| * @param requiredConfigTypes request config types |
| * @param containerTypeDescription container type description |
| * @return boolean true if match, false otherwise |
| */ |
| protected boolean matchHostSupportedConfigTypes( |
| String[] requiredConfigTypes, |
| ContainerTypeDescription containerTypeDescription) { |
| // if no config type is set the spec requires to create a default |
| // endpoint (see section 122.5.1) |
| if (requiredConfigTypes == null) |
| return true; |
| trace("matchHostSupportedConfigTypes","description="+containerTypeDescription.getName()+" testing for requiredConfigTypes"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| // Get supported config types for this description |
| String[] supportedConfigTypes = getSupportedConfigTypes(containerTypeDescription); |
| // If it doesn't support anything, return false |
| if (supportedConfigTypes == null || supportedConfigTypes.length == 0) { |
| trace("matchHostSupportedConfigTypes","No supported configs found for description="+containerTypeDescription.getName()); //$NON-NLS-1$ //$NON-NLS-2$ |
| return false; |
| } |
| // Turn supported config types for this description into list |
| List supportedConfigTypesList = Arrays.asList(supportedConfigTypes); |
| List requiredConfigTypesList = Arrays.asList(requiredConfigTypes); |
| // We check all of the required config types and make sure |
| // that one or more of them are present in the supportedConfigTypes |
| boolean result = false; |
| for (Iterator i = requiredConfigTypesList.iterator(); i.hasNext();) |
| result |= supportedConfigTypesList.contains(i.next()); |
| if (!result) |
| trace("matchHostSupportedConfigTypes","description="+containerTypeDescription.getName()+" does not support all required config types"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| return result; |
| } |
| |
| /** |
| * @param serviceReference service reference |
| * @param properties overriding properties |
| * @param serviceExportedInterfaces service exported interfaces to select for |
| * @param requiredConfigs service exported configs to select for |
| * @param requiredIntents intents to select for |
| * @return Collection of host containers |
| * @throws SelectContainerException if container cannot be created or configured |
| * @since 2.0 |
| */ |
| protected Collection createAndConfigureHostContainers( |
| ServiceReference serviceReference, Map<String, Object> properties, |
| String[] serviceExportedInterfaces, String[] requiredConfigs, |
| String[] serviceIntents) throws SelectContainerException { |
| |
| List results = new ArrayList(); |
| ContainerTypeDescription[] descriptions = getContainerTypeDescriptions(); |
| if (descriptions == null) |
| return Collections.EMPTY_LIST; |
| // Iterate through all descriptions and see if we have a match |
| for (int i = 0; i < descriptions.length; i++) { |
| trace("createAndConfigureHostContainers","Considering description="+descriptions[i]); //$NON-NLS-1$ //$NON-NLS-2$ |
| IRemoteServiceContainer matchingContainer = createMatchingContainer( |
| descriptions[i], serviceReference, properties, |
| serviceExportedInterfaces, requiredConfigs, |
| serviceIntents); |
| if (matchingContainer != null) |
| results.add(matchingContainer); |
| } |
| return results; |
| } |
| |
| protected ContainerTypeDescription[] getContainerTypeDescriptionsForDefaultConfigTypes( |
| ContainerTypeDescription[] descriptions) { |
| String[] defaultConfigTypes = getDefaultConfigTypes(); |
| if (defaultConfigTypes == null || defaultConfigTypes.length == 0) |
| return null; |
| List results = new ArrayList(); |
| for (int i = 0; i < descriptions.length; i++) { |
| // For each description, get supported config types |
| String[] supportedConfigTypes = descriptions[i] |
| .getSupportedConfigs(); |
| if (supportedConfigTypes != null |
| && matchDefaultConfigTypes(defaultConfigTypes, |
| supportedConfigTypes)) |
| results.add(descriptions[i]); |
| } |
| return (ContainerTypeDescription[]) results |
| .toArray(new ContainerTypeDescription[] {}); |
| } |
| |
| protected boolean matchDefaultConfigTypes(String[] defaultConfigTypes, |
| String[] supportedConfigTypes) { |
| List supportedConfigTypesList = Arrays.asList(supportedConfigTypes); |
| for (int i = 0; i < defaultConfigTypes.length; i++) { |
| if (supportedConfigTypesList.contains(defaultConfigTypes[i])) |
| return true; |
| } |
| return false; |
| } |
| |
| protected String[] getDefaultConfigTypes() { |
| return defaultConfigTypes; |
| } |
| |
| /** |
| * @since 4.6 |
| */ |
| protected boolean matchRequireServer(ContainerTypeDescription description) { |
| boolean result = this.defaultRequireServer && description.isServer(); |
| LogUtility.trace("matchRequireServer", DebugOptions.CONTAINER_SELECTOR, this.getClass(), "description="+description.getName()+((result)?" matched require server":" DID NOT match require server")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| return result; |
| } |
| |
| /** |
| * @since 4.6 |
| */ |
| protected boolean matchNotExcluded(ContainerTypeDescription description) { |
| boolean result = this.excludedDescriptions.contains(description.getName()); |
| LogUtility.trace("matchNotExcluded", DebugOptions.CONTAINER_SELECTOR, this.getClass(), "description="+description.getName()+((result)?" EXCLUDED via excludedDescriptions="+this.excludedDescriptions:" not excluded via excludedDescriptions="+this.excludedDescriptions)); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| return !result; |
| } |
| /** |
| * @param containerTypeDescription containerTypeDescription |
| * @param serviceReference reference |
| * @param properties properties |
| * @param serviceExportedInterfaces exported interfaces |
| * @param requiredConfigs configs |
| * @param requiredIntents intents |
| * @return IRemoteServiceContainer matching container created |
| * @throws SelectContainerException container cannot be created or selected |
| * @since 2.0 |
| */ |
| protected IRemoteServiceContainer createMatchingContainer( |
| ContainerTypeDescription containerTypeDescription, |
| ServiceReference serviceReference, Map<String, Object> properties, |
| String[] serviceExportedInterfaces, String[] requiredConfigs, |
| String[] serviceIntents) throws SelectContainerException { |
| |
| if (matchRequireServer(containerTypeDescription) && matchNotExcluded(containerTypeDescription) |
| && matchHostSupportedConfigTypes(requiredConfigs, containerTypeDescription) |
| && matchHostSupportedIntents(serviceIntents, containerTypeDescription)) { |
| return createRSContainer(serviceReference, properties, containerTypeDescription, serviceIntents); |
| } |
| return null; |
| } |
| |
| /** |
| * @param serviceReference serviceReference |
| * @param properties properties |
| * @param containerTypeDescription container type description |
| * @return IRemoteServiceContainer created remote service container |
| * @throws SelectContainerException if could not be created |
| * @since 2.0 |
| */ |
| protected IRemoteServiceContainer createRSContainer( |
| ServiceReference serviceReference, Map<String, Object> properties, |
| ContainerTypeDescription containerTypeDescription) |
| throws SelectContainerException { |
| return createRSContainer(serviceReference, properties, containerTypeDescription, null); |
| } |
| |
| /** |
| * @param serviceReference serviceReference |
| * @param properties properties |
| * @param containerTypeDescription container type description |
| * @return IRemoteServiceContainer created remote service container |
| * @throws SelectContainerException if could not be created |
| * @since 4.6 |
| */ |
| protected IRemoteServiceContainer createRSContainer( |
| ServiceReference serviceReference, Map<String, Object> properties, |
| ContainerTypeDescription containerTypeDescription, String[] intents) |
| throws SelectContainerException { |
| trace("createRSContainer", //$NON-NLS-1$ |
| "Creating container instance for ref=" + serviceReference + ";properties=" + properties //$NON-NLS-1$ //$NON-NLS-2$ |
| + ";description=" + containerTypeDescription.getName() + ";intents=" //$NON-NLS-1$ //$NON-NLS-2$ |
| + ((intents == null) ? "" : Arrays.asList(intents).toString())); //$NON-NLS-1$ |
| IContainer container = createContainer(serviceReference, properties, |
| containerTypeDescription, intents); |
| if (container == null) |
| return null; |
| IRemoteServiceContainerAdapter adapter = (IRemoteServiceContainerAdapter) container |
| .getAdapter(IRemoteServiceContainerAdapter.class); |
| if (adapter == null) { |
| LogUtility.logError("createRSContainer", DebugOptions.CONTAINER_SELECTOR, this.getClass(), "Container="+container.getID()+" does not implement IRemoteServiceContainerAdapter"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| return null; |
| } |
| return new RemoteServiceContainer(container, adapter); |
| } |
| |
| |
| /** |
| * @param serviceReference service reference |
| * @param properties properties |
| * @param container container |
| * @param target target |
| * @throws ContainerConnectException if container cannot be connected |
| * @throws IDCreateException thrown if ID cannot be created |
| * @since 2.0 |
| */ |
| protected void connectHostContainer(ServiceReference serviceReference, |
| Map<String, Object> properties, IContainer container, Object target) |
| throws ContainerConnectException, IDCreateException { |
| ID targetID = (target instanceof String) ? IDUtil.createID( |
| container.getConnectNamespace(), (String) target) : IDUtil |
| .createID(container.getConnectNamespace(), |
| new Object[] { target }); |
| Object context = properties |
| .get(RemoteConstants.SERVICE_EXPORTED_CONTAINER_CONNECT_CONTEXT); |
| IConnectContext connectContext = null; |
| if (context != null) { |
| connectContext = createConnectContext(serviceReference, properties, |
| container, context); |
| } |
| // connect the container |
| container.connect(targetID, connectContext); |
| } |
| |
| protected boolean matchHostSupportedIntents( |
| String[] serviceRequiredIntents, |
| ContainerTypeDescription containerTypeDescription) { |
| return matchHostSupportedIntents(serviceRequiredIntents, containerTypeDescription, null); |
| } |
| |
| /** |
| * @since 4.6 |
| */ |
| protected boolean matchHostSupportedIntents( |
| String[] serviceRequiredIntents, |
| ContainerTypeDescription containerTypeDescription, IContainer container) { |
| // If there are no required intents then we have a match |
| if (serviceRequiredIntents == null) |
| return true; |
| |
| trace("matchHostSupportedIntents","description="+containerTypeDescription.getName()+" testing for serviceRequiredIntents="+Arrays.asList(serviceRequiredIntents)); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| |
| String[] supportedIntents = getSupportedIntents(containerTypeDescription); |
| |
| if (supportedIntents == null) { |
| trace("matchHostSupportedIntents","description="+containerTypeDescription.getName()+" does not have any supported intents"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| return false; |
| } |
| // checks to see that containerTypeDescription supports requiredIntents |
| boolean result = true; |
| for (int i = 0; i < serviceRequiredIntents.length; i++) { |
| boolean found = false; |
| for(String supportedIntent: supportedIntents) |
| if (serviceRequiredIntents[i].equals(supportedIntent) || serviceRequiredIntents[i].startsWith(supportedIntent+".")) {//$NON-NLS-1$ |
| found = true; |
| break; |
| } |
| result &= found; |
| } |
| |
| if (!result) { |
| trace("matchHostSupportedIntents","description="+containerTypeDescription.getName()+" does not have all required intents"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| return false; |
| } |
| |
| // If container is non-null, |
| // check to see that it's ID is private. If it's not private, return null |
| if (container != null) { |
| try { |
| if (ContainerInstantiatorUtils.containsPrivateIntent(serviceRequiredIntents)) |
| ContainerInstantiatorUtils.checkPrivate(container.getID()); |
| } catch (ContainerIntentException e) { |
| trace("matchHostSupportedIntents","container="+container.getID()+" does not have osgi private intent"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| return false; |
| } |
| } |
| |
| if (!result) { |
| trace("matchHostSupportedIntents","container="+container.getID()+" does not have all required intents"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| return result; |
| } |
| |
| } |
