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 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, 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'] 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, 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 }
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())
class TestEndpointCreator(unittest.TestCase): 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 tearDown(self): self.environ_patch.stop() def test_creates_endpoint_with_configured_url(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-east-1', endpoint_url='https://endpoint.url') self.assertEqual(endpoint.host, 'https://endpoint.url') def test_create_endpoint_with_default_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com') self.assertEqual(endpoint.timeout, DEFAULT_TIMEOUT) def test_create_endpoint_with_customized_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', timeout=123) self.assertEqual(endpoint.timeout, 123) def test_get_endpoint_default_verify_ssl(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com') self.assertTrue(endpoint.verify) def test_verify_ssl_can_be_disabled(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify=False) self.assertFalse(endpoint.verify) def test_verify_ssl_can_specify_cert_bundle(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify='/path/cacerts.pem') self.assertEqual(endpoint.verify, '/path/cacerts.pem') def test_honor_cert_bundle_env_var(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com') self.assertEqual(endpoint.verify, '/env/cacerts.pem') def test_env_ignored_if_explicitly_passed(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify='/path/cacerts.pem') # /path/cacerts.pem wins over the value from the env var. self.assertEqual(endpoint.verify, '/path/cacerts.pem') def test_can_specify_max_pool_conns(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', max_pool_connections=100 ) self.assertEqual(endpoint.max_pool_connections, 100)
def _get_client_args(self, service_model, region_name, is_secure, endpoint_url, verify, credentials, scoped_config, client_config, endpoint_bridge): 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_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 }
class TestEndpointCreator(unittest.TestCase): 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()) self.mock_session = Mock(spec=URLLib3Session) def tearDown(self): self.environ_patch.stop() def test_creates_endpoint_with_configured_url(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-east-1', endpoint_url='https://endpoint.url') self.assertEqual(endpoint.host, 'https://endpoint.url') def test_create_endpoint_with_default_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('timeout'), DEFAULT_TIMEOUT) def test_create_endpoint_with_customized_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', timeout=123, http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('timeout'), 123) def test_get_endpoint_default_verify_ssl(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertTrue(session_args.get('verify')) def test_verify_ssl_can_be_disabled(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify=False, http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertFalse(session_args.get('verify')) def test_verify_ssl_can_specify_cert_bundle(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify='/path/cacerts.pem', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('verify'), '/path/cacerts.pem') def test_client_cert_can_specify_path(self): client_cert = '/some/path/cert' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', client_cert=client_cert, http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('client_cert'), '/some/path/cert') def test_honor_cert_bundle_env_var(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('verify'), '/env/cacerts.pem') def test_env_ignored_if_explicitly_passed(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify='/path/cacerts.pem', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] # /path/cacerts.pem wins over the value from the env var. self.assertEqual(session_args.get('verify'), '/path/cacerts.pem') def test_can_specify_max_pool_conns(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', max_pool_connections=100, http_session_cls=self.mock_session, ) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('max_pool_connections'), 100) def test_socket_options(self): socket_options = [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)] self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session, socket_options=socket_options) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('socket_options'), socket_options)
class TestEndpointCreator(unittest.TestCase): 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 tearDown(self): self.environ_patch.stop() def test_endpoint_resolver_with_configured_region_name(self): endpoint = self.creator.create_endpoint(self.service_model) self.assertEqual(endpoint.host, 'https://endpoint.url') def test_create_endpoint_with_endpoint_resolver_exception(self): self.resolver.construct_endpoint.side_effect = \ BaseEndpointResolverError() with self.assertRaises(BaseEndpointResolverError): self.creator.create_endpoint(self.service_model) def test_create_endpoint_with_endpoint_url_and_resolver_exception(self): self.resolver.construct_endpoint.side_effect = \ BaseEndpointResolverError() endpoint = self.creator.create_endpoint(self.service_model, endpoint_url='https://foo') self.assertEqual(endpoint.host, 'https://foo') def test_create_endpoint_with_default_timeout(self): endpoint = self.creator.create_endpoint(self.service_model, 'us-west-2') self.assertEqual(endpoint.timeout, DEFAULT_TIMEOUT) def test_create_endpoint_with_customized_timeout(self): endpoint = self.creator.create_endpoint(self.service_model, 'us-west-2', timeout=123) self.assertEqual(endpoint.timeout, 123) def test_get_endpoint_default_verify_ssl(self): endpoint = self.creator.create_endpoint(self.service_model, 'us-west-2') self.assertTrue(endpoint.verify) def test_verify_ssl_can_be_disabled(self): endpoint = self.creator.create_endpoint(self.service_model, 'us-west-2', verify=False) self.assertFalse(endpoint.verify) def test_verify_ssl_can_specify_cert_bundle(self): endpoint = self.creator.create_endpoint(self.service_model, 'us-west-2', verify='/path/cacerts.pem') self.assertEqual(endpoint.verify, '/path/cacerts.pem') def test_honor_cert_bundle_env_var(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint(self.service_model, 'us-west-2') self.assertEqual(endpoint.verify, '/env/cacerts.pem') def test_env_ignored_if_explicitly_passed(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint(self.service_model, 'us-west-2', verify='/path/cacerts.pem') # /path/cacerts.pem wins over the value from the env var. self.assertEqual(endpoint.verify, '/path/cacerts.pem')
class TestEndpointCreator(unittest.TestCase): 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()) self.mock_session = Mock(spec=URLLib3Session) def tearDown(self): self.environ_patch.stop() def test_creates_endpoint_with_configured_url(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-east-1', endpoint_url='https://endpoint.url') self.assertEqual(endpoint.host, 'https://endpoint.url') def test_create_endpoint_with_default_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('timeout'), DEFAULT_TIMEOUT) def test_create_endpoint_with_customized_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', timeout=123, http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('timeout'), 123) def test_get_endpoint_default_verify_ssl(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertTrue(session_args.get('verify')) def test_verify_ssl_can_be_disabled(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify=False, http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertFalse(session_args.get('verify')) def test_verify_ssl_can_specify_cert_bundle(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify='/path/cacerts.pem', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('verify'), '/path/cacerts.pem') def test_client_cert_can_specify_path(self): client_cert = '/some/path/cert' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', client_cert=client_cert, http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('client_cert'), '/some/path/cert') def test_honor_cert_bundle_env_var(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('verify'), '/env/cacerts.pem') def test_env_ignored_if_explicitly_passed(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', verify='/path/cacerts.pem', http_session_cls=self.mock_session) session_args = self.mock_session.call_args[1] # /path/cacerts.pem wins over the value from the env var. self.assertEqual(session_args.get('verify'), '/path/cacerts.pem') def test_can_specify_max_pool_conns(self): endpoint = self.creator.create_endpoint( self.service_model, region_name='us-west-2', endpoint_url='https://example.com', max_pool_connections=100, http_session_cls=self.mock_session, ) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('max_pool_connections'), 100) def test_socket_options(self): socket_options = [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)] self.creator.create_endpoint(self.service_model, region_name='us-west-2', endpoint_url='https://example.com', http_session_cls=self.mock_session, socket_options=socket_options) session_args = self.mock_session.call_args[1] self.assertEqual(session_args.get('socket_options'), socket_options)
class TestEndpointCreator(unittest.TestCase): 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 tearDown(self): self.environ_patch.stop() def test_endpoint_resolver_with_configured_region_name(self): endpoint = self.creator.create_endpoint(self.service_model) self.assertEqual(endpoint.host, 'https://endpoint.url') def test_create_endpoint_with_endpoint_resolver_exception(self): self.resolver.construct_endpoint.side_effect = \ BaseEndpointResolverError() with self.assertRaises(BaseEndpointResolverError): self.creator.create_endpoint(self.service_model) def test_create_endpoint_with_endpoint_url_and_resolver_exception(self): self.resolver.construct_endpoint.side_effect = \ BaseEndpointResolverError() endpoint = self.creator.create_endpoint(self.service_model, endpoint_url='https://foo') self.assertEqual(endpoint.host, 'https://foo') def test_create_endpoint_with_default_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, 'us-west-2') self.assertEqual(endpoint.timeout, DEFAULT_TIMEOUT) def test_create_endpoint_with_customized_timeout(self): endpoint = self.creator.create_endpoint( self.service_model, 'us-west-2', timeout=123) self.assertEqual(endpoint.timeout, 123) def test_get_endpoint_default_verify_ssl(self): endpoint = self.creator.create_endpoint( self.service_model, 'us-west-2') self.assertTrue(endpoint.verify) def test_verify_ssl_can_be_disabled(self): endpoint = self.creator.create_endpoint( self.service_model, 'us-west-2', verify=False) self.assertFalse(endpoint.verify) def test_verify_ssl_can_specify_cert_bundle(self): endpoint = self.creator.create_endpoint( self.service_model, 'us-west-2', verify='/path/cacerts.pem') self.assertEqual(endpoint.verify, '/path/cacerts.pem') def test_honor_cert_bundle_env_var(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, 'us-west-2') self.assertEqual(endpoint.verify, '/env/cacerts.pem') def test_env_ignored_if_explicitly_passed(self): self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem' endpoint = self.creator.create_endpoint( self.service_model, 'us-west-2', verify='/path/cacerts.pem') # /path/cacerts.pem wins over the value from the env var. self.assertEqual(endpoint.verify, '/path/cacerts.pem')
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) 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) 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. client_config = Config( region_name=region_name, signature_version=signature_version, user_agent=user_agent) 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': client_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 }