1 files changed, 550 insertions, 0 deletions
diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/node-impl-osgi/src/main/java/org/apache/tuscany/sca/osgi/remoteserviceadmin/impl/EndpointIntrospector.java b/sca-java-2.x/tags/2.0.1-RC1/modules/node-impl-osgi/src/main/java/org/apache/tuscany/sca/osgi/remoteserviceadmin/impl/EndpointIntrospector.java
new file mode 100644
index 0000000000..d00696a822
--- /dev/null
+++ b/sca-java-2.x/tags/2.0.1-RC1/modules/node-impl-osgi/src/main/java/org/apache/tuscany/sca/osgi/remoteserviceadmin/impl/EndpointIntrospector.java
@@ -0,0 +1,550 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.osgi.remoteserviceadmin.impl;
+
+import static org.apache.tuscany.sca.assembly.Base.SCA11_TUSCANY_NS;
+import static org.apache.tuscany.sca.implementation.osgi.OSGiProperty.SCA_BINDINGS;
+import static org.apache.tuscany.sca.osgi.remoteserviceadmin.impl.OSGiHelper.createOSGiProperty;
+import static org.apache.tuscany.sca.osgi.remoteserviceadmin.impl.OSGiHelper.getStringArray;
+import static org.osgi.framework.Constants.OBJECTCLASS;
+import static org.osgi.framework.Constants.SERVICE_ID;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Base;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentReference;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.Endpoint;
+import org.apache.tuscany.sca.assembly.Reference;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.ContributionFactory;
+import org.apache.tuscany.sca.contribution.processor.ContributionReadException;
+import org.apache.tuscany.sca.contribution.processor.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.resolver.ExtensibleModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolverExtensionPoint;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.FactoryExtensionPoint;
+import org.apache.tuscany.sca.core.UtilityExtensionPoint;
+import org.apache.tuscany.sca.deployment.Deployer;
+import org.apache.tuscany.sca.implementation.osgi.OSGiImplementation;
+import org.apache.tuscany.sca.implementation.osgi.OSGiImplementationFactory;
+import org.apache.tuscany.sca.implementation.osgi.OSGiProperty;
+import org.apache.tuscany.sca.implementation.osgi.SCAConfig;
+import org.apache.tuscany.sca.implementation.osgi.ServiceDescriptionsFactory;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.osgi.service.discovery.impl.LocalDiscoveryService;
+import org.apache.tuscany.sca.osgi.service.discovery.impl.LocalDiscoveryService.ExtenderConfiguration;
+import org.apache.tuscany.sca.policy.Intent;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.oasisopen.sca.ServiceRuntimeException;
+import org.oasisopen.sca.annotation.PolicySets;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.osgi.service.remoteserviceadmin.EndpointDescription;
+import org.osgi.service.remoteserviceadmin.RemoteConstants;
+import org.osgi.util.tracker.ServiceTracker;
+
+/**
+ * Introspect an OSGi Service to create an SCA composite that contains a single component with
+ * implementation.osgi
+ */
+public class EndpointIntrospector {
+    // private BundleContext context;
+    private AssemblyFactory assemblyFactory;
+    private ContributionFactory contributionFactory;
+    private OSGiImplementationFactory implementationFactory;
+    private PolicyFactory policyFactory;
+    private ExtensionPointRegistry registry;
+    private FactoryExtensionPoint factories;
+    private ModelResolverExtensionPoint modelResolvers;
+    // private StAXArtifactProcessor<Composite> compositeProcessor;
+    private JavaInterfaceFactory javaInterfaceFactory;
+    private Deployer deployer;
+    private ServiceTracker discoveryTracker;
+
+    /**
+     * @param name
+     * @return
+     */
+    private static QName getQName(String name) {
+        QName qname;
+        if (name.startsWith("{")) {
+            int i = name.indexOf('}');
+            if (i != -1) {
+                qname = new QName(name.substring(1, i), name.substring(i + 1));
+            } else {
+                throw new IllegalArgumentException("Invalid qname: " + name);
+            }
+        } else {
+            // Default to SCA namespace
+            qname = new QName("", name);
+        }
+        return qname;
+    }
+
+    /**
+     * @param context TODO
+     * @param registry
+     */
+    public EndpointIntrospector(BundleContext context, ExtensionPointRegistry registry, ServiceTracker discoveryTracker) {
+        super();
+        this.registry = registry;
+        // this.context = context;
+        this.discoveryTracker = discoveryTracker;
+        this.factories = registry.getExtensionPoint(FactoryExtensionPoint.class);
+        this.modelResolvers = registry.getExtensionPoint(ModelResolverExtensionPoint.class);
+//        this.compositeProcessor =
+//            registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class).getProcessor(Composite.class);
+        this.assemblyFactory = factories.getFactory(AssemblyFactory.class);
+        this.contributionFactory = factories.getFactory(ContributionFactory.class);
+        this.policyFactory = factories.getFactory(PolicyFactory.class);
+        this.implementationFactory = factories.getFactory(OSGiImplementationFactory.class);
+        this.javaInterfaceFactory = factories.getFactory(JavaInterfaceFactory.class);
+        this.deployer = registry.getExtensionPoint(UtilityExtensionPoint.class).getUtility(Deployer.class);
+    }
+
+    private Intent getIntent(String intent) {
+        QName name = getQName(intent);
+        Intent i = policyFactory.createIntent();
+        i.setName(name);
+        return i;
+    }
+
+    private List<Intent> getIntents(String[] intents) {
+        if (intents == null || intents.length == 0) {
+            return Collections.emptyList();
+        }
+        List<Intent> intentList = new ArrayList<Intent>();
+        for (String i : intents) {
+            Intent intent = getIntent(i);
+            if (intent != null) {
+                intentList.add(intent);
+            }
+        }
+        return intentList;
+    }
+
+    /**
+     * Any property in the map overrides the service reference properties, regardless of
+     * case. That is, if the map contains a key then it will override any case variant
+     * of this key in the Service Reference.<p>
+     * If the map contains the objectClass or service. id property key in any case
+     * variant, then these properties must not override the Service References value. This 
+     * implies that the map can provide the service.exported. interfaces, property allowing 
+     * the Topology Manager to export any registered service, also services not specifically 
+     * marked to be exported.
+     * @param reference
+     * @param props
+     * @return
+     */
+    private Map<String, Object> getProperties(ServiceReference reference, Map<String, Object> props) {
+        String[] names = reference.getPropertyKeys();
+        Map<String, Object> properties = new HashMap<String, Object>();
+        if (names != null) {
+            for (String name : names) {
+                properties.put(name, reference.getProperty(name));
+            }
+        }
+        if (props != null) {
+            // Create a map of names (key = lowcase name, value = name)
+            Map<String, String> nameMap = new HashMap<String, String>();
+            if (names != null) {
+                for (String name : names) {
+                    nameMap.put(name.toLowerCase(), name);
+                }
+            }
+            for (Map.Entry<String, Object> p : props.entrySet()) {
+                if (OBJECTCLASS.equalsIgnoreCase(p.getKey())) {
+                    throw new IllegalArgumentException(OBJECTCLASS + " property cannot be overridden.");
+                } else if (SERVICE_ID.equalsIgnoreCase(p.getKey())) {
+                    throw new IllegalArgumentException(SERVICE_ID + " property cannot be overridden.");
+                }
+                String key = nameMap.get(p.getKey().toLowerCase());
+                if (key != null) {
+                    properties.put(key, p.getValue());
+                } else {
+                    properties.put(p.getKey(), p.getValue());
+                }
+            }
+        }
+        return properties;
+    }
+
+    /**
+     * Parse the Stringp[] to support values that are separated by comma
+     * @param interfaces
+     * @return
+     */
+    private String[] parse(String[] interfaces) {
+        if (interfaces == null) {
+            return null;
+        }
+        List<String> names = new ArrayList<String>();
+        for (String i : interfaces) {
+            String[] parts = i.split(",");
+            for (String p : parts) {
+                names.add(p.trim());
+            }
+        }
+        return names.toArray(new String[names.size()]);
+    }
+
+    /**
+     * Introspect a local OSGi Service represented by the ServiceReference to create 
+     * an SCA service with the required intents and bindings 
+     * @param reference The service reference for a local OSGi service 
+     * @param props Addiontal properties
+     * @return An SCA contribution with a deployable composite for the SCA service
+     * @throws Exception
+     */
+    public Contribution introspect(ServiceReference reference, Map<String, Object> props) throws Exception {
+        Bundle bundle = reference.getBundle();
+        Map<String, Object> properties = getProperties(reference, props);
+        Collection<OSGiProperty> osgiProps = implementationFactory.createOSGiProperties(reference);
+        Long sid = (Long)reference.getProperty(SERVICE_ID);
+
+        String[] requiredIntents = getStringArray(properties.get(RemoteConstants.SERVICE_EXPORTED_INTENTS));
+        List<Intent> intents = getIntents(requiredIntents);
+        String[] requiredIntentsExtra = getStringArray(properties.get(RemoteConstants.SERVICE_EXPORTED_INTENTS_EXTRA));
+        List<Intent> extraIntents = getIntents(requiredIntentsExtra);
+        Set<Intent> allIntents = new HashSet<Intent>(intents);
+        allIntents.addAll(extraIntents);
+
+        String[] bindingNames = getStringArray(properties.get(SCA_BINDINGS));
+        Collection<Binding> bindings = loadBindings(bindingNames);
+
+        String[] remoteInterfaces = getStringArray(reference.getProperty(RemoteConstants.SERVICE_EXPORTED_INTERFACES));
+        if (remoteInterfaces == null || remoteInterfaces.length > 0 && "*".equals(remoteInterfaces[0])) {
+            remoteInterfaces = getStringArray(reference.getProperty(OBJECTCLASS));
+        } else {
+            remoteInterfaces = parse(remoteInterfaces);
+            String[] objectClasses = getStringArray(reference.getProperty(OBJECTCLASS));
+            Set<String> objectClassSet = new HashSet<String>(Arrays.asList(objectClasses));
+            if (!objectClassSet.containsAll(Arrays.asList(remoteInterfaces))) {
+                throw new IllegalArgumentException(
+                                                   "The exported interfaces are not a subset of the types" + " listed in the objectClass service property from the Service Reference");
+            }
+        }
+
+        Contribution contribution = generateContribution(bundle, sid, remoteInterfaces, bindings, allIntents, osgiProps);
+        return contribution;
+    }
+    
+    public String instrospectSCAConfig(ServiceReference reference, Map<String, Object> props, ComponentService service){
+        
+        ServiceDescriptionsFactory serviceDescriptionFactory = registry.getExtensionPoint(ServiceDescriptionsFactory.class);
+        SCAConfig scaConfig = serviceDescriptionFactory.createSCAConfig();
+        
+        // add the binding configurations
+        List<Binding> bindings = scaConfig.getBindings();
+        bindings.addAll(service.getBindings());
+        
+        // add the intent configurations
+        List<Intent> intents = scaConfig.getIntents();
+        intents.addAll(service.getRequiredIntents());
+        
+        // add the policy set configurations
+        List<PolicySet> policySets = scaConfig.getPolicySets();
+        policySets.addAll(service.getPolicySets());
+        
+        // set up the target namespace
+        // TODO - there is a bug in the spec which only allow bindings from one
+        //        namsepace to be included in sca-config element. Here we just 
+        //        the first bindings namespace
+        Map<String, Object> properties = getProperties(reference, props);
+        String[] bindingNames = getStringArray(properties.get(SCA_BINDINGS));
+        if (bindingNames.length > 0){
+            QName firstBindingQName = getQName(bindingNames[0]);
+            scaConfig.setTargetNamespace(firstBindingQName.getNamespaceURI());
+        }        
+        
+        // write the sca config out to XML
+        String scaConfigXMLString = "";
+        
+        try {
+            Writer writer = new StringWriter();
+            deployer.saveXMLDocument(scaConfig, writer, deployer.createMonitor());
+            scaConfigXMLString = writer.toString();
+        } catch (Exception ex){
+            throw new ServiceRuntimeException(ex);
+        }
+        
+        return scaConfigXMLString;
+    }    
+    
+    /*
+    public Contribution loadContribution(Bundle bundle, Composite composite) {
+        try {
+            URL root = bundle.getEntry("/");
+            Contribution contribution = deployer.loadContribution(root.toURI(), root, deployer.createMonitor());
+            deployer.attachDeploymentComposite(contribution, composite, false);
+            return contribution;
+        } catch (Exception e) {
+            throw new ServiceRuntimeException(e);
+        }
+    }
+    */
+
+    /**
+     * Generate a contribution that contains the composite for the exported service
+     * @param bundle The OSGi bundle
+     * @param sid The service id
+     * @param remoteInterfaces 
+     * @param bindings
+     * @param allIntents
+     * @return
+     * @throws ClassNotFoundException
+     * @throws InvalidInterfaceException
+     */
+    private Contribution generateContribution(Bundle bundle,
+                                              Long sid,
+                                              String[] remoteInterfaces,
+                                              Collection<Binding> bindings,
+                                              Set<Intent> allIntents,
+                                              Collection<OSGiProperty> osgiProps) throws ClassNotFoundException,
+        InvalidInterfaceException {
+        String id = "osgi.service." + UUID.randomUUID();
+        Composite composite = assemblyFactory.createComposite();
+        composite.setName(new QName(SCA11_TUSCANY_NS, id));
+
+        Component component = assemblyFactory.createComponent();
+        component.setName(id);
+
+        composite.getComponents().add(component);
+
+        OSGiImplementation implementation = implementationFactory.createOSGiImplementation();
+
+        implementation.setBundle(bundle);
+        component.setImplementation(implementation);
+        implementation.setUnresolved(false);
+
+        OSGiProperty serviceID = implementationFactory.createOSGiProperty();
+        serviceID.setName(SERVICE_ID);
+        // The service.id is Long
+        serviceID.setValue(String.valueOf(sid));
+
+        for (String intf : remoteInterfaces) {
+            Service service = assemblyFactory.createService();
+            JavaInterfaceContract interfaceContract = createJavaInterfaceContract(bundle, intf);
+            String name = intf.substring(intf.lastIndexOf('.') + 1);
+            service.setName(name);
+            service.setInterfaceContract(interfaceContract);
+
+            implementation.getServices().add(service);
+
+            ComponentService componentService = assemblyFactory.createComponentService();
+            componentService.setName(service.getName());
+            componentService.getExtensions().add(serviceID);
+            componentService.getExtensions().addAll(osgiProps);
+
+            component.getServices().add(componentService);
+            componentService.setService(service);
+        }
+
+        for (ComponentService componentService : component.getServices()) {
+            componentService.getRequiredIntents().addAll(allIntents);
+            componentService.getBindings().addAll(bindings);
+        }
+
+        // FIXME: Should we scan the owning bundle to create the SCA contribution?
+        Contribution contribution = loadContribution(bundle, id, composite);
+        return contribution;
+    }
+
+    private Contribution loadContribution(Bundle bundle, String id, Composite composite) {
+        Contribution contribution = contributionFactory.createContribution();
+        contribution.setClassLoader(OSGiHelper.createBundleClassLoader(bundle));
+        contribution.setURI(id);
+        contribution.setLocation(bundle.getEntry("/").toString());
+        deployer.attachDeploymentComposite(contribution, composite, false);
+        ModelResolver modelResolver = new ExtensibleModelResolver(contribution, modelResolvers, factories);
+        contribution.setModelResolver(modelResolver);
+        // compositeProcessor.resolve(composite, modelResolver, new ProcessorContext(registry));
+        contribution.setUnresolved(true);
+        return contribution;
+    }
+
+    /**
+     * @param bundle
+     * @param endpoint
+     * @return
+     * @throws Exception
+     */
+    public Contribution introspect(Bundle bundle, EndpointDescription endpoint) throws Exception {
+        Collection<Binding> bindings = Collections.emptyList();
+        Collection<String> interfaces = Collections.emptyList();
+        Collection<Intent> intents = Collections.emptyList();
+        Endpoint ep = (Endpoint)endpoint.getProperties().get(Endpoint.class.getName());
+        Collection<OSGiProperty> osgiProps = implementationFactory.createOSGiProperties(endpoint.getProperties());
+        if (ep != null) {
+            bindings = Collections.singletonList(ep.getBinding());
+            interfaces = Collections.singletonList(((JavaInterface)ep.getComponentServiceInterfaceContract().getInterface()).getName());
+            // FIXME: [rfeng] We need to build the in-memory composite so that intents are calculated at the ep level
+            intents = ep.getService().getRequiredIntents();
+        } else {
+            Map<String, Object> properties = endpoint.getProperties();
+            interfaces = endpoint.getInterfaces();
+            String[] requiredIntents = getStringArray(properties.get(RemoteConstants.SERVICE_INTENTS));
+            intents = getIntents(requiredIntents);
+
+            String[] bindingNames = getStringArray(properties.get(SCA_BINDINGS));
+            bindings = loadBindings(bindingNames);
+        }
+
+        Contribution contribution = generateContribution(bundle, interfaces, bindings, intents, osgiProps);
+        return contribution;
+    }
+
+    private Contribution generateContribution(Bundle bundle,
+                                              Collection<String> remoteInterfaces,
+                                              Collection<Binding> bindings,
+                                              Collection<Intent> intents,
+                                              Collection<OSGiProperty> osgiProps) throws ClassNotFoundException,
+        InvalidInterfaceException, ContributionResolveException {
+        String id = "osgi.reference." + UUID.randomUUID();
+        Composite composite = assemblyFactory.createComposite();
+        composite.setName(new QName(Base.SCA11_TUSCANY_NS, id));
+
+        Component component = assemblyFactory.createComponent();
+        component.setName(id);
+        // component.setAutowire(Boolean.TRUE);
+
+        composite.getComponents().add(component);
+
+        OSGiImplementation implementation = implementationFactory.createOSGiImplementation();
+
+        implementation.setBundle(bundle);
+        component.setImplementation(implementation);
+        implementation.setUnresolved(false);
+
+        int count = 0;
+        for (String intf : remoteInterfaces) {
+            Reference reference = assemblyFactory.createReference();
+            JavaInterfaceContract interfaceContract = createJavaInterfaceContract(bundle, intf);
+
+            reference.setName("ref" + (count++));
+            reference.setInterfaceContract(interfaceContract);
+
+            implementation.getReferences().add(reference);
+
+            ComponentReference componentReference = assemblyFactory.createComponentReference();
+            componentReference.setName(reference.getName());
+            componentReference.getExtensions().addAll(osgiProps);
+            component.getReferences().add(componentReference);
+            componentReference.setReference(reference);
+            componentReference.setWiredByImpl(true);
+        }
+
+        for (ComponentReference componentReference : component.getReferences()) {
+            componentReference.getRequiredIntents().addAll(intents);
+            componentReference.getBindings().addAll(bindings);
+        }
+
+        Contribution contribution = loadContribution(bundle, id, composite);
+        return contribution;
+    }
+
+    private JavaInterfaceContract createJavaInterfaceContract(Bundle bundle, String intf)
+        throws ClassNotFoundException, InvalidInterfaceException {
+        JavaInterfaceContract interfaceContract = javaInterfaceFactory.createJavaInterfaceContract();
+        Class<?> interfaceClass = bundle.loadClass(intf);
+        JavaInterface javaInterface = javaInterfaceFactory.createJavaInterface();
+        // [rfeng] For OSGi, the interfaces should be marked as remotable
+        javaInterface.setRemotable(true);
+        // [rfeng] We need to mark the interface to be remotable before the createJavaInterface() is called 
+        javaInterfaceFactory.createJavaInterface(javaInterface, interfaceClass);
+        interfaceContract.setInterface(javaInterface);
+        if (javaInterface.getCallbackClass() != null) {
+            JavaInterface callbackInterface = javaInterfaceFactory.createJavaInterface(javaInterface.getCallbackClass());
+            callbackInterface.setRemotable(true);
+            interfaceContract.setCallbackInterface(callbackInterface);
+        }
+        return interfaceContract;
+    }
+
+    private Collection<Binding> loadBindings(String[] qnames) throws IOException, ContributionReadException,
+        XMLStreamException {
+        if (qnames == null || qnames.length == 0) {
+            return Collections.emptyList();
+        }
+        QName[] bindingNames = new QName[qnames.length];
+        int index = 0;
+        for (String name : qnames) {
+            bindingNames[index++] = getQName(name);
+        }
+
+        LocalDiscoveryService discoveryService = (LocalDiscoveryService)discoveryTracker.getService();
+
+        Map<QName, Binding> bindingMap = new HashMap<QName, Binding>();
+        if (discoveryService != null) {
+            for (ExtenderConfiguration config : discoveryService.getConfigurations()) {
+                for (SCAConfig sc : config.getSCAConfigs()) {
+                    for (QName bindingName : bindingNames) {
+                        if ("".equals(bindingName.getNamespaceURI()) || 
+                            sc.getTargetNamespace().equals(bindingName.getNamespaceURI())) {
+                            for (Binding binding : sc.getBindings()) {
+                                if (bindingName.getLocalPart().equals(binding.getName())) {
+                                    // We need to check duplications
+                                    if (bindingMap.put(bindingName, binding) != null) {
+                                        throw new ServiceRuntimeException("Duplicate binding found: " + bindingName);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (QName bindingName : bindingNames) {
+            if (!bindingMap.containsKey(bindingName)) {
+                throw new ServiceRuntimeException("Binding cannot be resolved: " + bindingName);
+            }
+        }
+        return bindingMap.values();
+    }
+
+}