File size: 15,257 Bytes
065fee7 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 |
# 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 logging
from functools import partial
from .action import ServiceAction
from .action import WaiterAction
from .base import ResourceMeta, ServiceResource
from .collection import CollectionFactory
from .model import ResourceModel
from .response import build_identifiers, ResourceHandler
from ..exceptions import ResourceLoadException
logger = logging.getLogger(__name__)
class ResourceFactory(object):
"""
A factory to create new :py:class:`~boto3.resources.base.ServiceResource`
classes from a :py:class:`~boto3.resources.model.ResourceModel`. There are
two types of lookups that can be done: one on the service itself (e.g. an
SQS resource) and another on models contained within the service (e.g. an
SQS Queue resource).
"""
def __init__(self):
self._collection_factory = CollectionFactory()
def load_from_definition(self, service_name, resource_name, model,
resource_defs, service_model):
"""
Loads a resource from a model, creating a new
:py:class:`~boto3.resources.base.ServiceResource` subclass
with the correct properties and methods, named based on the service
and resource name, e.g. EC2.Instance.
:type service_name: string
:param service_name: Name of the service to look up
:type resource_name: string
:param resource_name: Name of the resource to look up. For services,
this should match the ``service_name``.
:type model: dict
:param model: The service or resource definition.
:type resource_defs: dict
:param resource_defs: The service's resource definitions, used to load
subresources (e.g. ``sqs.Queue``).
:type service_model: ``botocore.model.ServiceModel``
:param service_model: The Botocore service model, required only if the
resource shape contains members. This is used to
expose lazy-loaded attributes on the resource.
:rtype: Subclass of :py:class:`~boto3.resources.base.ServiceResource`
:return: The service or resource class.
"""
# Set some basic info
meta = ResourceMeta(service_name)
attrs = {
'meta': meta,
}
logger.debug('Loading %s:%s', service_name, resource_name)
resource_model = ResourceModel(resource_name, model, resource_defs)
shape = None
if resource_model.shape:
shape = service_model.shape_for(resource_model.shape)
resource_model.load_rename_map(shape)
self._load_identifiers(attrs, meta, resource_model)
self._load_actions(attrs, resource_model, resource_defs,
service_model)
self._load_attributes(attrs, meta, resource_model, service_model)
self._load_collections(attrs, resource_model, resource_defs,
service_model)
self._load_has_relations(attrs, service_name, resource_name,
resource_model, resource_defs, service_model)
self._load_waiters(attrs, resource_model)
# Create the name based on the requested service and resource
cls_name = resource_name
if service_name != resource_name:
cls_name = service_name + '.' + cls_name
return type(str(cls_name), (ServiceResource,), attrs)
def _load_identifiers(self, attrs, meta, model):
"""
Populate required identifiers. These are arguments without which
the resource cannot be used. Identifiers become arguments for
operations on the resource.
"""
for identifier in model.identifiers:
meta.identifiers.append(identifier.name)
attrs[identifier.name] = None
def _load_actions(self, attrs, model, resource_defs, service_model):
"""
Actions on the resource become methods, with the ``load`` method
being a special case which sets internal data for attributes, and
``reload`` is an alias for ``load``.
"""
if model.load:
attrs['load'] = self._create_action(
model.load, resource_defs, service_model, is_load=True)
attrs['reload'] = attrs['load']
for action in model.actions:
attrs[action.name] = self._create_action(action, resource_defs,
service_model)
def _load_attributes(self, attrs, meta, model, service_model):
"""
Load resource attributes based on the resource shape. The shape
name is referenced in the resource JSON, but the shape itself
is defined in the Botocore service JSON, hence the need for
access to the ``service_model``.
"""
if model.shape:
shape = service_model.shape_for(model.shape)
attributes = model.get_attributes(shape)
for name, (orig_name, member) in attributes.items():
attrs[name] = self._create_autoload_property(orig_name, name)
def _load_collections(self, attrs, model, resource_defs, service_model):
"""
Load resource collections from the model. Each collection becomes
a :py:class:`~boto3.resources.collection.CollectionManager` instance
on the resource instance, which allows you to iterate and filter
through the collection's items.
"""
for collection_model in model.collections:
attrs[collection_model.name] = self._create_collection(
attrs['meta'].service_name, model.name,
collection_model, resource_defs, service_model)
def _load_has_relations(self, attrs, service_name, resource_name,
model, resource_defs, service_model):
"""
Load related resources, which are defined via a ``has``
relationship but conceptually come in two forms:
1. A reference, which is a related resource instance and can be
``None``, such as an EC2 instance's ``vpc``.
2. A subresource, which is a resource constructor that will always
return a resource instance which shares identifiers/data with
this resource, such as ``s3.Bucket('name').Object('key')``.
"""
for reference in model.references:
# This is a dangling reference, i.e. we have all
# the data we need to create the resource, so
# this instance becomes an attribute on the class.
attrs[reference.name] = self._create_reference(
reference.resource.type, reference,
service_name, resource_name, model, resource_defs,
service_model)
for subresource in model.subresources:
# This is a sub-resource class you can create
# by passing in an identifier, e.g. s3.Bucket(name).
name = subresource.resource.type
attrs[subresource.name] = self._create_class_partial(
name, subresource, service_name, resource_name, model,
resource_defs, service_model)
def _load_waiters(self, attrs, model):
"""
Load resource waiters from the model. Each waiter allows you to
wait until a resource reaches a specific state by polling the state
of the resource.
"""
for waiter in model.waiters:
attrs[waiter.name] = self._create_waiter(waiter)
def _create_autoload_property(factory_self, name, snake_cased):
"""
Creates a new property on the resource to lazy-load its value
via the resource's ``load`` method (if it exists).
"""
# The property loader will check to see if this resource has already
# been loaded and return the cached value if possible. If not, then
# it first checks to see if it CAN be loaded (raise if not), then
# calls the load before returning the value.
def property_loader(self):
if self.meta.data is None:
if hasattr(self, 'load'):
self.load()
else:
raise ResourceLoadException(
'{0} has no load method'.format(self.__class__.__name__))
return self.meta.data.get(name)
property_loader.__name__ = str(snake_cased)
property_loader.__doc__ = 'TODO'
return property(property_loader)
def _create_waiter(factory_self, waiter_model):
"""
Creates a new wait method for each resource where both a waiter and
resource model is defined.
"""
waiter = WaiterAction(waiter_model,
waiter_resource_name=waiter_model.name)
def do_waiter(self, *args, **kwargs):
waiter(self, *args, **kwargs)
do_waiter.__name__ = str(waiter_model.name)
do_waiter.__doc__ = 'TODO'
return do_waiter
def _create_collection(factory_self, service_name, resource_name,
collection_model, resource_defs, service_model):
"""
Creates a new property on the resource to lazy-load a collection.
"""
cls = factory_self._collection_factory.load_from_definition(
service_name, resource_name, collection_model.name,
collection_model, resource_defs)
def get_collection(self):
return cls(collection_model, self, factory_self,
resource_defs, service_model)
get_collection.__name__ = str(collection_model.name)
get_collection.__doc__ = 'TODO'
return property(get_collection)
def _create_reference(factory_self, name, reference, service_name,
resource_name, model, resource_defs, service_model):
"""
Creates a new property on the resource to lazy-load a reference.
"""
# References are essentially an action with no request
# or response, so we can re-use the response handlers to
# build up resources from identifiers and data members.
handler = ResourceHandler(reference.resource.path, factory_self,
resource_defs, service_model,
reference.resource)
# Are there any identifiers that need access to data members?
# This is important when building the resource below since
# it requires the data to be loaded.
needs_data = any(i.source == 'data' for i in
reference.resource.identifiers)
def get_reference(self):
# We need to lazy-evaluate the reference to handle circular
# references between resources. We do this by loading the class
# when first accessed.
# This is using a *response handler* so we need to make sure
# our data is loaded (if possible) and pass that data into
# the handler as if it were a response. This allows references
# to have their data loaded properly.
if needs_data and self.meta.data is None and hasattr(self, 'load'):
self.load()
return handler(self, {}, self.meta.data)
get_reference.__name__ = str(reference.name)
get_reference.__doc__ = 'TODO'
return property(get_reference)
def _create_class_partial(factory_self, name, subresource,
service_name, resource_name, model,
resource_defs, service_model):
"""
Creates a new method which acts as a functools.partial, passing
along the instance's low-level `client` to the new resource
class' constructor.
"""
# We need a new method here because we want access to the
# instance's client.
def create_resource(self, *args, **kwargs):
positional_args = []
# We lazy-load the class to handle circular references.
resource_cls = factory_self.load_from_definition(
service_name, name, resource_defs.get(name, {}),
resource_defs, service_model)
# Assumes that identifiers are in order, which lets you do
# e.g. ``sqs.Queue('foo').Message('bar')`` to create a new message
# linked with the ``foo`` queue and which has a ``bar`` receipt
# handle. If we did kwargs here then future positional arguments
# would lead to failure.
identifiers = subresource.resource.identifiers
if identifiers is not None:
for identifier, value in build_identifiers(identifiers, self):
positional_args.append(value)
return partial(resource_cls, *positional_args,
client=self.meta.client)(*args, **kwargs)
create_resource.__name__ = str(name)
create_resource.__doc__ = 'TODO'
return create_resource
def _create_action(factory_self, action_model, resource_defs,
service_model, is_load=False):
"""
Creates a new method which makes a request to the underlying
AWS service.
"""
# Create the action in in this closure but before the ``do_action``
# method below is invoked, which allows instances of the resource
# to share the ServiceAction instance.
action = ServiceAction(action_model, factory=factory_self,
resource_defs=resource_defs, service_model=service_model)
# A resource's ``load`` method is special because it sets
# values on the resource instead of returning the response.
if is_load:
# We need a new method here because we want access to the
# instance via ``self``.
def do_action(self, *args, **kwargs):
response = action(self, *args, **kwargs)
self.meta.data = response
else:
# We need a new method here because we want access to the
# instance via ``self``.
def do_action(self, *args, **kwargs):
response = action(self, *args, **kwargs)
if hasattr(self, 'load'):
# Clear cached data. It will be reloaded the next
# time that an attribute is accessed.
# TODO: Make this configurable in the future?
self.meta.data = None
return response
do_action.__name__ = str(action_model.name)
do_action.__doc__ = 'TODO'
return do_action
|