def decorator(manager, ctx, *args, **kwargs):
try:
context.current()
except RuntimeError:
new_ctx = context.ClimateContext(ctx.values)
with new_ctx:
return func(manager, *args, **kwargs)
else:
return func(manager, ctx, *args, **kwargs)
def nova(self):
ctx = context.current()
nova = ClimateNovaClient(username=ctx.user_name,
api_key=None,
project_id=ctx.project_id,
ctx=ctx)
return nova
def create(self, name=None, az=True):
"""Create a Pool (an Aggregate) with or without Availability Zone.
By default expose to user the aggregate with an Availability Zone.
Return an aggregate or raise a nova exception.
"""
name = name or self._generate_aggregate_name()
if az:
az_name = "%s%s" % (self.config.climate_az_prefix,
name)
LOG.debug('Creating pool aggregate: %s'
'with Availability Zone %s' % (name, az_name))
agg = self.nova.aggregates.create(name, az_name)
else:
LOG.debug('Creating pool aggregate: %s'
'without Availability Zone' % name)
agg = self.nova.aggregates.create(name, None)
project_id = None
try:
ctx = context.current()
project_id = ctx.project_id
except RuntimeError:
e = manager_exceptions.ProjectIdNotFound()
LOG.error(e.message)
raise e
meta = {self.config.climate_owner: project_id}
self.nova.aggregates.set_metadata(agg, meta)
return agg
def model_query(model, session=None, project_only=False):
"""Query helper.
:param model: base model to query
:param project_only: if present and current context is user-type,
then restrict query to match the tenant_id from current context.
"""
session = session or get_session()
query = session.query(model)
if project_only and 'tenant_id' not in model.__table__.columns:
# model not having tenant_id as attribute
LOG.debug("Query not filtered per tenant")
return query
if project_only:
try:
ctx = context.current()
except RuntimeError:
# Context is not available
return query
if context.is_user_context(ctx):
query = query.filter_by(tenant_id=ctx.tenant_id)
return query
def create(self, name=None, az=True):
"""Create a Pool (an Aggregate) with or without Availability Zone.
By default expose to user the aggregate with an Availability Zone.
Return an aggregate or raise a nova exception.
"""
name = name or self._generate_aggregate_name()
if az:
az_name = "%s%s" % (self.config.climate_az_prefix,
name)
LOG.debug('Creating pool aggregate: %s'
'with Availability Zone %s' % (name, az_name))
agg = self.nova.aggregates.create(name, az_name)
else:
LOG.debug('Creating pool aggregate: %s'
'without Availability Zone' % name)
agg = self.nova.aggregates.create(name, None)
project_id = None
try:
ctx = context.current()
project_id = ctx.project_id
except RuntimeError:
e = manager_exceptions.ProjectIdNotFound()
LOG.error(e.message)
raise e
meta = {self.config.climate_owner: project_id}
self.nova.aggregates.set_metadata(agg, meta)
return agg
def nova(self):
ctx = context.current()
nova = ClimateNovaClient(username=ctx.user_name,
api_key=None,
project_id=ctx.project_id,
ctx=ctx)
return nova
def get_leases(self):
"""List all existing leases."""
ctx = context.current()
if policy.enforce(ctx, 'admin', {}, do_raise=False):
project_id = None
else:
project_id = ctx.project_id
return self.manager_rpcapi.list_leases(project_id=project_id)
def column_query(*columns, **kwargs):
session = kwargs.get("session") or get_session()
query = session.query(*columns)
if kwargs.get("project_only"):
ctx = context.current()
query = query.filter_by(tenant_id=ctx.tenant_id)
return query
def wrapped(self, *args, **kwargs):
cur_ctx = ctx or context.current()
tgt = target or {'project_id': cur_ctx.project_id,
'user_id': cur_ctx.user_id}
if action is None:
act = '%s:%s' % (api, extension)
else:
act = '%s:%s:%s' % (api, extension, action)
enforce(cur_ctx, act, tgt)
return func(self, *args, **kwargs)
def wrapped(self, *args, **kwargs):
cur_ctx = ctx or context.current()
tgt = target or {
'project_id': cur_ctx.project_id,
'user_id': cur_ctx.user_id
}
if action is None:
act = '%s:%s' % (api, extension)
else:
act = '%s:%s:%s' % (api, extension, action)
enforce(cur_ctx, act, tgt)
return func(self, *args, **kwargs)
def __init__(self):
self.ctx = context.current()
#TODO(sbauza): use catalog to find the url
auth_url = "%s://%s:%s/v2.0" % (cfg.CONF.os_auth_protocol,
cfg.CONF.os_auth_host,
cfg.CONF.os_auth_port)
self.nova = client.Client('2',
username=cfg.CONF.climate_username,
api_key=cfg.CONF.climate_password,
auth_url=auth_url,
project_id=cfg.CONF.climate_tenant_name)
def create_lease(self, lease_values):
"""Create a lease with reservations.
Return either the model of created lease or None if any error.
"""
# Remove and keep reservation values
reservations = lease_values.pop("reservations", [])
# Create the lease without the reservations
start_date = lease_values["start_date"]
end_date = lease_values["end_date"]
if start_date == "now":
start_date = datetime.datetime.utcnow()
else:
start_date = datetime.datetime.strptime(start_date, "%Y-%m-%d %H:%M")
end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d %H:%M")
ctx = context.current()
lease_values["user_id"] = ctx.user_id
lease_values["tenant_id"] = ctx.tenant_id
lease_values["start_date"] = start_date
lease_values["end_date"] = end_date
if not lease_values.get("events"):
lease_values["events"] = []
lease_values["events"].append({"event_type": "start_lease", "time": start_date, "status": "UNDONE"})
lease_values["events"].append({"event_type": "end_lease", "time": end_date, "status": "UNDONE"})
# TODO(scroiset): catch DB Exception when they will become alive
# see bug #1237293
try:
lease = db_api.lease_create(lease_values)
lease_id = lease["id"]
except RuntimeError:
LOG.exception("Cannot create a lease")
else:
try:
for reservation in reservations:
reservation["lease_id"] = lease["id"]
reservation["start_date"] = lease["start_date"]
reservation["end_date"] = lease["end_date"]
resource_type = reservation["resource_type"]
self.plugins[resource_type].create_reservation(reservation)
except RuntimeError:
LOG.exception(
"Failed to create reservation for a lease. " "Rollback the lease and associated reservations"
)
db_api.lease_destroy(lease_id)
else:
return db_api.lease_get(lease["id"])
def __init__(self):
self.ctx = context.current()
self.freepool_name = cfg.CONF['physical:host'].aggregate_freepool_name
#TODO(scroiset): use catalog to find the url
auth_url = "%s://%s:%s/v2.0" % (cfg.CONF.os_auth_protocol,
cfg.CONF.os_auth_host,
cfg.CONF.os_auth_port)
self.nova = client.Client('2',
username=cfg.CONF.climate_username,
api_key=cfg.CONF.climate_password,
auth_url=auth_url,
project_id=cfg.CONF.climate_tenant_name)
def create_trust():
"""Creates trust via Keystone API v3 to use in plugins."""
client = keystone.ClimateKeystoneClient()
trustee_id = keystone.ClimateKeystoneClient(
username=CONF.os_admin_username,
password=CONF.os_admin_password,
tenant_name=CONF.os_admin_project_name).user_id
ctx = context.current()
trust = client.trusts.create(trustor_user=ctx.user_id,
trustee_user=trustee_id,
impersonation=False,
role_names=ctx.roles,
project=ctx.project_id)
return trust
def create_trust():
"""Creates trust via Keystone API v3 to use in plugins."""
client = keystone.ClimateKeystoneClient()
trustee_id = keystone.ClimateKeystoneClient(
username=CONF.os_admin_username,
password=CONF.os_admin_password,
tenant_name=CONF.os_admin_project_name).user_id
ctx = context.current()
trust = client.trusts.create(trustor_user=ctx.user_id,
trustee_user=trustee_id,
impersonation=False,
role_names=ctx.roles,
project=ctx.project_id)
return trust
def model_query(model, session=None, project_only=None):
"""Query helper.
:param model: base model to query
:param project_only: if present and current context is user-type,
then restrict query to match the project_id from current context.
"""
session = session or get_session()
query = session.query(model)
if project_only:
ctx = context.current()
query = query.filter_by(tenant_id=ctx.project_id)
return query
def client(username=None, password=None, trust_id=None, auth_url=None,
tenant=None, ctx=None):
ctx = ctx or context.current()
tenant_name = tenant or ctx.tenant_name
auth_url = auth_url or base.url_for(ctx.service_catalog,
CONF.identity_service)
if not username:
username = ctx.user_name
keystone = keystone_client_v3.Client(username=username,
token=ctx.auth_token,
password=password,
tenant_name=tenant_name,
auth_url=auth_url,
trust_id=trust_id)
keystone.management_url = auth_url
return keystone
def __init__(self, **kwargs):
"""Description
We suppose that in future we may want to use CNC in some places
where context will be available, so we create 2 different ways of
creating client from context(future) and kwargs(we use it now).
:param version: service client version which we will use
:type version: str
:param auth_token: keystone auth token
:type auth_token: str
:param endpoint_override: endpoint url which we will use
:type endpoint_override: str
"""
ctx = kwargs.pop('ctx', None)
auth_token = kwargs.pop('auth_token', None)
endpoint_override = kwargs.pop('endpoint_override', None)
version = kwargs.pop('version', cfg.CONF.nova_client_version)
if ctx is None:
try:
ctx = context.current()
except RuntimeError:
pass
if ctx is not None:
auth_token = auth_token or ctx.auth_token
endpoint_override = endpoint_override or \
base.url_for(ctx.service_catalog,
CONF.compute_service)
auth = token_endpoint.Token(endpoint_override, auth_token)
sess = session.Session(auth=auth)
kwargs.setdefault('endpoint_override', endpoint_override)
kwargs.setdefault('session', sess)
kwargs.setdefault('version', version)
self.nova = nova_client.Client(**kwargs)
self.nova.servers = ServerManager(self.nova)
self.exceptions = nova_exception
def __init__(self, **kwargs):
"""Description
We suppose that in future we may want to use CNC in some places
where context will be available, so we create 2 different ways of
creating client from context(future) and kwargs(we use it now).
:param version: service client version which we will use
:type version: str
:param username: username
:type username: str
:param api_key: password
:type api_key: str
:param auth_token: keystone auth token
:type auth_token: str
:param project_id: project_id
:type api_key: str
:param auth_url: auth_url
:type auth_url: str
:param mgmt_url: management url
:type mgmt_url: str
"""
ctx = kwargs.pop('ctx', None)
auth_token = kwargs.pop('auth_token', None)
mgmt_url = kwargs.pop('mgmt_url', None)
if ctx is None:
try:
ctx = context.current()
except RuntimeError:
pass
kwargs.setdefault('version', cfg.CONF.nova_client_version)
if ctx is not None:
kwargs.setdefault('username', ctx.user_name)
kwargs.setdefault('api_key', None)
kwargs.setdefault('project_id', ctx.project_id)
kwargs.setdefault(
'auth_url',
base.url_for(ctx.service_catalog, CONF.identity_service))
auth_token = auth_token or ctx.auth_token
mgmt_url = mgmt_url or base.url_for(ctx.service_catalog,
CONF.compute_service)
if not kwargs.get('auth_url', None):
# NOTE(scroiset): novaclient v2.17.0 support only Identity API v2.0
auth_url = "%s://%s:%s/v2.0" % (
CONF.os_auth_protocol, CONF.os_auth_host, CONF.os_auth_port)
kwargs['auth_url'] = auth_url
self.nova = nova_client.Client(**kwargs)
self.nova.client.auth_token = auth_token
self.nova.client.management_url = mgmt_url
self.nova.servers = ServerManager(self.nova)
self.exceptions = nova_exception
def call(self, name, **kwargs):
ctx = context.current()
return self._client.call(ctx.to_dict(), name, **kwargs)
def __init__(self, **kwargs):
"""Description
We suppose that in future we may want to use CNC in some places
where context will be available, so we create 2 different ways of
creating client from context(future) and kwargs(we use it now).
:param version: service client version which we will use
:type version: str
:param username: username
:type username: str
:param api_key: password
:type api_key: str
:param auth_token: keystone auth token
:type auth_token: str
:param project_id: project_id
:type api_key: str
:param auth_url: auth_url
:type auth_url: str
:param mgmt_url: management url
:type mgmt_url: str
"""
ctx = kwargs.pop('ctx', None)
auth_token = kwargs.pop('auth_token', None)
mgmt_url = kwargs.pop('mgmt_url', None)
if ctx is None:
try:
ctx = context.current()
except RuntimeError:
pass
kwargs.setdefault('version', cfg.CONF.nova_client_version)
if ctx is not None:
kwargs.setdefault('username', ctx.user_name)
kwargs.setdefault('api_key', None)
kwargs.setdefault('project_id', ctx.project_id)
kwargs.setdefault('auth_url', base.url_for(
ctx.service_catalog, CONF.identity_service))
auth_token = auth_token or ctx.auth_token
mgmt_url = mgmt_url or base.url_for(ctx.service_catalog,
CONF.compute_service)
if not kwargs.get('auth_url', None):
# NOTE(scroiset): novaclient v2.17.0 support only Identity API v2.0
auth_url = "%s://%s:%s/v2.0" % (CONF.os_auth_protocol,
CONF.os_auth_host,
CONF.os_auth_port)
kwargs['auth_url'] = auth_url
self.nova = nova_client.Client(**kwargs)
self.nova.client.auth_token = auth_token
self.nova.client.management_url = mgmt_url
self.nova.servers = ServerManager(self.nova)
self.exceptions = nova_exception
def nova(self):
ctx = context.current()
nova = ClimateNovaClient(ctx=ctx)
return nova
def call(self, name, **kwargs):
ctx = context.current()
return self._client.call(ctx.to_dict(), name, **kwargs)
def cast(self, name, **kwargs):
ctx = context.current()
self._client.cast(ctx.to_dict(), name, **kwargs)
def __init__(self, **kwargs):
"""Description
Return Keystone client for defined in 'identity_service' conf.
NOTE: We will use tenant_name until we start using keystone V3
client for all our needs.
:param version: service client version which we will use
:type version: str
:param username: username
:type username: str
:param password: password
:type password: str
:param tenant_name: tenant_name
:type tenant_name: str
:param auth_url: auth_url
:type auth_url: str
:param ctx: climate context object
:type ctx: dict
:param auth_url: keystone auth url
:type auth_url: string
:param endpoint: keystone management (endpoint) url
:type endpoint: string
:param trust_id: keystone trust ID
:type trust_id: string
:param token: user token to use for authentication
:type token: string
"""
ctx = kwargs.pop('ctx', None)
if ctx is None:
try:
ctx = context.current()
except RuntimeError:
pass
kwargs.setdefault('version', cfg.CONF.keystone_client_version)
if ctx is not None:
kwargs.setdefault('username', ctx.user_name)
kwargs.setdefault('tenant_name', ctx.project_name)
if not kwargs.get('auth_url'):
kwargs['auth_url'] = base.url_for(
ctx.service_catalog, CONF.identity_service)
if not kwargs.get('trust_id'):
try:
kwargs.setdefault('endpoint', base.url_for(
ctx.service_catalog, CONF.identity_service,
endpoint_interface='admin'))
except AttributeError:
raise manager_exceptions.NoManagementUrl()
if not kwargs.get('password'):
kwargs.setdefault('token', ctx.auth_token)
# NOTE(dbelova): we need this checking to support current
# keystoneclient: token can only be scoped now to either
# a trust or project, not both.
if kwargs.get('trust_id') and kwargs.get('tenant_name'):
kwargs.pop('tenant_name')
try:
# NOTE(n.s.): we shall remove this try: except: clause when
# https://review.openstack.org/#/c/66494/ will be merged
self.keystone = keystone_client.Client(**kwargs)
self.keystone.session.auth = self.keystone
self.keystone.authenticate(auth_url=kwargs.get('auth_url', None))
except AttributeError:
raise manager_exceptions.WrongClientVersion()
self.exceptions = keystone_exception
def __init__(self, **kwargs):
"""Description
Return Keystone client for defined in 'identity_service' conf.
NOTE: We will use tenant_name until we start using keystone V3
client for all our needs.
:param version: service client version which we will use
:type version: str
:param username: username
:type username: str
:param password: password
:type password: str
:param tenant_name: tenant_name
:type tenant_name: str
:param auth_url: auth_url
:type auth_url: str
:param ctx: climate context object
:type ctx: dict
:param auth_url: keystone auth url
:type auth_url: string
:param endpoint: keystone management (endpoint) url
:type endpoint: string
:param trust_id: keystone trust ID
:type trust_id: string
:param token: user token to use for authentication
:type token: string
"""
ctx = kwargs.pop('ctx', None)
if ctx is None:
try:
ctx = context.current()
except RuntimeError:
pass
kwargs.setdefault('version', cfg.CONF.keystone_client_version)
if ctx is not None:
kwargs.setdefault('username', ctx.user_name)
kwargs.setdefault('tenant_name', ctx.project_name)
if not kwargs.get('auth_url'):
kwargs['auth_url'] = base.url_for(ctx.service_catalog,
CONF.identity_service)
if not kwargs.get('trust_id'):
try:
kwargs.setdefault(
'endpoint',
base.url_for(ctx.service_catalog,
CONF.identity_service,
endpoint_interface='admin'))
except AttributeError:
raise manager_exceptions.NoManagementUrl()
if not kwargs.get('password'):
kwargs.setdefault('token', ctx.auth_token)
# NOTE(dbelova): we need this checking to support current
# keystoneclient: token can only be scoped now to either
# a trust or project, not both.
if kwargs.get('trust_id') and kwargs.get('tenant_name'):
kwargs.pop('tenant_name')
try:
# NOTE(n.s.): we shall remove this try: except: clause when
# https://review.openstack.org/#/c/66494/ will be merged
self.keystone = keystone_client.Client(**kwargs)
self.keystone.session.auth = self.keystone
self.keystone.authenticate(auth_url=kwargs.get('auth_url', None))
except AttributeError:
raise manager_exceptions.WrongClientVersion()
self.exceptions = keystone_exception
def call(self, name, topic=None, version=None, ctx=None, **kwargs):
if ctx is None:
ctx = context.current()
msg = self.make_msg(name, **kwargs)
return super(RpcProxy, self).call(ctx, msg,
topic=topic, version=version)
def cast(self, name, **kwargs):
ctx = context.current()
self._client.cast(ctx.to_dict(), name, **kwargs)
