158 lines
4.9 KiB
Python
158 lines
4.9 KiB
Python
# -*- coding: utf-8 -*- #
|
|
# Copyright 2018 Google LLC. 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.
|
|
"""Common command line processing utilities for access context manager."""
|
|
|
|
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import unicode_literals
|
|
|
|
import re
|
|
|
|
from apitools.base.py import encoding
|
|
from googlecloudsdk.api_lib.util import waiter
|
|
from googlecloudsdk.calliope import base
|
|
from googlecloudsdk.core import exceptions
|
|
from googlecloudsdk.core import yaml
|
|
import six
|
|
|
|
|
|
class ParseFileError(exceptions.Error):
|
|
"""Error raised when a file could not be parsed."""
|
|
|
|
def __init__(self, path, reason):
|
|
"""Initializes a ParseFileError.
|
|
|
|
Args:
|
|
path: The path of the file that could not be parsed.
|
|
reason: The reason the file could not be parsed.
|
|
"""
|
|
super(ParseFileError, self).__init__(
|
|
'Issue parsing file [{}]: {}'.format(path, reason)
|
|
)
|
|
|
|
|
|
class InvalidMessageParseError(ParseFileError):
|
|
"""Error raised when a message could not be parsed from a YAML file."""
|
|
|
|
def __init__(self, path, reason, message_class, pluralize_error):
|
|
"""Initializes an InvalidMessageParseError.
|
|
|
|
Args:
|
|
path: The path of the file that could not be parsed.
|
|
reason: The reason the file could not be parsed.
|
|
message_class: The message class that could not be parsed.
|
|
pluralize_error: Whether the error meessage is pluralized.
|
|
"""
|
|
|
|
valid_fields = [f.name for f in message_class.all_fields()]
|
|
|
|
super(InvalidMessageParseError, self).__init__(
|
|
path,
|
|
(
|
|
'The YAML-compliant file provided contains errors: '
|
|
'{}\n\n'
|
|
'The {} in this file can contain the fields'
|
|
' [{}].'
|
|
).format(
|
|
reason,
|
|
'objects' if pluralize_error else 'object',
|
|
', '.join(valid_fields),
|
|
),
|
|
)
|
|
|
|
|
|
def ParseAccessContextManagerMessagesFromYaml(path, message_class, is_list):
|
|
"""Parse a YAML representation of a message(s).
|
|
|
|
Args:
|
|
path: str, path to YAML file containing data to parse
|
|
message_class: obj, message type to parse the contents of the yaml file to
|
|
is_list: bool, whether the file contains a list of messages or a single
|
|
message
|
|
|
|
Returns:
|
|
list of message object(s).
|
|
|
|
Raises:
|
|
ParseFileError: if the file could not be read into the proper object(s)
|
|
"""
|
|
|
|
data = yaml.load_path(path)
|
|
if not data:
|
|
raise ParseFileError(path, 'File is empty')
|
|
try:
|
|
if is_list:
|
|
messages = [encoding.DictToMessage(c, message_class) for c in data]
|
|
else:
|
|
messages = [encoding.DictToMessage(data, message_class)]
|
|
except Exception as err:
|
|
raise InvalidMessageParseError(
|
|
path, six.text_type(err), message_class, is_list
|
|
)
|
|
|
|
return messages
|
|
|
|
|
|
class ParseResponseError(exceptions.Error):
|
|
|
|
def __init__(self, reason):
|
|
super(ParseResponseError,
|
|
self).__init__('Issue parsing response: {}'.format(reason))
|
|
|
|
|
|
def GetDescriptionArg(noun):
|
|
return base.Argument(
|
|
'--description',
|
|
help='Long-form description of {}.'.format(noun),
|
|
)
|
|
|
|
|
|
def GetTitleArg(noun):
|
|
return base.Argument(
|
|
'--title',
|
|
help='Short human-readable title of the {}.'.format(noun),
|
|
)
|
|
|
|
|
|
class BulkAPIOperationPoller(waiter.CloudOperationPoller):
|
|
"""A Poller used by the Bulk API.
|
|
|
|
Polls ACM Operations endpoint then calls LIST instead of GET.
|
|
|
|
Attributes:
|
|
policy_number: The Access Policy ID that the Poller needs in order to call
|
|
LIST.
|
|
"""
|
|
|
|
def __init__(self, result_service, operation_service, operation_ref):
|
|
super(BulkAPIOperationPoller, self).__init__(result_service,
|
|
operation_service)
|
|
|
|
# Because policy id *could be* looked up automatically based on the set
|
|
# organization id config, policy might not be present in command line
|
|
# argument or set properties. We have to reply on the response to know what
|
|
# it is for sure.
|
|
policy_id = re.search(r'^accessPolicies/\d+', operation_ref.Name())
|
|
if policy_id:
|
|
self.policy_number = policy_id.group()
|
|
else:
|
|
raise ParseResponseError('Could not determine Access Policy ID from '
|
|
'operation response.')
|
|
|
|
def GetResult(self, operation):
|
|
del operation # Unused by BulkAPIOperationPoller.
|
|
request_type = self.result_service.GetRequestType('List')
|
|
return self.result_service.List(request_type(parent=self.policy_number))
|