def __init__(self, start_script=None): self.start_script = start_script parser = SafeConfigParser() try: parser.read("/home/ubuntu/VM-automatic-deploy/credentials.txt") except IOError: print("Credential file missing") sys.exit() self.username = parser.get("auth", "username") self.password = parser.get("auth", "password") self.tenant_name = parser.get("auth", "tenant_name") self.user_domain = parser.get("auth", "user_domain_name") self.project_domain = parser.get("auth", "project_domain_name") self.project_domain_id = parser.get("auth", "project_domain_id") self.auth_url = parser.get("auth", "auth_url") self.net_id = parser.get("auth", "net_id") self.pkey_id = parser.get("auth", "pkey_id") auth = v3.Password(username=self.username, password=self.password, project_name=self.tenant_name, auth_url=self.auth_url, user_domain_name=self.user_domain, project_domain_name=self.project_domain, project_id=self.project_domain_id) sess = session.Session(auth=auth) self.nova = NovaClient("2", session=sess)
def _get_nova_client(ctx): return NovaClient("2", ctx.username, ctx.api_key, ctx.tenant, auth_url=nova, auth_system=None) # TODO
def __init__(self, lease, key='default', image=DEFAULT_IMAGE, **extra): self.lease = lease self.session = self.lease.session self.neutron = NeutronClient( session=self.session, region_name=os.environ.get('OS_REGION_NAME')) self.nova = NovaClient('2', session=self.session, region_name=os.environ.get('OS_REGION_NAME')) self.glance = GlanceClient( '2', session=self.session, region_name=os.environ.get('OS_REGION_NAME')) self.ip = None self._fip = None self.image = resolve_image_idname(self.glance, image) net_ids = extra.pop('net_ids', None) net_name = extra.pop('net_name', None) if net_ids is None and net_name is not None: net_ids = [get_networkid_byname(self.neutron, net_name)] self.server_kwargs = instance_create_args(self.lease.reservation, key=key, image=self.image, net_ids=net_ids, **extra) self.server = self.nova.servers.create(**self.server_kwargs) self.id = self.server.id self.name = self.server.name
def _openstack(**config): """ Create Cinder and Nova volume managers suitable for use in the creation of a ``CinderBlockDeviceAPI``. They will be configured to use the region where the server that is running this code is running. :param config: Any additional configuration (possibly provider-specific) necessary to authenticate a session for use with the CinderClient and NovaClient. :return: A ``dict`` of keyword arguments for ``cinder_api``. """ # The execution context should have set up this environment variable, # probably by inspecting some cloud-y state to discover where this code is # running. Since the execution context is probably a stupid shell script, # fix the casing of the region name here (keystone is very sensitive to # case) instead of forcing me to figure out how to upper case things in # bash (I already learned a piece of shell syntax today, once is all I can # take). region = environ.get('FLOCKER_FUNCTIONAL_TEST_OPENSTACK_REGION') if region is not None: region = region.upper() auth = _openstack_auth_from_config(**config) session = Session(auth=auth) cinder_client = CinderClient( session=session, region_name=region, version=1 ) nova_client = NovaClient( session=session, region_name=region, version=2 ) return dict( cinder_client=cinder_client, nova_client=nova_client )
def nova_client_trove_admin(context, region_name=None, password=None): """ Returns a nova client object with the trove admin credentials All parameters are ignored since all the required informations are taken from CONF. The parameters are there just to be able to replace trove.common.nova_client. :param context :param region_name :param password :return novaclient: novaclient with trove admin credentials :rtype: novaclient.Client """ client = NovaClient(CONF.nova_client_version, username=CONF.nova_proxy_admin_user, password=CONF.nova_proxy_admin_pass, project_name=CONF.nova_proxy_admin_tenant_name, auth_url=CONF.trove_auth_url, service_type=CONF.nova_compute_service_type, region_name=CONF.os_region_name, insecure=CONF.nova_api_insecure) if CONF.nova_compute_url and CONF.nova_proxy_admin_tenant_id: client.client.endpoint_override = "%s/%s/" % ( normalize_url(compute_url), CONF.nova_proxy_admin_tenant_id) return client
def get_nova_client(region_name, api_version=2): """ Instantiate a python novaclient.Client() object with proper credentials """ # TODO this function duplicates features and code from get_openstack_connection. Merge them nova = NovaClient( api_version, username=settings.OPENSTACK_USER, password=settings.OPENSTACK_PASSWORD, project_name=settings.OPENSTACK_TENANT, auth_url=settings.OPENSTACK_AUTH_URL, region_name=region_name, ) # API queries via the nova client occasionally get connection errors from the OpenStack provider. # To gracefully recover when the unavailability is short-lived, ensure some requests are retried # before giving up. # - requests's HTTPAdapter provides a max_retries parameter that will be passed to urllib3 # - keystoneauth1 supports a connect_retries parameter, but it only retries certain types of errors # which inherit from RetriableConnectionFailure. This includes timeouts and socket errors but not # others like a 500 error. We add retries on those status codes here # adapter = requests.adapters.HTTPAdapter(max_retries=get_requests_retry()) nova.client.session.session.mount('http://', adapter) nova.client.session.session.mount('https://', adapter) # keystoneauth1 retries on certain status codes, see above nova.client.retriable_status_codes = range(500, 600) nova.client.status_code_retries = 10 return nova
def get_nova_client(self): return NovaClient(self.options.nova_api_version, username=self.creds['username'], api_key=self.creds['password'], project_id=self.creds['tenant_name'], auth_url=self.creds['auth_url'], endpoint_type='publicURL')
def nova_client_trove_admin(context, region_name=None, password=None): """ Returns a nova client object with the trove admin credentials :param context: original context from user request :type context: trove.common.context.TroveContext :return novaclient: novaclient with trove admin credentials :rtype: novaclient.client.Client """ global ADMIN_NOVA_CLIENT if ADMIN_NOVA_CLIENT: LOG.debug('Re-use admin nova client') return ADMIN_NOVA_CLIENT ks_session = get_keystone_session() ADMIN_NOVA_CLIENT = NovaClient( CONF.nova_client_version, session=ks_session, service_type=CONF.nova_compute_service_type, region_name=region_name or CONF.service_credentials.region_name, insecure=CONF.nova_api_insecure, endpoint_type=CONF.nova_compute_endpoint_type) if CONF.nova_compute_url and CONF.service_credentials.project_id: ADMIN_NOVA_CLIENT.client.endpoint_override = "%s/%s/" % (normalize_url( CONF.nova_compute_url), CONF.service_credentials.project_id) return ADMIN_NOVA_CLIENT
def nova_client(api_session, region_name=None, endpoint_type=None, service_type='compute', version=None, timeout=None, extensions=False): """ :rtype: novaclient.v2.client.Client """ endpoint_type = endpoint_type or plugin_settings.DEFAULT_INTERFACE timeout = timeout or plugin_settings.TIMEOUT region_name = region_name or plugin_settings.DEFAULT_REGION if version: if not isinstance(version, APIVersion): version = APIVersion(version_str=version) else: version = APIVersion(plugin_settings.COMPUTE_API_VERSION) exts = discover_extensions(version=version) if extensions else None return NovaClient(version=version, region_name=region_name, service_type=service_type, endpoint_type=endpoint_type, session=api_session, timeout=timeout, extensions=exts)
def __init__(self, **kwargs): """ :param kwargs: *version = version of NovaClient * region_name of NovaClient """ super().__init__(**kwargs) self._connection = NovaClient(session=self.authentication.session, version=self['version'], region_name=self.region_name)
def get_nova_v2_client(session, region): """ Create a Nova (compute) client from a Keystone session. :param keystoneclient.Session session: Authenticated Keystone session. :param str region: Openstack region. :return: A novaclient.Client """ return NovaClient(session=session, region_name=region, version=2)
def get_stats(user, passwd, tenant, url): keystone = KeystoneClient(username=user, password=passwd, tenant_name=tenant, auth_url=url) # Find my uuid user_list = keystone.users.list() admin_uuid = "" for usr in user_list: if usr.name == user: admin_uuid = usr.id # Find out which tenants I have roles in tenant_list = keystone.tenants.list() my_tenants = list() for tenant in tenant_list: if keystone.users.list_roles(user=admin_uuid, tenant=tenant.id): my_tenants.append( { "name": tenant.name, "id": tenant.id } ) #prefix = "openstack.nova.cluster" prefix = "openstack.nova" # Default data structure data = dict() # Prep counters data["%s.total.count" % (prefix)] = 0 counters = ('ram', 'vcpus', 'disk', 'ephemeral') for counter in counters: data["%s.total.%s" % (prefix,counter)] = 0 # for tenant in tenant_list: for tenant in my_tenants: client = NovaClient("1.1",user,passwd,tenant['name'],url,service_type="compute") # Figure out how much ram has been allocated total for all servers server_list = client.servers.list() data["%s.total.count" % (prefix)] += len(server_list) data["%s.tenant.%s.count" % (prefix,tenant['name'])] = 0 for server in server_list: flavor = client.flavors.get(int(server.flavor["id"])) tenant_uuid = keystone.tenants.get(server.tenant_id).name data["%s.tenant.%s.count" % (prefix,tenant_uuid)] += 1 for counter in counters: data["%s.total.%s" % (prefix,counter)] += int(flavor.__getattribute__(counter)) if "%s.%s.%s" % (prefix,tenant_uuid, counter) in data: data["%s.tenant.%s.%s" % (prefix,tenant_uuid,counter)] += int(flavor.__getattribute__(counter)) else: data["%s.tenant.%s.%s" % (prefix,tenant_uuid,counter)] = int(flavor.__getattribute__(counter)) ########## # debug for key in data.keys(): print "%s = %s" % (key, data[key]) ########## return data
def _client(self) -> NovaClient: if self._cached_client is None: self._cached_client = NovaClient( _NovaManager.NOVA_VERSION, self.openstack_connector.username, self.openstack_connector.password, project_name=self.openstack_connector.tenant, auth_url=self.openstack_connector.auth_url) return self._cached_client
def sdk_connect(self): auth_url = self.configuration['auth_url'] user = self.configuration['username'] password = self.configuration['password'] logger.debug('password from config = %s' % password) # FIXME read from rc password = '******' project_id = user nova = NovaClient('2', user, password, project_id, auth_url) return nova
def get_novaclient(token, region_name): """Instanciate a python novaclient.Client() object with proper credentials param: region_name: name of the region raises: ImportError: when novaclient is not available raises: KeyError: when no matching endpoint is found """ return NovaClient('2', auth_token=token.auth_token, auth_url=token.get_endpoint('identity', region_name)['url'], tenant_id=token.project['id'], region_name=region_name)
def __init__(self): self.readConf() self.auth = v3.Password( username=self.openStackUsername, password=self.openStackPassword, project_name=self.projectName, auth_url=self.openStackAuthUrl, user_domain_name=self.openStackUserDomainName, # domain_name = 'xerces', project_domain_name=self.openStackProjectDomainName, project_id=self.openStackProjectDomainId) self.sess = session.Session(auth=self.auth) self.nova = NovaClient("2", session=self.sess)
def __init__(self, lease, key='default', image=DEFAULT_IMAGE): self.lease = lease self.session = self.lease.session self.nova = NovaClient('2', session=self.session) self.ip = None self._fip = None self.image = resolve_image_idname(self.nova, image) self.server_kwargs = instance_create_args(self.lease.lease, key=key, image=self.image) self.server = self.nova.servers.create(**self.server_kwargs) self.id = self.server.id self.name = self.server.name
def __init__(self, session, id=None, lease=None, key='default', image=DEFAULT_IMAGE, **extra): self.session = session self.neutron = NeutronClient( session=self.session, region_name=os.environ.get('OS_REGION_NAME')) self.nova = NovaClient('2', session=self.session, region_name=os.environ.get('OS_REGION_NAME')) self.glance = GlanceClient( '2', session=self.session, region_name=os.environ.get('OS_REGION_NAME')) self.image = resolve_image_idname(self.glance, image) self.ip = None self._fip = None self._fip_created = False self._preexisting = False extra.setdefault('_no_clean', False) self._noclean = extra.pop('_no_clean') net_ids = extra.pop('net_ids', None) net_name = extra.pop('net_name', None) if net_ids is None and net_name is not None: net_ids = [get_networkid_byname(self.neutron, net_name)] if id is not None: self._preexisting = True self.server = self.nova.servers.get(id) elif lease is not None: server_kwargs = instance_create_args(lease.reservations[0]['id'], key=key, image=self.image, net_ids=net_ids, **extra) self.server = self.nova.servers.create(**server_kwargs) # print('created instance {}'.format(self.server.id)) else: raise ValueError( "Missing required argument: 'id' or 'lease' required.") self.id = self.server.id self.name = self.server.name
def __init__(self, id=None, lease=None, key=None, image=DEFAULT_IMAGE, **kwargs): kwargs.setdefault("session", context.session()) self.session = kwargs.pop("session") self.neutron = NeutronClient(session=self.session) self.nova = NovaClient("2", session=self.session) self.glance = GlanceClient("2", session=self.session) self.image = resolve_image_idname(self.glance, image) self.flavor = resolve_flavor(self.nova, "baremetal") self.ip = None self._fip = None self._fip_created = False self._preexisting = False kwargs.setdefault("_no_clean", False) self._noclean = kwargs.pop("_no_clean") net_ids = kwargs.pop("net_ids", None) net_name = kwargs.pop("net_name", "sharednet1") if net_ids is None and net_name is not None: net_ids = [get_networkid_byname(self.neutron, net_name)] if id is not None: self._preexisting = True self.server = self.nova.servers.get(id) elif lease is not None: if key is None: key = Keypair().key_name server_kwargs = instance_create_args(lease.node_reservation, image=self.image, flavor=self.flavor, key=key, net_ids=net_ids, **kwargs) self.server = self.nova.servers.create(**server_kwargs) else: raise ValueError( "Missing required argument: 'id' or 'lease' required.") self.id = self.server.id self.name = self.server.name
def os_connect(os_creds: OSCreds, version: str = "2") -> OSConnection: loader = loading.get_plugin_loader('password') auth = loader.load_from_options(auth_url=os_creds.auth_url, username=os_creds.name, password=os_creds.passwd, project_id=os_creds.tenant) auth_sess = session.Session(auth=auth) glance = GlanceClient(version, session=auth_sess) nova = NovaClient(version, session=auth_sess) cinder = CinderClient(os_creds.name, os_creds.passwd, os_creds.tenant, os_creds.auth_url, insecure=os_creds.insecure, api_version=version) return OSConnection(nova, cinder, glance)
def __init__(self): self.readConf() #Changed this according to Hakan's suggestion. //Erik self.auth = v3.Password( username=self.openStackUsername, password=self.openStackPassword, project_name='LiU-3', auth_url= self.openStackAuthUrl, user_domain_name = 'xerces', # domain_name = 'xerces', project_domain_name = 'xerces', project_id = 'cb6d5c67a25e445dafa4a48106af167b', ) #self.auth = v3.Password(username=self.openStackUsername, password=self.openStackPassword, # auth_url= self.openStackAuthUrl,user_domain_name='xerces',project_domain_name='xerces') self.sess = session.Session(auth=self.auth) self.nova = NovaClient("2", session=self.sess)
def __init__(self, pkey_id=None,start_script=None): self.pkey_id = pkey_id self.start_script = start_script parser = SafeConfigParser() try: parser.read("credentials.txt") except IOError: print("Credential file missing") sys.exit() self.username=parser.get("auth","username") self.password=parser.get("auth","password") self.tenant_name=parser.get("auth","tenant_name") self.auth_url=parser.get("auth","auth_url") auth = v2.Password(username=self.username, password=self.password, tenant_name=self.tenant_name, auth_url=self.auth_url) sess = session.Session(auth=auth) self.nova = NovaClient("2", session = sess)
def cinder_from_configuration(region, cluster_id, **config): """ Build a ``CinderBlockDeviceAPI`` using configuration and credentials in ``config``. :param str region: The region "slug" for which to configure the object. :param cluster_id: The unique cluster identifier for which to configure the object. """ auth = _openstack_auth_from_config(**config) session = Session(auth=auth) cinder_client = CinderClient(session=session, region_name=region, version=1) nova_client = NovaClient(session=session, region_name=region, version=2) return cinder_api( cinder_client=cinder_client, nova_client=nova_client, cluster_id=cluster_id, )
def nova_client_trove_admin(context, region_name=None, password=None): """ Returns a nova client object with the trove admin credentials :param context: original context from user request :type context: trove.common.context.TroveContext :return novaclient: novaclient with trove admin credentials :rtype: novaclient.client.Client """ ks_session = get_keystone_session() client = NovaClient(CONF.nova_client_version, session=ks_session, service_type=CONF.nova_compute_service_type, region_name=region_name or CONF.os_region_name, insecure=CONF.nova_api_insecure, endpoint_type=CONF.nova_compute_endpoint_type) if CONF.nova_compute_url and CONF.nova_proxy_admin_tenant_id: client.client.endpoint_override = "%s/%s/" % (normalize_url( CONF.nova_compute_url), CONF.nova_proxy_admin_tenant_id) return client
def get_nova_client(region_name, api_version=2): """ Instantiate a python novaclient.Client() object with proper credentials """ nova = NovaClient( api_version, settings.OPENSTACK_USER, settings.OPENSTACK_PASSWORD, settings.OPENSTACK_TENANT, settings.OPENSTACK_AUTH_URL, region_name=region_name, ) # API queries via the nova client occasionally get connection errors from the OpenStack provider. # To gracefully recover when the unavailability is short-lived, ensure safe requests (as per # urllib3's definition) are retried before giving up. adapter = requests.adapters.HTTPAdapter(max_retries=get_requests_retry()) nova.client.open_session() nova.client._session.mount('http://', adapter) nova.client._session.mount('https://', adapter) return nova
def init_session(): """Initialization of keystone session, glance, nova and neutron clients. Returns: tuple: glance_client, nova_client, neutron_client """ AUTH_URL = os.environ.get('OS_AUTH_URL') if not AUTH_URL: print("AUTH_URL must be set") sys.exit(1) PROJECT_DOMAIN_NAME = os.environ.get('OS_PROJECT_DOMAIN_NAME', 'default') USER_DOMAIN_NAME = os.environ.get('OS_USER_DOMAIN_NAME', 'default') PROJECT_NAME = os.environ.get('OS_PROJECT_NAME', 'admin') USERNAME = os.environ.get('OS_USERNAME', 'admin') PASSWORD = os.environ.get('OS_PASSWORD', 'password') auth = identity.v3.Password(auth_url=AUTH_URL, username=USERNAME, user_domain_name=USER_DOMAIN_NAME, password=PASSWORD, project_name=PROJECT_NAME, project_domain_name=PROJECT_DOMAIN_NAME) session = _session.Session(auth=auth) glance_client = GlanceClient(session=session) images = list(glance_client.images.list()) if not images: print("At least one image must exist") sys.exit(1) nova_client = NovaClient(version=2, session=session) neutron_client = NeutronClient(session=session, project_name=session.get_project_id()) return glance_client, nova_client, neutron_client
def make_nova_client(session): return NovaClient('2', session=session)
def nova_auth(self,): nova_client = NovaClient(**self.credentials) return nova_client
def get_stats(self): """Retrieves stats from nova""" keystone = self.get_keystone() tenant_list = keystone.tenants.list() data = { self.prefix: { 'cluster': { 'config': {} }, } } client = NovaClient('2', self.username, self.password, self.tenant, self.auth_url) for tenant in tenant_list: # FIX: nasty but works for now (tenant.id not being taken below :() client.tenant_id = tenant.id data[self.prefix]["tenant-%s" % tenant.name] = { 'limits': {}, 'quotas': {} } data_tenant = data[self.prefix]["tenant-%s" % tenant.name] # Get absolute limits for tenant limits = client.limits.get(tenant_id=tenant.id).absolute for limit in limits: if 'ram' in limit.name.lower(): limit.value = limit.value * 1024.0 * 1024.0 data_tenant['limits'][limit.name] = limit.value # Quotas for tenant quotas = client.quotas.get(tenant.id) for item in ('cores', 'fixed_ips', 'floating_ips', 'instances', 'key_pairs', 'ram', 'security_groups'): if item == 'ram': setattr(quotas, item, getattr(quotas, item) * 1024 * 1024) data_tenant['quotas'][item] = getattr(quotas, item) # Cluster allocation / reserved values for item in ('AllocationRatioCores', 'AllocationRatioRam', 'ReservedNodeCores', 'ReservedNodeRamMB', 'ReservedCores', 'ReservedRamMB'): data[self.prefix]['cluster']['config'][item] = getattr(self, item) # Hypervisor information hypervisors = client.hypervisors.list() for hypervisor in hypervisors: name = "hypervisor-%s" % hypervisor.hypervisor_hostname data[self.prefix][name] = {} for item in ('current_workload', 'free_disk_gb', 'free_ram_mb', 'hypervisor_version', 'memory_mb', 'memory_mb_used', 'running_vms', 'vcpus', 'vcpus_used'): data[self.prefix][name][item] = getattr(hypervisor, item) data[self.prefix][name]['memory_mb_overcommit'] = \ data[self.prefix][name]['memory_mb'] * data[self.prefix]['cluster']['config']['AllocationRatioRam'] data[self.prefix][name]['memory_mb_overcommit_withreserve'] = \ data[self.prefix][name]['memory_mb_overcommit'] - data[self.prefix]['cluster']['config']['ReservedNodeRamMB'] data[self.prefix][name]['vcpus_overcommit'] = \ data[self.prefix][name]['vcpus'] * data[self.prefix]['cluster']['config']['AllocationRatioCores'] data[self.prefix][name]['vcpus_overcommit_withreserve'] = \ data[self.prefix][name]['vcpus_overcommit'] - data[self.prefix]['cluster']['config']['ReservedNodeCores'] return data
def _get_nova_client(): sess = op_utils.get_session() return NovaClient(op_utils.get_nova_api_version(), session=sess)