Attachment #223234 for bug #356683

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 96-102 public class ChainedClassLoaderTest extends TestCase { Link Here

(-)a/core/src/test/java/org/eclipse/gemini/blueprint/context/internal/classloader/ChainedClassLoaderTest.java (-1 lines)
96	}	96	}
97		97
98	public void testGetResourceString() throws Exception {	98	public void testGetResourceString() throws Exception {
99	System.out.println(chainedLoader.getResource("java/lang/Object.class"));
100	assertNull(chainedLoader.getResource("java/lang/Object.class"));	99	assertNull(chainedLoader.getResource("java/lang/Object.class"));
101	chainedLoader.addClassLoader(Object.class);	100	chainedLoader.addClassLoader(Object.class);
102	assertNotNull(chainedLoader.getResource("java/lang/Object.class"));	101	assertNotNull(chainedLoader.getResource("java/lang/Object.class"));

Lines 44-50 public class ConfigLocationsTest extends TestCase { Link Here

(-)a/core/src/test/java/org/eclipse/gemini/blueprint/context/support/ConfigLocationsTest.java (-1 lines)
44	context.setConfigLocations(cfgs);	44	context.setConfigLocations(cfgs);
45	String[] returned =	45	String[] returned =
46	(String[]) invokeMethod("expandLocations", new Class[] { String[].class }, new Object[] { cfgs });	46	(String[]) invokeMethod("expandLocations", new Class[] { String[].class }, new Object[] { cfgs });
47	System.out.println("returned " + Arrays.toString(returned));
48	assertTrue(Arrays.equals(new String[] { "cnf/.xml", "/cnf/.xml" }, returned));	47	assertTrue(Arrays.equals(new String[] { "cnf/.xml", "/cnf/.xml" }, returned));
49	}	48	}
50		49




package org.eclipse.gemini.blueprint.extender.internal.activator;

import org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.support.BlueprintConfigUtils;

/**
 * @author Olaf Otto
 */
public class BlueprintNamespaceHandlerActivator extends NamespaceHandlerActivator {

    @Override
    protected String getManagedBundleExtenderVersionHeader() {
        return BlueprintConfigUtils.EXTENDER_VERSION;
    }
}





package org.eclipse.gemini.blueprint.extender.internal.activator;

import java.util.Map;
import java.util.WeakHashMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.gemini.blueprint.extender.OsgiApplicationContextCreator;
import org.eclipse.gemini.blueprint.extender.internal.activator.listeners.BaseListener;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.SynchronousBundleListener;
import org.osgi.framework.Version;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.CachedIntrospectionResults;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticaster;
import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
import org.eclipse.gemini.blueprint.extender.support.DefaultOsgiApplicationContextCreator;
import org.eclipse.gemini.blueprint.extender.support.internal.ConfigUtils;
import org.eclipse.gemini.blueprint.service.exporter.support.OsgiServiceFactoryBean;
import org.eclipse.gemini.blueprint.service.importer.support.OsgiServiceCollectionProxyFactoryBean;
import org.eclipse.gemini.blueprint.service.importer.support.OsgiServiceProxyFactoryBean;
import org.eclipse.gemini.blueprint.util.OsgiBundleUtils;
import org.eclipse.gemini.blueprint.util.OsgiStringUtils;
import org.osgi.framework.*;

/**
 * Osgi Extender that bootstraps 'Spring powered bundles'.

 */
public class ContextLoaderListener implements BundleActivator {

    /**
	 * Common base class for {@link ContextLoaderListener} listeners.
	 * 
	 * @author Costin Leau
	 */
	private abstract class BaseListener implements SynchronousBundleListener {

		static final int LAZY_ACTIVATION_EVENT_TYPE = 0x00000200;

		protected final Log log = LogFactory.getLog(getClass());

		/**
		 * common cache used for tracking down bundles started lazily so they don't get processed twice (once when
		 * started lazy, once when started fully)
		 */
		protected Map<Bundle, Object> lazyBundleCache = new WeakHashMap<Bundle, Object>();
		/** dummy value for the bundle cache */
		private final Object VALUE = new Object();

		// caches the bundle
		protected void push(Bundle bundle) {
			synchronized (lazyBundleCache) {
				lazyBundleCache.put(bundle, VALUE);
			}
		}

		// checks the presence of the bundle as well as removing it
		protected boolean pop(Bundle bundle) {
			synchronized (lazyBundleCache) {
				return (lazyBundleCache.remove(bundle) != null);
			}
		}

		/**
		 * A bundle has been started, stopped, resolved, or unresolved. This method is a synchronous callback, do not do
		 * any long-running work in this thread.
		 * 
		 * @see org.osgi.framework.SynchronousBundleListener#bundleChanged
		 */
		public void bundleChanged(BundleEvent event) {

			boolean trace = log.isTraceEnabled();

			// check if the listener is still alive
			if (isClosed) {
				if (trace)
					log.trace("Listener is closed; events are being ignored");
				return;
			}
			if (trace) {
				log.trace("Processing bundle event [" + OsgiStringUtils.nullSafeToString(event) + "] for bundle ["
						+ OsgiStringUtils.nullSafeSymbolicName(event.getBundle()) + "]");
			}
			try {
				handleEvent(event);
			} catch (Exception ex) {
				/* log exceptions before swallowing */
				log.warn("Got exception while handling event " + event, ex);
			}
		}

		protected abstract void handleEvent(BundleEvent event);
	}

	/**
	 * Bundle listener used for detecting namespace handler/resolvers. Exists as a separate listener so that it can be
	 * registered early to avoid race conditions with bundles in INSTALLING state but still to avoid premature context
	 * creation before the Spring {@link ContextLoaderListener} is not fully initialized.
	 * 
	 * @author Costin Leau
	 */
	private class NamespaceBundleLister extends BaseListener {

		private final boolean resolved;

		NamespaceBundleLister(boolean resolvedBundles) {
			this.resolved = resolvedBundles;
		}

		protected void handleEvent(BundleEvent event) {
			Bundle bundle = event.getBundle();

			switch (event.getType()) {

			case BundleEvent.RESOLVED:
				if (resolved) {
					maybeAddNamespaceHandlerFor(bundle, false);
				}
				break;

			case LAZY_ACTIVATION_EVENT_TYPE: {
				if (!resolved) {
					push(bundle);
					maybeAddNamespaceHandlerFor(bundle, true);
				}
				break;
			}
			case BundleEvent.STARTED: {
				if (!resolved) {
					if (!pop(bundle)) {
						maybeAddNamespaceHandlerFor(bundle, false);
					}
				}
				break;
			}
			case BundleEvent.STOPPED: {
				pop(bundle);
				maybeRemoveNameSpaceHandlerFor(bundle);
				break;
			}
			default:
				break;
			}
		}
	}

	/**
	 * Bundle listener used for context creation/destruction.
	 */
	private class ContextBundleListener extends BaseListener {


			Bundle bundle = event.getBundle();

			// ignore current bundle for context creation
			if (bundle.getBundleId() == bundleId) {
				return;
			}

			switch (event.getType()) {
			case LAZY_ACTIVATION_EVENT_TYPE: {
				// activate bundle
				try {
					bundle.loadClass("org.osgi.service.blueprint.container.BlueprintContainer");
				} catch (Exception ex) {

					if (log.isDebugEnabled()) {
						log.debug("System bundle stopping");
					}
					// System bundle is shutting down; Special handling for
					// framework shutdown
					shutdown();
				} else {
					lifecycleManager.maybeCloseApplicationContextFor(bundle);


	protected final Log log = LogFactory.getLog(getClass());

    private ExtenderConfiguration extenderConfiguration;
    private VersionMatcher versionMatcher;
    private Version extenderVersion;
	/** extender configuration */
	private ExtenderConfiguration extenderConfiguration;

    /** extender bundle id */
	private long bundleId;

	/** The bundle's context */
	private BundleContext bundleContext;

	/** Bundle listener interested in context creation */
	private BaseListener contextListener;

	/** Bundle listener interested in namespace resolvers/parsers discovery */
	private SynchronousBundleListener nsListener;

	/**
	 * Monitor used for dealing with the bundle activator and synchronous bundle threads

	 */
	private volatile boolean isClosed = false;

	/** This extender version */
	private Version extenderVersion;

	private volatile OsgiBundleApplicationContextEventMulticaster multicaster;

	private volatile LifecycleManager lifecycleManager;
	private volatile VersionMatcher versionMatcher;
	private volatile OsgiContextProcessor processor;
	private volatile ListListenerAdapter osgiListeners;

    public ContextLoaderListener(ExtenderConfiguration extenderConfiguration) {
        this.extenderConfiguration = extenderConfiguration;
    }

    /**
	 * <p/> Called by OSGi when this bundle is started. Finds all previously resolved bundles and adds namespace
	 * handlers for them if necessary. </p> <p/> Creates application contexts for bundles started before the extender
	 * was started. </p> <p/> Registers a namespace/entity resolving service for use by web app contexts. </p>
	 * 
	 * @see org.osgi.framework.BundleActivator#start
	 */
	public void start(BundleContext extenderBundleContext) throws Exception {

		this.bundleContext = extenderBundleContext;
		this.bundleId = extenderBundleContext.getBundle().getBundleId();
        this.extenderVersion = OsgiBundleUtils.getBundleVersion(extenderBundleContext.getBundle());
        this.versionMatcher = new DefaultVersionMatcher(getManagedBundleExtenderVersionHeader(), extenderVersion);
        this.processor = createContextProcessor();

		// initialize the configuration once namespace handlers have been detected
		this.lifecycleManager =
				new LifecycleManager(
                        this.extenderConfiguration,
                        getVersionMatcher(),
                        createContextConfigFactory(),
                        getOsgiApplicationContextCreator(),
						this.processor,
                        getTypeCompatibilityChecker(),
                        bundleContext);

		// Step 3: discover the bundles that are started
		// and require context creation
		initListenerService();

		// initialize the configuration once namespace handlers have been detected
		lifecycleManager =
				new LifecycleManager(extenderConfiguration, versionMatcher, createContextConfigFactory(),
						this.processor, getTypeCompatibilityChecker(), bundleContext);

		// Step 3: discover the bundles that are started
		// and require context creation
		initStartedBundles(bundleContext);
	}

	protected ExtenderConfiguration initExtenderConfiguration(BundleContext bundleContext) {
		return new ExtenderConfiguration(bundleContext, log);
	}

	protected OsgiContextProcessor createContextProcessor() {
		return new NoOpOsgiContextProcessor();
	}

		return null;
	}

	protected String getManagedBundleExtenderVersionHeader() {
		return ConfigUtils.EXTENDER_VERSION;
	}

	protected void initNamespaceHandlers(BundleContext context) {
		nsManager = new NamespaceManager(context);

		// register listener first to make sure any bundles in INSTALLED state
		// are not lost
		
		// if the property is defined and true, consider bundles in STARTED/LAZY-INIT state, otherwise use RESOLVED
		boolean nsResolved = !Boolean.getBoolean("org.eclipse.gemini.blueprint.ns.bundles.started");
		nsListener = new NamespaceBundleLister(nsResolved);
		context.addBundleListener(nsListener);

		Bundle[] previousBundles = context.getBundles();

		for (Bundle bundle : previousBundles) {
			// special handling for uber bundle being restarted
			if ((nsResolved && OsgiBundleUtils.isBundleResolved(bundle)) || (!nsResolved && OsgiBundleUtils.isBundleActive(bundle)) || bundleId == bundle.getBundleId()) {
				maybeAddNamespaceHandlerFor(bundle, false);
			} else if (OsgiBundleUtils.isBundleLazyActivated(bundle)) {
				maybeAddNamespaceHandlerFor(bundle, true);
			}
		}

		// discovery finished, publish the resolvers/parsers in the OSGi space
		nsManager.afterPropertiesSet();
	}

	protected void initStartedBundles(BundleContext bundleContext) {
		// register the context creation listener
		contextListener = new ContextBundleListener();
		// listen to any changes in bundles
		bundleContext.addBundleListener(contextListener);
		// get the bundles again to get an updated view
		Bundle[] previousBundles = bundleContext.getBundles();

		// Instantiate all previously resolved bundles which are Spring
		// powered
		for (int i = 0; i < previousBundles.length; i++) {
			if (OsgiBundleUtils.isBundleActive(previousBundles[i])) {
				try {

	 */
	protected void shutdown() {
		synchronized (monitor) {
			// if already closed, bail out
			if (isClosed)
				return;
			else
				isClosed = true;
		}
		log.info("Stopping [" + bundleContext.getBundle().getSymbolicName() + "] bundle v.[" + extenderVersion + "]");

        this.contextListener.close();

		// remove the bundle listeners (we are closing down)
		if (contextListener != null) {
			bundleContext.removeBundleListener(contextListener);
			contextListener = null;
		}

		// close managed bundles
			bundleContext.removeBundleListener(nsListener);
			nsListener = null;
		}

		// close managed bundles
		lifecycleManager.destroy();
		// clear the namespace registry
		nsManager.destroy();

		// release multicaster
		if (multicaster != null) {
			multicaster.removeAllListeners();
			multicaster = null;
		}
		// release listeners
		osgiListeners.destroy();
		osgiListeners = null;

		extenderConfiguration.destroy();
	}

	private void initJavaBeansCache() {
		Class<?>[] classes =
				new Class<?>[] { OsgiServiceFactoryBean.class, OsgiServiceProxyFactoryBean.class,
						OsgiServiceCollectionProxyFactoryBean.class };

		CachedIntrospectionResults.acceptClassLoader(OsgiStringUtils.class.getClassLoader());

		for (Class<?> clazz : classes) {
			BeanUtils.getPropertyDescriptors(clazz);
		}
	}

	private void destroyJavaBeansCache() {
		CachedIntrospectionResults.clearClassLoader(OsgiStringUtils.class.getClassLoader());
	}

	protected void maybeAddNamespaceHandlerFor(Bundle bundle, boolean isLazy) {
		if (handlerBundleMatchesExtenderVersion(bundle))
			nsManager.maybeAddNamespaceHandlerFor(bundle, isLazy);
	}

	protected void maybeRemoveNameSpaceHandlerFor(Bundle bundle) {
		if (handlerBundleMatchesExtenderVersion(bundle))
			nsManager.maybeRemoveNameSpaceHandlerFor(bundle);
	}

	/**
	 * Utility method that does extender range versioning and approapriate
	 * 
	 * logging.
	 * 
	 * @param bundle
	 */
	private boolean handlerBundleMatchesExtenderVersion(Bundle bundle) {
		if (!versionMatcher.matchVersion(bundle)) {
			if (log.isDebugEnabled())
				log.debug("Ignoring handler bundle " + OsgiStringUtils.nullSafeNameAndSymName(bundle)
						+ "] due to mismatch in expected extender version");
			return false;
		}
		return true;
	}

	protected ApplicationContextConfigurationFactory createContextConfigFactory() {
		return new DefaultApplicationContextConfigurationFactory();
	}

    public VersionMatcher getVersionMatcher() {
        return versionMatcher;
    }

    protected String getManagedBundleExtenderVersionHeader() {
        return ConfigUtils.EXTENDER_VERSION;
    }

    protected OsgiApplicationContextCreator getOsgiApplicationContextCreator() {
        OsgiApplicationContextCreator creator = this.extenderConfiguration.getContextCreator();
        if (creator == null) {
            creator = createDefaultOsgiApplicationContextCreator();
        }
        return creator;
    }

    protected OsgiApplicationContextCreator createDefaultOsgiApplicationContextCreator() {
        return new DefaultOsgiApplicationContextCreator();
    }
}




package org.eclipse.gemini.blueprint.extender.internal.activator;

import org.eclipse.gemini.blueprint.service.exporter.support.OsgiServiceFactoryBean;
import org.eclipse.gemini.blueprint.service.importer.support.OsgiServiceCollectionProxyFactoryBean;
import org.eclipse.gemini.blueprint.service.importer.support.OsgiServiceProxyFactoryBean;
import org.eclipse.gemini.blueprint.util.OsgiStringUtils;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.CachedIntrospectionResults;

/**
 * Used to prevent ad-hoc Java Bean discovery on lazy bundles.
 *
 * @author Bill Gallagher
 * @author Andy Piper
 * @author Hal Hildebrand
 * @author Adrian Colyer
 * @author Costin Leau
 * @author Olaf Otto
 */
public class JavaBeansCacheActivator implements BundleActivator {
    /**
     * Monitor used for dealing with the bundle activator and synchronous bundle threads
     */
    private final Object monitor = new Object();
    private boolean stopped = false;

    public void start(BundleContext extenderBundleContext) {
        initJavaBeansCache();
    }

    public void stop(BundleContext extenderBundleContext) {
        synchronized (monitor) {
            if (stopped) {
                return;
            }
            stopped = true;
        }
        destroyJavaBeansCache();
    }

    private void initJavaBeansCache() {
        Class<?>[] classes =
                new Class<?>[] { OsgiServiceFactoryBean.class, OsgiServiceProxyFactoryBean.class,
                        OsgiServiceCollectionProxyFactoryBean.class };

        CachedIntrospectionResults.acceptClassLoader(OsgiStringUtils.class.getClassLoader());

        for (Class<?> clazz : classes) {
            BeanUtils.getPropertyDescriptors(clazz);
        }
    }

    private void destroyJavaBeansCache() {
        CachedIntrospectionResults.clearClassLoader(OsgiStringUtils.class.getClassLoader());
    }
}



Lines 14-27 Link Here

(-)a/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/activator/LifecycleManager.java (-12 / +6 lines)
14		14
15	package org.eclipse.gemini.blueprint.extender.internal.activator;	15	package org.eclipse.gemini.blueprint.extender.internal.activator;
16		16
17	import java.util.ArrayList;
18	import java.util.Collection;
19	import java.util.Collections;
20	import java.util.List;
21	import java.util.Map;
22	import java.util.Timer;
23	import java.util.concurrent.ConcurrentHashMap;
24
25	import org.apache.commons.logging.Log;	17	import org.apache.commons.logging.Log;
26	import org.apache.commons.logging.LogFactory;	18	import org.apache.commons.logging.LogFactory;
27	import org.eclipse.gemini.blueprint.context.ConfigurableOsgiBundleApplicationContext;	19	import org.eclipse.gemini.blueprint.context.ConfigurableOsgiBundleApplicationContext;
Lines 45-50 import org.springframework.beans.factory.config.BeanFactoryPostProcessor; Link Here
45	import org.springframework.core.task.SyncTaskExecutor;	37	import org.springframework.core.task.SyncTaskExecutor;
46	import org.springframework.core.task.TaskExecutor;	38	import org.springframework.core.task.TaskExecutor;
47		39
		40	import java.util.*;
		41	import java.util.concurrent.ConcurrentHashMap;
		42
48	/**	43	/**
49	* Manager handling the startup/shutdown threading issues regarding OSGi contexts. Used by {@link ContextLoaderListener}	44	* Manager handling the startup/shutdown threading issues regarding OSGi contexts. Used by {@link ContextLoaderListener}
50	* .	45	* .
Lines 100-112 class LifecycleManager implements DisposableBean { Link Here
100	private final TypeCompatibilityChecker typeChecker;	95	private final TypeCompatibilityChecker typeChecker;
101		96
102	LifecycleManager(ExtenderConfiguration extenderConfiguration, VersionMatcher versionMatcher,	97	LifecycleManager(ExtenderConfiguration extenderConfiguration, VersionMatcher versionMatcher,
103	ApplicationContextConfigurationFactory appCtxCfgFactory, OsgiContextProcessor processor,	98	ApplicationContextConfigurationFactory appCtxCfgFactory, OsgiApplicationContextCreator osgiApplicationContextCreator, OsgiContextProcessor processor,
104	TypeCompatibilityChecker checker, BundleContext context) {	99	TypeCompatibilityChecker checker, BundleContext context) {
105		100
106	this.versionMatcher = versionMatcher;	101	this.versionMatcher = versionMatcher;
107	this.extenderConfiguration = extenderConfiguration;	102	this.extenderConfiguration = extenderConfiguration;
108	this.contextConfigurationFactory = appCtxCfgFactory;	103	this.contextConfigurationFactory = appCtxCfgFactory;
109		104	this.contextCreator = osgiApplicationContextCreator;
110	this.processor = processor;	105	this.processor = processor;
111		106
112	this.taskExecutor = extenderConfiguration.getTaskExecutor();	107	this.taskExecutor = extenderConfiguration.getTaskExecutor();
Lines 114-120 class LifecycleManager implements DisposableBean { Link Here
114		109
115	this.multicaster = extenderConfiguration.getEventMulticaster();	110	this.multicaster = extenderConfiguration.getEventMulticaster();
116		111
117	this.contextCreator = extenderConfiguration.getContextCreator();
118	this.postProcessors = extenderConfiguration.getPostProcessors();	112	this.postProcessors = extenderConfiguration.getPostProcessors();
119	this.typeChecker = checker;	113	this.typeChecker = checker;
120		114





package org.eclipse.gemini.blueprint.extender.internal.activator;

import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEvent;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextListener;
import java.lang.reflect.TypeVariable;
import java.util.Map;
import java.util.WeakHashMap;

import org.osgi.framework.BundleContext;
import org.osgi.util.tracker.ServiceTracker;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.GenericTypeResolver;

import java.util.Map;
import java.util.WeakHashMap;

/**
 * Listener interface that delegates to a list of listener. This is useful in OSGi environments when dealing with


	/**
	 * Constructs a new <code>ListListenerAdapter</code> instance.
	 * 
	 * @param listeners
	 */
	public ListListenerAdapter(BundleContext bundleContext) {
		this.tracker = new ServiceTracker(bundleContext, OsgiBundleApplicationContextListener.class.getName(), null);




package org.eclipse.gemini.blueprint.extender.internal.activator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticaster;
import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

/**
 * Initializes the event multicaster infrastructure.
 *
 * @author Bill Gallagher
 * @author Andy Piper
 * @author Hal Hildebrand
 * @author Adrian Colyer
 * @author Costin Leau
 * @author Olaf Otto
 */
public class ListenerServiceActivator implements BundleActivator {
    /**
     * Monitor used for dealing with the bundle activator and synchronous bundle threads
     */
    private final Object monitor = new Object();
    private boolean stopped = false;
    private OsgiBundleApplicationContextEventMulticaster multicaster;
    private volatile ListListenerAdapter osgiListeners;
    private final Log log = LogFactory.getLog(getClass());
    private final ExtenderConfiguration extenderConfiguration;
    private BundleContext extenderBundleContext;

    public ListenerServiceActivator(ExtenderConfiguration extenderConfiguration) {
        this.extenderConfiguration = extenderConfiguration;
    }

    public void start(BundleContext extenderBundleContext) throws Exception {
        this.extenderBundleContext = extenderBundleContext;
        initListenerService();
    }

    public void stop(BundleContext extenderBundleContext) throws Exception {
        synchronized (monitor) {
            if (stopped) {
                return;
            }
            stopped = true;
        }

        // release multicaster
        if (multicaster != null) {
            multicaster.removeAllListeners();
            multicaster = null;
        }
        // release listeners
        osgiListeners.destroy();
        osgiListeners = null;
    }

    protected void initListenerService() {
        this.multicaster = extenderConfiguration.getEventMulticaster();

        addApplicationListener(multicaster);
        multicaster.addApplicationListener(extenderConfiguration.getContextEventListener());

        if (log.isDebugEnabled())
            log.debug("Initialization of OSGi listeners service completed...");
    }

    protected void addApplicationListener(OsgiBundleApplicationContextEventMulticaster multicaster) {
        osgiListeners = new ListListenerAdapter(this.extenderBundleContext);
        osgiListeners.afterPropertiesSet();
        // register the listener that does the dispatching
        multicaster.addApplicationListener(osgiListeners);
    }

    public OsgiBundleApplicationContextEventMulticaster getMulticaster() {
        return multicaster;
    }
}




package org.eclipse.gemini.blueprint.extender.internal.activator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.gemini.blueprint.util.OsgiBundleUtils;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Version;

/**
 * Simply writes status convenient status information to the log.
 *
 * @author Olaf Otto
 */
public class LoggingActivator implements BundleActivator {
    private final Log log = LogFactory.getLog(getClass());

    public void start(BundleContext extenderBundleContext) throws Exception {
        Version extenderVersion = OsgiBundleUtils.getBundleVersion(extenderBundleContext.getBundle());
        log.info("Starting [" + extenderBundleContext.getBundle().getSymbolicName() + "] bundle v.[" + extenderVersion + "]");
    }

    public void stop(BundleContext extenderBundleContext) throws Exception {
        Version extenderVersion = OsgiBundleUtils.getBundleVersion(extenderBundleContext.getBundle());
        log.info("Stopping [" + extenderBundleContext.getBundle().getSymbolicName() + "] bundle v.[" + extenderVersion + "]");
    }
}




package org.eclipse.gemini.blueprint.extender.internal.activator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.gemini.blueprint.extender.internal.activator.listeners.BaseListener;
import org.eclipse.gemini.blueprint.extender.internal.activator.listeners.NamespaceBundleLister;
import org.eclipse.gemini.blueprint.extender.internal.support.NamespaceManager;
import org.eclipse.gemini.blueprint.extender.support.internal.ConfigUtils;
import org.eclipse.gemini.blueprint.util.OsgiBundleUtils;
import org.eclipse.gemini.blueprint.util.OsgiStringUtils;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Version;

/**
 * @author Bill Gallagher
 * @author Andy Piper
 * @author Hal Hildebrand
 * @author Adrian Colyer
 * @author Costin Leau
 * @author Olaf Otto
 */
public class NamespaceHandlerActivator implements BundleActivator {
    /**
     * Monitor used for dealing with the bundle activator and synchronous bundle threads
     */
    private final Object monitor = new Object();
    private boolean stopped = false;
    private final Log log = LogFactory.getLog(getClass());
    private NamespaceManager nsManager;
    private BaseListener nsListener;
    private long bundleId;
    private BundleContext extenderBundleContext;
    private DefaultVersionMatcher versionMatcher;

    public void start(BundleContext extenderBundleContext) {
        this.extenderBundleContext = extenderBundleContext;
        this.nsManager = new NamespaceManager(extenderBundleContext);
        this.bundleId = extenderBundleContext.getBundle().getBundleId();
        Version extenderVersion = OsgiBundleUtils.getBundleVersion(extenderBundleContext.getBundle());
        this.versionMatcher = new DefaultVersionMatcher(getManagedBundleExtenderVersionHeader(), extenderVersion);

        initNamespaceHandlers(extenderBundleContext);
    }

    public void stop(BundleContext context) throws Exception {
        synchronized (monitor) {
            if (stopped) {
                return;
            }
            stopped = true;
        }

        this.nsListener.close();
        this.extenderBundleContext.removeBundleListener(this.nsListener);
        this.nsListener = null;
        this.nsManager.destroy();
    }

    protected String getManagedBundleExtenderVersionHeader() {
        return ConfigUtils.EXTENDER_VERSION;
    }

    protected void initNamespaceHandlers(BundleContext extenderBundleContext) {
        nsManager = new NamespaceManager(extenderBundleContext);

        // register listener first to make sure any bundles in INSTALLED state
        // are not lost

        // if the property is defined and true, consider bundles in STARTED/LAZY-INIT state, otherwise use RESOLVED
        boolean nsResolved = !Boolean.getBoolean("org.eclipse.gemini.blueprint.ns.bundles.started");
        nsListener = new NamespaceBundleLister(nsResolved, this);
        extenderBundleContext.addBundleListener(nsListener);

        Bundle[] previousBundles = extenderBundleContext.getBundles();

        for (Bundle bundle : previousBundles) {
            // special handling for uber bundle being restarted
            if ((nsResolved && OsgiBundleUtils.isBundleResolved(bundle)) || (!nsResolved && OsgiBundleUtils.isBundleActive(bundle)) || bundleId == bundle.getBundleId()) {
                maybeAddNamespaceHandlerFor(bundle, false);
            } else if (OsgiBundleUtils.isBundleLazyActivated(bundle)) {
                maybeAddNamespaceHandlerFor(bundle, true);
            }
        }

        // discovery finished, publish the resolvers/parsers in the OSGi space
        nsManager.afterPropertiesSet();
    }


    public void maybeAddNamespaceHandlerFor(Bundle bundle, boolean isLazy) {
        if (handlerBundleMatchesExtenderVersion(bundle)) {
            nsManager.maybeAddNamespaceHandlerFor(bundle, isLazy);
        }
    }

    public void maybeRemoveNameSpaceHandlerFor(Bundle bundle) {
        if (handlerBundleMatchesExtenderVersion(bundle))
            nsManager.maybeRemoveNameSpaceHandlerFor(bundle);
    }

    /**
     * Utility method that does extender range version check and appropriate logging.
     */
    protected boolean handlerBundleMatchesExtenderVersion(Bundle bundle) {
        if (!versionMatcher.matchVersion(bundle)) {
            if (log.isDebugEnabled())
                log.debug("Ignoring handler bundle " + OsgiStringUtils.nullSafeNameAndSymName(bundle)
                        + "] due to mismatch in expected extender version");
            return false;
        }
        return true;
    }
}




package org.eclipse.gemini.blueprint.extender.internal.activator.listeners;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.gemini.blueprint.util.OsgiStringUtils;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.SynchronousBundleListener;

import java.util.Map;
import java.util.WeakHashMap;

/**
 * Common base class for {@link org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener} listeners.
 *
 * @author Costin Leau
 */
public abstract class BaseListener implements SynchronousBundleListener {
    public static final int LAZY_ACTIVATION_EVENT_TYPE = 0x00000200;

    protected final Log log = LogFactory.getLog(getClass());

    /**
     * flag indicating whether the context is down or not - useful during shutdown
     */
    private volatile boolean isClosed = false;

    /**
     * common cache used for tracking down bundles started lazily so they don't get processed twice (once when
     * started lazy, once when started fully)
     */
    protected final Map<Bundle, Object> lazyBundleCache = new WeakHashMap<Bundle, Object>();
    /**
     * dummy value for the bundle cache
     */
    private final Object VALUE = new Object();

    // caches the bundle
    protected void push(Bundle bundle) {
        synchronized (lazyBundleCache) {
            lazyBundleCache.put(bundle, VALUE);
        }
    }

    // checks the presence of the bundle as well as removing it
    protected boolean pop(Bundle bundle) {
        synchronized (lazyBundleCache) {
            return (lazyBundleCache.remove(bundle) != null);
        }
    }

    /**
     * A bundle has been started, stopped, resolved, or unresolved. This method is a synchronous callback, do not do
     * any long-running work in this thread.
     *
     * @see org.osgi.framework.SynchronousBundleListener#bundleChanged
     */
    public void bundleChanged(BundleEvent event) {

        boolean trace = log.isTraceEnabled();

        // check if the listener is still alive
        if (isClosed) {
            if (trace)
                log.trace("Listener is closed; events are being ignored");
            return;
        }
        if (trace) {
            log.trace("Processing bundle event [" + OsgiStringUtils.nullSafeToString(event) + "] for bundle ["
                    + OsgiStringUtils.nullSafeSymbolicName(event.getBundle()) + "]");
        }
        try {
            handleEvent(event);
        } catch (Exception ex) {
            /* log exceptions before swallowing */
            log.warn("Got exception while handling event " + event, ex);
        }
    }

    protected abstract void handleEvent(BundleEvent event);

    public void close() {
        this.isClosed = true;
    }
}




package org.eclipse.gemini.blueprint.extender.internal.activator.listeners;

import org.eclipse.gemini.blueprint.extender.internal.activator.NamespaceHandlerActivator;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleEvent;

/**
 * Bundle listener used for detecting namespace handler/resolvers. Exists as a separate listener so that it can be
 * registered early to avoid race conditions with bundles in INSTALLING state but still to avoid premature context
 * creation before the Spring {@link org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener} is not fully initialized.
 *
 * @author Costin Leau
 */
public class NamespaceBundleLister extends BaseListener {

    private final boolean resolved;
    private final NamespaceHandlerActivator namespaceHandlerActivator;

    public NamespaceBundleLister(boolean resolvedBundles, NamespaceHandlerActivator namespaceHandlerActivator) {
        this.resolved = resolvedBundles;
        this.namespaceHandlerActivator = namespaceHandlerActivator;
    }

    protected void handleEvent(BundleEvent event) {
        Bundle bundle = event.getBundle();

        switch (event.getType()) {

            case BundleEvent.RESOLVED:
                if (resolved) {
                    this.namespaceHandlerActivator.maybeAddNamespaceHandlerFor(bundle, false);
                }
                break;

            case LAZY_ACTIVATION_EVENT_TYPE: {
                if (!resolved) {
                    push(bundle);
                    this.namespaceHandlerActivator.maybeAddNamespaceHandlerFor(bundle, true);
                }
                break;
            }
            case BundleEvent.STARTED: {
                if (!resolved) {
                    if (!pop(bundle)) {
                        this.namespaceHandlerActivator.maybeAddNamespaceHandlerFor(bundle, false);
                    }
                }
                break;
            }
            case BundleEvent.STOPPED: {
                pop(bundle);
                this.namespaceHandlerActivator.maybeRemoveNameSpaceHandlerFor(bundle);
                break;
            }
            default:
                break;
        }
    }
}





package org.eclipse.gemini.blueprint.extender.internal.blueprint.activator;

import org.eclipse.gemini.blueprint.extender.OsgiApplicationContextCreator;
import org.eclipse.gemini.blueprint.extender.internal.activator.*;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticaster;
import org.eclipse.gemini.blueprint.extender.internal.activator.ApplicationContextConfigurationFactory;
import org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener;
import org.eclipse.gemini.blueprint.extender.internal.activator.OsgiContextProcessor;
import org.eclipse.gemini.blueprint.extender.internal.activator.TypeCompatibilityChecker;
import org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.support.BlueprintConfigUtils;
import org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.support.BlueprintContainerConfig;
import org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.support.BlueprintContainerCreator;
import org.eclipse.gemini.blueprint.extender.internal.blueprint.event.EventAdminDispatcher;
import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
import org.eclipse.gemini.blueprint.extender.support.ApplicationContextConfiguration;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;

/**
 * RFC124 extension to the Spring DM extender.

 * @author Costin Leau
 */
public class BlueprintLoaderListener extends ContextLoaderListener {
    private volatile BlueprintListenerManager listenerManager;
    private volatile BlueprintContainerProcessor contextProcessor;
	private volatile BlueprintListenerManager listenerManager;
	private volatile Bundle bundle;
	private volatile BlueprintContainerProcessor contextProcessor;
	private volatile TypeCompatibilityChecker typeChecker;
    private ListenerServiceActivator listenerServiceActivator;

    public BlueprintLoaderListener(ExtenderConfiguration extenderConfiguration, ListenerServiceActivator listenerServiceActivator) {
        super(extenderConfiguration);
        this.listenerServiceActivator = listenerServiceActivator;
    }

    @Override
	public void start(BundleContext context) throws Exception {
		this.listenerManager = new BlueprintListenerManager(context);
        EventAdminDispatcher dispatcher = new EventAdminDispatcher(context);
        Bundle bundle = context.getBundle();
		this.contextProcessor = new BlueprintContainerProcessor(dispatcher, listenerManager, bundle);
		this.typeChecker = new BlueprintTypeCompatibilityChecker(bundle);
        this.listenerServiceActivator.getMulticaster().addApplicationListener(this.contextProcessor);
		super.start(context);
	}


	}

	@Override
	protected ExtenderConfiguration initExtenderConfiguration(BundleContext bundleContext) {
		return new BlueprintExtenderConfiguration(bundleContext, log);
	}

	@Override
	protected ApplicationContextConfigurationFactory createContextConfigFactory() {
		return new ApplicationContextConfigurationFactory() {


		};
	}

    /**
     * Always use the {@link BlueprintContainerCreator}, never the configured creator.
     * Rationale: Backwards compatibility. Both DM and Blueprint extenders are available simultaneously,
     * however Blueprint extender support is new and must not be broken by existing configurations. Otherwise, existing
     * users would have to make their creators aware of the difference between blueprint and dm containers.
     */
    @Override
    protected OsgiApplicationContextCreator getOsgiApplicationContextCreator() {
        return new BlueprintContainerCreator();
    }

    @Override
	protected OsgiContextProcessor createContextProcessor() {
		return contextProcessor;
	}

	protected String getManagedBundleExtenderVersionHeader() {
		return BlueprintConfigUtils.EXTENDER_VERSION;
	}

	@Override
	protected void addApplicationListener(OsgiBundleApplicationContextEventMulticaster multicaster) {
		super.addApplicationListener(multicaster);
		// monitor bootstrapping events
		multicaster.addApplicationListener(contextProcessor);
	}

	protected ApplicationContextConfiguration createContextConfig(Bundle bundle) {
		return new BlueprintContainerConfig(bundle);
	}
}




/******************************************************************************
 * Copyright (c) 2006, 2010 VMware Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Apache License v2.0 which accompanies this distribution. 
 * The Eclipse Public License is available at 
 * http://www.eclipse.org/legal/epl-v10.html and the Apache License v2.0
 * is available at http://www.opensource.org/licenses/apache2.0.php.
 * You may elect to redistribute this code under either of these licenses. 
 * 
 * Contributors:
 *   VMware Inc.
 *****************************************************************************/

package org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.support;

import org.apache.commons.logging.Log;
import org.eclipse.gemini.blueprint.extender.OsgiApplicationContextCreator;
import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
import org.osgi.framework.BundleContext;

/**
 * Extension of the default extender configuration for handling RFC 124 extender semantics.
 * 
 * @author Costin Leau
 * 
 */
public class BlueprintExtenderConfiguration extends ExtenderConfiguration {

	private final OsgiApplicationContextCreator contextCreator = new BlueprintContainerCreator();

	/**
	 * Constructs a new <code>BlueprintExtenderConfiguration</code> instance.
	 * 
	 * @param bundleContext
	 */
	public BlueprintExtenderConfiguration(BundleContext bundleContext, Log log) {
		super(bundleContext, log);
	}

	public OsgiApplicationContextCreator getContextCreator() {
		return contextCreator;
	}
}

Lines 16-33 package org.eclipse.gemini.blueprint.extender.internal.boot; Link Here

(-)a/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/boot/ChainActivator.java (-8 / +41 lines)
16		16
17	import org.apache.commons.logging.Log;	17	import org.apache.commons.logging.Log;
18	import org.apache.commons.logging.LogFactory;	18	import org.apache.commons.logging.LogFactory;
		19	import org.eclipse.gemini.blueprint.extender.internal.activator.*;
		20	import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
19	import org.osgi.framework.BundleActivator;	21	import org.osgi.framework.BundleActivator;
20	import org.osgi.framework.BundleContext;	22	import org.osgi.framework.BundleContext;
21	import org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener;
22	import org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.BlueprintLoaderListener;	23	import org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.BlueprintLoaderListener;
23	import org.eclipse.gemini.blueprint.util.OsgiPlatformDetector;	24	import org.eclipse.gemini.blueprint.util.OsgiPlatformDetector;
24	import org.springframework.util.ClassUtils;	25	import org.springframework.util.ClassUtils;
25		26
26	/**	27	/**
27	* Bundle activator that simply the lifecycle callbacks to other activators.	28	* Bundle activator that simply the lifecycle callbacks to other activators.
28	*	29	*
29	* @author Costin Leau	30	* @author Costin Leau
30	*	31	*
31	*/	32	*/
32	public class ChainActivator implements BundleActivator {	33	public class ChainActivator implements BundleActivator {
33		34
Lines 40-58 public class ChainActivator implements BundleActivator { Link Here
40	private final BundleActivator[] CHAIN;	41	private final BundleActivator[] CHAIN;
41		42
42	public ChainActivator() {	43	public ChainActivator() {
43	if (OsgiPlatformDetector.isR42()) {	44	final LoggingActivator logStatus = new LoggingActivator();
		45	final JavaBeansCacheActivator activateJavaBeansCache = new JavaBeansCacheActivator();
		46	final NamespaceHandlerActivator activateCustomNamespaceHandling = new NamespaceHandlerActivator();
		47	final NamespaceHandlerActivator activateBlueprintspecificNamespaceHandling = new BlueprintNamespaceHandlerActivator();
		48	final ExtenderConfiguration initializeExtenderConfiguration = new ExtenderConfiguration();
		49	final ListenerServiceActivator activateListeners = new ListenerServiceActivator(initializeExtenderConfiguration);
		50	final ContextLoaderListener listenForSpringDmBundles = new ContextLoaderListener(initializeExtenderConfiguration);
		51	final BlueprintLoaderListener listenForBlueprintBundles = new BlueprintLoaderListener(initializeExtenderConfiguration, activateListeners);
		52
		53	if (OsgiPlatformDetector.isR42()) {
44	if (BLUEPRINT_AVAILABLE) {	54	if (BLUEPRINT_AVAILABLE) {
45	log.info("Blueprint API detected; enabling Blueprint Container functionality");	55	log.info("Blueprint API detected; enabling Blueprint Container functionality");
46	CHAIN = new BundleActivator[] { new ContextLoaderListener(), new BlueprintLoaderListener() };	56	CHAIN = new BundleActivator[] {
		57	logStatus,
		58	activateJavaBeansCache,
		59	activateCustomNamespaceHandling,
		60	activateBlueprintspecificNamespaceHandling,
		61	initializeExtenderConfiguration,
		62	activateListeners,
		63	listenForSpringDmBundles,
		64	listenForBlueprintBundles
		65	};
47	}	66	}
48	else {	67	else {
49	log.warn("Blueprint API not found; disabling Blueprint Container functionality");	68	log.warn("Blueprint API not found; disabling Blueprint Container functionality");
50	CHAIN = new BundleActivator[] { new ContextLoaderListener() };	69	CHAIN = new BundleActivator[] {
		70	logStatus,
		71	activateJavaBeansCache,
		72	activateCustomNamespaceHandling,
		73	initializeExtenderConfiguration,
		74	activateListeners,
		75	listenForSpringDmBundles
		76	};
51	}	77	}
52	} else {	78	} else {
53	log.warn("Pre-4.2 OSGi platform detected; disabling Blueprint Container functionality");	79	log.warn("Pre-4.2 OSGi platform detected; disabling Blueprint Container functionality");
54	CHAIN = new BundleActivator[] { new ContextLoaderListener() };	80	CHAIN = new BundleActivator[] {
55	}	81	logStatus,
		82	activateJavaBeansCache,
		83	activateCustomNamespaceHandling,
		84	initializeExtenderConfiguration,
		85	activateListeners,
		86	listenForSpringDmBundles
		87	};
		88	}
56	}	89	}
57		90
58	public void start(BundleContext context) throws Exception {	91	public void start(BundleContext context) throws Exception {

Lines 21-30 import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextLi Link Here

(-)a/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/support/DefaultOsgiBundleApplicationContextListener.java (-2 / +1 lines)
21	import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextClosedEvent;	21	import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextClosedEvent;
22	import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextFailedEvent;	22	import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextFailedEvent;
23	import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextRefreshedEvent;	23	import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextRefreshedEvent;
24	import org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener;
25		24
26	/**	25	/**
27	* Default application context event logger. Logs (using the {@link ContextLoaderListener} logger, the events received.	26	* Default application context event logger. Logs (using the {@link org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener} logger, the events received.
28	*	27	*
29	* @author Costin Leau	28	* @author Costin Leau
30	* @author Andy Piper	29	* @author Andy Piper





package org.eclipse.gemini.blueprint.extender.internal.support;

import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.Timer;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.framework.BundleContext;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.eclipse.gemini.blueprint.context.ConfigurableOsgiBundleApplicationContext;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticaster;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticasterAdapter;

import org.eclipse.gemini.blueprint.extender.OsgiBeanFactoryPostProcessor;
import org.eclipse.gemini.blueprint.extender.OsgiServiceDependencyFactory;
import org.eclipse.gemini.blueprint.extender.internal.dependencies.startup.MandatoryImporterDependencyFactory;
import org.eclipse.gemini.blueprint.extender.support.DefaultOsgiApplicationContextCreator;
import org.eclipse.gemini.blueprint.extender.support.internal.ConfigUtils;
import org.eclipse.gemini.blueprint.util.BundleDelegatingClassLoader;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.timer.TimerTaskExecutor;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;

import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.*;

/**
 * Configuration class for the extender. Takes care of locating the extender specific configurations and merging the
 * results with the defaults.
 * 
 * @author Costin Leau
 */
public class ExtenderConfiguration implements BundleActivator {

	/** logger */
    protected final Log log = LogFactory.getLog(getClass());

    private static final String TASK_EXECUTOR_NAME = "taskExecutor";

	private static final String SHUTDOWN_TASK_EXECUTOR_NAME = "shutdownTaskExecutor";



	private boolean forceThreadShutdown;

	private OsgiApplicationContextCreator contextCreator = null;

	/** bundle wrapped class loader */
	private ClassLoader classLoader;
	/** List of context post processors */
	private final List<OsgiBeanFactoryPostProcessor> postProcessors =
			Collections.synchronizedList(new ArrayList<OsgiBeanFactoryPostProcessor>(0));

	 * Constructs a new <code>ExtenderConfiguration</code> instance. Locates the extender configuration, creates an
	 * application context which will returned the extender items.
	 * 
	 * @param extenderBundleContext extender OSGi bundle context
	 */
	public void start(BundleContext extenderBundleContext) {
		Bundle bundle = extenderBundleContext.getBundle();
		Bundle bundle = bundleContext.getBundle();
		Properties properties = new Properties(createDefaultProperties());

		Enumeration<?> enm = bundle.findEntries(EXTENDER_CFG_LOCATION, XML_PATTERN, false);

		if (enm == null) {
			log.info("No custom extender configuration detected; using defaults...");

			synchronized (lock) {
				taskExecutor = createDefaultTaskExecutor();
				shutdownTaskExecutor = createDefaultShutdownTaskExecutor();
				eventMulticaster = createDefaultEventMulticaster();
				contextCreator = createDefaultApplicationContextCreator();
				contextEventListener = createDefaultApplicationContextListener();

			}
			classLoader = BundleDelegatingClassLoader.createBundleClassLoaderFor(bundle);
		} else {

			log.info("Detected extender custom configurations at " + ObjectUtils.nullSafeToString(configs));
			// create OSGi specific XML context
			ConfigurableOsgiBundleApplicationContext extenderAppCtx = new OsgiBundleXmlApplicationContext(configs);
			extenderAppCtx.setBundleContext(extenderBundleContext);
			extenderAppCtx.refresh();

			synchronized (lock) {

				contextCreator =
						extenderConfiguration.containsBean(CONTEXT_CREATOR_NAME) ? (OsgiApplicationContextCreator) extenderConfiguration
								.getBean(CONTEXT_CREATOR_NAME, OsgiApplicationContextCreator.class)
								: null;

				contextEventListener =
						extenderConfiguration.containsBean(CONTEXT_LISTENER_NAME) ? (OsgiBundleApplicationContextListener) extenderConfiguration

	 * 
	 * Cleanup the configuration items.
	 */
	public void stop(BundleContext extenderBundleContext) {

		synchronized (lock) {
			if (isMulticasterManagedInternally) {

		return new OsgiBundleApplicationContextEventMulticasterAdapter(new SimpleApplicationEventMulticaster());
	}

	private OsgiApplicationContextCreator createDefaultApplicationContextCreator() {
		return new DefaultOsgiApplicationContextCreator();
	}

	private OsgiBundleApplicationContextListener createDefaultApplicationContextListener() {
		return new DefaultOsgiBundleApplicationContextListener(log);
	}




 *   VMware Inc.
 *****************************************************************************/

package org.eclipse.gemini.blueprint.extender.internal;

import java.util.Dictionary;
import java.util.Hashtable;
import java.util.Properties;

import junit.framework.TestCase;

import org.easymock.MockControl;
import org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener;
import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
import org.eclipse.gemini.blueprint.extender.internal.support.TestTaskExecutor;
import org.eclipse.gemini.blueprint.extender.support.internal.ConfigUtils;
import org.eclipse.gemini.blueprint.mock.EntryLookupControllingMockBundle;
import org.eclipse.gemini.blueprint.mock.MockBundle;
import org.eclipse.gemini.blueprint.mock.MockBundleContext;
import org.eclipse.gemini.blueprint.mock.MockServiceRegistration;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleListener;
import org.osgi.framework.Constants;
import org.springframework.core.io.ClassPathResource;

/**
 * @author Adrian Colyer
 * 
 */
public abstract class ContextLoaderListenerTest extends TestCase {
	private ContextLoaderListener listener;
    // TODO: mock & train once there are any applications of this base class.
    private ExtenderConfiguration configuration;

    protected void setUp() throws Exception {
		super.setUp();
		this.listener = new ContextLoaderListener(this.configuration);
	}

	public void testStart() throws Exception {
		MockControl bundleContextControl = MockControl.createControl(BundleContext.class);
		BundleContext context = (BundleContext) bundleContextControl.getMock();
		// platform determination

		// extracting bundle id from bundle
		bundleContextControl.expectAndReturn(context.getBundle(), new MockBundle());

		// look for existing resolved bundles
		bundleContextControl.expectAndReturn(context.getBundles(), new Bundle[0], 2);

		// register namespace and entity resolving service
		// context.registerService((String[]) null, null, null);
		// bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER);
		// bundleContextControl.setReturnValue(null);

		// register context service
		context.registerService((String[]) null, null, null);
		bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER);
		bundleContextControl.setReturnValue(null, MockControl.ONE_OR_MORE);

		// create task executor
		EntryLookupControllingMockBundle aBundle = new EntryLookupControllingMockBundle(null);
		aBundle.setEntryReturnOnNextCallToGetEntry(null);
		bundleContextControl.expectAndReturn(context.getBundle(), aBundle, MockControl.ONE_OR_MORE);

		// listen for bundle events
		context.addBundleListener(null);
		bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER);
		bundleContextControl.setVoidCallable(2);

		bundleContextControl.expectAndReturn(context.registerService(new String[0], null, new Properties()),
			new MockServiceRegistration(), MockControl.ONE_OR_MORE);
		bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER);

		bundleContextControl.replay();

		this.listener.start(context);
		bundleContextControl.verify();
	}

	public void tstTaskExecutor() throws Exception {
		Dictionary headers = new Hashtable();
		headers.put(Constants.BUNDLE_NAME, "Extender mock bundle");
		final EntryLookupControllingMockBundle aBundle = new EntryLookupControllingMockBundle(headers);
		aBundle.setEntryReturnOnNextCallToGetEntry(new ClassPathResource("META-INF/spring/moved-extender.xml").getURL());

		MockBundleContext ctx = new MockBundleContext() {

			public Bundle getBundle() {
				return aBundle;
			}
		};

		this.listener.start(ctx);

		Dictionary hdrs = new Hashtable();
		hdrs.put(ConfigUtils.SPRING_CONTEXT_HEADER, "bla bla");
		MockBundle anotherBundle = new MockBundle(hdrs);
		anotherBundle.setBundleId(1);

		BundleEvent event = new BundleEvent(BundleEvent.STARTED, anotherBundle);

		BundleListener listener = (BundleListener) ctx.getBundleListeners().iterator().next();

		TestTaskExecutor.called = false;

		listener.bundleChanged(event);
		assertTrue("task executor should have been called if configured properly", TestTaskExecutor.called);
	}

}





package org.eclipse.gemini.blueprint.extender.internal.support;

import java.net.URL;
import java.util.Enumeration;
import java.util.List;

import junit.framework.TestCase;

import org.apache.commons.logging.LogFactory;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticasterAdapter;
import org.eclipse.gemini.blueprint.extender.internal.dependencies.startup.MandatoryImporterDependencyFactory;
import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
import org.eclipse.gemini.blueprint.mock.ArrayEnumerator;
import org.eclipse.gemini.blueprint.mock.MockBundle;
import org.eclipse.gemini.blueprint.mock.MockBundleContext;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;

import java.net.URL;
import java.util.Enumeration;
import java.util.List;

/**
 * @author Costin Leau

		};

		bundleContext = new MockBundleContext(bundle);
		config = new ExtenderConfiguration();
        config.start(this.bundleContext);
	}

	protected void tearDown() throws Exception {
		config.stop(this.bundleContext);
		config = null;
	}


Lines 14-34 Link Here

(-)a/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationDefaultSettingsTest.java (-13 / +9 lines)
14		14
15	package org.eclipse.gemini.blueprint.extender.internal.support;	15	package org.eclipse.gemini.blueprint.extender.internal.support;
16		16
17	import java.util.List;
18
19	import junit.framework.TestCase;	17	import junit.framework.TestCase;
20
21	import org.apache.commons.logging.LogFactory;
22	import org.osgi.framework.BundleContext;
23	import org.springframework.core.task.SimpleAsyncTaskExecutor;
24	import org.springframework.core.task.TaskExecutor;
25	import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticasterAdapter;	18	import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEventMulticasterAdapter;
26	import org.eclipse.gemini.blueprint.extender.internal.dependencies.startup.MandatoryImporterDependencyFactory;	19	import org.eclipse.gemini.blueprint.extender.internal.dependencies.startup.MandatoryImporterDependencyFactory;
27	import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
28	import org.eclipse.gemini.blueprint.extender.support.DefaultOsgiApplicationContextCreator;
29	import org.eclipse.gemini.blueprint.mock.MockBundleContext;	20	import org.eclipse.gemini.blueprint.mock.MockBundleContext;
		21	import org.osgi.framework.BundleContext;
		22	import org.springframework.core.task.SimpleAsyncTaskExecutor;
		23	import org.springframework.core.task.TaskExecutor;
30	import org.springframework.scheduling.timer.TimerTaskExecutor;	24	import org.springframework.scheduling.timer.TimerTaskExecutor;
31		25
		26	import java.util.List;
		27
32	/**	28	/**
33	* @author Costin Leau	29	* @author Costin Leau
34	*/	30	*/
Lines 39-49 public class ExtenderConfigurationDefaultSettingsTest extends TestCase { Link Here
39		35
40	protected void setUp() throws Exception {	36	protected void setUp() throws Exception {
41	bundleContext = new MockBundleContext();	37	bundleContext = new MockBundleContext();
42	config = new ExtenderConfiguration(bundleContext, LogFactory.getLog(ExtenderConfiguration.class));	38	config = new ExtenderConfiguration();
		39	this.config.start(this.bundleContext);
43	}	40	}
44		41
45	protected void tearDown() throws Exception {	42	protected void tearDown() throws Exception {
46	config.destroy();	43	config.start(this.bundleContext);
47	config = null;	44	config = null;
48	}	45	}
49		46
Lines 61-67 public class ExtenderConfigurationDefaultSettingsTest extends TestCase { Link Here
61	}	58	}
62		59
63	public void testApplicationContextCreator() throws Exception {	60	public void testApplicationContextCreator() throws Exception {
64	assertTrue(config.getContextCreator() instanceof DefaultOsgiApplicationContextCreator);	61	assertNull(config.getContextCreator());
65	}	62	}
66		63
67	public void testShutdownWaitTime() throws Exception {	64	public void testShutdownWaitTime() throws Exception {
68	-

Return to bug 356683

Added Link Here

(-)a/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/activator/JavaBeansCacheActivator.java (+60 lines)
1	package org.eclipse.gemini.blueprint.extender.internal.activator;
2
3	import org.eclipse.gemini.blueprint.service.exporter.support.OsgiServiceFactoryBean;
4	import org.eclipse.gemini.blueprint.service.importer.support.OsgiServiceCollectionProxyFactoryBean;
5	import org.eclipse.gemini.blueprint.service.importer.support.OsgiServiceProxyFactoryBean;
6	import org.eclipse.gemini.blueprint.util.OsgiStringUtils;
7	import org.osgi.framework.BundleActivator;
8	import org.osgi.framework.BundleContext;
9	import org.springframework.beans.BeanUtils;
10	import org.springframework.beans.CachedIntrospectionResults;
11
12	/**
13	* Used to prevent ad-hoc Java Bean discovery on lazy bundles.
14	*
15	* @author Bill Gallagher
16	* @author Andy Piper
17	* @author Hal Hildebrand
18	* @author Adrian Colyer
19	* @author Costin Leau
20	* @author Olaf Otto
21	*/
22	public class JavaBeansCacheActivator implements BundleActivator {
23	/**
24	* Monitor used for dealing with the bundle activator and synchronous bundle threads
25	*/
26	private final Object monitor = new Object();
27	private boolean stopped = false;
28
29	public void start(BundleContext extenderBundleContext) {
30	initJavaBeansCache();
31	}
32
33	public void stop(BundleContext extenderBundleContext) {
34	synchronized (monitor) {
35	if (stopped) {
36	return;
37	}
38	stopped = true;
39	}
40	destroyJavaBeansCache();
41	}
42
43	private void initJavaBeansCache() {
44	Class<?>[] classes =
45	new Class<?>[] { OsgiServiceFactoryBean.class, OsgiServiceProxyFactoryBean.class,
46	OsgiServiceCollectionProxyFactoryBean.class };
47
48	CachedIntrospectionResults.acceptClassLoader(OsgiStringUtils.class.getClassLoader());
49
50	for (Class<?> clazz : classes) {
51	BeanUtils.getPropertyDescriptors(clazz);
52	}
53	}
54
55	private void destroyJavaBeansCache() {
56	CachedIntrospectionResults.clearClassLoader(OsgiStringUtils.class.getClassLoader());
57	}
58	}
59
60

Lines 1-44 Link Here

(-)a/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/blueprint/activator/support/BlueprintExtenderConfiguration.java (-44 lines)
1	/******************************************************************************
2	* Copyright (c) 2006, 2010 VMware Inc.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* and Apache License v2.0 which accompanies this distribution.
6	* The Eclipse Public License is available at
7	* http://www.eclipse.org/legal/epl-v10.html and the Apache License v2.0
8	* is available at http://www.opensource.org/licenses/apache2.0.php.
9	* You may elect to redistribute this code under either of these licenses.
10	*
11	* Contributors:
12	* VMware Inc.
13	*****************************************************************************/
14
15	package org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.support;
16
17	import org.apache.commons.logging.Log;
18	import org.eclipse.gemini.blueprint.extender.OsgiApplicationContextCreator;
19	import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
20	import org.osgi.framework.BundleContext;
21
22	/**
23	* Extension of the default extender configuration for handling RFC 124 extender semantics.
24	*
25	* @author Costin Leau
26	*
27	*/
28	public class BlueprintExtenderConfiguration extends ExtenderConfiguration {
29
30	private final OsgiApplicationContextCreator contextCreator = new BlueprintContainerCreator();
31
32	/**
33	* Constructs a new <code>BlueprintExtenderConfiguration</code> instance.
34	*
35	* @param bundleContext
36	*/
37	public BlueprintExtenderConfiguration(BundleContext bundleContext, Log log) {
38	super(bundleContext, log);
39	}
40
41	public OsgiApplicationContextCreator getContextCreator() {
42	return contextCreator;
43	}
44	}