@Override public String getName() { return id.getName(); }
public boolean isConfigModelExcluded(ConfigId configId) { final Boolean namedOnly = excludedModels.get(configId.getModel()); if(namedOnly == null) { return false; } return namedOnly ? configId.getName() != null : true; }
List<ProvisionedConfig> getResolvedConfigs() throws ProvisioningException { final int configsTotal = configsToBuild.size(); if(configsTotal == 0) { return Collections.emptyList(); } List<ProvisionedConfig> configList = new ArrayList<>(configsTotal); for(Map.Entry<ConfigId, ConfigModelStack> entry : configsToBuild.entrySet()) { final ConfigId id = entry.getKey(); if(id.getName() == null || contains(configList, id)) { continue; } orderConfig(entry.getValue(), configList, Collections.emptySet()); } return configList.size() > 0 ? Collections.unmodifiableList(configList) : configList; }
@Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append(location.toString()); if (!layers.isEmpty()) { builder.append(" layers[ "); for (ConfigId l : layers) { builder.append(l.getModel()).append("/").append(l.getName()).append(" "); } builder.append("]"); } return builder.toString(); } }
public static Path getConfigXml(Path fpDir, ConfigId configId, boolean existing) throws ProvisioningDescriptionException { final String model = configId.getModel(); final String name = configId.getName(); final Path p; if(name == null) { if(model == null) { throw new ProvisioningDescriptionException("Anonymous configs are included in feature-pack.xml"); } p = fpDir.resolve(Constants.CONFIGS).resolve(model).resolve(Constants.MODEL_XML); } else if(model == null) { p = fpDir.resolve(Constants.CONFIGS).resolve(name).resolve(Constants.CONFIG_XML); } else { p = fpDir.resolve(Constants.CONFIGS).resolve(model).resolve(name).resolve(Constants.CONFIG_XML); } if(existing && !Files.exists(p)) { throw new ProvisioningDescriptionException("Failed to locate XML file describing configuration " + configId + " at " + p); } return p; }
private ConfigModelStack getConfigStack(ConfigId id) throws ProvisioningException { if(id.getName() == null) { throw new IllegalStateException("Config model not associated with a name"); configStack = nameOnlyConfigs.get(id.getName()); if(configStack == null) { configStack = new ConfigModelStack(id, this); nameOnlyConfigs = CollectionUtils.putLinked(nameOnlyConfigs, id.getName(), configStack); if(namedConfigs == null) { configStack = new ConfigModelStack(id, this); namedConfigs = Collections.singletonMap(id.getName(), configStack); namedModelConfigs = CollectionUtils.putLinked(namedModelConfigs, id.getModel(), namedConfigs); return configStack; configStack = namedConfigs.get(id.getName()); if(configStack != null) { return configStack; namedConfigs.put(id.getName(), configStack); return configStack;
ConfigLayerSpec getConfigLayer(ConfigId configId) throws ProvisioningException { if(layers != null) { final ConfigLayerSpec layer = layers.get(configId); if(layer != null) { return layer; } } final Path p = LayoutUtils.getLayerSpecXml(dir, configId.getModel(), configId.getName(), false); if (!Files.exists(p)) { return null; } final ConfigLayerSpec layer = XmlParsers.parseConfigLayerSpec(p, configId.getModel()); if (layers == null) { layers = new HashMap<>(); } layers.put(configId, layer); return layer; }
private static Map<String, Map<String, Set<String>>> getAllLayers(ProvisioningLayout<FeaturePackLayout> pLayout, boolean includeDependencies) throws ProvisioningException, IOException { Map<String, Map<String, Set<String>>> layersMap = new HashMap<>(); for (FeaturePackLayout fp : pLayout.getOrderedFeaturePacks()) { for (ConfigId layer : fp.loadLayers()) { String model = layer.getModel(); Map<String, Set<String>> names = layersMap.get(model); if (names == null) { names = new HashMap<>(); layersMap.put(model, names); } Set<String> dependencies = new TreeSet<>(); if (includeDependencies) { ConfigLayerSpec spec = fp.loadConfigLayerSpec(model, layer.getName()); for (ConfigLayerDependency dep : spec.getLayerDeps()) { dependencies.add(dep.getName()); } } names.put(layer.getName(), dependencies); } } return layersMap; }
@Override public String toString() { final StringBuilder buf = new StringBuilder(); buf.append("[model=").append(id.getModel()).append(" name=").append(id.getName()); if(origin != null) { buf.append(" origin=").append(origin);
public List<ResolvedFeature> orderFeatures(ConfigModelStack stack) throws ProvisioningException { this.specFeatures = stack.specFeatures; this.features = stack.features; try { doOrder(stack.rt); } catch (ProvisioningException e) { throw new ProvisioningException(Errors.failedToBuildConfigSpec(stack.id.getModel(), stack.id.getName()), e); } return orderedFeatures; }
doOrder(configStack.rt); } catch (ProvisioningException e) { throw new ProvisioningException(Errors.failedToBuildConfigSpec(configStack.id.getModel(), configStack.id.getName()), e);
@Override protected List<String> getItems(PmCompleterInvocation completerInvocation) { try { List<String> configs = new ArrayList<>(); AbstractProvisionedDefaultConfigCommand cmd = (AbstractProvisionedDefaultConfigCommand) completerInvocation.getCommand(); FeaturePackConfig fp = cmd.getProvisionedFP(completerInvocation.getPmSession()); if (fp == null) { // We want them all from all FP for (FeaturePackConfig fc : completerInvocation.getPmSession().getState().getConfig().getFeaturePackDeps()) { for (ConfigId cid : cmd.getTargetedConfigs(fc)) { String name = cid.getModel() + PathParser.PATH_SEPARATOR + cid.getName(); if (!configs.contains(name)) { configs.add(name); } } } } else { for (ConfigId cid : cmd.getTargetedConfigs(fp)) { String name = cid.getModel() + PathParser.PATH_SEPARATOR + cid.getName(); if (!configs.contains(name)) { configs.add(name); } } } return configs; } catch (Exception ex) { CliLogging.completionException(ex); return Collections.emptyList(); } }
final ConfigModelStack configStack; if (depId.getModel() == null) { configStack = nameOnlyConfigs.get(depId.getName()); } else { final Map<String, ConfigModelStack> configs = namedModelConfigs.get(depId.getModel()); throw new ProvisioningDescriptionException("Config " + config.id + " has unsatisfied dependency on config " + depId); configStack = configs.get(depId.getName());
public FeaturePackBuilder addConfig(ConfigModel config, boolean asDefault) throws ProvisioningDescriptionException { final ConfigId id = config.getId(); if(id.isAnonymous()) { throw new ProvisioningDescriptionException("Feature-pack " + fpBuilder.getFPID() + ": attempt to add an anonymous config"); } if(asDefault && id.isModelOnly()) { throw new ProvisioningDescriptionException("Feature-pack " + fpBuilder.getFPID() + ": model-only config can not be added as the default one"); } if (configs.isEmpty()) { configs = new HashMap<>(); } if (configs.put(id, config) != null) { throw new ProvisioningDescriptionException("Feature-pack " + fpBuilder.getFPID() + ": duplicate config " + id); } if(asDefault) { fpBuilder.addConfig(ConfigModel.builder(id.getModel(), id.getName()).build()); } return this; }
if (cm.getName().equals(id.getName()) && cm.getModel().equals(id.getModel())) { targetConfig = cm.getBuilder(); exclude = getExistingFeature(cm, feature.getFeatureId()) == null; targetConfig = ConfigModel.builder(id.getModel(), id.getName()); newConfig = true; targetConfig.excludeFeature(feature.getFeatureId());
addAttribute(propE, Attribute.MODEL, layerId.getModel()); addAttribute(propE, Attribute.NAME, layerId.getName());
ConfigId id = configs.get(0); model = id.getModel(); config = id.getName();
private void includeLayer(ConfigModelStack configStack, ConfigId layerId) throws ProvisioningException { if(!configStack.addLayer(layerId)) { return; } final ConfigModelStack layerStack = resolveConfigLayer(layerId); if(layerStack.hasLayerDeps()) { for(ConfigLayerDependency layerDep : layerStack.getLayerDeps()) { if(configStack.isLayerExcluded(layerDep.getName())) { if(layerDep.isOptional()) { continue; } throw new ProvisioningException(Errors.unsatisfiedLayerDependency(layerId.getName(), layerDep.getName())); } includeLayer(configStack, new ConfigId(configStack.id.getModel(), layerDep.getName())); } } configStack.includedLayer(layerId); for(ResolvedFeature feature : layerStack.orderFeatures(false)) { if(configStack.isFilteredOut(feature.getSpecId(), feature.getId())) { continue; } configStack.includeFeature(feature.id, feature.spec, feature.params, feature.deps); } }