private ResolvedFeatureSpec getFeatureSpec(String name, boolean switchOrigin) throws ProvisioningException { return getFeatureSpec(currentOrigin, name, switchOrigin); }
ResolvedFeatureSpec getFeatureSpec(FeaturePackRuntimeBuilder origin, String name) throws ProvisioningException { return getFeatureSpec(origin, name, false); }
private ResolvedFeatureSpec getFeatureSpec(String name) throws ProvisioningException { return getFeatureSpec(name, false); }
private Set<ResolvedSpecId> resolveSpecIds(Set<ResolvedSpecId> resolvedIds, Set<SpecId> specs) throws ProvisioningException { for (SpecId specId : specs) { resolvedIds = CollectionUtils.add(resolvedIds, getFeatureSpec(specId.getName()).id); } return resolvedIds; }
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; }
private Map<ResolvedFeatureId, FeatureDependencySpec> resolveFeatureDeps(ConfigModelStack configStack, Collection<FeatureDependencySpec> featureDeps, final ResolvedFeatureSpec spec) throws ProvisioningException { Map<ResolvedFeatureId, FeatureDependencySpec> resolvedDeps = spec.resolveFeatureDeps(this, featureDeps); if(!resolvedDeps.isEmpty()) { for(Map.Entry<ResolvedFeatureId, FeatureDependencySpec> dep : resolvedDeps.entrySet()) { if(!dep.getValue().isInclude()) { continue; } final ResolvedFeatureId depId = dep.getKey(); if(configStack.includes(depId) || configStack.isFilteredOut(depId.specId, depId)) { continue; } final FeatureDependencySpec depSpec = dep.getValue(); final FeaturePackRuntimeBuilder originalFp = setOrigin(depSpec.getOrigin()); try { resolveFeatureDepsAndRefs(configStack, getFeatureSpec(depId.getSpecId().getName()), depId, Collections.emptyMap(), Collections.emptyList()); } finally { setOrigin(originalFp); } } } return resolvedDeps; }
private Map<ResolvedFeatureId, FeatureConfig> resolveIncludedIds(Map<ResolvedFeatureId, FeatureConfig> includedFeatures, Map<FeatureId, FeatureConfig> features) throws ProvisioningException { for (Map.Entry<FeatureId, FeatureConfig> included : features.entrySet()) { final FeatureConfig fc = new FeatureConfig(included.getValue()); final ResolvedFeatureSpec resolvedSpec = getFeatureSpec(fc.getSpecId().getName()); if (parentFeature != null) { includedFeatures = CollectionUtils.put(includedFeatures, resolvedSpec.resolveIdFromForeignKey(parentFeature.id, fc.getParentRef(), fc.getParams()), fc); } else { includedFeatures = CollectionUtils.put(includedFeatures, resolvedSpec.resolveFeatureId(fc.getParams()), fc); } } return includedFeatures; }
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);
final ResolvedFeatureSpec refResolvedSpec = getFeatureSpec(refSpec.getFeature().getName()); final List<ResolvedFeatureId> refIds = spec.resolveRefId(parentFeature, refSpec, refResolvedSpec); if (!refIds.isEmpty()) {
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); } }
private void resolveFeature(ConfigModelStack configStack, FeatureConfig fc) throws ProvisioningException { final FeaturePackRuntimeBuilder originalOrigin = currentOrigin; final ResolvedFeatureSpec spec = getFeatureSpec(fc.getSpecId().getName(), true); final ResolvedFeature originalParent = parentFeature; try { final ResolvedFeatureId resolvedId = parentFeature == null ? spec.resolveFeatureId(fc.getParams()) : spec.resolveIdFromForeignKey(parentFeature.id, fc.getParentRef(), fc.getParams()); if (configStack.isFilteredOut(spec.id, resolvedId)) { return; } parentFeature = resolveFeatureDepsAndRefs(configStack, spec, resolvedId, spec.resolveNonIdParams(parentFeature == null ? null : parentFeature.id, fc.getParentRef(), fc.getParams()), fc.getFeatureDeps()); if (fc.hasUnsetParams()) { parentFeature.unsetAllParams(fc.getUnsetParams(), true); } if (fc.hasResetParams()) { parentFeature.resetAllParams(fc.getResetParams()); } } finally { currentOrigin = originalOrigin; } processConfigItemContainer(fc); parentFeature = originalParent; }