@Test public void testUpdateImportedPackagesRemoved() throws Exception { Archive<?> assemblyx = assembleArchive("bundlex", "/bundles/update/update-bundlex", ObjectX.class); Archive<?> assembly1 = assembleArchive("bundle1", "/bundles/update/update-bundle1", ObjectA.class); Archive<?> assembly2 = assembleArchive("bundle2", "/bundles/update/update-bundle101", ObjectB.class); Bundle bundleA = installBundle(assembly1); Bundle bundleX = installBundle(assemblyx); try { BundleContext systemContext = getFramework().getBundleContext(); int beforeCount = systemContext.getBundles().length; bundleA.start(); bundleX.start(); Class<?> cls = bundleX.loadClass(ObjectX.class.getName()); cls.newInstance(); assertBundleState(Bundle.ACTIVE, bundleA.getState()); assertBundleState(Bundle.ACTIVE, bundleX.getState()); assertEquals(Version.parseVersion("1.0.0"), bundleA.getVersion()); assertEquals("update-bundle1", bundleA.getSymbolicName()); assertLoadClass(bundleA, ObjectA.class.getName()); assertLoadClassFail(bundleA, ObjectB.class.getName()); assertLoadClass(bundleX, ObjectA.class.getName()); bundleA.update(toInputStream(assembly2)); assertBundleState(Bundle.ACTIVE, bundleA.getState()); assertBundleState(Bundle.ACTIVE, bundleX.getState()); assertEquals(Version.parseVersion("1.0.1"), bundleA.getVersion()); // Assembly X depends on a package in the bundle, this should still be available assertLoadClass(bundleX, ObjectA.class.getName()); getSystemContext().addFrameworkListener(this); getPackageAdmin().refreshPackages(new Bundle[] {bundleA}); assertFrameworkEvent(FrameworkEvent.ERROR, bundleX, BundleException.class); assertFrameworkEvent( FrameworkEvent.PACKAGES_REFRESHED, getSystemContext().getBundle(0), null); assertBundleState(Bundle.ACTIVE, bundleA.getState()); // Bundle X is installed because it cannot be resolved any more assertBundleState(Bundle.INSTALLED, bundleX.getState()); assertEquals(Version.parseVersion("1.0.1"), bundleA.getVersion()); // Nobody depends on the packages, so we can update them straight away assertLoadClass(bundleA, ObjectB.class.getName()); assertLoadClassFail(bundleA, ObjectA.class.getName()); int afterCount = systemContext.getBundles().length; assertEquals("Bundle count", beforeCount, afterCount); } finally { getSystemContext().removeFrameworkListener(this); bundleX.uninstall(); bundleA.uninstall(); } }
protected Bundle getInstalledBundle(String symbolicName) { for (Bundle b : bundleContext.getBundles()) { if (b.getSymbolicName().equals(symbolicName)) { return b; } } for (Bundle b : bundleContext.getBundles()) { System.err.println("Bundle: " + b.getSymbolicName()); } throw new RuntimeException("Bundle " + symbolicName + " does not exist"); }
/* * Launches against the agent */ public void testSimpleLauncher() throws Exception { Project project = workspace.getProject("p1"); Run bndrun = new Run(workspace, project.getBase(), project.getFile("one.bndrun")); bndrun.setProperty("-runpath", "biz.aQute.remote.launcher"); bndrun.setProperty("-runbundles", "bsn-1,bsn-2"); bndrun.setProperty("-runremote", "test"); final RemoteProjectLauncherPlugin pl = (RemoteProjectLauncherPlugin) bndrun.getProjectLauncher(); pl.prepare(); final CountDownLatch latch = new CountDownLatch(1); final AtomicInteger exitCode = new AtomicInteger(-1); List<? extends RunSession> sessions = pl.getRunSessions(); assertEquals(1, sessions.size()); final RunSession session = sessions.get(0); Thread t = new Thread("test-launch") { public void run() { try { exitCode.set(session.launch()); } catch (Exception e) { e.printStackTrace(); } finally { latch.countDown(); } } }; t.start(); Thread.sleep(500); for (Bundle b : context.getBundles()) { System.out.println(b.getLocation()); } assertEquals(4, context.getBundles().length); String p1 = t1.getAbsolutePath(); System.out.println(p1); assertNotNull(context.getBundle(p1)); assertNotNull(context.getBundle(t2.getAbsolutePath())); pl.cancel(); latch.await(); assertEquals(-3, exitCode.get()); bndrun.close(); }
private void processInstalledBundles() { List<MDSProcessorOutput> outputs = new ArrayList<>(); for (Bundle bundle : bundleContext.getBundles()) { MDSProcessorOutput output = process(bundle); if (hasNonEmptyOutput(output)) { outputs.add(output); bundlesToRefresh.add(bundle); try { migrationService.processBundle(bundle); } catch (IOException e) { LOGGER.error( "An error occurred while copying the migrations from bundle: {}", bundle.getSymbolicName(), e); } addEditableLookups(output, bundle); } } for (MDSProcessorOutput output : outputs) { processAnnotationScanningResults( output.getEntityProcessorOutputs(), output.getLookupProcessorOutputs()); } }
@Before public void areWeReady() { assertNotNull(bc); boolean debugit = false; Bundle b[] = bc.getBundles(); for (int i = 0; i < b.length; i++) { int state = b[i].getState(); if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) { log.debug("Bundle:" + b[i].getSymbolicName() + " state:" + stateToString(state)); debugit = true; } } if (debugit) { log.debug("Do some debugging because some bundle is " + "unresolved"); } // Assert if true, if false we are good to go! assertFalse(debugit); // Now lets create a hosttracker for testing purpose ServiceReference s = bc.getServiceReference(ISwitchManager.class.getName()); if (s != null) { this.switchManager = (ISwitchManager) bc.getService(s); } // If StatisticsManager is null, cannot run tests. assertNotNull(this.switchManager); }
public static FrameworkDTO newFrameworkDTO( BundleContext systemBundleContext, Map<String, String> configuration) { FrameworkDTO dto = new FrameworkDTO(); dto.properties = asProperties(configuration); if (systemBundleContext == null) { dto.bundles = newList(0); dto.services = newList(0); return dto; } Bundle[] bundles = systemBundleContext.getBundles(); int size = bundles == null ? 0 : bundles.length; List<BundleDTO> bundleDTOs = newList(size); for (int i = 0; i < size; i++) { bundleDTOs.add(newBundleDTO(bundles[i])); } dto.bundles = bundleDTOs; try { ServiceReference<?>[] references = systemBundleContext.getAllServiceReferences(null, null); size = references == null ? 0 : references.length; List<ServiceReferenceDTO> refDTOs = newList(size); for (int i = 0; i < size; i++) { ServiceReferenceDTO serviceRefDTO = getServiceReferenceDTO(references[i]); if (serviceRefDTO != null) { refDTOs.add(serviceRefDTO); } } dto.services = refDTOs; } catch (InvalidSyntaxException e) { dto.services = newList(0); } return dto; }
protected Class<?> getClass(String name) { BundleContext bundleContext = null; Bundle currentBundle = FrameworkUtil.getBundle(getClass()); if (currentBundle != null) { bundleContext = currentBundle.getBundleContext(); } if (bundleContext != null) { Bundle[] bundles = bundleContext.getBundles(); for (Bundle bundle : bundles) { if (bundle.getState() >= Bundle.RESOLVED) { try { return bundle.loadClass(name); } catch (ClassNotFoundException e) { // Ignore } } } } else { try { return Class.forName(name); } catch (ClassNotFoundException e) { LOG.warn("Failed to find class for {}", name); throw new RuntimeException(e); } } LOG.warn("Failed to find class for {}", name); throw new RuntimeException(new ClassNotFoundException(name)); }
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); }
/** * 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(); }
@Before public void areWeReady() { assertNotNull(bc); boolean debugit = false; Bundle b[] = bc.getBundles(); for (int i = 0; i < b.length; i++) { int state = b[i].getState(); if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) { System.out.println(">>> " + b[i].getSymbolicName() + " " + stateToString(state)); log.debug("Bundle:" + b[i].getSymbolicName() + " state:" + stateToString(state)); debugit = true; } } if (debugit) { log.debug("Do some debugging because some bundle is unresolved"); } // Assert if true, if false we are good to go! assertFalse(debugit); ServiceReference r = bc.getServiceReference(IAffinityManager.class.getName()); if (r != null) { this.manager = (IAffinityManager) bc.getService(r); } // If AffinityManager is null, cannot run tests. assertNotNull(this.manager); }
/** * 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 */ }
@Test public void shouldSendEventWhenChannelWasUpdated() { Channel channel = new Channel("displayName", BUNDLE_SYMBOLIC_NAME, VERSION); EventParameter eventParameter = new EventParameter("displayName", "eventKey"); TriggerEvent triggerEvent = new TriggerEvent("displayName", "subject", null, Arrays.asList(eventParameter), ""); channel.getTriggerTaskEvents().add(triggerEvent); when(channelsDataService.findByModuleName(channel.getModuleName())).thenReturn(channel); when(bundleContext.getBundles()).thenReturn(new Bundle[] {bundle}); when(bundle.getSymbolicName()).thenReturn(BUNDLE_SYMBOLIC_NAME); ArgumentCaptor<MotechEvent> captor = ArgumentCaptor.forClass(MotechEvent.class); Channel updatedChannel = new Channel("displayName2", BUNDLE_SYMBOLIC_NAME, VERSION); updatedChannel.getTriggerTaskEvents().add(triggerEvent); channelService.addOrUpdate(updatedChannel); ArgumentCaptor<TransactionCallback> transactionCaptor = ArgumentCaptor.forClass(TransactionCallback.class); verify(channelsDataService).doInTransaction(transactionCaptor.capture()); transactionCaptor.getValue().doInTransaction(null); verify(channelsDataService).update(channel); verify(eventRelay).sendEventMessage(captor.capture()); MotechEvent event = captor.getValue(); assertEquals(CHANNEL_UPDATE_SUBJECT, event.getSubject()); assertEquals(BUNDLE_SYMBOLIC_NAME, event.getParameters().get(CHANNEL_MODULE_NAME)); }
@Test public void shouldUseCorrectClassLoaderWhenCreatingInstances() throws ClassNotFoundException { mockSampleFields(); mockEntity(); mockDataService(); Bundle ddeBundle = mock(Bundle.class); Bundle entitiesBundle = mock(Bundle.class); when(bundleContext.getBundles()).thenReturn(new Bundle[] {ddeBundle, entitiesBundle}); when(entity.getBundleSymbolicName()).thenReturn("org.motechproject.test"); when(entitiesBundle.getSymbolicName()) .thenReturn(Constants.BundleNames.MDS_ENTITIES_SYMBOLIC_NAME); when(ddeBundle.getSymbolicName()).thenReturn("org.motechproject.test"); Class testClass = TestSample.class; when(entitiesBundle.loadClass(testClass.getName())).thenReturn(testClass); when(ddeBundle.loadClass(testClass.getName())).thenReturn(testClass); EntityRecord entityRecord = new EntityRecord(null, ENTITY_ID, Collections.<FieldRecord>emptyList()); when(entity.isDDE()).thenReturn(true); instanceService.saveInstance(entityRecord); verify(ddeBundle).loadClass(TestSample.class.getName()); when(entity.isDDE()).thenReturn(false); instanceService.saveInstance(entityRecord); verify(entitiesBundle).loadClass(TestSample.class.getName()); verify(motechDataService, times(2)).create(any(TestSample.class)); }
public static void activateBundlesFromFile(BundleContext context, String bundleStartupFileName) throws IOException, BundleException { Map<String, Version> bundleMap = readBundleActivationFile(context.getBundle(), bundleStartupFileName); Map<String, Bundle> startupBundleMap = new HashMap<String, Bundle>(); for (Bundle b : context.getBundles()) { String symbolicName = b.getSymbolicName(); if (bundleMap.containsKey(symbolicName)) { Version version = b.getVersion(); Version reqVersion = bundleMap.get(symbolicName); if (version.getMajor() == reqVersion.getMajor() && version.getMinor() >= reqVersion.getMinor()) { if (startupBundleMap.containsKey(symbolicName)) { Bundle previousBundle = startupBundleMap.get(symbolicName); if (version.compareTo(previousBundle.getVersion()) <= 0) { break; } } startupBundleMap.put(symbolicName, b); } } } for (Bundle startupBundle : startupBundleMap.values()) { logger.log(Level.INFO, "Starting bundle: " + startupBundle); startupBundle.start(); } }
@SuppressWarnings("deprecation") public void testAllResolved() { assertNotNull("Expected a Bundle Context", context); StringBuilder sb = new StringBuilder(); for (Bundle b : context.getBundles()) { if (b.getState() == Bundle.INSTALLED && b.getHeaders().get(aQute.bnd.osgi.Constants.FRAGMENT_HOST) == null) { try { b.start(); } catch (BundleException e) { sb.append(b.getBundleId()) .append(" ") .append(b.getSymbolicName()) .append(";") .append(b.getVersion()) .append("\n"); sb.append(" ").append(e.getMessage()).append("\n\n"); System.err.println(e.getMessage()); } } } Matcher matcher = IP_P.matcher(sb); String out = matcher.replaceAll( "\n\n " + aQute.bnd.osgi.Constants.IMPORT_PACKAGE + ": $1;version=[$2,$3)\n"); assertTrue("Unresolved bundles\n" + out, sb.length() == 0); }
@Override public int complete(String buffer, int cursor, List<CharSequence> candidates) { Bundle[] bundles = bundleContext.getBundles(); List<Long> bundleIds = new ArrayList<Long>(); for (Bundle b : bundles) { if (matcher.bundleMatches(b)) { bundleIds.add(b.getBundleId()); } } SortedSet<String> variants = new TreeSet<String>(); if (buffer.matches("^[0-9]+$")) { for (Long l : bundleIds) { variants.add(String.valueOf(l)); } } else { for (Long l : bundleIds) { variants.add(bundleContext.getBundle(l).getSymbolicName()); } } if (buffer.isEmpty()) { candidates.addAll(variants); } else { for (String match : variants.tailSet(buffer)) { if (!match.startsWith(buffer)) { break; } candidates.add(match.substring(buffer.length())); } } return candidates.isEmpty() ? -1 : buffer.length(); }
@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"); }
@Before public void areWeReady() { assertNotNull(bc); boolean debugit = false; Bundle b[] = bc.getBundles(); for (Bundle element : b) { int state = element.getState(); if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) { log.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state)); debugit = true; } } if (debugit) { log.debug("Do some debugging because some bundle is " + "unresolved"); } // Assert if true, if false we are good to go! assertFalse(debugit); ServiceReference r = bc.getServiceReference(IForwardingRulesManager.class.getName()); if (r != null) { this.manager = (IForwardingRulesManager) bc.getService(r); } // If StatisticsManager is null, cannot run tests. assertNotNull(this.manager); }
/** * test the supplementer registry with a supplemented bundle * * @throws Exception */ public void testSupplementerRegistryWithCombinedSupplementer() throws Exception { Hashtable headers = new Hashtable(); headers.put("Eclipse-SupplementImporter", "test.import1"); headers.put("Eclipse-SupplementExporter", "test.export1"); headers.put("Eclipse-SupplementBundle", "symbolic-name-supplementedBundle1"); EasyMock.expect(bundle.getHeaders()).andStubReturn(headers); EasyMock.expect(bundle.getSymbolicName()).andStubReturn("supplementer"); EasyMock.expect(context.getBundles()).andReturn(new Bundle[] {bundle}); EasyMock.expect(supplementedBundle1.getHeaders()).andStubReturn(new Hashtable()); headers = new Hashtable(); headers.put("Export-Package", "test.export1"); EasyMock.expect(supplementedBundle2.getHeaders()).andStubReturn(headers); headers = new Hashtable(); headers.put("Import-Package", "test.import1"); EasyMock.expect(supplementedBundle3.getHeaders()).andStubReturn(headers); EasyMock.replay(mocks); registry.addBundle(bundle); registry.addBundle(supplementedBundle1); registry.addBundle(supplementedBundle2); registry.addBundle(supplementedBundle3); Supplementer[] supplementers = registry.getSupplementers(supplementedBundle1); assertSame(bundle, supplementers[0].getSupplementerBundle()); supplementers = registry.getSupplementers(supplementedBundle2); assertSame(bundle, supplementers[0].getSupplementerBundle()); supplementers = registry.getSupplementers(supplementedBundle3); assertSame(bundle, supplementers[0].getSupplementerBundle()); EasyMock.verify(mocks); }
public void startBundle(String bundleSymbolicName) throws BundleException { for (Bundle bundle : bundleCtx.getBundles()) { if (bundleSymbolicName.equals(bundle.getSymbolicName())) { bundle.start(); } } }
/** * Forcing the registry of the HttpService, usually need it when the felix framework is reloaded * and we need to update the bundle context of our already registered services. * * @param context */ private void forceHttpServiceLoading(BundleContext context) throws Exception { try { // Working with the http bridge if (OSGIProxyServlet.servletConfig != null) { // If it is null probably the servlet wasn't even been loaded... try { OSGIProxyServlet.bundleContext.getBundle(); } catch (IllegalStateException e) { Bundle[] bundles = context.getBundles(); for (Bundle bundle : bundles) { if (bundle.getSymbolicName().equals(OSGIUtil.BUNDLE_HTTP_BRIDGE_SYMBOLIC_NAME)) { // If we are here is because we have an invalid bundle context, so we need to provide // a new one BundleContext httpBundle = bundle.getBundleContext(); OSGIProxyServlet.tracker = new DispatcherTracker(httpBundle, null, OSGIProxyServlet.servletConfig); OSGIProxyServlet.tracker.open(); OSGIProxyServlet.bundleContext = httpBundle; } } } } } catch (Exception e) { Logger.error(this, "Error loading HttpService.", e); throw e; } }
protected void findBundlesWithFramentsToRefresh(Set<Bundle> toRefresh) { for (Bundle b : toRefresh) { if (b.getState() != Bundle.UNINSTALLED) { String hostHeader = (String) b.getHeaders().get(Constants.FRAGMENT_HOST); if (hostHeader != null) { Clause[] clauses = Parser.parseHeader(hostHeader); if (clauses != null && clauses.length > 0) { Clause path = clauses[0]; for (Bundle hostBundle : bundleContext.getBundles()) { if (hostBundle.getSymbolicName().equals(path.getName())) { String ver = path.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE); if (ver != null) { VersionRange v = VersionRange.parseVersionRange(ver); if (v.contains(hostBundle.getVersion())) { toRefresh.add(hostBundle); } } else { toRefresh.add(hostBundle); } } } } } } } }
@Test public void shouldSendEventWhenChannelWasDeleted() { Channel channel = new Channel("displayName", BUNDLE_SYMBOLIC_NAME, VERSION); when(channelsDataService.findByModuleName(channel.getModuleName())).thenReturn(channel); when(bundleContext.getBundles()).thenReturn(new Bundle[] {bundle}); when(bundle.getSymbolicName()).thenReturn(BUNDLE_SYMBOLIC_NAME); ArgumentCaptor<MotechEvent> captor = ArgumentCaptor.forClass(MotechEvent.class); Channel deletedChannel = new Channel("displayName2", BUNDLE_SYMBOLIC_NAME, VERSION); channelService.delete(deletedChannel.getModuleName()); ArgumentCaptor<TransactionCallback> transactionCaptor = ArgumentCaptor.forClass(TransactionCallback.class); verify(channelsDataService).doInTransaction(transactionCaptor.capture()); transactionCaptor.getValue().doInTransaction(null); verify(channelsDataService).delete(channel); verify(eventRelay).sendEventMessage(captor.capture()); MotechEvent event = captor.getValue(); assertEquals(CHANNEL_DEREGISTER_SUBJECT, event.getSubject()); assertEquals(BUNDLE_SYMBOLIC_NAME, event.getParameters().get(CHANNEL_MODULE_NAME)); }
/** * Process Provide-Capability headers and populate a counter which keep all the expected service * counts. Register timers to track the service availability as well as pending service * registrations. * * <p>If there are no RequireCapabilityListener instances then this method returns. * * @param bundleContext OSGi bundle context of the Carbon.core bundle * @throws Exception if the service component activation fails */ @Activate public void start(BundleContext bundleContext) throws Exception { try { logger.debug("Initialize - Startup Order Resolver."); // 1) Process OSGi manifest headers to calculate the expected list required capabilities. processManifestHeaders(Arrays.asList(bundleContext.getBundles()), supportedManifestHeaders); // 2) Check for any startup components with pending required capabilities. if (startupComponentManager.getPendingComponents().size() == 0) { // There are no registered RequiredCapabilityListener // Clear all the populated maps. startupComponentManager = null; osgiServiceTracker = null; return; } // 3) Register capability trackers to get notified when required capabilities are available. startCapabilityTrackers(); // 4) Schedule a time task to check for startup components with zero pending required // capabilities. scheduleCapabilityListenerTimer(); // 5) Start a timer to track pending capabilities, pending CapabilityProvider services, // pending RequiredCapabilityLister services. schedulePendingCapabilityTimerTask(); } catch (Throwable e) { logger.error("Error occurred in Startup Order Resolver.", e); } }
@Test public void testClientDeploymentAsArchive() throws Exception { String symbolicName = "archive-deployer-test-bundle"; Archive<?> archive = provider.getClientDeployment(symbolicName); String depname = archiveDeployer.deploy(archive); Bundle bundle = null; try { for (Bundle aux : context.getBundles()) { if (symbolicName.equals(aux.getSymbolicName())) { bundle = aux; break; } } // Assert that the bundle is there assertNotNull("Bundle found", bundle); // Start the bundle bundle.start(); OSGiTestHelper.assertBundleState(Bundle.ACTIVE, bundle.getState()); // Stop the bundle bundle.stop(); OSGiTestHelper.assertBundleState(Bundle.RESOLVED, bundle.getState()); } finally { archiveDeployer.undeploy(depname); // FIXME JBAS-9359 // OSGiTestHelper.assertBundleState(Bundle.UNINSTALLED, bundle.getState()); } }
/** {@inheritDoc}. */ @SuppressWarnings("unchecked") @Override public List<Map<String, Object>> getServices(String applicationID) { List<Map<String, Object>> services = configAdminExt.listServices(getDefaultFactoryLdapFilter(), getDefaultLdapFilter()); List<Map<String, Object>> returnValues = new ArrayList<Map<String, Object>>(); BundleContext context = getContext(); if (!services.isEmpty()) { Application app = appService.getApplication(applicationID); MetaTypeService metatypeService = getMetaTypeService(); if (app != null) { try { Set<BundleInfo> bundles = app.getBundles(); Set<String> bundleLocations = new HashSet<String>(); Set<MetaTypeInformation> metatypeInformation = new HashSet<MetaTypeInformation>(); for (BundleInfo info : bundles) { bundleLocations.add(info.getLocation()); } for (Bundle bundle : context.getBundles()) { for (BundleInfo info : bundles) { if (info.getLocation().equals(bundle.getLocation())) { metatypeInformation.add(metatypeService.getMetaTypeInformation(bundle)); } } } for (Map<String, Object> service : services) { if (service.containsKey("configurations")) { List<Map<String, Object>> configurations = (List<Map<String, Object>>) service.get("configurations"); for (Map<String, Object> item : configurations) { if (item.containsKey("bundle_location")) { String bundleLocation = (String) item.get("bundle_location"); if (bundleLocations.contains(bundleLocation)) { returnValues.add(service); break; } } } } else { if (checkForMetaTypesForService(metatypeInformation, service)) { returnValues.add(service); } } } } catch (ApplicationServiceException e) { LOGGER.warn("There was an error while trying to access the application", e); return new ArrayList<Map<String, Object>>(); } } } return returnValues; }
/* * (non-Javadoc) * * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext) */ public void start(BundleContext context) throws Exception { super.start(context); plugin = this; // create a new RobotDeviceListener Bundle[] bundles = context.getBundles(); // ("org.eclipse.equinox.event"); Bundle r_osgi = null; for (int i = 0; i < bundles.length; i++) { Bundle bundle = bundles[i]; System.out.println("Bundle.getSymbolicName(): " + bundle.getSymbolicName()); if ("org.eclipse.equinox.event".equals(bundle.getSymbolicName())) { bundle.start(); } else if ("org.eclipse.equinox.log".equals(bundle.getSymbolicName())) { bundle.start(); } else if ("ch.ethz.iks.r_osgi.remote".equals(bundle.getSymbolicName())) { r_osgi = bundle; } else if ("org.leibnix.device.clocktimer.interfaces".equals(bundle.getSymbolicName())) { bundle.start(); } } if (r_osgi != null) { r_osgi.start(); } // ServiceReference ref = context // .getServiceReference(RemoteOSGiService.class.getName()); // if (ref != null) { // remote = (RemoteOSGiService) context.getService(ref); // // DeviceListener listener = new DeviceListener(context, remote); // // // register for discovery // context.registerService(DiscoveryListener.class.getName(), // listener, null); // } // ServiceReference ref = context // .getServiceReference(RemoteOSGiService.class.getName()); // if (ref != null) { // RemoteOSGiService rs = (RemoteOSGiService) context.getService(ref); // ServiceURL[] serviceURLs = rs.connect(InetAddress.getLocalHost(), // 9278, null); // FIXME use remote host from preferences // // for (ServiceURL service : serviceURLs) { // ServiceType serviceType = service.getServiceType(); // // System.out.println(serviceType.getConcreteTypeName()); // if (serviceType.getConcreteTypeName().endsWith("ClockTimer")) { // rs.fetchService(service); // Object remoteService = rs.getFetchedService(service); // // if (remoteService instanceof IClockTimer) { // IClockTimer clock = (IClockTimer) remoteService; // clock.addTimer("1"); // // } // break; // } // } // } }
private Bundle getBundleForSymbolicName(String symbolicName) { for (Bundle b : bundleContext.getBundles()) { if (b.getSymbolicName().equals(symbolicName)) { return b; } } return null; }
@MsgbusMethod public void getBundles(Request req, Response resp) { List<Object> l = new ArrayList<Object>(); for (Bundle bundle : bc.getBundles()) { l.add(marshal(bundle)); } resp.put("bundles", l); }
private Bundle findBundle(String id) { Bundle[] bundles = context.getBundles(); for (Bundle b : bundles) { if (b.getSymbolicName().equals(id)) { return b; } } return null; }