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)
