/* * (non-Javadoc) * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext) */ public void start(BundleContext bundleContext) throws Exception { Activator.context = bundleContext; plugin = this; GLLogger.infoTech("initializing the igraph plugin for genlab...", getClass()); IgraphLibFactory.isIGraphAvailable(); // declare the LCF algos bundleContext.addBundleListener( new BundleListener() { @Override public void bundleChanged(BundleEvent event) { if (event.getType() != BundleEvent.STARTED) return; if (!event.getBundle().getSymbolicName().equals("genlab.core")) return; GLLogger.infoTech("declaring famous LCF graphs", getClass()); FamousLCFGraphs.declareFamousLCF(); } }); }
/** * Starts the OSGi bundle by registering the engine with the bundle of the Restlet API. * * @param context The bundle context. */ public void start(BundleContext context) throws Exception { org.restlet.engine.Engine.register(false); // Discover helpers in installed bundles and start // the bundle if necessary for (final Bundle bundle : context.getBundles()) { registerHelpers(bundle); } // Listen to installed bundles context.addBundleListener( new BundleListener() { public void bundleChanged(BundleEvent event) { switch (event.getType()) { case BundleEvent.INSTALLED: registerHelpers(event.getBundle()); break; case BundleEvent.UNINSTALLED: break; } } }); Engine.getInstance().registerDefaultConnectors(); Engine.getInstance().registerDefaultAuthentications(); Engine.getInstance().registerDefaultConverters(); }
@Override public synchronized void start(BundleContext bundleContext) throws Exception { // This is how we replace the default FactoryFinder strategy // with one that is more compatible in an OSGi env. FactoryFinder.setObjectFactory(this); debug("activating"); this.bundleContext = bundleContext; cachePackageCapabilities( Service.class, Transport.class, DiscoveryAgent.class, PersistenceAdapter.class); debug("checking existing bundles"); bundleContext.addBundleListener(this); for (Bundle bundle : bundleContext.getBundles()) { if (bundle.getState() == Bundle.RESOLVED || bundle.getState() == Bundle.STARTING || bundle.getState() == Bundle.ACTIVE || bundle.getState() == Bundle.STOPPING) { register(bundle); } } debug("activated"); }
/** * Open this {@code BundleTracker} and begin tracking bundles. * * <p>Bundle which match the state criteria specified when this {@code BundleTracker} was created * are now tracked by this {@code BundleTracker}. * * @throws java.lang.IllegalStateException If the {@code BundleContext} with which this {@code * BundleTracker} was created is no longer valid. * @throws java.lang.SecurityException If the caller and this class do not have the appropriate * {@code AdminPermission[context bundle,LISTENER]}, and the Java Runtime Environment supports * permissions. */ public void open() { final Tracked t; synchronized (this) { if (tracked != null) { return; } if (DEBUG) { System.out.println("BundleTracker.open"); // $NON-NLS-1$ } t = new Tracked(); synchronized (t) { context.addBundleListener(t); Bundle[] bundles = context.getBundles(); if (bundles != null) { int length = bundles.length; for (int i = 0; i < length; i++) { int state = bundles[i].getState(); if ((state & mask) == 0) { /* null out bundles whose states are not interesting */ bundles[i] = null; } } /* set tracked with the initial bundles */ t.setInitial(bundles); } } tracked = t; } /* Call tracked outside of synchronized region */ t.trackInitial(); /* process the initial references */ }
private void initialize(final BundleContext context) { if (Debug.DEBUG_GENERAL) Debug.println("> AspectJHook.initialize() context=" + context); this.bundleContext = context; final ISupplementerRegistry supplementerRegistry = getSupplementerRegistry(); adaptorFactory.initialize(context, supplementerRegistry); final ServiceReference serviceReference = context.getServiceReference(PackageAdmin.class.getName()); final PackageAdmin packageAdmin = (PackageAdmin) context.getService(serviceReference); supplementerRegistry.setBundleContext(context); supplementerRegistry.setPackageAdmin(packageAdmin); context.addBundleListener(new SupplementBundleListener(supplementerRegistry)); // final re-build supplementer final registry state for final installed bundles final Bundle[] installedBundles = context.getBundles(); for (int i = 0; i < installedBundles.length; i++) { supplementerRegistry.addSupplementer(installedBundles[i], false); } for (int i = 0; i < installedBundles.length; i++) { supplementerRegistry.addSupplementedBundle(installedBundles[i]); } if (Debug.DEBUG_GENERAL) Debug.println("< AspectJHook.initialize() adaptorFactory=" + adaptorFactory); }
@Test public void testSynchronousBundleListener() throws Exception { final List<BundleEvent> events = new ArrayList<BundleEvent>(); BundleListener listener = new SynchronousBundleListener() { @Override public void bundleChanged(BundleEvent event) { events.add(event); } }; BundleContext context = getSystemContext(); context.addBundleListener(listener); Bundle bundle = installBundle(getBundleArchiveA()); try { bundle.start(); bundle.stop(); bundle.update(); } finally { bundle.uninstall(); } assertEquals("Event count in: " + events, 10, events.size()); assertEquals(BundleEvent.INSTALLED, events.get(0).getType()); assertEquals(BundleEvent.RESOLVED, events.get(1).getType()); assertEquals(BundleEvent.STARTING, events.get(2).getType()); assertEquals(BundleEvent.STARTED, events.get(3).getType()); assertEquals(BundleEvent.STOPPING, events.get(4).getType()); assertEquals(BundleEvent.STOPPED, events.get(5).getType()); assertEquals(BundleEvent.UNRESOLVED, events.get(6).getType()); assertEquals(BundleEvent.UPDATED, events.get(7).getType()); assertEquals(BundleEvent.UNRESOLVED, events.get(8).getType()); assertEquals(BundleEvent.UNINSTALLED, events.get(9).getType()); }
private void startInternal(BundleContext bundleContext) { // register the LogReaderService LogReaderServiceImpl logReader = new LogReaderServiceImpl(100); String readerServiceName = LogReaderService.class.getName(); m_registrationLogReaderService = bundleContext.registerService(readerServiceName, logReader, null); // Tracking for the EventAdmin try { m_eventAdmin = new EventAdminTracker(bundleContext); } catch (NoClassDefFoundError e) { // If we hit a NoClassDefFoundError, this means the event admin package is not available, // so use a dummy poster m_eventAdmin = new EventAdminPoster() { public void postEvent( Bundle bundle, int level, LogEntry entry, String message, Throwable exception, ServiceReference sr, Map context) {} public void destroy() {} }; } // register the Pax Logging service m_paxLogging = new PaxLoggingServiceImpl(bundleContext, logReader.getAccessDelegate(), m_eventAdmin); Hashtable<String, String> serviceProperties = new Hashtable<String, String>(); serviceProperties.put(Constants.SERVICE_ID, "org.ops4j.pax.logging.configuration"); serviceProperties.put(Constants.SERVICE_PID, CONFIGURATION_PID); m_RegistrationPaxLogging = bundleContext.registerService(LOG_SERVICE_INTERFACE_NAMES, m_paxLogging, serviceProperties); // Add a global handler for all JDK Logging (java.util.logging). if (!Boolean.valueOf(bundleContext.getProperty("org.ops4j.pax.logging.skipJUL"))) { LogManager manager = LogManager.getLogManager(); manager.reset(); // clear out old handlers Logger rootLogger = manager.getLogger(""); Handler[] handlers = rootLogger.getHandlers(); for (Handler handler : handlers) { rootLogger.removeHandler(handler); } rootLogger.setFilter(null); m_JdkHandler = new JdkHandler(m_paxLogging); rootLogger.addHandler(m_JdkHandler); } m_frameworkHandler = new FrameworkHandler(m_paxLogging); bundleContext.addBundleListener(m_frameworkHandler); bundleContext.addFrameworkListener(m_frameworkHandler); bundleContext.addServiceListener(m_frameworkHandler); }
/** component start */ public void init() throws Exception { bundleContext.addBundleListener(this); // for (Bundle bundle : bundleContext.getBundles()) { // switch (bundle.getState()) { // case Bundle.RESOLVED: // case Bundle.STARTING: // case Bundle.ACTIVE: // bundleChanged(new BundleEvent(BundleEvent.RESOLVED, bundle)); // } // } }
public void postConstruct() { logger.debug("postConstruct {" + bundleContext.getBundle() + "}"); loadPredefinedSegments(bundleContext); loadPredefinedScorings(bundleContext); for (Bundle bundle : bundleContext.getBundles()) { if (bundle.getBundleContext() != null) { loadPredefinedSegments(bundle.getBundleContext()); loadPredefinedScorings(bundle.getBundleContext()); } } bundleContext.addBundleListener(this); initializeTimer(); }
public Loader(final SlingRepository repository, final BundleContext bundleContext) { this.bundleContext = bundleContext; this.slingRepository = repository; this.delayedBundles = new ArrayList<Bundle>(); // scan existing bundles bundleContext.addBundleListener(this); for (Bundle bundle : bundleContext.getBundles()) { if (bundle.getState() != Bundle.UNINSTALLED) { registerBundle(bundle); } } }
public void testStart() throws Exception { MockControl bundleContextControl = MockControl.createControl(BundleContext.class); BundleContext context = (BundleContext) bundleContextControl.getMock(); // platform determination // extracting bundle id from bundle bundleContextControl.expectAndReturn(context.getBundle(), new MockBundle()); // look for existing resolved bundles bundleContextControl.expectAndReturn(context.getBundles(), new Bundle[0], 2); // register namespace and entity resolving service // context.registerService((String[]) null, null, null); // bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER); // bundleContextControl.setReturnValue(null); // register context service context.registerService((String[]) null, null, null); bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER); bundleContextControl.setReturnValue(null, MockControl.ONE_OR_MORE); // create task executor EntryLookupControllingMockBundle aBundle = new EntryLookupControllingMockBundle(null); aBundle.setEntryReturnOnNextCallToGetEntry(null); bundleContextControl.expectAndReturn(context.getBundle(), aBundle, MockControl.ONE_OR_MORE); // listen for bundle events context.addBundleListener(null); bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER); bundleContextControl.setVoidCallable(2); bundleContextControl.expectAndReturn( context.registerService(new String[0], null, new Properties()), new MockServiceRegistration(), MockControl.ONE_OR_MORE); bundleContextControl.setMatcher(MockControl.ALWAYS_MATCHER); bundleContextControl.replay(); this.listener.start(context); bundleContextControl.verify(); }
// called by the initializer after the initial entities bundle was generated public void start() { LOGGER.info("Scanning for MDS annotations"); bundlesToRefresh = new ArrayList<>(); TransactionTemplate tmpl = new TransactionTemplate(transactionManager); tmpl.execute( new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { schemaChangeLockManager.acquireLock( MdsBundleWatcher.class.getName() + " - start annotation processing"); processInstalledBundles(); schemaChangeLockManager.releaseLock( MdsBundleWatcher.class.getName() + " - start annotation processing"); } }); tmpl.execute( new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(TransactionStatus status) { schemaChangeLockManager.acquireLock( MdsBundleWatcher.class.getName() + " - start refreshing bundles"); // if we found annotations, we will refresh the bundle in order to start weaving the // classes it exposes if (!bundlesToRefresh.isEmpty()) { refreshBundles(bundlesToRefresh); } schemaChangeLockManager.releaseLock( MdsBundleWatcher.class.getName() + " - start refreshing bundles"); } }); bundleContext.addBundleListener(this); }
private RepositoryAdminImpl createRepositoryAdmin() throws Exception { BundleContext bundleContext = (BundleContext) EasyMock.createMock(BundleContext.class); Bundle systemBundle = (Bundle) EasyMock.createMock(Bundle.class); Activator.setContext(bundleContext); EasyMock.expect(bundleContext.getProperty(RepositoryAdminImpl.REPOSITORY_URL_PROP)) .andReturn(getClass().getResource("/referred.xml").toExternalForm()); EasyMock.expect(bundleContext.getProperty((String) EasyMock.anyObject())) .andReturn(null) .anyTimes(); EasyMock.expect(bundleContext.getBundle(0)).andReturn(systemBundle); EasyMock.expect(systemBundle.getHeaders()).andReturn(new Hashtable()); EasyMock.expect(systemBundle.getRegisteredServices()).andReturn(null); EasyMock.expect(new Long(systemBundle.getBundleId())).andReturn(new Long(0)).anyTimes(); EasyMock.expect(systemBundle.getBundleContext()).andReturn(bundleContext); bundleContext.addBundleListener((BundleListener) EasyMock.anyObject()); bundleContext.addServiceListener((ServiceListener) EasyMock.anyObject()); EasyMock.expect(bundleContext.getBundles()).andReturn(new Bundle[] {systemBundle}); final Capture c = new Capture(); EasyMock.expect(bundleContext.createFilter((String) capture(c))) .andAnswer( new IAnswer() { public Object answer() throws Throwable { return FilterImpl.newInstance((String) c.getValue()); } }) .anyTimes(); EasyMock.replay(new Object[] {bundleContext, systemBundle}); RepositoryAdminImpl repoAdmin = new RepositoryAdminImpl(bundleContext, new Logger(bundleContext)); // force initialization && remove all initial repositories Repository[] repos = repoAdmin.listRepositories(); for (int i = 0; repos != null && i < repos.length; i++) { repoAdmin.removeRepository(repos[i].getURI()); } return repoAdmin; }
public void addBundleListener(BundleListener listener) { delegate.addBundleListener(listener); }
public void start(BundleContext context) { context.addBundleListener(this); }
@Test public void testBundleListener() throws Exception { Bundle bundle = installBundle(getBundleArchiveA()); try { bundle.start(); BundleContext bundleContext = bundle.getBundleContext(); assertNotNull(bundleContext); try { bundleContext.addBundleListener(null); fail("Should not be here!"); } catch (IllegalArgumentException t) { // expected } try { bundleContext.removeBundleListener(null); fail("Should not be here!"); } catch (IllegalArgumentException t) { // expected } bundle.stop(); getSystemContext().addBundleListener(this); bundle.start(); assertBundleEvent(BundleEvent.STARTING, bundle); assertBundleEvent(BundleEvent.STARTED, bundle); assertNoBundleEvent(); bundle.stop(); assertBundleEvent(BundleEvent.STOPPING, bundle); assertBundleEvent(BundleEvent.STOPPED, bundle); assertNoBundleEvent(); getSystemContext().removeBundleListener(this); bundle.start(); bundle.stop(); assertNoBundleEvent(); getSystemContext().addBundleListener(this); getSystemContext().addBundleListener(this); bundle.start(); assertBundleEvent(BundleEvent.STARTING, bundle); assertBundleEvent(BundleEvent.STARTED, bundle); assertNoBundleEvent(); bundle.stop(); assertBundleEvent(BundleEvent.STOPPING, bundle); assertBundleEvent(BundleEvent.STOPPED, bundle); assertNoBundleEvent(); bundle.start(); assertBundleEvent(BundleEvent.STARTING, bundle); assertBundleEvent(BundleEvent.STARTED, bundle); assertNoBundleEvent(); // [TODO] test asynch BundleListener } finally { bundle.uninstall(); } assertBundleEvent(BundleEvent.STOPPING, bundle); assertBundleEvent(BundleEvent.STOPPED, bundle); assertBundleEvent(BundleEvent.UNINSTALLED, bundle); getSystemContext().removeBundleListener(this); }
/** * The activate method which called when the bundle is started. This will check for the presence * of ManagedService and then configure logging. Else this will throw a runtime exception. * * @param bundleContext BundleContext of this bundle * @throws Exception Could be thrown while bundle starting */ public void start(BundleContext bundleContext) throws Exception { this.bundleContext = bundleContext; bundleContext.addBundleListener(this); configureLogging(bundleContext); }
public void start(BundleContext context) throws Exception { super.start(context); System.out.println("CCWPlugin.start: ENTER"); plugin = this; context.addBundleListener( new BundleListener() { @Override public void bundleChanged(BundleEvent evt) { if (evt.getBundle() == CCWPlugin.this.getBundle() && evt.getType() == BundleEvent.STARTED) { tracer = new Tracer(evt.getBundle().getBundleContext(), TraceOptions.getTraceOptions()); // We immediately give control back to the OSGi framework application // by starting the code in a new thread new Thread( new Runnable() { @Override public void run() { // Some Eclipse plugins, such as LaunchingResourceManager // call PlatformUI.getWorbench() and checking for null, // even though null is not a valid return value // (instead, an exception is thrown), resulting // in the whole Eclipse to collapse. // Let's protect this code once and for all by ensuring // That the Workbench has been initialized before calling // the initialization code while (!PlatformUI.isWorkbenchRunning()) { try { if (CCWPlugin.this.getBundle().getState() != Bundle.ACTIVE) return; Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } // The Workbench may not be initialized, causing weird issues e.g. in // Kepler // WorkbenchThemeManager.getInstance() in Kepler for instance does // not ensure the instance is created in the UI Thread // Once the Workbench is initialized, WorkbenchThemeManager & all // are ensured to be created, so this removes a bunch of plugin startup // race conditions final IWorkbench workbench = PlatformUI.getWorkbench(); final AtomicBoolean isWorkbenchInitialized = new AtomicBoolean(); while (true) { workbench .getDisplay() .syncExec( new Runnable() { @Override public void run() { if (workbench.getActiveWorkbenchWindow() != null) { // we've got an active window, so workbench is // initialized! isWorkbenchInitialized.set(true); } } }); if (isWorkbenchInitialized.get()) { break; } else { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } } // Here, the workbench is initialized if (System.getProperty("ccw.autostartnrepl") != null) { try { startREPLServer(); } catch (Exception e) { e.printStackTrace(); } } getNatureAdapter().start(); } }) .start(); } } }); System.out.println("CCWPlugin.start: EXIT"); }
public BundleManagerService(BundleContext bc) { this.context = bc; bc.addBundleListener(this); config = new BundleConfig(getConfigService()); installPlugins(); }
private Command getExecuteCommand(BundleContext context) throws IOException { Map<String, Command> commands = new HashMap<String, Command>(); commands.put( "help", new HelpCommand(commands).setContext(context).setHelp("help - display commands.")); commands.put( "install", new InstallCommand() .setContext(context) .setHelp("install <url> - Install the bundle jar at the given url.")); commands.put( "start", new StartCommand() .setContext(context) .setHelp("start <id> - Start the bundle with the given bundle id.")); commands.put( "stop", new StopCommand() .setContext(context) .setHelp("stop <id> - Stop the bundle with the given bundle id.")); commands.put( "uninstall", new UninstallCommand() .setContext(context) .setHelp("uninstall <id> - Uninstall the bundle with the given bundle id.")); commands.put( "update", new UpdateCommand() .setContext(context) .setHelp("update <id> - Update the bundle with the given bundle id.")); commands.put( "startlevel", new StartLevelCommand() .setContext(context) .setHelp("startlevel [<level>] - Get or set the framework startlevel.")); commands.put( "bundlelevel", new BundleLevelCommand() .setContext(context) .setHelp("bundlelevel [-i] [<level>] <id> - Get or set (initial) bundle startlevel.")); commands.put( "refresh", new RefreshCommand().setContext(context).setHelp("refresh [<id> ...] - refresh bundles.")); commands.put( "resolve", new ResolveCommand().setContext(context).setHelp("resolve [<id> ...] - resolve bundles.")); commands.put( "bundles", new BundlesCommand() .setContext(context) .setHelp("bundles - Print information about the currently installed bundles")); commands.put( "obr-repo", new RepositoryCommand() .setContext(context) .setHelp("obr-repo {list-urls|add-url <url> |remove-url <url>|list}")); commands.put( "obr-resolver", new ResolverCommand().setContext(context).setHelp("obr-resolver <resource-filter>")); commands.put( "dpa", new DeploymentPackageCommand() .setContext(context) .setHelp("dpa {list|install <url>|uninstall <name>}")); commands.put( "cm", new ConfigAdminCommand() .setContext(context) .setHelp( "cm {list|add-cfg <pid> [key=value ...]|add-factory-cfg <pid> [key=value]|remove-factory-cfg <pid>|remove-cfg <pid>}")); commands.put("type", new MetaDataCommand().setContext(context).setHelp("type <bundle-id>")); HistoryDecorator command = new HistoryDecorator(new ExecuteCommand(commands), readHistory(context)); context.addFrameworkListener(command); context.addBundleListener(command); m_history = command; commands.put( "history", new HistoryCommand(command) .setContext(context) .setHelp("history {<n>} - Show the last commands (up to <n> if present).")); return command; }