def create_ironic_connection():
from ironicclient import client
from keystoneauth1 import loading
from keystoneauth1 import session
from keystoneclient import discover
kwargs = dict(auth_url=os.environ["OS_AUTH_URL"],
username=os.environ["OS_USERNAME"],
password=os.environ["OS_PASSWORD"])
kwargs["project_name"] = os.environ["OS_PROJECT_NAME"]
kwargs["user_domain_name"] = os.environ["OS_USER_DOMAIN_NAME"]
kwargs["project_domain_name"] = os.environ["OS_PROJECT_DOMAIN_NAME"]
loader = loading.get_plugin_loader('password')
keystone_auth = loader.load_from_options(**kwargs)
keystone_session = session.Session(auth=keystone_auth, verify=False)
ironic_endpoint_type = 'internalURL'
try:
ironic = client.Client(1,
session=keystone_session,
auth=keystone_auth,
endpoint_type=ironic_endpoint_type)
return ironic
except Exception as e:
logging.warning("Ironic connection failed. %s: %s" %
(e.__class__.__name__, e))
def get_client():
args = {'token': 'noauth', 'endpoint': IRONIC_ENDPOINT}
args['os_ironic_api_version'] = DEFAULT_IRONIC_API_VERSION
args['max_retries'] = 3
args['retry_interval'] = 1
return client.Client(1, **args)
def get_client(token=None,
api_version=DEFAULT_IRONIC_API_VERSION): # pragma: no cover
"""Get Ironic client instance."""
# NOTE: To support standalone ironic without keystone
if CONF.ironic.auth_strategy == 'noauth':
args = {'token': 'noauth', 'endpoint': CONF.ironic.ironic_url}
else:
global IRONIC_SESSION
if not IRONIC_SESSION:
IRONIC_SESSION = keystone.get_session(IRONIC_GROUP)
if token is None:
args = {
'session': IRONIC_SESSION,
'region_name': CONF.ironic.os_region
}
else:
ironic_url = IRONIC_SESSION.get_endpoint(
service_type=CONF.ironic.os_service_type,
endpoint_type=CONF.ironic.os_endpoint_type,
region_name=CONF.ironic.os_region)
args = {'token': token, 'endpoint': ironic_url}
args['os_ironic_api_version'] = api_version
args['max_retries'] = CONF.ironic.max_retries
args['retry_interval'] = CONF.ironic.retry_interval
return client.Client(1, **args)
def get_client(api_version=constants.DEFAULT_IRONIC_API_VERSION):
"""Create an Ironic client instance.
:param api_version: ironic api version, default latest.
:return: an Ironic Client instance
"""
if CONF.ironic.auth_strategy == 'noauth':
# To support standalone ironic without keystone
args = {'token': 'noauth', 'endpoint': CONF.ironic.endpoint}
else:
# To support keystone authentication
global KEYSTONE_SESSION
if not KEYSTONE_SESSION:
KEYSTONE_SESSION = create_keystone_session(
constants.IRONIC_GROUP_NAME)
args = {
'session': KEYSTONE_SESSION,
'region_name': CONF.ironic.os_region
}
args['os_ironic_api_version'] = api_version
args['max_retries'] = CONF.ironic.max_retries
args['retry_interval'] = CONF.ironic.retry_interval
# initialize an IronicClient instance
return client.Client(1, **args)
def get_ironic_client():
args = {
'token': 'noauth',
'endpoint': 'http://127.0.0.1:6385',
'os_ironic_api_version': '1.22',
'max_retries': 30,
'retry_interval': 2
}
return client.Client(1, **args)
def get_ironic_client():
args = {
'token': 'noauth',
'endpoint': CONF.get('ironic', 'api_url'),
'os_ironic_api_version': DEFAULT_IRONIC_API_VERSION,
'max_retries': 30,
'retry_interval': 2
}
return client.Client(1, **args)
def ironic(self, version='1.0'):
"""Returns Ironic client."""
client = ironic.Client(version,
username=self.endpoint.username,
password=self.endpoint.password,
tenant_name=self.endpoint.tenant_name,
auth_url=self.endpoint.auth_url,
timeout=CONF.openstack_client_http_timeout,
insecure=CONF.https_insecure,
cacert=CONF.https_cacert)
return client
def get_lease_info(sess, user_id, project_id):
lease_list = []
blazar = blazar_client.Client("1",
service_type="reservation",
interface="publicURL",
session=sess)
ironic = ironic_client.Client("1", session=sess)
leases = blazar.lease.list()
for lease in leases:
if lease.get("user_id") != user_id or lease.get(
"project_id") != project_id:
continue
# Ignore if more than 3 days out of date
end_date = parser.parse(lease.get("end_date"))
date_diff = datetime.utcnow() - end_date
if date_diff.days > 3:
continue
lease_dict = {}
lease_dict["name"] = lease.get("name")
lease_dict["status"] = lease.get("status")
lease_dict["start_date"] = str(parser.parse(lease.get("start_date")))
lease_dict["end_date"] = str(end_date)
lease_dict["id"] = lease.get("id")
lease_dict["hosts"] = []
resource_map = {r["id"]: r for r in blazar.host.list()}
for blazar_host in blazar.host.list_allocations():
if any(res["lease_id"] == lease_dict["id"]
for res in blazar_host["reservations"]):
resource_host = resource_map[blazar_host["resource_id"]]
host = {
"node_name": resource_host["node_name"],
"uid": resource_host["uid"],
"node_type": resource_host["node_type"],
}
node = ironic.node.get(resource_host["uid"])
host["provision_state"] = node.provision_state
host["instance_uuid"] = node.instance_uuid
host["last_error"] = node.last_error
lease_dict["hosts"].append(host)
lease_dict["networks"] = []
resource_map = {r["id"]: r for r in blazar.network.list()}
for network in blazar.network.list_allocations():
if any(res["lease_id"] == lease_dict["id"]
for res in network["reservations"]):
lease_dict["networks"].append(
resource_map[network["resource_id"]])
lease_list.append(lease_dict)
return lease_list
def ironicclient(request):
"""Returns a client connected to the Ironic backend.
"""
insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', DEFAULT_INSECURE)
cacert = getattr(settings, 'OPENSTACK_SSL_CACERT', DEFAULT_CACERT)
ironic_url = base.url_for(request, IRONIC_CLIENT_CLASS_NAME)
return client.Client(1,
ironic_url,
project_id=request.user.project_id,
token=request.user.token.id,
insecure=insecure,
cacert=cacert)
def baremetal_configure_boot(self, kwargs):
"""Run the action configure boot, and return data.
:param kwargs: options to pass into the ConfigureBootAction
:type kwargs: Dictionary
:returns: Object
"""
action = baremetal.ConfigureBootAction(**kwargs)
baremetal_client = ironicclient.Client(1, session=self.sess)
image_client = glanceclient.Client(2, session=self.sess)
return action.configure_boot(baremetal_client, image_client)
def baremetal_configure_root_device(self, kwargs):
"""Run the action configure root device, and return data.
:param kwargs: options to pass into the ConfigureRootDeviceAction
:type kwargs: Dictionary
:returns: Object
"""
action = baremetal.ConfigureRootDeviceAction(**kwargs)
baremetal_client = ironicclient.Client(1, session=self.sess)
inspector_client = self.get_ironic_inspector_client()
if not action.root_device:
return
else:
return action.configure_root_device(baremetal_client,
inspector_client)
def _get_ironic_client(self):
"""Get Ironic client instance."""
# NOTE: To support standalone ironic without keystone
if cfg.CONF.ironic.auth_strategy == 'noauth':
args = {'token': 'noauth',
'endpoint': cfg.CONF.ironic.ironic_url}
else:
global IRONIC_SESSION
if not IRONIC_SESSION:
IRONIC_SESSION = self._get_session(IRONIC_CONF_SECTION)
args = {'session': IRONIC_SESSION,
'region_name': cfg.CONF.ironic.region_name,
'endpoint_type': cfg.CONF.ironic.endpoint_type}
args['os_ironic_api_version'] = IRONIC_API_VERSION
args['max_retries'] = cfg.CONF.ironic.max_retries
args['retry_interval'] = cfg.CONF.ironic.retry_interval
return client.Client(IRONIC_CLIENT_VERSION, **args)
def get_client(token=None,
api_version=DEFAULT_IRONIC_API_VERSION): # pragma: no cover
"""Get Ironic client instance."""
global IRONIC_SESSION
# NOTE: To support standalone ironic without keystone
# TODO(pas-ha) remove handling of deprecated opts in Rocky
# TODO(pas-ha) rewrite when ironicclient natively supports 'none' auth
# via sessions https://review.openstack.org/#/c/359061/
if CONF.ironic.auth_strategy == 'noauth':
CONF.set_override('auth_type', 'none', group='ironic')
if not IRONIC_SESSION:
IRONIC_SESSION = keystone.get_session('ironic')
args = {
'os_ironic_api_version': api_version,
'max_retries': CONF.ironic.max_retries,
'retry_interval': CONF.ironic.retry_interval
}
adapter_opts = dict()
# TODO(pas-ha) use service auth with incoming token
if CONF.ironic.auth_type != 'none':
if token is None:
args['session'] = IRONIC_SESSION
else:
args['token'] = token
# TODO(pas-ha): remove handling of deprecated options in Rocky
if CONF.ironic.os_region and not CONF.ironic.region_name:
adapter_opts['region_name'] = CONF.ironic.os_region
if (CONF.ironic.auth_type == 'none' and not CONF.ironic.endpoint_override
and CONF.ironic.ironic_url):
adapter_opts['endpoint_override'] = CONF.ironic.ironic_url
adapter = keystone.get_adapter('ironic',
session=IRONIC_SESSION,
**adapter_opts)
endpoint = adapter.get_endpoint()
return client.Client(1, endpoint, **args)
def get_baremetal_client(self):
"""Return the baremetal (ironic) 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 'ironicclient' in self.client_cache:
return self.client_cache['ironicclient']
else:
self.client_cache['ironicclient'] = \
ironicclient.Client(
1,
session=self.sess,
os_ironic_api_version='1.36'
)
return self.client_cache['ironicclient']
def main(self, argv):
# Parse args once to find version
parser = self.get_base_parser()
(options, args) = parser.parse_known_args(argv)
self._setup_debugging(options.debug)
# build available subcommands based on version
(api_major_version, os_ironic_api_version) = (
self._check_version(options.ironic_api_version))
subcommand_parser = self.get_subcommand_parser(api_major_version)
self.parser = subcommand_parser
# Handle top-level --help/-h before attempting to parse
# a command off the command line
if options.help or not argv:
self.do_help(options)
return 0
# Parse args again and call whatever callback was selected
args = subcommand_parser.parse_args(argv)
# Short-circuit and deal with these commands right away.
if args.func == self.do_help:
self.do_help(args)
return 0
elif args.func == self.do_bash_completion:
self.do_bash_completion()
return 0
if not (args.os_auth_token and (args.ironic_url or args.os_endpoint)):
if not args.os_username:
raise exc.CommandError(_("You must provide a username via "
"either --os-username or via "
"env[OS_USERNAME]"))
if not args.os_password:
# No password, If we've got a tty, try prompting for it
if hasattr(sys.stdin, 'isatty') and sys.stdin.isatty():
# Check for Ctl-D
try:
args.os_password = getpass.getpass(
'OpenStack Password: '******'t have a tty or the
# user Ctl-D when prompted.
if not args.os_password:
raise exc.CommandError(_("You must provide a password via "
"either --os-password, "
"env[OS_PASSWORD], "
"or prompted response"))
if not (args.os_tenant_id or args.os_tenant_name or
args.os_project_id or args.os_project_name):
raise exc.CommandError(
_("You must provide a project name or"
" project id via --os-project-name, --os-project-id,"
" env[OS_PROJECT_ID] or env[OS_PROJECT_NAME]. You may"
" use os-project and os-tenant interchangeably."))
if not args.os_auth_url:
raise exc.CommandError(_("You must provide an auth url via "
"either --os-auth-url or via "
"env[OS_AUTH_URL]"))
endpoint = args.ironic_url or args.os_endpoint
service_type = args.os_service_type or 'baremetal'
project_id = args.os_project_id or args.os_tenant_id
project_name = args.os_project_name or args.os_tenant_name
if (args.os_auth_token and (args.ironic_url or args.os_endpoint)):
kwargs = {
'token': args.os_auth_token,
'insecure': args.insecure,
'timeout': args.timeout,
'ca_file': args.os_cacert,
'cert_file': args.os_cert,
'key_file': args.os_key,
'auth_ref': None,
}
elif (args.os_username and
args.os_password and
args.os_auth_url and
(project_id or project_name)):
keystone_session = kssession.Session.load_from_cli_options(args)
kwargs = {
'username': args.os_username,
'user_domain_id': args.os_user_domain_id,
'user_domain_name': args.os_user_domain_name,
'password': args.os_password,
'auth_token': args.os_auth_token,
'project_id': project_id,
'project_name': project_name,
'project_domain_id': args.os_project_domain_id,
'project_domain_name': args.os_project_domain_name,
}
keystone_auth = self._get_keystone_auth(keystone_session,
args.os_auth_url,
**kwargs)
if not endpoint:
svc_type = args.os_service_type
region_name = args.os_region_name
endpoint = keystone_auth.get_endpoint(keystone_session,
service_type=svc_type,
region_name=region_name)
endpoint_type = args.os_endpoint_type or 'publicURL'
kwargs = {
'auth_url': args.os_auth_url,
'session': keystone_session,
'auth': keystone_auth,
'service_type': service_type,
'endpoint_type': endpoint_type,
'region_name': args.os_region_name,
'username': args.os_username,
'password': args.os_password,
}
kwargs['os_ironic_api_version'] = os_ironic_api_version
client = iroclient.Client(api_major_version, endpoint, **kwargs)
try:
args.func(client, args)
except exc.Unauthorized:
raise exc.CommandError(_("Invalid OpenStack Identity credentials"))
def test_client_session_via_kwargs(self):
session = mock.Mock()
session.get_endpoint.return_value = 'http://localhost:35357/v2.0'
iroclient.Client('1', session=session,
endpoint_override="http://example.com")
def _get_ironic_client(ironic_api_version="1.58"):
keystone_session = openstack_utils.get_overcloud_keystone_session()
ironic = ironic_client.Client(1, session=keystone_session,
os_ironic_api_version=ironic_api_version)
return ironic
