Refine search
private BundleRevisionDTO getBundleRevisionDTO(BundleRevision revision) { if (revision == null) { return null; } BundleRevisionDTO dto = resources.get(revision); if (dto != null) { return dto; } dto = new BundleRevisionDTO(); dto.id = identifier(revision); resources.put(revision, dto); dto.bundle = revision.getBundle().getBundleId(); dto.symbolicName = revision.getSymbolicName(); dto.type = revision.getTypes(); dto.version = revision.getVersion().toString(); dto.capabilities = getListCapabilityDTO(revision.getDeclaredCapabilities(null)); dto.requirements = getListRequirementDTO(revision.getDeclaredRequirements(null)); return dto; }
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 Bundle[] getImportingBundles() { // Create set for storing importing bundles. Set<Bundle> result = new HashSet<Bundle>(); // Get all importers and requirers for all revisions of the bundle. // The spec says that require-bundle should be returned with importers. for (BundleWire wire : m_export.getRevision().getWiring().getProvidedWires(null)) { if (wire.getCapability() == m_export || BundleNamespace.BUNDLE_NAMESPACE.equals(wire.getCapability().getNamespace())) { result.add( wire.getRequirer().getBundle() ); } } // Return the results. return result.toArray(new Bundle[result.size()]); }
private boolean isFragment(Bundle bundle) { BundleRevision bundleRevision = bundle.adapt(BundleRevision.class); if (bundleRevision == null) throw new NullPointerException("Null bundle revision means that bundle has probably been uninstalled: " + bundle.getSymbolicName() + ":" + bundle.getVersion()); return (bundleRevision.getTypes() & BundleRevision.TYPE_FRAGMENT) != 0; }
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); } } }
static public String constructPlatformURI(Bundle bundle) { BundleRevision bundleRevision = bundle.adapt(BundleRevision.class); if (bundleRevision == null) return null; StringBuffer tmp = new StringBuffer(); tmp.append(PLATFORM_SCHEMA); if ((bundleRevision.getTypes() & BundleRevision.TYPE_FRAGMENT) == BundleRevision.TYPE_FRAGMENT) tmp.append(FRAGMENT_SEGMENT); else tmp.append(PLUGIN_SEGMENT); tmp.append(bundle.getSymbolicName()); return tmp.toString(); }
for (int i = 0; (bundles != null) && (i < bundles.length); i++) String sym = bundles[i].getSymbolicName(); if ((sym != null) && sym.equals(symbolicName)) Version v = bundles[i].adapt(BundleRevision.class).getVersion(); if ((vr == null) || vr.includes(v))
@Override public List<PackageRequirement> getImports() { Bundle[] bundles = bundleContext.getBundles(); SortedMap<String, PackageRequirement> requirements = new TreeMap<>(); for (Bundle bundle : bundles) { BundleRevision rev = bundle.adapt(BundleRevision.class); if (rev != null) { List<BundleRequirement> reqs = rev.getDeclaredRequirements(BundleRevision.PACKAGE_NAMESPACE); for (BundleRequirement req : reqs) { PackageRequirement preq = create(req, bundle); requirements.put(preq.getPackageName() + "|" + preq.getFilter() + "|" + preq.getBundle().getBundleId(), preq); } } } return new ArrayList<>(requirements.values()); }
private String getCapabilityId(BundleCapability capability) { StringBuilder sb = new StringBuilder(64); sb.append(capability.getRevision().getBundle().getBundleId()); Object v = capability.getAttributes().get(Constants.VERSION_ATTRIBUTE); if (v != null) { sb.append("; version=").append(v.toString()); } return sb.toString(); } }
private boolean isBundleLazyActivationPolicyUsed(BundleContext context) { if (context.getBundle().adapt(BundleStartLevel.class).isActivationPolicyUsed()) { // checking for lazy capability; NOTE this is equinox specific // but we fall back to header lookup for other frameworks List<BundleCapability> moduleData = context.getBundle().adapt(BundleRevision.class).getDeclaredCapabilities("equinox.module.data"); //$NON-NLS-1$ String activationPolicy = null; if (moduleData.isEmpty()) { activationPolicy = context.getBundle().getHeaders("").get(Constants.BUNDLE_ACTIVATIONPOLICY); //$NON-NLS-1$ } else { activationPolicy = (String) moduleData.get(0).getAttributes().get("activation.policy"); //$NON-NLS-1$ } return activationPolicy == null ? false : activationPolicy.startsWith(Constants.ACTIVATION_LAZY); } return false; }
private boolean checkRemove(String cap, BundleCapability cand) { return cap != null && !cap.equals(getCapabilityId(cand)) || cap == null && cand.getRevision().getBundle().getBundleId() != this.bundleId; }
private long getBundleId(BundleRequirement requirement) { long sourceId = requirement.getRevision().getBundle().getBundleId(); if (isFragment(requirement.getRevision()) && !requirement.getNamespace().equals(HostNamespace.HOST_NAMESPACE) && !requirement.getNamespace().equals(ExecutionEnvironmentNamespace.EXECUTION_ENVIRONMENT_NAMESPACE)) { sourceId = wiring.get(sourceId).getFragmentHost(); } return sourceId; }
private List<String> getExports(Bundle bundle) throws Exception { List<String> exports = new ArrayList<>(); BundleRevision rev = bundle.adapt(BundleRevision.class); List<BundleCapability> caps = rev.getDeclaredCapabilities(BundleRevision.PACKAGE_NAMESPACE); for (BundleCapability cap : caps) { Map<String, Object> attr = cap.getAttributes(); String packageName = (String)attr.get(BundleRevision.PACKAGE_NAMESPACE); exports.add(packageName); } return exports; }
for (BundleRevision revision : bundle.adapt(BundleRevisions.class).getRevisions()) if (revision.getWiring() != null) List<BundleWire> hostWires = revision.getWiring().getRequiredWires(null); for (int i = 0; (hostWires != null) && (i < hostWires.size()); i++) if (wire.getCapability().getNamespace().equals(BundleRevision.HOST_NAMESPACE)) Bundle b = wire.getProviderWiring().getBundle(); if (b != null)
List<BundleRevision> revisions = bundle.adapt(BundleRevisions.class).getRevisions(); for (BundleRevision revision : revisions) BundleWiring wiring = revision.getWiring(); if (wiring != null) for (BundleWire bw : wiring.getRequiredWires(null)) if (HostNamespace.HOST_NAMESPACE.equals(bw.getCapability().getNamespace())) result.add(bw.getProvider().getBundle()); result.add(dependentWire.getRequirer().getBundle());
public Bundle[] getRequiringBundles() { Set<Bundle> set = new HashSet<Bundle>(); for (BundleWire wire : m_bundle.adapt(BundleWiring.class).getProvidedWires(null)) { if (BundleNamespace.BUNDLE_NAMESPACE.equals(wire.getCapability().getNamespace())) { set.add(wire.getRequirer().getBundle()); } } return set.toArray(new Bundle[set.size()]); }
private void printDuplicatePackages(Tree<Bundle> tree) { Set<Bundle> bundles = tree.flatten(); Map<String, Set<Bundle>> exports = new HashMap<>(); for (Bundle bundle : bundles) { for (BundleRevision revision : bundle.adapt(BundleRevisions.class).getRevisions()) { BundleWiring wiring = revision.getWiring(); if (wiring != null) { List<BundleWire> wires = wiring.getProvidedWires(BundleRevision.PACKAGE_NAMESPACE); if (wires != null) { for (BundleWire wire : wires) { String name = wire.getCapability().getAttributes().get(BundleRevision.PACKAGE_NAMESPACE).toString(); exports.computeIfAbsent(name, k -> new HashSet<>()).add(bundle); } } } } } for(Map.Entry<String, Set<Bundle>> entry : exports.entrySet()) { Set<Bundle> bundlesExportingPkg = entry.getValue(); if(bundlesExportingPkg.size() > 1) { System.out.printf("%n"); System.out.printf("WARNING: multiple bundles are exporting package %s%n", entry.getKey()); for (Bundle bundle : bundlesExportingPkg) { System.out.printf("- %s%n", bundle); } } } }
.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();
for (BundleRevision br : bundle.adapt(BundleRevisions.class).getRevisions()) List<BundleCapability> caps = (br.getWiring() == null) ? br.getDeclaredCapabilities(null) : br.getWiring().getCapabilities(null); if ((caps != null) && (caps.size() > 0)) if (cap.getNamespace().equals(BundleRevision.PACKAGE_NAMESPACE)) cap.getAttributes().get(BundleRevision.PACKAGE_NAMESPACE); list.add(new ExportedPackageImpl( this, (BundleImpl) bundle, br, cap));