301 lines
11 KiB
Python
301 lines
11 KiB
Python
|
# Copyright 2014 Amazon.com, Inc. or its affiliates. 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. A copy of
|
||
|
|
# the License is located at
|
||
|
|
#
|
||
|
|
# http://aws.amazon.com/apache2.0/
|
||
|
|
#
|
||
|
|
# or in the "license" file accompanying this file. This file 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.
|
||
|
|
|
||
|
|
import jmespath
|
||
|
|
from botocore import xform_name
|
||
|
|
|
||
|
|
from .params import get_data_member
|
||
|
|
|
||
|
|
|
||
|
|
def all_not_none(iterable):
|
||
|
|
"""
|
||
|
|
Return True if all elements of the iterable are not None (or if the
|
||
|
|
iterable is empty). This is like the built-in ``all``, except checks
|
||
|
|
against None, so 0 and False are allowable values.
|
||
|
|
"""
|
||
|
|
for element in iterable:
|
||
|
|
if element is None:
|
||
|
|
return False
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def build_identifiers(identifiers, parent, params=None, raw_response=None):
|
||
|
|
"""
|
||
|
|
Builds a mapping of identifier names to values based on the
|
||
|
|
identifier source location, type, and target. Identifier
|
||
|
|
values may be scalars or lists depending on the source type
|
||
|
|
and location.
|
||
|
|
|
||
|
|
:type identifiers: list
|
||
|
|
:param identifiers: List of :py:class:`~boto3.resources.model.Parameter`
|
||
|
|
definitions
|
||
|
|
:type parent: ServiceResource
|
||
|
|
:param parent: The resource instance to which this action is attached.
|
||
|
|
:type params: dict
|
||
|
|
:param params: Request parameters sent to the service.
|
||
|
|
:type raw_response: dict
|
||
|
|
:param raw_response: Low-level operation response.
|
||
|
|
:rtype: list
|
||
|
|
:return: An ordered list of ``(name, value)`` identifier tuples.
|
||
|
|
"""
|
||
|
|
results = []
|
||
|
|
|
||
|
|
for identifier in identifiers:
|
||
|
|
source = identifier.source
|
||
|
|
target = identifier.target
|
||
|
|
|
||
|
|
if source == 'response':
|
||
|
|
value = jmespath.search(identifier.path, raw_response)
|
||
|
|
elif source == 'requestParameter':
|
||
|
|
value = jmespath.search(identifier.path, params)
|
||
|
|
elif source == 'identifier':
|
||
|
|
value = getattr(parent, xform_name(identifier.name))
|
||
|
|
elif source == 'data':
|
||
|
|
# If this is a data member then it may incur a load
|
||
|
|
# action before returning the value.
|
||
|
|
value = get_data_member(parent, identifier.path)
|
||
|
|
elif source == 'input':
|
||
|
|
# This value is set by the user, so ignore it here
|
||
|
|
continue
|
||
|
|
else:
|
||
|
|
raise NotImplementedError(
|
||
|
|
'Unsupported source type: {0}'.format(source))
|
||
|
|
|
||
|
|
results.append((xform_name(target), value))
|
||
|
|
|
||
|
|
return results
|
||
|
|
|
||
|
|
|
||
|
|
def build_empty_response(search_path, operation_name, service_model):
|
||
|
|
"""
|
||
|
|
Creates an appropriate empty response for the type that is expected,
|
||
|
|
based on the service model's shape type. For example, a value that
|
||
|
|
is normally a list would then return an empty list. A structure would
|
||
|
|
return an empty dict, and a number would return None.
|
||
|
|
|
||
|
|
:type search_path: string
|
||
|
|
:param search_path: JMESPath expression to search in the response
|
||
|
|
:type operation_name: string
|
||
|
|
:param operation_name: Name of the underlying service operation.
|
||
|
|
:type service_model: :ref:`botocore.model.ServiceModel`
|
||
|
|
:param service_model: The Botocore service model
|
||
|
|
:rtype: dict, list, or None
|
||
|
|
:return: An appropriate empty value
|
||
|
|
"""
|
||
|
|
response = None
|
||
|
|
|
||
|
|
operation_model = service_model.operation_model(operation_name)
|
||
|
|
shape = operation_model.output_shape
|
||
|
|
|
||
|
|
if search_path:
|
||
|
|
# Walk the search path and find the final shape. For example, given
|
||
|
|
# a path of ``foo.bar[0].baz``, we first find the shape for ``foo``,
|
||
|
|
# then the shape for ``bar`` (ignoring the indexing), and finally
|
||
|
|
# the shape for ``baz``.
|
||
|
|
for item in search_path.split('.'):
|
||
|
|
item = item.strip('[0123456789]$')
|
||
|
|
|
||
|
|
if shape.type_name == 'structure':
|
||
|
|
shape = shape.members[item]
|
||
|
|
elif shape.type_name == 'list':
|
||
|
|
shape = shape.member
|
||
|
|
else:
|
||
|
|
raise NotImplementedError(
|
||
|
|
'Search path hits shape type {0} from {1}'.format(
|
||
|
|
shape.type_name, item))
|
||
|
|
|
||
|
|
# Anything not handled here is set to None
|
||
|
|
if shape.type_name == 'structure':
|
||
|
|
response = {}
|
||
|
|
elif shape.type_name == 'list':
|
||
|
|
response = []
|
||
|
|
elif shape.type_name == 'map':
|
||
|
|
response = {}
|
||
|
|
|
||
|
|
return response
|
||
|
|
|
||
|
|
|
||
|
|
class RawHandler(object):
|
||
|
|
"""
|
||
|
|
A raw action response handler. This passed through the response
|
||
|
|
dictionary, optionally after performing a JMESPath search if one
|
||
|
|
has been defined for the action.
|
||
|
|
|
||
|
|
:type search_path: string
|
||
|
|
:param search_path: JMESPath expression to search in the response
|
||
|
|
:rtype: dict
|
||
|
|
:return: Service response
|
||
|
|
"""
|
||
|
|
def __init__(self, search_path):
|
||
|
|
self.search_path = search_path
|
||
|
|
|
||
|
|
def __call__(self, parent, params, response):
|
||
|
|
"""
|
||
|
|
:type parent: ServiceResource
|
||
|
|
:param parent: The resource instance to which this action is attached.
|
||
|
|
:type params: dict
|
||
|
|
:param params: Request parameters sent to the service.
|
||
|
|
:type response: dict
|
||
|
|
:param response: Low-level operation response.
|
||
|
|
"""
|
||
|
|
# TODO: Remove the '$' check after JMESPath supports it
|
||
|
|
if self.search_path and self.search_path != '$':
|
||
|
|
response = jmespath.search(self.search_path, response)
|
||
|
|
|
||
|
|
return response
|
||
|
|
|
||
|
|
|
||
|
|
class ResourceHandler(object):
|
||
|
|
"""
|
||
|
|
Creates a new resource or list of new resources from the low-level
|
||
|
|
response based on the given response resource definition.
|
||
|
|
|
||
|
|
:type search_path: string
|
||
|
|
:param search_path: JMESPath expression to search in the response
|
||
|
|
|
||
|
|
:type factory: ResourceFactory
|
||
|
|
:param factory: The factory that created the resource class to which
|
||
|
|
this action is attached.
|
||
|
|
|
||
|
|
:type resource_model: :py:class:`~boto3.resources.model.ResponseResource`
|
||
|
|
:param resource_model: Response resource model.
|
||
|
|
|
||
|
|
:type service_context: :py:class:`~boto3.utils.ServiceContext`
|
||
|
|
:param service_context: Context about the AWS service
|
||
|
|
|
||
|
|
:type operation_name: string
|
||
|
|
:param operation_name: Name of the underlying service operation, if it
|
||
|
|
exists.
|
||
|
|
|
||
|
|
:rtype: ServiceResource or list
|
||
|
|
:return: New resource instance(s).
|
||
|
|
"""
|
||
|
|
def __init__(self, search_path, factory, resource_model,
|
||
|
|
service_context, operation_name=None):
|
||
|
|
self.search_path = search_path
|
||
|
|
self.factory = factory
|
||
|
|
self.resource_model = resource_model
|
||
|
|
self.operation_name = operation_name
|
||
|
|
self.service_context = service_context
|
||
|
|
|
||
|
|
def __call__(self, parent, params, response):
|
||
|
|
"""
|
||
|
|
:type parent: ServiceResource
|
||
|
|
:param parent: The resource instance to which this action is attached.
|
||
|
|
:type params: dict
|
||
|
|
:param params: Request parameters sent to the service.
|
||
|
|
:type response: dict
|
||
|
|
:param response: Low-level operation response.
|
||
|
|
"""
|
||
|
|
resource_name = self.resource_model.type
|
||
|
|
json_definition = self.service_context.resource_json_definitions.get(
|
||
|
|
resource_name)
|
||
|
|
|
||
|
|
# Load the new resource class that will result from this action.
|
||
|
|
resource_cls = self.factory.load_from_definition(
|
||
|
|
resource_name=resource_name,
|
||
|
|
single_resource_json_definition=json_definition,
|
||
|
|
service_context=self.service_context
|
||
|
|
)
|
||
|
|
raw_response = response
|
||
|
|
search_response = None
|
||
|
|
|
||
|
|
# Anytime a path is defined, it means the response contains the
|
||
|
|
# resource's attributes, so resource_data gets set here. It
|
||
|
|
# eventually ends up in resource.meta.data, which is where
|
||
|
|
# the attribute properties look for data.
|
||
|
|
if self.search_path:
|
||
|
|
search_response = jmespath.search(self.search_path, raw_response)
|
||
|
|
|
||
|
|
# First, we parse all the identifiers, then create the individual
|
||
|
|
# response resources using them. Any identifiers that are lists
|
||
|
|
# will have one item consumed from the front of the list for each
|
||
|
|
# resource that is instantiated. Items which are not a list will
|
||
|
|
# be set as the same value on each new resource instance.
|
||
|
|
identifiers = dict(build_identifiers(
|
||
|
|
self.resource_model.identifiers, parent, params,
|
||
|
|
raw_response))
|
||
|
|
|
||
|
|
# If any of the identifiers is a list, then the response is plural
|
||
|
|
plural = [v for v in identifiers.values() if isinstance(v, list)]
|
||
|
|
|
||
|
|
if plural:
|
||
|
|
response = []
|
||
|
|
|
||
|
|
# The number of items in an identifier that is a list will
|
||
|
|
# determine how many resource instances to create.
|
||
|
|
for i in range(len(plural[0])):
|
||
|
|
# Response item data is *only* available if a search path
|
||
|
|
# was given. This prevents accidentally loading unrelated
|
||
|
|
# data that may be in the response.
|
||
|
|
response_item = None
|
||
|
|
if search_response:
|
||
|
|
response_item = search_response[i]
|
||
|
|
response.append(
|
||
|
|
self.handle_response_item(resource_cls, parent,
|
||
|
|
identifiers, response_item))
|
||
|
|
elif all_not_none(identifiers.values()):
|
||
|
|
# All identifiers must always exist, otherwise the resource
|
||
|
|
# cannot be instantiated.
|
||
|
|
response = self.handle_response_item(
|
||
|
|
resource_cls, parent, identifiers, search_response)
|
||
|
|
else:
|
||
|
|
# The response should be empty, but that may mean an
|
||
|
|
# empty dict, list, or None based on whether we make
|
||
|
|
# a remote service call and what shape it is expected
|
||
|
|
# to return.
|
||
|
|
response = None
|
||
|
|
if self.operation_name is not None:
|
||
|
|
# A remote service call was made, so try and determine
|
||
|
|
# its shape.
|
||
|
|
response = build_empty_response(
|
||
|
|
self.search_path, self.operation_name,
|
||
|
|
self.service_context.service_model)
|
||
|
|
|
||
|
|
return response
|
||
|
|
|
||
|
|
def handle_response_item(self, resource_cls, parent, identifiers,
|
||
|
|
resource_data):
|
||
|
|
"""
|
||
|
|
Handles the creation of a single response item by setting
|
||
|
|
parameters and creating the appropriate resource instance.
|
||
|
|
|
||
|
|
:type resource_cls: ServiceResource subclass
|
||
|
|
:param resource_cls: The resource class to instantiate.
|
||
|
|
:type parent: ServiceResource
|
||
|
|
:param parent: The resource instance to which this action is attached.
|
||
|
|
:type identifiers: dict
|
||
|
|
:param identifiers: Map of identifier names to value or values.
|
||
|
|
:type resource_data: dict or None
|
||
|
|
:param resource_data: Data for resource attributes.
|
||
|
|
:rtype: ServiceResource
|
||
|
|
:return: New resource instance.
|
||
|
|
"""
|
||
|
|
kwargs = {
|
||
|
|
'client': parent.meta.client,
|
||
|
|
}
|
||
|
|
|
||
|
|
for name, value in identifiers.items():
|
||
|
|
# If value is a list, then consume the next item
|
||
|
|
if isinstance(value, list):
|
||
|
|
value = value.pop(0)
|
||
|
|
|
||
|
|
kwargs[name] = value
|
||
|
|
|
||
|
|
resource = resource_cls(**kwargs)
|
||
|
|
|
||
|
|
if resource_data is not None:
|
||
|
|
resource.meta.data = resource_data
|
||
|
|
|
||
|
|
return resource
|