Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * JBossOSGi Framework
   * %%
   * Copyright (C) 2010 - 2012 JBoss by Red Hat
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 2.1 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Lesser Public License for more details.
  *
  * You should have received a copy of the GNU General Lesser Public
  * License along with this program.  If not, see
  * <http://www.gnu.org/licenses/lgpl-2.1.html>.
  * #L%
  */
 package org.jboss.osgi.framework.internal;
 
 import static org.jboss.osgi.framework.FrameworkLogger.LOGGER;
 import static org.jboss.osgi.framework.FrameworkMessages.MESSAGES;
 
 import java.net.URL;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
An abstract representation of a org.osgi.framework.Bundle state.

It is used by the various AbstractBundleServices.

Author(s):
thomas.diesler@jboss.com
Since:
04-Apr-2011
 
 abstract class AbstractBundleState<R extends BundleStateRevisionextends AbstractElement implements XBundleLockableItem {
 
     private final long bundleId;
     private final String symbolicName;
     private final FrameworkState frameworkState;
     private final AtomicInteger bundleState = new AtomicInteger();
     private final LockSupport bundleLock = LockManager.Factory.addLockSupport(this);
     private AbstractBundleContext<? extends AbstractBundleState<?>> bundleContext;
     private R currentRevision;
 
     AbstractBundleState(FrameworkState frameworkState, R brevlong bundleId) {
         assert frameworkState != null : "Null frameworkState";
         assert brev != null : "Null revision";
 
        // strip-off the directives
        String symbolicName = brev.getOSGiMetaData().getBundleSymbolicName();
        if (symbolicName != null && symbolicName.indexOf(';') > 0)
            symbolicName = symbolicName.substring(0, symbolicName.indexOf(';'));
        this. = bundleId;
        this. = symbolicName;
        this. = frameworkState;
        // Link the bundle revision to this state
        brev.addAttachment(Bundle.classthis);
    }
    static AbstractBundleState<?> assertBundleState(Bundle bundle) {
        assert bundle != null : "Null bundle";
        assert bundle instanceof AbstractBundleState : "Not a BundleState: " + bundle;
        return (AbstractBundleState<?>) bundle;
    }
        return ;
    }
        return .getBundleManager();
    }
        BundleManager bundleManager = .getBundleManager();
        return BundleManagerPlugin.assertBundleManagerPlugin(bundleManager);
    }
        return .getCoreServices();
    }
    @Override
    public int getState() {
        return .get();
    }
    @Override
    public long getBundleId() {
        return ;
    }
    @Override
    public String getSymbolicName() {
        return ;
    }
    @Override
    @SuppressWarnings("unchecked")
    public <T> T adapt(Class<T> type) {
        T result = null;
        if (type.isAssignableFrom(OSGiMetaData.class)) {
            result = (T) getOSGiMetaData();
        } else if (type.isAssignableFrom(StorageState.class)) {
            result = (T) getStorageState();
        } else if (type.isAssignableFrom(BundleManager.class)) {
            result = (T) getBundleManager();
        }
        return result;
    }
    @Override
    public R getBundleRevision() {
        return ;
    }
    void addBundleRevision(R rev) {
        rev.addAttachment(Bundle.classthis);
         = rev;
    }
    abstract R getBundleRevisionById(int revisionId);
    abstract ServiceName getServiceName(int state);
    abstract boolean isSingleton();
        return getBundleRevision().getStorageState();
    }
        return getBundleRevision().getModuleIdentifier();
    }
    void changeState(int state) {
        int bundleEvent;
        switch (state) {
            case .:
                bundleEvent = .;
                break;
            case .:
                bundleEvent = .;
                break;
            case .:
                bundleEvent = .;
                break;
            case .:
                bundleEvent = .;
                break;
            case .:
                bundleEvent = .;
                break;
            case .:
                bundleEvent = .;
                break;
            default:
                throw .illegalArgumentUnknownBundleState(state);
        }
        changeState(statebundleEvent);
    }
    void changeState(int stateint eventType) {
        .tracef("changeState: %s -> %s"this, ConstantsHelper.bundleState(state));
        // Invoke the lifecycle interceptors
        boolean frameworkActive = getBundleManagerPlugin().isFrameworkCreated();
        if (frameworkActive && getBundleId() > 0) {
            plugin.handleStateChange(statethis);
        }
        .set(state);
        // Fire the bundle event
        if (frameworkActive && eventType != 0) {
            fireBundleEvent(eventType);
        }
    }
    void fireBundleEvent(int eventType) {
        FrameworkEvents eventsPlugin = getFrameworkState().getFrameworkEvents();
        eventsPlugin.fireBundleEvent(thiseventType);
    }
    void addRegisteredService(ServiceState serviceState) {
        .tracef("Add registered service %s to: %s"serviceStatethis);
        .add(serviceState);
    }
    void removeRegisteredService(ServiceState serviceState) {
        .tracef("Remove registered service %s from: %s"serviceStatethis);
        .remove(serviceState);
    }
    @Override
        assertNotUninstalled();
        if (rs.isEmpty())
            return null;
        List<ServiceReferencesrefs = new ArrayList<ServiceReference>();
        for (ServiceState serviceState : rs)
            srefs.add(serviceState.getReference());
        return srefs.toArray(new ServiceReference[srefs.size()]);
    }
        return Collections.unmodifiableList();
    }
    @Override
    public ServiceReference[] getServicesInUse() {
        assertNotUninstalled();
        Set<ServiceStateservicesInUse = getServicesInUseInternal();
        if (servicesInUse.isEmpty())
            return null;
        List<ServiceReferencesrefs = new ArrayList<ServiceReference>();
        for (ServiceState serviceState : servicesInUse)
            srefs.add(serviceState.getReference());
        return srefs.toArray(new ServiceReference[srefs.size()]);
    }
        return Collections.unmodifiableSet(.keySet());
    }
    void addServiceInUse(ServiceState serviceState) {
        .tracef("Add service in use %s to: %s"serviceStatethis);
        .putIfAbsent(serviceStatenew AtomicInteger());
        AtomicInteger count = .get(serviceState);
        count.incrementAndGet();
    }
    int removeServiceInUse(ServiceState serviceState) {
        .tracef("Remove service in use %s from: %s"serviceStatethis);
        AtomicInteger count = .get(serviceState);
        if (count == null)
            return -1;
        int countVal = count.decrementAndGet();
        if (countVal == 0)
            .remove(serviceState);
        return countVal;
    }
    @Override
    public boolean hasPermission(Object permission) {
        if (permission == null || permission instanceof Permission == false)
            return false;
        SecurityManager sm = System.getSecurityManager();
        if (sm == null)
            return true;
        // [TODO] AbstractBundle.hasPermission
        return true;
    }
    @Override
    public URL getResource(String name) {
        return getBundleRevision().getResource(name);
    }
    @Override
    public Dictionary<StringStringgetHeaders() {
        // If the specified locale is null then the locale returned
        // by java.util.Locale.getDefault is used.
        return getHeaders(null);
    }
    @Override
    @SuppressWarnings("unchecked")
    public Dictionary<StringStringgetHeaders(String locale) {
        // Get the raw (unlocalized) manifest headers
        Dictionary<StringStringrawHeaders = getOSGiMetaData().getHeaders();
        // If the specified locale is the empty string, this method will return the
        // raw (unlocalized) manifest headers including any leading "%"
        if ("".equals(locale))
            return rawHeaders;
        // If the specified locale is null then the locale
        // returned by java.util.Locale.getDefault is used
        if (locale == null)
            locale = Locale.getDefault().toString();
        // Get the localization base name
        String baseName = rawHeaders.get(.);
        if (baseName == null)
            baseName = .;
        // Get the resource bundle URL for the given base and locale
        URL entryURL = getLocalizationEntry(baseNamelocale);
        // If the specified locale entry could not be found fall back to the default locale entry
        if (entryURL == null) {
            String defaultLocale = Locale.getDefault().toString();
            entryURL = getLocalizationEntry(baseNamedefaultLocale);
        }
        // Read the resource bundle
        ResourceBundle resBundle = null;
        if (entryURL != null) {
            try {
                resBundle = new PropertyResourceBundle(entryURL.openStream());
            } catch (IOException ex) {
                throw .illegalStateCannotReadResourceBundle(exentryURL);
            }
        }
        Dictionary<StringStringlocHeaders = new Hashtable<StringString>();
        Enumeration<Stringe = rawHeaders.keys();
        while (e.hasMoreElements()) {
            String key = e.nextElement();
            String value = rawHeaders.get(key);
            if (value.startsWith("%"))
                value = value.substring(1);
            if (resBundle != null) {
                try {
                    value = resBundle.getString(value);
                } catch (MissingResourceException ex) {
                    // ignore
                }
            }
            locHeaders.put(keyvalue);
        }
        return new CaseInsensitiveDictionary(locHeaders);
    }
        return getBundleRevision().getOSGiMetaData();
    }
    @Override
    public boolean isResolved() {
        return getBundleRevision().getWiring() != null;
    }
    boolean isUninstalled() {
        return getState() == .;
    }
    private URL getLocalizationEntry(String baseNameString locale) {
        // The Framework searches for localization entries by appending suffixes to
        // the localization base name according to a specified locale and finally
        // appending the .properties suffix. If a translation is not found, the locale
        // must be made more generic by first removing the variant, then the country
        // and finally the language until an entry is found that contains a valid translation.
        String entryPath = baseName + "_" + locale + ".properties";
        URL entryURL = getLocalizationEntry(entryPath);
        while (entryURL == null) {
            if (entryPath.equals(baseName + ".properties"))
                break;
            int lastIndex = locale.lastIndexOf('_');
            if (lastIndex > 0) {
                locale = locale.substring(0, lastIndex);
                entryPath = baseName + "_" + locale + ".properties";
            } else {
                entryPath = baseName + ".properties";
            }
            // The bundle's class loader is not used to search for localization entries. Only
            // the contents of the bundle and its attached fragments are searched.
            entryURL = getLocalizationEntry(entryPath);
        }
        return entryURL;
    }

    
The framework must search for localization entries using the following search rules based on the bundle type:

fragment bundle - If the bundle is a resolved fragment, then the search for localization data must delegate to the attached host bundle with the highest version. If the fragment is not resolved, then the framework must search the fragment's JAR for the localization entry.

other bundle - The framework must first search in the bundle’s JAR for the localization entry. If the entry is not found and the bundle has fragments, then the attached fragment JARs must be searched for the localization entry.

    private URL getLocalizationEntry(String entryPath) {
        return getBundleRevision().getLocalizationEntry(entryPath);
    }
    @Override
    public Class<?> loadClass(String classNamethrows ClassNotFoundException {
        assertNotUninstalled();
        return getBundleRevision().loadClass(className);
    }
    @Override
    public Enumeration<URLgetResources(String namethrows IOException {
        return getBundleRevision().getResources(name);
    }
    @Override
    public Enumeration<StringgetEntryPaths(String path) {
        return getBundleRevision().getEntryPaths(path);
    }
    @Override
    public URL getEntry(String path) {
        return getBundleRevision().getEntry(path);
    }
    @Override
    public long getLastModified() {
        return getStorageState().getLastModified();
    }
    void updateLastModified() {
        // A bundle is considered to be modified when it is installed, updated or uninstalled.
    }
    @Override
    public Enumeration<URLfindEntries(String pathString filePatternboolean recurse) {
        return getBundleRevision().findEntries(pathfilePatternrecurse);
    }
        return ;
    }
        assert  == null : "BundleContext already available";
        return  = createContextInternal();
    }
    void destroyBundleContext() {
        // The BundleContext object is only valid during the execution of its context bundle;
        // that is, during the period from when the context bundle is in the STARTING, STOPPING, and ACTIVE bundle states.
        // If the BundleContext object is used subsequently, an IllegalStateException must be thrown.
        // The BundleContext object must never be reused after its context bundle is stopped.
        if ( != null) {
            .destroy();
             = null;
        }
    }
    @Override
    public BundleContext getBundleContext() {
        return ;
    }
    @Override
    @SuppressWarnings("rawtypes")
    public Map getSignerCertificates(int signersType) {
        throw new UnsupportedOperationException();
    }
    @Override
    public Version getVersion() {
        return getBundleRevision().getVersion();
    }
    @Override
    public void start() throws BundleException {
        startWithOptions(0);
    }
    @Override
    public void start(int optionsthrows BundleException {
        startWithOptions(options);
    }
    private void startWithOptions(int optionsthrows BundleException {
        assertStartConditions(options);
        try {
            BundleLifecycle bundleLifecycle = getCoreServices().getBundleLifecycle();
            bundleLifecycle.start(thisoptions);
        } catch (BundleException ex) {
            .debugf(ex"Cannot start bundle: %s"this);
            throw ex;
        }
    }
    void assertStartConditions(int optionsthrows BundleException {
        assertNotUninstalled();
    }
    abstract void startInternal(int optionsthrows BundleException;
    @Override
    public void stop() throws BundleException {
        stopWithOptions(0);
    }
    @Override
    public void stop(int optionsthrows BundleException {
        stopWithOptions(options);
    }
    private void stopWithOptions(int optionsthrows BundleException {
        assertNotUninstalled();
        try {
            BundleLifecycle bundleLifecycle = getCoreServices().getBundleLifecycle();
            bundleLifecycle.stop(thisoptions);
        } catch (BundleException ex) {
            .debugf(ex"Cannot stop bundle: %s"this);
            throw ex;
        }
    }
    abstract void stopInternal(int optionsthrows BundleException;
    @Override
    public void update() throws BundleException {
        updateWithInputStream(null);
    }
    @Override
    public void update(InputStream inputthrows BundleException {
        updateWithInputStream(input);
    }
    private void updateWithInputStream(InputStream inputthrows BundleException {
        assertNotUninstalled();
        try {
            BundleLifecycle bundleLifecycle = getCoreServices().getBundleLifecycle();
            bundleLifecycle.update(thisinput);
        } catch (BundleException ex) {
            .debugf(ex"Cannot update bundle: %s"this);
            throw ex;
        }
    }
    abstract void updateInternal(InputStream inputthrows BundleException;
    @Override
    public void uninstall() throws BundleException {
        // #1 If this bundle's state is UNINSTALLED then an IllegalStateException is thrown
        assertNotUninstalled();
        try {
            BundleLifecycle bundleLifecycle = getCoreServices().getBundleLifecycle();
            bundleLifecycle.uninstall(this, 0);
        } catch (BundleException ex) {
            .debugf(ex"Cannot uninstall bundle: %s"this);
            throw ex;
        }
    }
    abstract void uninstallInternal(int optionsthrows BundleException;
    boolean ensureResolved(boolean fireEvent) {
        if (isUninstalled())
            throw .illegalStateBundleAlreadyUninstalled(this);
        // If this bundle's state is INSTALLED, this method must attempt to resolve this bundle
        // If this bundle cannot be resolved, a Framework event of type FrameworkEvent.ERROR is fired
        // containing a BundleException with details of the reason this bundle could not be resolved.
        boolean result = true;
        if (isResolved() == false) {
            try {
                BundleLifecycle bundleLifecycle = getCoreServices().getBundleLifecycle();
                bundleLifecycle.resolve(this);
                if (.isDebugEnabled()) {
                    BundleWiring wiring = getBundleRevision().getWiring();
                    .tracef("Required resource wires for: %s"wiring.getResource());
                    for (Wire wire : wiring.getRequiredResourceWires(null)) {
                        .tracef("   %s"wire);
                    }
                    .tracef("Provided resource wires for: %s"wiring.getResource());
                    for (Wire wire : wiring.getProvidedResourceWires(null)) {
                        .tracef("   %s"wire);
                    }
                }
            } catch (ResolutionException ex) {
                .debugf(ex"Cannot resolve bundle: %s"this);
                 = ex;
                result = false;
                if (fireEvent == true) {
                    FrameworkEvents eventsPlugin = getFrameworkState().getFrameworkEvents();
                    eventsPlugin.fireFrameworkEvent(this.new BundleException(ex.getMessage(), ex));
                }
            }
        }
        return result;
    }
        return ;
    }
    @Override
    public LockSupport getLockSupport() {
        return ;
    }
    void assertNotUninstalled() {
        if (isUninstalled())
            throw .illegalStateBundleAlreadyUninstalled(this);
    }
    @Override
    public String getCanonicalName() {
        OSGiMetaData metadata = getOSGiMetaData();
        String name = metadata.getBundleSymbolicName();
        name = name != null ? name : metadata.getBundleName();
        return name + ":" + metadata.getBundleVersion();
    }
    @Override
    public int hashCode() {
        return (intgetBundleId() * 51;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof XBundle == false)
            return false;
        if (obj == this)
            return true;
        XBundle other = (XBundleobj;
        return getBundleId() == other.getBundleId();
    }
    @Override
    public String toString() {
        return getCanonicalName();
    }
New to GrepCode? Check out our FAQ X