/******************************************************************************* | |
* Copyright (c) 2010-2011 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.Arrays; | |
import java.util.Dictionary; | |
import java.util.Iterator; | |
import java.util.List; | |
import java.util.Map; | |
import org.eclipse.ecf.core.ContainerConnectException; | |
import org.eclipse.ecf.core.ContainerCreateException; | |
import org.eclipse.ecf.core.ContainerTypeDescription; | |
import org.eclipse.ecf.core.IContainer; | |
import org.eclipse.ecf.core.IContainerFactory; | |
import org.eclipse.ecf.core.identity.ID; | |
import org.eclipse.ecf.core.security.IConnectContext; | |
import org.eclipse.ecf.internal.osgi.services.remoteserviceadmin.PropertiesUtil; | |
import org.eclipse.ecf.remoteservice.IRemoteServiceContainer; | |
import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter; | |
import org.eclipse.ecf.remoteservice.RemoteServiceContainer; | |
/** | |
* Abstract superclass for consumer container selectors...i.e. implementers of | |
* {@link IConsumerContainerSelector}). | |
* | |
*/ | |
public class AbstractConsumerContainerSelector extends | |
AbstractContainerSelector { | |
protected IRemoteServiceContainer selectExistingConsumerContainer( | |
ID endpointID, String[] remoteSupportedConfigs, ID connectTargetID) { | |
// Get all containers available | |
IContainer[] containers = getContainers(); | |
// If none then return null | |
if (containers == null) | |
return null; | |
for (int i = 0; i < containers.length; i++) { | |
// Do *not* include containers with same ID as endpointID | |
if (matchContainerID(containers[i], endpointID)) | |
continue; | |
IRemoteServiceContainerAdapter adapter = hasRemoteServiceContainerAdapter(containers[i]); | |
// Container must have adapter | |
if (adapter != null | |
// And it must match the connect namespace | |
&& matchConnectNamespace(containers[i], endpointID, | |
connectTargetID) | |
// and it must match the configs | |
&& matchSupportedConfigs(containers[i], | |
remoteSupportedConfigs) | |
// and the container should either not be connected or | |
// already be connected to the desired endpointID | |
&& matchNotConnected(containers[i], endpointID, | |
connectTargetID)) { | |
trace("selectExistingConsumerContainer", //$NON-NLS-1$ | |
"MATCH of existing remote service container id=" //$NON-NLS-1$ | |
+ containers[i].getID() | |
+ " endpointID=" //$NON-NLS-1$ | |
+ endpointID | |
+ " remoteSupportedConfigs=" //$NON-NLS-1$ | |
+ ((remoteSupportedConfigs == null) ? "[]" //$NON-NLS-1$ | |
: Arrays.asList(remoteSupportedConfigs) | |
.toString())); | |
return new RemoteServiceContainer(containers[i], adapter); | |
} else { | |
trace("selectExistingConsumerContainer", //$NON-NLS-1$ | |
"No match of existing remote service container id=" //$NON-NLS-1$ | |
+ containers[i].getID() | |
+ " endpointID=" //$NON-NLS-1$ | |
+ endpointID | |
+ " remoteSupportedConfigs=" //$NON-NLS-1$ | |
+ ((remoteSupportedConfigs == null) ? "[]" //$NON-NLS-1$ | |
: Arrays.asList(remoteSupportedConfigs) | |
.toString())); | |
} | |
} | |
return null; | |
} | |
protected boolean matchNotConnected(IContainer container, ID endpointID, | |
ID connectTargetID) { | |
// if the container is not connected, OR it's connected to the desired | |
// endpointID already then we've got a match | |
ID connectedID = container.getConnectedID(); | |
if (connectedID == null || connectedID.equals(endpointID) | |
|| connectedID.equals(connectTargetID)) | |
return true; | |
return false; | |
} | |
protected boolean matchSupportedConfigs(IContainer container, | |
String[] remoteSupportedConfigs) { | |
if (remoteSupportedConfigs == null) | |
return false; | |
ContainerTypeDescription description = getContainerTypeDescription(container); | |
if (description == null) | |
return false; | |
return description.getImportedConfigs(remoteSupportedConfigs) != null; | |
} | |
protected void connectContainerToTarget( | |
IRemoteServiceContainer rsContainer, ID connectTargetID) { | |
if (connectTargetID == null) | |
return; | |
IContainer container = rsContainer.getContainer(); | |
ID connectedID = container.getConnectedID(); | |
// Only connect the container to the connect target when | |
// it's not already connected | |
if (connectedID == null) { | |
// connect to target | |
try { | |
connectContainer(container, connectTargetID, | |
getConnectContext(container, connectTargetID)); | |
} catch (ContainerConnectException e) { | |
logException("Exception connecting container id=" //$NON-NLS-1$ | |
+ container.getID() + " to connectTargetID=" //$NON-NLS-1$ | |
+ connectTargetID, e); | |
} | |
} | |
} | |
protected IConnectContext getConnectContext(IContainer container, | |
ID connectTargetID) { | |
return null; | |
} | |
protected IRemoteServiceContainer createAndConfigureConsumerContainer( | |
String[] remoteSupportedConfigs, Map remoteExportedProperties) | |
throws SelectContainerException { | |
if (remoteSupportedConfigs == null | |
|| remoteSupportedConfigs.length == 0) | |
return null; | |
// Get container factory | |
IContainerFactory containerFactory = getContainerFactory(); | |
if (containerFactory == null) | |
return null; | |
// Get all container type descriptions from factory | |
List containerTypeDescriptions = containerFactory.getDescriptions(); | |
if (containerTypeDescriptions == null) | |
return null; | |
// Go through all containerTypeDescriptions | |
for (Iterator i = containerTypeDescriptions.iterator(); i.hasNext();) { | |
ContainerTypeDescription desc = (ContainerTypeDescription) i.next(); | |
// For each one, get the localImportedConfigs for the remote | |
// supported configs | |
String[] localImportedConfigs = desc | |
.getImportedConfigs(remoteSupportedConfigs); | |
// If their are some local imported configs for this description | |
if (localImportedConfigs != null) { | |
// Then get the imported config properties | |
Dictionary importedConfigProperties = desc | |
.getPropertiesForImportedConfigs( | |
localImportedConfigs, | |
PropertiesUtil | |
.createDictionaryFromMap(remoteExportedProperties)); | |
// Then select a specific local imported config (typically the | |
// first on in the array) | |
String selectedConfig = selectLocalImportedConfig( | |
localImportedConfigs, importedConfigProperties); | |
// If we have one to use, then create the container | |
if (selectedConfig != null) { | |
IRemoteServiceContainer rsContainer = createContainer( | |
desc, | |
selectedConfig, | |
PropertiesUtil | |
.createMapFromDictionary(importedConfigProperties)); | |
if (rsContainer != null) { | |
trace("createAndConfigureProxyContainers", //$NON-NLS-1$ | |
"created new proxy container with config type=" //$NON-NLS-1$ | |
+ selectedConfig + " and id=" //$NON-NLS-1$ | |
+ rsContainer.getContainer().getID()); | |
return rsContainer; | |
} | |
} | |
} | |
} | |
return null; | |
} | |
protected IRemoteServiceContainer createContainer( | |
ContainerTypeDescription containerTypeDescription, | |
String containerTypeDescriptionName, Map properties) | |
throws SelectContainerException { | |
try { | |
IContainer container = (properties == null) ? getContainerFactory() | |
.createContainer(containerTypeDescriptionName) | |
: getContainerFactory().createContainer( | |
containerTypeDescriptionName, properties); | |
IRemoteServiceContainerAdapter adapter = (IRemoteServiceContainerAdapter) container | |
.getAdapter(IRemoteServiceContainerAdapter.class); | |
if (adapter == null) | |
throw new SelectContainerException( | |
"Container does not implement IRemoteServiceContainerAdapter", null, containerTypeDescription); //$NON-NLS-1$ | |
return new RemoteServiceContainer(container); | |
} catch (ContainerCreateException e) { | |
String message = "Cannot create container with container type description name=" //$NON-NLS-1$ | |
+ containerTypeDescriptionName; | |
logException(message, e); | |
throw new SelectContainerException(message, e, | |
containerTypeDescription); | |
} | |
} | |
protected String selectLocalImportedConfig(String[] localConfigTypes, | |
Dictionary importedConfigProperties) { | |
if (localConfigTypes == null || localConfigTypes.length == 0) | |
return null; | |
// By default, we'll select the first config to use... | |
return localConfigTypes[0]; | |
} | |
} |