public String getOptionValue(ProvisioningOption option) throws ProvisioningException { final String setValue = options.get(option.getName()); if(setValue == null) { if(option.isRequired() && (!options.containsKey(option.getName()) && option.getDefaultValue() == null)) { throw new ProvisioningException(Errors.pluginOptionRequired(option.getName())); } return option.getDefaultValue(); } if(!option.getValueSet().isEmpty() && !option.getValueSet().contains(setValue)) { throw new ProvisioningException(Errors.pluginOptionIllegalValue(option.getName(), setValue, option.getValueSet())); } return setValue; }
public ProvisioningOption build() { return new ProvisioningOption(this); } }
protected ProvisioningOption(String name) { this.name = name; required = false; persistent = true; defaultValue = null; valueSet = getBooleanValueSet(); }
private static String buildOptionsTable(Set<ProvisioningOption> options) { Table t = new Table(Headers.OPTION, Headers.REQUIRED, Headers.DEFAULT_VALUE); for (ProvisioningOption opt : options) { t.addLine("--" + opt.getName() + "=", opt.isRequired() ? "Y" : "N", opt.getDefaultValue() == null ? "" : opt.getDefaultValue()); } t.sort(Table.SortType.ASCENDANT); return t.build(); }
private void processOptions(Iterable<? extends ProvisioningOption> pluginOptions, Map<String, String> extraOptions, final Map<String, ProvisioningOption> recognizedOptions, final List<ProvisioningOption> overridenOptions) throws ProvisioningException { for(ProvisioningOption pluginOption : pluginOptions) { final String optionName = pluginOption.getName(); if(!options.containsKey(optionName)) { if(pluginOption.isRequired()) { throw new ProvisioningException(Errors.pluginOptionRequired(optionName)); } continue; } final ProvisioningOption existing = recognizedOptions.put(optionName, pluginOption); // options should probably not be shared between plugins but just in case make sure non-persistent option // doesn't override a persistent one if (existing != null && existing.isPersistent() && !pluginOption.isPersistent()) { recognizedOptions.put(existing.getName(), existing); } else if (pluginOption.isPersistent() || extraOptions.containsKey(optionName) && config.hasOption(optionName)) { overridenOptions.add(pluginOption); } } }
@Override protected List<AbstractDynamicCommand.DynamicOption> getDynamicOptions(State state) throws Exception { if (state == null) { return Collections.emptyList(); } List<AbstractDynamicCommand.DynamicOption> options = new ArrayList<>(); ProvisioningRuntime rt = state.getRuntime(); Set<ProvisioningOption> opts = getPluginOptions(rt); for (ProvisioningOption opt : opts) { AbstractDynamicCommand.DynamicOption dynOption = new AbstractDynamicCommand.DynamicOption(opt.getName(), opt.isRequired()); options.add(dynOption); } return options; }
processOptions(ProvisioningOption.getStandardList(), extraOptions, recognizedOptions, overridenOptions); final String optionName = option.getName(); if(!extraOptions.containsKey(optionName)) { continue; if(option.isPersistent()) { configBuilder.addOption(optionName, value); } else if (value == null) {
break; default: throw new ProvisioningDescriptionException(Errors.pluginOptionIllegalValue(ProvisioningOption.OPTIONAL_PACKAGES.getName(), optionalPackages, ProvisioningOption.OPTIONAL_PACKAGES.getValueSet()));
protected Set<ProvisioningOption> getPluginOptions(ProvisioningRuntime runtime) throws ProvisioningException { Set<ProvisioningOption> pluginOptions = new HashSet<>(ProvisioningOption.getStandardList()); FeaturePackPluginVisitor<InstallPlugin> visitor = new FeaturePackPluginVisitor<InstallPlugin>() { @Override public void visitPlugin(InstallPlugin plugin) throws ProvisioningException { pluginOptions.addAll(plugin.getOptions().values()); } }; runtime.getLayout().visitPlugins(visitor, InstallPlugin.class); return pluginOptions; }
public boolean isOptionSet(ProvisioningOption option) throws ProvisioningException { return layout.isOptionSet(option.getName()); }
@Override protected List<DynamicOption> getDynamicOptions(State state) throws Exception { List<DynamicOption> options = new ArrayList<>(); FeaturePackLocation fpl = pmSession.getResolvedLocation(getInstallationDirectory(pmSession.getAeshContext()), getId(pmSession)); Set<ProvisioningOption> pluginOptions = getPluginOptions(fpl); for (ProvisioningOption opt : pluginOptions) { DynamicOption dynOption = new DynamicOption(opt.getName(), opt.isRequired()); options.add(dynOption); } return options; }
public static ResolvedPlugins resolvePlugins(ProvisioningLayout<FeaturePackLayout> layout) throws ProvisioningException { final Set<ProvisioningOption> installOptions = new HashSet<>(ProvisioningOption.getStandardList()); final Set<ProvisioningOption> diffOptions = new HashSet<>(ProvisioningOption.getStandardList()); if (layout.hasPlugins()) { FeaturePackPluginVisitor<InstallPlugin> visitor = new FeaturePackPluginVisitor<InstallPlugin>() { @Override public void visitPlugin(InstallPlugin plugin) throws ProvisioningException { installOptions.addAll(plugin.getOptions().values()); } }; layout.visitPlugins(visitor, InstallPlugin.class); FeaturePackPluginVisitor<StateDiffPlugin> diffVisitor = new FeaturePackPluginVisitor<StateDiffPlugin>() { @Override public void visitPlugin(StateDiffPlugin plugin) throws ProvisioningException { diffOptions.addAll(plugin.getOptions().values()); } }; layout.visitPlugins(diffVisitor, StateDiffPlugin.class); } return new ResolvedPlugins(installOptions, diffOptions); }
@Override public Map<String, ProvisioningOption> getOptions() { if(pluginOptions == null) { final List<ProvisioningOption> options= initPluginOptions(); if(options.isEmpty()) { pluginOptions = Collections.emptyMap(); } else if(options.size() == 1) { final ProvisioningOption option = options.get(0); pluginOptions = Collections.singletonMap(option.getName(), option); } else { pluginOptions = new HashMap<>(options.size()); for(int i = 0; i < options.size(); ++i) { final ProvisioningOption option = options.get(i); pluginOptions.put(option.getName(), option); } } } return pluginOptions; }
public String getOptionValue(ProvisioningOption option, String defaultValue) throws ProvisioningException { final String value = layout.getOptionValue(option.getName()); if(value == null) { if(defaultValue != null) { return defaultValue; } defaultValue = option.getDefaultValue(); if(defaultValue != null) { return defaultValue; } if(option.isRequired()) { throw new ProvisioningException("Required plugin option " + option.getName() + " has not been provided"); } return null; } if(!option.getValueSet().isEmpty() && !option.getValueSet().contains(value)) { final StringBuilder buf = new StringBuilder(); buf.append("Plugin option ").append(option.getName()).append(" is set to ").append(value).append(" but expects one of "); StringUtils.append(buf, option.getValueSet()); throw new ProvisioningException(buf.toString()); } return value; }
@Override protected List<DynamicOption> getDynamicOptions(State state) throws Exception { List<DynamicOption> options = new ArrayList<>(); Set<ProvisioningOption> opts; String file = getFile(); if (file == null) { return Collections.emptyList(); } ProvisioningConfig config = ProvisioningXmlParser.parse(getAbsolutePath(file, pmSession.getAeshContext())); opts = pmSession.getResolver().get(null, PluginResolver.newResolver(pmSession, config)).getInstall(); for (ProvisioningOption opt : opts) { DynamicOption dynOption = new DynamicOption(opt.getName(), opt.isRequired()); options.add(dynOption); } return options; }
protected ProvisioningOption(Builder builder) { this.name = builder.name; this.required = builder.required; this.persistent = builder.persistent; this.defaultValue = builder.defaultValue; if(builder.valueSet.isEmpty()) { if(defaultValue == null || getBooleanValueSet().contains(defaultValue)) { this.valueSet = getBooleanValueSet(); } else { valueSet = Collections.emptySet(); } } else { if(defaultValue != null && !builder.valueSet.contains(defaultValue)) { throw new IllegalArgumentException("The default value " + defaultValue + " of provisioning option " + name + " is not in the allowed value set " + builder.valueSet); } this.valueSet = CollectionUtils.unmodifiable(builder.valueSet); } }
@Override protected List<DynamicOption> getDynamicOptions(State state) throws Exception { String targetDirArg = (String) getValue(DIR_OPTION_NAME); if (targetDirArg == null) { // Check in argument or option, that is the option completion case. targetDirArg = getOptionValue(DIR_OPTION_NAME); } Path installation = getAbsolutePath(targetDirArg, pmSession.getAeshContext()); ProvisioningConfig config = pmSession.newProvisioningManager(installation, false).getProvisioningConfig(); Set<ProvisioningOption> opts = pmSession.getResolver().get(null, PluginResolver.newResolver(pmSession, config)).getDiff(); List<DynamicOption> options = new ArrayList<>(); for (ProvisioningOption opt : opts) { DynamicOption dynOption = new DynamicOption(opt.getName(), opt.isRequired()); options.add(dynOption); } return options; }
List<DynamicOption> options = new ArrayList<>(); for (ProvisioningOption opt : opts) { DynamicOption dynOption = new DynamicOption(opt.getName(), opt.isRequired()); options.add(dynOption);