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())
