bundles/org.eclipse.osgi/core/composite/org/eclipse/osgi/internal/composite/CompositeImpl.java - equinox/rt.equinox.framework - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 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.internal.composite;

 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 import java.net.URLConnection;
 import java.security.AccessControlContext;
 import java.security.AllPermission;
 import java.util.*;
 import org.eclipse.osgi.framework.adaptor.BundleData;
 import org.eclipse.osgi.framework.debug.Debug;
 import org.eclipse.osgi.framework.internal.core.*;
 import org.eclipse.osgi.framework.internal.protocol.ContentHandlerFactory;
 import org.eclipse.osgi.framework.internal.protocol.StreamHandlerFactory;
 import org.eclipse.osgi.internal.composite.CompositeInfo.ClassSpacePolicyInfo;
 import org.eclipse.osgi.internal.composite.CompositeInfo.ServicePolicyInfo;
 import org.eclipse.osgi.internal.loader.BundleLoaderProxy;
 import org.eclipse.osgi.internal.permadmin.SecurityAdmin;
 import org.eclipse.osgi.internal.resolver.StateBuilder;
 import org.eclipse.osgi.internal.resolver.StateObjectFactoryImpl;
 import org.eclipse.osgi.service.resolver.*;
 import org.eclipse.osgi.util.ManifestElement;
 import org.osgi.framework.*;
 import org.osgi.framework.Constants;
 import org.osgi.service.composite.CompositeBundle;
 import org.osgi.service.composite.CompositeConstants;
 import org.osgi.service.condpermadmin.ConditionalPermissionUpdate;

 public class CompositeImpl extends BundleHost implements CompositeBundle {
 	static final StateObjectFactory stateFactory = new StateObjectFactoryImpl();
 	private final ThreadLocal<Boolean> updating = new ThreadLocal<Boolean>() {
 		public Boolean initialValue() {
 			return Boolean.FALSE;
 		}
 	};

 	private final CompositeSystemBundle compositeSystemBundle;
 	private final CompositeInfo compositeInfo;
 	private final StartLevelManager startLevelManager;
 	private final SecurityAdmin securityAdmin;
 	private final StreamHandlerFactory streamHandlerFactory;
 	private final ContentHandlerFactory contentHandlerFactory;
 	private final List<BundleDescription> constituents = new ArrayList<BundleDescription>(0);
 	private final int beginningStartLevel;
 	private final Properties configuration;

 	public CompositeImpl(BundleData bundledata, Framework framework, boolean setCompositeParent) throws BundleException {
 		super(bundledata, framework);
 		compositeSystemBundle = new CompositeSystemBundle((BundleHost) framework.getBundle(0), framework);
 		compositeInfo = createCompositeInfo(setCompositeParent);
 		Object existing = framework.getBundle(bundledata.getBundleID());
 		if (existing != null && existing instanceof CompositeImpl) {
 			checkBSNAndVersions((CompositeImpl) existing, compositeInfo);
 		}

 		startLevelManager = new StartLevelManager(framework, bundledata.getBundleID(), compositeSystemBundle);
 		startLevelManager.initialize();
 		configuration = loadCompositeConfiguration();
 		beginningStartLevel = loadBeginningStartLevel(configuration);
 		if (setCompositeParent) {
 			try {
 				securityAdmin = new SecurityAdmin(framework, framework.getAdaptor().getPermissionStorage(), bundledata.getBundleID());
 			} catch (IOException e) {
 				throw new BundleException("Error creating SecurityAdmin", e); //$NON-NLS-1$
 			}
 			streamHandlerFactory = new StreamHandlerFactory(compositeSystemBundle.getBundleContext(), framework.getAdaptor());
 			contentHandlerFactory = new ContentHandlerFactory(compositeSystemBundle.getBundleContext(), framework.getAdaptor());
 			framework.getStreamHandlerFactory().registerComposite(streamHandlerFactory);
 			framework.getContentHandlerFactory().registerComposite(contentHandlerFactory);
 		} else {
 			securityAdmin = null;
 			streamHandlerFactory = null;
 			contentHandlerFactory = null;
 		}
 	}

 	private void checkBSNAndVersions(CompositeImpl existing, CompositeInfo compositeInfo) throws BundleException {
 		// save off original policy
 		CompositeInfo original = new CompositeInfo(existing.getBundleId(), null, null, null, null, null, null, null, null, null);
 		original.update(existing.compositeInfo);
 		// update current policy
 		existing.compositeInfo.update(compositeInfo);
 		try {
 			validateBSNAndVersions(existing);
 		} finally {
 			existing.compositeInfo.update(original);
 		}
 	}

 	private void validateBSNAndVersions(CompositeImpl composite) throws BundleException {
 		AbstractBundle[] bundles = framework.getBundles(composite.getBundleId());
 		// check that we still have valid BSN/Version consistency
 		for (AbstractBundle bundle : bundles) {
 			if (bundle.getBundleId() == 0) // not the system bundle
 				continue;
 			framework.validateNameAndVersion(bundle.getBundleData());
 			if (bundle instanceof CompositeImpl)
 				validateBSNAndVersions((CompositeImpl) bundle);
 		}
 	}

 	private int loadBeginningStartLevel(Properties config) {
 		String level = config.getProperty(Constants.FRAMEWORK_BEGINNING_STARTLEVEL);
 		if (level == null)
 			return 1;
 		return Integer.parseInt(level);
 	}

 	private Properties loadCompositeConfiguration() throws BundleException {
 		Properties result = new Properties();
 		URL configURL = bundledata.getEntry(CompositeSupport.COMPOSITE_CONFIGURATION);
 		if (configURL == null)
 			return result;
 		InputStream in = null;
 		try {
 			in = configURL.openStream();
 			result.load(configURL.openStream());
 		} catch (IOException e) {
 			throw new BundleException("Error loading composite configuration: " + configURL, e); //$NON-NLS-1$
 		} finally {
 			if (in != null)
 				try {
 					in.close();
 				} catch (IOException e) {
 					// nothing
 				}
 		}
 		return result;
 	}

 	private CompositeInfo createCompositeInfo(boolean setParent) throws BundleException {
 		Dictionary manifest = bundledata.getManifest();
 		String importPackage = (String) manifest.get(CompositeConstants.COMPOSITE_PACKAGE_IMPORT_POLICY);
 		String exportPackage = (String) manifest.get(CompositeConstants.COMPOSITE_PACKAGE_EXPORT_POLICY);
 		String requireBundle = (String) manifest.get(CompositeConstants.COMPOSITE_BUNDLE_REQUIRE_POLICY);
 		String provideBundle = (String) manifest.get(CompositeConstants.COMPOSITE_BUNDLE_PROVIDE_POLICY);
 		String importService = (String) manifest.get(CompositeConstants.COMPOSITE_SERVICE_IMPORT_POLICY);
 		String exportService = (String) manifest.get(CompositeConstants.COMPOSITE_SERVICE_EXPORT_POLICY);

 		BundleContext systemContext = compositeSystemBundle.getBundleContext();

 		BundleDescription desc = stateFactory.createBundleDescription(manifest, bundledata.getLocation(), bundledata.getBundleID());
 		ClassSpacePolicyInfo[] imports = createClassSpacePolicy(importPackage, stateFactory, CompositeConstants.COMPOSITE_PACKAGE_IMPORT_POLICY, desc);
 		ClassSpacePolicyInfo[] exports = createClassSpacePolicy(exportPackage, stateFactory, CompositeConstants.COMPOSITE_PACKAGE_EXPORT_POLICY, desc);
 		ClassSpacePolicyInfo[] requires = createClassSpacePolicy(requireBundle, stateFactory, CompositeConstants.COMPOSITE_BUNDLE_REQUIRE_POLICY, desc);
 		ClassSpacePolicyInfo[] provides = createClassSpacePolicy(provideBundle, stateFactory, CompositeConstants.COMPOSITE_BUNDLE_PROVIDE_POLICY, desc);
 		ServicePolicyInfo[] importServiceFilter = createServicePolicyInfo(importService, stateFactory, CompositeConstants.COMPOSITE_SERVICE_IMPORT_POLICY, systemContext);
 		ServicePolicyInfo[] exportServiceFilter = createServicePolicyInfo(exportService, stateFactory, CompositeConstants.COMPOSITE_SERVICE_EXPORT_POLICY, systemContext);
 		// set the parent info
 		CompositeInfo parentInfo = null;
 		if (setParent) {
 			parentInfo = framework.getCompositeSupport().compositPolicy.getCompositeInfo(bundledata.getCompositeID());
 		}
 		CompositeInfo result = new CompositeInfo(bundledata.getBundleID(), bundledata.getSymbolicName(), bundledata.getVersion(), parentInfo, imports, exports, requires, provides, importServiceFilter, exportServiceFilter);
 		if (setParent) {
 			// add the the composite info as a child of the parent.
 			parentInfo.addChild(result);
 		}
 		return result;
 	}

 	public BundleContext getSystemBundleContext() {
 		if (getState() == Bundle.UNINSTALLED)
 			return null;
 		return compositeSystemBundle.getBundleContext();
 	}

 	public void update() throws BundleException {
 		throw new BundleException("Must update a composite with the update(Map) method.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
 	}

 	public void update(InputStream in) throws BundleException {
 		if (in == RELOAD) {
 			super.update(RELOAD);
 			return;
 		}
 		try {
 			in.close();
 		} catch (IOException e) {
 			// do nothing
 		}
 		update();
 	}

 	public void update(Map<String, String> compositeManifest) throws BundleException {
 		if (Debug.DEBUG && Debug.DEBUG_GENERAL) {
 			Debug.println("update location " + bundledata.getLocation()); //$NON-NLS-1$
 			Debug.println("   from: " + compositeManifest); //$NON-NLS-1$
 		}
 		SecurityManager sm = System.getSecurityManager();
 		if (sm != null)
 			// must have AllPermission to do this
 			sm.checkPermission(new AllPermission());
 		// make a local copy of the manifest first
 		compositeManifest = new HashMap<String, String>(compositeManifest);
 		// make sure the manifest is valid
 		CompositeSupport.validateCompositeManifest(compositeManifest);
 		try {
 			URL configURL = bundledata.getEntry(CompositeSupport.COMPOSITE_CONFIGURATION);
 			Properties config = new Properties();
 			config.load(configURL.openStream());
 			// get an in memory input stream to jar content of the composite we want to install
 			InputStream content = CompositeSupport.getCompositeInput(config, compositeManifest);
 			updating.set(true);
 			// update with the new content
 			super.update(content);
 		} catch (IOException e) {
 			throw new BundleException("Error creating composite bundle", e); //$NON-NLS-1$
 		} finally {
 			updating.set(false);
 		}
 	}

 	@Override
 	protected void updateWorkerPrivileged(URLConnection source, AccessControlContext callerContext) throws BundleException {
 		CompositeInfo originalInfo = createCompositeInfo(false);
 		super.updateWorkerPrivileged(source, callerContext);
 		// update the composite info with the new data.
 		CompositeInfo updatedInfo = createCompositeInfo(false);
 		compositeInfo.update(updatedInfo);
 		AbstractBundle[] bundles = framework.getBundles(getBundleId());
 		// reload all the constituents
 		for (AbstractBundle bundle : bundles) {
 			if (bundle.getBundleId() == 0) // not the system bundle
 				continue;
 			try {
 				bundle.reload();
 			} catch (BundleException e) {
 				framework.publishFrameworkEvent(FrameworkEvent.ERROR, bundle, e);
 			}
 		}
 	}

 	protected void startHook() {
 		startLevelManager.doSetStartLevel(beginningStartLevel);
 	}

 	protected void stopHook() {
 		if (updating.get())
 			startLevelManager.update();
 		else
 			startLevelManager.shutdown();
 	}

 	public void uninstallWorkerPrivileged() throws BundleException {
 		// uninstall the composite first to invalidate the context
 		super.uninstallWorkerPrivileged();
 		Bundle[] bundles = framework.getBundles(getBundleId());
 		// uninstall all the constituents
 		for (int i = 0; i < bundles.length; i++) {
 			if (bundles[i].getBundleId() != 0) // not the system bundle
 				try {
 					bundles[i].uninstall();
 				} catch (BundleException e) {
 					framework.publishFrameworkEvent(FrameworkEvent.ERROR, bundles[i], e);
 				}
 		}
 		// clean up persistent storage associated with this composite
 		framework.getAdaptor().setInitialBundleStartLevel(getBundleId(), -1);
 		securityAdmin.setDefaultPermissions(null);
 		String[] locations = securityAdmin.getLocations();
 		if (locations != null)
 			for (int i = 0; i < locations.length; i++)
 				securityAdmin.setPermissions(locations[i], null);
 		ConditionalPermissionUpdate update = securityAdmin.newConditionalPermissionUpdate();
 		update.getConditionalPermissionInfos().clear();
 		update.commit();
 	}

 	protected void close() {
 		super.close();
 		startLevelManager.cleanup();
 		// remove the composite info from the parent
 		compositeInfo.orphaned();
 		// unregister the composite factory before closing the system bundle
 		getFramework().getStreamHandlerFactory().unregisterComposite(streamHandlerFactory);
 		getFramework().getContentHandlerFactory().unregisterComposite(contentHandlerFactory);
 		compositeSystemBundle.close();
 	}

 	public class CompositeSystemBundle extends InternalSystemBundle {
 		private final BundleHost rootSystemBundle;

 		public CompositeSystemBundle(BundleHost systemBundle, Framework framework) throws BundleException {
 			super(systemBundle.getBundleData(), framework);
 			this.rootSystemBundle = systemBundle;
 			this.state = Bundle.STARTING; // Initial state must be STARTING for composite system bundle
 		}

 		protected BundleContextImpl createContext() {
 			CompositeContext compositeContext = new CompositeContext(this);
 			return compositeContext;
 		}

 		public ServiceReference[] getRegisteredServices() {
 			// TODO this is not scoped; do we care?
 			return rootSystemBundle.getRegisteredServices();
 		}

 		public ServiceReference[] getServicesInUse() {
 			return rootSystemBundle.getServicesInUse();
 		}

 		public void start(int options) throws BundleException {
 			throw new BundleException("Cannot start a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
 		}

 		public void start() throws BundleException {
 			start(0);
 		}

 		public void stop(int options) throws BundleException {
 			throw new BundleException("Cannot stop a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
 		}

 		public void stop() throws BundleException {
 			stop(0);
 		}

 		public void uninstall() throws BundleException {
 			throw new BundleException("Cannot uninstall a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
 		}

 		public void update(InputStream input) throws BundleException {
 			throw new BundleException("Cannot update a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
 		}

 		public void update() throws BundleException {
 			update(null);
 		}

 		public long getCompositeId() {
 			return CompositeImpl.this.getBundleId();
 		}

 		public BundleLoaderProxy getLoaderProxy() {
 			return rootSystemBundle.getLoaderProxy();
 		}

 		protected void close() {
 			super.close();
 			this.state = Bundle.UNINSTALLED;
 		}

 	}

 	public class CompositeContext extends BundleContextImpl {

 		protected CompositeContext(BundleHost bundle) {
 			super(bundle);
 		}

 		protected long getCompositeId() {
 			return CompositeImpl.this.getBundleId();
 		}

 		protected void start() {
 			// nothing;
 		}

 		protected void stop() {
 			// nothing
 		}
 	}

 	public StartLevelManager getStartLevelService() {
 		return startLevelManager;
 	}

 	public SecurityAdmin getSecurityAdmin() {
 		return securityAdmin;
 	}

 	public BundleHost getSystemBundle() {
 		return compositeSystemBundle;
 	}

 	public String getProperty(String key) {
 		SecurityManager sm = System.getSecurityManager();
 		if (sm != null)
 			sm.checkPropertyAccess(key);
 		return configuration.getProperty(key, FrameworkProperties.getProperty(key));
 	}

 	public String setProperty(String key, String value) {
 		SecurityManager sm = System.getSecurityManager();
 		if (sm != null)
 			sm.checkPermission(new PropertyPermission(key, "write")); //$NON-NLS-1$
 		return (String) configuration.setProperty(key, value);
 	}

 	protected void refresh() {
 		super.refresh();
 		loadConstituents();
 	}

 	void loadConstituents() {
 		synchronized (constituents) {
 			constituents.clear();
 			AbstractBundle[] bundles = framework.getBundles(getBundleId());
 			for (int i = 0; i < bundles.length; i++) {
 				if (bundles[i].getBundleId() == 0)
 					continue;
 				BundleDescription constituent = bundles[i].getBundleDescription();
 				if (constituent != null)
 					constituents.add(constituent);
 			}
 		}
 	}

 	void addConstituent(BundleDescription description) {
 		synchronized (constituents) {
 			constituents.add(description);
 		}
 	}

 	BundleDescription[] getConstituentDescriptions() {
 		synchronized (constituents) {
 			return constituents.toArray(new BundleDescription[constituents.size()]);
 		}
 	}

 	private static ClassSpacePolicyInfo[] createClassSpacePolicy(String policySpec, StateObjectFactory factory, String header, BundleDescription desc) throws BundleException {
 		ManifestElement[] policy = ManifestElement.parseHeader(header, policySpec);
 		if (policy == null || policy.length == 0)
 			return null;
 		ArrayList<ClassSpacePolicyInfo> result = new ArrayList<ClassSpacePolicyInfo>(policy.length);
 		for (int i = 0; i < policy.length; i++) {
 			String compositeAffinityName = policy[i].getDirective(CompositeConstants.COMPOSITE_SYMBOLICNAME_DIRECTIVE);
 			VersionRange compositeAffinityVersion = StateBuilder.getVersionRange(policy[i].getDirective(CompositeConstants.COMPOSITE_VERSION_DIRECTIVE));
 			if (header == CompositeConstants.COMPOSITE_PACKAGE_IMPORT_POLICY || header == CompositeConstants.COMPOSITE_PACKAGE_EXPORT_POLICY) {
 				VersionRange versionRange = StateBuilder.getVersionRange(policy[i].getAttribute(Constants.VERSION_ATTRIBUTE));

 				String bundleSymbolicName = policy[i].getAttribute(Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE);
 				VersionRange bundleVersionRange = StateBuilder.getVersionRange(policy[i].getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE));

 				Map attributes = StateBuilder.getAttributes(policy[i], StateBuilder.DEFINED_MATCHING_ATTRS);

 				String[] packageNames = policy[i].getValueComponents();
 				for (int j = 0; j < packageNames.length; j++) {
 					ImportPackageSpecification importSpec = factory.createImportPackageSpecification(packageNames[j], versionRange, bundleSymbolicName, bundleVersionRange, null, attributes, desc);
 					result.add(new ClassSpacePolicyInfo(compositeAffinityName, compositeAffinityVersion, importSpec));
 				}
 			} else {
 				String bsn = policy[i].getValue();
 				VersionRange bundleVersion = StateBuilder.getVersionRange(policy[i].getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE));
 				result.add(new ClassSpacePolicyInfo(compositeAffinityName, compositeAffinityVersion, factory.createBundleSpecification(bsn, bundleVersion, false, false)));
 			}
 		}
 		return result.toArray(new ClassSpacePolicyInfo[result.size()]);
 	}

 	private static ServicePolicyInfo[] createServicePolicyInfo(String policySpec, StateObjectFactory factory, String header, BundleContext context) throws BundleException {
 		ManifestElement[] policy = ManifestElement.parseHeader(header, policySpec);
 		if (policy == null || policy.length == 0)
 			return null;
 		ArrayList<ServicePolicyInfo> result = new ArrayList<ServicePolicyInfo>(policy.length);
 		for (int i = 0; i < policy.length; i++) {
 			String compositeAffinityName = policy[i].getDirective(CompositeConstants.COMPOSITE_SYMBOLICNAME_DIRECTIVE);
 			VersionRange compositeAffinityVersion = StateBuilder.getVersionRange(policy[i].getDirective(CompositeConstants.COMPOSITE_VERSION_DIRECTIVE));
 			String[] filters = policy[i].getValueComponents();
 			for (int j = 0; j < filters.length; j++) {
 				Filter filter = null;
 				try {
 					filter = context.createFilter(filters[i]);
 				} catch (InvalidSyntaxException e) {
 					throw new BundleException("Invalid service sharing policy: " + filters[i], BundleException.MANIFEST_ERROR, e); //$NON-NLS-1$
 				}
 				result.add(new ServicePolicyInfo(compositeAffinityName, compositeAffinityVersion, filter));
 			}
 		}
 		return result.toArray(new ServicePolicyInfo[result.size()]);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009, 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.internal.composite;

	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URL;
	import java.net.URLConnection;
	import java.security.AccessControlContext;
	import java.security.AllPermission;
	import java.util.*;
	import org.eclipse.osgi.framework.adaptor.BundleData;
	import org.eclipse.osgi.framework.debug.Debug;
	import org.eclipse.osgi.framework.internal.core.*;
	import org.eclipse.osgi.framework.internal.protocol.ContentHandlerFactory;
	import org.eclipse.osgi.framework.internal.protocol.StreamHandlerFactory;
	import org.eclipse.osgi.internal.composite.CompositeInfo.ClassSpacePolicyInfo;
	import org.eclipse.osgi.internal.composite.CompositeInfo.ServicePolicyInfo;
	import org.eclipse.osgi.internal.loader.BundleLoaderProxy;
	import org.eclipse.osgi.internal.permadmin.SecurityAdmin;
	import org.eclipse.osgi.internal.resolver.StateBuilder;
	import org.eclipse.osgi.internal.resolver.StateObjectFactoryImpl;
	import org.eclipse.osgi.service.resolver.*;
	import org.eclipse.osgi.util.ManifestElement;
	import org.osgi.framework.*;
	import org.osgi.framework.Constants;
	import org.osgi.service.composite.CompositeBundle;
	import org.osgi.service.composite.CompositeConstants;
	import org.osgi.service.condpermadmin.ConditionalPermissionUpdate;

	public class CompositeImpl extends BundleHost implements CompositeBundle {
	static final StateObjectFactory stateFactory = new StateObjectFactoryImpl();
	private final ThreadLocal<Boolean> updating = new ThreadLocal<Boolean>() {
	public Boolean initialValue() {
	return Boolean.FALSE;
	}
	};

	private final CompositeSystemBundle compositeSystemBundle;
	private final CompositeInfo compositeInfo;
	private final StartLevelManager startLevelManager;
	private final SecurityAdmin securityAdmin;
	private final StreamHandlerFactory streamHandlerFactory;
	private final ContentHandlerFactory contentHandlerFactory;
	private final List<BundleDescription> constituents = new ArrayList<BundleDescription>(0);
	private final int beginningStartLevel;
	private final Properties configuration;

	public CompositeImpl(BundleData bundledata, Framework framework, boolean setCompositeParent) throws BundleException {
	super(bundledata, framework);
	compositeSystemBundle = new CompositeSystemBundle((BundleHost) framework.getBundle(0), framework);
	compositeInfo = createCompositeInfo(setCompositeParent);
	Object existing = framework.getBundle(bundledata.getBundleID());
	if (existing != null && existing instanceof CompositeImpl) {
	checkBSNAndVersions((CompositeImpl) existing, compositeInfo);
	}

	startLevelManager = new StartLevelManager(framework, bundledata.getBundleID(), compositeSystemBundle);
	startLevelManager.initialize();
	configuration = loadCompositeConfiguration();
	beginningStartLevel = loadBeginningStartLevel(configuration);
	if (setCompositeParent) {
	try {
	securityAdmin = new SecurityAdmin(framework, framework.getAdaptor().getPermissionStorage(), bundledata.getBundleID());
	} catch (IOException e) {
	throw new BundleException("Error creating SecurityAdmin", e); //$NON-NLS-1$
	}
	streamHandlerFactory = new StreamHandlerFactory(compositeSystemBundle.getBundleContext(), framework.getAdaptor());
	contentHandlerFactory = new ContentHandlerFactory(compositeSystemBundle.getBundleContext(), framework.getAdaptor());
	framework.getStreamHandlerFactory().registerComposite(streamHandlerFactory);
	framework.getContentHandlerFactory().registerComposite(contentHandlerFactory);
	} else {
	securityAdmin = null;
	streamHandlerFactory = null;
	contentHandlerFactory = null;
	}
	}

	private void checkBSNAndVersions(CompositeImpl existing, CompositeInfo compositeInfo) throws BundleException {
	// save off original policy
	CompositeInfo original = new CompositeInfo(existing.getBundleId(), null, null, null, null, null, null, null, null, null);
	original.update(existing.compositeInfo);
	// update current policy
	existing.compositeInfo.update(compositeInfo);
	try {
	validateBSNAndVersions(existing);
	} finally {
	existing.compositeInfo.update(original);
	}
	}

	private void validateBSNAndVersions(CompositeImpl composite) throws BundleException {
	AbstractBundle[] bundles = framework.getBundles(composite.getBundleId());
	// check that we still have valid BSN/Version consistency
	for (AbstractBundle bundle : bundles) {
	if (bundle.getBundleId() == 0) // not the system bundle
	continue;
	framework.validateNameAndVersion(bundle.getBundleData());
	if (bundle instanceof CompositeImpl)
	validateBSNAndVersions((CompositeImpl) bundle);
	}
	}

	private int loadBeginningStartLevel(Properties config) {
	String level = config.getProperty(Constants.FRAMEWORK_BEGINNING_STARTLEVEL);
	if (level == null)
	return 1;
	return Integer.parseInt(level);
	}

	private Properties loadCompositeConfiguration() throws BundleException {
	Properties result = new Properties();
	URL configURL = bundledata.getEntry(CompositeSupport.COMPOSITE_CONFIGURATION);
	if (configURL == null)
	return result;
	InputStream in = null;
	try {
	in = configURL.openStream();
	result.load(configURL.openStream());
	} catch (IOException e) {
	throw new BundleException("Error loading composite configuration: " + configURL, e); //$NON-NLS-1$
	} finally {
	if (in != null)
	try {
	in.close();
	} catch (IOException e) {
	// nothing
	}
	}
	return result;
	}

	private CompositeInfo createCompositeInfo(boolean setParent) throws BundleException {
	Dictionary manifest = bundledata.getManifest();
	String importPackage = (String) manifest.get(CompositeConstants.COMPOSITE_PACKAGE_IMPORT_POLICY);
	String exportPackage = (String) manifest.get(CompositeConstants.COMPOSITE_PACKAGE_EXPORT_POLICY);
	String requireBundle = (String) manifest.get(CompositeConstants.COMPOSITE_BUNDLE_REQUIRE_POLICY);
	String provideBundle = (String) manifest.get(CompositeConstants.COMPOSITE_BUNDLE_PROVIDE_POLICY);
	String importService = (String) manifest.get(CompositeConstants.COMPOSITE_SERVICE_IMPORT_POLICY);
	String exportService = (String) manifest.get(CompositeConstants.COMPOSITE_SERVICE_EXPORT_POLICY);

	BundleContext systemContext = compositeSystemBundle.getBundleContext();

	BundleDescription desc = stateFactory.createBundleDescription(manifest, bundledata.getLocation(), bundledata.getBundleID());
	ClassSpacePolicyInfo[] imports = createClassSpacePolicy(importPackage, stateFactory, CompositeConstants.COMPOSITE_PACKAGE_IMPORT_POLICY, desc);
	ClassSpacePolicyInfo[] exports = createClassSpacePolicy(exportPackage, stateFactory, CompositeConstants.COMPOSITE_PACKAGE_EXPORT_POLICY, desc);
	ClassSpacePolicyInfo[] requires = createClassSpacePolicy(requireBundle, stateFactory, CompositeConstants.COMPOSITE_BUNDLE_REQUIRE_POLICY, desc);
	ClassSpacePolicyInfo[] provides = createClassSpacePolicy(provideBundle, stateFactory, CompositeConstants.COMPOSITE_BUNDLE_PROVIDE_POLICY, desc);
	ServicePolicyInfo[] importServiceFilter = createServicePolicyInfo(importService, stateFactory, CompositeConstants.COMPOSITE_SERVICE_IMPORT_POLICY, systemContext);
	ServicePolicyInfo[] exportServiceFilter = createServicePolicyInfo(exportService, stateFactory, CompositeConstants.COMPOSITE_SERVICE_EXPORT_POLICY, systemContext);
	// set the parent info
	CompositeInfo parentInfo = null;
	if (setParent) {
	parentInfo = framework.getCompositeSupport().compositPolicy.getCompositeInfo(bundledata.getCompositeID());
	}
	CompositeInfo result = new CompositeInfo(bundledata.getBundleID(), bundledata.getSymbolicName(), bundledata.getVersion(), parentInfo, imports, exports, requires, provides, importServiceFilter, exportServiceFilter);
	if (setParent) {
	// add the the composite info as a child of the parent.
	parentInfo.addChild(result);
	}
	return result;
	}

	public BundleContext getSystemBundleContext() {
	if (getState() == Bundle.UNINSTALLED)
	return null;
	return compositeSystemBundle.getBundleContext();
	}

	public void update() throws BundleException {
	throw new BundleException("Must update a composite with the update(Map) method.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
	}

	public void update(InputStream in) throws BundleException {
	if (in == RELOAD) {
	super.update(RELOAD);
	return;
	}
	try {
	in.close();
	} catch (IOException e) {
	// do nothing
	}
	update();
	}

	public void update(Map<String, String> compositeManifest) throws BundleException {
	if (Debug.DEBUG && Debug.DEBUG_GENERAL) {
	Debug.println("update location " + bundledata.getLocation()); //$NON-NLS-1$
	Debug.println(" from: " + compositeManifest); //$NON-NLS-1$
	}
	SecurityManager sm = System.getSecurityManager();
	if (sm != null)
	// must have AllPermission to do this
	sm.checkPermission(new AllPermission());
	// make a local copy of the manifest first
	compositeManifest = new HashMap<String, String>(compositeManifest);
	// make sure the manifest is valid
	CompositeSupport.validateCompositeManifest(compositeManifest);
	try {
	URL configURL = bundledata.getEntry(CompositeSupport.COMPOSITE_CONFIGURATION);
	Properties config = new Properties();
	config.load(configURL.openStream());
	// get an in memory input stream to jar content of the composite we want to install
	InputStream content = CompositeSupport.getCompositeInput(config, compositeManifest);
	updating.set(true);
	// update with the new content
	super.update(content);
	} catch (IOException e) {
	throw new BundleException("Error creating composite bundle", e); //$NON-NLS-1$
	} finally {
	updating.set(false);
	}
	}

	@Override
	protected void updateWorkerPrivileged(URLConnection source, AccessControlContext callerContext) throws BundleException {
	CompositeInfo originalInfo = createCompositeInfo(false);
	super.updateWorkerPrivileged(source, callerContext);
	// update the composite info with the new data.
	CompositeInfo updatedInfo = createCompositeInfo(false);
	compositeInfo.update(updatedInfo);
	AbstractBundle[] bundles = framework.getBundles(getBundleId());
	// reload all the constituents
	for (AbstractBundle bundle : bundles) {
	if (bundle.getBundleId() == 0) // not the system bundle
	continue;
	try {
	bundle.reload();
	} catch (BundleException e) {
	framework.publishFrameworkEvent(FrameworkEvent.ERROR, bundle, e);
	}
	}
	}

	protected void startHook() {
	startLevelManager.doSetStartLevel(beginningStartLevel);
	}

	protected void stopHook() {
	if (updating.get())
	startLevelManager.update();
	else
	startLevelManager.shutdown();
	}

	public void uninstallWorkerPrivileged() throws BundleException {
	// uninstall the composite first to invalidate the context
	super.uninstallWorkerPrivileged();
	Bundle[] bundles = framework.getBundles(getBundleId());
	// uninstall all the constituents
	for (int i = 0; i < bundles.length; i++) {
	if (bundles[i].getBundleId() != 0) // not the system bundle
	try {
	bundles[i].uninstall();
	} catch (BundleException e) {
	framework.publishFrameworkEvent(FrameworkEvent.ERROR, bundles[i], e);
	}
	}
	// clean up persistent storage associated with this composite
	framework.getAdaptor().setInitialBundleStartLevel(getBundleId(), -1);
	securityAdmin.setDefaultPermissions(null);
	String[] locations = securityAdmin.getLocations();
	if (locations != null)
	for (int i = 0; i < locations.length; i++)
	securityAdmin.setPermissions(locations[i], null);
	ConditionalPermissionUpdate update = securityAdmin.newConditionalPermissionUpdate();
	update.getConditionalPermissionInfos().clear();
	update.commit();
	}

	protected void close() {
	super.close();
	startLevelManager.cleanup();
	// remove the composite info from the parent
	compositeInfo.orphaned();
	// unregister the composite factory before closing the system bundle
	getFramework().getStreamHandlerFactory().unregisterComposite(streamHandlerFactory);
	getFramework().getContentHandlerFactory().unregisterComposite(contentHandlerFactory);
	compositeSystemBundle.close();
	}

	public class CompositeSystemBundle extends InternalSystemBundle {
	private final BundleHost rootSystemBundle;

	public CompositeSystemBundle(BundleHost systemBundle, Framework framework) throws BundleException {
	super(systemBundle.getBundleData(), framework);
	this.rootSystemBundle = systemBundle;
	this.state = Bundle.STARTING; // Initial state must be STARTING for composite system bundle
	}

	protected BundleContextImpl createContext() {
	CompositeContext compositeContext = new CompositeContext(this);
	return compositeContext;
	}

	public ServiceReference[] getRegisteredServices() {
	// TODO this is not scoped; do we care?
	return rootSystemBundle.getRegisteredServices();
	}

	public ServiceReference[] getServicesInUse() {
	return rootSystemBundle.getServicesInUse();
	}

	public void start(int options) throws BundleException {
	throw new BundleException("Cannot start a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
	}

	public void start() throws BundleException {
	start(0);
	}

	public void stop(int options) throws BundleException {
	throw new BundleException("Cannot stop a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
	}

	public void stop() throws BundleException {
	stop(0);
	}

	public void uninstall() throws BundleException {
	throw new BundleException("Cannot uninstall a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
	}

	public void update(InputStream input) throws BundleException {
	throw new BundleException("Cannot update a composite system bundle.", BundleException.UNSUPPORTED_OPERATION); //$NON-NLS-1$
	}

	public void update() throws BundleException {
	update(null);
	}

	public long getCompositeId() {
	return CompositeImpl.this.getBundleId();
	}

	public BundleLoaderProxy getLoaderProxy() {
	return rootSystemBundle.getLoaderProxy();
	}

	protected void close() {
	super.close();
	this.state = Bundle.UNINSTALLED;
	}

	}

	public class CompositeContext extends BundleContextImpl {

	protected CompositeContext(BundleHost bundle) {
	super(bundle);
	}

	protected long getCompositeId() {
	return CompositeImpl.this.getBundleId();
	}

	protected void start() {
	// nothing;
	}

	protected void stop() {
	// nothing
	}
	}

	public StartLevelManager getStartLevelService() {
	return startLevelManager;
	}

	public SecurityAdmin getSecurityAdmin() {
	return securityAdmin;
	}

	public BundleHost getSystemBundle() {
	return compositeSystemBundle;
	}

	public String getProperty(String key) {
	SecurityManager sm = System.getSecurityManager();
	if (sm != null)
	sm.checkPropertyAccess(key);
	return configuration.getProperty(key, FrameworkProperties.getProperty(key));
	}

	public String setProperty(String key, String value) {
	SecurityManager sm = System.getSecurityManager();
	if (sm != null)
	sm.checkPermission(new PropertyPermission(key, "write")); //$NON-NLS-1$
	return (String) configuration.setProperty(key, value);
	}

	protected void refresh() {
	super.refresh();
	loadConstituents();
	}

	void loadConstituents() {
	synchronized (constituents) {
	constituents.clear();
	AbstractBundle[] bundles = framework.getBundles(getBundleId());
	for (int i = 0; i < bundles.length; i++) {
	if (bundles[i].getBundleId() == 0)
	continue;
	BundleDescription constituent = bundles[i].getBundleDescription();
	if (constituent != null)
	constituents.add(constituent);
	}
	}
	}

	void addConstituent(BundleDescription description) {
	synchronized (constituents) {
	constituents.add(description);
	}
	}

	BundleDescription[] getConstituentDescriptions() {
	synchronized (constituents) {
	return constituents.toArray(new BundleDescription[constituents.size()]);
	}
	}

	private static ClassSpacePolicyInfo[] createClassSpacePolicy(String policySpec, StateObjectFactory factory, String header, BundleDescription desc) throws BundleException {
	ManifestElement[] policy = ManifestElement.parseHeader(header, policySpec);
	if (policy == null \|\| policy.length == 0)
	return null;
	ArrayList<ClassSpacePolicyInfo> result = new ArrayList<ClassSpacePolicyInfo>(policy.length);
	for (int i = 0; i < policy.length; i++) {
	String compositeAffinityName = policy[i].getDirective(CompositeConstants.COMPOSITE_SYMBOLICNAME_DIRECTIVE);
	VersionRange compositeAffinityVersion = StateBuilder.getVersionRange(policy[i].getDirective(CompositeConstants.COMPOSITE_VERSION_DIRECTIVE));
	if (header == CompositeConstants.COMPOSITE_PACKAGE_IMPORT_POLICY \|\| header == CompositeConstants.COMPOSITE_PACKAGE_EXPORT_POLICY) {
	VersionRange versionRange = StateBuilder.getVersionRange(policy[i].getAttribute(Constants.VERSION_ATTRIBUTE));

	String bundleSymbolicName = policy[i].getAttribute(Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE);
	VersionRange bundleVersionRange = StateBuilder.getVersionRange(policy[i].getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE));

	Map attributes = StateBuilder.getAttributes(policy[i], StateBuilder.DEFINED_MATCHING_ATTRS);

	String[] packageNames = policy[i].getValueComponents();
	for (int j = 0; j < packageNames.length; j++) {
	ImportPackageSpecification importSpec = factory.createImportPackageSpecification(packageNames[j], versionRange, bundleSymbolicName, bundleVersionRange, null, attributes, desc);
	result.add(new ClassSpacePolicyInfo(compositeAffinityName, compositeAffinityVersion, importSpec));
	}
	} else {
	String bsn = policy[i].getValue();
	VersionRange bundleVersion = StateBuilder.getVersionRange(policy[i].getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE));
	result.add(new ClassSpacePolicyInfo(compositeAffinityName, compositeAffinityVersion, factory.createBundleSpecification(bsn, bundleVersion, false, false)));
	}
	}
	return result.toArray(new ClassSpacePolicyInfo[result.size()]);
	}

	private static ServicePolicyInfo[] createServicePolicyInfo(String policySpec, StateObjectFactory factory, String header, BundleContext context) throws BundleException {
	ManifestElement[] policy = ManifestElement.parseHeader(header, policySpec);
	if (policy == null \|\| policy.length == 0)
	return null;
	ArrayList<ServicePolicyInfo> result = new ArrayList<ServicePolicyInfo>(policy.length);
	for (int i = 0; i < policy.length; i++) {
	String compositeAffinityName = policy[i].getDirective(CompositeConstants.COMPOSITE_SYMBOLICNAME_DIRECTIVE);
	VersionRange compositeAffinityVersion = StateBuilder.getVersionRange(policy[i].getDirective(CompositeConstants.COMPOSITE_VERSION_DIRECTIVE));
	String[] filters = policy[i].getValueComponents();
	for (int j = 0; j < filters.length; j++) {
	Filter filter = null;
	try {
	filter = context.createFilter(filters[i]);
	} catch (InvalidSyntaxException e) {
	throw new BundleException("Invalid service sharing policy: " + filters[i], BundleException.MANIFEST_ERROR, e); //$NON-NLS-1$
	}
	result.add(new ServicePolicyInfo(compositeAffinityName, compositeAffinityVersion, filter));
	}
	}
	return result.toArray(new ServicePolicyInfo[result.size()]);
	}
	}