def test_client_init(self):
self.assertRaises(client.VersionNotSupported,
client.ClientV1,
session=self.session,
api_version=(1, 999))
self.assertRaises(client.VersionNotSupported,
client.ClientV1,
session=self.session,
api_version=2)
self.assertTrue(
client.ClientV1(api_version=1,
session=self.session).server_api_versions())
self.assertTrue(
client.ClientV1(api_version='1.0',
session=self.session).server_api_versions())
self.assertTrue(
client.ClientV1(api_version=(1, 0),
session=self.session).server_api_versions())
self.assertTrue(
client.ClientV1(
inspector_url='http://127.0.0.1:5050').server_api_versions())
self.assertTrue(
client.ClientV1(inspector_url='http://127.0.0.1:5050/v1').
server_api_versions())
def load_auth_clients():
auth_fields = {
'auth_url': os.environ['OS_AUTH_URL'],
'username': os.environ['OS_USERNAME'],
'password': os.environ['OS_PASSWORD'],
'project_name': os.environ['OS_PROJECT_NAME'],
'user_domain_name': os.environ['OS_USER_DOMAIN_NAME'],
'project_domain_name': os.environ['OS_PROJECT_DOMAIN_NAME']
}
v3_auth = v3.Password(**auth_fields)
ks_sess = keystone_session.Session(auth=v3_auth, verify=False)
ks_client = keystone_client.Client(session=ks_sess)
CLIENTS['keystone'] = ks_client
gl_client = glanceclient.Client('2', session=ks_sess)
CLIENTS['glance'] = gl_client
nv_client = nova_client.Client(2, session=ks_sess)
CLIENTS['nova'] = nv_client
ir_client = ironic_client.get_client(1,
insecure=True,
os_ironic_api_version='1.46',
**auth_fields)
CLIENTS['ironic'] = ir_client
ins_client = ironic_inspector_client.ClientV1(session=ks_sess)
CLIENTS['ironic-inspector'] = ins_client
def setUp(self):
super(TestV1PythonAPI, self).setUp()
self.auth = token_endpoint.Token(endpoint='http://127.0.0.1:5050',
token='token')
self.session = ks_session.Session(self.auth)
self.client = client.ClientV1(session=self.session)
functional.cfg.CONF.set_override('store_data', 'none', 'processing')
def make_client(instance):
return ironic_inspector_client.ClientV1(
inspector_url=instance.get_configuration().get('inspector_url'),
session=instance.session,
api_version=instance._api_version[API_NAME],
interface=instance._interface,
region_name=instance._region_name)
def get_baremetal_introspection_client(self, context):
bmi_endpoint = keystone_utils.get_endpoint_for_project(
'ironic-inspector')
return ironic_inspector_client.ClientV1(
api_version='1.2',
inspector_url=bmi_endpoint.url,
region_name=bmi_endpoint.region,
auth_token=context.auth_token)
def get_baremetal_introspection_client(self, context):
bmi_endpoint = keystone_utils.get_endpoint_for_project(
context, 'ironic-inspector')
auth = Token(endpoint=bmi_endpoint.url, token=context.auth_token)
return ironic_inspector_client.ClientV1(
api_version='1.2',
region_name=bmi_endpoint.region,
session=ks_session.Session(auth))
def make_client(instance):
url = instance.get_configuration().get('inspector_url')
if not url:
url = instance.get_endpoint_for_service_type(
'baremetal-introspection',
interface=instance.interface,
region_name=instance._region_name)
return ironic_inspector_client.ClientV1(
inspector_url=url,
session=instance.session,
api_version=instance._api_version[API_NAME],
interface=instance._interface,
region_name=instance._region_name)
def get_disks(args):
try:
ironic = ironicclient.client.get_client(
1,
os_username=args.os_username,
os_password=args.os_password,
os_auth_url=args.os_auth_url,
os_tenant_name=args.os_tenant_name)
except ironicclient.exc.AmbiguousAuthSystem as exc:
logging.error(exc)
return [], {}
loader = ksloading.get_plugin_loader('password')
auth_plugin = loader.load_from_options(username=args.os_username,
password=args.os_password,
auth_url=args.os_auth_url,
tenant_name=args.os_tenant_name)
keystone_session = ksloading.session.Session().load_from_options(
auth=auth_plugin)
insp_client = ironic_inspector_client.ClientV1(session=keystone_session)
all_disks = []
node_data_json = {}
for node in ironic.node.list():
details = ironic.node.get(node.uuid)
data = insp_client.get_data(node.uuid)
root_disk = data.get('root_disk')
disks = data.get('inventory', {}).get('disks', [])
machine_uuid = data.get('extra', {}).get('system',
{}).get('product',
{}).get('uuid')
node_data_json[machine_uuid] = {}
node_data_json[machine_uuid]["swift::storage::disks::args"] = {}
for disk in disks:
if root_disk.get('name') != disk.get('name'):
device = os.path.basename(disk.get('name'))
entry = {
'ip': "%s.storagemgmt" % machine_uuid.lower(),
'device': device,
'size': disk.get('size', 0),
'meta': '%s:%s' % (machine_uuid.lower(), device)
}
all_disks.append(entry)
node_data_json[machine_uuid]["swift::storage::disks::args"][
device] = {}
return all_disks, node_data_json
def get_ironic_inspector_client(self):
"""Return the ironic inspector client.
This method will return a client object using the legacy library. Upon
the creation of a successful client creation, the client object will
be stored in the `self.client_cache object`, should this method be
called more than once, the cached object will automatically return,
resulting in fewer authentications and faster API interactions.
:returns: Object
"""
if 'ironic_inspector_client' in self.client_cache:
return self.client_cache['ironic_inspector_client']
else:
self.client_cache['ironic_inspector_client'] = \
ironic_inspector_client.ClientV1(session=self.sess)
return self.client_cache['ironic_inspector_client']
def _create_inspector_client(self):
assert ironic_inspector_client is not None, \
'BUG: _create_inspector_client called without inspector client'
# NOTE(dtantsur): endpoint_override is required to respect settings in
# clouds.yaml, such as baremetal_introspection_endpoint_override.
endpoint_override = self.cloud_region.get_endpoint(_INSPECTOR_TYPE)
try:
return ironic_inspector_client.ClientV1(
inspector_url=endpoint_override,
session=self.cloud_region.get_session(),
region_name=self.cloud_region.get_region_name(_INSPECTOR_TYPE),
)
except ironic_inspector_client.EndpointNotFound as e:
# Re-raise with a more obvious message.
raise exc.EndpointNotFound(_HELP % {
'err': e,
'cmd': sys.argv[0],
'project': 'ironic-inspector'
})
def get_inspector_client(self):
os_auth_url, os_tenant_name, os_username, os_password, \
os_user_domain_name, os_project_domain_name = \
CredentialHelper.get_undercloud_creds()
auth_url = os_auth_url + "v3"
kwargs = {
'username': os_username,
'password': os_password,
'auth_url': os_auth_url,
'project_id': os_tenant_name,
'user_domain_name': os_user_domain_name,
'project_domain_name': os_project_domain_name
}
auth = v3.Password(auth_url=auth_url,
username=os_username,
password=os_password,
project_name=os_tenant_name,
user_domain_name=os_user_domain_name,
project_domain_name=os_project_domain_name)
sess = session.Session(auth=auth)
self.inspector = ironic_inspector_client.ClientV1(session=sess)
def set_ironic_clients(self):
self.ironic_client_kwargs['os_auth_url'] = self.auth_url
self.ironic_client = \
ironicclient.get_client(1, **self.ironic_client_kwargs)
self.ironic_inspector_client = ironic_inspector_client.ClientV1(
session=self.keystone_session)
def get_client(self, **kwargs):
kwargs.setdefault('inspector_url', self.my_ip)
return ironic_inspector_client.ClientV1(**kwargs)
def setUp(self):
super(TestV1PythonAPI, self).setUp()
self.client = client.ClientV1()
functional.cfg.CONF.set_override('store_data', '', 'processing')
def setUp(self):
super(TestV1PythonAPI, self).setUp()
self.auth = token_endpoint.Token(endpoint='http://127.0.0.1:5050',
token='token')
self.session = ks_session.Session(self.auth)
self.client = client.ClientV1(session=self.session)
def get_client(self, **kwargs):
return ironic_inspector_client.ClientV1(auth_token=self.token,
**kwargs)
