connect/src/main/java/org/apache/felix/connect/PojoSRBundle.java - felix-dev - 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.connect;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 import java.security.cert.X509Certificate;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Dictionary;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 import java.util.StringTokenizer;

 import org.apache.felix.connect.felix.framework.DTOFactory;
 import org.apache.felix.connect.felix.framework.ServiceRegistry;
 import org.apache.felix.connect.felix.framework.util.EventDispatcher;
 import org.apache.felix.connect.felix.framework.util.MapToDictionary;
 import org.apache.felix.connect.felix.framework.util.StringMap;
 import org.osgi.dto.DTO;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleActivator;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.BundleEvent;
 import org.osgi.framework.BundleException;
 import org.osgi.framework.Constants;
 import org.osgi.framework.ServiceReference;
 import org.osgi.framework.Version;
 import org.osgi.framework.startlevel.BundleStartLevel;
 import org.osgi.framework.wiring.BundleCapability;
 import org.osgi.framework.wiring.BundleRequirement;
 import org.osgi.framework.wiring.BundleRevision;
 import org.osgi.framework.wiring.BundleRevisions;
 import org.osgi.framework.wiring.BundleWire;
 import org.osgi.framework.wiring.BundleWiring;
 import org.osgi.resource.Capability;
 import org.osgi.resource.Requirement;
 import org.osgi.resource.Wire;

 class PojoSRBundle implements Bundle, BundleRevisions
 {
     private final Revision m_revision;
     private final Map<String, String> m_headers;
     private final Version m_version;
     private final String m_location;
     private final Map<Long, Bundle> m_bundles;
     private final ServiceRegistry m_registry;
     private final String m_activatorClass;
     private final long m_id;
     private final String m_symbolicName;
     private volatile BundleActivator m_activator = null;
     volatile int m_state = Bundle.RESOLVED;
     volatile BundleContext m_context = null;
     private final EventDispatcher m_dispatcher;
     private final ClassLoader m_classLoader;
     private final Map<Class, Object> m_services;
     private final Map m_config;

     public PojoSRBundle(ServiceRegistry registry,
                         EventDispatcher dispatcher,
                         Map<Long, Bundle> bundles,
                         String location,
                         long id,
                         String symbolicName,
                         Version version,
                         Revision revision,
                         ClassLoader classLoader,
                         Map<String, String> headers,
                         Map<Class, Object> services,
                         Map<? extends Object, ? extends Object> config)
     {
         m_revision = revision;
         m_headers = headers;
         m_version = version;
         m_location = location;
         m_registry = registry;
         m_dispatcher = dispatcher;
         m_activatorClass = headers.get(Constants.BUNDLE_ACTIVATOR);
         m_id = id;
         m_symbolicName = symbolicName;
         m_bundles = bundles;
         m_classLoader = classLoader;
         m_services = services;
         m_config = config;
         if (classLoader instanceof BundleAware) {
             ((BundleAware) classLoader).setBundle(this);
         }
         if (services != null) {
             for (Object o : services.values()) {
                 if (o instanceof BundleAware) {
                     ((BundleAware) o).setBundle(this);
                 }
             }
         }
     }

     @Override
     public int getState()
     {
         return m_state;
     }

     @Override
     public void start(int options) throws BundleException
     {
         // TODO: lifecycle - fix this
         start();
     }

     @Override
     public synchronized void start() throws BundleException
     {
         if (m_state != Bundle.RESOLVED)
         {
             if (m_state == Bundle.ACTIVE)
             {
                 return;
             }
             throw new BundleException("Bundle is in wrong state for start");
         }
         try
         {
             m_state = Bundle.STARTING;

             m_context = new PojoSRBundleContext(this, m_registry, m_dispatcher, m_bundles, m_config);
             m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STARTING, this));
             if (m_activatorClass != null)
             {
                 m_activator = (BundleActivator) m_classLoader.loadClass(m_activatorClass).newInstance();
                 m_activator.start(m_context);
             }
             m_state = Bundle.ACTIVE;
             m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STARTED, this));
         }
         catch (Throwable ex)
         {
             m_state = Bundle.RESOLVED;
             m_activator = null;
             m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STOPPED, this));
             throw new BundleException("Unable to start bundle", ex);
         }
     }

     @Override
     public void stop(int options) throws BundleException
     {
         // TODO: lifecycle - fix this
         stop();
     }

     @Override
     public synchronized void stop() throws BundleException
     {
         if (m_state != Bundle.ACTIVE)
         {
             if (m_state == Bundle.RESOLVED)
             {
                 return;
             }
             throw new BundleException("Bundle is in wrong state for stop");
         }
         try
         {
             m_state = Bundle.STOPPING;
             m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STOPPING,
                     this));
             if (m_activator != null)
             {
                 m_activator.stop(m_context);
             }
         }
         catch (Throwable ex)
         {
             throw new BundleException("Error while stopping bundle", ex);
         }
         finally
         {
             m_registry.unregisterServices(this);
             m_dispatcher.removeListeners(m_context);
             m_activator = null;
             m_context = null;
             m_state = Bundle.RESOLVED;
             m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STOPPED,
                     this));
         }
     }

     @Override
     public void update(InputStream input) throws BundleException
     {
         throw new BundleException("pojosr bundles can't be updated");
     }

     @Override
     public void update() throws BundleException
     {
         throw new BundleException("pojosr bundles can't be updated");
     }

     @Override
     public void uninstall() throws BundleException
     {
         throw new BundleException("pojosr bundles can't be uninstalled");
     }

     @Override
     public Dictionary<String, String> getHeaders()
     {
         return getHeaders(Locale.getDefault().toString());
     }

     @Override
     public long getBundleId()
     {
         return m_id;
     }

     @Override
     public String getLocation()
     {
         return m_location;
     }

     @Override
     public ServiceReference<?>[] getRegisteredServices()
     {
         return m_registry.getRegisteredServices(this);
     }

     @Override
     public ServiceReference<?>[] getServicesInUse()
     {
         return m_registry.getServicesInUse(this);
     }

     @Override
     public boolean hasPermission(Object permission)
     {
         // TODO: security - fix this
         return true;
     }

     @Override
     public URL getResource(String name)
     {
         URL result = getEntry(name);
         return result != null ? result : m_classLoader.getResource(name != null ? name.trim().startsWith("/") ? name.substring(1) : name : null);
     }

     @Override
     public Dictionary<String, String> getHeaders(String locale)
     {
         return new MapToDictionary<String, String>(getCurrentLocalizedHeader(locale));
     }

     Map<String, String> getCurrentLocalizedHeader(String locale)
     {
         Map<String, String> result = null;

         // Spec says empty local returns raw headers.
         if ((locale == null) || (locale.length() == 0))
         {
             result = (Map) new StringMap(m_headers);
         }

         // If we have no result, try to get it from the cached headers.
         if (result == null)
         {
             synchronized (m_cachedHeaders)
             {
                 // If the bundle is uninstalled, then the cached headers should
                 // only contain the localized headers for the default locale at
                 // the time of uninstall, so just return that.
                 if (getState() == Bundle.UNINSTALLED)
                 {
                     result = m_cachedHeaders.values().iterator().next();
                 }
                 // If the bundle has been updated, clear the cached headers.
                 else if (getLastModified() > m_cachedHeadersTimestamp)
                 {
                     m_cachedHeaders.clear();
                 }
                 // Otherwise, returned the cached headers if they exist.
                 else
                 {
                     // Check if headers for this locale have already been resolved
                     result = m_cachedHeaders.get(locale);
                 }
             }
         }

         // If the requested locale is not cached, then try to create it.
         if (result == null)
         {
             // Get a modifiable copy of the raw headers.
             Map<String, String> headers = (Map) new StringMap(m_headers);
             // Assume for now that this will be the result.
             result = headers;

             // Check to see if we actually need to localize anything
             boolean localize = false;
             for (String s : headers.values())
             {
                 if ((s).startsWith("%"))
                 {
                     localize = true;
                     break;
                 }
             }

             if (!localize)
             {
                 // If localization is not needed, just cache the headers and
                 // return
                 // them as-is. Not sure if this is useful
                 updateHeaderCache(locale, headers);
             }
             else
             {
                 // Do localization here and return the localized headers
                 String basename = headers.get(Constants.BUNDLE_LOCALIZATION);
                 if (basename == null)
                 {
                     basename = Constants.BUNDLE_LOCALIZATION_DEFAULT_BASENAME;
                 }

                 // Create ordered list of files to load properties from
                 List<String> resourceList = createLocalizationResourceList(basename, locale);

                 // Create a merged props file with all available props for this
                 // locale
                 boolean found = false;
                 Properties mergedProperties = new Properties();
                 for (String aResourceList : resourceList)
                 {
                     URL temp = m_revision.getEntry(aResourceList + ".properties");
                     if (temp != null)
                     {
                         found = true;
                         try
                         {
                             mergedProperties.load(temp.openConnection().getInputStream());
                         }
                         catch (IOException ex)
                         {
                             // File doesn't exist, just continue loop
                         }
                     }
                 }

                 // If the specified locale was not found, then the spec says we
                 // should
                 // return the default localization.
                 if (!found && !locale.equals(Locale.getDefault().toString()))
                 {
                     result = getCurrentLocalizedHeader(Locale.getDefault().toString());
                 }
                 // Otherwise, perform the localization based on the discovered
                 // properties and cache the result.
                 else
                 {
                     // Resolve all localized header entries
                     for (Map.Entry<String, String> entry : headers.entrySet())
                     {
                         String value = entry.getValue();
                         if (value.startsWith("%"))
                         {
                             String newvalue;
                             String key = value.substring(value.indexOf("%") + 1);
                             newvalue = mergedProperties.getProperty(key);
                             if (newvalue == null)
                             {
                                 newvalue = key;
                             }
                             entry.setValue(newvalue);
                         }
                     }

                     updateHeaderCache(locale, headers);
                 }
             }
         }

         return result;
     }

     private void updateHeaderCache(String locale, Map<String, String> localizedHeaders)
     {
         synchronized (m_cachedHeaders)
         {
             m_cachedHeaders.put(locale, localizedHeaders);
             m_cachedHeadersTimestamp = System.currentTimeMillis();
         }
     }

     private final Map<String, Map<String, String>> m_cachedHeaders = new HashMap<String, Map<String, String>>();
     private long m_cachedHeadersTimestamp;

     private static List<String> createLocalizationResourceList(String basename, String locale)
     {
         List<String> result = new ArrayList<String>(4);

         StringTokenizer tokens;
         StringBuilder tempLocale = new StringBuilder(basename);

         result.add(tempLocale.toString());

         if (locale.length() > 0)
         {
             tokens = new StringTokenizer(locale, "_");
             while (tokens.hasMoreTokens())
             {
                 tempLocale.append("_").append(tokens.nextToken());
                 result.add(tempLocale.toString());
             }
         }
         return result;
     }

     public String getSymbolicName()
     {
         return m_symbolicName;
     }

     public Class<?> loadClass(String name) throws ClassNotFoundException
     {
         return m_classLoader.loadClass(name);
     }

     @Override
     public Enumeration<URL> getResources(String name) throws IOException
     {
         // TODO: module - implement this based on the revision
         return m_classLoader.getResources(name);
     }

     @Override
     public Enumeration<String> getEntryPaths(String path)
     {
         Enumeration<String> result = new EntryFilterEnumeration<String>(m_revision, false, path, null, false,
                 false);
         return result.hasMoreElements() ? result : null;
     }

     @Override
     public URL getEntry(String path)
     {
         URL result = m_revision.getEntry(path);
         return result;
     }

     @Override
     public long getLastModified()
     {
         return m_revision.getLastModified();
     }

     @Override
     public Enumeration<URL> findEntries(String path, String filePattern, boolean recurse)
     {
         // TODO: module - implement this based on the revision
         Enumeration<URL> result = new EntryFilterEnumeration<URL>(m_revision, true, path, filePattern, recurse, true);
         return result.hasMoreElements() ? result : null;
     }

     @Override
     public BundleContext getBundleContext()
     {
         return m_context;
     }

     @Override
     public Map<X509Certificate, List<X509Certificate>> getSignerCertificates(int signersType)
     {
         // TODO: security - fix this
         return new HashMap<X509Certificate, List<X509Certificate>>();
     }

     @Override
     public Version getVersion()
     {
         return m_version;
     }

     @Override
     public boolean equals(Object o)
     {
         if (o instanceof PojoSRBundle)
         {
             return ((PojoSRBundle) o).m_id == m_id;
         }
         return false;
     }

     @Override
     public int compareTo(Bundle o)
     {
         long thisBundleId = this.getBundleId();
         long thatBundleId = o.getBundleId();
         return (thisBundleId < thatBundleId ? -1 : (thisBundleId == thatBundleId ? 0 : 1));
     }

     @SuppressWarnings("unchecked")
     public <A> A adapt(Class<A> type)
     {
         if (m_services != null && m_services.containsKey(type))
         {
             return (A) m_services.get(type);
         }
         if (type.isInstance(this))
         {
             return (A) this;
         }
         if (type == BundleWiring.class)
         {
             return (A) new BundleWiringImpl(this, m_classLoader);
         }
         if (type == BundleRevision.class)
         {
             return (A) new BundleRevisionImpl(this);
         }
         if (type == BundleStartLevel.class)
         {
             return (A) new BundleStartLevelImpl(this);
         }
         if (DTO.class.isAssignableFrom(type) ||
             DTO[].class.isAssignableFrom(type))
         {
             return DTOFactory.createDTO(this, type);
         }
         return null;
     }

     public File getDataFile(String filename)
     {
         return m_context.getDataFile(filename);
     }

     public String toString()
     {
         String sym = getSymbolicName();
         if (sym != null)
         {
             return sym + " [" + getBundleId() + "]";
         }
         return "[" + getBundleId() + "]";
     }

     @Override
     public List<BundleRevision> getRevisions()
     {
         return Arrays.asList(adapt(BundleRevision.class));
     }

     @Override
     public Bundle getBundle()
     {
         return this;
     }


     public static class BundleStartLevelImpl implements BundleStartLevel
     {
         private final Bundle bundle;

         public BundleStartLevelImpl(Bundle bundle)
         {
             this.bundle = bundle;
         }

         public int getStartLevel()
         {
             // TODO Implement this?
             return 1;
         }

         public void setStartLevel(int startlevel)
         {
             // TODO Implement this?
         }

         public boolean isPersistentlyStarted()
         {
             return true;
         }

         public boolean isActivationPolicyUsed()
         {
             return false;
         }

         @Override
         public Bundle getBundle()
         {
             return bundle;
         }
     }

     public static class BundleRevisionImpl implements BundleRevision
     {
         private final Bundle bundle;

         public BundleRevisionImpl(Bundle bundle)
         {
             this.bundle = bundle;
         }

         @Override
         public String getSymbolicName()
         {
             return bundle.getSymbolicName();
         }

         @Override
         public Version getVersion()
         {
             return bundle.getVersion();
         }

         @Override
         public List<BundleCapability> getDeclaredCapabilities(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<BundleRequirement> getDeclaredRequirements(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public int getTypes()
         {
             if (bundle.getHeaders().get(Constants.FRAGMENT_HOST) != null)
             {
                 return BundleRevision.TYPE_FRAGMENT;
             }
             return 0;
         }

         @Override
         public BundleWiring getWiring()
         {
             return bundle.adapt(BundleWiring.class);
         }

         @Override
         public List<Capability> getCapabilities(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<Requirement> getRequirements(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public Bundle getBundle()
         {
             return bundle;
         }
     }

     public static class BundleWiringImpl implements BundleWiring
     {

         private final Bundle bundle;
         private final ClassLoader classLoader;

         public BundleWiringImpl(Bundle bundle, ClassLoader classLoader)
         {
             this.bundle = bundle;
             this.classLoader = classLoader;
         }

         @Override
         public boolean isInUse()
         {
             return true;
         }

         @Override
         public boolean isCurrent()
         {
             return true;
         }

         @Override
         public BundleRevision getRevision()
         {
             return bundle.adapt(BundleRevision.class);
         }

         @Override
         public List<BundleRequirement> getRequirements(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<BundleWire> getRequiredWires(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<BundleWire> getProvidedWires(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public ClassLoader getClassLoader()
         {
             return classLoader;
         }

         @Override
         public List<BundleCapability> getCapabilities(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<Capability> getResourceCapabilities(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<Requirement> getResourceRequirements(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<Wire> getProvidedResourceWires(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public List<Wire> getRequiredResourceWires(String namespace)
         {
             return Collections.emptyList();
         }

         @Override
         public BundleRevision getResource()
         {
             return getRevision();
         }

         @Override
         public Bundle getBundle()
         {
             return bundle;
         }

         @Override
         public List<URL> findEntries(String path, String filePattern, int options)
         {
             List<URL> result = new ArrayList<URL>();
             for (Enumeration<URL> e = bundle.findEntries(path, filePattern, options == BundleWiring.FINDENTRIES_RECURSE); e.hasMoreElements(); )
             {
                 result.add(e.nextElement());
             }
             return result;
         }

         @Override
         public Collection<String> listResources(String path, String filePattern, int options)
         {
             // TODO: this is wrong, we should return the resource names
             Collection<String> result = new ArrayList<String>();
             for (URL u : findEntries(path, filePattern, options))
             {
                 result.add(u.toString());
             }
             return result;
         }

     }

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

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URL;
	import java.security.cert.X509Certificate;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Dictionary;
	import java.util.Enumeration;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Locale;
	import java.util.Map;
	import java.util.Properties;
	import java.util.StringTokenizer;

	import org.apache.felix.connect.felix.framework.DTOFactory;
	import org.apache.felix.connect.felix.framework.ServiceRegistry;
	import org.apache.felix.connect.felix.framework.util.EventDispatcher;
	import org.apache.felix.connect.felix.framework.util.MapToDictionary;
	import org.apache.felix.connect.felix.framework.util.StringMap;
	import org.osgi.dto.DTO;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.BundleActivator;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.BundleEvent;
	import org.osgi.framework.BundleException;
	import org.osgi.framework.Constants;
	import org.osgi.framework.ServiceReference;
	import org.osgi.framework.Version;
	import org.osgi.framework.startlevel.BundleStartLevel;
	import org.osgi.framework.wiring.BundleCapability;
	import org.osgi.framework.wiring.BundleRequirement;
	import org.osgi.framework.wiring.BundleRevision;
	import org.osgi.framework.wiring.BundleRevisions;
	import org.osgi.framework.wiring.BundleWire;
	import org.osgi.framework.wiring.BundleWiring;
	import org.osgi.resource.Capability;
	import org.osgi.resource.Requirement;
	import org.osgi.resource.Wire;

	class PojoSRBundle implements Bundle, BundleRevisions
	{
	private final Revision m_revision;
	private final Map<String, String> m_headers;
	private final Version m_version;
	private final String m_location;
	private final Map<Long, Bundle> m_bundles;
	private final ServiceRegistry m_registry;
	private final String m_activatorClass;
	private final long m_id;
	private final String m_symbolicName;
	private volatile BundleActivator m_activator = null;
	volatile int m_state = Bundle.RESOLVED;
	volatile BundleContext m_context = null;
	private final EventDispatcher m_dispatcher;
	private final ClassLoader m_classLoader;
	private final Map<Class, Object> m_services;
	private final Map m_config;

	public PojoSRBundle(ServiceRegistry registry,
	EventDispatcher dispatcher,
	Map<Long, Bundle> bundles,
	String location,
	long id,
	String symbolicName,
	Version version,
	Revision revision,
	ClassLoader classLoader,
	Map<String, String> headers,
	Map<Class, Object> services,
	Map<? extends Object, ? extends Object> config)
	{
	m_revision = revision;
	m_headers = headers;
	m_version = version;
	m_location = location;
	m_registry = registry;
	m_dispatcher = dispatcher;
	m_activatorClass = headers.get(Constants.BUNDLE_ACTIVATOR);
	m_id = id;
	m_symbolicName = symbolicName;
	m_bundles = bundles;
	m_classLoader = classLoader;
	m_services = services;
	m_config = config;
	if (classLoader instanceof BundleAware) {
	((BundleAware) classLoader).setBundle(this);
	}
	if (services != null) {
	for (Object o : services.values()) {
	if (o instanceof BundleAware) {
	((BundleAware) o).setBundle(this);
	}
	}
	}
	}

	@Override
	public int getState()
	{
	return m_state;
	}

	@Override
	public void start(int options) throws BundleException
	{
	// TODO: lifecycle - fix this
	start();
	}

	@Override
	public synchronized void start() throws BundleException
	{
	if (m_state != Bundle.RESOLVED)
	{
	if (m_state == Bundle.ACTIVE)
	{
	return;
	}
	throw new BundleException("Bundle is in wrong state for start");
	}
	try
	{
	m_state = Bundle.STARTING;

	m_context = new PojoSRBundleContext(this, m_registry, m_dispatcher, m_bundles, m_config);
	m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STARTING, this));
	if (m_activatorClass != null)
	{
	m_activator = (BundleActivator) m_classLoader.loadClass(m_activatorClass).newInstance();
	m_activator.start(m_context);
	}
	m_state = Bundle.ACTIVE;
	m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STARTED, this));
	}
	catch (Throwable ex)
	{
	m_state = Bundle.RESOLVED;
	m_activator = null;
	m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STOPPED, this));
	throw new BundleException("Unable to start bundle", ex);
	}
	}

	@Override
	public void stop(int options) throws BundleException
	{
	// TODO: lifecycle - fix this
	stop();
	}

	@Override
	public synchronized void stop() throws BundleException
	{
	if (m_state != Bundle.ACTIVE)
	{
	if (m_state == Bundle.RESOLVED)
	{
	return;
	}
	throw new BundleException("Bundle is in wrong state for stop");
	}
	try
	{
	m_state = Bundle.STOPPING;
	m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STOPPING,
	this));
	if (m_activator != null)
	{
	m_activator.stop(m_context);
	}
	}
	catch (Throwable ex)
	{
	throw new BundleException("Error while stopping bundle", ex);
	}
	finally
	{
	m_registry.unregisterServices(this);
	m_dispatcher.removeListeners(m_context);
	m_activator = null;
	m_context = null;
	m_state = Bundle.RESOLVED;
	m_dispatcher.fireBundleEvent(new BundleEvent(BundleEvent.STOPPED,
	this));
	}
	}

	@Override
	public void update(InputStream input) throws BundleException
	{
	throw new BundleException("pojosr bundles can't be updated");
	}

	@Override
	public void update() throws BundleException
	{
	throw new BundleException("pojosr bundles can't be updated");
	}

	@Override
	public void uninstall() throws BundleException
	{
	throw new BundleException("pojosr bundles can't be uninstalled");
	}

	@Override
	public Dictionary<String, String> getHeaders()
	{
	return getHeaders(Locale.getDefault().toString());
	}

	@Override
	public long getBundleId()
	{
	return m_id;
	}

	@Override
	public String getLocation()
	{
	return m_location;
	}

	@Override
	public ServiceReference<?>[] getRegisteredServices()
	{
	return m_registry.getRegisteredServices(this);
	}

	@Override
	public ServiceReference<?>[] getServicesInUse()
	{
	return m_registry.getServicesInUse(this);
	}

	@Override
	public boolean hasPermission(Object permission)
	{
	// TODO: security - fix this
	return true;
	}

	@Override
	public URL getResource(String name)
	{
	URL result = getEntry(name);
	return result != null ? result : m_classLoader.getResource(name != null ? name.trim().startsWith("/") ? name.substring(1) : name : null);
	}

	@Override
	public Dictionary<String, String> getHeaders(String locale)
	{
	return new MapToDictionary<String, String>(getCurrentLocalizedHeader(locale));
	}

	Map<String, String> getCurrentLocalizedHeader(String locale)
	{
	Map<String, String> result = null;

	// Spec says empty local returns raw headers.
	if ((locale == null) \|\| (locale.length() == 0))
	{
	result = (Map) new StringMap(m_headers);
	}

	// If we have no result, try to get it from the cached headers.
	if (result == null)
	{
	synchronized (m_cachedHeaders)
	{
	// If the bundle is uninstalled, then the cached headers should
	// only contain the localized headers for the default locale at
	// the time of uninstall, so just return that.
	if (getState() == Bundle.UNINSTALLED)
	{
	result = m_cachedHeaders.values().iterator().next();
	}
	// If the bundle has been updated, clear the cached headers.
	else if (getLastModified() > m_cachedHeadersTimestamp)
	{
	m_cachedHeaders.clear();
	}
	// Otherwise, returned the cached headers if they exist.
	else
	{
	// Check if headers for this locale have already been resolved
	result = m_cachedHeaders.get(locale);
	}
	}
	}

	// If the requested locale is not cached, then try to create it.
	if (result == null)
	{
	// Get a modifiable copy of the raw headers.
	Map<String, String> headers = (Map) new StringMap(m_headers);
	// Assume for now that this will be the result.
	result = headers;

	// Check to see if we actually need to localize anything
	boolean localize = false;
	for (String s : headers.values())
	{
	if ((s).startsWith("%"))
	{
	localize = true;
	break;
	}
	}

	if (!localize)
	{
	// If localization is not needed, just cache the headers and
	// return
	// them as-is. Not sure if this is useful
	updateHeaderCache(locale, headers);
	}
	else
	{
	// Do localization here and return the localized headers
	String basename = headers.get(Constants.BUNDLE_LOCALIZATION);
	if (basename == null)
	{
	basename = Constants.BUNDLE_LOCALIZATION_DEFAULT_BASENAME;
	}

	// Create ordered list of files to load properties from
	List<String> resourceList = createLocalizationResourceList(basename, locale);

	// Create a merged props file with all available props for this
	// locale
	boolean found = false;
	Properties mergedProperties = new Properties();
	for (String aResourceList : resourceList)
	{
	URL temp = m_revision.getEntry(aResourceList + ".properties");
	if (temp != null)
	{
	found = true;
	try
	{
	mergedProperties.load(temp.openConnection().getInputStream());
	}
	catch (IOException ex)
	{
	// File doesn't exist, just continue loop
	}
	}
	}

	// If the specified locale was not found, then the spec says we
	// should
	// return the default localization.
	if (!found && !locale.equals(Locale.getDefault().toString()))
	{
	result = getCurrentLocalizedHeader(Locale.getDefault().toString());
	}
	// Otherwise, perform the localization based on the discovered
	// properties and cache the result.
	else
	{
	// Resolve all localized header entries
	for (Map.Entry<String, String> entry : headers.entrySet())
	{
	String value = entry.getValue();
	if (value.startsWith("%"))
	{
	String newvalue;
	String key = value.substring(value.indexOf("%") + 1);
	newvalue = mergedProperties.getProperty(key);
	if (newvalue == null)
	{
	newvalue = key;
	}
	entry.setValue(newvalue);
	}
	}

	updateHeaderCache(locale, headers);
	}
	}
	}

	return result;
	}

	private void updateHeaderCache(String locale, Map<String, String> localizedHeaders)
	{
	synchronized (m_cachedHeaders)
	{
	m_cachedHeaders.put(locale, localizedHeaders);
	m_cachedHeadersTimestamp = System.currentTimeMillis();
	}
	}

	private final Map<String, Map<String, String>> m_cachedHeaders = new HashMap<String, Map<String, String>>();
	private long m_cachedHeadersTimestamp;

	private static List<String> createLocalizationResourceList(String basename, String locale)
	{
	List<String> result = new ArrayList<String>(4);

	StringTokenizer tokens;
	StringBuilder tempLocale = new StringBuilder(basename);

	result.add(tempLocale.toString());

	if (locale.length() > 0)
	{
	tokens = new StringTokenizer(locale, "_");
	while (tokens.hasMoreTokens())
	{
	tempLocale.append("_").append(tokens.nextToken());
	result.add(tempLocale.toString());
	}
	}
	return result;
	}

	public String getSymbolicName()
	{
	return m_symbolicName;
	}

	public Class<?> loadClass(String name) throws ClassNotFoundException
	{
	return m_classLoader.loadClass(name);
	}

	@Override
	public Enumeration<URL> getResources(String name) throws IOException
	{
	// TODO: module - implement this based on the revision
	return m_classLoader.getResources(name);
	}

	@Override
	public Enumeration<String> getEntryPaths(String path)
	{
	Enumeration<String> result = new EntryFilterEnumeration<String>(m_revision, false, path, null, false,
	false);
	return result.hasMoreElements() ? result : null;
	}

	@Override
	public URL getEntry(String path)
	{
	URL result = m_revision.getEntry(path);
	return result;
	}

	@Override
	public long getLastModified()
	{
	return m_revision.getLastModified();
	}

	@Override
	public Enumeration<URL> findEntries(String path, String filePattern, boolean recurse)
	{
	// TODO: module - implement this based on the revision
	Enumeration<URL> result = new EntryFilterEnumeration<URL>(m_revision, true, path, filePattern, recurse, true);
	return result.hasMoreElements() ? result : null;
	}

	@Override
	public BundleContext getBundleContext()
	{
	return m_context;
	}

	@Override
	public Map<X509Certificate, List<X509Certificate>> getSignerCertificates(int signersType)
	{
	// TODO: security - fix this
	return new HashMap<X509Certificate, List<X509Certificate>>();
	}

	@Override
	public Version getVersion()
	{
	return m_version;
	}

	@Override
	public boolean equals(Object o)
	{
	if (o instanceof PojoSRBundle)
	{
	return ((PojoSRBundle) o).m_id == m_id;
	}
	return false;
	}

	@Override
	public int compareTo(Bundle o)
	{
	long thisBundleId = this.getBundleId();
	long thatBundleId = o.getBundleId();
	return (thisBundleId < thatBundleId ? -1 : (thisBundleId == thatBundleId ? 0 : 1));
	}

	@SuppressWarnings("unchecked")
	public <A> A adapt(Class<A> type)
	{
	if (m_services != null && m_services.containsKey(type))
	{
	return (A) m_services.get(type);
	}
	if (type.isInstance(this))
	{
	return (A) this;
	}
	if (type == BundleWiring.class)
	{
	return (A) new BundleWiringImpl(this, m_classLoader);
	}
	if (type == BundleRevision.class)
	{
	return (A) new BundleRevisionImpl(this);
	}
	if (type == BundleStartLevel.class)
	{
	return (A) new BundleStartLevelImpl(this);
	}
	if (DTO.class.isAssignableFrom(type) \|\|
	DTO[].class.isAssignableFrom(type))
	{
	return DTOFactory.createDTO(this, type);
	}
	return null;
	}

	public File getDataFile(String filename)
	{
	return m_context.getDataFile(filename);
	}

	public String toString()
	{
	String sym = getSymbolicName();
	if (sym != null)
	{
	return sym + " [" + getBundleId() + "]";
	}
	return "[" + getBundleId() + "]";
	}

	@Override
	public List<BundleRevision> getRevisions()
	{
	return Arrays.asList(adapt(BundleRevision.class));
	}

	@Override
	public Bundle getBundle()
	{
	return this;
	}


	public static class BundleStartLevelImpl implements BundleStartLevel
	{
	private final Bundle bundle;

	public BundleStartLevelImpl(Bundle bundle)
	{
	this.bundle = bundle;
	}

	public int getStartLevel()
	{
	// TODO Implement this?
	return 1;
	}

	public void setStartLevel(int startlevel)
	{
	// TODO Implement this?
	}

	public boolean isPersistentlyStarted()
	{
	return true;
	}

	public boolean isActivationPolicyUsed()
	{
	return false;
	}

	@Override
	public Bundle getBundle()
	{
	return bundle;
	}
	}

	public static class BundleRevisionImpl implements BundleRevision
	{
	private final Bundle bundle;

	public BundleRevisionImpl(Bundle bundle)
	{
	this.bundle = bundle;
	}

	@Override
	public String getSymbolicName()
	{
	return bundle.getSymbolicName();
	}

	@Override
	public Version getVersion()
	{
	return bundle.getVersion();
	}

	@Override
	public List<BundleCapability> getDeclaredCapabilities(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<BundleRequirement> getDeclaredRequirements(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public int getTypes()
	{
	if (bundle.getHeaders().get(Constants.FRAGMENT_HOST) != null)
	{
	return BundleRevision.TYPE_FRAGMENT;
	}
	return 0;
	}

	@Override
	public BundleWiring getWiring()
	{
	return bundle.adapt(BundleWiring.class);
	}

	@Override
	public List<Capability> getCapabilities(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<Requirement> getRequirements(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public Bundle getBundle()
	{
	return bundle;
	}
	}

	public static class BundleWiringImpl implements BundleWiring
	{

	private final Bundle bundle;
	private final ClassLoader classLoader;

	public BundleWiringImpl(Bundle bundle, ClassLoader classLoader)
	{
	this.bundle = bundle;
	this.classLoader = classLoader;
	}

	@Override
	public boolean isInUse()
	{
	return true;
	}

	@Override
	public boolean isCurrent()
	{
	return true;
	}

	@Override
	public BundleRevision getRevision()
	{
	return bundle.adapt(BundleRevision.class);
	}

	@Override
	public List<BundleRequirement> getRequirements(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<BundleWire> getRequiredWires(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<BundleWire> getProvidedWires(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public ClassLoader getClassLoader()
	{
	return classLoader;
	}

	@Override
	public List<BundleCapability> getCapabilities(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<Capability> getResourceCapabilities(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<Requirement> getResourceRequirements(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<Wire> getProvidedResourceWires(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public List<Wire> getRequiredResourceWires(String namespace)
	{
	return Collections.emptyList();
	}

	@Override
	public BundleRevision getResource()
	{
	return getRevision();
	}

	@Override
	public Bundle getBundle()
	{
	return bundle;
	}

	@Override
	public List<URL> findEntries(String path, String filePattern, int options)
	{
	List<URL> result = new ArrayList<URL>();
	for (Enumeration<URL> e = bundle.findEntries(path, filePattern, options == BundleWiring.FINDENTRIES_RECURSE); e.hasMoreElements(); )
	{
	result.add(e.nextElement());
	}
	return result;
	}

	@Override
	public Collection<String> listResources(String path, String filePattern, int options)
	{
	// TODO: this is wrong, we should return the resource names
	Collection<String> result = new ArrayList<String>();
	for (URL u : findEntries(path, filePattern, options))
	{
	result.add(u.toString());
	}
	return result;
	}

	}

	}