def __init__(self, auth_args, logger=None): """Initialization of SFCClient object :param auth_args (dict): A dict of essential arguments for Keystone authentication :param logger(logging.Logger): Logger object """ self.auth_args = auth_args if not logger: logger = _get_logger() self.logger = logger sess = self._construct_session() adap_args = { 'user_agent': 'python-sfcclient', 'service_type': 'network', 'service_name': 'neutron', 'interface': 'admin', # Min and maximum API version, appended at the end of the Endpoint 'min_version': NEUTRON_API_VERSION, 'max_version': NEUTRON_API_VERSION } # HTTP client for REST requests self._httpclient = adapter.Adapter(sess, **adap_args) # user and project IDs self.user_id = self._httpclient.get_user_id() self.project_id = self._httpclient.get_project_id() self.endpoint = self._httpclient.get_endpoint()
def test_adapter_get_token(self): auth = CalledAuthPlugin() sess = client_session.Session() adpt = adapter.Adapter(sess, auth=auth) self.assertEqual(self.TEST_TOKEN, adpt.get_token()) self.assertTrue(auth.get_token_called)
def setUp(self): super(PlacementFixture, self).setUp() # Turn off manipulation of socket_options in TCPKeepAliveAdapter # to keep wsgi-intercept happy. Replace it with the method # from its superclass. self.useFixture( fixtures.MonkeyPatch( 'keystoneauth1.session.TCPKeepAliveAdapter.init_poolmanager', adapters.HTTPAdapter.init_poolmanager)) self._client = ka.Adapter(ks.Session(auth=None), raise_exc=False) # NOTE(sbauza): We need to mock the scheduler report client because # we need to fake Keystone by directly calling the endpoint instead # of looking up the service catalog, like we did for the OSAPIFixture. self.useFixture( fixtures.MonkeyPatch( 'nova.scheduler.client.report.SchedulerReportClient.get', self._fake_get)) self.useFixture( fixtures.MonkeyPatch( 'nova.scheduler.client.report.SchedulerReportClient.post', self._fake_post)) self.useFixture( fixtures.MonkeyPatch( 'nova.scheduler.client.report.SchedulerReportClient.put', self._fake_put)) self.useFixture( fixtures.MonkeyPatch( 'nova.scheduler.client.report.SchedulerReportClient.delete', self._fake_delete)) self.api = PlacementApiClient(self)
def test_logger_object_passed(self): logger = logging.getLogger(uuid.uuid4().hex) logger.setLevel(logging.DEBUG) logger.propagate = False io = six.StringIO() handler = logging.StreamHandler(io) logger.addHandler(handler) auth = AuthPlugin() sess = client_session.Session(auth=auth) adpt = adapter.Adapter(sess, auth=auth, logger=logger) response = uuid.uuid4().hex self.stub_url('GET', text=response, headers={'Content-Type': 'text/html'}) resp = adpt.get(self.TEST_URL, logger=logger) self.assertEqual(response, resp.text) output = io.getvalue() self.assertIn(self.TEST_URL, output) self.assertIn(response, output) self.assertNotIn(self.TEST_URL, self.logger.output) self.assertNotIn(response, self.logger.output)
def test_user_and_project_id(self): auth = AuthPlugin() sess = client_session.Session() adpt = adapter.Adapter(sess, auth=auth) self.assertEqual(auth.TEST_USER_ID, adpt.get_user_id()) self.assertEqual(auth.TEST_PROJECT_ID, adpt.get_project_id())
def test_logger_object_passed(self): logger = logging.getLogger(uuid.uuid4().hex) logger.setLevel(logging.DEBUG) logger.propagate = False io = six.StringIO() handler = logging.StreamHandler(io) logger.addHandler(handler) auth = AuthPlugin() sess = client_session.Session(auth=auth) adpt = adapter.Adapter(sess, auth=auth, logger=logger) response = {uuid.uuid4().hex: uuid.uuid4().hex} self.stub_url('GET', json=response, headers={'Content-Type': 'application/json'}) resp = adpt.get(self.TEST_URL, logger=logger) self.assertEqual(response, resp.json()) output = io.getvalue() self.assertIn(self.TEST_URL, output) self.assertIn(list(response.keys())[0], output) self.assertIn(list(response.values())[0], output) self.assertNotIn(self.TEST_URL, self.logger.output) self.assertNotIn(list(response.keys())[0], self.logger.output) self.assertNotIn(list(response.values())[0], self.logger.output)
def get_session_client(self, service_key, version=None): """Return a prepped requests adapter for a given service. This is useful for making direct requests calls against a 'mounted' endpoint. That is, if you do: client = get_session_client('compute') then you can do: client.get('/flavors') and it will work like you think. """ (version, min_version, max_version) = self._get_version_args(service_key, version) return adapter.Adapter(session=self.get_session(), service_type=self.get_service_type(service_key), service_name=self.get_service_name(service_key), interface=self.get_interface(service_key), region_name=self.region_name, version=version, min_version=min_version, max_version=max_version)
def _create_client(self, **kwargs): """Create the HTTP session accessing the placement service.""" username = kwargs.pop('username', CONF.os_admin_username) user_domain_name = kwargs.pop('user_domain_name', CONF.os_admin_user_domain_name) project_name = kwargs.pop('project_name', CONF.os_admin_project_name) password = kwargs.pop('password', CONF.os_admin_password) project_domain_name = kwargs.pop('project_domain_name', CONF.os_admin_project_domain_name) auth_url = kwargs.pop('auth_url', None) if auth_url is None: auth_url = "%s://%s:%s/%s/%s" % ( CONF.os_auth_protocol, CONF.os_auth_host, CONF.os_auth_port, CONF.os_auth_prefix, CONF.os_auth_version) auth = v3.Password(auth_url=auth_url, username=username, password=password, project_name=project_name, user_domain_name=user_domain_name, project_domain_name=project_domain_name) sess = session.Session(auth=auth) # Set accept header on every request to ensure we notify placement # service of our response body media type preferences. headers = {'accept': 'application/json'} client = adapter.Adapter(session=sess, service_type='placement', interface='public', additional_headers=headers) return client
def _create_identity_server(self): # NOTE(jamielennox): Loading Session here should be exactly the # same as calling Session.load_from_conf_options(CONF, GROUP) # however we can't do that because we have to use _conf_get to # support the paste.ini options. sess = session_loading.Session().load_from_options( cert=self._conf_get('certfile'), key=self._conf_get('keyfile'), cacert=self._conf_get('cafile'), insecure=self._conf_get('insecure'), timeout=self._conf_get('http_connect_timeout'), user_agent=self._build_useragent_string()) auth_plugin = self._get_auth_plugin() adap = adapter.Adapter( sess, auth=auth_plugin, service_type='identity', interface='admin', region_name=self._conf_get('region_name'), connect_retries=self._conf_get('http_request_max_retries')) auth_version = self._conf_get('auth_version') if auth_version is not None: auth_version = discover.normalize_version_number(auth_version) return _identity.IdentityServer( self.log, adap, include_service_catalog=self._include_service_catalog, requested_auth_version=auth_version)
def test_version_data_legacy_ironic_no_override(self): """Validate detection of legacy Ironic microversion ranges.""" ironic_url = 'https://bare-metal.example.com/v1/' self.requests_mock.get(ironic_url, status_code=200, json={ 'id': 'v1', 'links': [{ "href": ironic_url, "rel": "self" }] }, headers={ 'X-OpenStack-Ironic-API-Minimum-Version': '1.3', 'X-OpenStack-Ironic-API-Maximum-Version': '1.21', }) plugin = noauth.NoAuth() a = adapter.Adapter(self.session, auth=plugin, service_type='baremetal') self.assertIsNone(a.get_api_major_version())
def __init__(self, conf, latest_microversion=False): conf.set_override('auth_strategy', 'noauth2', group='api') def app(): return deploy.loadapp(conf) self.url = 'http://%s/placement' % str(uuidutils.generate_uuid()) # Supply our own session so the wsgi-intercept can intercept # the right thing. request_session = requests.Session() headers = { 'x-auth-token': 'admin', } # TODO(efried): See below if latest_microversion: headers['OpenStack-API-Version'] = 'placement latest' self.adapter = adapter.Adapter(session.Session( auth=None, session=request_session, additional_headers=headers), service_type='placement', raise_exc=False) # TODO(efried): Figure out why this isn't working: # default_microversion='latest' if latest_microversion else None) self._mocked_endpoint = mock.patch( 'keystoneauth1.session.Session.get_endpoint', new=mock.Mock(return_value=self.url)) super(PlacementDirect, self).__init__(app, url=self.url)
def __init__(self, session=None, adapter_options={}, cacert=None, insecure=False, **kwargs): adapter_options.setdefault('service_type', 'rating') if insecure: verify_cert = False else: if cacert: verify_cert = cacert else: verify_cert = True self.session = session if self.session is None: self.session = ks_session.Session(verify=verify_cert, **kwargs) self.api_client = adapter.Adapter(session=self.session, **adapter_options) self.info = info.InfoManager(self.api_client) self.collector = collector.CollectorManager(self.api_client) self.rating = rating.RatingManager(self.api_client) self.report = report.ReportManager(self.api_client) self.storage = storage.StorageManager(self.api_client)
def test_adapter_invalidate(self): auth = CalledAuthPlugin() sess = client_session.Session() adpt = adapter.Adapter(sess, auth=auth) adpt.invalidate() self.assertTrue(auth.invalidate_called)
def test_methods(self): sess = client_session.Session() adpt = adapter.Adapter(sess) url = 'http://url' for method in ['get', 'head', 'post', 'put', 'patch', 'delete']: with mock.patch.object(adpt, 'request') as m: getattr(adpt, method)(url) m.assert_called_once_with(url, method.upper())
def get_flocx_market_client(): auth_plugin = ks_loading.load_auth_from_conf_options(CONF, 'flocx_market') sess = ks_loading.load_session_from_conf_options(CONF, 'flocx_market', auth=auth_plugin) adpt = adapter.Adapter(session=sess, service_type='marketplace', interface='public') return flocx_market_client.FlocxMarketClient(adpt)
def _create_loaded_adapter(self): auth = CalledAuthPlugin() sess = client_session.Session() return adapter.Adapter(sess, auth=auth, service_type=self.SERVICE_TYPE, service_name=self.SERVICE_NAME, interface=self.INTERFACE, region_name=self.REGION_NAME, user_agent=self.USER_AGENT, version=self.VERSION)
def test_adapter_user_agent_session(self): sess = client_session.Session(app_name='ksatest', app_version='1.2.3') adap = adapter.Adapter(session=sess) url = 'http://keystone.test.com' self.requests_mock.get(url) adap.get(url) agent = 'ksatest/1.2.3' self.assertEqual(agent + ' ' + client_session.DEFAULT_USER_AGENT, self.requests_mock.last_request.headers['User-Agent'])
def get_heat_client(): loader = loading.get_plugin_loader('password') auth = loader.load_from_options( auth_url=environ['OS_AUTH_URL'], username=environ['OS_USERNAME'], password=environ['OS_PASSWORD'], project_id=environ['OS_PROJECT_ID'], user_domain_name=environ['OS_USER_DOMAIN_NAME']) sess = session.Session(auth=auth) adp = adapter.Adapter(session=sess, region_name=environ['OS_REGION_NAME']) return client.Client('1', session=adp)
def __init__(self): super(NoAuthReportClient, self).__init__() # Supply our own session so the wsgi-intercept can intercept # the right thing. Another option would be to use the direct # urllib3 interceptor. request_session = requests.Session() headers = { 'x-auth-token': 'admin', 'OpenStack-API-Version': 'placement latest', } self._client = adapter.Adapter(session.Session( auth=None, session=request_session, additional_headers=headers), service_type='placement')
def gnocchi_client(api_session, region_name=None, service_type='metric', version=None, interface=None): region_name = region_name or plugin_settings.DEFAULT_REGION interface = interface or plugin_settings.DEFAULT_INTERFACE version = int(float((version or plugin_settings.METRIC_API_VERSION))) session = adapter.Adapter(api_session, service_type=service_type, interface=interface, region_name=region_name) return GnocchiClient(version=version, session=session)
def test_adapter_user_agent_adapter(self): sess = client_session.Session() adap = adapter.Adapter(client_name='testclient', client_version='4.5.6', session=sess) url = 'http://keystone.test.com' self.requests_mock.get(url) adap.get(url) agent = 'testclient/4.5.6' self.assertEqual(agent + ' ' + client_session.DEFAULT_USER_AGENT, self.requests_mock.last_request.headers['User-Agent'])
def test_endpoint_data_token_endpoint_adapter(self): mock = self.requests_mock.get( V3_URL, status_code=200, json=V3_VERSION_ENTRY) plugin = token_endpoint.Token(endpoint=V3_URL, token='bogus') client = adapter.Adapter(session.Session(plugin)) data = client.get_endpoint_data() self.assertEqual(data.api_version, (3, 0)) self.assertEqual(data.url, V3_URL) self.assertEqual(client.get_api_major_version(), (3, 0)) self.assertEqual(client.get_endpoint(), V3_URL) self.assertTrue(mock.called_once)
def test_adapter_connect_retries(self): retries = 2 sess = client_session.Session() adpt = adapter.Adapter(sess, connect_retries=retries) self.stub_url('GET', exc=requests.exceptions.ConnectionError()) with mock.patch('time.sleep') as m: self.assertRaises(exceptions.ConnectionError, adpt.get, self.TEST_URL) self.assertEqual(retries, m.call_count) # we count retries so there will be one initial request + 2 retries self.assertThat(self.requests_mock.request_history, matchers.HasLength(retries + 1))
def test_endpoint_data_noauth_adapter(self): mock = self.requests_mock.get(V3_URL, status_code=200, json=V3_VERSION_ENTRY) client = adapter.Adapter(session.Session(noauth.NoAuth()), endpoint_override=V3_URL) data = client.get_endpoint_data() self.assertEqual(data.api_version, (3, 0)) self.assertEqual(data.url, V3_URL) self.assertEqual(client.get_api_major_version(), (3, 0)) self.assertEqual(client.get_endpoint(), V3_URL) self.assertTrue(mock.called_once)
def send_to_flocx_market(self): auth_plugin = ks_loading.load_auth_from_conf_options( CONF, 'flocx_market') sess = ks_loading.load_session_from_conf_options(CONF, 'flocx_market', auth=auth_plugin) marketplace_offer_dict = self.to_marketplace_dict() adpt = adapter.Adapter(session=sess, service_type='marketplace', interface='public') marketplace_client = flocx_market_client.FlocxMarketClient(adpt) res_status_code = marketplace_client.send_offer(marketplace_offer_dict) return res_status_code
def get_session(auth_url, username, password, project_name, user_domain_name='default', project_domain_name='default', region_name=None, interface=None): auth = v3.Password(auth_url=auth_url, username=username, password=password, project_name=project_name, user_domain_name=user_domain_name, project_domain_name=project_domain_name) sess = session.Session(auth=auth) return adapter.Adapter(sess, region_name=region_name, interface=interface)
def test_adapter_user_agent_session_adapter_additional(self): sess = client_session.Session(app_name='ksatest', app_version='1.2.3', additional_user_agent=[('one', '1.1.1'), ('two', '2.2.2')]) adap = adapter.Adapter(client_name='testclient', client_version='4.5.6', session=sess) url = 'http://keystone.test.com' self.requests_mock.get(url) adap.get(url) agent = 'ksatest/1.2.3 one/1.1.1 two/2.2.2 testclient/4.5.6' self.assertEqual(agent + ' ' + client_session.DEFAULT_USER_AGENT, self.requests_mock.last_request.headers['User-Agent'])
def test_adapter_user_agent_session_override(self): sess = client_session.Session(app_name='ksatest', app_version='1.2.3', additional_user_agent=[('one', '1.1.1'), ('two', '2.2.2')]) adap = adapter.Adapter(client_name='testclient', client_version='4.5.6', session=sess) url = 'http://keystone.test.com' self.requests_mock.get(url) override_user_agent = '%s/%s' % (uuid.uuid4().hex, uuid.uuid4().hex) adap.get(url, user_agent=override_user_agent) self.assertEqual(override_user_agent, self.requests_mock.last_request.headers['User-Agent'])
def _create_identity_server(self): adap = adapter.Adapter( self._session, auth=self._auth, service_type='identity', interface='admin', region_name=self._conf.get('region_name'), connect_retries=self._conf.get('http_request_max_retries')) auth_version = self._conf.get('auth_version') if auth_version is not None: auth_version = discover.normalize_version_number(auth_version) return _identity.IdentityServer( self.log, adap, include_service_catalog=self._include_service_catalog, requested_auth_version=auth_version)
def test_setting_endpoint_override(self): endpoint_override = 'http://overrideurl' path = '/path' endpoint_url = endpoint_override + path auth = CalledAuthPlugin() sess = client_session.Session(auth=auth) adpt = adapter.Adapter(sess, endpoint_override=endpoint_override) response = uuid.uuid4().hex self.requests_mock.get(endpoint_url, text=response) resp = adpt.get(path) self.assertEqual(response, resp.text) self.assertEqual(endpoint_url, self.requests_mock.last_request.url) self.assertEqual(endpoint_override, adpt.get_endpoint())