Refine search
public static String getType(Resource resource) { List<Capability> caps = resource.getCapabilities(null); for (Capability cap : caps) { if (cap.getNamespace().equals(IDENTITY_NAMESPACE)) { return cap.getAttributes().get(CAPABILITY_TYPE_ATTRIBUTE).toString(); } } return null; }
static Requirement getSubsystemRequirement(Resource resource) { for (Requirement requirement : resource.getRequirements(null)) { if (IDENTITY_NAMESPACE.equals(requirement.getNamespace()) && TYPE_SUBSYSTEM.equals(requirement.getAttributes().get(CAPABILITY_TYPE_ATTRIBUTE))) { return requirement; } } return null; }
@Override public int hashCode() { int hash = 5; hash = 29 * hash + (this.m_requirer != null ? this.m_requirer.hashCode() : 0); hash = 29 * hash + (this.m_req != null ? this.m_req.hashCode() : 0); hash = 29 * hash + (this.m_provider != null ? this.m_provider.hashCode() : 0); hash = 29 * hash + (this.m_cap != null ? this.m_cap.hashCode() : 0); return hash; } }
private static Object toJson(Resource resource) { Map<String, Object> obj = new HashMap<>(); List<Object> caps = new ArrayList<>(); List<Object> reqs = new ArrayList<>(); for (Capability cap : resource.getCapabilities(null)) { caps.add(ResourceUtils.toString(null, cap.getNamespace(), cap.getAttributes(), cap.getDirectives())); } for (Requirement req : resource.getRequirements(null)) { reqs.add(ResourceUtils.toString(null, req.getNamespace(), req.getAttributes(), req.getDirectives())); } obj.put("capabilities", caps); obj.put("requirements", reqs); return obj; }
List<Capability> caps = (wiring != null) ? wiring.getResourceCapabilities(null) : resource.getCapabilities(null); for (Capability cap : caps) if (cap.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) if (!cap.getResource().equals(resource)) (String) cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE), new Blame(cap, null)); Capability cap = wire.getCapability(); if (!cap.getResource().equals(wire.getProvider())) cap = new WrappedCapability(wire.getProvider(), cap); for (Requirement req : resource.getRequirements(null)) if (req.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE))
@Override public boolean equals(Object obj) { if (obj == this) return true; if (obj instanceof Wire) { Wire w = (Wire) obj; if (capability.equals(w.getCapability()) && requirement.equals(w.getRequirement())) { Resource provider = getProvider(); Resource requirer = getRequirer(); return (provider == null ? w.getProvider() == null : provider.equals(w.getProvider())) && (requirer == null ? w.getRequirer() == null : requirer.equals(w.getRequirer())); } } return false; }
for (Capability cap : wiring.getResource().getCapabilities(null)) if (cap.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) (String) cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE)); for (Capability cap : wire.getRequirement().getResource().getCapabilities(null)) if (cap.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) exportNames.add((String) cap.getAttributes().get( for (Wire wire : wiring.getRequiredResourceWires(null)) if (wire.getCapability().getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) if (exportNames.contains(wire.getCapability().getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE)))
public List<Capability> findProvider(Requirement requirement) { String namespace = requirement.getNamespace(); return resources.stream() .flatMap(resource -> resource.getCapabilities(namespace) .stream()) .filter(capability -> { if (!requirement.getNamespace() .equals(capability.getNamespace())) return false; if (!ResourceUtils.isEffective(requirement, capability)) return false; String filter = requirement.getDirectives() .get(Namespace.REQUIREMENT_FILTER_DIRECTIVE); if (filter == null) return true; try { Filter f = cache.computeIfAbsent(filter, (k) -> new Filter(k)); return f.matchMap(capability.getAttributes()); } catch (Exception e) { return false; } }) .collect(toCapabilities()); }
private static Resource findResolvedProvider(Wire wire, Set<Resource> resources, AbstractResolveContext rc) { // Make sure not to add new resources into the result. The resolver // already created the closure of all the needed resources. We need to // find the key in the result that already provides the capability // defined by this wire. Capability capability = wire.getCapability(); Resource resource = capability.getResource(); if (rc.isSystemResource(resource) || (ResourceUtils.isFragment(resource) && resources.contains(resource))) { return resource; } for (Resource resolved : resources) { for (Capability resolvedCap : resolved.getCapabilities(capability.getNamespace())) { if (ResourceUtils.matches(wire.getRequirement(), resolvedCap)) { return resolved; } } } // It shouldn't be possible to arrive here! throw new IllegalStateException( Strings.format("The capability for wire %s was not associated with a resource in the resolution", wire)); }
public ResourceBuilder(Resource source) throws Exception { addCapabilities(source.getCapabilities(null)); addRequirements(source.getRequirements(null)); }
public void copyCapabilities(Set<String> ignoreNamespaces, Resource r) throws Exception { for (Capability c : r.getCapabilities(null)) { if (ignoreNamespaces.contains(c.getNamespace())) continue; addCapability(c); } }
@SuppressWarnings("unchecked") private static <T extends Resource> Set<T> collectDependencies(T resource, CapabilitySet capSet) { Set<T> result = new LinkedHashSet<>(); for (Requirement requirement : resource.getRequirements(null)) { String filter = requirement.getDirectives().get(Constants.FILTER_DIRECTIVE); SimpleFilter sf = (filter != null) ? SimpleFilter.parse(filter) : SimpleFilter.MATCH_ALL_FILTER; for (Capability cap : capSet.match(sf, true)) { result.add((T) cap.getResource()); } } return result; }
/** * Returns a mapping for resources that match given filter, to a subsystem that represents region or scoped feature. * @param resourceFilter * @return map from resource to region name */ private Map<Resource, String> getResourceMapping(SimpleFilter resourceFilter) { Map<String, String> flats = getFlatSubsystemsMap(); Map<Resource, List<Wire>> wiring = getWiring(); Map<Resource, String> resources = new HashMap<>(); SimpleFilter sf = createFilter(IDENTITY_NAMESPACE, "*", CAPABILITY_TYPE_ATTRIBUTE, TYPE_SUBSYSTEM); if (wiring != null) { for (Resource resource : wiring.keySet()) { if (findMatchingCapability(resourceFilter, resource.getCapabilities(null)) != null) { // Find the subsystem where this feature is installed Wire wire = findMatchingWire(sf, wiring.get(resource)); if (wire != null) { String region = (String) wire.getCapability().getAttributes().get(IDENTITY_NAMESPACE); region = flats.get(region); resources.put(resource, region); } } } } return resources; }
private void addWiredBundle(Map<Resource, List<Wire>> wirings, Resource resource, List<Resource> result) { List<Requirement> reqs = resource.getRequirements(BUNDLE_NAMESPACE); for (Requirement req : reqs) { List<Wire> wrs = wirings.get(resource); for (Wire w : wrs) { if (w.getRequirement() .equals(req)) { Resource res = w.getProvider(); if (res != null) { if (!result.contains(res)) { result.add(res); addWiredBundle(wirings, res, result); } } } } } }
protected static Capability findFrameworkContractCapability(Resource resource) { List<Capability> contractCaps = resource.getCapabilities(CONTRACT_NAMESPACE); if (contractCaps != null) for (Capability cap : contractCaps) { if (CONTRACT_OSGI_FRAMEWORK.equals(cap.getAttributes() .get(CONTRACT_NAMESPACE))) return cap; } return null; }
protected void processMandatoryResource(Requirement requirement, LinkedHashSet<Capability> firstStageResult, Resource resource) { if (resource != null) { List<Capability> selfCaps = resource.getCapabilities(requirement.getNamespace()); if (selfCaps != null) { for (Capability selfCap : selfCaps) { if (matches(requirement, selfCap)) firstStageResult.add(selfCap); } } } }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final WrappedCapability other = (WrappedCapability) obj; if (m_host != other.m_host && (m_host == null || !m_host.equals(other.m_host))) { return false; } if (m_cap != other.m_cap && (m_cap == null || !m_cap.equals(other.m_cap))) { return false; } return true; }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final WrappedRequirement other = (WrappedRequirement) obj; if (m_host != other.m_host && (m_host == null || !m_host.equals(other.m_host))) { return false; } if (m_req != other.m_req && (m_req == null || !m_req.equals(other.m_req))) { return false; } return true; }
private Map<Resource, Integer> computeEdges(Resource resource) { Map<Resource, Integer> edges = new HashMap<>(); String owner = ResolverUtil.getOwnerName(resource); for (Requirement req : resource.getRequirements(null)) { if (isOptional(req) || isDynamic(req)) { continue; } List<Capability> caps = findProviders(req); for (Capability cap : caps) { Resource r = cap.getResource(); // If there's a single provider for any kind of mandatory requirement, // this means the resource is also mandatory. // Else prefer resources from the same subsystem (with the same owner). int v = (caps.size() == 1) ? 0 : (Objects.equals(ResolverUtil.getOwnerName(r), owner)) ? 1 : 10; edges.merge(r, v, Math::min); } } return edges; }