Examples with Wiring org.osgi.resource.Wiring used on opensource projects

Example 1 with Wiring

use of org.osgi.resource.Wiring in project felix by apache.

the class PluginResolveContext method getWirings.

@Override
public Map<Resource, Wiring> getWirings() {
    Map<Resource, Wiring> wiringMap = new HashMap<>();
    Bundle[] bundles = this.bundleContext.getBundles();
    for (Bundle bundle : bundles) {
        // BundleRevision extends Resource
        BundleRevision revision = bundle.adapt(BundleRevision.class);
        // BundleWiring extends Wiring
        BundleWiring wiring = revision.getWiring();
        if (wiring != null) {
            wiringMap.put(revision, wiring);
        }
    }
    return wiringMap;
}

Example 2 with Wiring

use of org.osgi.resource.Wiring in project felix by apache.

the class StatefulResolver method resolve.

BundleRevision resolve(BundleRevision revision, String pkgName) throws ResolutionException, BundleException {
    BundleRevision provider = null;
    // acquired the global lock below.
    if ((revision.getWiring() != null) && isAllowedDynamicImport(revision, pkgName)) {
        // Acquire global lock.
        boolean locked = m_felix.acquireGlobalLock();
        if (!locked) {
            throw new ResolveException("Unable to acquire global lock for resolve.", revision, null);
        }
        // the case if a resolver hook does something bad.
        if (m_isResolving) {
            m_felix.releaseGlobalLock();
            throw new IllegalStateException("Nested resolve operations not allowed.");
        }
        m_isResolving = true;
        Map<Resource, List<Wire>> wireMap = null;
        try {
            // Double check to make sure that someone hasn't beaten us to
            // dynamically importing the package, which can happen if two
            // threads are racing to do so. If we have an existing wire,
            // then just return it instead.
            provider = ((BundleWiringImpl) revision.getWiring()).getImportedPackageSource(pkgName);
            if (provider == null) {
                // Prepare resolver hooks, if any.
                ResolverHookRecord record = prepareResolverHooks(Collections.singleton(revision), Collections.EMPTY_SET);
                // Select any singletons in the resolver state.
                selectSingletons(record);
                // Catch any resolve exception to rethrow later because
                // we may need to call end() on resolver hooks.
                ResolutionException rethrow = null;
                try {
                    List<BundleRequirement> dynamics = Util.getDynamicRequirements(revision.getWiring().getRequirements(null));
                    // Loop through the importer's dynamic requirements to determine if
                    // there is a matching one for the package from which we want to
                    // load a class.
                    Map<String, Object> attrs = Collections.singletonMap(BundleRevision.PACKAGE_NAMESPACE, (Object) pkgName);
                    BundleRequirementImpl req = new BundleRequirementImpl(revision, BundleRevision.PACKAGE_NAMESPACE, Collections.EMPTY_MAP, attrs);
                    final List<BundleCapability> candidates = findProvidersInternal(record, req, false, true);
                    // Try to find a dynamic requirement that matches the capabilities.
                    BundleRequirementImpl dynReq = null;
                    for (int dynIdx = 0; (candidates.size() > 0) && (dynReq == null) && (dynIdx < dynamics.size()); dynIdx++) {
                        for (Iterator<BundleCapability> itCand = candidates.iterator(); (dynReq == null) && itCand.hasNext(); ) {
                            Capability cap = itCand.next();
                            if (CapabilitySet.matches(cap, ((BundleRequirementImpl) dynamics.get(dynIdx)).getFilter())) {
                                dynReq = (BundleRequirementImpl) dynamics.get(dynIdx);
                            }
                        }
                    }
                    // any candidates that do not match it.
                    if (dynReq != null) {
                        for (Iterator<BundleCapability> itCand = candidates.iterator(); itCand.hasNext(); ) {
                            Capability cap = itCand.next();
                            if (!CapabilitySet.matches(cap, dynReq.getFilter())) {
                                itCand.remove();
                            }
                        }
                    } else {
                        candidates.clear();
                    }
                    Map<Resource, Wiring> wirings = getWirings();
                    wireMap = wirings.containsKey(revision) ? m_resolver.resolveDynamic(new ResolveContextImpl(this, wirings, record, Collections.<BundleRevision>emptyList(), Collections.<BundleRevision>emptyList(), getFragments()) {

                        @Override
                        public List<Capability> findProviders(Requirement br) {
                            return (List) candidates;
                        }
                    }, revision.getWiring(), dynReq) : Collections.<Resource, List<Wire>>emptyMap();
                } catch (ResolutionException ex) {
                    rethrow = ex;
                }
                // Release resolver hooks, if any.
                releaseResolverHooks(record);
                // If the resolve failed, rethrow the exception.
                if (rethrow != null) {
                    throw rethrow;
                }
                if ((wireMap != null) && wireMap.containsKey(revision)) {
                    List<Wire> dynamicWires = wireMap.remove(revision);
                    Wire dynamicWire = dynamicWires.get(0);
                    // Mark all revisions as resolved.
                    markResolvedRevisions(wireMap);
                    // Dynamically add new wire to importing revision.
                    if (dynamicWire != null) {
                        // TODO can we optimize this?
                        if (dynamicWire.getRequirer() instanceof BundleRevision && dynamicWire.getRequirement() instanceof BundleRequirement && dynamicWire.getProvider() instanceof BundleRevision && dynamicWire.getCapability() instanceof BundleCapability) {
                            BundleRevision dwRequirer = (BundleRevision) dynamicWire.getRequirer();
                            BundleRequirement dwRequirement = (BundleRequirement) dynamicWire.getRequirement();
                            BundleRevision dwProvider = (BundleRevision) dynamicWire.getProvider();
                            BundleCapability dwCapability = (BundleCapability) dynamicWire.getCapability();
                            BundleWire bw = new BundleWireImpl(dwRequirer, dwRequirement, dwProvider, dwCapability);
                            m_felix.getDependencies().addDependent(bw);
                            ((BundleWiringImpl) revision.getWiring()).addDynamicWire(bw);
                            m_felix.getLogger().log(Logger.LOG_DEBUG, "DYNAMIC WIRE: " + dynamicWire);
                            provider = ((BundleWiringImpl) revision.getWiring()).getImportedPackageSource(pkgName);
                        }
                    }
                }
            }
        } finally {
            // Clear resolving flag.
            m_isResolving = false;
            // Always release the global lock.
            m_felix.releaseGlobalLock();
        }
        fireResolvedEvents(wireMap);
    }
    return provider;
}

Example 3 with Wiring

use of org.osgi.resource.Wiring in project felix by apache.

the class ResolverTest method testScenario6.

@Test
public void testScenario6() throws Exception {
    Resolver resolver = new ResolverImpl(new Logger(Logger.LOG_DEBUG));
    Map<Resource, Wiring> wirings = new HashMap<Resource, Wiring>();
    Map<Requirement, List<Capability>> candMap = new HashMap<Requirement, List<Capability>>();
    List<Resource> mandatory = populateScenario6(wirings, candMap);
    ResolveContextImpl rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.<Resource>emptyList());
    Map<Resource, List<Wire>> wireMap = resolver.resolve(rci);
    int aResources = 0;
    for (Resource r : wireMap.keySet()) {
        if ("A".equals(getResourceName(r))) {
            aResources++;
            List<Wire> wires = wireMap.get(r);
            assertEquals(4, wires.size());
            List<String> providers = new ArrayList<String>();
            for (Wire w : wires) {
                providers.add(getResourceName(w.getProvider()));
            }
            Collections.sort(providers);
            assertEquals(Arrays.asList("B", "C", "D", "D"), providers);
        }
    }
    assertEquals("Should have found two resolved resources named 'A'", 2, aResources);
}

Example 4 with Wiring

use of org.osgi.resource.Wiring in project felix by apache.

the class ResolverTest method populateScenario17.

private ResolveContext populateScenario17(boolean realSubstitute, boolean felixResolveContext, boolean existingWirings) {
    Map<Requirement, List<Capability>> candMap = new HashMap<Requirement, List<Capability>>();
    ResourceImpl core = new ResourceImpl("core");
    Capability core_pkgCap = addCap(core, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    Capability core_bundleCap = addCap(core, BundleNamespace.BUNDLE_NAMESPACE, "core");
    Requirement core_pkgReq = addReq(core, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    ResourceImpl misc = new ResourceImpl("misc");
    Capability misc_pkgCap = addCap(misc, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    Capability misc_bundleCap = addCap(misc, BundleNamespace.BUNDLE_NAMESPACE, "misc");
    Requirement misc_bundleReq = addReq(misc, BundleNamespace.BUNDLE_NAMESPACE, "core");
    ResourceImpl importsCore = new ResourceImpl("importsCore");
    Capability importsCore_pkgCap = addCap(importsCore, PackageNamespace.PACKAGE_NAMESPACE, "pkg2", "pkg1");
    Requirement importsCore_pkgReq = addReq(importsCore, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    ResourceImpl requiresMisc = new ResourceImpl("requiresMisc");
    Requirement requiresMisc_pkgReq = addReq(requiresMisc, PackageNamespace.PACKAGE_NAMESPACE, "pkg2");
    Requirement requiresMisc_bundleReq = addReq(requiresMisc, BundleNamespace.BUNDLE_NAMESPACE, "misc");
    ResourceImpl substitutesCore = new ResourceImpl("substitutesCore");
    Capability substitutesCore_pkgCap = addCap(substitutesCore, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    candMap.put(core_pkgReq, Collections.singletonList(realSubstitute ? substitutesCore_pkgCap : core_pkgCap));
    candMap.put(misc_bundleReq, Collections.singletonList(core_bundleCap));
    candMap.put(importsCore_pkgReq, Collections.singletonList(realSubstitute ? substitutesCore_pkgCap : core_pkgCap));
    candMap.put(requiresMisc_pkgReq, Collections.singletonList(importsCore_pkgCap));
    candMap.put(requiresMisc_bundleReq, Collections.singletonList(misc_bundleCap));
    Map<Resource, List<Wire>> wires = new HashMap<Resource, List<Wire>>();
    wires.put(substitutesCore, new ArrayList<Wire>());
    wires.put(core, new ArrayList<Wire>());
    if (realSubstitute) {
        wires.get(core).add(new SimpleWire(core_pkgReq, substitutesCore_pkgCap));
    }
    wires.put(misc, new ArrayList<Wire>());
    wires.get(misc).add(new SimpleWire(misc_bundleReq, core_bundleCap));
    Wiring coreWiring = null;
    Map<Resource, Wiring> wirings = new HashMap<Resource, Wiring>();
    if (existingWirings) {
        Map<Resource, List<Wire>> invertedWires = new HashMap<Resource, List<Wire>>();
        invertedWires.put(substitutesCore, new ArrayList<Wire>());
        if (realSubstitute) {
            invertedWires.get(substitutesCore).add(new SimpleWire(core_pkgReq, substitutesCore_pkgCap));
        }
        invertedWires.put(core, new ArrayList<Wire>());
        invertedWires.get(core).add(new SimpleWire(misc_bundleReq, core_bundleCap));
        invertedWires.put(misc, new ArrayList<Wire>());
        wirings.put(substitutesCore, new SimpleWiring(substitutesCore, Arrays.asList(substitutesCore_pkgCap), wires, invertedWires));
        coreWiring = new SimpleWiring(core, Arrays.asList(core_bundleCap, core_pkgCap), wires, invertedWires);
        wirings.put(core, coreWiring);
        wirings.put(misc, new SimpleWiring(misc, Arrays.asList(misc_bundleCap, misc_pkgCap), wires, invertedWires));
    }
    Collection<Resource> mandatory = Collections.<Resource>singletonList(requiresMisc);
    if (felixResolveContext) {
        Map<Wiring, Collection<Wire>> substitutions = new HashMap<Wiring, Collection<Wire>>();
        if (realSubstitute && coreWiring != null) {
            substitutions.put(coreWiring, Arrays.<Wire>asList(new SimpleWire(core_pkgReq, substitutesCore_pkgCap)));
        }
        return new ResolveContextImpl.FelixResolveContextImpl(wirings, candMap, mandatory, Collections.<Resource>emptyList(), substitutions);
    } else {
        return new ResolveContextImpl(wirings, candMap, mandatory, Collections.<Resource>emptyList());
    }
}

Example 5 with Wiring

use of org.osgi.resource.Wiring in project felix by apache.

the class ResolverTest method testScenario9.

@Test
public void testScenario9() throws Exception {
    Resolver resolver = new ResolverImpl(new Logger(Logger.LOG_DEBUG), 1);
    Map<Resource, Wiring> wirings = new HashMap<Resource, Wiring>();
    Map<Requirement, List<Capability>> candMap = new HashMap<Requirement, List<Capability>>();
    List<Resource> mandatory = populateScenario9(wirings, candMap);
    ResolveContextImpl rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.<Resource>emptyList());
    Map<Resource, List<Wire>> wireMap = resolver.resolve(rci);
    Resource resB = findResource("B", wireMap.keySet());
    Resource resA = findResource("A", wirings.keySet());
    Resource resC1 = findResource("C1", wirings.keySet());
    assertNotNull(resB);
    assertNotNull(resC1);
    assertEquals(1, wireMap.size());
    List<Wire> wiresB = wireMap.get(resB);
    assertEquals(2, wiresB.size());
    // should be wired to A and C1
    assertEquals(resA, wiresB.get(0).getProvider());
    assertEquals(resC1, wiresB.get(1).getProvider());
}