private void loadProvider(final BundleContext bundleContext, final BundleWiring bundleWiring) { final String filter = "(APIVersion>=2.6.0)"; try { final Collection<ServiceReference<Provider>> serviceReferences = bundleContext.getServiceReferences(Provider.class, filter); Provider maxProvider = null; for (final ServiceReference<Provider> serviceReference : serviceReferences) { final Provider provider = bundleContext.getService(serviceReference); if (maxProvider == null || provider.getPriority() > maxProvider.getPriority()) { maxProvider = provider; } } if (maxProvider != null) { ProviderUtil.addProvider(maxProvider); } } catch (final InvalidSyntaxException ex) { LOGGER.error("Invalid service filter: " + filter, ex); } final List<URL> urls = bundleWiring.findEntries("META-INF", "log4j-provider.properties", 0); for (final URL url : urls) { ProviderUtil.loadProvider(url, bundleWiring.getClassLoader()); } }
@Override public void start(final BundleContext bundleContext) throws Exception { ProviderUtil.STARTUP_LOCK.lock(); lockingProviderUtil = true; final BundleWiring self = bundleContext.getBundle().adapt(BundleWiring.class); final List<BundleWire> required = self.getRequiredWires(LoggerContextFactory.class.getName()); for (final BundleWire wire : required) { loadProvider(bundleContext, wire.getProviderWiring()); } bundleContext.addBundleListener(this); final Bundle[] bundles = bundleContext.getBundles(); for (final Bundle bundle : bundles) { loadProvider(bundle); } unlockIfReady(); }
/** * Caches the package capabilities that are needed for a set of interface classes * * @param classes interfaces we want to track */ private void cachePackageCapabilities(Class<?> ... classes) { BundleWiring ourWiring = bundleContext.getBundle().adapt(BundleWiring.class); Set<String> packageNames = new HashSet<String>(); for (Class<?> clazz: classes) { packageNames.add(clazz.getPackage().getName()); } List<BundleCapability> ourExports = ourWiring.getCapabilities(PACKAGE_NAMESPACE); for (BundleCapability ourExport : ourExports) { String ourPkgName = (String) ourExport.getAttributes().get(PACKAGE_NAMESPACE); if (packageNames.contains(ourPkgName)) { packageCapabilities.add(ourExport); } } }
public ShimBridgingClassloader( ClassLoader parentClassLoader, BundleContext bundleContext ) { super( parentClassLoader ); this.bundleWiring = (BundleWiring) bundleContext.getBundle().adapt( BundleWiring.class ); this.bundleWiringClassloader = new PublicLoadResolveClassLoader( bundleWiring.getClassLoader() ); }
private static LinkedHashSet<Bundle> getWiredBundles43(Bundle bundle) { LinkedHashSet<Bundle> wiredBundles = new LinkedHashSet<Bundle>(); BundleWiring wiring = bundle.adapt(BundleWiring.class); if (wiring != null) { List<BundleWire> wires; wires = wiring.getRequiredWires(BundleRevision.PACKAGE_NAMESPACE); for (BundleWire wire : wires) { wiredBundles.add(wire.getProviderWiring().getBundle()); } wires = wiring.getRequiredWires(BundleRevision.BUNDLE_NAMESPACE); for (BundleWire wire : wires) { wiredBundles.add(wire.getProviderWiring().getBundle()); } } return wiredBundles; }
public WrappingTransformer(ClassTransformer delegate, ServiceReference<?> persistenceProvider) { validate(delegate, persistenceProvider); this.delegate = delegate; Object packages = persistenceProvider.getProperty("org.apache.aries.jpa.container.weaving.packages"); if (packages instanceof String[]) { for (String s : (String[])packages) { packageImportsToAdd.add(s); } } else { Bundle provider = persistenceProvider.getBundle(); String suffix = ";" + Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE + "=" + provider.getSymbolicName() + ";" + Constants.BUNDLE_VERSION_ATTRIBUTE + "=" + provider.getVersion(); BundleRevision br = provider.adapt(BundleWiring.class).getRevision(); for (BundleCapability bc : br.getDeclaredCapabilities(BundleRevision.PACKAGE_NAMESPACE)) { packageImportsToAdd.add(bc.getAttributes().get(BundleRevision.PACKAGE_NAMESPACE) + suffix); } } }
private boolean canBeSatisfied(BundleRequirement req) { Bundle[] bundles = bundleContext.getBundles(); for (Bundle bundle : bundles) { BundleWiring wiring = bundle.adapt(BundleWiring.class); if (wiring != null) { List<BundleCapability> caps = wiring.getCapabilities(null); for (BundleCapability cap : caps) { if (req.matches(cap)) { return true; } } } } return false; }
public Map<String, Bundle> getWiredBundles(Bundle bundle) { // the set of bundles from which the bundle imports packages Map<String, Bundle> exporters = new HashMap<>(); for (BundleRevision revision : bundle.adapt(BundleRevisions.class).getRevisions()) { BundleWiring wiring = revision.getWiring(); if (wiring != null) { List<BundleWire> wires = wiring.getRequiredWires(BundleRevision.PACKAGE_NAMESPACE); if (wires != null) { for (BundleWire wire : wires) { if (wire.getProviderWiring().getBundle().getBundleId() != 0) { exporters.put(wire.getCapability().getAttributes().get(BundleRevision.PACKAGE_NAMESPACE).toString(), wire.getProviderWiring().getBundle()); } } } } } return exporters; }
public static void testAllServicesAreAvailable() { Set<String> osgiAvailableClasses = stream(spliterator(OsgiServiceLoader.load(ServiceFactory.class).iterator(), Long.MAX_VALUE, 0), false) .map(f -> f.getClass().getName()) .collect(toSet()); Set<String> jdkAvailableClasses = of(EhcacheActivator.getCoreBundle().getBundles()) .map(b -> b.adapt(BundleWiring.class).getClassLoader()) .flatMap(cl -> stream(spliterator(ServiceLoader.load(ServiceFactory.class, cl).iterator(), Long.MAX_VALUE, 0), false) .map(f -> f.getClass().getName())) .collect(toSet()); assertThat(osgiAvailableClasses, hasItems(jdkAvailableClasses.toArray(new String[0]))); }
private BundleWiringDTO getBundleWiringDTO(BundleWiring wiring) { if (wiring == null) { return null; } BundleWiringDTO dto = new BundleWiringDTO(); dto.bundle = wiring.getBundle().getBundleId(); dto.root = getWiringId(wiring); dto.nodes = new HashSet<>(wiringnodes.values()); dto.resources = new HashSet<>(resources.values()); return dto; }
protected void findResource() { Bundle[] bundles = bundleContext.getBundles(); String filter = "*" + className + "*"; for (Bundle bundle : bundles) { BundleWiring wiring = (BundleWiring) bundle.adapt(BundleWiring.class); if (wiring != null) { Collection<String> resources = wiring.listResources("/", filter, BundleWiring.LISTRESOURCES_RECURSE); if (resources.size() > 0) { System.out.println("\n" + Util.getBundleName(bundle)); } for (String resource:resources) { System.out.println(resource); } } else { System.out.println("Bundle " + bundle.getBundleId() + " is not resolved."); } } }
private String getHeaderFromBundleOrFragment(Bundle bundle, String headerName, String matchString) { String val = bundle.getHeaders().get(headerName); if (matches(val, matchString)) return val; BundleRevision rev = bundle.adapt(BundleRevision.class); if (rev != null) { BundleWiring wiring = rev.getWiring(); if (wiring != null) { for (BundleWire wire : wiring.getProvidedWires("osgi.wiring.host")) { Bundle fragment = wire.getRequirement().getRevision().getBundle(); val = fragment.getHeaders().get(headerName); if (matches(val, matchString)) { return val; } } } } return null; }
Collection<BundleCapability> identities = bundleContext.getBundle(Constants.SYSTEM_BUNDLE_LOCATION) .adapt(FrameworkWiring.class).findProviders(req); Collection<BundleWiring> result = new ArrayList<BundleWiring>(1); // normally BundleRevision revision = identity.getRevision(); BundleWiring wiring = revision.getWiring(); if (wiring != null) { if ((revision.getTypes() & BundleRevision.TYPE_FRAGMENT) != 0) { wiring = wiring.getRequiredWires(HostNamespace.HOST_NAMESPACE).get(0).getProviderWiring();
private static boolean isExtension(Bundle candidate) { if (candidate.getSymbolicName().equals("org.ops4j.pax.cdi.extension")) { return true; } List<BundleWire> wires = candidate.adapt(BundleWiring.class).getProvidedWires( Constants.CDI_EXTENSION_CAPABILITY); return !wires.isEmpty(); } }
public static List<URL> findResources(Iterable<Bundle> bundles, String path, String pattern, boolean recurse) { List<URL> resources = new ArrayList<>(); for (Bundle bundle : bundles) { Collection<String> names = bundle .adapt(BundleWiring.class) .listResources( path, pattern, BundleWiring.LISTRESOURCES_LOCAL | (recurse ? BundleWiring.LISTRESOURCES_RECURSE : 0)); for (String name : names) { resources.add(bundle.getResource(name)); } } return resources; }
BundleWires(Bundle bundle) { this.bundleId = bundle.getBundleId(); for (BundleWire wire : bundle.adapt(BundleWiring.class).getRequiredWires(null)) { String requirementId = getRequirementId(wire.getRequirement()); String capabilityId = getCapabilityId(wire.getCapability()); this.wiring.put(requirementId, capabilityId); } }
protected void printResources(Bundle bundle) { BundleWiring wiring = (BundleWiring) bundle.adapt(BundleWiring.class); if (wiring != null) { Collection<String> resources = null; if (displayAllFiles) { resources = wiring.listResources("/", null, BundleWiring.LISTRESOURCES_RECURSE); } else { resources = wiring.listResources("/", "*class", BundleWiring.LISTRESOURCES_RECURSE); } if (resources.size() > 0) { System.out.println("\n" + Util.getBundleName(bundle)); } for (String resource : resources) { System.out.println(resource); } } else { System.out.println("Bundle " + bundle.getBundleId() + " is not resolved"); } }
public ModuleApplicationContextRegistrator( Bundle extendeeBundle, Bundle extenderBundle, ServiceConfigurator serviceConfigurator) { _extendeeBundle = extendeeBundle; _extenderBundle = extenderBundle; _serviceConfigurator = serviceConfigurator; BundleWiring bundleWiring = _extendeeBundle.adapt(BundleWiring.class); _extendeeClassLoader = bundleWiring.getClassLoader(); }
public static void ensureAllClassesLoaded(Bundle bundle) throws ClassNotFoundException { BundleWiring wiring = bundle.adapt(BundleWiring.class); if (wiring != null) { for (String path : wiring.listResources("/", "*.class", BundleWiring.LISTRESOURCES_RECURSE)) { String className = path.substring(0, path.length() - ".class".length()); className = className.replace('/', '.'); bundle.loadClass(className); } } }
private static BundleWiringDTO createBundleWiringDTO(BundleWiring wiring) { BundleWiringDTO dto = new BundleWiringDTO(); dto.bundle = wiring.getBundle().getBundleId(); dto.root = getWiringID(wiring); dto.nodes = new HashSet<BundleWiringDTO.NodeDTO>(); dto.resources = new HashSet<BundleRevisionDTO>(); createBundleRevisionDTO(wiring.getRevision(), dto.resources); createBundleWiringNodeDTO(wiring, dto.resources, dto.nodes); return dto; }