Attachment #179476 for bug #326011

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

View | Details | Raw Unified | Return to bug 326011
Collapse All | Expand All

Lines 791-796 Link Here

(-).settings/.api_filters (+7 lines)
791	</message_arguments>	791	</message_arguments>
792	</filter>	792	</filter>
793	</resource>	793	</resource>
		794	<resource path="osgi/src/org/osgi/framework/hooks/resolver/ResolverHookFactory.java" type="org.osgi.framework.hooks.resolver.ResolverHookFactory">
		795	<filter comment="Ignore OSGi API" id="1110441988">
		796	<message_arguments>
		797	<message_argument value="org.osgi.framework.hooks.resolver.ResolverHookFactory"/>
		798	</message_arguments>
		799	</filter>
		800	</resource>
794	<resource path="osgi/src/org/osgi/framework/launch/Framework.java" type="org.osgi.framework.launch.Framework">	801	<resource path="osgi/src/org/osgi/framework/launch/Framework.java" type="org.osgi.framework.launch.Framework">
795	<filter id="403984517">	802	<filter id="403984517">
796	<message_arguments>	803	<message_arguments>




 *******************************************************************************/
package org.eclipse.osgi.service.resolver;

import java.util.Collection;
import java.util.Dictionary;
import org.osgi.framework.BundleException;
import org.osgi.framework.Version;


	/**
	 * Resolves the constraints contained in this state using the resolver
	 * currently associated with the state in an incremental, "least-perturbing" 
	 * mode, and returns a delta describing the changes in resolved states and 
	 * dependencies in the state.
	 * 

	public StateDelta resolve(BundleDescription[] discard);

	/**
	 * Resolves the constraints contained in this state using the resolver
	 * currently associated with the state in an incremental, "least-perturbing"
	 * mode, and returns a delta describing the changes in resolved states and
	 * dependencies in the state.  If discard is set to true the 
	 * the descriptions contained in the resolve array will have their 
	 * current resolution state discarded and will be re-resolved.
	 * This method will attempt to resolve the supplied descriptions
	 * and may attempt to resolve any other unresolved descriptions contained
	 * in this state.
	 * 
	 * @param resolve an array containing descriptions for bundles to resolve.
	 * @param discard a value of true indicates the resolve descriptions
	 * should have their current resolution state discarded and re-resolved.
	 * @return a delta describing the changes in the resolved state and
	 * interconnections.
	 * @since 3.7
	 */
	public StateDelta resolve(BundleDescription[] resolve, boolean discard);

	/**
	 * Sets the version overrides which are to be applied during the resolutoin
	 * of this state. Version overrides allow external forces to
	 * refine/override the version constraints setup by the components in the
	 * state.
	 * 
	 * @param value
	 * @deprecated The exact form of this has never been defined.  There is
	 * no alternative method available.
	 */
	// TODO the exact form of this is not defined as yet.
	public void setOverrides(Object value);

	/**

	public BundleDescription[] getRemovalPending();

	/**
	 * Returns the dependency closure for the specified bundles.
	 * 
	 * <p>
	 * A graph of bundles is computed starting with the specified bundles. The
	 * graph is expanded by adding any bundle that is either wired to a package
	 * that is currently exported by a bundle in the graph or requires a bundle
	 * in the graph. The graph is fully constructed when there is no bundle
	 * outside the graph that is wired to a bundle in the graph. The graph may
	 * contain removal pending bundles.
	 * 
	 * @param bundles The initial bundles for which to generate the dependency
	 *        closure.
	 * @return A collection containing a snapshot of the dependency closure of
	 *         the specified bundles, or an empty collection if there were no
	 *         specified bundles.
	 * @since 3.7
	 */
	public Collection<BundleDescription> getDependencyClosure(Collection<BundleDescription> bundles);

	/**
	 * Returns whether this state is empty.
	 * @return <code>true</code> if this state is empty, <code>false</code> 
	 * 	otherwise




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.osgi.framework.internal.core;

import java.util.*;
import org.eclipse.osgi.framework.debug.Debug;
import org.eclipse.osgi.internal.serviceregistry.*;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.*;
import org.osgi.framework.hooks.resolver.ResolverHook;
import org.osgi.framework.wiring.BundleRevision;
import org.osgi.framework.wiring.Capability;

/**
 * This class encapsulates the delegation to ResolverHooks that are registered with the service
 * registry.  This way the resolver implementation only has to call out to a single hook
 * which does all the necessary service registry lookups.
 * 
 * This class is not thread safe and expects external synchronization.
 *
 */
public class CoreResolverHook implements ResolverHook {
	// need a tuple to hold the service reference and hook object
	// do not use a map for performance reasons; no need to hash based on a key.
	static class HookReference {
		public HookReference(ServiceReferenceImpl<ResolverHook> reference, ResolverHook hook) {
			this.reference = reference;
			this.hook = hook;
		}

		final ServiceReferenceImpl<ResolverHook> reference;
		final ResolverHook hook;
	}

	private final BundleContextImpl context;
	private final ServiceRegistry registry;
	private final List<HookReference> hooks = new ArrayList<HookReference>(0);

	public CoreResolverHook(BundleContextImpl context, ServiceRegistry registry) {
		this.context = context;
		this.registry = registry;
	}

	private void handleHookException(Throwable t, ResolverHook hook, String method, Bundle hookBundle) {
		if (Debug.DEBUG_HOOKS) {
			Debug.println(hook.getClass().getName() + "." + method + "() exception: " + t.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$
			Debug.printStackTrace(t);
		}
		// allow the adaptor to handle this unexpected error
		context.framework.getAdaptor().handleRuntimeError(t);
		ServiceException se = new ServiceException(NLS.bind(Msg.SERVICE_FACTORY_EXCEPTION, hook.getClass().getName(), method), t);
		context.framework.publishFrameworkEvent(FrameworkEvent.ERROR, hookBundle, se);
	}

	private ServiceReferenceImpl<ResolverHook>[] getHookReferences() {
		try {
			@SuppressWarnings("unchecked")
			ServiceReferenceImpl<ResolverHook>[] result = (ServiceReferenceImpl<ResolverHook>[]) registry.getServiceReferences(context, ResolverHook.class.getName(), null, false, false);
			return result;
		} catch (InvalidSyntaxException e) {
			// cannot happen; no filter
			return null;
		}
	}

	public void begin() {
		if (Debug.DEBUG_HOOKS) {
			Debug.println("ResolverHook.begin"); //$NON-NLS-1$
		}
		ServiceReferenceImpl<ResolverHook>[] refs = getHookReferences();
		if (refs == null || refs.length == 0)
			return;
		for (ServiceReferenceImpl<ResolverHook> hookRef : refs) {
			ResolverHook hook = context.getService(hookRef);
			if (hook != null) {
				hooks.add(new HookReference(hookRef, hook));
				try {
					hook.begin();
				} catch (Throwable t) {
					handleHookException(t, hook, "begin", hookRef.getBundle()); //$NON-NLS-1$
				}
			}
		}
	}

	public void filterResolvable(Collection<BundleRevision> candidates) {
		if (Debug.DEBUG_HOOKS) {
			Debug.println("ResolverHook.filterResolvable(" + candidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		if (hooks.isEmpty())
			return;
		candidates = new ShrinkableCollection<BundleRevision>(candidates);
		for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
			HookReference hookRef = iHooks.next();
			if (hookRef.reference.getBundle() == null) {
				iHooks.remove();
			} else {
				try {
					hookRef.hook.filterResolvable(candidates);
				} catch (Throwable t) {
					handleHookException(t, hookRef.hook, "filterResolvable", hookRef.reference.getBundle()); //$NON-NLS-1$
				}
			}
		}
	}

	public void filterSingletonCollisions(Capability singleton, Collection<Capability> collisionCandidates) {
		if (Debug.DEBUG_HOOKS) {
			Debug.println("ResolverHook.filterSingletonCollisions(" + singleton + ", " + collisionCandidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
		if (hooks.isEmpty())
			return;
		collisionCandidates = new ShrinkableCollection<Capability>(collisionCandidates);
		for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
			HookReference hookRef = iHooks.next();
			if (hookRef.reference.getBundle() == null) {
				iHooks.remove();
			} else {
				try {
					hookRef.hook.filterSingletonCollisions(singleton, collisionCandidates);
				} catch (Throwable t) {
					handleHookException(t, hookRef.hook, "filterSingletonCollisions", hookRef.reference.getBundle()); //$NON-NLS-1$
				}
			}
		}
	}

	public void filterMatches(BundleRevision requirer, Collection<Capability> candidates) {
		if (Debug.DEBUG_HOOKS) {
			Debug.println("ResolverHook.filterMatches(" + requirer + ", " + candidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
		if (hooks.isEmpty())
			return;
		candidates = new ShrinkableCollection<Capability>(candidates);
		for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
			HookReference hookRef = iHooks.next();
			if (hookRef.reference.getBundle() == null) {
				iHooks.remove();
			} else {
				try {
					hookRef.hook.filterMatches(requirer, candidates);
				} catch (Throwable t) {
					handleHookException(t, hookRef.hook, "filterMatches", hookRef.reference.getBundle()); //$NON-NLS-1$
				}
			}
		}
	}

	public void end() {
		if (Debug.DEBUG_HOOKS) {
			Debug.println("ResolverHook.end"); //$NON-NLS-1$
		}
		if (hooks.isEmpty())
			return;
		for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
			HookReference hookRef = iHooks.next();
			// We do not remove unregistered services here because we are going to remove of of them at the end
			if (hookRef.reference.getBundle() != null) {
				try {
					hookRef.hook.end();
				} catch (Throwable t) {
					handleHookException(t, hookRef.hook, "end", hookRef.reference.getBundle()); //$NON-NLS-1$
				}
				context.ungetService(hookRef.reference);
			}
		}
		hooks.clear();
	}

}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.osgi.framework.internal.core;

import java.util.*;
import org.eclipse.osgi.framework.debug.Debug;
import org.eclipse.osgi.internal.serviceregistry.*;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.*;
import org.osgi.framework.hooks.resolver.ResolverHook;
import org.osgi.framework.hooks.resolver.ResolverHookFactory;
import org.osgi.framework.wiring.BundleRevision;
import org.osgi.framework.wiring.Capability;

/**
 * This class encapsulates the delegation to ResolverHooks that are registered with the service
 * registry.  This way the resolver implementation only has to call out to a single hook
 * which does all the necessary service registry lookups.
 * 
 * This class is not thread safe and expects external synchronization.
 *
 */
public class CoreResolverHookFactory implements ResolverHookFactory {
	// need a tuple to hold the service reference and hook object
	// do not use a map for performance reasons; no need to hash based on a key.
	static class HookReference {
		public HookReference(ServiceReferenceImpl<ResolverHookFactory> reference, ResolverHook hook) {
			this.reference = reference;
			this.hook = hook;
		}

		final ServiceReferenceImpl<ResolverHookFactory> reference;
		final ResolverHook hook;
	}

	private final BundleContextImpl context;
	private final ServiceRegistry registry;

	public CoreResolverHookFactory(BundleContextImpl context, ServiceRegistry registry) {
		this.context = context;
		this.registry = registry;
	}

	void handleHookException(Throwable t, Object hook, String method, Bundle hookBundle) {
		if (Debug.DEBUG_HOOKS) {
			Debug.println(hook.getClass().getName() + "." + method + "() exception: " + t.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$
			Debug.printStackTrace(t);
		}
		// allow the adaptor to handle this unexpected error
		context.framework.getAdaptor().handleRuntimeError(t);
		ServiceException se = new ServiceException(NLS.bind(Msg.SERVICE_FACTORY_EXCEPTION, hook.getClass().getName(), method), t);
		context.framework.publishFrameworkEvent(FrameworkEvent.ERROR, hookBundle, se);
	}

	private ServiceReferenceImpl<ResolverHookFactory>[] getHookReferences() {
		try {
			@SuppressWarnings("unchecked")
			ServiceReferenceImpl<ResolverHookFactory>[] result = (ServiceReferenceImpl<ResolverHookFactory>[]) registry.getServiceReferences(context, ResolverHookFactory.class.getName(), null, false, false);
			return result;
		} catch (InvalidSyntaxException e) {
			// cannot happen; no filter
			return null;
		}
	}

	public ResolverHook begin(Collection<BundleRevision> triggers) {
		if (Debug.DEBUG_HOOKS) {
			Debug.println("ResolverHook.begin"); //$NON-NLS-1$
		}
		ServiceReferenceImpl<ResolverHookFactory>[] refs = getHookReferences();
		@SuppressWarnings("unchecked")
		List<HookReference> hookRefs = refs == null ? Collections.EMPTY_LIST : new ArrayList<CoreResolverHookFactory.HookReference>(refs.length);
		if (refs != null)
			for (ServiceReferenceImpl<ResolverHookFactory> hookRef : refs) {
				ResolverHookFactory factory = context.getService(hookRef);
				if (factory != null) {
					try {
						ResolverHook hook = factory.begin(triggers);
						if (hook != null)
							hookRefs.add(new HookReference(hookRef, hook));
					} catch (Throwable t) {
						handleHookException(t, factory, "begin", hookRef.getBundle()); //$NON-NLS-1$
					}
				}
			}
		return new CoreResolverHook(hookRefs);
	}

	class CoreResolverHook implements ResolverHook {
		private final List<HookReference> hooks;

		CoreResolverHook(List<HookReference> hooks) {
			this.hooks = hooks;
		}

		public void filterResolvable(Collection<BundleRevision> candidates) {
			if (Debug.DEBUG_HOOKS) {
				Debug.println("ResolverHook.filterResolvable(" + candidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$
			}
			if (hooks.isEmpty())
				return;
			candidates = new ShrinkableCollection<BundleRevision>(candidates);
			for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
				HookReference hookRef = iHooks.next();
				if (hookRef.reference.getBundle() == null) {
					iHooks.remove();
				} else {
					try {
						hookRef.hook.filterResolvable(candidates);
					} catch (Throwable t) {
						handleHookException(t, hookRef.hook, "filterResolvable", hookRef.reference.getBundle()); //$NON-NLS-1$
					}
				}
			}
		}

		public void filterSingletonCollisions(Capability singleton, Collection<Capability> collisionCandidates) {
			if (Debug.DEBUG_HOOKS) {
				Debug.println("ResolverHook.filterSingletonCollisions(" + singleton + ", " + collisionCandidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			}
			if (hooks.isEmpty())
				return;
			collisionCandidates = new ShrinkableCollection<Capability>(collisionCandidates);
			for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
				HookReference hookRef = iHooks.next();
				if (hookRef.reference.getBundle() == null) {
					iHooks.remove();
				} else {
					try {
						hookRef.hook.filterSingletonCollisions(singleton, collisionCandidates);
					} catch (Throwable t) {
						handleHookException(t, hookRef.hook, "filterSingletonCollisions", hookRef.reference.getBundle()); //$NON-NLS-1$
					}
				}
			}
		}

		public void filterMatches(BundleRevision requirer, Collection<Capability> candidates) {
			if (Debug.DEBUG_HOOKS) {
				Debug.println("ResolverHook.filterMatches(" + requirer + ", " + candidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			}
			if (hooks.isEmpty())
				return;
			candidates = new ShrinkableCollection<Capability>(candidates);
			for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
				HookReference hookRef = iHooks.next();
				if (hookRef.reference.getBundle() == null) {
					iHooks.remove();
				} else {
					try {
						hookRef.hook.filterMatches(requirer, candidates);
					} catch (Throwable t) {
						handleHookException(t, hookRef.hook, "filterMatches", hookRef.reference.getBundle()); //$NON-NLS-1$
					}
				}
			}
		}

		public void end() {
			if (Debug.DEBUG_HOOKS) {
				Debug.println("ResolverHook.end"); //$NON-NLS-1$
			}
			if (hooks.isEmpty())
				return;
			for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
				HookReference hookRef = iHooks.next();
				// We do not remove unregistered services here because we are going to remove of of them at the end
				if (hookRef.reference.getBundle() != null) {
					try {
						hookRef.hook.end();
					} catch (Throwable t) {
						handleHookException(t, hookRef.hook, "end", hookRef.reference.getBundle()); //$NON-NLS-1$
					}
					context.ungetService(hookRef.reference);
				}
			}
			hooks.clear();
		}
	}
}





	public boolean resolveBundles(Bundle[] bundles) {
		framework.checkAdminPermission(framework.systemBundle, AdminPermission.RESOLVE);
		doResolveBundles(null, false, null);
		if (bundles == null)
			bundles = framework.getAllBundles();
		doResolveBundles(bundles, false, null);
		for (int i = 0; i < bundles.length; i++)
			if (!((AbstractBundle) bundles[i]).isResolved())
				return false;

	}

	// This method is protected to enable a work around to bug 245251
	synchronized protected void doResolveBundles(Bundle[] bundles, boolean refreshPackages, FrameworkListener[] listeners) {
		try {
			if (Profile.PROFILE && Profile.STARTUP)
				Profile.logEnter("resolve bundles"); //$NON-NLS-1$

			State systemState = framework.adaptor.getState();
			BundleDescription[] descriptions = null;
			int numBundles = bundles == null ? 0 : bundles.length;
			if (!refreshPackages) {
				List<BundleDescription> resolving = new ArrayList<BundleDescription>();
				for (Bundle bundle : bundles) {
					BundleDescription description = ((AbstractBundle) bundle).getBundleDescription();
					if (((bundle.getState() & Bundle.UNINSTALLED) == 0) && description != null)
						resolving.add(description);
				}
				descriptions = resolving.toArray(new BundleDescription[resolving.size()]);
			} else if (numBundles > 0) {
				// populate the resolved hosts package sources first (do this outside sync block: bug 280929)
				populateLoaders(framework.getAllBundles());
				synchronized (framework.bundles) {

					List<BundleDescription> results = new ArrayList<BundleDescription>(numBundles);
					BundleDelta[] addDeltas = null;
					for (int i = 0; i < numBundles; i++) {
						BundleDescription description = ((AbstractBundle) bundles[i]).getBundleDescription();
						if (description != null && description.getBundleId() != 0 && !results.contains(description))
							results.add(description);
						// add in any bundles that have the same symbolic name see bug (169593)

					descriptions = (results.size() == 0 ? null : results.toArray(new BundleDescription[results.size()]));
				}
			}
			BundleDelta[] delta = systemState.resolve(descriptions, refreshPackages).getChanges();
			processDelta(delta, refreshPackages, systemState);
		} catch (Throwable t) {
			if (Debug.DEBUG_PACKAGEADMIN) {

		// We currently have three places this is kept (PackageAdminImpl, StateImpl and ResolverImpl)
		// Using the state's because it has easy access to the uninstalled Bundle objects
		BundleDescription[] removals = framework.adaptor.getState().getRemovalPending();
		Set<Bundle> result = new HashSet<Bundle>();
		for (int i = 0; i < removals.length; i++) {
			Object ref = removals[i].getUserObject();
			if (ref instanceof BundleReference)

	}

	public Collection<Bundle> getDependencyClosure(Collection<Bundle> bundles) {
		Collection<BundleDescription> descriptions = getDescriptionClosure(bundles);
		BundleDescription[] removals = state.getRemovalPending();
		Set<Bundle> result = new HashSet<Bundle>();
		for (BundleDescription description : descriptions) {
			Object userObject = description.getUserObject();
			if (userObject instanceof BundleReference) {
				Bundle bundle = ((BundleReference) userObject).getBundle();
				if (bundle != null)
					result.add(bundle);
			}
		}
		return result;
	}

	private Collection<BundleDescription> getDescriptionClosure(Collection<Bundle> bundles) {
		State state = framework.adaptor.getState();
		Collection<BundleDescription> descriptions = new ArrayList<BundleDescription>();
		for (Bundle bundle : bundles) {
			BundleDescription description = state.getBundle(bundle.getBundleId());
			if (description != null)
				descriptions.add(description);
		for (BundleDescription removed : removals) {
			if (removed.getBundleId() == bundle.getBundleId())
				addDependents(removed, result, removals, state);
		}
		return state.getDependencyClosure(descriptions);
	}

	private static void addDependents(BundleDescription description, Set<Bundle> result, BundleDescription[] removals, State state) {
		if (description == null)
			return;
		BundleDescription[] dependents = description.getDependents();
		for (BundleDescription dependent : dependents) {
			Object ref = dependent.getUserObject();
			if (ref instanceof BundleReference)
				addDependents(((BundleReference) ref).getBundle(), result, removals, state);
		}
	}
}

Lines 60-66 Link Here

(-)core/framework/org/eclipse/osgi/framework/internal/core/SystemBundleActivator.java (-1 / +1 lines)
60	framework.adaptor.frameworkStart(bc);	60	framework.adaptor.frameworkStart(bc);
61	State state = framework.adaptor.getState();	61	State state = framework.adaptor.getState();
62	if (state instanceof StateImpl)	62	if (state instanceof StateImpl)
63	((StateImpl) state).setResolverHook(new CoreResolverHook((BundleContextImpl) context, framework.getServiceRegistry()));	63	((StateImpl) state).setResolverHookFactory(new CoreResolverHookFactory((BundleContextImpl) context, framework.getServiceRegistry()));
64	// attempt to resolve all bundles	64	// attempt to resolve all bundles
65	// this is done after the adaptor.frameworkStart has been called	65	// this is done after the adaptor.frameworkStart has been called
66	// this should be the first time the resolver State is accessed	66	// this should be the first time the resolver State is accessed




import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;

 * </ul>
 * 
 * @ThreadSafe
 * @version $Id: 4017ce21a422bbf0d4a9d0f192104eced96bec30 $
 * @since 1.6
 */

public final class CapabilityPermission extends BasicPermission {
	static final long								serialVersionUID	= -7662148639076511574L;
	/**
	 * The action string {@code require}.
	 */

	 */
	public final static String						PROVIDE				= "provide";

	private final static int						ACTION_REQUIRE		= 0x00000001;
	private final static int						ACTION_PROVIDE		= 0x00000002;
	private final static int						ACTION_ALL			= ACTION_REQUIRE
																				| ACTION_PROVIDE;
	final static int								ACTION_NONE			= 0;

	/**
	 * The actions mask.
	 */
	transient int									action_mask;

	/**
	 * The actions in canonical form.
	 * 
	 * @serial
	 */
	private volatile String							actions				= null;

	/**
	 * The attributes of the requested capability. Must be null if not
	 * constructed with attributes.
	 */
	transient final Map<String, Object>				attributes;

	/**
	 * The bundle of the requested capability. Must be null if not constructed
	 * with bundle.
	 */
	transient final Bundle							bundle;

	/**
	 * If this CapabilityPermission was constructed with a filter, this holds a
	 * Filter matching object used to evaluate the filter in implies.
	 */
	transient Filter								filter;

	/**
	 * This map holds the properties of the permission, used to match a filter
	 * in implies. This is not initialized until necessary, and then cached in
	 * this object.
	 */
	private transient volatile Map<String, Object>	properties;

	/**
	 * True if constructed with a name and the name is "*" or ends with ".*".
	 */
	private transient boolean				wildcard;

	/**
	 * If constructed with a name and the name ends with ".*", this contains the
	 * name without the final "*".
	 */
	private transient String				prefix;

	/**
	 * Create a new CapabilityPermission.
	 * 
	 * <p>

	 * @param providingBundle The bundle providing the requested capability.
	 * @param actions The action {@code require}.
	 * @throws IllegalArgumentException If the specified action is not
	 *         {@code require} or attributes or providingBundle are {@code null}
	 *         .
	 */
	public CapabilityPermission(String namespace, Map<String, ? > attributes,
			Bundle providingBundle, String actions) {
		super(namespace);
		setTransients(namespace, parseActions(actions));
		if (attributes == null) {
			throw new IllegalArgumentException("attributes must not be null");
		}
		if (providingBundle == null) {
			throw new IllegalArgumentException("bundle must not be null");
		}
		this.attributes = new HashMap<String, Object>(attributes);
		this.bundle = providingBundle;
		if ((action_mask & ACTION_ALL) != ACTION_REQUIRE) {
			throw new IllegalArgumentException("invalid action string");
		}
	}

	/**
	 * Package private constructor used by CapabilityPermissionCollection.
	 * 
	 * @param reference ServiceReference to use to create permission name.
	 * @return permission name.
	 */
	private static String createName(ServiceReference< ? > reference) {
		if (reference == null) {
			throw new IllegalArgumentException("reference must not be null");
		}
		StringBuffer sb = new StringBuffer("(service.id=");
		sb.append(reference.getProperty(Constants.SERVICE_ID));
		sb.append(")");
		return sb.toString();
	}

	/**
	 * Package private constructor used by ServicePermissionCollection.
	 * 
	 * @param name class name
	 * @param mask action mask
	 */
	CapabilityPermission(String name, int mask) {
		super(name);
		setTransients(name, mask);
		this.attributes = null;
		this.bundle = null;
	}

	/**

	 * 
	 * @param mask action mask
	 */
	private void setTransients(String name, int mask) {
		if ((mask == ACTION_NONE) || ((mask & ACTION_ALL) != mask)) {
			throw new IllegalArgumentException("invalid action string");
		}
		action_mask = mask;
		filter = parseFilter(name);
		if (f == null) {
			String name = getName();
			int l = name.length();
			/* if "*" or endsWith ".*" */
			wildcard = ((name.charAt(l - 1) == '*') && ((l == 1) || (name
					.charAt(l - 2) == '.')));
			if (wildcard && (l > 1)) {
				prefix = name.substring(0, l - 1);
			}
		}
	}

	/**

			// check for the known strings
			int matchlen;

			if (i >= 6 && (a[i - 6] == 'r' || a[i - 6] == 'R')
					&& (a[i - 5] == 'e' || a[i - 5] == 'E')
					&& (a[i - 4] == 'q' || a[i - 4] == 'Q')
					&& (a[i - 3] == 'u' || a[i - 3] == 'U')
					&& (a[i - 2] == 'i' || a[i - 2] == 'I')
					&& (a[i - 1] == 'r' || a[i - 1] == 'R')
					&& (a[i] == 'e' || a[i] == 'E')) {
				matchlen = 7;
				mask |= ACTION_REQUIRE;

			}
			else
				if (i >= 6 && (a[i - 6] == 'p' || a[i - 6] == 'P')
						&& (a[i - 5] == 'r' || a[i - 5] == 'R')
						&& (a[i - 4] == 'o' || a[i - 4] == 'O')
						&& (a[i - 3] == 'v' || a[i - 3] == 'V')
						&& (a[i - 2] == 'i' || a[i - 2] == 'I')
						&& (a[i - 1] == 'd' || a[i - 1] == 'D')
						&& (a[i] == 'e' || a[i] == 'E')) {
					matchlen = 7;
					matchlen = 8;
					mask |= ACTION_PROVIDE;

				}
				else {
					// parse error

				}

			// make sure we didn't just match the tail of a word
			// like "ackbarfprovide". Also, skip to the comma.
			seencomma = false;
			while (i >= matchlen && !seencomma) {
				switch (a[i - matchlen]) {
					case ',' :
						seencomma = true;
						/* FALLTHROUGH */
					case ' ' :
					case '\r' :
					case '\n' :

			return false;
		}
		CapabilityPermission requested = (CapabilityPermission) p;
		if (bundle != null) {
			return false;
		}
		// if requested permission has a filter, then it is an invalid argument

	 * Internal implies method. Used by the implies and the permission
	 * collection implies methods.
	 * 
	 * @param requested The requested CapabilityPermission which has already be
	 *        validated as a proper argument. The requested CapabilityPermission
	 *        must not have a filter expression.
	 * @param effective The effective actions with which to start.
	 * @return {@code true} if the specified permission is implied by this

		if ((effective & desired) != desired) {
			return false;
		}
		/* Get filter if any */
		if (wildcard && (prefix == null)) {
			return true;
		}
		/* if we have a filter */
		Filter f = filter;
		if (f == null) {
			return f.matches(requested.getProperties());
		}
		/* if requested permission not created with ServiceReference */
		String[] requestedNames = requested.objectClass;
		if (requestedNames == null) {
			return super.implies(requested);
		}
		return f.matches(requested.getProperties());
		if (wildcard) {
			int pl = prefix.length();
			for (int i = 0, l = requestedNames.length; i < l; i++) {
				String requestedName = requestedNames[i];
				if ((requestedName.length() > pl)
						&& requestedName.startsWith(prefix)) {
					return true;
				}
			}
		}
		else {
			String name = getName();
			for (int i = 0, l = requestedNames.length; i < l; i++) {
				if (requestedNames[i].equals(name)) {
					return true;
				}
			}
		}
		return false;
	}

	/**

			return false;
		}

		CapabilityPermission cp = (CapabilityPermission) obj;

		return (action_mask == cp.action_mask)
				&& getName().equals(cp.getName())
				&& ((attributes == cp.attributes) || ((attributes != null) && (attributes
						.equals(cp.attributes))))
				&& ((bundle == cp.bundle) || ((bundle != null) && bundle
						.equals(cp.bundle)));
	}

	/**

	public int hashCode() {
		int h = 31 * 17 + getName().hashCode();
		h = 31 * h + getActions().hashCode();
		if (attributes != null) {
			h = 31 * h + attributes.hashCode();
		}
		if (bundle != null) {
			h = 31 * h + bundle.hashCode();
		}
		return h;
	}

	 */
	private synchronized void writeObject(java.io.ObjectOutputStream s)
			throws IOException {
		if (bundle != null) {
			throw new NotSerializableException("cannot serialize");
		}
		// Write out the actions. The superclass takes care of the name

			throws IOException, ClassNotFoundException {
		// Read in the action, then initialize the rest
		s.defaultReadObject();
		setTransients(getName(), parseActions(actions));
	}

	/**
	 * Called by {@code <@link CapabilityPermission#implies(Permission)>}. This
	 * method is only called on a requested permission which cannot have a
	 * filter set.
	 * 
	 * @return a map of properties for this permission.
	 */
	private Map<String, Object> getProperties() {
		Map<String, Object> result = properties;
		if (result != null) {
			return result;
		}
		final Map<String, Object> props = new HashMap<String, Object>(5);
		props.put("capability.namespace", getName());
		if (bundle == null) {
			return properties = props;
		}
		AccessController.doPrivileged(new PrivilegedAction<Object>() {
			public Object run() {
				props.put("id", new Long(bundle.getBundleId()));
				props.put("location", bundle.getLocation());
				String name = bundle.getSymbolicName();
				if (name != null) {
					props.put("name", name);
				}
				SignerProperty signer = new SignerProperty(bundle);
				if (signer.isBundleSigned()) {
					props.put("signer", signer);
						props.put("name", name);
					}
					SignerProperty signer = new SignerProperty(bundle);
					if (signer.isBundleSigned()) {
						props.put("signer", signer);
					}
					return null;
				}
				return null;
			}
		});
		return properties = new Properties(props, attributes);
	}

	private static class Properties extends AbstractMap<String, Object> {
		private final Map<String, Object>							properties;
		private final Map<String, Object>							attributes;
		private transient volatile Set<Map.Entry<String, Object>>	entries;

		Properties(Map<String, Object> properties,
				Map<String, Object> attributes) {
			this.properties = properties;
			this.attributes = attributes;
			entries = null;
		}


			}
			String key = (String) k;
			if (key.charAt(0) == '@') {
				return attributes.get(key.substring(1));
			}
			Object value = properties.get(key);
			if (value != null) { // fall back to service properties
				return value;
			}
			return attributes.get(key);
		}

		public Set<Map.Entry<String, Object>> entrySet() {

				return entries;
			}
			Set<Map.Entry<String, Object>> all = new HashSet<Map.Entry<String, Object>>(
					attributes.size() + properties.size());
			all.addAll(attributes.entrySet());
			all.addAll(properties.entrySet());
					if (key.equalsIgnoreCase(k)) {
						continue add;
					}
				}
				all.add(new Entry(key, service.getProperty(key)));
			}
			return entries = Collections.unmodifiableSet(all);
		}
		
		private static class Entry implements Map.Entry<String, Object> {
			private final String	k;
			private final Object	v;

			Entry(String key, Object value) {
				this.k = key;
				this.v = value;
			}
			public String getKey() {
				return k;
			}
			public Object getValue() {
				return v;
			}
			public Object setValue(Object value) {
				throw new UnsupportedOperationException();
			}
			public String toString() {
				return k + "=" + v;
			}
			public int hashCode() {
				return ((k == null) ? 0 : k.hashCode())
						^ ((v == null) ? 0 : v.hashCode());
			}
			public boolean equals(Object obj) {
				if (obj == this) {
					return true;
				}
				if (!(obj instanceof Map.Entry)) {
					return false;
				}
				Map.Entry< ? , ? > e = (Map.Entry< ? , ? >) obj;
				final Object key = e.getKey();
				if ((k == key) || ((k != null) && k.equals(key))) {
					final Object value = e.getValue();
					if ((v == value) || ((v != null) && v.equals(value))) {
						return true;
					}
				}
				return false;
			}
		}
	}
}

/**
 * Stores a set of CapabilityPermission permissions.
 * 
 * @see java.security.Permission
 * @see java.security.Permissions
 * @see java.security.PermissionCollection
 */
final class CapabilityPermissionCollection extends PermissionCollection {
	static final long							serialVersionUID	= -615322242639008920L;

	/**
	 * Table of permissions.
	 * 
	 * @serial
	 * @GuardedBy this
	 */
	private Map<String, CapabilityPermission>	permissions;

	/**
	 * Boolean saying if "*" is in the collection.

	 * @serial
	 * @GuardedBy this
	 */
	private boolean								all_allowed;

	/**
	 * Table of permissions with filter expressions.

	 * @serial
	 * @GuardedBy this
	 */
	private Map<String, CapabilityPermission>	filterPermissions;

	/**
	 * Creates an empty CapabilityPermissionCollection object.

	 * 
	 * @param permission The Permission object to add.
	 * @throws IllegalArgumentException If the specified permission is not a
	 *         CapabilityPermission object.
	 * @throws SecurityException If this {@code CapabilityPermissionCollection}
	 *         object has been marked read-only.
	 *         read-only.
	 */
	public void add(final Permission permission) {
		if (!(permission instanceof CapabilityPermission)) {

					+ "readonly PermissionCollection");
		}

		final CapabilityPermission cp = (CapabilityPermission) permission;
		if (cp.bundle != null) {
			throw new IllegalArgumentException("cannot add to collection: "
					+ cp);
		}

		final String name = cp.getName();
		final Filter f = cp.filter;
		synchronized (this) {
			/* select the bucket for the permission */
			Map<String, CapabilityPermission> pc;

				pc = permissions;
			}
			final CapabilityPermission existing = pc.get(name);

			if (existing != null) {
				final int oldMask = existing.action_mask;
				final int newMask = cp.action_mask;
				if (oldMask != newMask) {
					pc.put(name, new CapabilityPermission(name, oldMask
							.put(name, new CapabilityPermission(name, oldMask
							| newMask));
				}
			}
			else {
				pc.put(name, cp);
			}

			if (!all_allowed) {
				if (name.equals("*")) {
					all_allowed = true;

	 * {@code permission}.
	 * 
	 * @param permission The Permission object to compare.
	 * @return {@code true} if {@code permission} is a proper subset of a
	 *         permission in the set; {@code false} otherwise.
	 *         otherwise.
	 */
	public boolean implies(final Permission permission) {
		if (!(permission instanceof CapabilityPermission)) {

			return false;
		}

		String requestedName = requested.getName();
		final int desired = requested.action_mask;
		int effective = CapabilityPermission.ACTION_NONE;

		Collection<CapabilityPermission> perms;
		synchronized (this) {
			Map<String, CapabilityPermission> pc = permissions;
			CapabilityPermission cp;
			/* short circuit if the "*" Permission was added */
			if (all_allowed) {
				cp = pc.get("*");
				if (cp != null) {
					effective |= cp.action_mask;
					if ((effective & desired) == desired) {
						return true;
					}
				}
			}

			/*
			 * strategy: Check for full match first. Then work our way up the
			 * name looking for matches on a.b.*
			 */
			cp = pc.get(requestedName);
			if (cp != null) {
				/* we have a direct hit! */
				effective |= cp.action_mask;
				if ((effective & desired) == desired) {
					return true;
				}
			}
			/* work our way up the tree... */
			int last;
			int offset = requestedName.length() - 1;
			while ((last = requestedName.lastIndexOf(".", offset)) != -1) {
				requestedName = requestedName.substring(0, last + 1) + "*";
				cp = pc.get(requestedName);
				if (cp != null) {
					effective |= cp.action_mask;
					if ((effective & desired) == desired) {
						return true;
					}
				}
				offset = last - 1;
			}
			/*
			 * we don't have to check for "*" as it was already checked before
			 * we were called.
			 */
			pc = filterPermissions;
			if (pc == null) {
				return false;
			}
			perms = pc.values();
		}
		
		/* iterate one by one over filteredPermissions */
		for (CapabilityPermission perm : perms) {
			if (perm.implies0(requested, effective)) {

	}

	/**
	 * Returns an enumeration of all the {@code CapabilityPermission} objects in
	 * the container.
	 * 
	 * @param requestedName The requested service name.
	 * @param desired The desired actions.
	 * @param effective The effective actions.
	 * @return The new effective actions.
	 */
	private int effective(String requestedName, final int desired,
			int effective) {
		final Map<String, CapabilityPermission> pc = permissions;
		CapabilityPermission sp = pc.get(requestedName);
		// strategy:
		// Check for full match first. Then work our way up the
		// name looking for matches on a.b.*
		if (sp != null) {
			// we have a direct hit!
			effective |= sp.action_mask;
			if ((effective & desired) == desired) {
				return effective;
			}
		}
		// work our way up the tree...
		int last;
		int offset = requestedName.length() - 1;
		while ((last = requestedName.lastIndexOf(".", offset)) != -1) {
			requestedName = requestedName.substring(0, last + 1) + "*";
			sp = pc.get(requestedName);
			if (sp != null) {
				effective |= sp.action_mask;
				if ((effective & desired) == desired) {
					return effective;
				}
			}
			offset = last - 1;
		}
		/*
		 * we don't have to check for "*" as it was already checked before we
		 * were called.
		 */
		return effective;
	}
	
	/**
	 * Returns an enumeration of all the {@code ServicePermission}
	 * objects in the container.
	 * 
	 * @return Enumeration of all the CapabilityPermission objects.
	 */
	public synchronized Enumeration<Permission> elements() {
		List<Permission> all = new ArrayList<Permission>(permissions.values());

		}
		return Collections.enumeration(all);
	}

	/* serialization logic */
	private static final ObjectStreamField[]	serialPersistentFields	= {
			new ObjectStreamField("permissions", HashMap.class),
			new ObjectStreamField("all_allowed", Boolean.TYPE),
			new ObjectStreamField("filterPermissions", HashMap.class)	};

	private synchronized void writeObject(ObjectOutputStream out)
			throws IOException {
		Hashtable<String, CapabilityPermission> hashtable = new Hashtable<String, CapabilityPermission>(
				permissions);
		ObjectOutputStream.PutField pfields = out.putFields();
		pfields.put("permissions", permissions);
		pfields.put("all_allowed", all_allowed);
		pfields.put("filterPermissions", filterPermissions);
		out.writeFields();

	private synchronized void readObject(java.io.ObjectInputStream in)
			throws IOException, ClassNotFoundException {
		ObjectInputStream.GetField gfields = in.readFields();
		HashMap<String, CapabilityPermission> p = (HashMap<String, CapabilityPermission>) gfields
				.get("permissions", null);
		permissions = p;
		all_allowed = gfields.get("all_allowed", false);
		HashMap<String, CapabilityPermission> fp = (HashMap<String, CapabilityPermission>) gfields
				.get("filterPermissions", null);




import org.osgi.framework.wiring.FrameworkWiring;

/**
 * OSGi Framework Resolver Hook instances are obtained from the OSGi {@link ResolverHookFactory
 * Framework Resolver Hook Factory} service.  
 * 
 * <p>
 * A Resolver Hook instance is called by the framework during a resolve
 * process.  A resolver hook may influence the outcome of a resolve process by removing entries
 * in time.  A resolver hook may influence the outcome of a resolve process by removing entries
 * from shrinkable collections that are passed to the hook during a resolve process.  A shrinkable 
 * collection is a {@code Collection} that supports all remove operations.  Any other attempts to modify
 * a shrinkable collection will result in an {@code UnsupportedOperationException} being thrown.

 * The following steps outline the way a framework uses the resolver hooks during a resolve
 * process.
 * <ol>
 *  <li> Collect a snapshot of registered resolver hook factories that will be called during the
 *       current resolve process.  Any hook factories registered after the snapshot is taken must not be called
 *       during the current resolve process.  A resolver hook factory contained in the snapshot may become
 *       unregistered during the resolve process.  The framework should handle this and stop calling
 *       the resolver hook instance provided by the unregistered hook factory for the remainder of the resolve process.</li>
 *  <li> For each registered hook factory call the {@link ResolverHookFactory#begin(Collection)} method to inform the 
 *       hooks about a resolve process beginning and to obtain a Resolver Hook instance that will be used for the duration
 *       of the resolve process.</li>
 *  <li> Determine the collection of unresolved bundle revisions that may be considered for resolution during
 *       the current resolution process and place each of the bundle revisions in a shrinkable collection
 *       <b>{@code R}</b>.
 *       <ol type="a">
 *         <li> For each resolver hook call the {@link #filterResolvable(Collection)} method with the 
 *              shrinkable collection <b>{@code R}</b>.</li>
 *       </ol>
 *  </li>

 *         <li> Remove the {@link Capability#BUNDLE_CAPABILITY osgi.bundle} capability provided by
 *              bundle revision <b>{@code B}</b> from shrinkable collection <b>{@code S}</b>.  A singleton bundle 
 *              cannot collide with itself.</li>
 *         <li> For each resovler hook call the {@link #filterSingletonCollisions(Capability, Collection)}
 *              with the {@link Capability#BUNDLE_CAPABILITY osgi.bundle} capability provided by bundle revision 
 *              <b>{@code B}</b> and the shrinkable collection <b>{@code S}</b></li>
 *         <li> The shrinkable collection <b>{@code S}</b> now contains all singleton {@link Capability#BUNDLE_CAPABILITY 

 *       <ol type="a">
 *         <li> For each requirement <b>{@code T}</b> specified by bundle revision <b>{@code B}</b> determine the 
 *              collection of capabilities that satisfy (or match) the requirement and place each matching capability into
 *              a shrinkable collection <b>{@code C}</b>.  A capability is considered to match a particular requirement
 *              if its attributes satisfy a specified requirement and the requirer bundle has permission to access the
 *              capability.</li>
 *         <li> For each resolver hook call the {@link #filterMatches(BundleRevision, Collection)} with the
 *              bundle revision <b>{@code B}</b> and the shrinkable collection <b>{@code C}</b>.</li>
 *         <li> The shrinkable collection <b>{@code C}</b> now contains all the capabilities that may be used to 
 *              satisfy the requirement <b>{@code T}</b>.  Any other capabilities that got removed from the 
 *              shrinkable collection <b>{@code C}</b> must not be used to satisfy requirement <b>{@code T}</b>.</li>
 *       </ol>
 *  </li>
 *  <li> For each resolver hook call the {@link #end()} method to inform the hooks about a resolve 
 *       process ending.</li>
 * </ol>
 * In all cases, the order in which the resolver hooks are called is the reverse compareTo ordering of 

 * resolve process (e.g. by calling {@link Bundle#start()} or {@link FrameworkWiring#resolveBundles(Collection)}).  
 * The framework must detect this and throw an {@link IllegalStateException}.
 * 
 * @see ResolverHookFactory
 * @ThreadSafe
 * @version $Id: e896c443a68b3ea287735c9c19f0b1c62bd4755d $
 */
public interface ResolverHook {

	/**
	 * This method is called once at the beginning of the resolve process
	 * before any other methods are called on this hook.
	 */
	void begin();

	/**
	 * Filter resolvable candidates hook method.  This method may be called
	 * multiple times during a single resolve process.

	 * <p>
	 * All of the candidates will have the same name space and will 
	 * match a requirement of the requirer.
	 * <p>
	 * If the Java Runtime Environment supports permissions then the collection of 
	 * candidates will only contain candidates for which the requirer has permission to
	 * access.
	 * @param requirer the bundle revision which contains a requirement
	 * @param candidates a collection of candidates that match a requirement of the requirer
	 */

	/**
	 * This method is called once at the end of the resolve process.
	 * After the end method is called the resolve process has ended.
	 * The framework must not hold onto this resolver hook instance
	 * after end has been called.
	 * a new resolve process is beginning.
	 */
	void end();
}




/*
 * Copyright (c) OSGi Alliance (2010). All Rights Reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.osgi.framework.hooks.resolver;

import java.util.Collection;

import org.osgi.framework.Bundle;
import org.osgi.framework.wiring.BundleRevision;
import org.osgi.framework.wiring.FrameworkWiring;

/** 
 * OSGi Framework Resolver Hook Factory Service.
 * 
 * <p>
 * Bundles registering this service will be called by the framework during 
 * a bundle resolver process to obtain a {@link ResolverHook resolver hook}
 * instance which will be used for the duration of a resolve process.
 * 
 * @ThreadSafe
 * @see ResolverHook
 * @version $Id: 18ea1ec1f14f47410a43e99be4da3b2583149722 $
 */
public interface ResolverHookFactory {
	/**
	 * This method is called by the framework each time a resolve process begins
	 * to obtain a {@link ResolverHook resolver hook} instance.  This resolver hook 
	 * instance will be used for the duration of the resolve process.  At the end of 
	 * the resolve process the method {@link ResolverHook#end()} must be called by 
	 * the framework and the framework must not hold any references of the resolver 
	 * hook instance.
	 * <p>
	 * The triggers represent the collection of bundles which triggered
	 * the resolve process.  This collection may be empty if the triggers
	 * cannot be determined by the framework.  In most cases the triggers 
	 * can easily be determined.  Calling certain methods on 
	 * {@link Bundle bundle} when a bundle is in the {@link Bundle#INSTALLED INSTALLED} 
	 * state will cause the framework to begin a resolve process in order to resolve the 
	 * bundle.  The following methods will start a resolve process in this case:
	 * <ul>
	 *   <li>{@link Bundle#start() start}</li>
	 *   <li>{@link Bundle#loadClass(String) loadClass}</li>
	 *   <li>{@link Bundle#findEntries(String, String, boolean) findEntries}</li>
	 *   <li>{@link Bundle#getResource(String) getResource}</li>
	 *   <li>{@link Bundle#getResources(String) getResources}</li>
	 * </ul> 
	 * In such cases the collection will contain the single bundle which the
	 * framework is trying to resolve.  Other cases will cause multiple bundles to be
	 * included in the trigger bundles collection.  When {@link FrameworkWiring#resolveBundles(Collection)
	 * resolveBundles} is called the collection of triggers must include all the current bundle 
	 * revisions for bundles passed to resolveBundles which have not been uninstalled.
	 * <p>
	 * When {@link FrameworkWiring#refreshBundles(Collection, org.osgi.framework.FrameworkListener...)}
	 * is called the collection of triggers is determined with the following steps:
	 * <ul>
	 *   <li>If the collection of bundles passed is null then {@link FrameworkWiring#getRemovalPendingBundles()}
	 *   is called to get the initial collection of bundles.</li>
	 *   <li>The equivalent of calling {@link FrameworkWiring#getDependencyClosure(Collection)} is called with
	 *   the initial collection of bundles to get the dependency closure collection of the bundles being refreshed.</li>
	 *   <li>Remove any non-active bundles from the dependency closure collection.</li>
	 *   <li>For each bundle remaining in the dependency closure collection get the current bundle revision
	 *   and add it to the collection of triggers.</li> 
	 * </ul>
	 * @param triggers an unmodifiable collection of bundles which triggered the resolve process.
	 * This collection may be empty if the collection of trigger bundles cannot be
	 * determined.
	 * @return a resolver hook instance to be used for the duration of the resolve process.
	 */
	ResolverHook begin(Collection<BundleRevision> triggers);
}

Lines 12-17 Link Here

(-)resolver/src/org/eclipse/osgi/internal/resolver/ReadOnlyState.java (-1 / +12 lines)
12	*******************************************************************************/	12	*******************************************************************************/
13	package org.eclipse.osgi.internal.resolver;	13	package org.eclipse.osgi.internal.resolver;
14		14
		15	import java.util.Collection;
15	import java.util.Dictionary;	16	import java.util.Dictionary;
16	import org.eclipse.osgi.service.resolver.*;	17	import org.eclipse.osgi.service.resolver.*;
17	import org.osgi.framework.BundleException;	18	import org.osgi.framework.BundleException;
Lines 100-105 Link Here
100	throw new UnsupportedOperationException();	101	throw new UnsupportedOperationException();
101	}	102	}
102		103
		104	public StateDelta resolve(BundleDescription[] resolve, boolean discard) {
		105	throw new UnsupportedOperationException();
		106	}
		107
		108	@SuppressWarnings("deprecation")
103	public void setOverrides(Object value) {	109	public void setOverrides(Object value) {
104	throw new UnsupportedOperationException();	110	throw new UnsupportedOperationException();
105	}	111	}
Lines 150-156 Link Here
150	throw new UnsupportedOperationException();	156	throw new UnsupportedOperationException();
151	}	157	}
152		158
153	public Dictionary<Object, Object>[] getPlatformProperties() {	159	@SuppressWarnings("rawtypes")
		160	public Dictionary[] getPlatformProperties() {
154	return target.getPlatformProperties();	161	return target.getPlatformProperties();
155	}	162	}
156		163
Lines 214-217 Link Here
214	throw new UnsupportedOperationException();	221	throw new UnsupportedOperationException();
215	}	222	}
216		223
		224	public Collection<BundleDescription> getDependencyClosure(Collection<BundleDescription> bundles) {
		225	return target.getDependencyClosure(bundles);
		226	}
		227
217	}	228	}

Lines 25-30 Link Here

(-)resolver/src/org/eclipse/osgi/internal/resolver/StateImpl.java (-22 / +82 lines)
25	import org.eclipse.osgi.util.NLS;	25	import org.eclipse.osgi.util.NLS;
26	import org.osgi.framework.*;	26	import org.osgi.framework.*;
27	import org.osgi.framework.hooks.resolver.ResolverHook;	27	import org.osgi.framework.hooks.resolver.ResolverHook;
		28	import org.osgi.framework.hooks.resolver.ResolverHookFactory;
		29	import org.osgi.framework.wiring.BundleRevision;
28		30
29	public abstract class StateImpl implements State {	31	public abstract class StateImpl implements State {
30	private static final String OSGI_OS = "osgi.os"; //$NON-NLS-1$	32	private static final String OSGI_OS = "osgi.os"; //$NON-NLS-1$
Lines 54-59 Link Here
54	private Dictionary<Object, Object>[] platformProperties = new Dictionary[] {new Hashtable<String, String>(PROPS.length)}; // Dictionary here because of Filter API	56	private Dictionary<Object, Object>[] platformProperties = new Dictionary[] {new Hashtable<String, String>(PROPS.length)}; // Dictionary here because of Filter API
55	private long highestBundleId = -1;	57	private long highestBundleId = -1;
56	private final Set<String> platformPropertyKeys = new HashSet<String>(PROPS.length);	58	private final Set<String> platformPropertyKeys = new HashSet<String>(PROPS.length);
		59	private ResolverHookFactory hookFactory;
57	private ResolverHook hook;	60	private ResolverHook hook;
58		61
59	private static long cumulativeTime;	62	private static long cumulativeTime;
Lines 426-442 Link Here
426	bundle.removeDependencies();	429	bundle.removeDependencies();
427	}	430	}
428		431
429	private StateDelta resolve(boolean incremental, BundleDescription[] reResolve) {	432	private StateDelta resolve(boolean incremental, BundleDescription[] reResolve, BundleDescription[] triggers) {
430	synchronized (this.monitor) {	433	synchronized (this.monitor) {
431	if (resolver == null)	434	if (resolver == null)
432	throw new IllegalStateException("no resolver set"); //$NON-NLS-1$	435	throw new IllegalStateException("no resolver set"); //$NON-NLS-1$
433	if (resolving == true)	436	if (resolving == true)
434	throw new IllegalStateException("An attempt to start a nested resolve process has been detected."); //$NON-NLS-1$	437	throw new IllegalStateException("An attempt to start a nested resolve process has been detected."); //$NON-NLS-1$
435	ResolverHook currentHook = getResolverHook();	438	ResolverHook currentHook = null;
436	try {	439	try {
437	resolving = true;	440	resolving = true;
438	if (currentHook != null)
439	currentHook.begin();
440	fullyLoad();	441	fullyLoad();
441	long start = 0;	442	long start = 0;
442	if (StateManager.DEBUG_PLATFORM_ADMIN_RESOLVER)	443	if (StateManager.DEBUG_PLATFORM_ADMIN_RESOLVER)
Lines 450-461 Link Here
450	reResolve = mergeBundles(reResolve, removed);	451	reResolve = mergeBundles(reResolve, removed);
451	}	452	}
452	flush(reResolve);	453	flush(reResolve);
453	}	454	} else {
454	if (resolved && reResolve == null)	455	if (resolved && reResolve == null)
455	return new StateDeltaImpl(this);	456	return new StateDeltaImpl(this);
456	if (removalPendings.size() > 0) {	457	if (reResolve == null)
457	BundleDescription[] removed = internalGetRemovalPending();	458	reResolve = internalGetRemovalPending();
458	reResolve = mergeBundles(reResolve, removed);	459	if (triggers == null) {
		460	Set<BundleDescription> triggerSet = new HashSet<BundleDescription>();
		461	Collection<BundleDescription> closure = getDependencyClosure(Arrays.asList(reResolve));
		462	for (BundleDescription toRefresh : closure) {
		463	Bundle bundle = toRefresh.getBundle();
		464	if (bundle != null && (bundle.getState() & (Bundle.INSTALLED \| Bundle.UNINSTALLED \| Bundle.RESOLVED)) == 0)
		465	triggerSet.add(toRefresh);
		466	}
		467	triggers = triggerSet.toArray(new BundleDescription[triggerSet.size()]);
		468	}
459	}	469	}
460	// use the Headers class to handle ignoring case while matching keys (bug 180817)	470	// use the Headers class to handle ignoring case while matching keys (bug 180817)
461	@SuppressWarnings("unchecked")	471	@SuppressWarnings("unchecked")
Lines 467-472 Link Here
467	tmpPlatformProperties[i].put(key, platformProperties[i].get(key));	477	tmpPlatformProperties[i].put(key, platformProperties[i].get(key));
468	}	478	}
469	}	479	}
		480
		481	ResolverHookFactory currentFactory = hookFactory;
		482	if (currentFactory != null) {
		483	@SuppressWarnings("unchecked")
		484	Collection<BundleRevision> triggerRevisions = Collections.unmodifiableCollection(triggers == null ? Collections.EMPTY_LIST : Arrays.asList((BundleRevision[]) triggers));
		485	currentHook = begin(triggerRevisions);
		486	}
470	resolver.resolve(reResolve, tmpPlatformProperties);	487	resolver.resolve(reResolve, tmpPlatformProperties);
471	resolved = removalPendings.size() == 0;	488	resolved = removalPendings.size() == 0;
472		489
Lines 526-550 Link Here
526	}	543	}
527		544
528	public StateDelta resolve() {	545	public StateDelta resolve() {
529	return resolve(true, null);	546	return resolve(true, null, null);
530	}	547	}
531		548
532	public StateDelta resolve(boolean incremental) {	549	public StateDelta resolve(boolean incremental) {
533	return resolve(incremental, null);	550	return resolve(incremental, null, null);
534	}	551	}
535		552
536	public StateDelta resolve(BundleDescription[] reResolve) {	553	public StateDelta resolve(BundleDescription[] reResolve) {
537	return resolve(true, reResolve);	554	return resolve(true, reResolve, null);
538	}	555	}
539		556
		557	public StateDelta resolve(BundleDescription[] resolve, boolean discard) {
		558	BundleDescription[] reResolve = discard ? resolve : new BundleDescription[0];
		559	BundleDescription[] triggers = discard ? null : resolve;
		560	return resolve(true, reResolve, triggers);
		561	}
		562
		563	@SuppressWarnings("deprecation")
540	public void setOverrides(Object value) {	564	public void setOverrides(Object value) {
541	throw new UnsupportedOperationException();	565	throw new UnsupportedOperationException();
542	}	566	}
543		567
544	public void setResolverHook(ResolverHook hook) {	568	public void setResolverHookFactory(ResolverHookFactory hookFactory) {
		569	synchronized (this.monitor) {
		570	this.hookFactory = hookFactory;
		571	}
		572	}
		573
		574	private ResolverHook begin(Collection<BundleRevision> triggers) {
		575	ResolverHookFactory current;
		576	synchronized (this.monitor) {
		577	current = this.hookFactory;
		578	}
		579	ResolverHook newHook = current.begin(triggers);
545	synchronized (this.monitor) {	580	synchronized (this.monitor) {
546	this.hook = hook;	581	this.hook = newHook;
547	}	582	}
		583	return newHook;
548	}	584	}
549		585
550	public ResolverHook getResolverHook() {	586	public ResolverHook getResolverHook() {
Lines 874-883 Link Here
874	return symbolicName != null ? symbolicName : Constants.getInternalSymbolicName();	910	return symbolicName != null ? symbolicName : Constants.getInternalSymbolicName();
875	}	911	}
876		912
877	/**
878	* Returns the latest versions BundleDescriptions which have old removal pending versions.
879	* @return the BundleDescriptions that have removal pending versions.
880	*/
881	public BundleDescription[] getRemovalPending() {	913	public BundleDescription[] getRemovalPending() {
882	synchronized (this.monitor) {	914	synchronized (this.monitor) {
883	return removalPendings.toArray(new BundleDescription[removalPendings.size()]);	915	return removalPendings.toArray(new BundleDescription[removalPendings.size()]);
Lines 891-896 Link Here
891	}	923	}
892	}	924	}
893		925
		926	public Collection<BundleDescription> getDependencyClosure(Collection<BundleDescription> bundles) {
		927	BundleDescription[] removals = getRemovalPending();
		928	Set<BundleDescription> result = new HashSet<BundleDescription>();
		929	for (BundleDescription bundle : bundles) {
		930	addDependents(bundle, result, removals);
		931	}
		932	return result;
		933	}
		934
		935	private static void addDependents(BundleDescription bundle, Set<BundleDescription> result, BundleDescription[] removals) {
		936	if (result.contains(bundle))
		937	return; // avoid cycles
		938	result.add(bundle);
		939	BundleDescription[] dependents = bundle.getDependents();
		940	for (BundleDescription dependent : dependents)
		941	addDependents(dependent, result, removals);
		942	// check if this is a removal pending
		943	for (BundleDescription removed : removals) {
		944	if (removed.getBundleId() == bundle.getBundleId())
		945	addDependents(removed, result, removals);
		946	}
		947	}
		948
894	/**	949	/**
895	* Returns the latest versions BundleDescriptions which have old removal pending versions.	950	* Returns the latest versions BundleDescriptions which have old removal pending versions.
896	* @return the BundleDescriptions that have removal pending versions.	951	* @return the BundleDescriptions that have removal pending versions.
Lines 915-925 Link Here
915	return null;	970	return null;
916	fullyLoad();	971	fullyLoad();
917	synchronized (this.monitor) {	972	synchronized (this.monitor) {
918	ResolverHook currentHook = getResolverHook();	973	ResolverHook currentHook = null;
919	try {	974	try {
920	resolving = true;	975	resolving = true;
921	if (currentHook != null)	976	ResolverHookFactory currentFactory = hookFactory;
922	currentHook.begin();	977	if (currentFactory != null) {
		978	Collection<BundleRevision> triggers = new ArrayList<BundleRevision>(1);
		979	triggers.add(importingBundle);
		980	triggers = Collections.unmodifiableCollection(triggers);
		981	currentHook = begin(triggers);
		982	}
923	// ask the resolver to resolve our dynamic import	983	// ask the resolver to resolve our dynamic import
924	ExportPackageDescriptionImpl result = (ExportPackageDescriptionImpl) resolver.resolveDynamicImport(importingBundle, requestedPackage);	984	ExportPackageDescriptionImpl result = (ExportPackageDescriptionImpl) resolver.resolveDynamicImport(importingBundle, requestedPackage);
925	if (result == null)	985	if (result == null)

Return to bug 326011

Lines 182-190 Link Here

(-)core/framework/org/eclipse/osgi/framework/internal/core/PackageAdminImpl.java (-36 / +30 lines)
182		182
183	public boolean resolveBundles(Bundle[] bundles) {	183	public boolean resolveBundles(Bundle[] bundles) {
184	framework.checkAdminPermission(framework.systemBundle, AdminPermission.RESOLVE);	184	framework.checkAdminPermission(framework.systemBundle, AdminPermission.RESOLVE);
185	doResolveBundles(null, false, null);
186	if (bundles == null)	185	if (bundles == null)
187	bundles = framework.getAllBundles();	186	bundles = framework.getAllBundles();
		187	doResolveBundles(bundles, false, null);
188	for (int i = 0; i < bundles.length; i++)	188	for (int i = 0; i < bundles.length; i++)
189	if (!((AbstractBundle) bundles[i]).isResolved())	189	if (!((AbstractBundle) bundles[i]).isResolved())
190	return false;	190	return false;
Lines 193-199 Link Here
193	}	193	}
194		194
195	// This method is protected to enable a work around to bug 245251	195	// This method is protected to enable a work around to bug 245251
196	synchronized protected void doResolveBundles(AbstractBundle[] bundles, boolean refreshPackages, FrameworkListener[] listeners) {	196	synchronized protected void doResolveBundles(Bundle[] bundles, boolean refreshPackages, FrameworkListener[] listeners) {
197	try {	197	try {
198	if (Profile.PROFILE && Profile.STARTUP)	198	if (Profile.PROFILE && Profile.STARTUP)
199	Profile.logEnter("resolve bundles"); //$NON-NLS-1$	199	Profile.logEnter("resolve bundles"); //$NON-NLS-1$
Lines 201-212 Link Here
201	State systemState = framework.adaptor.getState();	201	State systemState = framework.adaptor.getState();
202	BundleDescription[] descriptions = null;	202	BundleDescription[] descriptions = null;
203	int numBundles = bundles == null ? 0 : bundles.length;	203	int numBundles = bundles == null ? 0 : bundles.length;
204	if (!refreshPackages)	204	if (!refreshPackages) {
205	// in this case we must make descriptions non-null so we do	205	List<BundleDescription> resolving = new ArrayList<BundleDescription>();
206	// not force the removal pendings to be processed when resolving	206	for (Bundle bundle : bundles) {
207	// the state.	207	BundleDescription description = ((AbstractBundle) bundle).getBundleDescription();
208	descriptions = new BundleDescription[0];	208	if (((bundle.getState() & Bundle.UNINSTALLED) == 0) && description != null)
209	else if (numBundles > 0) {	209	resolving.add(description);
		210	}
		211	descriptions = resolving.toArray(new BundleDescription[resolving.size()]);
		212	} else if (numBundles > 0) {
210	// populate the resolved hosts package sources first (do this outside sync block: bug 280929)	213	// populate the resolved hosts package sources first (do this outside sync block: bug 280929)
211	populateLoaders(framework.getAllBundles());	214	populateLoaders(framework.getAllBundles());
212	synchronized (framework.bundles) {	215	synchronized (framework.bundles) {
Lines 214-220 Link Here
214	List<BundleDescription> results = new ArrayList<BundleDescription>(numBundles);	217	List<BundleDescription> results = new ArrayList<BundleDescription>(numBundles);
215	BundleDelta[] addDeltas = null;	218	BundleDelta[] addDeltas = null;
216	for (int i = 0; i < numBundles; i++) {	219	for (int i = 0; i < numBundles; i++) {
217	BundleDescription description = bundles[i].getBundleDescription();	220	BundleDescription description = ((AbstractBundle) bundles[i]).getBundleDescription();
218	if (description != null && description.getBundleId() != 0 && !results.contains(description))	221	if (description != null && description.getBundleId() != 0 && !results.contains(description))
219	results.add(description);	222	results.add(description);
220	// add in any bundles that have the same symbolic name see bug (169593)	223	// add in any bundles that have the same symbolic name see bug (169593)
Lines 235-241 Link Here
235	descriptions = (results.size() == 0 ? null : results.toArray(new BundleDescription[results.size()]));	238	descriptions = (results.size() == 0 ? null : results.toArray(new BundleDescription[results.size()]));
236	}	239	}
237	}	240	}
238	BundleDelta[] delta = systemState.resolve(descriptions).getChanges();	241	BundleDelta[] delta = systemState.resolve(descriptions, refreshPackages).getChanges();
239	processDelta(delta, refreshPackages, systemState);	242	processDelta(delta, refreshPackages, systemState);
240	} catch (Throwable t) {	243	} catch (Throwable t) {
241	if (Debug.DEBUG_PACKAGEADMIN) {	244	if (Debug.DEBUG_PACKAGEADMIN) {
Lines 743-749 Link Here
743	// We currently have three places this is kept (PackageAdminImpl, StateImpl and ResolverImpl)	746	// We currently have three places this is kept (PackageAdminImpl, StateImpl and ResolverImpl)
744	// Using the state's because it has easy access to the uninstalled Bundle objects	747	// Using the state's because it has easy access to the uninstalled Bundle objects
745	BundleDescription[] removals = framework.adaptor.getState().getRemovalPending();	748	BundleDescription[] removals = framework.adaptor.getState().getRemovalPending();
746	Collection<Bundle> result = new HashSet<Bundle>();	749	Set<Bundle> result = new HashSet<Bundle>();
747	for (int i = 0; i < removals.length; i++) {	750	for (int i = 0; i < removals.length; i++) {
748	Object ref = removals[i].getUserObject();	751	Object ref = removals[i].getUserObject();
749	if (ref instanceof BundleReference)	752	if (ref instanceof BundleReference)
Lines 753-789 Link Here
753	}	756	}
754		757
755	public Collection<Bundle> getDependencyClosure(Collection<Bundle> bundles) {	758	public Collection<Bundle> getDependencyClosure(Collection<Bundle> bundles) {
756	State state = framework.adaptor.getState();	759	Collection<BundleDescription> descriptions = getDescriptionClosure(bundles);
757	BundleDescription[] removals = state.getRemovalPending();
758	Set<Bundle> result = new HashSet<Bundle>();	760	Set<Bundle> result = new HashSet<Bundle>();
759	for (Bundle bundle : bundles) {	761	for (BundleDescription description : descriptions) {
760	addDependents(bundle, result, removals, state);	762	Object userObject = description.getUserObject();
		763	if (userObject instanceof BundleReference) {
		764	Bundle bundle = ((BundleReference) userObject).getBundle();
		765	if (bundle != null)
		766	result.add(bundle);
		767	}
761	}	768	}
762	return result;	769	return result;
763	}	770	}
764		771
765	private static void addDependents(Bundle bundle, Set<Bundle> result, BundleDescription[] removals, State state) {	772	private Collection<BundleDescription> getDescriptionClosure(Collection<Bundle> bundles) {
766	if (result.contains(bundle))	773	State state = framework.adaptor.getState();
767	return; // avoid cycles	774	Collection<BundleDescription> descriptions = new ArrayList<BundleDescription>();
768	result.add(bundle);	775	for (Bundle bundle : bundles) {
769	BundleDescription description = state.getBundle(bundle.getBundleId());	776	BundleDescription description = state.getBundle(bundle.getBundleId());
770	addDependents(description, result, removals, state);	777	if (description != null)
771	// check if this is a removal pending	778	descriptions.add(description);
772	for (BundleDescription removed : removals) {
773	if (removed.getBundleId() == bundle.getBundleId())
774	addDependents(removed, result, removals, state);
775	}	779	}
776		780	return state.getDependencyClosure(descriptions);
777	}	781	}
778		782
779	private static void addDependents(BundleDescription description, Set<Bundle> result, BundleDescription[] removals, State state) {
780	if (description == null)
781	return;
782	BundleDescription[] dependents = description.getDependents();
783	for (BundleDescription dependent : dependents) {
784	Object ref = dependent.getUserObject();
785	if (ref instanceof BundleReference)
786	addDependents(((BundleReference) ref).getBundle(), result, removals, state);
787	}
788	}
789	}	783	}

Lines 10-15 Link Here

(-)core/adaptor/org/eclipse/osgi/service/resolver/State.java (-2 / +44 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.osgi.service.resolver;	11	package org.eclipse.osgi.service.resolver;
12		12
		13	import java.util.Collection;
13	import java.util.Dictionary;	14	import java.util.Dictionary;
14	import org.osgi.framework.BundleException;	15	import org.osgi.framework.BundleException;
15	import org.osgi.framework.Version;	16	import org.osgi.framework.Version;
Lines 346-352 Link Here
346		347
347	/**	348	/**
348	* Resolves the constraints contained in this state using the resolver	349	* Resolves the constraints contained in this state using the resolver
349	* currently associated with the state in a incremental, "least-perturbing"	350	* currently associated with the state in an incremental, "least-perturbing"
350	* mode, and returns a delta describing the changes in resolved states and	351	* mode, and returns a delta describing the changes in resolved states and
351	* dependencies in the state.	352	* dependencies in the state.
352	*	353	*
Lines 359-372 Link Here
359	public StateDelta resolve(BundleDescription[] discard);	360	public StateDelta resolve(BundleDescription[] discard);
360		361
361	/**	362	/**
		363	* Resolves the constraints contained in this state using the resolver
		364	* currently associated with the state in an incremental, "least-perturbing"
		365	* mode, and returns a delta describing the changes in resolved states and
		366	* dependencies in the state. If discard is set to true the
		367	* the descriptions contained in the resolve array will have their
		368	* current resolution state discarded and will be re-resolved.
		369	* This method will attempt to resolve the supplied descriptions
		370	* and may attempt to resolve any other unresolved descriptions contained
		371	* in this state.
		372	*
		373	* @param resolve an array containing descriptions for bundles to resolve.
		374	* @param discard a value of true indicates the resolve descriptions
		375	* should have their current resolution state discarded and re-resolved.
		376	* @return a delta describing the changes in the resolved state and
		377	* interconnections.
		378	* @since 3.7
		379	*/
		380	public StateDelta resolve(BundleDescription[] resolve, boolean discard);
		381
		382	/**
362	* Sets the version overrides which are to be applied during the resolutoin	383	* Sets the version overrides which are to be applied during the resolutoin
363	* of this state. Version overrides allow external forces to	384	* of this state. Version overrides allow external forces to
364	* refine/override the version constraints setup by the components in the	385	* refine/override the version constraints setup by the components in the
365	* state.	386	* state.
366	*	387	*
367	* @param value	388	* @param value
		389	* @deprecated The exact form of this has never been defined. There is
		390	* no alternative method available.
368	*/	391	*/
369	// TODO the exact form of this is not defined as yet.
370	public void setOverrides(Object value);	392	public void setOverrides(Object value);
371		393
372	/**	394	/**
Lines 385-390 Link Here
385	public BundleDescription[] getRemovalPending();	407	public BundleDescription[] getRemovalPending();
386		408
387	/**	409	/**
		410	* Returns the dependency closure for the specified bundles.
		411	*
		412	* <p>
		413	* A graph of bundles is computed starting with the specified bundles. The
		414	* graph is expanded by adding any bundle that is either wired to a package
		415	* that is currently exported by a bundle in the graph or requires a bundle
		416	* in the graph. The graph is fully constructed when there is no bundle
		417	* outside the graph that is wired to a bundle in the graph. The graph may
		418	* contain removal pending bundles.
		419	*
		420	* @param bundles The initial bundles for which to generate the dependency
		421	* closure.
		422	* @return A collection containing a snapshot of the dependency closure of
		423	* the specified bundles, or an empty collection if there were no
		424	* specified bundles.
		425	* @since 3.7
		426	*/
		427	public Collection<BundleDescription> getDependencyClosure(Collection<BundleDescription> bundles);
		428
		429	/**
388	* Returns whether this state is empty.	430	* Returns whether this state is empty.
389	* @return <code>true</code> if this state is empty, <code>false</code>	431	* @return <code>true</code> if this state is empty, <code>false</code>
390	* otherwise	432	* otherwise

Removed Link Here

(-)core/framework/org/eclipse/osgi/framework/internal/core/CoreResolverHook.java (-178 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
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	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.osgi.framework.internal.core;
12
13	import java.util.*;
14	import org.eclipse.osgi.framework.debug.Debug;
15	import org.eclipse.osgi.internal.serviceregistry.*;
16	import org.eclipse.osgi.util.NLS;
17	import org.osgi.framework.*;
18	import org.osgi.framework.hooks.resolver.ResolverHook;
19	import org.osgi.framework.wiring.BundleRevision;
20	import org.osgi.framework.wiring.Capability;
21
22	/**
23	* This class encapsulates the delegation to ResolverHooks that are registered with the service
24	* registry. This way the resolver implementation only has to call out to a single hook
25	* which does all the necessary service registry lookups.
26	*
27	* This class is not thread safe and expects external synchronization.
28	*
29	*/
30	public class CoreResolverHook implements ResolverHook {
31	// need a tuple to hold the service reference and hook object
32	// do not use a map for performance reasons; no need to hash based on a key.
33	static class HookReference {
34	public HookReference(ServiceReferenceImpl<ResolverHook> reference, ResolverHook hook) {
35	this.reference = reference;
36	this.hook = hook;
37	}
38
39	final ServiceReferenceImpl<ResolverHook> reference;
40	final ResolverHook hook;
41	}
42
43	private final BundleContextImpl context;
44	private final ServiceRegistry registry;
45	private final List<HookReference> hooks = new ArrayList<HookReference>(0);
46
47	public CoreResolverHook(BundleContextImpl context, ServiceRegistry registry) {
48	this.context = context;
49	this.registry = registry;
50	}
51
52	private void handleHookException(Throwable t, ResolverHook hook, String method, Bundle hookBundle) {
53	if (Debug.DEBUG_HOOKS) {
54	Debug.println(hook.getClass().getName() + "." + method + "() exception: " + t.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$
55	Debug.printStackTrace(t);
56	}
57	// allow the adaptor to handle this unexpected error
58	context.framework.getAdaptor().handleRuntimeError(t);
59	ServiceException se = new ServiceException(NLS.bind(Msg.SERVICE_FACTORY_EXCEPTION, hook.getClass().getName(), method), t);
60	context.framework.publishFrameworkEvent(FrameworkEvent.ERROR, hookBundle, se);
61	}
62
63	private ServiceReferenceImpl<ResolverHook>[] getHookReferences() {
64	try {
65	@SuppressWarnings("unchecked")
66	ServiceReferenceImpl<ResolverHook>[] result = (ServiceReferenceImpl<ResolverHook>[]) registry.getServiceReferences(context, ResolverHook.class.getName(), null, false, false);
67	return result;
68	} catch (InvalidSyntaxException e) {
69	// cannot happen; no filter
70	return null;
71	}
72	}
73
74	public void begin() {
75	if (Debug.DEBUG_HOOKS) {
76	Debug.println("ResolverHook.begin"); //$NON-NLS-1$
77	}
78	ServiceReferenceImpl<ResolverHook>[] refs = getHookReferences();
79	if (refs == null \|\| refs.length == 0)
80	return;
81	for (ServiceReferenceImpl<ResolverHook> hookRef : refs) {
82	ResolverHook hook = context.getService(hookRef);
83	if (hook != null) {
84	hooks.add(new HookReference(hookRef, hook));
85	try {
86	hook.begin();
87	} catch (Throwable t) {
88	handleHookException(t, hook, "begin", hookRef.getBundle()); //$NON-NLS-1$
89	}
90	}
91	}
92	}
93
94	public void filterResolvable(Collection<BundleRevision> candidates) {
95	if (Debug.DEBUG_HOOKS) {
96	Debug.println("ResolverHook.filterResolvable(" + candidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$
97	}
98	if (hooks.isEmpty())
99	return;
100	candidates = new ShrinkableCollection<BundleRevision>(candidates);
101	for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
102	HookReference hookRef = iHooks.next();
103	if (hookRef.reference.getBundle() == null) {
104	iHooks.remove();
105	} else {
106	try {
107	hookRef.hook.filterResolvable(candidates);
108	} catch (Throwable t) {
109	handleHookException(t, hookRef.hook, "filterResolvable", hookRef.reference.getBundle()); //$NON-NLS-1$
110	}
111	}
112	}
113	}
114
115	public void filterSingletonCollisions(Capability singleton, Collection<Capability> collisionCandidates) {
116	if (Debug.DEBUG_HOOKS) {
117	Debug.println("ResolverHook.filterSingletonCollisions(" + singleton + ", " + collisionCandidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
118	}
119	if (hooks.isEmpty())
120	return;
121	collisionCandidates = new ShrinkableCollection<Capability>(collisionCandidates);
122	for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
123	HookReference hookRef = iHooks.next();
124	if (hookRef.reference.getBundle() == null) {
125	iHooks.remove();
126	} else {
127	try {
128	hookRef.hook.filterSingletonCollisions(singleton, collisionCandidates);
129	} catch (Throwable t) {
130	handleHookException(t, hookRef.hook, "filterSingletonCollisions", hookRef.reference.getBundle()); //$NON-NLS-1$
131	}
132	}
133	}
134	}
135
136	public void filterMatches(BundleRevision requirer, Collection<Capability> candidates) {
137	if (Debug.DEBUG_HOOKS) {
138	Debug.println("ResolverHook.filterMatches(" + requirer + ", " + candidates + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
139	}
140	if (hooks.isEmpty())
141	return;
142	candidates = new ShrinkableCollection<Capability>(candidates);
143	for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
144	HookReference hookRef = iHooks.next();
145	if (hookRef.reference.getBundle() == null) {
146	iHooks.remove();
147	} else {
148	try {
149	hookRef.hook.filterMatches(requirer, candidates);
150	} catch (Throwable t) {
151	handleHookException(t, hookRef.hook, "filterMatches", hookRef.reference.getBundle()); //$NON-NLS-1$
152	}
153	}
154	}
155	}
156
157	public void end() {
158	if (Debug.DEBUG_HOOKS) {
159	Debug.println("ResolverHook.end"); //$NON-NLS-1$
160	}
161	if (hooks.isEmpty())
162	return;
163	for (Iterator<HookReference> iHooks = hooks.iterator(); iHooks.hasNext();) {
164	HookReference hookRef = iHooks.next();
165	// We do not remove unregistered services here because we are going to remove of of them at the end
166	if (hookRef.reference.getBundle() != null) {
167	try {
168	hookRef.hook.end();
169	} catch (Throwable t) {
170	handleHookException(t, hookRef.hook, "end", hookRef.reference.getBundle()); //$NON-NLS-1$
171	}
172	context.ungetService(hookRef.reference);
173	}
174	}
175	hooks.clear();
176	}
177
178	}

Lines 24-35 Link Here

(-)osgi/src/org/osgi/framework/hooks/resolver/ResolverHook.java (-26 / +26 lines)
24	import org.osgi.framework.wiring.FrameworkWiring;	24	import org.osgi.framework.wiring.FrameworkWiring;
25		25
26	/**	26	/**
27	* OSGi Framework Resolver Hook Service.	27	* OSGi Framework Resolver Hook instances are obtained from the OSGi {@link ResolverHookFactory
		28	* Framework Resolver Hook Factory} service.
28	*	29	*
29	* <p>	30	* <p>
30	* Services registered with this service interface will be called by the framework during a resolve	31	* A Resolver Hook instance is called by the framework during a resolve
31	* process. The framework must, at most, have one resolve process running at any given point	32	* process. A resolver hook may influence the outcome of a resolve process by removing entries
32	* in time. A resolver hook may influence the outcome of a resolve process by removing entries
33	* from shrinkable collections that are passed to the hook during a resolve process. A shrinkable	33	* from shrinkable collections that are passed to the hook during a resolve process. A shrinkable
34	* collection is a {@code Collection} that supports all remove operations. Any other attempts to modify	34	* collection is a {@code Collection} that supports all remove operations. Any other attempts to modify
35	* a shrinkable collection will result in an {@code UnsupportedOperationException} being thrown.	35	* a shrinkable collection will result in an {@code UnsupportedOperationException} being thrown.
Lines 37-54 Link Here
37	* The following steps outline the way a framework uses the resolver hooks during a resolve	37	* The following steps outline the way a framework uses the resolver hooks during a resolve
38	* process.	38	* process.
39	* <ol>	39	* <ol>
40	* <li> Collect a snapshot of registered resolver hooks that will be called during the	40	* <li> Collect a snapshot of registered resolver hook factories that will be called during the
41	* current resolve process. Any hooks registered after the snapshot is taken must not be called	41	* current resolve process. Any hook factories registered after the snapshot is taken must not be called
42	* during the current resolve process. A resolver hook contained in the snapshot may become	42	* during the current resolve process. A resolver hook factory contained in the snapshot may become
43	* unregistered during the resolve process. The framework should handle this and stop calling	43	* unregistered during the resolve process. The framework should handle this and stop calling
44	* the unregistered hook for the remainder of the resolve process.</li>	44	* the resolver hook instance provided by the unregistered hook factory for the remainder of the resolve process.</li>
45	* <li> For each registered hook call the {@link #begin()} method to inform the hooks about a resolve	45	* <li> For each registered hook factory call the {@link ResolverHookFactory#begin(Collection)} method to inform the
46	* process beginning.</li>	46	* hooks about a resolve process beginning and to obtain a Resolver Hook instance that will be used for the duration
		47	* of the resolve process.</li>
47	* <li> Determine the collection of unresolved bundle revisions that may be considered for resolution during	48	* <li> Determine the collection of unresolved bundle revisions that may be considered for resolution during
48	* the current resolution process and place each of the bundle revisions in a shrinkable collection	49	* the current resolution process and place each of the bundle revisions in a shrinkable collection
49	* <b>{@code R}</b>.	50	* <b>{@code R}</b>.
50	* <ol type="a">	51	* <ol type="a">
51	* <li> For each registered hook call the {@link #filterResolvable(Collection)} method with the	52	* <li> For each resolver hook call the {@link #filterResolvable(Collection)} method with the
52	* shrinkable collection <b>{@code R}</b>.</li>	53	* shrinkable collection <b>{@code R}</b>.</li>
53	* </ol>	54	* </ol>
54	* </li>	55	* </li>
Lines 66-72 Link Here
66	* <li> Remove the {@link Capability#BUNDLE_CAPABILITY osgi.bundle} capability provided by	67	* <li> Remove the {@link Capability#BUNDLE_CAPABILITY osgi.bundle} capability provided by
67	* bundle revision <b>{@code B}</b> from shrinkable collection <b>{@code S}</b>. A singleton bundle	68	* bundle revision <b>{@code B}</b> from shrinkable collection <b>{@code S}</b>. A singleton bundle
68	* cannot collide with itself.</li>	69	* cannot collide with itself.</li>
69	* <li> For each registered hook call the {@link #filterSingletonCollisions(Capability, Collection)}	70	* <li> For each resovler hook call the {@link #filterSingletonCollisions(Capability, Collection)}
70	* with the {@link Capability#BUNDLE_CAPABILITY osgi.bundle} capability provided by bundle revision	71	* with the {@link Capability#BUNDLE_CAPABILITY osgi.bundle} capability provided by bundle revision
71	* <b>{@code B}</b> and the shrinkable collection <b>{@code S}</b></li>	72	* <b>{@code B}</b> and the shrinkable collection <b>{@code S}</b></li>
72	* <li> The shrinkable collection <b>{@code S}</b> now contains all singleton {@link Capability#BUNDLE_CAPABILITY	73	* <li> The shrinkable collection <b>{@code S}</b> now contains all singleton {@link Capability#BUNDLE_CAPABILITY
Lines 79-93 Link Here
79	* <ol type="a">	80	* <ol type="a">
80	* <li> For each requirement <b>{@code T}</b> specified by bundle revision <b>{@code B}</b> determine the	81	* <li> For each requirement <b>{@code T}</b> specified by bundle revision <b>{@code B}</b> determine the
81	* collection of capabilities that satisfy (or match) the requirement and place each matching capability into	82	* collection of capabilities that satisfy (or match) the requirement and place each matching capability into
82	* a shrinkable collection <b>{@code C}</b>.</li>	83	* a shrinkable collection <b>{@code C}</b>. A capability is considered to match a particular requirement
83	* <li> For each registered hook call the {@link #filterMatches(BundleRevision, Collection)} with the	84	* if its attributes satisfy a specified requirement and the requirer bundle has permission to access the
		85	* capability.</li>
		86	* <li> For each resolver hook call the {@link #filterMatches(BundleRevision, Collection)} with the
84	* bundle revision <b>{@code B}</b> and the shrinkable collection <b>{@code C}</b>.</li>	87	* bundle revision <b>{@code B}</b> and the shrinkable collection <b>{@code C}</b>.</li>
85	* <li> The shrinkable collection <b>{@code C}</b> now contains all the capabilities that may be used to	88	* <li> The shrinkable collection <b>{@code C}</b> now contains all the capabilities that may be used to
86	* satisfy the requirement <b>{@code T}</b>. Any other capabilities that got removed from the	89	* satisfy the requirement <b>{@code T}</b>. Any other capabilities that got removed from the
87	* shrinkable collection <b>{@code C}</b> must not be used to satisfy requirement <b>{@code T}</b>.</li>	90	* shrinkable collection <b>{@code C}</b> must not be used to satisfy requirement <b>{@code T}</b>.</li>
88	* </ol>	91	* </ol>
89	* </li>	92	* </li>
90	* <li> For each registered hook call the {@link #end()} method to inform the hooks about a resolve	93	* <li> For each resolver hook call the {@link #end()} method to inform the hooks about a resolve
91	* process ending.</li>	94	* process ending.</li>
92	* </ol>	95	* </ol>
93	* In all cases, the order in which the resolver hooks are called is the reverse compareTo ordering of	96	* In all cases, the order in which the resolver hooks are called is the reverse compareTo ordering of
Lines 100-116 Link Here
100	* resolve process (e.g. by calling {@link Bundle#start()} or {@link FrameworkWiring#resolveBundles(Collection)}).	103	* resolve process (e.g. by calling {@link Bundle#start()} or {@link FrameworkWiring#resolveBundles(Collection)}).
101	* The framework must detect this and throw an {@link IllegalStateException}.	104	* The framework must detect this and throw an {@link IllegalStateException}.
102	*	105	*
		106	* @see ResolverHookFactory
103	* @ThreadSafe	107	* @ThreadSafe
104	* @version $Id: 17fa0cb4223f6e2e6738ac675099d5aa8b44ab46 $	108	* @version $Id: e896c443a68b3ea287735c9c19f0b1c62bd4755d $
105	*/	109	*/
106	public interface ResolverHook {	110	public interface ResolverHook {
107
108	/**
109	* This method is called once at the beginning of the resolve process
110	* before any other methods are called on this hook.
111	*/
112	void begin();
113
114	/**	111	/**
115	* Filter resolvable candidates hook method. This method may be called	112	* Filter resolvable candidates hook method. This method may be called
116	* multiple times during a single resolve process.	113	* multiple times during a single resolve process.
Lines 158-163 Link Here
158	* <p>	155	* <p>
159	* All of the candidates will have the same name space and will	156	* All of the candidates will have the same name space and will
160	* match a requirement of the requirer.	157	* match a requirement of the requirer.
		158	* <p>
		159	* If the Java Runtime Environment supports permissions then the collection of
		160	* candidates will only contain candidates for which the requirer has permission to
		161	* access.
161	* @param requirer the bundle revision which contains a requirement	162	* @param requirer the bundle revision which contains a requirement
162	* @param candidates a collection of candidates that match a requirement of the requirer	163	* @param candidates a collection of candidates that match a requirement of the requirer
163	*/	164	*/
Lines 166-174 Link Here
166	/**	167	/**
167	* This method is called once at the end of the resolve process.	168	* This method is called once at the end of the resolve process.
168	* After the end method is called the resolve process has ended.	169	* After the end method is called the resolve process has ended.
169	* No methods will be called on this hook except after the	170	* The framework must not hold onto this resolver hook instance
170	* {@link #begin() begin} method is called again to indicate	171	* after end has been called.
171	* a new resolve process is beginning.
172	*/	172	*/
173	void end();	173	void end();
174	}	174	}

Added Link Here

(-)osgi/src/org/osgi/framework/hooks/resolver/ResolverHookFactory.java (+83 lines)
1	/*
2	* Copyright (c) OSGi Alliance (2010). All Rights Reserved.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package org.osgi.framework.hooks.resolver;
18
19	import java.util.Collection;
20
21	import org.osgi.framework.Bundle;
22	import org.osgi.framework.wiring.BundleRevision;
23	import org.osgi.framework.wiring.FrameworkWiring;
24
25	/**
26	* OSGi Framework Resolver Hook Factory Service.
27	*
28	* <p>
29	* Bundles registering this service will be called by the framework during
30	* a bundle resolver process to obtain a {@link ResolverHook resolver hook}
31	* instance which will be used for the duration of a resolve process.
32	*
33	* @ThreadSafe
34	* @see ResolverHook
35	* @version $Id: 18ea1ec1f14f47410a43e99be4da3b2583149722 $
36	*/
37	public interface ResolverHookFactory {
38	/**
39	* This method is called by the framework each time a resolve process begins
40	* to obtain a {@link ResolverHook resolver hook} instance. This resolver hook
41	* instance will be used for the duration of the resolve process. At the end of
42	* the resolve process the method {@link ResolverHook#end()} must be called by
43	* the framework and the framework must not hold any references of the resolver
44	* hook instance.
45	* <p>
46	* The triggers represent the collection of bundles which triggered
47	* the resolve process. This collection may be empty if the triggers
48	* cannot be determined by the framework. In most cases the triggers
49	* can easily be determined. Calling certain methods on
50	* {@link Bundle bundle} when a bundle is in the {@link Bundle#INSTALLED INSTALLED}
51	* state will cause the framework to begin a resolve process in order to resolve the
52	* bundle. The following methods will start a resolve process in this case:
53	* <ul>
54	* <li>{@link Bundle#start() start}</li>
55	* <li>{@link Bundle#loadClass(String) loadClass}</li>
56	* <li>{@link Bundle#findEntries(String, String, boolean) findEntries}</li>
57	* <li>{@link Bundle#getResource(String) getResource}</li>
58	* <li>{@link Bundle#getResources(String) getResources}</li>
59	* </ul>
60	* In such cases the collection will contain the single bundle which the
61	* framework is trying to resolve. Other cases will cause multiple bundles to be
62	* included in the trigger bundles collection. When {@link FrameworkWiring#resolveBundles(Collection)
63	* resolveBundles} is called the collection of triggers must include all the current bundle
64	* revisions for bundles passed to resolveBundles which have not been uninstalled.
65	* <p>
66	* When {@link FrameworkWiring#refreshBundles(Collection, org.osgi.framework.FrameworkListener...)}
67	* is called the collection of triggers is determined with the following steps:
68	* <ul>
69	* <li>If the collection of bundles passed is null then {@link FrameworkWiring#getRemovalPendingBundles()}
70	* is called to get the initial collection of bundles.</li>
71	* <li>The equivalent of calling {@link FrameworkWiring#getDependencyClosure(Collection)} is called with
72	* the initial collection of bundles to get the dependency closure collection of the bundles being refreshed.</li>
73	* <li>Remove any non-active bundles from the dependency closure collection.</li>
74	* <li>For each bundle remaining in the dependency closure collection get the current bundle revision
75	* and add it to the collection of triggers.</li>
76	* </ul>
77	* @param triggers an unmodifiable collection of bundles which triggered the resolve process.
78	* This collection may be empty if the collection of trigger bundles cannot be
79	* determined.
80	* @return a resolver hook instance to be used for the duration of the resolve process.
81	*/
82	ResolverHook begin(Collection<BundleRevision> triggers);
83	}