@Override public FeaturePackRuntimeBuilder newFeaturePack(FeaturePackLocation fpl, FeaturePackSpec spec, Path fpDir, int type) { return new FeaturePackRuntimeBuilder(fpl.getFPID(), spec, fpDir, type); } };
@Override public FeaturePackRuntime transform(FeaturePackRuntimeBuilder other) throws ProvisioningException { return other.build(builder); } });
FeatureGroup getFeatureGroupSpec(String name) throws ProvisioningException { if(fgSpecs != null) { final FeatureGroup fgSpec = fgSpecs.get(name); if(fgSpec != null) { return fgSpec; } } final Path specXml = dir.resolve(Constants.FEATURE_GROUPS).resolve(name + ".xml"); if (!Files.exists(specXml)) { return null; } try (BufferedReader reader = Files.newBufferedReader(specXml)) { final FeatureGroup fgSpec = FeatureGroupXmlParser.getInstance().parse(reader); if(!fgSpec.getName().equals(name)) { throw new ProvisioningDescriptionException("Feature-pack " + getFPID() + " feature group " + fgSpec.getName() + " does not match the requested feature group name " + name); } if (fgSpecs == null) { fgSpecs = new HashMap<>(); } fgSpecs.put(name, fgSpec); return fgSpec; } catch (Exception e) { throw new ProvisioningException(Errors.parseXml(specXml), e); } }
private FeatureGroup getFeatureGroupSpec(FeaturePackRuntimeBuilder origin, String name) throws ProvisioningException { final FeaturePackDepsConfig fpDeps; if(origin != null) { if(origin.isVisited()) { return null; } final FeatureGroup fg = origin.getFeatureGroupSpec(name); if(fg != null) { currentOrigin = origin; return fg; } fpDeps = origin.getSpec(); setVisited(origin); } else { fpDeps = config; } if (!fpDeps.hasFeaturePackDeps()) { return null; } for (FeaturePackConfig fpDep : fpDeps.getFeaturePackDeps()) { final FeatureGroup fg = getFeatureGroupSpec(layout.getFeaturePack(fpDep.getLocation().getProducer()), name); if (fg != null) { return fg; } } return null; }
private ResolvedFeatureSpec findFeatureSpec(FeaturePackRuntimeBuilder origin, String name, boolean switchOrigin) throws ProvisioningException { final FeaturePackDepsConfig fpDeps; if (origin != null) { if(origin.isVisited()) { return null; } final ResolvedFeatureSpec fs = origin.getFeatureSpec(name); if (fs != null) { if (switchOrigin) { currentOrigin = origin; } return fs; } fpDeps = origin.getSpec(); setVisited(origin); } else { fpDeps = config; } if (!fpDeps.hasFeaturePackDeps()) { return null; } for (FeaturePackConfig fpDep : fpDeps.getFeaturePackDeps()) { final ResolvedFeatureSpec fs = findFeatureSpec(layout.getFeaturePack(fpDep.getLocation().getProducer()), name, switchOrigin); if (fs != null) { return fs; } } return null; }
config = currentOrigin.getConfig(configId); if (config != null) { configStack.pushConfig(config); config = currentOrigin.getSpec().getDefinedConfig(configId); if(config != null) { configStack.pushConfig(config); if (currentOrigin.getSpec().hasFeaturePackDeps()) { if (currentOrigin.getSpec().hasTransitiveDeps()) { for (FeaturePackConfig fpDep : currentOrigin.getSpec().getTransitiveDeps()) { extendedStackLevel |= fpConfigStack.push(fpDep, extendedStackLevel); for (FeaturePackConfig fpDep : currentOrigin.getSpec().getFeaturePackDeps()) { extendedStackLevel |= fpConfigStack.push(fpDep, extendedStackLevel); if (fpConfig.isInheritPackages() && currentOrigin.getSpec().hasDefaultPackages()) { for (String packageName : currentOrigin.getSpec().getDefaultPackageNames()) { if (fpConfigStack.isPackageFilteredOut(currentOrigin.producer, packageName, false)) { continue;
private boolean resolvePackage(FeaturePackRuntimeBuilder origin, String name, PackageRuntime.Builder parent, int type) throws ProvisioningException { final FeaturePackDepsConfig fpDeps; if (origin != null) { if(origin.resolvePackage(name, this, parent, type)) { return true; } fpDeps = origin.getSpec(); } else { fpDeps = config; } if (!fpDeps.hasFeaturePackDeps()) { return false; } for (FeaturePackConfig fpDep : fpDeps.getFeaturePackDeps()) { final FeaturePackRuntimeBuilder fpDepBuilder = layout.getFeaturePack(fpDep.getLocation().getProducer()); if (setVisited(fpDepBuilder) && resolvePackage(fpDepBuilder, name, parent, type)) { return true; } } return false; }
private void resolveConfigLayer(FeaturePackRuntimeBuilder fp, ConfigModelStack layerStack, ConfigId layerId) throws ProvisioningException { final FeaturePackRuntimeBuilder prevOrigin = currentOrigin; try { final ConfigLayerSpec configLayer = fp.getConfigLayer(layerId); if (configLayer != null) { layerStack.pushGroup(configLayer); } if(fp.getSpec().hasFeaturePackDeps()) { for(FeaturePackConfig depConfig : fp.getSpec().getFeaturePackDeps()) { resolveConfigLayer(layout.getFeaturePack(depConfig.getLocation().getProducer()), layerStack, layerId); } } if(configLayer != null) { setOrigin(fp); processConfigLayer(layerStack, popLayer(layerStack)); } } finally { setOrigin(prevOrigin); } }
FeaturePackRuntimeBuilder getOrigin(final String depName) throws ProvisioningException { if(Constants.THIS.equals(depName)) { if(thisOrigin == null) { throw new ProvisioningException("Feature-pack reference 'this' cannot be used in the current context."); } return thisOrigin; } final FeaturePackLocation fpl = currentOrigin == null ? config.getFeaturePackDep(depName).getLocation() : currentOrigin.getSpec().getFeaturePackDep(depName).getLocation(); return layout.getFeaturePack(fpl.getProducer()); }
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()));
++pushedCount; config = fp.getSpec().getDefinedConfig(configId); if(config != null) { if(modelOnlyStack == null) { ++pushedCount; config = fp.getConfig(configId); if (config != null) { if(modelOnlyStack == null) { if (fp.getSpec().hasTransitiveDeps()) { for (FeaturePackConfig fpDep : fp.getSpec().getTransitiveDeps()) { extendedStackLevel |= fpConfigStack.push(fpDep, extendedStackLevel); if(fp.getSpec().hasFeaturePackDeps()) { for(FeaturePackConfig fpDep : fp.getSpec().getFeaturePackDeps()) { extendedStackLevel |= fpConfigStack.push(fpDep, extendedStackLevel); if(fpDep.isConfigModelExcluded(configId) || !fpDep.isInheritModelOnlyConfigs() && !fpDep.isConfigModelIncluded(configId)) {
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); } }
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); } }
final FeaturePackSpec currentSpec = currentOrigin.getSpec(); if (currentSpec.hasDefinedConfigs()) { for (ConfigModel config : currentSpec.getDefinedConfigs()) {
throw new ProvisioningDescriptionException("Feature-pack " + getFPID() + " package spec name " + pkgBuilder.spec.getName() + " does not match the requested package name " + pkgName); rt.processPackageDeps(pkgBuilder.spec, pkgBuilder); } catch(UnsatisfiedPackageDependencyException e) { throw new UnsatisfiedPackageDependencyException(getFPID(), pkgName, e); } catch(ProvisioningException e) { throw new ProvisioningException(Errors.resolvePackage(getFPID(), pkgName), e); } finally { rt.setOrigin(currentOrigin);
if(fpConfigStack.isPackageExcluded(currentOrigin.producer, dep.getName())) { if(!dep.isOptional()) { throw new UnsatisfiedPackageDependencyException(currentOrigin.getFPID(), dep.getName()); if (fpConfigStack.isPackageExcluded(currentOrigin.producer, dep.getName())) { if (!dep.isOptional()) { throw new UnsatisfiedPackageDependencyException(currentOrigin.getFPID(), dep.getName());