Java Bundle.ACTIVE屬性代碼示例

/**
 * Stops and un-installs the current bundle.
 */
public void stopAndUninstallBundles() {
	
	// --- Get a copy of loaded bundles -----
	Vector<Bundle> bundlesToRemove = new Vector<>(this.getBundleVector());
	for (Bundle bundle: bundlesToRemove) {
		try {
			// --- Remove, if active --------
			if (bundle.getState()==Bundle.ACTIVE) {
				bundle.stop();
				bundle.uninstall();
			}
			// --- Remove from vector -------
			this.getBundleVector().remove(bundle);
			if (this.debug) System.out.println("=> - " + bundle.getSymbolicName() + " stoped & uninstalled");
			
		} catch (BundleException bEx) {
			bEx.printStackTrace();
		}
	}
}
 

@Test
public void testBundleActivation()
{
    String bundleName = getBundleName();

    boolean bundleFound = false;
    boolean bundleActive = false;
    Bundle[] bundles = context.getBundles();
    for ( Bundle bundle : bundles )
    {
        //System.out.println( "### bundle=" + bundle + " " + bundle.getState() );
        if ( bundle != null && bundle.getSymbolicName() != null && bundle.getSymbolicName().equals( bundleName ) )
        {
            bundleFound = true;
            if ( bundle.getState() == Bundle.ACTIVE )
            {
                bundleActive = true;
            }
        }
    }

    assertTrue( "Bundle " + bundleName + " not found.", bundleFound );
    assertTrue( "Bundle " + bundleName + " is not active.", bundleActive );
}
 

@Activate
void activate(BundleContext ctx) {
    this.base = new File("").toURI();
    // Find the resolved vaadin bundle
    this.vaadinResourceBundles = new BundleTracker<Bundle>(ctx, Bundle.RESOLVED |
            Bundle.STARTING | Bundle.ACTIVE | Bundle.STOPPING,
                new BundleTrackerCustomizer<Bundle>() {
                    @Override
                    public Bundle addingBundle(Bundle bundle, BundleEvent event) {
                        return VAADIN_SERVER_BUNDLE.equals(bundle.getSymbolicName()) ?
                                bundle : null;
                    }

                    @Override
                    public void modifiedBundle(Bundle bundle, BundleEvent event, Bundle object) {

                    }

                    @Override
                    public void removedBundle(Bundle bundle, BundleEvent event, Bundle object) {
                    }
            });
    this.vaadinResourceBundles.open();
}
 

void addEvent(BlueprintEvent event) {
	// copy event
	BlueprintEvent replay = new BlueprintEvent(event, true);
	Bundle bnd = replay.getBundle();
	if (bnd.getState() == Bundle.ACTIVE || bnd.getState() == Bundle.STARTING || bnd.getState() == Bundle.STOPPING) {
		events.put(bnd, replay);
		if (log.isTraceEnabled())
			log.trace("Adding replay event  " + replay.getType() + " for bundle " + replay.getBundle());
	} else {
		if (log.isTraceEnabled()) {
			log.trace("Replay event " + replay.getType() + " ignored; " + "owning bundle has been uninstalled "
					+ bnd);
			events.remove(bnd);
		}
	}
}
 

/**
 * Implemented from BundleTrackerCustomizer.
 */
@Override
public void modifiedBundle(final Bundle bundle, final BundleEvent event, final Bundle object) {
    if (shuttingDown) {
        return;
    }

    if (bundle.getState() == Bundle.ACTIVE) {
        List<Object> paths = findBlueprintPaths(bundle);

        if (!paths.isEmpty()) {
            LOG.info("Creating blueprint container for bundle {} with paths {}", bundle, paths);

            blueprintExtenderService.createContainer(bundle, paths);
        }
    }
}
 

/**
 * Ensures that if a second SceneService is deployed, that is it not loaded into the Stage.
 */
@Test
public void testSecondSceneServiceNotSelected() throws Exception
{
    final String installDummyBundleTwoCommand ="bundle:install mvn:"
            + OSGIFX_GROUP_ID + "/"
            + DUMMY_TWO_BUNDLE_ARTIFACT_ID + "/"
            + PROJECT_VERSION;
    // Ensure the dummy bundle two is not installed.
    Bundle dummyTwoBundle = getInstalledBundle(OSGIFX_GROUP_ID + "." + DUMMY_TWO_BUNDLE_ARTIFACT_ID);
    assertNull("Dummy Bundle Two found to be already deployed.", dummyTwoBundle);

    session.execute(installDummyBundleTwoCommand);

    dummyTwoBundle = getInstalledBundle(OSGIFX_GROUP_ID + "." + DUMMY_TWO_BUNDLE_ARTIFACT_ID);
    assertNotNull("Dummy Bundle Two was not installed.", dummyTwoBundle);
    if (dummyTwoBundle.getState() != Bundle.ACTIVE)
    {
        dummyTwoBundle.start();
    }
    assertEquals("Dummy Two bundle not active.", Bundle.ACTIVE, dummyTwoBundle.getState());
    dummyTwoBundle.uninstall();

}
 

public static Bundle findBundle(String bsn) throws Exception {
    Bundle[] arr = findFramework().getBundleContext().getBundles();
    Bundle candidate = null;
    for (Bundle b : arr) {
        if (bsn.equals(b.getSymbolicName())) {
            candidate = b;
            if ((b.getState() & Bundle.ACTIVE) != 0) {
                return b;
            }
        }
    }
    return candidate;
}
 

public @Override boolean isEnabled() {
    switch (b.getState()) {
    case Bundle.RESOLVED:
    case Bundle.ACTIVE:
    case Bundle.STARTING:
    case Bundle.STOPPING:
        return true;
    default:
        return false;
    }
}
 

private void processLoadedBundles() {
        List<Bundle> toLoad = new ArrayList<Bundle>();
        for (Bundle b : context.getBundles()) {
            if (b.getState() == Bundle.ACTIVE) {
                Dictionary<?,?> headers = b.getHeaders();
                toLoad.addAll(queue.offer(b, provides(headers), requires(headers), needs(headers)));
            }
        }
//        System.err.println("processing already loaded bundles: " + toLoad);
        load(toLoad);
    }
 

@Override
public void start(BundleContext context) throws Exception {
    registerWeavingHook(context, TransformerRegistrySingleton.get());

    PersistenceBundleTracker customizer = new PersistenceBundleTracker(context.getBundle().adapt(BundleWiring.class));
    persistenceBundleManager = new BundleTracker<Bundle>(context, Bundle.STARTING | Bundle.ACTIVE, customizer);
    persistenceBundleManager.open();
}
 

@Override
public void start(BundleContext ctx) {
    LOG.debug("Starting EclipseLink adapter");
    context = ctx;
    ctx.addBundleListener(this);
    
    for (Bundle b : ctx.getBundles()) {
        if ((b.getState() & (Bundle.ACTIVE | Bundle.STARTING | Bundle.RESOLVED | Bundle.STOPPING)) != 0) 
            handlePotentialEclipseLink(b);
    }
}
 

public void testGetBundleStateAsName() throws Exception {
	OsgiStringUtilsTest.state = Bundle.ACTIVE;
	assertEquals("ACTIVE", OsgiStringUtils.bundleStateAsString(bundle));
	OsgiStringUtilsTest.state = Bundle.STARTING;
	assertEquals("STARTING", OsgiStringUtils.bundleStateAsString(bundle));
	OsgiStringUtilsTest.state = Bundle.STOPPING;
	assertEquals("STOPPING", OsgiStringUtils.bundleStateAsString(bundle));
	OsgiStringUtilsTest.state = -123;
	assertEquals("UNKNOWN STATE", OsgiStringUtils.bundleStateAsString(bundle));
}
 

public void testIsInActiveBundleState() throws Exception {
	OsgiBundleUtilsTest.state = Bundle.ACTIVE;
	assertTrue(OsgiBundleUtils.isBundleActive(bundle));

	OsgiBundleUtilsTest.state = Bundle.STARTING;
	assertFalse(OsgiBundleUtils.isBundleActive(bundle));

	OsgiBundleUtilsTest.state = Bundle.INSTALLED;
	assertFalse(OsgiBundleUtils.isBundleActive(bundle));
}
 

private void readMetanodes() {
	// iterate over the meta node config elements and create meta node templates
	IExtension[] metanodeExtensions = getExtensions(ID_META_NODE);
	for (IExtension mnExt : metanodeExtensions) {
		IConfigurationElement[] mnConfigElems = mnExt.getConfigurationElements();
		for (IConfigurationElement mnConfig : mnConfigElems) {

			try {
				MetaNodeTemplate metaNode = RepositoryFactory.createMetaNode(mnConfig);
				LOGGER.debug("Found meta node definition '" + metaNode.getID() + "': " + metaNode.getName());

				IContainerObject parentContainer = m_root.findContainer(metaNode.getCategoryPath());
				// If parent category is illegal, log an error and append the node to the
				// repository root.
				if (parentContainer == null) {
					LOGGER.warn("Invalid category-path for node contribution: '" + metaNode.getCategoryPath()
							+ "' - adding to root instead");
					m_root.addChild(metaNode);
				} else {
					// everything is fine, add the node to its parent category
					parentContainer.addChild(metaNode);
				}
			} catch (Throwable t) {
				String message = "MetaNode " + mnConfig.getAttribute("id") + "' from plugin '"
						+ mnConfig.getNamespaceIdentifier() + "' could not be created: " + t.getMessage();
				Bundle bundle = Platform.getBundle(mnConfig.getNamespaceIdentifier());

				if (bundle == null || bundle.getState() != Bundle.ACTIVE) {
					// if the plugin is null, the plugin could not be activated maybe due to a not
					// activateable plugin (plugin class cannot be found)
					message = message + " The corresponding plugin bundle could not be activated!";
				}

				LOGGER.error(message, t);
			}
		}
	}
}
 

public void start() throws BundleException {
    state = Bundle.ACTIVE;
}