@Override public boolean resolveCapabilityElement(CapabilityResolver capResolver, Object o) throws ProvisioningException { if(!format.isCollection()) { capResolver.add(o); return true; } final Collection<?> col = (Collection<?>)o; if(col.isEmpty()) { if (capResolver.getSpec().isOptional()) { return false; } throw new ProvisioningException(Errors.capabilityMissingParameter(capResolver.getSpec(), capResolver.getElem())); } capResolver.multiply(col); return true; } }
public boolean resolve(CapabilityResolver resolver) throws ProvisioningException { for(int i = 0; i < elems.length; ++i) { if(!resolver.resolveElement(elems[i], isElemStatic[i])) { return false; } } return true; }
public CapabilityResolver add(Object elem) throws ProvisioningException { if(capList == null) { if(capBuf.length() > 0) { capBuf.append('.'); } capBuf.append(toStringElem(elem)); return this; } final String str = toStringElem(elem); for(int i = 0; i < capList.size(); ++i) { capList.get(i).append('.').append(str); } return this; }
add(elems.iterator().next()); return this; capList.add(capBuf.length() == 0 ? new StringBuilder(toStringElem(o)) : new StringBuilder(capBuf).append(toStringElem(o))); final Object firstElem = elemI.next(); while(elemI.hasNext()) { capList.add(new StringBuilder(capBuf).append(toStringElem(elemI.next()))); capBuf.append(toStringElem(firstElem));
private List<CircularRefInfo> orderCapabilityProviders(ResolvedFeature feature, List<CircularRefInfo> circularRefs) throws ProvisioningException { for (CapabilitySpec capSpec : feature.spec.xmlSpec.getRequiredCapabilities()) { final List<String> resolvedCaps = capResolver.resolve(capSpec, feature); if (resolvedCaps.isEmpty()) { continue; } for (String resolvedCap : resolvedCaps) { final CapabilityProviders providers; try { providers = getProviders(resolvedCap, false); } catch (ProvisioningException e) { throw new ProvisioningException(Errors.noCapabilityProvider(feature, capSpec, resolvedCap)); } final List<CircularRefInfo> circles = orderProviders(providers); if (circularRefs == null) { circularRefs = circles; } else { if (circularRefs.size() == 1) { final CircularRefInfo first = circularRefs.get(0); circularRefs = new ArrayList<>(1 + circles.size()); circularRefs.add(first); } circularRefs.addAll(circles); } } } return circularRefs; }
@Override public boolean resolveCapabilityElement(CapabilityResolver capResolver, Object o) throws ProvisioningException { capResolver.add(o); return true; } }
List<String> resolve(CapabilitySpec capSpec, ResolvedFeature feature) throws ProvisioningException { if(capSpec.isStatic()) { return Collections.singletonList(capSpec.toString()); } if(capBuf == null) { capBuf = new StringBuilder(); } this.feature = feature; this.capSpec = capSpec; try { if(!capSpec.resolve(this)) { return Collections.emptyList(); } if(capList == null) { return capBuf.length() == 0 ? Collections.emptyList() : Collections.singletonList(capBuf.toString()); } List<String> resolved = new ArrayList<>(capList.size()); for (int i = 0; i < capList.size(); ++i) { resolved.add(capList.get(i).toString()); } return resolved; } catch(ProvisioningException e) { throw new ProvisioningException(Errors.failedToResolveCapability(feature, capSpec), e); } finally { reset(); } }
boolean resolveCapabilityElement(ResolvedFeature feature, String paramName, CapabilityResolver capResolver) throws ProvisioningException { final ResolvedFeatureParam resolvedParam = getResolvedParam(paramName); Object value = feature.getResolvedParam(paramName); if(value == null) { value = feature.isUnset(paramName) ? null : resolvedParam.defaultValue; if (value == null) { if (capResolver.getSpec().isOptional()) { return false; } throw new ProvisioningException(Errors.capabilityMissingParameter(capResolver.getSpec(), paramName)); } } if(Constants.GLN_UNDEFINED.equals(value)) { return true; // skip GLN_UNDEFINED } return resolvedParam.type.resolveCapabilityElement(capResolver, value); }
private void doOrder(ProvisioningRuntimeBuilder rt) throws ProvisioningException { for (SpecFeatures features : specFeatures.values()) { // resolve references features.spec.resolveRefMappings(rt); // resolve and register capability providers if(features.spec.xmlSpec.providesCapabilities()) { for(CapabilitySpec cap : features.spec.xmlSpec.getProvidedCapabilities()) { if(cap.isStatic()) { getProviders(cap.toString(), true).add(features); } else { for(ResolvedFeature feature : features.getFeatures()) { final List<String> resolvedCaps = capResolver.resolve(cap, feature); if(resolvedCaps.isEmpty()) { continue; } for(String resolvedCap : resolvedCaps) { getProviders(resolvedCap, true).add(feature); } } } } } } orderedFeatures = new ArrayList<>(features.size()); for(SpecFeatures features : specFeatures.values()) { orderFeaturesInSpec(features, false); } }
public boolean resolveElement(String elem, boolean isStatic) throws ProvisioningException { if(isStatic) { add(elem); return true; } this.currentElem = elem; return feature.spec.resolveCapabilityElement(feature, elem, this); }
private List<CircularRefInfo> orderCapabilityProviders(ResolvedFeature feature, List<CircularRefInfo> circularRefs) throws ProvisioningException { for (CapabilitySpec capSpec : feature.spec.xmlSpec.getRequiredCapabilities()) { final List<String> resolvedCaps = capResolver.resolve(capSpec, feature); if (resolvedCaps.isEmpty()) { continue; } for (String resolvedCap : resolvedCaps) { final CapabilityProviders providers; try { providers = getProviders(resolvedCap, false); } catch (ProvisioningException e) { throw new ProvisioningException(Errors.noCapabilityProvider(feature, capSpec, resolvedCap)); } circularRefs = CollectionUtils.addAll(circularRefs, orderProviders(providers)); if(providers.isProvided()) { feature.addBranchDep(providers.branches.iterator().next(), false); //System.out.println("added branch dep on cap provider " + feature.getId() + " -> " + providers.branches); } else { providers.addBranchDependee(feature); } } } return circularRefs; }
} else { for(ResolvedFeature feature : specFeatures.getFeatures()) { final List<String> resolvedCaps = capResolver.resolve(cap, feature); if(resolvedCaps.isEmpty()) { continue;