Attachment #223184 for bug #356683

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




/******************************************************************************
 * 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;
	}
}





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 {


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

    private ExtenderConfiguration extenderConfiguration;
    private VersionMatcher versionMatcher;
    private Version extenderVersion;

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

	/** extender configuration */
	private ExtenderConfiguration extenderConfiguration;

	/** Spring namespace/resolver manager */
	private NamespaceManager nsManager;

	/** 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();

		this.extenderVersion = OsgiBundleUtils.getBundleVersion(context.getBundle());
		log.info("Starting [" + bundleContext.getBundle().getSymbolicName() + "] bundle v.[" + extenderVersion + "]");
		versionMatcher = new DefaultVersionMatcher(getManagedBundleExtenderVersionHeader(), extenderVersion);
		processor = createContextProcessor();

		// init cache (to prevent ad-hoc Java Bean discovery on lazy bundles)
		initJavaBeansCache();

		// Step 1 : discover existing namespaces (in case there are fragments with custom XML definitions)
		nsManager = new NamespaceManager(context);
		initNamespaceHandlers(bundleContext);

		// Step 2: initialize the extender configuration
		extenderConfiguration = initExtenderConfiguration(bundleContext);

		// init the OSGi event dispatch/listening system
		initListenerService();

		// 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
		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();

			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) {

			contextListener = null;
		}

		if (nsListener != null) {
			bundleContext.removeBundleListener(nsListener);
			nsListener = null;
		}

		// close managed bundles
		lifecycleManager.destroy();
	}
		nsManager.destroy();

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

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

    public VersionMatcher getVersionMatcher() {
        return versionMatcher;
				new Class<?>[] { OsgiServiceFactoryBean.class, OsgiServiceProxyFactoryBean.class,
						OsgiServiceCollectionProxyFactoryBean.class };

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

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

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

    private OsgiApplicationContextCreator getOsgiApplicationContextCreator() {
        OsgiApplicationContextCreator creator = this.extenderConfiguration.getContextCreator();
        if (creator == null) {
            creator = createDefaultOsgiApplicationContextCreator();
        }
        return creator;
	protected void maybeRemoveNameSpaceHandlerFor(Bundle bundle) {
		if (handlerBundleMatchesExtenderVersion(bundle))
			nsManager.maybeRemoveNameSpaceHandlerFor(bundle);
    }

    protected OsgiApplicationContextCreator createDefaultOsgiApplicationContextCreator() {
        return new DefaultOsgiApplicationContextCreator();
	 * 
	 * 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();
	}

	protected void initListenerService() {
		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(bundleContext);
		osgiListeners.afterPropertiesSet();
		// register the listener that does the dispatching
		multicaster.addApplicationListener(osgiListeners);
    }
}




		};

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

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


Lines 16-33 Link Here

(-)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 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[] {
		81	logStatus,
		82	activateJavaBeansCache,
		83	activateCustomNamespaceHandling,
		84	initializeExtenderConfiguration,
		85	activateListeners,
		86	listenForSpringDmBundles
		87	};
55	}	88	}
56	}	89	}
57		90
58	public void start(BundleContext context) throws Exception {	91	public void start(BundleContext context) throws Exception {




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;
    }
}





	protected void setUp() throws Exception {
		bundleContext = new MockBundleContext();
		config = new ExtenderConfiguration();
        this.config.start(this.bundleContext);
	}

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


	}

	public void testApplicationContextCreator() throws Exception {
        assertNull(config.getContextCreator());
	}

	public void testShutdownWaitTime() throws Exception {





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 EventAdminDispatcher dispatcher;
	private volatile BlueprintListenerManager listenerManager;
    private volatile BlueprintContainerProcessor contextProcessor;
	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() {


		};
	}

    @Override
    protected OsgiApplicationContextCreator createDefaultOsgiApplicationContextCreator() {
        return new BlueprintContainerCreator();
    }

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

	@Override
	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);
	}
}

Lines 21-30 Link Here

(-)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





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;

 * 
 */
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 {
	protected void setUp() throws Exception {
		super.setUp();
		this.listener = new ContextLoaderListener(this.configuration);
	}

	public void testStart() throws Exception {




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 + "]");
    }
}

Lines 44-50 Link Here

(-)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.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.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());
    }
}







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 org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEvent;
import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextListener;

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
 * dynamic collections which can be updated during iteration.


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

Lines 96-102 Link Here

(-)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"));




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 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 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;
    }
}

Lines 14-27 Link Here

(-)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 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 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 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

Return to bug 356683

Lines 1-44 Link Here

(-)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	}

Lines 51-61 Link Here

(-)extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationCustomSettingsTest.java (-2 / +3 lines)
51	};	51	};
52		52
53	bundleContext = new MockBundleContext(bundle);	53	bundleContext = new MockBundleContext(bundle);
54	config = new ExtenderConfiguration(bundleContext, LogFactory.getLog(ExtenderConfiguration.class));	54	config = new ExtenderConfiguration();
		55	config.start(this.bundleContext);
55	}	56	}
56		57
57	protected void tearDown() throws Exception {	58	protected void tearDown() throws Exception {
58	config.destroy();	59	config.stop(this.bundleContext);
59	config = null;	60	config = null;
60	}	61	}
61		62

Lines 39-49 Link Here

(-)extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationDefaultSettingsTest.java (-3 / +4 lines)
39		39
40	protected void setUp() throws Exception {	40	protected void setUp() throws Exception {
41	bundleContext = new MockBundleContext();	41	bundleContext = new MockBundleContext();
42	config = new ExtenderConfiguration(bundleContext, LogFactory.getLog(ExtenderConfiguration.class));	42	config = new ExtenderConfiguration();
		43	this.config.start(this.bundleContext);
43	}	44	}
44		45
45	protected void tearDown() throws Exception {	46	protected void tearDown() throws Exception {
46	config.destroy();	47	config.start(this.bundleContext);
47	config = null;	48	config = null;
48	}	49	}
49		50
Lines 61-67 Link Here
61	}	62	}
62		63
63	public void testApplicationContextCreator() throws Exception {	64	public void testApplicationContextCreator() throws Exception {
64	assertTrue(config.getContextCreator() instanceof DefaultOsgiApplicationContextCreator);	65	assertNull(config.getContextCreator());
65	}	66	}
66		67
67	public void testShutdownWaitTime() throws Exception {	68	public void testShutdownWaitTime() throws Exception {

Lines 22-27 Link Here

(-)extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/ContextLoaderListenerTest.java (-4 / +5 lines)
22		22
23	import org.easymock.MockControl;	23	import org.easymock.MockControl;
24	import org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener;	24	import org.eclipse.gemini.blueprint.extender.internal.activator.ContextLoaderListener;
		25	import org.eclipse.gemini.blueprint.extender.internal.support.ExtenderConfiguration;
25	import org.eclipse.gemini.blueprint.extender.internal.support.TestTaskExecutor;	26	import org.eclipse.gemini.blueprint.extender.internal.support.TestTaskExecutor;
26	import org.eclipse.gemini.blueprint.extender.support.internal.ConfigUtils;	27	import org.eclipse.gemini.blueprint.extender.support.internal.ConfigUtils;
27	import org.eclipse.gemini.blueprint.mock.EntryLookupControllingMockBundle;	28	import org.eclipse.gemini.blueprint.mock.EntryLookupControllingMockBundle;
Lines 40-52 Link Here
40	*	41	*
41	*/	42	*/
42	public abstract class ContextLoaderListenerTest extends TestCase {	43	public abstract class ContextLoaderListenerTest extends TestCase {
43
44	private ContextLoaderListener listener;	44	private ContextLoaderListener listener;
		45	// TODO: mock & train once there are any applications of this base class.
		46	private ExtenderConfiguration configuration;
45		47
46		48	protected void setUp() throws Exception {
47	protected void setUp() throws Exception {
48	super.setUp();	49	super.setUp();
49	this.listener = new ContextLoaderListener();	50	this.listener = new ContextLoaderListener(this.configuration);
50	}	51	}
51		52
52	public void testStart() throws Exception {	53	public void testStart() throws Exception {

Line 0 Link Here

(-)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