def get_client_args(self, service_model, region_name, is_secure,
endpoint_url, verify, credentials, scoped_config,
client_config, endpoint_bridge):
final_args = self.compute_client_args(
service_model, client_config, endpoint_bridge, region_name,
endpoint_url, is_secure, scoped_config)
service_name = final_args['service_name']
parameter_validation = final_args['parameter_validation']
endpoint_config = final_args['endpoint_config']
protocol = final_args['protocol']
config_kwargs = final_args['config_kwargs']
s3_config = final_args['s3_config']
partition = endpoint_config['metadata'].get('partition', None)
socket_options = final_args['socket_options']
signing_region = endpoint_config['signing_region']
endpoint_region_name = endpoint_config['region_name']
if signing_region is None and endpoint_region_name is None:
signing_region, endpoint_region_name = \
self._get_default_s3_region(service_name, endpoint_bridge)
config_kwargs['region_name'] = endpoint_region_name
event_emitter = copy.copy(self._event_emitter)
signer = RequestSigner(
service_model.service_id, signing_region,
endpoint_config['signing_name'],
endpoint_config['signature_version'],
credentials, event_emitter
)
config_kwargs['s3'] = s3_config
new_config = Config(**config_kwargs)
endpoint_creator = EndpointCreator(event_emitter)
endpoint = endpoint_creator.create_endpoint(
service_model, region_name=endpoint_region_name,
endpoint_url=endpoint_config['endpoint_url'], verify=verify,
response_parser_factory=self._response_parser_factory,
max_pool_connections=new_config.max_pool_connections,
proxies=new_config.proxies,
timeout=(new_config.connect_timeout, new_config.read_timeout),
socket_options=socket_options,
client_cert=new_config.client_cert)
serializer = botocore.serialize.create_serializer(
protocol, parameter_validation)
response_parser = botocore.parsers.create_parser(protocol)
return {
'serializer': serializer,
'endpoint': endpoint,
'response_parser': response_parser,
'event_emitter': event_emitter,
'request_signer': signer,
'service_model': service_model,
'loader': self._loader,
'client_config': new_config,
'partition': partition,
'exceptions_factory': self._exceptions_factory
}
def setUp(self):
self.service_model = Mock(
endpoint_prefix='ec2', signature_version='v2',
signing_name='ec2')
self.environ = {}
self.environ_patch = patch('os.environ', self.environ)
self.environ_patch.start()
self.creator = EndpointCreator(Mock())
def test_endpoint_resolver_with_configured_region_name(self):
resolver = Mock()
resolver.construct_endpoint.return_value = {
'uri': 'https://endpoint.url',
'properties': {}
}
creator = EndpointCreator(resolver, 'us-west-2', Mock(), 'user-agent')
endpoint = creator.create_endpoint(self.service_model)
self.assertEqual(endpoint.host, 'https://endpoint.url')
def setUp(self):
self.service_model = mock.Mock(endpoint_prefix='ec2',
signature_version='v2',
signing_name='ec2')
self.environ = {}
self.environ_patch = mock.patch('os.environ', self.environ)
self.environ_patch.start()
self.creator = EndpointCreator(mock.Mock())
self.mock_session = mock.Mock(spec=URLLib3Session)
def get_client_args(self, service_model, region_name, is_secure,
endpoint_url, verify, credentials, scoped_config,
client_config, endpoint_bridge):
final_args = self.compute_client_args(service_model, client_config,
endpoint_bridge, region_name,
endpoint_url, is_secure,
scoped_config)
service_name = final_args['service_name']
parameter_validation = final_args['parameter_validation']
endpoint_config = final_args['endpoint_config']
protocol = final_args['protocol']
config_kwargs = final_args['config_kwargs']
s3_config = final_args['s3_config']
partition = endpoint_config['metadata'].get('partition', None)
event_emitter = copy.copy(self._event_emitter)
signer = RequestSigner(service_name, endpoint_config['signing_region'],
endpoint_config['signing_name'],
endpoint_config['signature_version'],
credentials, event_emitter)
# Add any additional s3 configuration for client
config_kwargs['s3'] = s3_config
self._conditionally_unregister_fix_s3_host(endpoint_url, event_emitter)
new_config = Config(**config_kwargs)
endpoint_creator = EndpointCreator(event_emitter)
endpoint = endpoint_creator.create_endpoint(
service_model,
region_name=endpoint_config['region_name'],
endpoint_url=endpoint_config['endpoint_url'],
verify=verify,
response_parser_factory=self._response_parser_factory,
max_pool_connections=new_config.max_pool_connections,
timeout=(new_config.connect_timeout, new_config.read_timeout))
serializer = botocore.serialize.create_serializer(
protocol, parameter_validation)
response_parser = botocore.parsers.create_parser(protocol)
return {
'serializer': serializer,
'endpoint': endpoint,
'response_parser': response_parser,
'event_emitter': event_emitter,
'request_signer': signer,
'service_model': service_model,
'loader': self._loader,
'client_config': new_config,
'partition': partition
}
def _create_endpoint_creator(self, aws_access_key_id,
aws_secret_access_key, aws_session_token):
resolver = self.get_component('endpoint_resolver')
region = self.get_config_variable('region')
event_emitter = self.get_component('event_emitter')
if aws_secret_access_key is None:
credentials = self.get_credentials()
else:
credentials = None
user_agent = self.user_agent()
endpoint_creator = EndpointCreator(resolver, region, event_emitter,
credentials, user_agent)
return endpoint_creator
def setUp(self):
self.service_model = Mock(endpoint_prefix='ec2',
signature_version='v2',
signing_name='ec2')
self.environ = {}
self.environ_patch = patch('os.environ', self.environ)
self.environ_patch.start()
self.resolver = Mock()
self.resolver.construct_endpoint.return_value = {
'uri': 'https://endpoint.url',
'properties': {}
}
self.creator = EndpointCreator(self.resolver, 'us-west-2', Mock())
def test_endpoint_resolver_uses_signature_version(self):
resolver = Mock()
resolver.construct_endpoint.return_value = {
'uri': 'https://endpoint.url',
'properties': {
# Setting a signatureVersion in the properties
# back of an endpoint heuristic will override
# any other value when constructing an endpoint.
'signatureVersion': 'v4',
}
}
creator = EndpointCreator(resolver, 'us-west-2', Mock(), Mock(),
'user-agent')
endpoint = creator.create_endpoint(self.service_model)
self.assertIsInstance(endpoint.auth, SigV4Auth)
def _get_client_args(self, service_model, region_name, is_secure,
endpoint_url, verify, credentials, scoped_config,
client_config):
# A client needs:
#
# * serializer
# * endpoint
# * response parser
# * request signer
protocol = service_model.metadata['protocol']
serializer = botocore.serialize.create_serializer(
protocol, include_validation=True)
event_emitter = copy.copy(self._event_emitter)
endpoint_creator = EndpointCreator(self._endpoint_resolver,
region_name, event_emitter,
self._user_agent)
endpoint = endpoint_creator.create_endpoint(
service_model,
region_name,
is_secure=is_secure,
endpoint_url=endpoint_url,
verify=verify,
response_parser_factory=self._response_parser_factory)
response_parser = botocore.parsers.create_parser(protocol)
# This is only temporary in the sense that we should remove any
# region_name logic from endpoints and put it into clients.
# But that can only happen once operation objects are deprecated.
region_name = endpoint.region_name
signature_version, region_name = \
self._get_signature_version_and_region(
service_model, region_name, is_secure, scoped_config)
if client_config and client_config.signature_version is not None:
signature_version = client_config.signature_version
signer = RequestSigner(service_model.service_name, region_name,
service_model.signing_name, signature_version,
credentials, event_emitter)
return {
'serializer': serializer,
'endpoint': endpoint,
'response_parser': response_parser,
'event_emitter': event_emitter,
'request_signer': signer,
'service_model': service_model,
'loader': self._loader,
}
def test_endpoint_resolver_uses_credential_scope(self):
resolver = Mock()
resolver_region_override = 'us-east-1'
resolver.construct_endpoint.return_value = {
'uri': 'https://endpoint.url',
'properties': {
'credentialScope': {
'region': resolver_region_override,
}
}
}
original_region_name = 'us-west-2'
creator = EndpointCreator(resolver, original_region_name, Mock(),
'user-agent')
endpoint = creator.create_endpoint(self.service_model)
self.assertEqual(endpoint.region_name, 'us-east-1')
def _get_client_args(self, service_model, region_name, is_secure,
endpoint_url, verify, credentials, scoped_config,
client_config):
service_name = service_model.endpoint_prefix
protocol = service_model.metadata['protocol']
parameter_validation = True
if client_config and not client_config.parameter_validation:
parameter_validation = False
elif scoped_config:
raw_value = str(scoped_config.get('parameter_validation', ''))
if raw_value.lower() == 'false':
parameter_validation = False
serializer = botocore.serialize.create_serializer(
protocol, parameter_validation)
event_emitter = copy.copy(self._event_emitter)
response_parser = botocore.parsers.create_parser(protocol)
endpoint_bridge = ClientEndpointBridge(
self._endpoint_resolver,
scoped_config,
client_config,
service_signing_name=service_model.metadata.get('signingName'))
endpoint_config = endpoint_bridge.resolve(service_name, region_name,
endpoint_url, is_secure)
# Override the user agent if specified in the client config.
user_agent = self._user_agent
if client_config is not None:
if client_config.user_agent is not None:
user_agent = client_config.user_agent
if client_config.user_agent_extra is not None:
user_agent += ' %s' % client_config.user_agent_extra
signer = RequestSigner(service_name, endpoint_config['signing_region'],
endpoint_config['signing_name'],
endpoint_config['signature_version'],
credentials, event_emitter)
# Create a new client config to be passed to the client based
# on the final values. We do not want the user to be able
# to try to modify an existing client with a client config.
config_kwargs = dict(
region_name=endpoint_config['region_name'],
signature_version=endpoint_config['signature_version'],
user_agent=user_agent)
if client_config is not None:
config_kwargs.update(connect_timeout=client_config.connect_timeout,
read_timeout=client_config.read_timeout)
# Add any additional s3 configuration for client
self._inject_s3_configuration(config_kwargs, scoped_config,
client_config)
self._conditionally_unregister_fix_s3_host(endpoint_url, event_emitter)
new_config = Config(**config_kwargs)
endpoint_creator = EndpointCreator(event_emitter)
endpoint = endpoint_creator.create_endpoint(
service_model,
region_name=endpoint_config['region_name'],
endpoint_url=endpoint_config['endpoint_url'],
verify=verify,
response_parser_factory=self._response_parser_factory,
timeout=(new_config.connect_timeout, new_config.read_timeout))
return {
'serializer': serializer,
'endpoint': endpoint,
'response_parser': response_parser,
'event_emitter': event_emitter,
'request_signer': signer,
'service_model': service_model,
'loader': self._loader,
'client_config': new_config
}
def _get_client_args(self, service_model, region_name, is_secure,
endpoint_url, verify, credentials, scoped_config,
client_config):
protocol = service_model.metadata['protocol']
serializer = botocore.serialize.create_serializer(
protocol, include_validation=True)
event_emitter = copy.copy(self._event_emitter)
response_parser = botocore.parsers.create_parser(protocol)
# Determine what region the user provided either via the
# region_name argument or the client_config.
if region_name is None:
if client_config and client_config.region_name is not None:
region_name = client_config.region_name
# Based on what the user provided use the scoped config file
# to determine if the region is going to change and what
# signature should be used.
signature_version, region_name = \
self._get_signature_version_and_region(
service_model, region_name, is_secure, scoped_config,
endpoint_url)
# Override the signature if the user specifies it in the client
# config.
if client_config and client_config.signature_version is not None:
signature_version = client_config.signature_version
# Override the user agent if specified in the client config.
user_agent = self._user_agent
if client_config is not None:
if client_config.user_agent is not None:
user_agent = client_config.user_agent
if client_config.user_agent_extra is not None:
user_agent += ' %s' % client_config.user_agent_extra
signer = RequestSigner(service_model.service_name, region_name,
service_model.signing_name, signature_version,
credentials, event_emitter)
# Create a new client config to be passed to the client based
# on the final values. We do not want the user to be able
# to try to modify an existing client with a client config.
config_kwargs = dict(region_name=region_name,
signature_version=signature_version,
user_agent=user_agent)
if client_config is not None:
config_kwargs.update(connect_timeout=client_config.connect_timeout,
read_timeout=client_config.read_timeout)
new_config = Config(**config_kwargs)
endpoint_creator = EndpointCreator(self._endpoint_resolver,
region_name, event_emitter)
endpoint = endpoint_creator.create_endpoint(
service_model,
region_name,
is_secure=is_secure,
endpoint_url=endpoint_url,
verify=verify,
response_parser_factory=self._response_parser_factory,
timeout=(new_config.connect_timeout, new_config.read_timeout))
return {
'serializer': serializer,
'endpoint': endpoint,
'response_parser': response_parser,
'event_emitter': event_emitter,
'request_signer': signer,
'service_model': service_model,
'loader': self._loader,
'client_config': new_config
}
