from sfa.util.sfalogging import logger
from sfa.util.defaultdict import defaultdict
from sfa.util.sfatime import utcparse, datetime_to_string, datetime_to_epoch
-from sfa.util.xrn import Xrn, hrn_to_urn, get_leaf
+from sfa.util.xrn import Xrn, hrn_to_urn, get_leaf
from sfa.openstack.osxrn import OSXrn, hrn_to_os_slicename, hrn_to_os_tenant_name
from sfa.util.cache import Cache
from sfa.trust.credential import Credential
from sfa.openstack.osaggregate import OSAggregate
from sfa.planetlab.plslices import PlSlices
+
def list_to_dict(recs, key):
"""
convert a list of dictionaries into a dictionary keyed on the
specified dictionary key
"""
- return dict ( [ (rec[key],rec) for rec in recs ] )
+ return dict([(rec[key], rec) for rec in recs])
#
# PlShell is just an xmlrpc serverproxy where methods
# can be sent as-is; it takes care of authentication
# from the global config
-#
+#
+
+
class NovaDriver(Driver):
- # the cache instance is a class member so it survives across incoming requests
+ # the cache instance is a class member so it survives across incoming
+ # requests
cache = None
- def __init__ (self, api):
+ def __init__(self, api):
Driver.__init__(self, api)
config = api.config
self.shell = Shell(config=config)
- self.cache=None
+ self.cache = None
if config.SFA_AGGREGATE_CACHING:
if NovaDriver.cache is None:
NovaDriver.cache = Cache()
sliver_id_parts = Xrn(xrn).get_sliver_id_parts()
slice = self.shell.auth_manager.tenants.find(id=sliver_id_parts[0])
if not slice:
- raise Forbidden("Unable to locate slice record for sliver: %s" % xrn)
+ raise Forbidden(
+ "Unable to locate slice record for sliver: %s" % xrn)
slice_xrn = OSXrn(name=slice.name, type='slice')
return slice_xrn
slice_ids.append(sliver_id_parts[0])
if not slice_ids:
- raise Forbidden("sliver urn not provided")
+ raise Forbidden("sliver urn not provided")
sliver_names = []
for slice_id in slice_ids:
- slice = self.shell.auth_manager.tenants.find(slice_id)
+ slice = self.shell.auth_manager.tenants.find(slice_id)
sliver_names.append(slice['name'])
# make sure we have a credential for every specified sliver ierd
if sliver_name not in slice_cred_names:
msg = "Valid credential not found for target: %s" % sliver_name
raise Forbidden(msg)
-
+
########################################
- ########## registry oriented
+ # registry oriented
########################################
- ########## disabled users
- def is_enabled (self, record):
+ # disabled users
+ def is_enabled(self, record):
# all records are enabled
return True
- def augment_records_with_testbed_info (self, sfa_records):
- return self.fill_record_info (sfa_records)
+ def augment_records_with_testbed_info(self, sfa_records):
+ return self.fill_record_info(sfa_records)
+
+ ##########
+ def register(self, sfa_record, hrn, pub_key):
- ##########
- def register (self, sfa_record, hrn, pub_key):
-
if sfa_record['type'] == 'slice':
- record = self.register_slice(sfa_record, hrn)
+ record = self.register_slice(sfa_record, hrn)
elif sfa_record['type'] == 'user':
record = self.register_user(sfa_record, hrn, pub_key)
- elif sfa_record['type'].startswith('authority'):
+ elif sfa_record['type'].startswith('authority'):
record = self.register_authority(sfa_record, hrn)
# We should be returning the records id as a pointer but
- # this is a string and the records table expects this to be an
+ # this is a string and the records table expects this to be an
# int.
- #return record.id
+ # return record.id
return -1
def register_slice(self, sfa_record, hrn):
self.shell.auth_manager.tenants.create(name, description)
tenant = self.shell.auth_manager.tenants.find(name=name)
auth_hrn = OSXrn(xrn=hrn, type='slice').get_authority_hrn()
- parent_tenant_name = OSXrn(xrn=auth_hrn, type='slice').get_tenant_name()
- parent_tenant = self.shell.auth_manager.tenants.find(name=parent_tenant_name)
+ parent_tenant_name = OSXrn(
+ xrn=auth_hrn, type='slice').get_tenant_name()
+ parent_tenant = self.shell.auth_manager.tenants.find(
+ name=parent_tenant_name)
researchers = sfa_record.get('researchers', [])
for researcher in researchers:
name = Xrn(researcher).get_leaf()
user = self.shell.auth_manager.users.find(name=name)
self.shell.auth_manager.roles.add_user_role(user, 'Member', tenant)
self.shell.auth_manager.roles.add_user_role(user, 'user', tenant)
-
pis = sfa_record.get('pis', [])
for pi in pis:
name = Xrn(pi).get_leaf()
user = self.shell.auth_manager.users.find(name=name)
self.shell.auth_manager.roles.add_user_role(user, 'pi', tenant)
- self.shell.auth_manager.roles.add_user_role(user, 'pi', parent_tenant)
+ self.shell.auth_manager.roles.add_user_role(
+ user, 'pi', parent_tenant)
return tenant
-
+
def register_user(self, sfa_record, hrn, pub_key):
# add person roles, projects and keys
email = sfa_record.get('email', None)
xrn = Xrn(hrn)
name = xrn.get_leaf()
auth_hrn = xrn.get_authority_hrn()
- tenant_name = OSXrn(xrn=auth_hrn, type='authority').get_tenant_name()
- tenant = self.shell.auth_manager.tenants.find(name=tenant_name)
- self.shell.auth_manager.users.create(name, email=email, tenant_id=tenant.id)
+ tenant_name = OSXrn(xrn=auth_hrn, type='authority').get_tenant_name()
+ tenant = self.shell.auth_manager.tenants.find(name=tenant_name)
+ self.shell.auth_manager.users.create(
+ name, email=email, tenant_id=tenant.id)
user = self.shell.auth_manager.users.find(name=name)
slices = sfa_records.get('slices', [])
for slice in projects:
- slice_tenant_name = OSXrn(xrn=slice, type='slice').get_tenant_name()
- slice_tenant = self.shell.auth_manager.tenants.find(name=slice_tenant_name)
- self.shell.auth_manager.roles.add_user_role(user, slice_tenant, 'user')
+ slice_tenant_name = OSXrn(
+ xrn=slice, type='slice').get_tenant_name()
+ slice_tenant = self.shell.auth_manager.tenants.find(
+ name=slice_tenant_name)
+ self.shell.auth_manager.roles.add_user_role(
+ user, slice_tenant, 'user')
keys = sfa_records.get('keys', [])
for key in keys:
keyname = OSXrn(xrn=hrn, type='user').get_slicename()
def register_authority(self, sfa_record, hrn):
name = OSXrn(xrn=hrn, type='authority').get_tenant_name()
- self.shell.auth_manager.tenants.create(name, sfa_record.get('description', ''))
+ self.shell.auth_manager.tenants.create(
+ name, sfa_record.get('description', ''))
tenant = self.shell.auth_manager.tenants.find(name=name)
return tenant
-
-
+
##########
- # xxx actually old_sfa_record comes filled with plc stuff as well in the original code
- def update (self, old_sfa_record, new_sfa_record, hrn, new_key):
- type = new_sfa_record['type']
-
+ # xxx actually old_sfa_record comes filled with plc stuff as well in the
+ # original code
+ def update(self, old_sfa_record, new_sfa_record, hrn, new_key):
+ type = new_sfa_record['type']
+
# new_key implemented for users only
- if new_key and type not in [ 'user' ]:
+ if new_key and type not in ['user']:
raise UnknownSfaType(type)
elif type == "slice":
project_manager = Xrn(pis[0], 'user').get_leaf()
elif researchers:
project_manager = Xrn(researchers[0], 'user').get_leaf()
- self.shell.auth_manager.modify_project(name, project_manager, description)
+ self.shell.auth_manager.modify_project(
+ name, project_manager, description)
elif type == "user":
# can techinally update access_key and secret_key,
- # but that is not in our scope, so we do nothing.
+ # but that is not in our scope, so we do nothing.
pass
return True
-
##########
- def remove (self, sfa_record):
- type=sfa_record['type']
+ def remove(self, sfa_record):
+ type = sfa_record['type']
if type == 'user':
- name = Xrn(sfa_record['hrn']).get_leaf()
+ name = Xrn(sfa_record['hrn']).get_leaf()
if self.shell.auth_manager.get_user(name):
self.shell.auth_manager.delete_user(name)
elif type == 'slice':
- name = hrn_to_os_slicename(sfa_record['hrn'])
+ name = hrn_to_os_slicename(sfa_record['hrn'])
if self.shell.auth_manager.get_project(name):
self.shell.auth_manager.delete_project(name)
return True
-
####################
def fill_record_info(self, records):
"""
else:
continue
record['geni_urn'] = hrn_to_urn(record['hrn'], record['type'])
- record['geni_certificate'] = record['gid']
- #if os_record.created_at is not None:
+ record['geni_certificate'] = record['gid']
+ # if os_record.created_at is not None:
# record['date_created'] = datetime_to_string(utcparse(os_record.created_at))
- #if os_record.updated_at is not None:
+ # if os_record.updated_at is not None:
# record['last_updated'] = datetime_to_string(utcparse(os_record.updated_at))
-
+
return records
def fill_user_record_info(self, record):
slices = []
all_tenants = self.shell.auth_manager.tenants.list()
for tmp_tenant in all_tenants:
- if tmp_tenant.name.startswith(tenant.name +"."):
+ if tmp_tenant.name.startswith(tenant.name + "."):
for tmp_user in tmp_tenant.list_users():
if tmp_user.name == user.name:
- slice_hrn = ".".join([self.hrn, tmp_tenant.name])
- slices.append(slice_hrn)
+ slice_hrn = ".".join([self.hrn, tmp_tenant.name])
+ slices.append(slice_hrn)
record['slices'] = slices
roles = self.shell.auth_manager.roles.roles_for_user(user, tenant)
- record['roles'] = [role.name for role in roles]
+ record['roles'] = [role.name for role in roles]
keys = self.shell.nova_manager.keypairs.findall(name=record['hrn'])
record['keys'] = [key.public_key for key in keys]
return record
tenant_name = hrn_to_os_tenant_name(record['hrn'])
tenant = self.shell.auth_manager.tenants.find(name=tenant_name)
parent_tenant_name = OSXrn(xrn=tenant_name).get_authority_hrn()
- parent_tenant = self.shell.auth_manager.tenants.find(name=parent_tenant_name)
+ parent_tenant = self.shell.auth_manager.tenants.find(
+ name=parent_tenant_name)
researchers = []
pis = []
for user in tenant.list_users():
for role in self.shell.auth_manager.roles.roles_for_user(user, tenant):
if role.name.lower() == 'pi':
- user_tenant = self.shell.auth_manager.tenants.find(id=user.tenantId)
+ user_tenant = self.shell.auth_manager.tenants.find(
+ id=user.tenantId)
hrn = ".".join([self.hrn, user_tenant.name, user.name])
pis.append(hrn)
elif role.name.lower() in ['user', 'member']:
- user_tenant = self.shell.auth_manager.tenants.find(id=user.tenantId)
+ user_tenant = self.shell.auth_manager.tenants.find(
+ id=user.tenantId)
hrn = ".".join([self.hrn, user_tenant.name, user.name])
researchers.append(hrn)
for user in parent_tenant.list_users():
for role in self.shell.auth_manager.roles.roles_for_user(user, parent_tenant):
if role.name.lower() == 'pi':
- user_tenant = self.shell.auth_manager.tenants.find(id=user.tenantId)
+ user_tenant = self.shell.auth_manager.tenants.find(
+ id=user.tenantId)
hrn = ".".join([self.hrn, user_tenant.name, user.name])
pis.append(hrn)
record['name'] = tenant_name
# look for slices
slices = []
- all_tenants = self.shell.auth_manager.tenants.list()
+ all_tenants = self.shell.auth_manager.tenants.list()
for tmp_tenant in all_tenants:
- if tmp_tenant.name.startswith(tenant.name+"."):
- slices.append(".".join([self.hrn, tmp_tenant.name]))
+ if tmp_tenant.name.startswith(tenant.name + "."):
+ slices.append(".".join([self.hrn, tmp_tenant.name]))
record['name'] = tenant_name
record['description'] = tenant.description
####################
# plcapi works by changes, compute what needs to be added/deleted
- def update_relation (self, subject_type, target_type, subject_id, target_ids):
+ def update_relation(self, subject_type, target_type, subject_id, target_ids):
# hard-wire the code for slice/user for now, could be smarter if needed
- if subject_type =='slice' and target_type == 'user':
- subject=self.shell.project_get(subject_id)[0]
+ if subject_type == 'slice' and target_type == 'user':
+ subject = self.shell.project_get(subject_id)[0]
current_target_ids = [user.name for user in subject.members]
- add_target_ids = list ( set (target_ids).difference(current_target_ids))
- del_target_ids = list ( set (current_target_ids).difference(target_ids))
- logger.debug ("subject_id = %s (type=%s)"%(subject_id,type(subject_id)))
+ add_target_ids = list(
+ set(target_ids).difference(current_target_ids))
+ del_target_ids = list(
+ set(current_target_ids).difference(target_ids))
+ logger.debug("subject_id = %s (type=%s)" %
+ (subject_id, type(subject_id)))
for target_id in add_target_ids:
- self.shell.project_add_member(target_id,subject_id)
- logger.debug ("add_target_id = %s (type=%s)"%(target_id,type(target_id)))
+ self.shell.project_add_member(target_id, subject_id)
+ logger.debug("add_target_id = %s (type=%s)" %
+ (target_id, type(target_id)))
for target_id in del_target_ids:
- logger.debug ("del_target_id = %s (type=%s)"%(target_id,type(target_id)))
+ logger.debug("del_target_id = %s (type=%s)" %
+ (target_id, type(target_id)))
self.shell.project_remove_member(target_id, subject_id)
else:
- logger.info('unexpected relation to maintain, %s -> %s'%(subject_type,target_type))
+ logger.info('unexpected relation to maintain, %s -> %s' %
+ (subject_type, target_type))
-
########################################
- ########## aggregate oriented
+ # aggregate oriented
########################################
- def testbed_name (self): return "openstack"
+ def testbed_name(self): return "openstack"
- def aggregate_version (self):
+ def aggregate_version(self):
return {}
# first 2 args are None in case of resource discovery
- def list_resources (self, version=None, options=None):
- if options is None: options={}
+ def list_resources(self, version=None, options=None):
+ if options is None:
+ options = {}
aggregate = OSAggregate(self)
- rspec = aggregate.list_resources(version=version, options=options)
+ rspec = aggregate.list_resources(version=version, options=options)
return rspec
def describe(self, urns, version=None, options=None):
- if options is None: options={}
+ if options is None:
+ options = {}
aggregate = OSAggregate(self)
return aggregate.describe(urns, version=version, options=options)
-
- def status (self, urns, options=None):
- if options is None: options={}
+
+ def status(self, urns, options=None):
+ if options is None:
+ options = {}
aggregate = OSAggregate(self)
- desc = aggregate.describe(urns)
+ desc = aggregate.describe(urns)
status = {'geni_urn': desc['geni_urn'],
'geni_slivers': desc['geni_slivers']}
return status
- def allocate (self, urn, rspec_string, expiration, options=None):
- if options is None: options={}
- xrn = Xrn(urn)
+ def allocate(self, urn, rspec_string, expiration, options=None):
+ if options is None:
+ options = {}
+ xrn = Xrn(urn)
aggregate = OSAggregate(self)
# assume first user is the caller and use their context
pubkeys = []
for user in users:
pubkeys.extend(user['keys'])
-
+
rspec = RSpec(rspec_string)
instance_name = hrn_to_os_slicename(slice_hrn)
tenant_name = OSXrn(xrn=slice_hrn, type='slice').get_tenant_name()
- slivers = aggregate.run_instances(instance_name, tenant_name, \
+ slivers = aggregate.run_instances(instance_name, tenant_name,
rspec_string, key_name, pubkeys)
-
- # update all sliver allocation states setting then to geni_allocated
+
+ # update all sliver allocation states setting then to geni_allocated
sliver_ids = [sliver.id for sliver in slivers]
- dbsession=self.api.dbsession()
- SliverAllocation.set_allocations(sliver_ids, 'geni_provisioned',dbsession)
-
+ dbsession = self.api.dbsession()
+ SliverAllocation.set_allocations(
+ sliver_ids, 'geni_provisioned', dbsession)
+
return aggregate.describe(urns=[urn], version=rspec.version)
def provision(self, urns, options=None):
- if options is None: options={}
+ if options is None:
+ options = {}
# update sliver allocation states and set them to geni_provisioned
aggregate = OSAggregate(self)
instances = aggregate.get_instances(urns)
for instance in instances:
sliver_hrn = "%s.%s" % (self.driver.hrn, instance.id)
sliver_ids.append(Xrn(sliver_hrn, type='sliver').urn)
- dbsession=self.api.dbsession()
- SliverAllocation.set_allocations(sliver_ids, 'geni_provisioned',dbsession)
+ dbsession = self.api.dbsession()
+ SliverAllocation.set_allocations(
+ sliver_ids, 'geni_provisioned', dbsession)
version_manager = VersionManager()
- rspec_version = version_manager.get_version(options['geni_rspec_version'])
- return self.describe(urns, rspec_version, options=options)
+ rspec_version = version_manager.get_version(
+ options['geni_rspec_version'])
+ return self.describe(urns, rspec_version, options=options)
- def delete (self, urns, options=None):
- if options is None: options={}
+ def delete(self, urns, options=None):
+ if options is None:
+ options = {}
# collect sliver ids so we can update sliver allocation states after
# we remove the slivers.
aggregate = OSAggregate(self)
for instance in instances:
sliver_hrn = "%s.%s" % (self.driver.hrn, instance.id)
sliver_ids.append(Xrn(sliver_hrn, type='sliver').urn)
-
+
# delete the instance
aggregate.delete_instance(instance)
-
+
# delete sliver allocation states
- dbsession=self.api.dbsession()
+ dbsession = self.api.dbsession()
SliverAllocation.delete_allocations(sliver_ids, dbsession)
# return geni_slivers
geni_slivers.append(
{'geni_sliver_urn': sliver['sliver_id'],
'geni_allocation_status': 'geni_unallocated',
- 'geni_expires': None})
+ 'geni_expires': None})
return geni_slivers
- def renew (self, urns, expiration_time, options=None):
- if options is None: options={}
+ def renew(self, urns, expiration_time, options=None):
+ if options is None:
+ options = {}
description = self.describe(urns, None, options)
return description['geni_slivers']
- def perform_operational_action (self, urns, action, options=None):
- if options is None: options={}
+ def perform_operational_action(self, urns, action, options=None):
+ if options is None:
+ options = {}
aggregate = OSAggregate(self)
- action = action.lower()
+ action = action.lower()
if action == 'geni_start':
action_method = aggregate.start_instances
elif action == 'geni_stop':
else:
raise UnsupportedOperation(action)
- # fault if sliver is not full allocated (operational status is geni_pending_allocation)
+ # fault if sliver is not full allocated (operational status is
+ # geni_pending_allocation)
description = self.describe(urns, None, options)
for sliver in description['geni_slivers']:
if sliver['geni_operational_status'] == 'geni_pending_allocation':
- raise UnsupportedOperation(action, "Sliver must be fully allocated (operational status is not geni_pending_allocation)")
+ raise UnsupportedOperation(
+ action, "Sliver must be fully allocated (operational status is not geni_pending_allocation)")
#
# Perform Operational Action Here
#
- instances = aggregate.get_instances(urns)
+ instances = aggregate.get_instances(urns)
for instance in instances:
tenant_name = self.driver.shell.auth_manager.client.tenant_name
action_method(tenant_name, instance.name, instance.id)
return geni_slivers
def shutdown(self, xrn, options=None):
- if options is None: options={}
+ if options is None:
+ options = {}
xrn = OSXrn(xrn=xrn, type='slice')
tenant_name = xrn.get_tenant_name()
name = xrn.get_slicename()
git://git.onelab.eu / sfa.git / blobdiff