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