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 static org.jboss.osgi.framework.spi.IntegrationServices.BUNDLE_BASE_NAME;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
The BundleManager is the central managing entity for OSGi bundles.

Author(s):
thomas.diesler@jboss.com
David Bosschaert
Since:
29-Jun-2010
 
 
     // The framework execution environment
     private static String OSGi_FRAMEWORK_EXECUTIONENVIRONMENT;
     // The framework language
     private static String OSGi_FRAMEWORK_LANGUAGE = Locale.getDefault().getLanguage();
     // The os name
    private static String OSGi_FRAMEWORK_OS_NAME;
    // The os version
    private static String OSGi_FRAMEWORK_OS_VERSION;
    // The os version
    private static String OSGi_FRAMEWORK_PROCESSOR;
    // The framework vendor
    private static String OSGi_FRAMEWORK_VENDOR = "jboss.org";
    // The framework version. This is the version of the org.osgi.framework package in r4v42
    private static String OSGi_FRAMEWORK_VERSION = "1.5";
    private static String implementationVersion;
    static {
    }
    private final FrameworkBuilder frameworkBuilder;
    private final ShutdownContainer shutdownContainer;
    private final Set<ExecutorServiceexecutorServices = new HashSet<ExecutorService>();
    private final Map<StringObjectproperties = new HashMap<StringObject>();
    private final AtomicInteger managerState = new AtomicInteger(.);
    private final AtomicBoolean managerStopped = new AtomicBoolean();
    private final ServiceContainer serviceContainer;
    private ServiceTarget serviceTarget;
    private int stoppedEvent;
    BundleManagerPlugin(ServiceContainer serviceContainerFrameworkBuilder frameworkBuilder) {
        super(.);
        this. = serviceContainer;
        this. = frameworkBuilder;
        this. = .;
        // The properties on the BundleManager are mutable as long the framework is not created
        // Plugins may modify these properties in their respective constructor
        .putAll(frameworkBuilder.getProperties());
        // Init default framework properties
        if (getProperty(.) == null)
        if (getProperty(.) == null)
        if (getProperty(.) == null)
        if (getProperty(.) == null)
        boolean allowContainerShutdown = frameworkBuilder.getServiceContainer() == null;
         = new ShutdownContainer(serviceContainerallowContainerShutdown);
    }
    @Override
    protected void addServiceDependencies(ServiceBuilder<BundleManagerbuilder) {
        builder.setInitialMode(.);
    }
    @Override
    public void start(StartContext contextthrows StartException {
        super.start(context);
         = context.getChildTarget();
        .debugf("Framework properties");
        for (Entry<StringObjectentry : .entrySet()) {
            .debugf(" %s = %s"entry.getKey(), entry.getValue());
        }
    }
    @Override
    protected BundleManager createServiceValue(StartContext startContext) {
        return this;
    }
        assert bundleManager != null : "Null bundleManager";
        assert bundleManager instanceof BundleManagerPlugin : "Not an BundleManagerPlugin: " + bundleManager;
        return (BundleManagerPluginbundleManager;
    }
        return ;
    }
    @Override
        return ;
    }
    @Override
    public ServiceTarget getServiceTarget() {
        return ;
    }
    @Override
        return .getOptionalValue();
    }

    
True if the framework has reached the org.jboss.osgi.framework.Services.FRAMEWORK_CREATE state
    boolean isFrameworkCreated() {
        return getFrameworkState() != null;
    }
    void assertFrameworkCreated() {
        if (isFrameworkCreated() == false)
            throw .illegalStateFrameworkNotActive();
    }
    @Override
    public boolean isFrameworkActive() {
    }
        return .getOptionalValue();
    }
    static Version getFrameworkVersion() {
        Version version;
        String versionSpec = BundleManagerPlugin.class.getPackage().getImplementationVersion();
        try {
            version = Version.parseVersion(versionSpec);
        } catch (IllegalArgumentException ex) {
            if (versionSpec.endsWith("-SNAPSHOT")) {
                versionSpec = versionSpec.substring(0, versionSpec.length() - 9);
            }
            version = Version.parseVersion(versionSpec);
        }
        return version;
    }
    int getManagerState() {
        return .get();
    }
    void setManagerState(int state) {
        .set(state);
    }
    @Override
    public Object getProperty(String key) {
        Object value = .get(key);
        if (value == null)
            value = SecurityActions.getSystemProperty(keynull);
        return value;
    }
    @Override
    public Map<StringObjectgetProperties() {
        Map<StringObjectm = new HashMap<StringObject>();
        for (Map.Entry<ObjectObjectentry : System.getProperties().entrySet()) {
            m.put(entry.getKey().toString(), entry.getValue());
        }
        m.putAll();
        return m;
    }
    void setProperty(String keyObject value) {
        if (isFrameworkCreated())
            throw .illegalStateCannotAddProperty();
        .put(keyvalue);
    }
    @Override
    public Set<XBundlegetBundles() {
        Set<XBundleresult = new HashSet<XBundle>();
        XEnvironment env = .getValue();
        for (Resource aux : env.getResources(.)) {
            XBundle bundle = ((XBundleRevisionaux).getBundle();
            if (bundle.getState() != .)
                result.add(bundle);
        }
        return Collections.unmodifiableSet(result);
    }
    @Override
    public Set<XBundlegetBundles(Integer states) {
        Set<XBundleresult = new HashSet<XBundle>();
        XEnvironment env = .getValue();
        for (Resource aux : env.getResources(.)) {
            XBundle bundle = ((XBundleRevisionaux).getBundle();
            if (states == null || (bundle.getState() & states.intValue()) != 0)
                result.add(bundle);
        }
        return Collections.unmodifiableSet(result);
    }
    @Override
    public XBundle getBundleById(long bundleId) {
        if (bundleId == 0) {
            return getFrameworkState().getSystemBundle();
        }
        XEnvironment env = .getValue();
        for (Resource aux : resources) {
            XBundle bundle = ((XBundleRevisionaux).getBundle();
            if (bundle.getBundleId() == bundleId) {
                return bundle;
            }
        }
        return null;
    }
    @Override
    public XBundle getBundleByLocation(String location) {
        assert location != null : "Null location";
        for (XBundle aux : getBundles()) {
            String auxLocation = aux.getLocation();
            if (location.equals(auxLocation)) {
                return aux;
            }
        }
        return null;
    }
    @Override
    public Set<XBundlegetBundles(String symbolicNameString versionRange) {
        Set<XBundleresultSet = new HashSet<XBundle>();
        for (XBundle aux : getBundles(null)) {
            if (symbolicName == null || symbolicName.equals(aux.getSymbolicName())) {
                if (versionRange == null || VersionRange.parse(versionRange).isInRange(aux.getVersion())) {
                    resultSet.add(aux);
                }
            }
        }
        return Collections.unmodifiableSet(resultSet);
    }
    @Override
    public ServiceName installBundle(Deployment depServiceTarget installTargetServiceListener<XBundlelistenerthrows BundleException {
        if (dep == null)
            throw .illegalArgumentNull("deployment");
        if (installTarget == null)
            installTarget = getServiceTarget();
        ServiceName serviceName;
        // If a bundle containing the same location identifier is already installed,
        // the Bundle object for that bundle is returned.
        XBundle bundle = getBundleByLocation(dep.getLocation());
        if (bundle instanceof AbstractBundleState) {
            .debugf("Installing an already existing bundle: %s"dep);
            AbstractBundleState<?> bundleState = AbstractBundleState.assertBundleState(bundle);
            serviceName = bundleState.getServiceName(.);
            VFSUtils.safeClose(dep.getRoot());
        } else {
            try {
                Long bundleId;
                String symbolicName = dep.getSymbolicName();
                XEnvironment env = .getValue();
                // The storage state exists when we re-create the bundle from persistent storage
                StorageState storageState = dep.getAttachment(StorageState.class);
                if (storageState != null) {
                    .debugf("Found storage state: %s"storageState);
                    bundleId = env.nextResourceIdentifier(storageState.getBundleId(), symbolicName);
                } else {
                    bundleId = env.nextResourceIdentifier(nullsymbolicName);
                }
                dep.addAttachment(Long.classbundleId);
                // Check that we have valid metadata
                OSGiMetaData metadata = dep.getAttachment(OSGiMetaData.class);
                if (metadata == null) {
                    DeploymentProvider plugin = getFrameworkState().getDeploymentProvider();
                    metadata = plugin.createOSGiMetaData(dep);
                }
                // Create the bundle services
                if (metadata.getFragmentHost() == null) {
                    HostBundleInstalledService service = new HostBundleInstalledService(getFrameworkState(), dep);
                    serviceName = service.install(installTargetlistener);
                } else {
                    FragmentBundleInstalledService service = new FragmentBundleInstalledService(getFrameworkState(), dep);
                    serviceName = service.install(installTargetlistener);
                }
            } catch (RuntimeException rte) {
                VFSUtils.safeClose(dep.getRoot());
                throw rte;
            } catch (BundleException ex) {
                VFSUtils.safeClose(dep.getRoot());
                throw ex;
            }
        }
        dep.addAttachment(ServiceName.classserviceName);
        return serviceName;
    }
    @Override
    public void startBundle(XBundle bundleint optionsthrows BundleException {
        AbstractBundleState<?> bundleState = AbstractBundleState.assertBundleState(bundle);
        bundleState.startInternal(options);
    }
    @Override
    public void stopBundle(XBundle bundleint optionsthrows BundleException {
        AbstractBundleState<?> bundleState = AbstractBundleState.assertBundleState(bundle);
        bundleState.stopInternal(options);
    }
    @Override
    public void updateBundle(XBundle bundleInputStream inputthrows BundleException {
        AbstractBundleState<?> bundleState = AbstractBundleState.assertBundleState(bundle);
        bundleState.updateInternal(input);
    }
    @Override
    public void uninstallBundle(XBundle bundleint optionsthrows BundleException {
        AbstractBundleState<?> bundleState = AbstractBundleState.assertBundleState(bundle);
        bundleState.uninstallInternal(options);
    }
    void removeBundle(UserBundleState<?> userBundleint options) {
        .tracef("Start removing bundle: %s"userBundle);
        if ((options & .) == 0) {
            BundleStorage storagePlugin = getFrameworkState().getBundleStorage();
            storagePlugin.deleteStorageState(userBundle.getStorageState());
        }
        XEnvironment env = getFrameworkState().getEnvironment();
        for (XBundleRevision abr : userBundle.getAllBundleRevisions()) {
            env.uninstallResources(abr);
        }
        FrameworkEvents eventsPlugin = getFrameworkState().getFrameworkEvents();
        eventsPlugin.fireBundleEvent(userBundle.);
        ModuleManager moduleManager = getFrameworkState().getModuleManager();
        for (XBundleRevision brev : userBundle.getAllBundleRevisions()) {
            UserBundleRevision userRev = (UserBundleRevisionbrev;
            if (userRev.isFragment() == false) {
                ModuleIdentifier identifier = moduleManager.getModuleIdentifier(brev);
                moduleManager.removeModule(brevidentifier);
            }
            userRev.close();
        }
        .debugf("Removed bundle: %s"userBundle);
    }
    @Override
    public ServiceName getServiceName(XBundle bundleint state) {
        ServiceName result = null;
        if (bundle instanceof AbstractBundleState) {
            AbstractBundleState<?> bundleState = (AbstractBundleState<?>) bundle;
            result = bundleState.getServiceName(state);
        }
        return result;
    }
    @Override
    public ServiceName getServiceName(Deployment depint state) {
        // Currently the bundleId is needed for uniqueness because of
        // [MSC-97] Cannot re-install service with same name
        Long bundleId = dep.getAttachment(Long.class);
        String bsname = dep.getSymbolicName();
        String version = dep.getVersion();
        ServiceName serviceName = ServiceName.of("" + bsname"" + version"bid" + bundleId);
        if (state == . || state == . || state == .) {
            serviceName = serviceName.append(ConstantsHelper.bundleState(state));
        }
        return serviceName;
    }
    void setServiceMode(ServiceName serviceNameMode mode) {
        ServiceController<?> controller = .getService(serviceName);
        if (controller == null) {
            .debugf("Cannot set mode %s on non-existing service: %s"modeserviceName);
        } else {
            setServiceMode(controllermode);
        }
    }
    void setServiceMode(ServiceController<?> controllerMode mode) {
        .debugf("Set mode %s on service: %s"modecontroller.getName());
        try {
            controller.setMode(mode);
        } catch (IllegalArgumentException rte) {
            // [MSC-105] Cannot determine whether container is shutting down
            if (rte.getMessage().equals("Container is shutting down") == false)
                throw rte;
        }
    }
    @Override
    public void registerExecutorService(ExecutorService executorService) {
        synchronized () {
            .add(executorService);
        }
    }
    @Override
    public void unregisterExecutorService(ExecutorService executorService) {
        synchronized () {
            .remove(executorService);
        }
    }
    void fireFrameworkError(Bundle bundleString contextThrowable t) {
        if (t instanceof BundleException) {
            plugin.fireFrameworkEvent(bundle.t);
        } else if (bundle != null) {
            plugin.fireFrameworkEvent(bundle.new BundleException("Error " + context + " bundle: " + bundlet));
        } else {
            SystemBundleState systemBundle = .getValue();
            plugin.fireFrameworkEvent(systemBundle.new BundleException("Error " + contextt));
        }
    }
    void fireFrameworkWarning(AbstractBundleState<?> bundleStateString contextThrowable t) {
        if (t instanceof BundleException) {
            plugin.fireFrameworkEvent(bundleState.t);
        } else if (bundleState != null) {
            plugin.fireFrameworkEvent(bundleState.new BundleException("Error " + context + " bundle: " + bundleStatet));
        } else {
            SystemBundleState systemBundle = .getValue();
            plugin.fireFrameworkEvent(systemBundle.new BundleException("Error " + contextt));
        }
    }
    boolean hasStopped() {
    }
    void assertNotStopped() {
        if (hasStopped())
            throw .illegalStateFrameworkAlreadyStopped();
    }
    void shutdownManager(boolean stopForUpdate) {
        // If the Framework is not STARTING and not ACTIVE there is nothing to do
        int state = getManagerState();
        if (state != . && state != .)
            return;
        .debugf("Stop framework");
         = stopForUpdate ? . : .;
        // Move to start level 0 in the current thread
        CoreServices coreServices = getFrameworkState().getCoreServices();
        StartLevelSupport startLevel = coreServices.getStartLevelSupport();
        startLevel.decreaseStartLevel(0);
        synchronized () {
            for (ExecutorService service : ) {
                service.shutdown();
            }
            for (ExecutorService service : ) {
                try {
                    service.awaitTermination(10, .);
                } catch (InterruptedException ex) {
                    // ignore
                }
            }
        }
         = getSystemBundle();
        .shutdown();
    }

    
Wait until this Framework has completely stopped. The stop and update methods on a Framework performs an asynchronous stop of the Framework. This method can be used to wait until the asynchronous stop of this Framework has completed. This method will only wait if called when this Framework is in the Bundle.STARTING, Bundle.ACTIVE, or Bundle.STOPPING states. Otherwise it will return immediately. A Framework Event is returned to indicate why this Framework has stopped.
    FrameworkEvent waitForStop(long timeoutthrows InterruptedException {
        SystemBundleState systemBundle = getSystemBundle();
        Bundle eventSource = systemBundle != null ? systemBundle : ;
        FrameworkEvent frameworkEvent = null;
        if (eventSource != null) {
            int eventType = .isShutdownComplete() ?  : .;
            frameworkEvent = new FrameworkEvent(eventTypeeventSourcenull);
        }
        return frameworkEvent;
    }
    static {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                List<StringexecEnvironments = new ArrayList<String>();
                if (Java.isCompatible(.)) {
                    execEnvironments.add("OSGi/Minimum-1.1");
                    execEnvironments.add("J2SE-1.1");
                }
                if (Java.isCompatible(.)) {
                    execEnvironments.add("OSGi/Minimum-1.2");
                    execEnvironments.add("J2SE-1.2");
                }
                if (Java.isCompatible(.))
                    execEnvironments.add("J2SE-1.3");
                if (Java.isCompatible(.))
                    execEnvironments.add("J2SE-1.4");
                if (Java.isCompatible(.))
                    execEnvironments.add("J2SE-1.5");
                if (Java.isCompatible(.))
                    execEnvironments.add("JavaSE-1.6");
                if (Java.isCompatible(.))
                    execEnvironments.add("JavaSE-1.7");
                String envlist = execEnvironments.toString();
                envlist = envlist.substring(1, envlist.length() - 1);
                 = envlist;
                 = SecurityActions.getSystemProperty("os.name"null);
                 = getOSVersionInOSGiFormat();
                 = SecurityActions.getSystemProperty("os.arch"null);
                return null;
            }
        });
    }
    // Turn the OS version into an OSGi-compatible version. The spec says that an external operator
    // should do this by changing the framework properties, but this is pretty inconvenient and other
    // OSGi frameworks seem to automatically fix this too. The original os version is still available
    // in the "os.version" system property.
    static String getOSVersionInOSGiFormat() {
        StringBuilder osgiVersion = new StringBuilder();
        String sysVersion = SecurityActions.getSystemProperty("os.version"null);
        String[] elements = sysVersion.split("\\.");
        int i = 0;
        for (; i < 3 && i < elements.lengthi++) {
            try {
                Integer.parseInt(elements[i]);
                if (i > 0)
                    osgiVersion.append('.');
                osgiVersion.append(elements[i]);
            } catch (NumberFormatException nfe) {
                break;
            }
        }
        if (i == 3 && elements.length > 3) {
            // All the parts were ok so far, now add the qualifier
            osgiVersion.append('.');
            osgiVersion.append(elements[3]);
        }
        return osgiVersion.toString();
    }
    // The TCK calls waitForStop before it initiates the shutdown, in which case the {@link ServiceContainer}
    // returns imediately from awaitTermination and returns false from isShutdownComplete.
    // We compensate with a grace periode that allows the shutdown to get initiated after awaitTermination.
    static class ShutdownContainer {
        private final ServiceContainer serviceContainer;
        private final AtomicBoolean shutdownInitiated;
        private final boolean allowContainerShutdown;
        ShutdownContainer(final ServiceContainer serviceContainerboolean allowContainerShutdown) {
            this. = serviceContainer;
            this. = allowContainerShutdown;
            this. = new AtomicBoolean(false);
        }
        ServiceController<?> getRequiredService(ServiceName serviceName) {
            return .getRequiredService(serviceName);
        }
        boolean isShutdownInitiated() {
            return .get();
        }
        void shutdown() {
            if () {
                .shutdown();
                synchronized () {
                    .set(true);
                    .debugf("shutdownInitiated.notifyAll");
                    .notifyAll();
                }
            }
        }
        void awaitTermination(long timeoutTimeUnit unitthrows InterruptedException {
            .debugf("awaitTermination: %dms"unit.toMillis(timeout));
            synchronized () {
                if (.get() == false) {
                    .debugf("shutdownInitiated.wait");
                    .wait(2000);
                }
            }
            .awaitTermination(timeout == 0 ? . : timeoutunit);
        }
        boolean isShutdownComplete() {
            return .isShutdownComplete();
        }
    }
New to GrepCode? Check out our FAQ X