877 lines
38 KiB
Python
877 lines
38 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 logging
|
|
import functools
|
|
|
|
from botocore import waiter, xform_name
|
|
from botocore.auth import AUTH_TYPE_MAPS
|
|
from botocore.awsrequest import prepare_request_dict
|
|
from botocore.docs.docstring import ClientMethodDocstring
|
|
from botocore.docs.docstring import PaginatorDocstring
|
|
from botocore.exceptions import ClientError, DataNotFoundError
|
|
from botocore.exceptions import OperationNotPageableError
|
|
from botocore.exceptions import UnknownSignatureVersionError
|
|
from botocore.hooks import first_non_none_response
|
|
from botocore.model import ServiceModel
|
|
from botocore.paginate import Paginator
|
|
from botocore.utils import CachedProperty
|
|
from botocore.utils import get_service_module_name
|
|
from botocore.utils import switch_host_s3_accelerate
|
|
from botocore.utils import S3RegionRedirector
|
|
from botocore.utils import fix_s3_host
|
|
from botocore.utils import switch_to_virtual_host_style
|
|
from botocore.utils import S3_ACCELERATE_WHITELIST
|
|
from botocore.args import ClientArgsCreator
|
|
from botocore.compat import urlsplit
|
|
from botocore import UNSIGNED
|
|
# Keep this imported. There's pre-existing code that uses
|
|
# "from botocore.client import Config".
|
|
from botocore.config import Config
|
|
from botocore.history import get_global_history_recorder
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
history_recorder = get_global_history_recorder()
|
|
|
|
|
|
class ClientCreator(object):
|
|
"""Creates client objects for a service."""
|
|
def __init__(self, loader, endpoint_resolver, user_agent, event_emitter,
|
|
retry_handler_factory, retry_config_translator,
|
|
response_parser_factory=None, exceptions_factory=None):
|
|
self._loader = loader
|
|
self._endpoint_resolver = endpoint_resolver
|
|
self._user_agent = user_agent
|
|
self._event_emitter = event_emitter
|
|
self._retry_handler_factory = retry_handler_factory
|
|
self._retry_config_translator = retry_config_translator
|
|
self._response_parser_factory = response_parser_factory
|
|
self._exceptions_factory = exceptions_factory
|
|
|
|
def create_client(self, service_name, region_name, is_secure=True,
|
|
endpoint_url=None, verify=None,
|
|
credentials=None, scoped_config=None,
|
|
api_version=None,
|
|
client_config=None):
|
|
responses = self._event_emitter.emit(
|
|
'choose-service-name', service_name=service_name)
|
|
service_name = first_non_none_response(responses, default=service_name)
|
|
service_model = self._load_service_model(service_name, api_version)
|
|
cls = self._create_client_class(service_name, service_model)
|
|
endpoint_bridge = ClientEndpointBridge(
|
|
self._endpoint_resolver, scoped_config, client_config,
|
|
service_signing_name=service_model.metadata.get('signingName'))
|
|
client_args = self._get_client_args(
|
|
service_model, region_name, is_secure, endpoint_url,
|
|
verify, credentials, scoped_config, client_config, endpoint_bridge)
|
|
service_client = cls(**client_args)
|
|
self._register_retries(service_client)
|
|
self._register_s3_events(
|
|
service_client, endpoint_bridge, endpoint_url, client_config,
|
|
scoped_config)
|
|
return service_client
|
|
|
|
def create_client_class(self, service_name, api_version=None):
|
|
service_model = self._load_service_model(service_name, api_version)
|
|
return self._create_client_class(service_name, service_model)
|
|
|
|
def _create_client_class(self, service_name, service_model):
|
|
class_attributes = self._create_methods(service_model)
|
|
py_name_to_operation_name = self._create_name_mapping(service_model)
|
|
class_attributes['_PY_TO_OP_NAME'] = py_name_to_operation_name
|
|
bases = [BaseClient]
|
|
service_id = service_model.service_id.hyphenize()
|
|
self._event_emitter.emit(
|
|
'creating-client-class.%s' % service_id,
|
|
class_attributes=class_attributes,
|
|
base_classes=bases)
|
|
class_name = get_service_module_name(service_model)
|
|
cls = type(str(class_name), tuple(bases), class_attributes)
|
|
return cls
|
|
|
|
def _load_service_model(self, service_name, api_version=None):
|
|
json_model = self._loader.load_service_model(service_name, 'service-2',
|
|
api_version=api_version)
|
|
service_model = ServiceModel(json_model, service_name=service_name)
|
|
return service_model
|
|
|
|
def _register_retries(self, client):
|
|
endpoint_prefix = client.meta.service_model.endpoint_prefix
|
|
service_id = client.meta.service_model.service_id
|
|
service_event_name = service_id.hyphenize()
|
|
|
|
# First, we load the entire retry config for all services,
|
|
# then pull out just the information we need.
|
|
original_config = self._loader.load_data('_retry')
|
|
if not original_config:
|
|
return
|
|
|
|
retry_config = self._retry_config_translator.build_retry_config(
|
|
endpoint_prefix, original_config.get('retry', {}),
|
|
original_config.get('definitions', {}),
|
|
client.meta.config.retries
|
|
)
|
|
|
|
logger.debug("Registering retry handlers for service: %s",
|
|
client.meta.service_model.service_name)
|
|
handler = self._retry_handler_factory.create_retry_handler(
|
|
retry_config, endpoint_prefix)
|
|
unique_id = 'retry-config-%s' % service_event_name
|
|
client.meta.events.register(
|
|
'needs-retry.%s' % service_event_name, handler,
|
|
unique_id=unique_id
|
|
)
|
|
|
|
def _register_s3_events(self, client, endpoint_bridge, endpoint_url,
|
|
client_config, scoped_config):
|
|
if client.meta.service_model.service_name != 's3':
|
|
return
|
|
S3RegionRedirector(endpoint_bridge, client).register()
|
|
self._set_s3_addressing_style(
|
|
endpoint_url, client.meta.config.s3, client.meta.events,
|
|
client.meta.partition
|
|
)
|
|
# Enable accelerate if the configuration is set to to true or the
|
|
# endpoint being used matches one of the accelerate endpoints.
|
|
if self._is_s3_accelerate(endpoint_url, client.meta.config.s3):
|
|
# Also make sure that the hostname gets switched to
|
|
# s3-accelerate.amazonaws.com
|
|
client.meta.events.register_first(
|
|
'before-sign.s3', switch_host_s3_accelerate)
|
|
|
|
self._set_s3_presign_signature_version(
|
|
client.meta, client_config, scoped_config)
|
|
|
|
def _set_s3_addressing_style(self, endpoint_url, s3_config, event_emitter,
|
|
partition):
|
|
if s3_config is None:
|
|
s3_config = {}
|
|
|
|
addressing_style = self._get_s3_addressing_style(
|
|
endpoint_url, s3_config)
|
|
handler = self._get_s3_addressing_handler(
|
|
endpoint_url, s3_config, addressing_style, partition)
|
|
if handler is not None:
|
|
event_emitter.register('before-sign.s3', handler)
|
|
|
|
def _get_s3_addressing_style(self, endpoint_url, s3_config):
|
|
# Use virtual host style addressing if accelerate is enabled or if
|
|
# the given endpoint url is an accelerate endpoint.
|
|
accelerate = s3_config.get('use_accelerate_endpoint', False)
|
|
if accelerate or self._is_s3_accelerate(endpoint_url, s3_config):
|
|
return 'virtual'
|
|
|
|
# If a particular addressing style is configured, use it.
|
|
configured_addressing_style = s3_config.get('addressing_style')
|
|
if configured_addressing_style:
|
|
return configured_addressing_style
|
|
|
|
def _get_s3_addressing_handler(self, endpoint_url, s3_config,
|
|
addressing_style, partition):
|
|
# If virtual host style was configured, use it regardless of whether
|
|
# or not the bucket looks dns compatible.
|
|
if addressing_style == 'virtual':
|
|
logger.debug("Using S3 virtual host style addressing.")
|
|
return switch_to_virtual_host_style
|
|
|
|
# If path style is configured, no additional steps are needed. If
|
|
# endpoint_url was specified, don't default to virtual. We could
|
|
# potentially default provided endpoint urls to virtual hosted
|
|
# style, but for now it is avoided.
|
|
if addressing_style == 'path' or endpoint_url is not None:
|
|
logger.debug("Using S3 path style addressing.")
|
|
return None
|
|
|
|
logger.debug("Defaulting to S3 virtual host style addressing with "
|
|
"path style addressing fallback.")
|
|
|
|
# By default, try to use virtual style with path fallback.
|
|
return fix_s3_host
|
|
|
|
def _is_s3_accelerate(self, endpoint_url, s3_config):
|
|
# Accelerate has been explicitly configured.
|
|
if s3_config is not None and s3_config.get('use_accelerate_endpoint'):
|
|
return True
|
|
|
|
# Accelerate mode is turned on automatically if an endpoint url is
|
|
# provided that matches the accelerate scheme.
|
|
if endpoint_url is None:
|
|
return False
|
|
|
|
# Accelerate is only valid for Amazon endpoints.
|
|
netloc = urlsplit(endpoint_url).netloc
|
|
if not netloc.endswith('amazonaws.com'):
|
|
return False
|
|
|
|
# The first part of the url should always be s3-accelerate.
|
|
parts = netloc.split('.')
|
|
if parts[0] != 's3-accelerate':
|
|
return False
|
|
|
|
# Url parts between 's3-accelerate' and 'amazonaws.com' which
|
|
# represent different url features.
|
|
feature_parts = parts[1:-2]
|
|
|
|
# There should be no duplicate url parts.
|
|
if len(feature_parts) != len(set(feature_parts)):
|
|
return False
|
|
|
|
# Remaining parts must all be in the whitelist.
|
|
return all(p in S3_ACCELERATE_WHITELIST for p in feature_parts)
|
|
|
|
def _set_s3_presign_signature_version(self, client_meta,
|
|
client_config, scoped_config):
|
|
# This will return the manually configured signature version, or None
|
|
# if none was manually set. If a customer manually sets the signature
|
|
# version, we always want to use what they set.
|
|
provided_signature_version = _get_configured_signature_version(
|
|
's3', client_config, scoped_config)
|
|
if provided_signature_version is not None:
|
|
return
|
|
|
|
# Check to see if the region is a region that we know about. If we
|
|
# don't know about a region, then we can safely assume it's a new
|
|
# region that is sigv4 only, since all new S3 regions only allow sigv4.
|
|
regions = self._endpoint_resolver.get_available_endpoints(
|
|
's3', client_meta.partition)
|
|
if client_meta.region_name not in regions:
|
|
return
|
|
|
|
# If it is a region we know about, we want to default to sigv2, so here
|
|
# we check to see if it is available.
|
|
endpoint = self._endpoint_resolver.construct_endpoint(
|
|
's3', client_meta.region_name)
|
|
signature_versions = endpoint['signatureVersions']
|
|
if 's3' not in signature_versions:
|
|
return
|
|
|
|
# We now know that we're in a known region that supports sigv2 and
|
|
# the customer hasn't set a signature version so we default the
|
|
# signature version to sigv2.
|
|
client_meta.events.register(
|
|
'choose-signer.s3', self._default_s3_presign_to_sigv2)
|
|
|
|
def _default_s3_presign_to_sigv2(self, signature_version, **kwargs):
|
|
"""
|
|
Returns the 's3' (sigv2) signer if presigning an s3 request. This is
|
|
intended to be used to set the default signature version for the signer
|
|
to sigv2.
|
|
|
|
:type signature_version: str
|
|
:param signature_version: The current client signature version.
|
|
|
|
:type signing_name: str
|
|
:param signing_name: The signing name of the service.
|
|
|
|
:return: 's3' if the request is an s3 presign request, None otherwise
|
|
"""
|
|
for suffix in ['-query', '-presign-post']:
|
|
if signature_version.endswith(suffix):
|
|
return 's3' + suffix
|
|
|
|
def _get_client_args(self, service_model, region_name, is_secure,
|
|
endpoint_url, verify, credentials,
|
|
scoped_config, client_config, endpoint_bridge):
|
|
args_creator = ClientArgsCreator(
|
|
self._event_emitter, self._user_agent,
|
|
self._response_parser_factory, self._loader,
|
|
self._exceptions_factory)
|
|
return args_creator.get_client_args(
|
|
service_model, region_name, is_secure, endpoint_url,
|
|
verify, credentials, scoped_config, client_config, endpoint_bridge)
|
|
|
|
def _create_methods(self, service_model):
|
|
op_dict = {}
|
|
for operation_name in service_model.operation_names:
|
|
py_operation_name = xform_name(operation_name)
|
|
op_dict[py_operation_name] = self._create_api_method(
|
|
py_operation_name, operation_name, service_model)
|
|
return op_dict
|
|
|
|
def _create_name_mapping(self, service_model):
|
|
# py_name -> OperationName, for every operation available
|
|
# for a service.
|
|
mapping = {}
|
|
for operation_name in service_model.operation_names:
|
|
py_operation_name = xform_name(operation_name)
|
|
mapping[py_operation_name] = operation_name
|
|
return mapping
|
|
|
|
def _create_api_method(self, py_operation_name, operation_name,
|
|
service_model):
|
|
def _api_call(self, *args, **kwargs):
|
|
# We're accepting *args so that we can give a more helpful
|
|
# error message than TypeError: _api_call takes exactly
|
|
# 1 argument.
|
|
if args:
|
|
raise TypeError(
|
|
"%s() only accepts keyword arguments." % py_operation_name)
|
|
# The "self" in this scope is referring to the BaseClient.
|
|
return self._make_api_call(operation_name, kwargs)
|
|
|
|
_api_call.__name__ = str(py_operation_name)
|
|
|
|
# Add the docstring to the client method
|
|
operation_model = service_model.operation_model(operation_name)
|
|
docstring = ClientMethodDocstring(
|
|
operation_model=operation_model,
|
|
method_name=operation_name,
|
|
event_emitter=self._event_emitter,
|
|
method_description=operation_model.documentation,
|
|
example_prefix='response = client.%s' % py_operation_name,
|
|
include_signature=False
|
|
)
|
|
_api_call.__doc__ = docstring
|
|
return _api_call
|
|
|
|
|
|
class ClientEndpointBridge(object):
|
|
"""Bridges endpoint data and client creation
|
|
|
|
This class handles taking out the relevant arguments from the endpoint
|
|
resolver and determining which values to use, taking into account any
|
|
client configuration options and scope configuration options.
|
|
|
|
This class also handles determining what, if any, region to use if no
|
|
explicit region setting is provided. For example, Amazon S3 client will
|
|
utilize "us-east-1" by default if no region can be resolved."""
|
|
|
|
DEFAULT_ENDPOINT = '{service}.{region}.amazonaws.com'
|
|
|
|
def __init__(self, endpoint_resolver, scoped_config=None,
|
|
client_config=None, default_endpoint=None,
|
|
service_signing_name=None):
|
|
self.service_signing_name = service_signing_name
|
|
self.endpoint_resolver = endpoint_resolver
|
|
self.scoped_config = scoped_config
|
|
self.client_config = client_config
|
|
self.default_endpoint = default_endpoint or self.DEFAULT_ENDPOINT
|
|
|
|
def resolve(self, service_name, region_name=None, endpoint_url=None,
|
|
is_secure=True):
|
|
region_name = self._check_default_region(service_name, region_name)
|
|
resolved = self.endpoint_resolver.construct_endpoint(
|
|
service_name, region_name)
|
|
if resolved:
|
|
return self._create_endpoint(
|
|
resolved, service_name, region_name, endpoint_url, is_secure)
|
|
else:
|
|
return self._assume_endpoint(service_name, region_name,
|
|
endpoint_url, is_secure)
|
|
|
|
def _check_default_region(self, service_name, region_name):
|
|
if region_name is not None:
|
|
return region_name
|
|
# Use the client_config region if no explicit region was provided.
|
|
if self.client_config and self.client_config.region_name is not None:
|
|
return self.client_config.region_name
|
|
|
|
def _create_endpoint(self, resolved, service_name, region_name,
|
|
endpoint_url, is_secure):
|
|
region_name, signing_region = self._pick_region_values(
|
|
resolved, region_name, endpoint_url)
|
|
if endpoint_url is None:
|
|
if self._is_s3_dualstack_mode(service_name):
|
|
endpoint_url = self._create_dualstack_endpoint(
|
|
service_name, region_name,
|
|
resolved['dnsSuffix'], is_secure)
|
|
else:
|
|
# Use the sslCommonName over the hostname for Python 2.6 compat.
|
|
hostname = resolved.get('sslCommonName', resolved.get('hostname'))
|
|
endpoint_url = self._make_url(hostname, is_secure,
|
|
resolved.get('protocols', []))
|
|
signature_version = self._resolve_signature_version(
|
|
service_name, resolved)
|
|
signing_name = self._resolve_signing_name(service_name, resolved)
|
|
return self._create_result(
|
|
service_name=service_name, region_name=region_name,
|
|
signing_region=signing_region, signing_name=signing_name,
|
|
endpoint_url=endpoint_url, metadata=resolved,
|
|
signature_version=signature_version)
|
|
|
|
def _is_s3_dualstack_mode(self, service_name):
|
|
if service_name != 's3':
|
|
return False
|
|
# TODO: This normalization logic is duplicated from the
|
|
# ClientArgsCreator class. Consolidate everything to
|
|
# ClientArgsCreator. _resolve_signature_version also has similarly
|
|
# duplicated logic.
|
|
client_config = self.client_config
|
|
if client_config is not None and client_config.s3 is not None and \
|
|
'use_dualstack_endpoint' in client_config.s3:
|
|
# Client config trumps scoped config.
|
|
return client_config.s3['use_dualstack_endpoint']
|
|
if self.scoped_config is None:
|
|
return False
|
|
enabled = self.scoped_config.get('s3', {}).get(
|
|
'use_dualstack_endpoint', False)
|
|
if enabled in [True, 'True', 'true']:
|
|
return True
|
|
return False
|
|
|
|
def _create_dualstack_endpoint(self, service_name, region_name,
|
|
dns_suffix, is_secure):
|
|
hostname = '{service}.dualstack.{region}.{dns_suffix}'.format(
|
|
service=service_name, region=region_name,
|
|
dns_suffix=dns_suffix)
|
|
# Dualstack supports http and https so were hardcoding this value for
|
|
# now. This can potentially move into the endpoints.json file.
|
|
return self._make_url(hostname, is_secure, ['http', 'https'])
|
|
|
|
def _assume_endpoint(self, service_name, region_name, endpoint_url,
|
|
is_secure):
|
|
if endpoint_url is None:
|
|
# Expand the default hostname URI template.
|
|
hostname = self.default_endpoint.format(
|
|
service=service_name, region=region_name)
|
|
endpoint_url = self._make_url(hostname, is_secure,
|
|
['http', 'https'])
|
|
logger.debug('Assuming an endpoint for %s, %s: %s',
|
|
service_name, region_name, endpoint_url)
|
|
# We still want to allow the user to provide an explicit version.
|
|
signature_version = self._resolve_signature_version(
|
|
service_name, {'signatureVersions': ['v4']})
|
|
signing_name = self._resolve_signing_name(service_name, resolved={})
|
|
return self._create_result(
|
|
service_name=service_name, region_name=region_name,
|
|
signing_region=region_name, signing_name=signing_name,
|
|
signature_version=signature_version, endpoint_url=endpoint_url,
|
|
metadata={})
|
|
|
|
def _create_result(self, service_name, region_name, signing_region,
|
|
signing_name, endpoint_url, signature_version,
|
|
metadata):
|
|
return {
|
|
'service_name': service_name,
|
|
'region_name': region_name,
|
|
'signing_region': signing_region,
|
|
'signing_name': signing_name,
|
|
'endpoint_url': endpoint_url,
|
|
'signature_version': signature_version,
|
|
'metadata': metadata
|
|
}
|
|
|
|
def _make_url(self, hostname, is_secure, supported_protocols):
|
|
if is_secure and 'https' in supported_protocols:
|
|
scheme = 'https'
|
|
else:
|
|
scheme = 'http'
|
|
return '%s://%s' % (scheme, hostname)
|
|
|
|
def _resolve_signing_name(self, service_name, resolved):
|
|
# CredentialScope overrides everything else.
|
|
if 'credentialScope' in resolved \
|
|
and 'service' in resolved['credentialScope']:
|
|
return resolved['credentialScope']['service']
|
|
# Use the signingName from the model if present.
|
|
if self.service_signing_name:
|
|
return self.service_signing_name
|
|
# Just assume is the same as the service name.
|
|
return service_name
|
|
|
|
def _pick_region_values(self, resolved, region_name, endpoint_url):
|
|
signing_region = region_name
|
|
if endpoint_url is None:
|
|
# Do not use the region name or signing name from the resolved
|
|
# endpoint if the user explicitly provides an endpoint_url. This
|
|
# would happen if we resolve to an endpoint where the service has
|
|
# a "defaults" section that overrides all endpoint with a single
|
|
# hostname and credentialScope. This has been the case historically
|
|
# for how STS has worked. The only way to resolve an STS endpoint
|
|
# was to provide a region_name and an endpoint_url. In that case,
|
|
# we would still resolve an endpoint, but we would not use the
|
|
# resolved endpointName or signingRegion because we want to allow
|
|
# custom endpoints.
|
|
region_name = resolved['endpointName']
|
|
signing_region = region_name
|
|
if 'credentialScope' in resolved \
|
|
and 'region' in resolved['credentialScope']:
|
|
signing_region = resolved['credentialScope']['region']
|
|
return region_name, signing_region
|
|
|
|
def _resolve_signature_version(self, service_name, resolved):
|
|
configured_version = _get_configured_signature_version(
|
|
service_name, self.client_config, self.scoped_config)
|
|
if configured_version is not None:
|
|
return configured_version
|
|
|
|
# Pick a signature version from the endpoint metadata if present.
|
|
if 'signatureVersions' in resolved:
|
|
potential_versions = resolved['signatureVersions']
|
|
if service_name == 's3':
|
|
return 's3v4'
|
|
if 'v4' in potential_versions:
|
|
return 'v4'
|
|
# Now just iterate over the signature versions in order until we
|
|
# find the first one that is known to Botocore.
|
|
for known in AUTH_TYPE_MAPS:
|
|
if known in potential_versions:
|
|
return known
|
|
raise UnknownSignatureVersionError(
|
|
signature_version=resolved.get('signatureVersions'))
|
|
|
|
|
|
class BaseClient(object):
|
|
|
|
# This is actually reassigned with the py->op_name mapping
|
|
# when the client creator creates the subclass. This value is used
|
|
# because calls such as client.get_paginator('list_objects') use the
|
|
# snake_case name, but we need to know the ListObjects form.
|
|
# xform_name() does the ListObjects->list_objects conversion, but
|
|
# we need the reverse mapping here.
|
|
_PY_TO_OP_NAME = {}
|
|
|
|
def __init__(self, serializer, endpoint, response_parser,
|
|
event_emitter, request_signer, service_model, loader,
|
|
client_config, partition, exceptions_factory):
|
|
self._serializer = serializer
|
|
self._endpoint = endpoint
|
|
self._response_parser = response_parser
|
|
self._request_signer = request_signer
|
|
self._cache = {}
|
|
self._loader = loader
|
|
self._client_config = client_config
|
|
self.meta = ClientMeta(event_emitter, self._client_config,
|
|
endpoint.host, service_model,
|
|
self._PY_TO_OP_NAME, partition)
|
|
self._exceptions_factory = exceptions_factory
|
|
self._exceptions = None
|
|
self._register_handlers()
|
|
|
|
def __getattr__(self, item):
|
|
event_name = 'getattr.%s.%s' % (
|
|
self._service_model.service_id.hyphenize(), item
|
|
)
|
|
handler, event_response = self.meta.events.emit_until_response(
|
|
event_name, client=self)
|
|
|
|
if event_response is not None:
|
|
return event_response
|
|
|
|
raise AttributeError(
|
|
"'%s' object has no attribute '%s'" % (
|
|
self.__class__.__name__, item)
|
|
)
|
|
|
|
def _register_handlers(self):
|
|
# Register the handler required to sign requests.
|
|
service_id = self.meta.service_model.service_id.hyphenize()
|
|
self.meta.events.register(
|
|
'request-created.%s' % service_id,
|
|
self._request_signer.handler
|
|
)
|
|
|
|
@property
|
|
def _service_model(self):
|
|
return self.meta.service_model
|
|
|
|
def _make_api_call(self, operation_name, api_params):
|
|
operation_model = self._service_model.operation_model(operation_name)
|
|
service_name = self._service_model.service_name
|
|
history_recorder.record('API_CALL', {
|
|
'service': service_name,
|
|
'operation': operation_name,
|
|
'params': api_params,
|
|
})
|
|
if operation_model.deprecated:
|
|
logger.debug('Warning: %s.%s() is deprecated',
|
|
service_name, operation_name)
|
|
request_context = {
|
|
'client_region': self.meta.region_name,
|
|
'client_config': self.meta.config,
|
|
'has_streaming_input': operation_model.has_streaming_input,
|
|
'auth_type': operation_model.auth_type,
|
|
}
|
|
request_dict = self._convert_to_request_dict(
|
|
api_params, operation_model, context=request_context)
|
|
|
|
service_id = self._service_model.service_id.hyphenize()
|
|
handler, event_response = self.meta.events.emit_until_response(
|
|
'before-call.{service_id}.{operation_name}'.format(
|
|
service_id=service_id,
|
|
operation_name=operation_name),
|
|
model=operation_model, params=request_dict,
|
|
request_signer=self._request_signer, context=request_context)
|
|
|
|
if event_response is not None:
|
|
http, parsed_response = event_response
|
|
else:
|
|
http, parsed_response = self._endpoint.make_request(
|
|
operation_model, request_dict)
|
|
|
|
self.meta.events.emit(
|
|
'after-call.{service_id}.{operation_name}'.format(
|
|
service_id=service_id,
|
|
operation_name=operation_name),
|
|
http_response=http, parsed=parsed_response,
|
|
model=operation_model, context=request_context
|
|
)
|
|
|
|
if http.status_code >= 300:
|
|
error_code = parsed_response.get("Error", {}).get("Code")
|
|
error_class = self.exceptions.from_code(error_code)
|
|
raise error_class(parsed_response, operation_name)
|
|
else:
|
|
return parsed_response
|
|
|
|
def _convert_to_request_dict(self, api_params, operation_model,
|
|
context=None):
|
|
api_params = self._emit_api_params(
|
|
api_params, operation_model, context)
|
|
request_dict = self._serializer.serialize_to_request(
|
|
api_params, operation_model)
|
|
prepare_request_dict(request_dict, endpoint_url=self._endpoint.host,
|
|
user_agent=self._client_config.user_agent,
|
|
context=context)
|
|
return request_dict
|
|
|
|
def _emit_api_params(self, api_params, operation_model, context):
|
|
# Given the API params provided by the user and the operation_model
|
|
# we can serialize the request to a request_dict.
|
|
operation_name = operation_model.name
|
|
|
|
# Emit an event that allows users to modify the parameters at the
|
|
# beginning of the method. It allows handlers to modify existing
|
|
# parameters or return a new set of parameters to use.
|
|
service_id = self._service_model.service_id.hyphenize()
|
|
responses = self.meta.events.emit(
|
|
'provide-client-params.{service_id}.{operation_name}'.format(
|
|
service_id=service_id,
|
|
operation_name=operation_name),
|
|
params=api_params, model=operation_model, context=context)
|
|
api_params = first_non_none_response(responses, default=api_params)
|
|
|
|
event_name = (
|
|
'before-parameter-build.{service_id}.{operation_name}')
|
|
self.meta.events.emit(
|
|
event_name.format(
|
|
service_id=service_id,
|
|
operation_name=operation_name),
|
|
params=api_params, model=operation_model, context=context)
|
|
return api_params
|
|
|
|
def get_paginator(self, operation_name):
|
|
"""Create a paginator for an operation.
|
|
|
|
:type operation_name: string
|
|
:param operation_name: The operation name. This is the same name
|
|
as the method name on the client. For example, if the
|
|
method name is ``create_foo``, and you'd normally invoke the
|
|
operation as ``client.create_foo(**kwargs)``, if the
|
|
``create_foo`` operation can be paginated, you can use the
|
|
call ``client.get_paginator("create_foo")``.
|
|
|
|
:raise OperationNotPageableError: Raised if the operation is not
|
|
pageable. You can use the ``client.can_paginate`` method to
|
|
check if an operation is pageable.
|
|
|
|
:rtype: L{botocore.paginate.Paginator}
|
|
:return: A paginator object.
|
|
|
|
"""
|
|
if not self.can_paginate(operation_name):
|
|
raise OperationNotPageableError(operation_name=operation_name)
|
|
else:
|
|
actual_operation_name = self._PY_TO_OP_NAME[operation_name]
|
|
|
|
# Create a new paginate method that will serve as a proxy to
|
|
# the underlying Paginator.paginate method. This is needed to
|
|
# attach a docstring to the method.
|
|
def paginate(self, **kwargs):
|
|
return Paginator.paginate(self, **kwargs)
|
|
|
|
paginator_config = self._cache['page_config'][
|
|
actual_operation_name]
|
|
# Add the docstring for the paginate method.
|
|
paginate.__doc__ = PaginatorDocstring(
|
|
paginator_name=actual_operation_name,
|
|
event_emitter=self.meta.events,
|
|
service_model=self.meta.service_model,
|
|
paginator_config=paginator_config,
|
|
include_signature=False
|
|
)
|
|
|
|
# Rename the paginator class based on the type of paginator.
|
|
paginator_class_name = str('%s.Paginator.%s' % (
|
|
get_service_module_name(self.meta.service_model),
|
|
actual_operation_name))
|
|
|
|
# Create the new paginator class
|
|
documented_paginator_cls = type(
|
|
paginator_class_name, (Paginator,), {'paginate': paginate})
|
|
|
|
operation_model = self._service_model.operation_model(actual_operation_name)
|
|
paginator = documented_paginator_cls(
|
|
getattr(self, operation_name),
|
|
paginator_config,
|
|
operation_model)
|
|
return paginator
|
|
|
|
def can_paginate(self, operation_name):
|
|
"""Check if an operation can be paginated.
|
|
|
|
:type operation_name: string
|
|
:param operation_name: The operation name. This is the same name
|
|
as the method name on the client. For example, if the
|
|
method name is ``create_foo``, and you'd normally invoke the
|
|
operation as ``client.create_foo(**kwargs)``, if the
|
|
``create_foo`` operation can be paginated, you can use the
|
|
call ``client.get_paginator("create_foo")``.
|
|
|
|
:return: ``True`` if the operation can be paginated,
|
|
``False`` otherwise.
|
|
|
|
"""
|
|
if 'page_config' not in self._cache:
|
|
try:
|
|
page_config = self._loader.load_service_model(
|
|
self._service_model.service_name,
|
|
'paginators-1',
|
|
self._service_model.api_version)['pagination']
|
|
self._cache['page_config'] = page_config
|
|
except DataNotFoundError:
|
|
self._cache['page_config'] = {}
|
|
actual_operation_name = self._PY_TO_OP_NAME[operation_name]
|
|
return actual_operation_name in self._cache['page_config']
|
|
|
|
def _get_waiter_config(self):
|
|
if 'waiter_config' not in self._cache:
|
|
try:
|
|
waiter_config = self._loader.load_service_model(
|
|
self._service_model.service_name,
|
|
'waiters-2',
|
|
self._service_model.api_version)
|
|
self._cache['waiter_config'] = waiter_config
|
|
except DataNotFoundError:
|
|
self._cache['waiter_config'] = {}
|
|
return self._cache['waiter_config']
|
|
|
|
def get_waiter(self, waiter_name):
|
|
"""Returns an object that can wait for some condition.
|
|
|
|
:type waiter_name: str
|
|
:param waiter_name: The name of the waiter to get. See the waiters
|
|
section of the service docs for a list of available waiters.
|
|
|
|
:returns: The specified waiter object.
|
|
:rtype: botocore.waiter.Waiter
|
|
"""
|
|
config = self._get_waiter_config()
|
|
if not config:
|
|
raise ValueError("Waiter does not exist: %s" % waiter_name)
|
|
model = waiter.WaiterModel(config)
|
|
mapping = {}
|
|
for name in model.waiter_names:
|
|
mapping[xform_name(name)] = name
|
|
if waiter_name not in mapping:
|
|
raise ValueError("Waiter does not exist: %s" % waiter_name)
|
|
|
|
return waiter.create_waiter_with_client(
|
|
mapping[waiter_name], model, self)
|
|
|
|
@CachedProperty
|
|
def waiter_names(self):
|
|
"""Returns a list of all available waiters."""
|
|
config = self._get_waiter_config()
|
|
if not config:
|
|
return []
|
|
model = waiter.WaiterModel(config)
|
|
# Waiter configs is a dict, we just want the waiter names
|
|
# which are the keys in the dict.
|
|
return [xform_name(name) for name in model.waiter_names]
|
|
|
|
@property
|
|
def exceptions(self):
|
|
if self._exceptions is None:
|
|
self._exceptions = self._load_exceptions()
|
|
return self._exceptions
|
|
|
|
def _load_exceptions(self):
|
|
return self._exceptions_factory.create_client_exceptions(
|
|
self._service_model)
|
|
|
|
|
|
class ClientMeta(object):
|
|
"""Holds additional client methods.
|
|
|
|
This class holds additional information for clients. It exists for
|
|
two reasons:
|
|
|
|
* To give advanced functionality to clients
|
|
* To namespace additional client attributes from the operation
|
|
names which are mapped to methods at runtime. This avoids
|
|
ever running into collisions with operation names.
|
|
|
|
"""
|
|
|
|
def __init__(self, events, client_config, endpoint_url, service_model,
|
|
method_to_api_mapping, partition):
|
|
self.events = events
|
|
self._client_config = client_config
|
|
self._endpoint_url = endpoint_url
|
|
self._service_model = service_model
|
|
self._method_to_api_mapping = method_to_api_mapping
|
|
self._partition = partition
|
|
|
|
@property
|
|
def service_model(self):
|
|
return self._service_model
|
|
|
|
@property
|
|
def region_name(self):
|
|
return self._client_config.region_name
|
|
|
|
@property
|
|
def endpoint_url(self):
|
|
return self._endpoint_url
|
|
|
|
@property
|
|
def config(self):
|
|
return self._client_config
|
|
|
|
@property
|
|
def method_to_api_mapping(self):
|
|
return self._method_to_api_mapping
|
|
|
|
@property
|
|
def partition(self):
|
|
return self._partition
|
|
|
|
|
|
def _get_configured_signature_version(service_name, client_config,
|
|
scoped_config):
|
|
"""
|
|
Gets the manually configured signature version.
|
|
|
|
:returns: the customer configured signature version, or None if no
|
|
signature version was configured.
|
|
"""
|
|
# Client config overrides everything.
|
|
if client_config and client_config.signature_version is not None:
|
|
return client_config.signature_version
|
|
|
|
# Scoped config overrides picking from the endpoint metadata.
|
|
if scoped_config is not None:
|
|
# A given service may have service specific configuration in the
|
|
# config file, so we need to check there as well.
|
|
service_config = scoped_config.get(service_name)
|
|
if service_config is not None and isinstance(service_config, dict):
|
|
version = service_config.get('signature_version')
|
|
if version:
|
|
logger.debug(
|
|
"Switching signature version for service %s "
|
|
"to version %s based on config file override.",
|
|
service_name, version)
|
|
return version
|
|
return None
|