1 files changed, 252 insertions, 0 deletions
diff --git a/sca-java-1.x/tags/1.6.1-TUSCANY-3909/osgi-runtime/src/main/java/org/apache/tuscany/sca/osgi/runtime/OSGiBundleActivator.java b/sca-java-1.x/tags/1.6.1-TUSCANY-3909/osgi-runtime/src/main/java/org/apache/tuscany/sca/osgi/runtime/OSGiBundleActivator.java
new file mode 100644
index 0000000000..b87f70deef
--- /dev/null
+++ b/sca-java-1.x/tags/1.6.1-TUSCANY-3909/osgi-runtime/src/main/java/org/apache/tuscany/sca/osgi/runtime/OSGiBundleActivator.java
@@ -0,0 +1,252 @@
+/*
+ * 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.runtime;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashSet;
+
+import org.apache.tuscany.sca.extensibility.ServiceDiscovery;
+import org.apache.tuscany.sca.extensibility.osgi.OSGiServiceDiscoverer;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.BundleEvent;
+import org.osgi.framework.BundleListener;
+
+/**
+ * OSGi bundle activator, which is run when Tuscany is run inside an OSGi runtime.
+ *
+ * @version $Rev$ $Date$
+ */
+public class OSGiBundleActivator implements BundleActivator, BundleListener {
+
+    private static final String TUSCANY_SCA_BUNDLE_PREFIX = "org.apache.tuscany.sca";
+    private static final String TUSCANY_3RD_PARTY_BUNDLE_PREFIX = "org.apache.tuscany.sca.3rdparty";
+    private OSGiRuntime runtime;
+    /*
+    private ConcurrentHashMap<Bundle, ClassLoader> serviceDiscoveryClassLoaders =
+        new ConcurrentHashMap<Bundle, ClassLoader>();
+    */    
+    private BundleClassLoader threadContextClassLoader;
+    private ClassLoader origTCCL;
+    private Bundle thisBundle;
+
+    public void start(BundleContext bundleContext) throws Exception {
+
+        initializeTuscanyClassLoaders(bundleContext);
+
+        runtime = OSGiRuntime.findRuntime();
+        runtime.setBundleContext(bundleContext);
+        runtime.setContextClassLoader(threadContextClassLoader);
+        runtime.initialize();
+
+    }
+
+    public void stop(BundleContext bundleContext) throws Exception {
+
+        // runtime.shutdown();
+
+        if (Thread.currentThread().getContextClassLoader() == threadContextClassLoader)
+            Thread.currentThread().setContextClassLoader(origTCCL);
+    }
+
+    /**
+     * Create a bundle ClassLoader which has visibility of all Tuscany related
+     * bundles. Use this ClassLoader as TCCL, and the Tuscany service discovery
+     * ClassLoader.
+     * 
+     * @param bundleContext
+     */
+    private void initializeTuscanyClassLoaders(BundleContext bundleContext) {
+
+        OSGiServiceDiscoverer discoverer = new OSGiServiceDiscoverer(bundleContext);
+        ServiceDiscovery.getInstance().setServiceDiscoverer(discoverer);
+        thisBundle = bundleContext.getBundle();
+
+        origTCCL = Thread.currentThread().getContextClassLoader();
+
+        threadContextClassLoader = new BundleClassLoader(thisBundle, origTCCL);
+
+        Thread.currentThread().setContextClassLoader(threadContextClassLoader);
+
+        ClassLoader cl = new BundleClassLoader(thisBundle, null);
+        // ServiceDiscovery.getInstance().registerClassLoader(cl);
+        // serviceDiscoveryClassLoaders.put(thisBundle, cl);
+
+        Bundle[] bundles = bundleContext.getBundles();
+        for (Bundle bundle : bundles) {
+            updateBundleClassLoader(bundle);
+        }
+        bundleContext.addBundleListener(this);
+
+    }
+
+    /**
+     * Add an installed bundle to the list of bundles in the service discovery classpath
+     * if the installed bundle is a Tuscany bundle using the same Core-SPI bundle.
+     * Since the bundle containing this activator is in Tuscany Runtime, this bundle
+     * will provide access to Runtime and its dependencies (SPI, SCA-API). Third party
+     * bundles don't need to be in the service discovery classpath, since they will be automatically
+     * imported by bundles which require them. That leaves Tuscany extension bundles,
+     * which are added to the service discovery classpath here.
+     * 
+     * 3rd party bundle should be explicitly added to TCCL since classes from these
+     * bundles use TCCL to load other classes from the bundle.
+     * 
+     * Load one class from the bundle to check if the new bundle matches this runtime bundle.
+     * 
+     * @param bundle
+     */
+    private void updateBundleClassLoader(Bundle bundle) {
+
+        if (bundle.getSymbolicName().startsWith(TUSCANY_SCA_BUNDLE_PREFIX)) {
+
+            // This may be the third party bundle.
+            if (bundle.getSymbolicName().startsWith(TUSCANY_3RD_PARTY_BUNDLE_PREFIX)) {
+
+                threadContextClassLoader.addBundle(bundle);
+            } else {
+
+                String thisBundleVersion = (String)thisBundle.getHeaders().get("Bundle-Version");
+                String bundleVersion = (String)bundle.getHeaders().get("Bundle-Version");
+
+                if (thisBundleVersion == null || bundleVersion == null || thisBundleVersion.equals(bundleVersion)) {
+
+                    if (!threadContextClassLoader.bundles.contains(bundle)) {
+                        ClassLoader cl = new BundleClassLoader(bundle, null);
+                        // ServiceDiscovery.getInstance().registerClassLoader(cl);
+                        // serviceDiscoveryClassLoaders.put(bundle, cl);
+                        threadContextClassLoader.addBundle(bundle);
+                    }
+                }
+            }
+        } else {
+            threadContextClassLoader.addBundle(bundle);
+        }
+    }
+
+    /**
+     * Handle bundle install/uninstall events 
+     */
+    public void bundleChanged(BundleEvent event) {
+
+        Bundle bundle = event.getBundle();
+        if (event.getType() == BundleEvent.UNINSTALLED) {
+//            ClassLoader cl = serviceDiscoveryClassLoaders.get(bundle);
+//            if (cl != null) {
+//                ServiceDiscovery.getInstance().unregisterClassLoader(cl);
+//            }
+            threadContextClassLoader.removeBundle(bundle);
+        } else if (event.getType() == BundleEvent.INSTALLED) {
+            updateBundleClassLoader(bundle);
+        }
+    }
+
+    /**
+     * Bundle ClassLoader that searches a bundle classpath consisting of
+     * a list of bundles. The parent ClassLoader is searched only if a class
+     * cannot be loaded from the bundle classpath. Tuscany bundles are
+     * dynamically added and removed from the bundle classpath when the bundles
+     * are installed and uninstalled.
+     * 
+     * No ordering of bundles is maintained at the moment.
+     *
+     */
+    private static class BundleClassLoader extends ClassLoader {
+
+        private HashSet<Bundle> bundles;
+
+        BundleClassLoader(Bundle bundle, ClassLoader parent) {
+            super(parent);
+            this.bundles = new HashSet<Bundle>();
+            bundles.add(bundle);
+        }
+
+        private synchronized void addBundle(Bundle bundle) {
+            bundles.add(bundle);
+        }
+
+        private synchronized void removeBundle(Bundle bundle) {
+            if (bundles.contains(bundle))
+                bundles.remove(bundle);
+        }
+
+        @Override
+        protected Class<?> findClass(String className) throws ClassNotFoundException {
+            Class<?> clazz = null;
+            synchronized (this) {
+                for (Bundle bundle : bundles) {
+                    try {
+                        clazz = bundle.loadClass(className);
+                        break;
+                    } catch (ClassNotFoundException e) {
+                    } catch (NoClassDefFoundError e) {
+                    }
+
+                }
+            }
+            if (clazz != null) {
+                return clazz;
+            }
+            return super.findClass(className);
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public Enumeration<URL> getResources(String resName) throws IOException {
+            HashSet<URL> urlSet = new HashSet<URL>();
+            Enumeration<URL> urls = null;
+            synchronized (this) {
+                for (Bundle bundle : bundles) {
+                    urls = bundle.getResources(resName);
+                    if (urls != null) {
+                        while (urls.hasMoreElements()) {
+                            urlSet.add(urls.nextElement());
+                        }
+                    }
+                }
+            }
+            if (urlSet.size() > 0)
+                return Collections.enumeration(urlSet);
+            return super.getResources(resName);
+        }
+
+        @Override
+        public URL getResource(String resName) {
+            URL url = null;
+            synchronized (this) {
+                for (Bundle bundle : bundles) {
+                    url = bundle.getResource(resName);
+                    if (url != null)
+                        return url;
+                }
+            }
+            return super.getResource(resName);
+        }
+
+        @Override
+        public String toString() {
+            return "Tuscany BundleClassLoader " + bundles.iterator().next();
+        }
+
+    }
+}