if(entry.getValue().spec.getSpec().hasId()) { continue;
void add(SpecFeatures specFeatures) { specs = CollectionUtils.add(specs, specFeatures); specFeatures.spec.addCapabilityProviders(this); }
FeatureParameterType getTypeForParameter(String paramName) throws ParameterTypeNotFoundException, ProvisioningDescriptionException { return getResolvedParam(paramName).type; }
assertRefParamMapping(refSpec, targetSpec); if(!child && (resolvedParam.spec.isFeatureId() && targetSpec.getSpec().getParam(refParamName).isFeatureId())) { child = true; paramValue = feature.isUnset(paramName) ? null : resolvedParam.defaultValue; if (paramValue == null) { assertRefNotNillable(feature, refSpec); return Collections.emptyList(); final Collection<?> col = (Collection<?>) paramValue; if(col.isEmpty()) { assertRefNotNillable(feature, refSpec); return Collections.emptyList(); paramValue = feature.isUnset(paramName) ? null : resolvedParam.defaultValue; if (paramValue == null) { assertRefNotNillable(feature, refSpec); return Collections.emptyList(); final Collection<?> col = (Collection<?>) paramValue; if(col.isEmpty()) { assertRefNotNillable(feature, refSpec); return Collections.emptyList(); assertRefNotNillable(feature, refSpec); assertRefNotNillable(feature, refSpec); return Collections.emptyList();
Set<FeatureSpecInfo> specs = new HashSet<>(); for (ResolvedFeatureSpec resolvedSpec : layout.getFeaturePack(fpid.getProducer()).getFeatureSpecs()) { ResolvedSpecId resolved = resolvedSpec.getId(); if (wantedSpecs == null || wantedSpecs.contains(resolved)) { FeatureSpecInfo specInfo = allspecs.get(resolved); if (specInfo == null) { Set<Identity> missingPackages = new HashSet<>(); FeatureSpec spec = resolvedSpec.getSpec(); specInfo = new FeatureSpecInfo(resolved, id, spec); Identity specId = Identity.fromChannel(resolved.getProducer(), resolved.getName());
private void doOrder(ProvisioningRuntimeBuilder rt) throws ProvisioningException { for (SpecFeatures specFeatures : specFeatures.values()) { specFeatures.spec.resolveRefMappings(rt); if(entry.getValue().spec.getSpec().hasId()) { continue;
if(feature.spec.isSpecBranch(branchPerSpec)) { final SpecFeatures spec = feature.getSpecFeatures(); branch = spec.isBranchSet() ? spec.getBranch() : (spec.spec.branchId == null ? null : branchesWithId.get(spec.spec.branchId)); if(branch == null) { branch = startNewBranch(spec.spec.branchId, feature.spec.isBatchBranch(branchIsBatch)); spec.setBranch(branch); } else if (createsDepCircle(branch, feature)) { branch = startNewBranch(null, feature.spec.isBatchBranch(branchIsBatch)); || currentBranch.isFkBranch() || createsDepCircle(currentBranch, feature)) { startNewBranch(null, feature.spec.isBatchBranch(branchIsBatch));
@Override public void nextSpec(ResolvedFeatureSpec spec) { specElement = addElement(fpElement, Element.SPEC.getLocalName(), parent.getNamespace()); addAttribute(specElement, Attribute.NAME, spec.getId().getName()); }
String configValue = params.get(idParamSpec.getName()); if(configValue != null) { final Object childValue = paramFromString(idParamSpec.getName(), configValue); final Object idValue = resolvedParams.put(idParamSpec.getName(), childValue); if(idValue != null && !idValue.equals(childValue)) { final Object childValue = getResolvedParam(idParamSpec.getName()).defaultValue; if(childValue == null) { throw new ProvisioningDescriptionException(Errors.nonNillableParameterIsNull(id, idParamSpec.getName())); String configValue = params.get(idParamSpec.getName()); if(configValue != null) { final Object childValue = paramFromString(idParamSpec.getName(), configValue); if(parentValue != null && !parentValue.equals(childValue)) { throw new ProvisioningDescriptionException(Errors.idParamForeignKeyInitConflict(id, idParamSpec.getName(), childValue, parentValue)); final Object childValue = getResolvedParam(idParamSpec.getName()).defaultValue; if(childValue == null) { throw new ProvisioningDescriptionException(Errors.nonNillableParameterIsNull(id, idParamSpec.getName()));
public ResolvedFeatureSpec getFeatureSpec(String name) throws ProvisioningException { if(featureSpecs != null) { final ResolvedFeatureSpec resolvedSpec = featureSpecs.get(name); if(resolvedSpec != null) { return resolvedSpec; } } final Path specXml = dir.resolve(Constants.FEATURES).resolve(name).resolve(Constants.SPEC_XML); if (!Files.exists(specXml)) { return null; } try (BufferedReader reader = Files.newBufferedReader(specXml)) { final FeatureSpec xmlSpec = FeatureSpecXmlParser.getInstance().parse(reader); if(!xmlSpec.getName().equals(name)) { throw new ProvisioningDescriptionException("Feature-pack " + getFPID() + " feature spec " + xmlSpec.getName() + " does not match the requested feature spec name " + name); } final ResolvedFeatureSpec resolvedSpec = new ResolvedFeatureSpec(new ResolvedSpecId(producer, xmlSpec.getName()), featureParamTypeProvider, xmlSpec); if (featureSpecs == null) { featureSpecs = new HashMap<>(); } featureSpecs.put(name, resolvedSpec); return resolvedSpec; } catch (Exception e) { throw new ProvisioningDescriptionException(Errors.parseXml(specXml), e); } }
void validate() throws ProvisioningDescriptionException { for(Map.Entry<String, ResolvedFeatureParam> entry : spec.getResolvedParams().entrySet()) { final ResolvedFeatureParam param = entry.getValue(); if(params.containsKey(entry.getKey())) { continue; } if(param.defaultValue == null || unsetParams.contains(entry.getKey())) { if(param.spec.isNillable()) { continue; } throw new ProvisioningDescriptionException(Errors.nonNillableParameterIsNull(this, entry.getKey())); } params.put(entry.getKey(), param.defaultValue); } }
return; final FeatureParameterType valueType = spec.getTypeForParameter(name); if(valueType.isMergeable()) { params.put(name, overwrite ? valueType.merge(prevValue, value) : valueType.merge(value, prevValue));
private ResolvedFeatureSpec resolveRefMapping(ProvisioningRuntimeBuilder rt, FeaturePackRuntimeBuilder origin, FeatureReferenceSpec refSpec) throws ProvisioningException { try { if(refSpec.getOrigin() != null) { origin = rt.layout.getFeaturePack(origin.getSpec().getFeaturePackDep(refSpec.getOrigin()).getLocation().getProducer()); } final ResolvedFeatureSpec resolvedRefSpec = rt.getFeatureSpec(origin, refSpec.getFeature().getName()); assertRefParamMapping(refSpec, resolvedRefSpec); return resolvedRefSpec; } catch (ProvisioningDescriptionException e) { throw new ProvisioningDescriptionException(Errors.failedToResolveFeatureReference(refSpec, id), e); } }
@Override public void handle(ProvisionedConfigHandler handler) throws ProvisioningException { if (!hasFeatures()) { return; } handler.prepare(this); ResolvedSpecId lastHandledSpecId = null; for(ProvisionedFeature feature : features) { if(!feature.getSpecId().equals(lastHandledSpecId)) { if (lastHandledSpecId == null || !feature.getSpecId().getProducer().equals(lastHandledSpecId.getProducer())) { handler.nextFeaturePack(feature.getSpecId().getProducer().getLocation().getFPID()); } // TODO: complete spec isn't available here, but specId is enough for marshalling handler.nextSpec(new ResolvedFeatureSpec(feature.getSpecId(), null, FeatureSpec.builder().build())); lastHandledSpecId = feature.getSpecId(); } handler.nextFeature(feature); } handler.done(); }
final ProvisionedFeature original = feature[0]; final ProvisionedFeature actual = feature[1]; final FeatureSpec fSpec = layout.getFeaturePack(actual.getSpecId().getProducer()).getFeatureSpec(actual.getSpecId().getName()).getSpec(); final FeatureConfig config = new FeatureConfig(fSpec.getName()); config.setOrigin(provisionedConfig.originOf(actual.getSpecId().getProducer()));
String paramToString(String name, Object value) throws ProvisioningException { return getResolvedParam(name).type.toString(value); }
private Object paramFromString(String name, String value) throws ProvisioningException { try { return getResolvedParam(name).type.fromString(value); } catch (ParameterTypeConversionException e) { throw new ProvisioningException(Errors.failedToResolveParameter(id, name, value), e); } }
private Object resolveIdParamValue(Map<String, String> params, final FeatureParameterSpec param) throws ProvisioningException { final ResolvedFeatureParam resolvedParam = getResolvedParam(param.getName()); final String strValue = params.get(param.getName()); if(strValue == null) { final Object value = resolvedParam.defaultValue; if (value == null) { throw new ProvisioningDescriptionException(Errors.nonNillableParameterIsNull(id, param.getName())); } return value; } return resolvedParam.type.fromString(strValue); }
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); }