deploymentadmin/deploymentadmin/src/main/java/org/apache/felix/deploymentadmin/AbstractDeploymentPackage.java - felix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.felix.deploymentadmin;

 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.jar.Manifest;

 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.InvalidSyntaxException;
 import org.osgi.framework.ServiceReference;
 import org.osgi.framework.Version;
 import org.osgi.service.deploymentadmin.BundleInfo;
 import org.osgi.service.deploymentadmin.DeploymentException;
 import org.osgi.service.deploymentadmin.DeploymentPackage;
 import org.osgi.service.deploymentadmin.spi.ResourceProcessor;
 import org.osgi.service.log.LogService;

 /**
  * Base class for various types of deployment packages. Indifferent in regard to
  * how the deployment package data is obtained, this should be handled by
  * extending classes.
  */
 public abstract class AbstractDeploymentPackage implements DeploymentPackage, Constants {
     /**
      * Represents an empty deployment package.
      */
     private static final class EmptyDeploymentPackage extends AbstractDeploymentPackage {
         private static final String[] STRINGS = new String[] {};
         private static final ResourceInfoImpl[] RESOURCE_INFO_IMPLS = new ResourceInfoImpl[] {};
         private static final BundleInfoImpl[] BUNDLE_INFO_IMPLS = new BundleInfoImpl[] {};

         public Bundle getBundle(String symbolicName) {
             return null;
         }

         public BundleInfoImpl[] getBundleInfoImpls() {
             return BUNDLE_INFO_IMPLS;
         }

         public BundleInfo[] getBundleInfos() {
             return BUNDLE_INFO_IMPLS;
         }

         public InputStream getBundleStream(String symbolicName) throws IOException {
             return null;
         }

         public InputStream getCurrentEntryStream() {
             throw new UnsupportedOperationException();
         }

         public String getDisplayName() {
             return "";
         }

         public String getHeader(String header) {
             if (DEPLOYMENTPACKAGE_SYMBOLICMAME.equals(header)) {
                 return "";
             }
             else if (DEPLOYMENTPACKAGE_VERSION.equals(header)) {
                 return Version.emptyVersion.toString();
             }
             else {
                 return null;
             }
         }

         public URL getIcon() {
             return null;
         }

         public String getName() {
             return "";
         }

         public AbstractInfo getNextEntry() throws IOException {
             throw new UnsupportedOperationException();
         }

         public BundleInfoImpl[] getOrderedBundleInfos() {
             return BUNDLE_INFO_IMPLS;
         }

         public ResourceInfoImpl[] getOrderedResourceInfos() {
             return RESOURCE_INFO_IMPLS;
         }

         public String getResourceHeader(String resource, String header) {
             return null;
         }

         public ResourceInfoImpl[] getResourceInfos() {
             return RESOURCE_INFO_IMPLS;
         }

         public ServiceReference getResourceProcessor(String resource) {
             return null;
         }

         public String[] getResources() {
             return STRINGS;
         }

         public Version getVersion() {
             return Version.emptyVersion;
         }

         public boolean isStale() {
             return true;
         }

         public void uninstall() throws DeploymentException {
             throw new IllegalStateException("Can not uninstall stale DeploymentPackage");
         }

         public boolean uninstallForced() throws DeploymentException {
             throw new IllegalStateException("Can not uninstall stale DeploymentPackage");
         }
     }

     protected static final AbstractDeploymentPackage EMPTY_PACKAGE = new EmptyDeploymentPackage();

     private final BundleContext m_bundleContext;
     private final DeploymentAdminImpl m_deploymentAdmin;
     private final DeploymentPackageManifest m_manifest;
     private final Map m_nameToBundleInfo = new HashMap();
     private final Map m_pathToEntry = new HashMap();
     private final BundleInfoImpl[] m_bundleInfos;
     private final ResourceInfoImpl[] m_resourceInfos;
     private final String[] m_resourcePaths;
     private final boolean m_isFixPackage;
     private boolean m_isStale;

     /**
      * Creates an instance of this class.
      *
      * @param manifest The manifest of the deployment package.
      * @param bundleContext The bundle context.
      * @throws DeploymentException Thrown if the specified manifest does not
      *             describe a valid deployment package.
      */
     public AbstractDeploymentPackage(Manifest manifest, BundleContext bundleContext, DeploymentAdminImpl deploymentAdmin) throws DeploymentException {
         m_manifest = new DeploymentPackageManifest(manifest);
         m_isFixPackage = m_manifest.getFixPackage() != null;
         m_bundleContext = bundleContext;
         m_deploymentAdmin = deploymentAdmin;

         List bundleInfos = m_manifest.getBundleInfos();
         m_bundleInfos = (BundleInfoImpl[]) bundleInfos.toArray(new BundleInfoImpl[bundleInfos.size()]);

         for (int i = 0; i < m_bundleInfos.length; i++) {
             String bsn = m_bundleInfos[i].getSymbolicName();
             if (m_nameToBundleInfo.put(bsn, m_bundleInfos[i]) != null) {
                 // FELIX-4463: make sure that the DP is consistent...
                 throw new DeploymentException(CODE_OTHER_ERROR, "Duplicate bundle present in deployment package: " + bsn);
             }

             String path = m_bundleInfos[i].getPath();
             if (m_pathToEntry.put(path, m_bundleInfos[i]) != null) {
                 // FELIX-4463: make sure that the DP is consistent...
                 throw new DeploymentException(CODE_OTHER_ERROR, "Non-unique path present in deployment package: " + path);
             }
         }

         List resourceInfos = m_manifest.getResourceInfos();
         m_resourceInfos = (ResourceInfoImpl[]) resourceInfos.toArray(new ResourceInfoImpl[resourceInfos.size()]);

         for (int i = 0; i < m_resourceInfos.length; i++) {
             String path = m_resourceInfos[i].getPath();
             if (m_pathToEntry.put(path, m_resourceInfos[i]) != null) {
                 // FELIX-4463: make sure that the DP is consistent...
                 throw new DeploymentException(CODE_OTHER_ERROR, "Non-unique path present in deployment package: " + path);
             }
         }
         m_resourcePaths = (String[]) m_pathToEntry.keySet().toArray(new String[m_pathToEntry.size()]);
     }

     /* Constructor only for use by the emptyPackage static variable */
     private AbstractDeploymentPackage() {
         m_bundleContext = null;
         m_manifest = null;
         m_bundleInfos = null;
         m_resourceInfos = null;
         m_resourcePaths = null;
         m_isFixPackage = false;
         m_deploymentAdmin = null;
     }

     public Bundle getBundle(String symbolicName) {
         if (isStale()) {
             throw new IllegalStateException("Can not get bundle from stale deployment package.");
         }

         BundleInfo bundleInfo = (BundleInfo) m_nameToBundleInfo.get(symbolicName);
         if (bundleInfo != null) {
             Version version = bundleInfo.getVersion();

             Bundle[] bundles = m_bundleContext.getBundles();
             for (int i = 0; i < bundles.length; i++) {
                 if (symbolicName.equals(bundles[i].getSymbolicName()) && version.equals(bundles[i].getVersion())) {
                     return bundles[i];
                 }
             }
         }
         return null;
     }

     /**
      * Determines the info about a bundle resource based on the bundle symbolic
      * name.
      *
      * @param symbolicName String containing a bundle symbolic name
      * @return <code>BundleInfoImpl</code> for the bundle identified by the
      *         specified symbolic name or null if the symbolic name is unknown
      */
     public BundleInfoImpl getBundleInfoByName(String symbolicName) {
         return (BundleInfoImpl) m_nameToBundleInfo.get(symbolicName);
     }

     /**
      * Determines the info about a bundle based on it's path/resource-id.
      *
      * @param path String containing a bundle path
      * @return <code>BundleInfoImpl</code> for the bundle resource identified by
      *         the specified path or null if the path is unknown or does not
      *         describe a bundle resource
      */
     public BundleInfoImpl getBundleInfoByPath(String path) {
         AbstractInfo info = (AbstractInfo) m_pathToEntry.get(path);
         if (info instanceof BundleInfoImpl) {
             return (BundleInfoImpl) info;
         }
         return null;
     }

     /**
      * Returns the bundles of this deployment package as an array of
      * <code>BundleInfoImpl</code> objects.
      *
      * @return Array containing <code>BundleInfoImpl</code> objects for each
      *         bundle this deployment package.
      */
     public BundleInfoImpl[] getBundleInfoImpls() {
         return (BundleInfoImpl[]) m_bundleInfos.clone();
     }

     public BundleInfo[] getBundleInfos() {
         return (BundleInfo[]) m_bundleInfos.clone();
     }

     /**
      * Determines the data stream of a bundle resource based on the bundle
      * symbolic name
      *
      * @param symbolicName Bundle symbolic name
      * @return Stream to the bundle identified by the specified symbolic name or
      *         null if no such bundle exists in this deployment package.
      * @throws IOException If the bundle can not be properly offered as an
      *             inputstream
      */
     public abstract InputStream getBundleStream(String symbolicName) throws IOException;

     /**
      * Determines the data stream to the current entry of this deployment
      * package, use this together with the <code>getNextEntry</code> method.
      *
      * @return Stream to the current resource in the deployment package (as
      *         determined by the order in which the deployment package was
      *         received originally) or null if there is no entry
      */
     public abstract InputStream getCurrentEntryStream();

     public String getDisplayName() {
         return getHeader(DEPLOYMENTPACKAGE_NAME);
     }

     public String getHeader(String header) {
         return m_manifest.getHeader(header);
     }

     public URL getIcon() {
         String icon = getHeader(DEPLOYMENTPACKAGE_ICON);
         if (icon == null) {
             return null;
         }
         else {
             try {
                 // TODO spec states this must be a local resource, but we don't make sure of that yet
                 return new URL(icon);
             }
             catch (MalformedURLException e) {
                 return null;
             }
         }
     }

     public String getName() {
         return m_manifest.getSymbolicName();
     }

     /**
      * Determines the next resource entry in this deployment package based on
      * the order in which the resources appeared when the package was originally
      * received.
      *
      * @return <code>AbstractInfo</code> describing the next resource entry (as
      *         determined by the order in which the deployment package was
      *         received originally) or null if there is no next entry
      * @throws IOException if the next entry can not be properly determined
      */
     public abstract AbstractInfo getNextEntry() throws IOException;

     /**
      * Determines the bundles of this deployment package in the order in which
      * they were originally received.
      *
      * @return Array containing <code>BundleInfoImpl</code> objects of the
      *         bundles in this deployment package, ordered in the way they
      *         appeared when the deployment package was first received.
      */
     public abstract BundleInfoImpl[] getOrderedBundleInfos();

     /**
      * Determines the resources of this deployment package in the order in which
      * they were originally received.
      *
      * @return Array containing <code>ResourceInfoImpl</code> objects of all
      *         processed resources in this deployment package, ordered in the
      *         way they appeared when the deployment package was first received
      */
     public abstract ResourceInfoImpl[] getOrderedResourceInfos();

     public String getResourceHeader(String resource, String header) {
         AbstractInfo info = (AbstractInfo) m_pathToEntry.get(resource);
         if (info != null) {
             return info.getHeader(header);
         }
         return null;
     }

     /**
      * Determines the info about a processed resource based on it's
      * path/resource-id.
      *
      * @param path String containing a (processed) resource path
      * @return <code>ResourceInfoImpl</code> for the resource identified by the
      *         specified path or null if the path is unknown or does not
      *         describe a processed resource
      */
     public ResourceInfoImpl getResourceInfoByPath(String path) {
         AbstractInfo info = (AbstractInfo) m_pathToEntry.get(path);
         if (info instanceof ResourceInfoImpl) {
             return (ResourceInfoImpl) info;
         }
         return null;
     }

     /**
      * Returns the processed resources of this deployment package as an array of
      * <code>ResourceInfoImpl</code> objects.
      *
      * @return Array containing <code>ResourceInfoImpl</code> objects for each
      *         processed resource of this deployment package.
      */
     public ResourceInfoImpl[] getResourceInfos() {
         return (ResourceInfoImpl[]) m_resourceInfos.clone();
     }

     public ServiceReference getResourceProcessor(String resource) {
         if (isStale()) {
             throw new IllegalStateException("Can not get bundle from stale deployment package.");
         }
         AbstractInfo info = (AbstractInfo) m_pathToEntry.get(resource);
         if (info instanceof ResourceInfoImpl) {
             String processor = ((ResourceInfoImpl) info).getResourceProcessor();
             if (processor != null) {
                 try {
                     ServiceReference[] services = m_bundleContext.getServiceReferences(ResourceProcessor.class.getName(), "(" + SERVICE_PID + "=" + processor + ")");
                     if (services != null && services.length > 0) {
                         return services[0];
                     }
                     else {
                         return null;
                     }
                 }
                 catch (InvalidSyntaxException e) {
                     m_deploymentAdmin.getLog().log(LogService.LOG_WARNING, "Invalid resource processor name: " + processor, e);
                     return null;
                 }
             }
         }
         return null;
     }

     public String[] getResources() {
         return (String[]) m_resourcePaths.clone();
     }

     public Version getVersion() {
         return m_manifest.getVersion();
     }

     /**
      * If this deployment package is a fix package this method determines the
      * version range this deployment package can be applied to.
      *
      * @return <code>VersionRange</code> the fix package can be applied to or
      *         <code>null</code> if it is not a fix package.
      */
     public VersionRange getVersionRange() {
         return m_manifest.getFixPackage();
     }

     /**
      * Determines whether this deployment package is a fix package.
      *
      * @return True if this deployment package is a fix package, false
      *         otherwise.
      */
     public boolean isFixPackage() {
         return m_isFixPackage;
     }

     /**
      * @return <code>true</code> if this package is actually an empty package
      *         used for installing new deployment packages, <code>false</code>
      *         otherwise.
      */
     public boolean isNew() {
         return this == EMPTY_PACKAGE;
     }

     public boolean isStale() {
         return m_isStale;
     }

     public void setStale(boolean isStale) {
         m_isStale = isStale;
     }

     public void uninstall() throws DeploymentException {
         if (isStale()) {
             throw new IllegalStateException("Deployment package is stale, cannot uninstall!");
         }

         m_deploymentAdmin.uninstallDeploymentPackage(this, false /* force */);
         // FELIX-4484: only mark a DP as stale when it is *successfully* uninstalled...
         setStale(true);
     }

     public boolean uninstallForced() throws DeploymentException {
         if (isStale()) {
             throw new IllegalStateException("Deployment package is stale, cannot force uninstallation!");
         }

         try {
             m_deploymentAdmin.uninstallDeploymentPackage(this, true /* force */);
         }
         finally {
             // FELIX-4484: this is a best-effort method, if it fails, we cannot do anything about it anymore...
             setStale(true);
         }
         return true;
     }

     /**
      * Determines the info about either a bundle or processed resource based on
      * it's path/resource-id.
      *
      * @param path String containing a resource path (either bundle or processed
      *            resource)
      * @return <code>AbstractInfoImpl</code> for the resource identified by the
      *         specified path or null if the path is unknown
      */
     protected AbstractInfo getAbstractInfoByPath(String path) {
         return (AbstractInfo) m_pathToEntry.get(path);
     }

     /**
      * Returns whether the given name (which is expected to be the name of a
      * JarEntry) is a signature file or the JAR index file.
      *
      * @param name the name of the JAR entry to test, cannot be
      *            <code>null</code>.
      * @return <code>true</code> if the given JAR entry name is a signature file
      *         or JAR index file, <code>false</code> otherwise.
      */
     protected boolean isMetaInfFile(String name) {
         name = name.toUpperCase(Locale.US);
         return name.startsWith("META-INF/") && (name.endsWith("/INDEX.LIST") || name.endsWith(".SF") || name.endsWith(".DSA") || name.endsWith(".RSA") || name.endsWith(".EC"));
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.felix.deploymentadmin;

	import java.io.IOException;
	import java.io.InputStream;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Locale;
	import java.util.Map;
	import java.util.jar.Manifest;

	import org.osgi.framework.Bundle;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.InvalidSyntaxException;
	import org.osgi.framework.ServiceReference;
	import org.osgi.framework.Version;
	import org.osgi.service.deploymentadmin.BundleInfo;
	import org.osgi.service.deploymentadmin.DeploymentException;
	import org.osgi.service.deploymentadmin.DeploymentPackage;
	import org.osgi.service.deploymentadmin.spi.ResourceProcessor;
	import org.osgi.service.log.LogService;

	/**
	* Base class for various types of deployment packages. Indifferent in regard to
	* how the deployment package data is obtained, this should be handled by
	* extending classes.
	*/
	public abstract class AbstractDeploymentPackage implements DeploymentPackage, Constants {
	/**
	* Represents an empty deployment package.
	*/
	private static final class EmptyDeploymentPackage extends AbstractDeploymentPackage {
	private static final String[] STRINGS = new String[] {};
	private static final ResourceInfoImpl[] RESOURCE_INFO_IMPLS = new ResourceInfoImpl[] {};
	private static final BundleInfoImpl[] BUNDLE_INFO_IMPLS = new BundleInfoImpl[] {};

	public Bundle getBundle(String symbolicName) {
	return null;
	}

	public BundleInfoImpl[] getBundleInfoImpls() {
	return BUNDLE_INFO_IMPLS;
	}

	public BundleInfo[] getBundleInfos() {
	return BUNDLE_INFO_IMPLS;
	}

	public InputStream getBundleStream(String symbolicName) throws IOException {
	return null;
	}

	public InputStream getCurrentEntryStream() {
	throw new UnsupportedOperationException();
	}

	public String getDisplayName() {
	return "";
	}

	public String getHeader(String header) {
	if (DEPLOYMENTPACKAGE_SYMBOLICMAME.equals(header)) {
	return "";
	}
	else if (DEPLOYMENTPACKAGE_VERSION.equals(header)) {
	return Version.emptyVersion.toString();
	}
	else {
	return null;
	}
	}

	public URL getIcon() {
	return null;
	}

	public String getName() {
	return "";
	}

	public AbstractInfo getNextEntry() throws IOException {
	throw new UnsupportedOperationException();
	}

	public BundleInfoImpl[] getOrderedBundleInfos() {
	return BUNDLE_INFO_IMPLS;
	}

	public ResourceInfoImpl[] getOrderedResourceInfos() {
	return RESOURCE_INFO_IMPLS;
	}

	public String getResourceHeader(String resource, String header) {
	return null;
	}

	public ResourceInfoImpl[] getResourceInfos() {
	return RESOURCE_INFO_IMPLS;
	}

	public ServiceReference getResourceProcessor(String resource) {
	return null;
	}

	public String[] getResources() {
	return STRINGS;
	}

	public Version getVersion() {
	return Version.emptyVersion;
	}

	public boolean isStale() {
	return true;
	}

	public void uninstall() throws DeploymentException {
	throw new IllegalStateException("Can not uninstall stale DeploymentPackage");
	}

	public boolean uninstallForced() throws DeploymentException {
	throw new IllegalStateException("Can not uninstall stale DeploymentPackage");
	}
	}

	protected static final AbstractDeploymentPackage EMPTY_PACKAGE = new EmptyDeploymentPackage();

	private final BundleContext m_bundleContext;
	private final DeploymentAdminImpl m_deploymentAdmin;
	private final DeploymentPackageManifest m_manifest;
	private final Map m_nameToBundleInfo = new HashMap();
	private final Map m_pathToEntry = new HashMap();
	private final BundleInfoImpl[] m_bundleInfos;
	private final ResourceInfoImpl[] m_resourceInfos;
	private final String[] m_resourcePaths;
	private final boolean m_isFixPackage;
	private boolean m_isStale;

	/**
	* Creates an instance of this class.
	*
	* @param manifest The manifest of the deployment package.
	* @param bundleContext The bundle context.
	* @throws DeploymentException Thrown if the specified manifest does not
	* describe a valid deployment package.
	*/
	public AbstractDeploymentPackage(Manifest manifest, BundleContext bundleContext, DeploymentAdminImpl deploymentAdmin) throws DeploymentException {
	m_manifest = new DeploymentPackageManifest(manifest);
	m_isFixPackage = m_manifest.getFixPackage() != null;
	m_bundleContext = bundleContext;
	m_deploymentAdmin = deploymentAdmin;

	List bundleInfos = m_manifest.getBundleInfos();
	m_bundleInfos = (BundleInfoImpl[]) bundleInfos.toArray(new BundleInfoImpl[bundleInfos.size()]);

	for (int i = 0; i < m_bundleInfos.length; i++) {
	String bsn = m_bundleInfos[i].getSymbolicName();
	if (m_nameToBundleInfo.put(bsn, m_bundleInfos[i]) != null) {
	// FELIX-4463: make sure that the DP is consistent...
	throw new DeploymentException(CODE_OTHER_ERROR, "Duplicate bundle present in deployment package: " + bsn);
	}

	String path = m_bundleInfos[i].getPath();
	if (m_pathToEntry.put(path, m_bundleInfos[i]) != null) {
	// FELIX-4463: make sure that the DP is consistent...
	throw new DeploymentException(CODE_OTHER_ERROR, "Non-unique path present in deployment package: " + path);
	}
	}

	List resourceInfos = m_manifest.getResourceInfos();
	m_resourceInfos = (ResourceInfoImpl[]) resourceInfos.toArray(new ResourceInfoImpl[resourceInfos.size()]);

	for (int i = 0; i < m_resourceInfos.length; i++) {
	String path = m_resourceInfos[i].getPath();
	if (m_pathToEntry.put(path, m_resourceInfos[i]) != null) {
	// FELIX-4463: make sure that the DP is consistent...
	throw new DeploymentException(CODE_OTHER_ERROR, "Non-unique path present in deployment package: " + path);
	}
	}
	m_resourcePaths = (String[]) m_pathToEntry.keySet().toArray(new String[m_pathToEntry.size()]);
	}

	/* Constructor only for use by the emptyPackage static variable */
	private AbstractDeploymentPackage() {
	m_bundleContext = null;
	m_manifest = null;
	m_bundleInfos = null;
	m_resourceInfos = null;
	m_resourcePaths = null;
	m_isFixPackage = false;
	m_deploymentAdmin = null;
	}

	public Bundle getBundle(String symbolicName) {
	if (isStale()) {
	throw new IllegalStateException("Can not get bundle from stale deployment package.");
	}

	BundleInfo bundleInfo = (BundleInfo) m_nameToBundleInfo.get(symbolicName);
	if (bundleInfo != null) {
	Version version = bundleInfo.getVersion();

	Bundle[] bundles = m_bundleContext.getBundles();
	for (int i = 0; i < bundles.length; i++) {
	if (symbolicName.equals(bundles[i].getSymbolicName()) && version.equals(bundles[i].getVersion())) {
	return bundles[i];
	}
	}
	}
	return null;
	}

	/**
	* Determines the info about a bundle resource based on the bundle symbolic
	* name.
	*
	* @param symbolicName String containing a bundle symbolic name
	* @return <code>BundleInfoImpl</code> for the bundle identified by the
	* specified symbolic name or null if the symbolic name is unknown
	*/
	public BundleInfoImpl getBundleInfoByName(String symbolicName) {
	return (BundleInfoImpl) m_nameToBundleInfo.get(symbolicName);
	}

	/**
	* Determines the info about a bundle based on it's path/resource-id.
	*
	* @param path String containing a bundle path
	* @return <code>BundleInfoImpl</code> for the bundle resource identified by
	* the specified path or null if the path is unknown or does not
	* describe a bundle resource
	*/
	public BundleInfoImpl getBundleInfoByPath(String path) {
	AbstractInfo info = (AbstractInfo) m_pathToEntry.get(path);
	if (info instanceof BundleInfoImpl) {
	return (BundleInfoImpl) info;
	}
	return null;
	}

	/**
	* Returns the bundles of this deployment package as an array of
	* <code>BundleInfoImpl</code> objects.
	*
	* @return Array containing <code>BundleInfoImpl</code> objects for each
	* bundle this deployment package.
	*/
	public BundleInfoImpl[] getBundleInfoImpls() {
	return (BundleInfoImpl[]) m_bundleInfos.clone();
	}

	public BundleInfo[] getBundleInfos() {
	return (BundleInfo[]) m_bundleInfos.clone();
	}

	/**
	* Determines the data stream of a bundle resource based on the bundle
	* symbolic name
	*
	* @param symbolicName Bundle symbolic name
	* @return Stream to the bundle identified by the specified symbolic name or
	* null if no such bundle exists in this deployment package.
	* @throws IOException If the bundle can not be properly offered as an
	* inputstream
	*/
	public abstract InputStream getBundleStream(String symbolicName) throws IOException;

	/**
	* Determines the data stream to the current entry of this deployment
	* package, use this together with the <code>getNextEntry</code> method.
	*
	* @return Stream to the current resource in the deployment package (as
	* determined by the order in which the deployment package was
	* received originally) or null if there is no entry
	*/
	public abstract InputStream getCurrentEntryStream();

	public String getDisplayName() {
	return getHeader(DEPLOYMENTPACKAGE_NAME);
	}

	public String getHeader(String header) {
	return m_manifest.getHeader(header);
	}

	public URL getIcon() {
	String icon = getHeader(DEPLOYMENTPACKAGE_ICON);
	if (icon == null) {
	return null;
	}
	else {
	try {
	// TODO spec states this must be a local resource, but we don't make sure of that yet
	return new URL(icon);
	}
	catch (MalformedURLException e) {
	return null;
	}
	}
	}

	public String getName() {
	return m_manifest.getSymbolicName();
	}

	/**
	* Determines the next resource entry in this deployment package based on
	* the order in which the resources appeared when the package was originally
	* received.
	*
	* @return <code>AbstractInfo</code> describing the next resource entry (as
	* determined by the order in which the deployment package was
	* received originally) or null if there is no next entry
	* @throws IOException if the next entry can not be properly determined
	*/
	public abstract AbstractInfo getNextEntry() throws IOException;

	/**
	* Determines the bundles of this deployment package in the order in which
	* they were originally received.
	*
	* @return Array containing <code>BundleInfoImpl</code> objects of the
	* bundles in this deployment package, ordered in the way they
	* appeared when the deployment package was first received.
	*/
	public abstract BundleInfoImpl[] getOrderedBundleInfos();

	/**
	* Determines the resources of this deployment package in the order in which
	* they were originally received.
	*
	* @return Array containing <code>ResourceInfoImpl</code> objects of all
	* processed resources in this deployment package, ordered in the
	* way they appeared when the deployment package was first received
	*/
	public abstract ResourceInfoImpl[] getOrderedResourceInfos();

	public String getResourceHeader(String resource, String header) {
	AbstractInfo info = (AbstractInfo) m_pathToEntry.get(resource);
	if (info != null) {
	return info.getHeader(header);
	}
	return null;
	}

	/**
	* Determines the info about a processed resource based on it's
	* path/resource-id.
	*
	* @param path String containing a (processed) resource path
	* @return <code>ResourceInfoImpl</code> for the resource identified by the
	* specified path or null if the path is unknown or does not
	* describe a processed resource
	*/
	public ResourceInfoImpl getResourceInfoByPath(String path) {
	AbstractInfo info = (AbstractInfo) m_pathToEntry.get(path);
	if (info instanceof ResourceInfoImpl) {
	return (ResourceInfoImpl) info;
	}
	return null;
	}

	/**
	* Returns the processed resources of this deployment package as an array of
	* <code>ResourceInfoImpl</code> objects.
	*
	* @return Array containing <code>ResourceInfoImpl</code> objects for each
	* processed resource of this deployment package.
	*/
	public ResourceInfoImpl[] getResourceInfos() {
	return (ResourceInfoImpl[]) m_resourceInfos.clone();
	}

	public ServiceReference getResourceProcessor(String resource) {
	if (isStale()) {
	throw new IllegalStateException("Can not get bundle from stale deployment package.");
	}
	AbstractInfo info = (AbstractInfo) m_pathToEntry.get(resource);
	if (info instanceof ResourceInfoImpl) {
	String processor = ((ResourceInfoImpl) info).getResourceProcessor();
	if (processor != null) {
	try {
	ServiceReference[] services = m_bundleContext.getServiceReferences(ResourceProcessor.class.getName(), "(" + SERVICE_PID + "=" + processor + ")");
	if (services != null && services.length > 0) {
	return services[0];
	}
	else {
	return null;
	}
	}
	catch (InvalidSyntaxException e) {
	m_deploymentAdmin.getLog().log(LogService.LOG_WARNING, "Invalid resource processor name: " + processor, e);
	return null;
	}
	}
	}
	return null;
	}

	public String[] getResources() {
	return (String[]) m_resourcePaths.clone();
	}

	public Version getVersion() {
	return m_manifest.getVersion();
	}

	/**
	* If this deployment package is a fix package this method determines the
	* version range this deployment package can be applied to.
	*
	* @return <code>VersionRange</code> the fix package can be applied to or
	* <code>null</code> if it is not a fix package.
	*/
	public VersionRange getVersionRange() {
	return m_manifest.getFixPackage();
	}

	/**
	* Determines whether this deployment package is a fix package.
	*
	* @return True if this deployment package is a fix package, false
	* otherwise.
	*/
	public boolean isFixPackage() {
	return m_isFixPackage;
	}

	/**
	* @return <code>true</code> if this package is actually an empty package
	* used for installing new deployment packages, <code>false</code>
	* otherwise.
	*/
	public boolean isNew() {
	return this == EMPTY_PACKAGE;
	}

	public boolean isStale() {
	return m_isStale;
	}

	public void setStale(boolean isStale) {
	m_isStale = isStale;
	}

	public void uninstall() throws DeploymentException {
	if (isStale()) {
	throw new IllegalStateException("Deployment package is stale, cannot uninstall!");
	}

	m_deploymentAdmin.uninstallDeploymentPackage(this, false /* force */);
	// FELIX-4484: only mark a DP as stale when it is successfully uninstalled...
	setStale(true);
	}

	public boolean uninstallForced() throws DeploymentException {
	if (isStale()) {
	throw new IllegalStateException("Deployment package is stale, cannot force uninstallation!");
	}

	try {
	m_deploymentAdmin.uninstallDeploymentPackage(this, true /* force */);
	}
	finally {
	// FELIX-4484: this is a best-effort method, if it fails, we cannot do anything about it anymore...
	setStale(true);
	}
	return true;
	}

	/**
	* Determines the info about either a bundle or processed resource based on
	* it's path/resource-id.
	*
	* @param path String containing a resource path (either bundle or processed
	* resource)
	* @return <code>AbstractInfoImpl</code> for the resource identified by the
	* specified path or null if the path is unknown
	*/
	protected AbstractInfo getAbstractInfoByPath(String path) {
	return (AbstractInfo) m_pathToEntry.get(path);
	}

	/**
	* Returns whether the given name (which is expected to be the name of a
	* JarEntry) is a signature file or the JAR index file.
	*
	* @param name the name of the JAR entry to test, cannot be
	* <code>null</code>.
	* @return <code>true</code> if the given JAR entry name is a signature file
	* or JAR index file, <code>false</code> otherwise.
	*/
	protected boolean isMetaInfFile(String name) {
	name = name.toUpperCase(Locale.US);
	return name.startsWith("META-INF/") && (name.endsWith("/INDEX.LIST") \|\| name.endsWith(".SF") \|\| name.endsWith(".DSA") \|\| name.endsWith(".RSA") \|\| name.endsWith(".EC"));
	}
	}