def IPV4Argument(value):
"""Argparse argument type that checks for a valid ipv4 address."""
if not IsValidIPV4(value):
raise arg_parsers.ArgumentTypeError(
"invalid ipv4 value: '{0}'".format(value))
return value
def _ParseDayOfWeek(value):
value_upper = value.upper()
if value_upper not in visible_choices_set:
raise arg_parsers.ArgumentTypeError(
'{value} must be one of [{choices}]'.format(
value=value, choices=', '.join(visible_choices)))
return day_of_week_enum.lookup_by_name(value_upper)
def ValidateAndStandarizeBucketUriOrRaise(bucket):
"""Checks if a bucket uri provided by user is valid.
If the Bucket uri is valid, converts it to a standard form.
Args:
bucket: Bucket uri provided by user.
Returns:
Sanitized bucket uri.
Raises:
ArgumentTypeError: If the name provided by user is not valid.
"""
if _BUCKET_RESOURCE_URI_RE.match(bucket):
bucket_ref = storage_util.BucketReference.FromBucketUrl(bucket)
else:
try:
bucket_ref = storage_util.BucketReference.FromArgument(
bucket, require_prefix=False)
except argparse.ArgumentTypeError as e:
raise arg_parsers.ArgumentTypeError(
"Invalid value '{}': {}".format(bucket, e))
# strip any extrenuous '/' and append single '/'
bucket = bucket_ref.ToBucketUrl().rstrip('/') + '/'
return bucket
def _Parse(value):
value = six.text_type(value.lower())
if value not in valid_choices:
raise arg_parsers.ArgumentTypeError(
'[type] must be one of [{0}]'.format(
','.join(valid_choices)))
return value
def _Parse(value):
value = six.text_type(value.lower())
if value not in _AUTOSCALING_MODES:
raise arg_parsers.ArgumentTypeError(
'[mode] must be one of [{0}]'.format(
','.join(_AUTOSCALING_MODES)))
return value
def Run(self, args):
"""Retrieves information about a backup.
Args:
args: argparse.Namespace, The arguments that this command was invoked
with.
Returns:
A dict object that has the backup run resource if the command ran
successfully.
Raises:
HttpException: A http error response was received while executing api
request.
ToolException: An error other than http error occured while executing the
command.
"""
validate.ValidateInstanceName(args.instance)
try:
# Check if ID is an integer.
# TODO(b/21877717): Remove this try clause after deprecation period when
# re-adding validation above.
id_integer = int(args.id)
except ValueError:
try:
# If input is not an integer, check if it is a datetime.
datetime = arg_parsers.Datetime.Parse(args.id)
except arg_parsers.ArgumentTypeError:
# If user input is not integer or datetime, throw error.
raise arg_parsers.ArgumentTypeError('ID must be an integer.')
return self._GetByDatetime(datetime, args)
return self._GetById(id_integer, args)
def ParseFutureDatetime(s):
"""Parses a string value into a future Datetime object."""
dt = arg_parsers.Datetime.Parse(s)
if dt < times.Now():
raise arg_parsers.ArgumentTypeError(
'Date/time must be in the future: {0}'.format(s))
return dt
def ParseDirectory(directory):
"""Checks if a source directory provided by user is valid.
Args:
directory: Path do directory provided by user.
Returns:
Path to directory.
Raises:
ArgumentTypeError: If the directory provided by user is not valid.
"""
if not os.path.exists(directory):
raise arg_parsers.ArgumentTypeError(
'Provided directory does not exist.')
if not os.path.isdir(directory):
raise arg_parsers.ArgumentTypeError(
'Provided path does not point to a directory.')
return directory
def __call__(self, file_path):
map_file_dict = yaml.load_path(file_path)
map_dict = {}
for key, value in map_file_dict.items():
if self.key_type:
try:
key = self.key_type(key)
except ValueError:
raise arg_parsers.ArgumentTypeError('Invalid key [{0}]'.format(key))
if self.value_type:
try:
value = self.value_type(value)
except ValueError:
raise arg_parsers.ArgumentTypeError(
'Invalid value [{0}]'.format(value))
map_dict[key] = value
return map_dict
def _InitialDelayValidator(value):
duration_parser = arg_parsers.Duration(parsed_unit='s')
parsed_value = duration_parser(value)
if parsed_value > _MAX_INITIAL_DELAY_DURATION:
raise arg_parsers.ArgumentTypeError(
'The value of initial delay must be between 0 and {max_value}'.
format(max_value=_MAX_INITIAL_DELAY_DURATION_HUMAN_READABLE))
return parsed_value
def testParserException(self):
for arg_value in {'', '123', '21,2', 'uninstalled', 'purged', '^F&^%'}:
self.Run(
None,
arg_value,
exception=arg_parsers.ArgumentTypeError((
'Invalid value [{}] from field [package-state], expected one of '
'[installed, removed].').format(arg_value)))
def testParserException(self):
for arg_value in {'', '123', '21,2', 'trace', '^F&^%'}:
self.Run(
None,
arg_value,
exception=arg_parsers.ArgumentTypeError(
('Invalid value [{}] from field [type], expected one of '
'[logging, metrics, ops-agent].').format(arg_value)))
def _ParseTimeOfDay(value):
m = re.match(r'^(\d?\d):00$', value)
if m:
hour = int(m.group(1))
if hour <= 23 and hour >= 0:
return alloydb_messages.GoogleTypeTimeOfDay(hours=hour)
raise arg_parsers.ArgumentTypeError(
'Failed to parse time of day: {0}, expected format: HH:00.'.format(
value))
def _ValidateArgumentByRegexOrRaise(argument, regex, error_message):
if isinstance(regex, str):
match = re.match(regex, argument)
else:
match = regex.match(argument)
if not match:
raise arg_parsers.ArgumentTypeError("Invalid value '{0}': {1}".format(
argument, error_message))
return argument
def RealmValidator(realm):
"""Validates that the realm argument is a supported RealmValueValuesEnum."""
messages = api_util.GetMessages()
try:
realm = realm.upper()
messages.RealmConfig.RealmValueValuesEnum(realm)
except TypeError:
raise arg_parsers.ArgumentTypeError(
'invalid realm {}, must be one of:{}'.format(
realm, GetFormattedSupportedEnums()))
return realm
def CheckValidEnumNames(api_names, choices_values):
"""Ensures the api_name given in the spec matches a value from the API."""
if api_names:
bad_choices = [name for name in choices_values if not (
name in api_names or ChoiceToEnumName(
six.text_type(name)) in api_names)]
else:
bad_choices = []
if bad_choices:
raise arg_parsers.ArgumentTypeError(
'{} is/are not valid enum values.'.format(', '.join(bad_choices)))
def __call__(self, file_path):
map_file_dict = yaml.load_path(file_path)
map_dict = {}
if not yaml.dict_like(map_file_dict):
raise arg_parsers.ArgumentTypeError(
'Invalid YAML/JSON data in [{}], expected map-like data.'.
format(file_path))
for key, value in map_file_dict.items():
if self.key_type:
try:
key = self.key_type(key)
except ValueError:
raise arg_parsers.ArgumentTypeError(
'Invalid key [{0}]'.format(key))
if self.value_type:
try:
value = self.value_type(value)
except ValueError:
raise arg_parsers.ArgumentTypeError(
'Invalid value [{0}]'.format(value))
map_dict[key] = value
return map_dict
def ChoiceToEnum(choice, enum_type, item_type='choice', valid_choices=None):
"""Converts the typed choice into an apitools Enum value."""
if choice is None:
return None
name = ChoiceToEnumName(choice)
valid_choices = (valid_choices or
[EnumNameToChoice(n) for n in enum_type.names()])
try:
return enum_type.lookup_by_name(name)
except KeyError:
raise arg_parsers.ArgumentTypeError(
'Invalid {item}: {selection}. Valid choices are: [{values}].'.format(
item=item_type,
selection=EnumNameToChoice(name),
values=', '.join(c for c in sorted(valid_choices))))
def ChoiceToEnum(choice, enum_type, valid_choices=None):
# type: (str, enum.Enum, list) -> enum.Enum
"""Converts the typed choice into an apitools Enum value."""
if choice is None:
return None
name = choice.replace('-', '_').upper()
valid_choices = (valid_choices
or [EnumNameToChoice(n) for n in enum_type.names()])
try:
return enum_type.lookup_by_name(name)
except KeyError:
raise arg_parsers.ArgumentTypeError(
'Invalid choice: {}. Valid choices are: [{}].'.format(
EnumNameToChoice(name),
', '.join(c for c in sorted(valid_choices))))
def ParseDirectoryOrCloudRepoPath(directory_or_cloud_repo_path):
"""Checks if a source directory or cloud repo path provided by user is valid.
Args:
directory_or_cloud_repo_path: A string: a local path do directory provided
by user, or a path to a Cloud Repository.
Returns:
The argument provided, if found valid.
Raises:
ArgumentTypeError: If the user provided a directory which is not valid.
"""
if IsCloudRepoPath(directory_or_cloud_repo_path):
return directory_or_cloud_repo_path
directory = directory_or_cloud_repo_path
if not os.path.exists(directory):
raise arg_parsers.ArgumentTypeError(
'Provided directory does not exist. If you intended to provide a path '
'to Google Cloud Repository, it must start with "{0}"'.format(
_CLOUD_REPO_PREFIX))
if not os.path.isdir(directory):
raise arg_parsers.ArgumentTypeError(
'Provided path does not point to a directory.')
return directory
def AspectRatioType(value):
"""A type function to be used to parse aspect ratios."""
try:
return float(value)
except ValueError:
parts = value.split(':')
if len(parts) == 2:
try:
return float(parts[0]) / float(parts[1])
except ValueError:
pass
raise arg_parsers.ArgumentTypeError(
'Each aspect ratio must either be specified as a decimal (ex. 1.333) '
'or as a ratio of width to height (ex 4:3)')
def ParseFunctionName(name):
"""Checks if a function name provided by user is valid.
Args:
name: Function name provided by user.
Returns:
Function name.
Raises:
ArgumentTypeError: If the name provided by user is not valid.
"""
match = _FUNCTION_NAME_RE.match(name)
if not match:
raise arg_parsers.ArgumentTypeError(
'Function name must match [{0}]'.format(_FUNCTION_NAME_RE.pattern))
return name
def ParseEntryPointName(entry_point):
"""Checks if a entry point name provided by user is valid.
Args:
entry_point: Entry point name provided by user.
Returns:
Entry point name.
Raises:
ArgumentTypeError: If the entry point name provided by user is not valid.
"""
match = _ENTRY_POINT_NAME_RE.match(entry_point)
if not match:
raise arg_parsers.ArgumentTypeError(
'Entry point name must match [{0}]'.format(
_ENTRY_POINT_NAME_RE.pattern))
return entry_point
def ParsePubsubTopicName(topic):
"""Checks if a Pub/Sub topic name provided by user is valid.
Args:
topic: Pub/Sub topic name provided by user.
Returns:
Topic name.
Raises:
ArgumentTypeError: If the name provided by user is not valid.
"""
match = _TOPIC_NAME_RE.match(topic)
if not match:
raise arg_parsers.ArgumentTypeError('Topic must match [{0}]'.format(
_TOPIC_NAME_RE.pattern))
project = properties.VALUES.core.project.Get(required=True)
return 'projects/{0}/topics/{1}'.format(project, topic)
def RoutingPolicyDataArgType(routing_policy_data_value):
"""Converts --routing-policy-data flag value to a list of policy data items.
Args:
routing_policy_data_value: String value specified in the
--routing-policy-data flag.
Returns:
A list of policy data items in the format below:
[
{ 'key': <routing_policy_data_key1>, 'rrdatas': <IP address list> },
{ 'key': <routing_policy_data_key2>, 'rrdatas': <IP address list> },
...
]
Where <routing_policy_data_key> is either a weight or location name,
depending on whether the user specified --routing-policy-type == WRR or
--routing-policy-type == GEO, respectively. We keep
<routing_policy_data_key> a string value, even in the case of weights
(which will eventually be interpereted as floats). This is to keep this
flag type generic between WRR and GEO types.
"""
routing_policy_data = []
# Grab each policy data item, split by ';'
policy_items = routing_policy_data_value.split(';')
for policy_item in policy_items:
# Grab key and value from policy_item, split by ':'
key_value_split = policy_item.split('=')
# Ensure that there is only one key and value from the string split on ':'
if len(key_value_split) != 2:
raise arg_parsers.ArgumentTypeError(
'Must specify exactly one "=" inside each policy data item'
)
key = key_value_split[0]
value = key_value_split[1]
# Grab list of IPs from value, split by ','
ip_list = value.split(',')
routing_policy_data.append({'key': key, 'rrdatas': ip_list})
return routing_policy_data
def __call__(self, arg_value):
"""Interpret the arg value as an item from an allowed value list.
Args:
arg_value: str.
The value of the user input argument.
Raises:
arg_parsers.ArgumentTypeError.
If the arg value is not one of the allowed values.
Returns:
The value of the arg.
"""
str_value = str(arg_value)
if str_value not in self._allowed_values:
raise arg_parsers.ArgumentTypeError(
'Invalid value [{0}] from field [{1}], expected one of [{2}].'.format(
arg_value, self._field_name, ', '.join(self._allowed_values)))
return str_value
def ParseBucketUri(bucket):
"""Checks if a bucket uri provided by user is valid.
Args:
bucket: Bucket uri provided by user.
Returns:
Sanitized bucket uri.
Raises:
ArgumentTypeError: If the name provided by user is not valid.
"""
if not bucket.endswith('/'):
bucket += '/'
if not bucket.startswith('gs://'):
bucket = 'gs://' + bucket
match = _BUCKET_URI_RE.match(bucket)
if not match:
raise arg_parsers.ArgumentTypeError('Bucket must match [{0}]'.format(
_BUCKET_URI_RE.pattern))
return bucket
def EnvVarKeyType(key):
"""Validates environment variable keys.
Args:
key: The environment variable key.
Returns:
The environment variable key.
Raises:
ArgumentTypeError: If the key is not a valid environment variable key.
"""
env_var_key_validator = arg_parsers.RegexpValidator(
r'^[a-zA-Z_][a-zA-Z0-9_]*$',
'Environment variable keys should only consist of alphanumeric '
'characters and underscores. The first character cannot be a digit.')
env_var_key_validator(key)
if key.startswith('X_GOOGLE_'):
raise arg_parsers.ArgumentTypeError(
'Environment variable keys that start with `X_GOOGLE_` are reserved '
'for use by deployment tools and cannot be specified manually.')
return key
def _ValidateAcceleratorCount(accelerator_count):
count = int(accelerator_count)
if count <= 0:
raise arg_parsers.ArgumentTypeError(
'The count of the accelerator must be greater than 0.')
return count
def ValidateV1TimeoutFlag(args):
if args.timeout and args.timeout > 540:
raise arg_parsers.ArgumentTypeError(
'--timeout: value must be less than or equal to 540s; received: {}s'
.format(args.timeout))
