private CapabilitySpec(List<String> elems, List<Boolean> elemTypes, boolean optional) throws ProvisioningDescriptionException { this.elems = elems.toArray(new String[elems.size()]); this.isElemStatic = elemTypes.toArray(new Boolean[elemTypes.size()]); this.optional = optional; if(optional && isStatic()) { throw new ProvisioningDescriptionException("Static capability cannot be optional: " + toString()); } }
public static CapabilitySpec fromString(String str) throws ProvisioningDescriptionException { return fromString(str, false); }
private void writeCaps(final ElementNode parent, Set<CapabilitySpec> caps) { for(CapabilitySpec cap : caps) { final ElementNode capE = addElement(parent, Element.CAPABILITY); addAttribute(capE, Attribute.NAME, cap.toString()); if(cap.isOptional()) { addAttribute(capE, Attribute.OPTIONAL, 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(); } }
case '.': { if(buf.length() == 0) { formatError(str); formatError(str); formatError(str); formatError(str); return new CapabilitySpec(elems, isElemStatic, optional);
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); }
@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; } }
static String noCapabilityProvider(ResolvedFeature feature, CapabilitySpec capSpec, String resolvedCap) { final StringBuilder buf = new StringBuilder(); buf.append("No provider found for capability ").append(resolvedCap); buf.append(" required by "); if(feature.hasId()) { buf.append(feature.getId()); } else { buf.append(" an instance of ").append(feature.getSpecId()); } if(!capSpec.isStatic()) { buf.append(" as ").append(capSpec.toString()); } return buf.toString(); }
public Builder requiresCapability(String name, boolean optional) throws ProvisioningDescriptionException { return requiresCapability(CapabilitySpec.fromString(name, optional)); }
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 Builder providesCapability(String name, boolean optional) throws ProvisioningDescriptionException { return providesCapability(CapabilitySpec.fromString(name, optional)); }
private CapabilitySpec parseCapabilityName(XMLExtendedStreamReader reader) throws XMLStreamException { String name = null; boolean optional = false; final int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); switch (attribute) { case NAME: name = reader.getAttributeValue(i); break; case OPTIONAL: optional = Boolean.parseBoolean(reader.getAttributeValue(i)); break; default: throw ParsingUtils.unexpectedAttribute(reader, i); } } if (name == null) { throw ParsingUtils.missingAttributes(reader.getLocation(), Collections.singleton(Attribute.NAME)); } ParsingUtils.parseNoContent(reader); try { return CapabilitySpec.fromString(name, optional); } catch (ProvisioningDescriptionException e) { throw new XMLStreamException("Failed to parse capability '" + name + "'", reader.getLocation(), e); } } }