public FeatureId build() throws ProvisioningDescriptionException { return new FeatureId(specId, params); } }
formatException(str); if(c == ':') { if(buf.length() == 0) { formatException(str); formatException(str); final int equals = str.indexOf('=', nextIndex + 1); if(equals < 0 || equals == str.length() - 1) { formatException(str); return FeatureId.create(specId.toString(), str.substring(nextIndex, equals), str.substring(equals + 1)); final Builder builder = FeatureId.builder(specId.toString()); int lastComma = nextIndex - 1; while(endIndex > 0) { int equals = str.indexOf('=', lastComma + 2); if(equals < 0 || equals == str.length() - 1) { formatException(str); formatException(str);
private static FeatureConfig getExistingFeature(ConfigModel cm, FeatureId featId) { for (ConfigItem ci : cm.getItems()) { if (ci instanceof FeatureConfig) { FeatureConfig fi = (FeatureConfig) ci; if (fi.getSpecId().equals(featId.getSpec())) { boolean eq = true; for (String name : featId.getParamNames()) { String p = fi.getParam(name); if (p == null || !p.equals(featId.getParam(name))) { eq = false; break; } } if (eq) { return fi; } } } } return null; }
for(Map.Entry<FeatureId, String> excluded : dep.getExcludedFeatures().entrySet()) { final ElementNode excludeE = addElement(depE, Element.EXCLUDE.getLocalName(), ns); addAttribute(excludeE, Attribute.FEATURE_ID, excluded.getKey().toString()); if(excluded.getValue() != null) { addAttribute(excludeE, Attribute.PARENT_REF, excluded.getValue()); for(Map.Entry<FeatureId, FeatureConfig> entry : dep.getIncludedFeatures().entrySet()) { final ElementNode includeE = addElement(depE, Element.INCLUDE.getLocalName(), ns); addAttribute(includeE, Attribute.FEATURE_ID, entry.getKey().toString()); final FeatureConfig fc = entry.getValue(); if(fc.getParentRef() != null) {
addAttribute(depE, Attribute.ORIGIN, depSpec.getOrigin()); addAttribute(depE, Attribute.FEATURE_ID, depSpec.getFeatureId().toString()); if(depSpec.isInclude()) { addAttribute(depE, Attribute.INCLUDE, TRUE); for(Map.Entry<String, String> param : fc.getParams().entrySet()) { final String name = param.getKey(); if(id != null && id.hasParam(name)) { continue;
public FeatureInfo(ConfigInfo configInfo, ProvisionedFeature feature, List<String> path, FPID currentFP) throws ProvisioningDescriptionException { this.feature = feature; this.path = path; this.currentFP = currentFP; this.configInfo = configInfo; FeatureId.Builder builder = FeatureId.builder(feature.getSpecId().getName()); if (feature.getId() != null) { for (Entry<String, Object> param : feature.getId().getParams().entrySet()) { builder.setParam(param.getKey(), param.getValue().toString()); } featureId = builder.build(); featureConfig = FeatureConfig.newConfig(featureId); } else { featureId = null; featureConfig = null; } StringBuilder b = new StringBuilder(); b.append(FeatureContainerPathConsumer.FINAL_CONFIGS_PATH).append(configInfo.getModel()). append(PathParser.PATH_SEPARATOR).append(configInfo.getName()).append(PathParser.PATH_SEPARATOR); for (int i = 0; i < path.size(); i++) { b.append(path.get(i)); if (i < path.size() - 1) { b.append(PathParser.PATH_SEPARATOR); } } fullPath = b.toString(); }
session.println("NONE"); } else { for (Entry<String, String> entry : f.getFeatureId().getParams().entrySet()) { session.println(entry.getKey() + "=" + entry.getValue());
private static FeatureId parseFeatureId(String id) throws XMLStreamException { try { return FeatureId.fromString(id); } catch (ProvisioningDescriptionException e) { throw new XMLStreamException("Failed to parse feature-id", e); } }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; FeatureDependencySpec other = (FeatureDependencySpec) obj; if (origin == null) { if (other.origin != null) return false; } else if (!origin.equals(other.origin)) return false; if (featureId == null) { if (other.featureId != null) return false; } else if (!featureId.equals(other.featureId)) return false; if (include != other.include) return false; return true; }
} else { for (FeatureDependencySpec c : f.getSpec().getFeatureDeps()) { session.println(tab + c.getFeatureId().toString());
private static FeatureId getFeatureId(final ProvisionedFeature feature) throws ProvisioningDescriptionException, ProvisioningException { final FeatureId.Builder id = FeatureId.builder(feature.getSpecId().getName()); final ResolvedFeatureId resolvedId = feature.getId(); for(String name : resolvedId.getParams().keySet()) { id.setParam(name, feature.getConfigParam(name)); } return id.build(); } }
private FeatureDependencySpec parseDependency(XMLExtendedStreamReader reader) throws XMLStreamException { String dependency = null; boolean include = false; String featureId = null; for (int i = 0; i < reader.getAttributeCount(); i++) { final Attribute attribute = Attribute.of(reader.getAttributeName(i)); switch (attribute) { case DEPENDENCY: dependency = reader.getAttributeValue(i); break; case FEATURE_ID: featureId = reader.getAttributeValue(i); break; case INCLUDE: include = Boolean.parseBoolean(reader.getAttributeValue(i)); break; default: throw ParsingUtils.unexpectedAttribute(reader, i); } } if(featureId == null) { throw ParsingUtils.missingAttributes(reader.getLocation(), Collections.singleton(Attribute.FEATURE_ID)); } ParsingUtils.parseNoContent(reader); try { return FeatureDependencySpec.create(FeatureId.fromString(featureId), dependency, include); } catch (ProvisioningDescriptionException e) { throw new XMLStreamException("Failed to parse feature dependency", reader.getLocation(), e); } }
private Set<ResolvedFeatureId> resolveExcludedIds(Set<ResolvedFeatureId> resolvedIds, Map<FeatureId, String> features) throws ProvisioningException { for (Map.Entry<FeatureId, String> excluded : features.entrySet()) { final FeatureId excludedId = excluded.getKey(); final ResolvedFeatureSpec resolvedSpec = getFeatureSpec(excludedId.getSpec().getName()); if(parentFeature != null) { resolvedIds = CollectionUtils.add(resolvedIds, resolvedSpec.resolveIdFromForeignKey(parentFeature.id, excluded.getValue(), excludedId.getParams())); } else { resolvedIds = CollectionUtils.add(resolvedIds, resolvedSpec.resolveFeatureId(excludedId.getParams())); } } return resolvedIds; }
public static FeatureId create(String specId, String name, String value) throws ProvisioningDescriptionException { return new FeatureId(specId, Collections.singletonMap(name, value)); }
for(FeatureDependencySpec dep : featureSpec.getFeatureDeps()) { final ElementNode depE = addElement(depsE, Element.DEPENDENCY); addAttribute(depE, Attribute.FEATURE_ID, dep.getFeatureId().toString()); if(dep.getOrigin() != null) { addAttribute(depE, Attribute.DEPENDENCY, dep.getOrigin());
@SuppressWarnings("unchecked") public B removeFeature(FeatureId id) throws ProvisioningDescriptionException { int index = -1; // Although that is a list, we have a single ConfigModel for a given ConfigId for (int i = 0; i < items.size(); i++) { ConfigItem ci = items.get(i); if (ci instanceof FeatureConfig) { FeatureConfig conf = (FeatureConfig) ci; if (conf.getSpecId().equals(id.getSpec())) { boolean eq = true; for (Entry<String, String> entry : id.getParams().entrySet()) { String val = conf.getParam(entry.getKey()); if (val == null || !val.equals(entry.getValue())) { eq = false; break; } } if (eq) { index = i; break; } } } } if (index == -1) { throw new ProvisioningDescriptionException("Feature " + id + " is not added"); } items = CollectionUtils.remove(items, index); return (B) this; }
featId = new FeatureId(spec.getSpec().getName(), ids); FeatureConfig fc = FeatureConfig.newConfig(featId);
@SuppressWarnings("unchecked") public B includeFeature(FeatureId featureId, FeatureConfig feature) throws ProvisioningDescriptionException { if(feature != null && feature.getOrigin() != null) { final String origin = feature.getOrigin(); feature.setOrigin(null); getExternalFgConfig(origin).includeFeature(featureId, feature); return (B) this; } if(excludedFeatures.containsKey(featureId)) { throw new ProvisioningDescriptionException(featureId + " has been explicitly excluded"); } if(feature == null) { feature = new FeatureConfig(featureId.getSpec()); } else if(feature.specId == null) { feature.specId = featureId.getSpec(); } for (Map.Entry<String, String> idEntry : featureId.getParams().entrySet()) { final String prevValue = feature.putParam(idEntry.getKey(), idEntry.getValue()); if (prevValue != null && !prevValue.equals(idEntry.getValue())) { throw new ProvisioningDescriptionException("Parameter " + idEntry.getKey() + " has value '" + idEntry.getValue() + "' in feature ID and value '" + prevValue + "' in the feature body"); } } includedFeatures = CollectionUtils.putLinked(includedFeatures, featureId, feature); return (B) this; }
final FeatureDependencySpec depSpec = depSpecs.iterator().next(); final FeaturePackRuntimeBuilder depFp = depSpec.getOrigin() == null ? rt.layout.getFeaturePack(id.producer) : rt.getOrigin(depSpec.getOrigin()); final ResolvedFeatureSpec depResolvedSpec = rt.getFeatureSpec(depFp, depSpec.getFeatureId().getSpec().getName()); return Collections.singletonMap(depResolvedSpec.resolveFeatureId(depSpec.getFeatureId().getParams()), depSpec); for (FeatureDependencySpec userDep : depSpecs) { final FeaturePackRuntimeBuilder depFp = userDep.getOrigin() == null ? ownFp : rt.getOrigin(userDep.getOrigin()); final ResolvedFeatureSpec depResolvedSpec = rt.getFeatureSpec(depFp, userDep.getFeatureId().getSpec().getName()); final ResolvedFeatureId depId = depResolvedSpec.resolveFeatureId(userDep.getFeatureId().getParams()); final FeatureDependencySpec specDep = result.put(depId, userDep); if(specDep != null) {