Refine search
/** * Create a capability based on an existing capability, providing the resource. * The namespace, attributes and directives are copied from the provided capability. * @param capability The capability to base the new requirement on. * @param resource The resource to be associated with the capability */ public CapabilityImpl(Resource resource, Capability capability) { this(resource, capability.getNamespace(), capability.getDirectives(), capability.getAttributes()); }
private boolean equalsCap(Capability other) { if (!Objects.equals(namespace, other.getNamespace())) return false; if (!Objects.equals(attributes, other.getAttributes())) return false; if (!Objects.equals(directives, other.getDirectives())) return false; return Objects.equals(resource, other.getResource()); }
@Override public boolean equals(Object o) { return (o instanceof Blame) && m_reqs.equals(((Blame) o).m_reqs) && m_cap.equals(((Blame) o).m_cap); } }
@Override public String toString() { return m_cap.getResource() + "." + m_cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE) + (((m_reqs == null) || m_reqs.isEmpty()) ? " NO BLAME" : " BLAMED ON " + m_reqs); }
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; }
@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; }
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; }
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()); }
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( PackageNamespace.PACKAGE_NAMESPACE)); for (Wire wire : wiring.getRequiredResourceWires(null)) if (wire.getCapability().getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) if (exportNames.contains(wire.getCapability().getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE)))
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)); }
@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 Wire createWire(Requirement requirement, Candidates allCandidates) { Capability cand = allCandidates.getFirstCandidate(requirement); if (cand == null) { return null; } return new WireImpl( getDeclaredResource(requirement.getResource()), getDeclaredRequirement(requirement), getDeclaredResource(cand.getResource()), getDeclaredCapability(cand)); }
private static BundleWireDTO createBundleWireDTO(Wire wire, Set<BundleRevisionDTO> resources, Set<NodeDTO> nodes) { BundleWireDTO wdto = new BundleWireDTO(); if (wire instanceof BundleWire) { BundleWire w = (BundleWire) wire; BundleWiring pw = w.getProviderWiring(); addWiringNodeIfNotPresent(pw, resources, nodes); wdto.providerWiring = getWiringID(pw); BundleWiring rw = w.getRequirerWiring(); addWiringNodeIfNotPresent(rw, resources, nodes); wdto.requirerWiring = getWiringID(rw); } wdto.provider = getResourceIDAndAdd(wire.getProvider(), resources); wdto.requirer = getResourceIDAndAdd(wire.getRequirer(), resources); wdto.capability = new CapabilityRefDTO(); wdto.capability.capability = getCapabilityID(wire.getCapability()); wdto.capability.resource = getResourceIDAndAdd(wire.getCapability().getResource(), resources); wdto.requirement = new RequirementRefDTO(); wdto.requirement.requirement = getRequirementID(wire.getRequirement()); wdto.requirement.resource = getResourceIDAndAdd(wire.getRequirement().getResource(), resources); return wdto; }
@SuppressWarnings("unchecked") public static <T extends Capability> T as(final Capability cap, Class<T> type) { return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] { type }, (target, method, args) -> (Capability.class == method.getDeclaringClass()) ? method.invoke(cap, args) : get(method, cap.getAttributes(), cap.getDirectives(), args)); }
@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; }
public void copyCapabilities(Set<String> ignoreNamespaces, Resource r) throws Exception { for (Capability c : r.getCapabilities(null)) { if (ignoreNamespaces.contains(c.getNamespace())) continue; addCapability(c); } }
private void propagateState(Map<Resource, FeatureState> states, Resource resource, FeatureState state, SubsystemResolver resolver) { if (!isSubsystem(resource)) { FeatureState reqState = mergeStates(state, states.get(resource)); if (reqState != states.get(resource)) { states.put(resource, reqState); for (Wire wire : resolver.getWiring().get(resource)) { if (IDENTITY_NAMESPACE.equals(wire.getCapability().getNamespace())) { propagateState(states, wire.getProvider(), reqState, resolver); } } } } }
private int compareVersions(Capability cap1, Capability cap2, String attribute) { Version v1 = (!cap1.getAttributes().containsKey(attribute)) ? Version.emptyVersion : (Version) cap1.getAttributes().get(attribute); Version v2 = (!cap2.getAttributes().containsKey(attribute)) ? Version.emptyVersion : (Version) cap2.getAttributes().get(attribute); // Compare these in reverse order, since we want // highest version to have priority. return v2.compareTo(v1); }