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.util.List;
 import java.util.Set;
 
Represents the INSTALLED state of a host bundle.

Author(s):
thomas.diesler@jboss.com
David Bosschaert
 
 
     private final AtomicBoolean alreadyStarting = new AtomicBoolean();
     private final AtomicBoolean awaitLazyActivation = new AtomicBoolean();
 
     HostBundleState(FrameworkState frameworkStateHostBundleRevision brevServiceName serviceNameServiceTarget serviceTarget) {
         super(frameworkStatebrevserviceNameserviceTarget);
     }
 
     static HostBundleState assertBundleState(Bundle bundle) {
         AbstractBundleState<?> bundleState = AbstractBundleState.assertBundleState(bundle);
         assert bundleState instanceof HostBundleState : "Not a HostBundleState: " + bundleState;
         return (HostBundleStatebundleState;
     }
 
     // Invalid discovery of Bundle.getBundleContext() method
     // http://issues.ops4j.org/browse/PAXSB-44
     @Override
     public BundleContext getBundleContext() {
         return super.getBundleContext();
     }
 
     @Override
     public boolean isFragment() {
         return false;
     }
 
     @Override
     public HostBundleRevision getBundleRevision() {
         return super.getBundleRevision();
     }
    @Override
        super.addBundleRevision(brev);
        assignModuleIdentifier(brev);
    }
    @Override
    public Class<?> loadClass(String classNamethrows ClassNotFoundException {
        LazyActivationTracker.startTracking(thisclassName);
        try {
            Class<?> loadedClass = super.loadClass(className);
            LazyActivationTracker.processLoadedClass(loadedClass);
            return loadedClass;
        } finally {
            LazyActivationTracker.stopTracking(thisclassName);
        }
    }
    @Override
    void initLazyActivation() {
    }
    @Override
        return new HostBundleContext(this);
    }
    @Override
    HostBundleRevision createUpdateRevision(Deployment depOSGiMetaData metadataStorageState storageStatethrows BundleException {
        return new HostBundleRevision(getFrameworkState(), depmetadatastorageState);
    }
    boolean isActivationLazy() {
        ActivationPolicyMetaData activationPolicy = getActivationPolicy();
        String policyType = (activationPolicy != null ? activationPolicy.getType() : null);
        return ..equals(policyType);
    }
        return getOSGiMetaData().getBundleActivationPolicy();
    }
    boolean awaitLazyActivation() {
        return .get();
    }
    void activateLazily() throws BundleException {
        if (.getAndSet(false)) {
            if (startLevelValidForStart() == true) {
                int options = ;
                if (isBundleActivationPolicyUsed()) {
                    options |= ;
                }
                .debugf("Lazy activation of: %s"this);
                startInternal(options);
            }
        }
    }
    void setBundleActivationPolicyUsed(boolean usePolicy) {
        StorageState storageState = getStorageState();
        storageState.setBundleActivationPolicyUsed(usePolicy);
    }
    boolean isAlreadyStarting() {
        return .get();
    }
        Set<HostBundleStateresult = new HashSet<HostBundleState>();
        if (isResolved() == true) {
            BundleWiring wiring = getBundleRevision().getWiring();
            List<Wirewires = wiring.getRequiredResourceWires(null);
            for (Wire wire : wires) {
                BundleRevision brev = (BundleRevisionwire.getProvider();
                Bundle bundle = brev.getBundle();
                if (bundle instanceof UserBundleState)
                    result.add((HostBundleStatebundle);
            }
        }
        return result;
    }
    @Override
    void startInternal(int optionsthrows BundleException {
        // #1 If this bundle is in the process of being activated or deactivated
        // then this method must wait for activation or deactivation to complete before continuing.
        // If this does not occur in a reasonable time, a BundleException is thrown
        LockContext lockContext = null;
        LockManager lockManager = getFrameworkState().getLockManager();
        try {
            lockContext = lockManager.lockItems(.this);
            // We got the permit, now start
            try {
                .set(true);
                startInternalNow(options);
            } finally {
                .set(false);
            }
        } finally {
            lockManager.unlockItems(lockContext);
        }
    }
    private void startInternalNow(int optionsthrows BundleException {
        // #2 If this bundle's state is ACTIVE then this method returns immediately.
        if (getState() == )
            return;
        // #3 Set this bundle's autostart setting
        persistAutoStartSettings(options);
        // If the Framework's current start level is less than this bundle's start level
        if (startLevelValidForStart() == false) {
            StartLevelSupport plugin = getCoreServices().getStartLevelSupport();
            int frameworkState = getBundleManager().getSystemBundle().getState();
            Level level = (plugin.isChangingStartLevel() || frameworkState != .) ? . : .;
            .log(level.bundleStartLevelNotValid(getBundleStartLevel(), plugin.getStartLevel(), this));
            return;
        }
        .debugf("Starting bundle: %s"this);
        // #4 If this bundle's state is not RESOLVED, an attempt is made to resolve this bundle.
        // If the Framework cannot resolve this bundle, a BundleException is thrown.
        if (ensureResolved(true) == false) {
            ResolutionException resex = getLastResolutionException();
            throw .cannotResolveBundle(resexthis);
        }
        // The BundleContext object is valid during STARTING, STOPPING, and ACTIVE
        if (getBundleContextInternal() == null)
            createBundleContext();
        // #5 If the START_ACTIVATION_POLICY option is set and this bundle's declared activation policy is lazy
        boolean useActivationPolicy = (options & ) != 0;
        if (.get() == true && useActivationPolicy == true) {
            // #5.1 If this bundle's state is STARTING then this method returns immediately.
            if (getState() == )
                return;
            // #5.2 This bundle's state is set to STARTING.
            // #5.3 A bundle event of type BundleEvent.LAZY_ACTIVATION is fired
            return;
        }
        // #6 This bundle's state is set to STARTING.
        // #7 A bundle event of type BundleEvent.STARTING is fired.
        try {
            changeState(.);
        } catch (LifecycleInterceptorException ex) {
            throw .cannotTransitionToStarting(exthis);
        }
        // #8 The BundleActivator.start(BundleContext) method of this bundle is called
        String className = getOSGiMetaData().getBundleActivator();
        if (className != null) {
            try {
                 = getDeployment().getAttachment(BundleActivator.class);
                if ( == null) {
                    Object result = loadClass(className).newInstance();
                    if (result instanceof BundleActivator) {
                         = (BundleActivatorresult;
                    } else {
                        throw .invalidBundleActivator(className);
                    }
                }
                if ( != null) {
                    .start(getBundleContext());
                }
            }
            // If the BundleActivator is invalid or throws an exception then
            catch (Throwable th) {
                // #8.1 This bundle's state is set to STOPPING
                // #8.2 A bundle event of type BundleEvent.STOPPING is fired
                changeState(.);
                // #8.3 Any services registered by this bundle must be unregistered.
                // #8.4 Any services used by this bundle must be released.
                // #8.5 Any listeners registered by this bundle must be removed.
                removeServicesAndListeners(this);
                // The BundleContext object is valid during STARTING, STOPPING, and ACTIVE
                destroyBundleContext();
                // #8.6 This bundle's state is set to RESOLVED
                // #8.7 A bundle event of type BundleEvent.STOPPED is fired
                changeState(.);
                // #8.8 A BundleException is then thrown
                if (th instanceof BundleException)
                    throw (BundleExceptionth;
                throw .cannotStartBundle(ththis);
            }
        }
        // #9 If this bundle's state is UNINSTALLED, because this bundle was uninstalled while
        // the BundleActivator.start method was running, a BundleException is thrown
        if (getState() == .)
            throw .uninstalledDuringActivatorStart(this);
        // #10 This bundle's state is set to ACTIVE.
        // #11 A bundle event of type BundleEvent.STARTED is fired
        changeState(.);
        // Activate the service that represents bundle state ACTIVE
        .infoBundleStarted(this);
    }
    @Override
    void stopInternal(int optionsthrows BundleException {
        // #2 If this bundle is in the process of being activated or deactivated
        // then this method must wait for activation or deactivation to complete before continuing.
        // If this does not occur in a reasonable time, a BundleException is thrown to indicate this bundle was unable to be
        // stopped
        LockContext lockContext = null;
        LockManager lockManager = getFrameworkState().getLockManager();
        try {
            lockContext = lockManager.lockItems(.this);
            // We got the permit, now stop
            stopInternalNow(options);
        } finally {
            lockManager.unlockItems(lockContext);
        }
    }
    private void stopInternalNow(int optionsthrows BundleException {
        int priorState = getState();
        LockContext lockContext = null;
        LockManager lockManager = getFrameworkState().getLockManager();
        try {
            LockManager.LockableItem[] lockItems = new LockableItem[] { this };
            lockContext = lockManager.lockItems(.lockItems);
            // #3 If the STOP_TRANSIENT option is not set then then set this bundle's persistent autostart setting to Stopped.
            // When the Framework is restarted and this bundle's autostart setting is Stopped, this bundle must not be
            // automatically started.
            if ((options & .) == 0) {
                setPersistentlyStarted(false);
                setBundleActivationPolicyUsed(false);
            }
            // #4 If this bundle's state is not STARTING or ACTIVE then this method returns immediately
            if (priorState != . && priorState != .)
                return;
            // #5 This bundle's state is set to STOPPING
            // #6 A bundle event of type BundleEvent.STOPPING is fired
            changeState(.);
        } finally {
            lockManager.unlockItems(lockContext);
        }
        // #7 If this bundle's state was ACTIVE prior to setting the state to STOPPING,
        // the BundleActivator.stop(org.osgi.framework.BundleContext) method of this bundle's BundleActivator,
        // if one is specified, is called. If that method throws an exception, this method must continue to stop
        // this bundle and a BundleException must be thrown after completion of the remaining steps.
        Throwable rethrow = null;
        if (priorState == .) {
            if ( != null) {
                try {
                    .stop(getBundleContext());
                } catch (Throwable t) {
                    rethrow = t;
                }
            }
        }
        // #8 Any services registered by this bundle must be unregistered.
        // #9 Any services used by this bundle must be released.
        // #10 Any listeners registered by this bundle must be removed.
        removeServicesAndListeners(this);
        // #11 If this bundle's state is UNINSTALLED, because this bundle was uninstalled while the
        // BundleActivator.stop method was running, a BundleException must be thrown
        if (getState() == .)
            throw .uninstalledDuringActivatorStop(this);
        // The BundleContext object is valid during STARTING, STOPPING, and ACTIVE
        destroyBundleContext();
        // #12 This bundle's state is set to RESOLVED
        // #13 A bundle event of type BundleEvent.STOPPED is fired
        // Deactivate the service that represents bundle state ACTIVE
        if (rethrow != null) {
            throw .cannotStopBundle(rethrowthis);
        } else {
            .infoBundleStopped(this);
        }
    }
    @Override
    void assertStartConditions(int optionsthrows BundleException {
        super.assertStartConditions(options);
        // The service platform may run this bundle if any of the execution environments named in the
        // Bundle-RequiredExecutionEnvironment header matches one of the execution environments it implements.
        List<StringrequiredEnvs = getOSGiMetaData().getRequiredExecutionEnvironment();
        if (requiredEnvs != null) {
            boolean foundSupportedEnv = false;
            String frameworkEnvProp = (StringgetBundleManager().getProperty(.);
            List<StringavailableEnvs = Arrays.asList(frameworkEnvProp.split("[,\\s]+"));
            for (String aux : requiredEnvs) {
                if (availableEnvs.contains(aux)) {
                    foundSupportedEnv = true;
                    break;
                }
            }
            if (foundSupportedEnv == false)
                throw .unsupportedExecutionEnvironment(requiredEnvsavailableEnvs);
        }
        // If the Framework's current start level is less than this bundle's start level
        if (startLevelValidForStart() == false) {
            // If the START_TRANSIENT option is set, then a BundleException is thrown
            // indicating this bundle cannot be started due to the Framework's current start level
            if ((options & ) != 0)
                throw .cannotStartBundleDueToStartLevel();
            // Set this bundle's autostart setting
            persistAutoStartSettings(options);
        }
    }
    private void persistAutoStartSettings(int options) {
        // The Framework must set this bundle's persistent autostart setting to
        // Started with declared activation if the START_ACTIVATION_POLICY option is set or
        // Started with eager activation if not set.
        if ((options & ) == 0) {
            setPersistentlyStarted(true);
            boolean activationPolicyUsed = (options & ) != 0;
            setBundleActivationPolicyUsed(activationPolicyUsed);
        }
    }
    private int getBundleStartLevel() {
        StartLevelSupport startLevelPlugin = getCoreServices().getStartLevelSupport();
        return startLevelPlugin.getBundleStartLevel(this);
    }
    void setPersistentlyStarted(boolean started) {
        StartLevelSupport startLevelPlugin = getCoreServices().getStartLevelSupport();
        startLevelPlugin.setBundlePersistentlyStarted(thisstarted);
    }
    private void assignModuleIdentifier(HostBundleRevision brev) {
        ModuleManager moduleManager = getFrameworkState().getModuleManager();
        ModuleIdentifier moduleIdentifier = moduleManager.getModuleIdentifier(brev);
        brev.addAttachment(ModuleIdentifier.classmoduleIdentifier);
    }
    private boolean startLevelValidForStart() {
        StartLevelSupport startLevelPlugin = getCoreServices().getStartLevelSupport();
        return startLevelPlugin.getBundleStartLevel(this) <= startLevelPlugin.getStartLevel();
    }
    private boolean isBundleActivationPolicyUsed() {
        StorageState storageState = getStorageState();
        return storageState.isBundleActivationPolicyUsed();
    }
    private void removeServicesAndListeners(HostBundleState hostState) {
        // Any services registered by this bundle must be unregistered.
        // Any services used by this bundle must be released.
        for (ServiceState serviceState : hostState.getRegisteredServicesInternal()) {
            serviceState.unregisterInternal();
        }
        // Any listeners registered by this bundle must be removed
        FrameworkEvents eventsPlugin = hostState.getFrameworkState().getFrameworkEvents();
        eventsPlugin.removeBundleListeners(hostState);
    }
New to GrepCode? Check out our FAQ X