Java tutorial
// Copyright 2015 The Bazel Authors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.devtools.common.options; import com.google.common.base.Joiner; import com.google.common.base.Verify; import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Multimap; import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.AllowValues; import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.DisallowValues; import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.FlagPolicy; import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.FlagPolicy.OperationCase; import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.InvocationPolicy; import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.SetValue; import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.UseDefault; import com.google.devtools.common.options.OptionPriority.PriorityCategory; import com.google.devtools.common.options.OptionsParser.OptionDescription; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.logging.Level; import java.util.logging.Logger; import java.util.stream.Collectors; import javax.annotation.Nullable; /** * Enforces the {@link FlagPolicy}s (from an {@link InvocationPolicy} proto) on an {@link * OptionsParser} by validating and changing the flag values in the given {@link OptionsParser}. * * <p>"Flag" and "Option" are used interchangeably in this file. */ public final class InvocationPolicyEnforcer { private static final Logger logger = Logger.getLogger(InvocationPolicyEnforcer.class.getName()); private static final String INVOCATION_POLICY_SOURCE = "Invocation policy"; @Nullable private final InvocationPolicy invocationPolicy; private final Level loglevel; /** * Creates an InvocationPolicyEnforcer that enforces the given policy. * * @param invocationPolicy the policy to enforce. A null policy means this enforcer will do * nothing in calls to enforce(). */ public InvocationPolicyEnforcer(@Nullable InvocationPolicy invocationPolicy) { this(invocationPolicy, Level.FINE); } /** * Creates an InvocationPolicyEnforcer that enforces the given policy. * * @param invocationPolicy the policy to enforce. A null policy means this enforcer will do * nothing in calls to enforce(). * @param loglevel the level at which to log informational statements. Warnings and errors will * still be logged at the appropriate level. */ public InvocationPolicyEnforcer(@Nullable InvocationPolicy invocationPolicy, Level loglevel) { this.invocationPolicy = invocationPolicy; this.loglevel = loglevel; } private static final class FlagPolicyWithContext { private final FlagPolicy policy; private final OptionDescription description; private final OptionInstanceOrigin origin; public FlagPolicyWithContext(FlagPolicy policy, OptionDescription description, OptionInstanceOrigin origin) { this.policy = policy; this.description = description; this.origin = origin; } } public InvocationPolicy getInvocationPolicy() { return invocationPolicy; } /** * Applies this OptionsPolicyEnforcer's policy to the given OptionsParser for all blaze commands. * * @param parser The OptionsParser to enforce policy on. * @throws OptionsParsingException if any flag policy is invalid. */ public void enforce(OptionsParser parser) throws OptionsParsingException { enforce(parser, null); } /** * Applies this OptionsPolicyEnforcer's policy to the given OptionsParser. * * @param parser The OptionsParser to enforce policy on. * @param command The current blaze command, for flag policies that apply to only specific * commands. Such policies will be enforced only if they contain this command or a command * they inherit from * @throws OptionsParsingException if any flag policy is invalid. */ public void enforce(OptionsParser parser, @Nullable String command) throws OptionsParsingException { if (invocationPolicy == null || invocationPolicy.getFlagPoliciesCount() == 0) { return; } // The effective policy returned is expanded, filtered for applicable commands, and cleaned of // redundancies and conflicts. List<FlagPolicyWithContext> effectivePolicies = getEffectivePolicies(invocationPolicy, parser, command, loglevel); for (FlagPolicyWithContext flagPolicy : effectivePolicies) { String flagName = flagPolicy.policy.getFlagName(); OptionValueDescription valueDescription; try { valueDescription = parser.getOptionValueDescription(flagName); } catch (IllegalArgumentException e) { // This flag doesn't exist. We are deliberately lenient if the flag policy has a flag // we don't know about. This is for better future proofing so that as new flags are added, // new policies can use the new flags without worrying about older versions of Bazel. logger.log(loglevel, String.format("Flag '%s' specified by invocation policy does not exist", flagName)); continue; } // getOptionDescription() will return null if the option does not exist, however // getOptionValueDescription() above would have thrown an IllegalArgumentException if that // were the case. Verify.verifyNotNull(flagPolicy.description); switch (flagPolicy.policy.getOperationCase()) { case SET_VALUE: applySetValueOperation(parser, flagPolicy, valueDescription, loglevel); break; case USE_DEFAULT: applyUseDefaultOperation(parser, "UseDefault", flagPolicy.description.getOptionDefinition(), loglevel); break; case ALLOW_VALUES: AllowValues allowValues = flagPolicy.policy.getAllowValues(); FilterValueOperation.AllowValueOperation allowValueOperation = new FilterValueOperation.AllowValueOperation( loglevel); allowValueOperation.apply(parser, flagPolicy.origin, allowValues.getAllowedValuesList(), allowValues.hasNewValue() ? allowValues.getNewValue() : null, allowValues.hasUseDefault(), valueDescription, flagPolicy.description); break; case DISALLOW_VALUES: DisallowValues disallowValues = flagPolicy.policy.getDisallowValues(); FilterValueOperation.DisallowValueOperation disallowValueOperation = new FilterValueOperation.DisallowValueOperation( loglevel); disallowValueOperation.apply(parser, flagPolicy.origin, disallowValues.getDisallowedValuesList(), disallowValues.hasNewValue() ? disallowValues.getNewValue() : null, disallowValues.hasUseDefault(), valueDescription, flagPolicy.description); break; case OPERATION_NOT_SET: throw new PolicyOperationNotSetException(flagName); default: logger.warning(String.format("Unknown operation '%s' from invocation policy for flag '%s'", flagPolicy.policy.getOperationCase(), flagName)); break; } } } private static class PolicyOperationNotSetException extends OptionsParsingException { PolicyOperationNotSetException(String flagName) { super(String.format("Flag policy for flag '%s' does not " + "have an operation", flagName)); } } private static boolean policyApplies(FlagPolicy policy, ImmutableSet<String> applicableCommands) { // Skip the flag policy if it doesn't apply to this command. If the commands list is empty, // then the policy applies to all commands. if (policy.getCommandsList().isEmpty() || applicableCommands.isEmpty()) { return true; } return !Collections.disjoint(policy.getCommandsList(), applicableCommands); } /** Returns the expanded and filtered policy that would be enforced for the given command. */ public static InvocationPolicy getEffectiveInvocationPolicy(InvocationPolicy invocationPolicy, OptionsParser parser, String command, Level loglevel) throws OptionsParsingException { ImmutableList<FlagPolicyWithContext> effectivePolicies = getEffectivePolicies(invocationPolicy, parser, command, loglevel); InvocationPolicy.Builder builder = InvocationPolicy.newBuilder(); for (FlagPolicyWithContext policyWithContext : effectivePolicies) { builder.addFlagPolicies(policyWithContext.policy); } return builder.build(); } /** * Takes the provided policy and processes it to the form that can be used on the user options. * * <p>Expands any policies on expansion flags. */ private static ImmutableList<FlagPolicyWithContext> getEffectivePolicies(InvocationPolicy invocationPolicy, OptionsParser parser, String command, Level loglevel) throws OptionsParsingException { if (invocationPolicy == null) { return ImmutableList.of(); } ImmutableSet<String> commandAndParentCommands = command == null ? ImmutableSet.of() : CommandNameCache.CommandNameCacheInstance.INSTANCE.get(command); // Expand all policies to transfer policies on expansion flags to policies on the child flags. List<FlagPolicyWithContext> expandedPolicies = new ArrayList<>(); OptionPriority nextPriority = OptionPriority .lowestOptionPriorityAtCategory(PriorityCategory.INVOCATION_POLICY); for (FlagPolicy policy : invocationPolicy.getFlagPoliciesList()) { // These policies are high-level, before expansion, and so are not the implicitDependents or // expansions of any other flag, other than in an obtuse sense from --invocation_policy. OptionPriority currentPriority = nextPriority; OptionInstanceOrigin origin = new OptionInstanceOrigin(currentPriority, INVOCATION_POLICY_SOURCE, null, null); nextPriority = OptionPriority.nextOptionPriority(currentPriority); if (!policyApplies(policy, commandAndParentCommands)) { // Only keep and expand policies that are applicable to the current command. continue; } OptionDescription optionDescription = parser.getOptionDescription(policy.getFlagName()); if (optionDescription == null) { // InvocationPolicy ignores policy on non-existing flags by design, for version // compatibility. logger.log(loglevel, String.format( "Flag '%s' specified by invocation policy does not exist, and will be ignored", policy.getFlagName())); continue; } FlagPolicyWithContext policyWithContext = new FlagPolicyWithContext(policy, optionDescription, origin); List<FlagPolicyWithContext> policies = expandPolicy(policyWithContext, parser, loglevel); expandedPolicies.addAll(policies); } // Only keep that last policy for each flag. Map<String, FlagPolicyWithContext> effectivePolicy = new HashMap<>(); for (FlagPolicyWithContext expandedPolicy : expandedPolicies) { String flagName = expandedPolicy.policy.getFlagName(); effectivePolicy.put(flagName, expandedPolicy); } return ImmutableList.copyOf(effectivePolicy.values()); } private static void throwAllowValuesOnExpansionFlagException(String flagName) throws OptionsParsingException { throw new OptionsParsingException( String.format("Allow_Values on expansion flags like %s is not allowed.", flagName)); } private static void throwDisallowValuesOnExpansionFlagException(String flagName) throws OptionsParsingException { throw new OptionsParsingException( String.format("Disallow_Values on expansion flags like %s is not allowed.", flagName)); } /** * Expand a single policy. If the policy is not about an expansion flag, this will simply return a * list with a single element, oneself. If the policy is for an expansion flag, the policy will * get split into multiple policies applying to each flag the original flag expands to. * * <p>None of the flagPolicies returned should be on expansion flags. */ private static List<FlagPolicyWithContext> expandPolicy(FlagPolicyWithContext originalPolicy, OptionsParser parser, Level loglevel) throws OptionsParsingException { List<FlagPolicyWithContext> expandedPolicies = new ArrayList<>(); boolean isExpansion = originalPolicy.description.isExpansion(); ImmutableList<ParsedOptionDescription> subflags = parser.getExpansionValueDescriptions( originalPolicy.description.getOptionDefinition(), originalPolicy.origin); // If we have nothing to expand to, no need to do any further work. if (subflags.isEmpty()) { return ImmutableList.of(originalPolicy); } if (logger.isLoggable(loglevel)) { // Log the expansion. This is only really useful for understanding the invocation policy // itself. List<String> subflagNames = new ArrayList<>(subflags.size()); for (ParsedOptionDescription subflag : subflags) { subflagNames.add("--" + subflag.getOptionDefinition().getOptionName()); } logger.logp(loglevel, "InvocationPolicyEnforcer", "expandPolicy", String.format("Expanding %s on option %s to its %s: %s.", originalPolicy.policy.getOperationCase(), originalPolicy.policy.getFlagName(), isExpansion ? "expansions" : "implied flags", Joiner.on("; ").join(subflagNames))); } // Repeated flags are special, and could set multiple times in an expansion, with the user // expecting both values to be valid. Collect these separately. Multimap<OptionDescription, ParsedOptionDescription> repeatableSubflagsInSetValues = ArrayListMultimap .create(); // Create a flag policy for the child that looks like the parent's policy "transferred" to its // child. Note that this only makes sense for SetValue, when setting an expansion flag, or // UseDefault, when preventing it from being set. for (ParsedOptionDescription currentSubflag : subflags) { OptionDescription subflagOptionDescription = parser .getOptionDescription(currentSubflag.getOptionDefinition().getOptionName()); if (currentSubflag.getOptionDefinition().allowsMultiple() && originalPolicy.policy.getOperationCase().equals(OperationCase.SET_VALUE)) { repeatableSubflagsInSetValues.put(subflagOptionDescription, currentSubflag); } else { FlagPolicyWithContext subflagAsPolicy = getSingleValueSubflagAsPolicy(subflagOptionDescription, currentSubflag, originalPolicy, isExpansion); // In case any of the expanded flags are themselves expansions, recurse. expandedPolicies.addAll(expandPolicy(subflagAsPolicy, parser, loglevel)); } } // If there are any repeatable flag SetValues, deal with them together now. // Note that expansion flags have no value, and so cannot have multiple values either. // Skipping the recursion above is fine. for (OptionDescription repeatableFlag : repeatableSubflagsInSetValues.keySet()) { int numValues = repeatableSubflagsInSetValues.get(repeatableFlag).size(); ArrayList<String> newValues = new ArrayList<>(numValues); ArrayList<OptionInstanceOrigin> origins = new ArrayList<>(numValues); for (ParsedOptionDescription setValue : repeatableSubflagsInSetValues.get(repeatableFlag)) { newValues.add(setValue.getUnconvertedValue()); origins.add(setValue.getOrigin()); } // These options come from expanding a single policy, so they have effectively the same // priority. They could have come from different expansions or implicit requirements in the // recursive resolving of the option list, so just pick the first one. Do collapse the source // strings though, in case there are different sources. OptionInstanceOrigin arbitraryFirstOptionOrigin = origins.get(0); OptionInstanceOrigin originOfSubflags = new OptionInstanceOrigin( arbitraryFirstOptionOrigin.getPriority(), origins.stream().map(OptionInstanceOrigin::getSource).distinct() .collect(Collectors.joining(", ")), arbitraryFirstOptionOrigin.getImplicitDependent(), arbitraryFirstOptionOrigin.getExpandedFrom()); expandedPolicies .add(getSetValueSubflagAsPolicy(repeatableFlag, newValues, originOfSubflags, originalPolicy)); } // Don't add the original policy if it was an expansion flag, which have no value, but do add // it if there was either no expansion or if it was a valued flag with implicit requirements. if (!isExpansion) { expandedPolicies.add(originalPolicy); } return expandedPolicies; } /** * Expand a SetValue flag policy on a repeatable flag. SetValue operations are the only flag * policies that set the flag, and so interact with repeatable flags, flags that can be set * multiple times, in subtle ways. * * @param subflagDesc, the description of the flag the SetValue'd expansion flag expands to. * @param subflagValue, the values that the SetValue'd expansion flag expands to for this flag. * @param originalPolicy, the original policy on the expansion flag. * @return the flag policy for the subflag given, this will be part of the expanded form of the * SetValue policy on the original flag. */ private static FlagPolicyWithContext getSetValueSubflagAsPolicy(OptionDescription subflagDesc, List<String> subflagValue, OptionInstanceOrigin subflagOrigin, FlagPolicyWithContext originalPolicy) { // Some sanity checks. OptionDefinition subflag = subflagDesc.getOptionDefinition(); Verify.verify(originalPolicy.policy.getOperationCase().equals(OperationCase.SET_VALUE)); if (!subflag.allowsMultiple()) { Verify.verify(subflagValue.size() <= 1); } // Flag value from the expansion, overridability from the original policy, unless the flag is // repeatable, in which case we care about appendability, not overridability. SetValue.Builder setValueExpansion = SetValue.newBuilder(); for (String value : subflagValue) { setValueExpansion.addFlagValue(value); } if (subflag.allowsMultiple()) { setValueExpansion.setAppend(originalPolicy.policy.getSetValue().getOverridable()); } else { setValueExpansion.setOverridable(originalPolicy.policy.getSetValue().getOverridable()); } // Commands from the original policy, flag name of the expansion return new FlagPolicyWithContext( FlagPolicy.newBuilder().addAllCommands(originalPolicy.policy.getCommandsList()) .setFlagName(subflag.getOptionName()).setSetValue(setValueExpansion).build(), subflagDesc, subflagOrigin); } /** * For an expansion flag in an invocation policy, each flag it expands to must be given a * corresponding policy. */ private static FlagPolicyWithContext getSingleValueSubflagAsPolicy(OptionDescription subflagContext, ParsedOptionDescription currentSubflag, FlagPolicyWithContext originalPolicy, boolean isExpansion) throws OptionsParsingException { FlagPolicyWithContext subflagAsPolicy = null; switch (originalPolicy.policy.getOperationCase()) { case SET_VALUE: if (currentSubflag.getOptionDefinition().allowsMultiple()) { throw new AssertionError( "SetValue subflags with allowMultiple should have been dealt with separately and " + "accumulated into a single FlagPolicy."); } // Accept null originalValueStrings, they are expected when the subflag is also an expansion // flag. List<String> subflagValue; if (currentSubflag.getUnconvertedValue() == null) { subflagValue = ImmutableList.of(); } else { subflagValue = ImmutableList.of(currentSubflag.getUnconvertedValue()); } subflagAsPolicy = getSetValueSubflagAsPolicy(subflagContext, subflagValue, currentSubflag.getOrigin(), originalPolicy); break; case USE_DEFAULT: // Commands from the original policy, flag name of the expansion subflagAsPolicy = new FlagPolicyWithContext( FlagPolicy.newBuilder().addAllCommands(originalPolicy.policy.getCommandsList()) .setFlagName(currentSubflag.getOptionDefinition().getOptionName()) .setUseDefault(UseDefault.getDefaultInstance()).build(), subflagContext, currentSubflag.getOrigin()); break; case ALLOW_VALUES: if (isExpansion) { throwAllowValuesOnExpansionFlagException(originalPolicy.policy.getFlagName()); } // If this flag is an implicitRequirement, and some values for the parent flag are // allowed, nothing needs to happen on the implicitRequirement that is set for all // values of the flag. break; case DISALLOW_VALUES: if (isExpansion) { throwDisallowValuesOnExpansionFlagException(originalPolicy.policy.getFlagName()); } // If this flag is an implicitRequirement, and some values for the parent flag are // disallowed, that implies that all others are allowed, so nothing needs to happen // on the implicitRequirement that is set for all values of the parent flag. break; case OPERATION_NOT_SET: throw new PolicyOperationNotSetException(originalPolicy.policy.getFlagName()); default: return null; } return subflagAsPolicy; } private static void logInApplySetValueOperation(Level loglevel, String formattingString, Object... objects) { // Finding the caller here is relatively expensive and shows up in profiling, so provide it // manually. logger.logp(loglevel, "InvocationPolicyEnforcer", "applySetValueOperation", String.format(formattingString, objects)); } private static void applySetValueOperation(OptionsParser parser, FlagPolicyWithContext flagPolicy, OptionValueDescription valueDescription, Level loglevel) throws OptionsParsingException { SetValue setValue = flagPolicy.policy.getSetValue(); OptionDefinition optionDefinition = flagPolicy.description.getOptionDefinition(); // SetValue.flag_value must have at least 1 value. if (setValue.getFlagValueCount() == 0) { throw new OptionsParsingException(String.format( "SetValue operation from invocation policy for %s does not have a value", optionDefinition)); } // Flag must allow multiple values if multiple values are specified by the policy. if (setValue.getFlagValueCount() > 1 && !flagPolicy.description.getOptionDefinition().allowsMultiple()) { throw new OptionsParsingException( String.format("SetValue operation from invocation policy sets multiple values for %s which " + "does not allow multiple values", optionDefinition)); } if (setValue.getOverridable() && valueDescription != null) { // The user set the value for the flag but the flag policy is overridable, so keep the user's // value. logInApplySetValueOperation(loglevel, "Keeping value '%s' from source '%s' for %s because the invocation policy specifying " + "the value(s) '%s' is overridable", valueDescription.getValue(), valueDescription.getSourceString(), optionDefinition, setValue.getFlagValueList()); } else { if (!setValue.getAppend()) { // Clear the value in case the flag is a repeated flag so that values don't accumulate. parser.clearValue(flagPolicy.description.getOptionDefinition()); } // Set all the flag values from the policy. for (String flagValue : setValue.getFlagValueList()) { if (valueDescription == null) { logInApplySetValueOperation(loglevel, "Setting value for %s from invocation policy to '%s', overriding the default value " + "'%s'", optionDefinition, flagValue, optionDefinition.getDefaultValue()); } else { logInApplySetValueOperation(loglevel, "Setting value for %s from invocation policy to '%s', overriding value '%s' from " + "'%s'", optionDefinition, flagValue, valueDescription.getValue(), valueDescription.getSourceString()); } parser.addOptionValueAtSpecificPriority(flagPolicy.origin, optionDefinition, flagValue); } } } private static void applyUseDefaultOperation(OptionsParser parser, String policyType, OptionDefinition option, Level loglevel) throws OptionsParsingException { OptionValueDescription clearedValueDescription = parser.clearValue(option); if (clearedValueDescription != null) { // Log the removed value. String clearedFlagName = clearedValueDescription.getOptionDefinition().getOptionName(); Object clearedFlagDefaultValue = clearedValueDescription.getOptionDefinition().getDefaultValue(); logger.log(loglevel, String.format( "Using default value '%s' for flag '%s' as specified by %s invocation policy, " + "overriding original value '%s' from '%s'", clearedFlagDefaultValue, clearedFlagName, policyType, clearedValueDescription.getValue(), clearedValueDescription.getSourceString())); } } /** Checks the user's flag values against a filtering function. */ private abstract static class FilterValueOperation { private static final class AllowValueOperation extends FilterValueOperation { AllowValueOperation(Level loglevel) { super("Allow", loglevel); } @Override boolean isFlagValueAllowed(Set<Object> convertedPolicyValues, Object value) { return convertedPolicyValues.contains(value); } } private static final class DisallowValueOperation extends FilterValueOperation { DisallowValueOperation(Level loglevel) { super("Disalllow", loglevel); } @Override boolean isFlagValueAllowed(Set<Object> convertedPolicyValues, Object value) { // In a disallow operation, the values that the flag policy specifies are not allowed, // so the value is allowed if the set of policy values does not contain the current // flag value. return !convertedPolicyValues.contains(value); } } private final String policyType; private final Level loglevel; FilterValueOperation(String policyType, Level loglevel) { this.policyType = policyType; this.loglevel = loglevel; } /** * Determines if the given value is allowed. * * @param convertedPolicyValues The values given from the FlagPolicy, converted to real objects. * @param value The user value of the flag. * @return True if the value should be allowed, false if it should not. */ abstract boolean isFlagValueAllowed(Set<Object> convertedPolicyValues, Object value); void apply(OptionsParser parser, OptionInstanceOrigin origin, List<String> policyValues, String newValue, boolean useDefault, OptionValueDescription valueDescription, OptionDescription optionDescription) throws OptionsParsingException { OptionDefinition optionDefinition = optionDescription.getOptionDefinition(); // Convert all the allowed values from strings to real objects using the options' // converters so that they can be checked for equality using real .equals() instead // of string comparison. For example, "--foo=0", "--foo=false", "--nofoo", and "-f-" // (if the option has an abbreviation) are all equal for boolean flags. Plus converters // can be arbitrarily complex. Set<Object> convertedPolicyValues = new HashSet<>(); for (String value : policyValues) { Object convertedValue = optionDefinition.getConverter().convert(value); // Some converters return lists, and if the flag is a repeatable flag, the items in the // list from the converter should be added, and not the list itself. Otherwise the items // from invocation policy will be compared to lists, which will never work. // See OptionsParserImpl.ParsedOptionEntry.addValue. if (optionDefinition.allowsMultiple() && convertedValue instanceof List<?>) { convertedPolicyValues.addAll((List<?>) convertedValue); } else { convertedPolicyValues.add(optionDefinition.getConverter().convert(value)); } } // Check that if the default value of the flag is disallowed by the policy, that the policy // does not also set use_default. Otherwise the default value would will still be set if the // user uses a disallowed value. This doesn't apply to repeatable flags since the default // value for repeatable flags is always the empty list. if (!optionDescription.getOptionDefinition().allowsMultiple()) { boolean defaultValueAllowed = isFlagValueAllowed(convertedPolicyValues, optionDescription.getOptionDefinition().getDefaultValue()); if (!defaultValueAllowed && useDefault) { throw new OptionsParsingException(String.format( "%sValues policy disallows the default value '%s' for %s but also specifies to " + "use the default value", policyType, optionDefinition.getDefaultValue(), optionDefinition)); } } if (valueDescription == null) { // Nothing has set the value yet, so check that the default value from the flag's // definition is allowed. The else case below (i.e. valueDescription is not null) checks for // the flag allowing multiple values, however, flags that allow multiple values cannot have // default values, and their value is always the empty list if they haven't been specified, // which is why new_default_value is not a repeated field. checkDefaultValue(parser, origin, optionDescription, policyValues, newValue, convertedPolicyValues); } else { checkUserValue(parser, origin, optionDescription, valueDescription, policyValues, newValue, useDefault, convertedPolicyValues); } } void checkDefaultValue(OptionsParser parser, OptionInstanceOrigin origin, OptionDescription optionDescription, List<String> policyValues, String newValue, Set<Object> convertedPolicyValues) throws OptionsParsingException { OptionDefinition optionDefinition = optionDescription.getOptionDefinition(); if (!isFlagValueAllowed(convertedPolicyValues, optionDescription.getOptionDefinition().getDefaultValue())) { if (newValue != null) { // Use the default value from the policy, since the original default is not allowed logger.log(loglevel, String.format( "Overriding default value '%s' for %s with value '%s' specified by invocation " + "policy. %sed values are: %s", optionDefinition.getDefaultValue(), optionDefinition, newValue, policyType, policyValues)); parser.clearValue(optionDefinition); parser.addOptionValueAtSpecificPriority(origin, optionDefinition, newValue); } else { // The operation disallows the default value, but doesn't supply a new value. throw new OptionsParsingException(String.format( "Default flag value '%s' for %s is not allowed by invocation policy, but " + "the policy does not provide a new value. %sed values are: %s", optionDescription.getOptionDefinition().getDefaultValue(), optionDefinition, policyType, policyValues)); } } } void checkUserValue(OptionsParser parser, OptionInstanceOrigin origin, OptionDescription optionDescription, OptionValueDescription valueDescription, List<String> policyValues, String newValue, boolean useDefault, Set<Object> convertedPolicyValues) throws OptionsParsingException { OptionDefinition option = optionDescription.getOptionDefinition(); if (optionDescription.getOptionDefinition().allowsMultiple()) { // allowMultiple requires that the type of the option be List<T>, so cast from Object // to List<?>. List<?> optionValues = (List<?>) valueDescription.getValue(); for (Object value : optionValues) { if (!isFlagValueAllowed(convertedPolicyValues, value)) { if (useDefault) { applyUseDefaultOperation(parser, policyType + "Values", option, loglevel); } else { throw new OptionsParsingException(String.format( "Flag value '%s' for %s is not allowed by invocation policy. %sed values " + "are: %s", value, option, policyType, policyValues)); } } } } else { if (!isFlagValueAllowed(convertedPolicyValues, valueDescription.getValue())) { if (newValue != null) { logger.log(loglevel, String.format( "Overriding disallowed value '%s' for %s with value '%s' " + "specified by invocation policy. %sed values are: %s", valueDescription.getValue(), option, newValue, policyType, policyValues)); parser.clearValue(option); parser.addOptionValueAtSpecificPriority(origin, option, newValue); } else if (useDefault) { applyUseDefaultOperation(parser, policyType + "Values", option, loglevel); } else { throw new OptionsParsingException(String.format( "Flag value '%s' for %s is not allowed by invocation policy and the " + "policy does not specify a new value. %sed values are: %s", valueDescription.getValue(), option, policyType, policyValues)); } } } } } }