def provision(self, urns, options=None):
if options is None: options={}
# update sliver allocation states and set them to geni_provisioned
aggregate = OSAggregate(self)
# Update connection for the current client
xrn = Xrn(urns[0], type='slice')
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
tenant_name = OSXrn(xrn=urns[0], type='slice').get_hrn()
self.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
instances = aggregate.get_instances(xrn)
# Allocate new floating IP per the instance
servers = aggregate.check_floatingip(instances, True)
aggregate.create_floatingip(tenant_name, servers)
sliver_ids=[]
for instance in instances:
sliver_id = OSXrn(name=('koren'+'.'+ instance.name), id=instance.id, type='node+openstack').get_urn()
sliver_ids.append(sliver_id)
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)
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)
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')
keys = sfa_records.get('keys', [])
for key in keys:
keyname = OSXrn(xrn=hrn, type='user').get_slicename()
self.shell.nova_client.keypairs.create(keyname, key)
return user
def describe(self, urns, version=None, options=None):
if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# Update connection for the current user
xrn = Xrn(urns[0], type='slice')
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
tenant_name = OSXrn(xrn=urns[0], type='slice').get_hrn()
self.driver.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
# For delay to collect instance info
time.sleep(3)
# Get instances from the Openstack
instances = self.get_instances(xrn)
# Add sliver(s) from instance(s)
geni_slivers = []
rspec.xml.set( 'expires', datetime_to_string(utcparse(time.time())) )
rspec_nodes = []
for instance in instances:
rspec_nodes.append(self.instance_to_rspec_node(instance))
geni_sliver = self.instance_to_geni_sliver(instance)
geni_slivers.append(geni_sliver)
rspec.version.add_nodes(rspec_nodes)
result = { 'geni_urn': xrn.get_urn(),
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers }
return result
def delete_instance(self, instance):
def _delete_security_group(inst):
security_group = inst.metadata.get('security_groups', '')
if security_group:
manager = SecurityGroup(self.driver)
timeout = 10.0 # wait a maximum of 10 seconds before forcing the security group delete
start_time = time.time()
instance_deleted = False
while instance_deleted == False and (time.time() - start_time) < timeout:
tmp_inst = self.driver.shell.compute_manager.servers.findall(id=inst.id)
if not tmp_inst:
instance_deleted = True
time.sleep(.5)
manager.delete_security_group(security_group)
multiclient = MultiClient()
tenant = self.driver.shell.auth_manager.tenants.find(id=instance.tenant_id)
# Update connection for the current client
xrn = Xrn(tenant.name)
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
self.driver.shell.compute_manager.connect(username=user_name, tenant=tenant.name, password=user_name)
args = { 'name': instance.name,
'id': instance.id }
instances = self.driver.shell.compute_manager.servers.findall(**args)
security_group_manager = SecurityGroup(self.driver)
for instance in instances:
# destroy instance
self.driver.shell.compute_manager.servers.delete(instance)
# deleate this instance's security groups
multiclient.run(_delete_security_group, instance)
return 1
def restart_instances(self, instacne_name, tenant_name, id=None):
# Update connection for the current client
xrn = Xrn(tenant_name)
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
self.driver.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
self.stop_instances(instance_name, tenant_name, id)
self.start_instances(instance_name, tenant_name, id)
return 1
def start_instances(self, instance_name, tenant_name, id=None):
# Update connection for the current client
xrn = Xrn(tenant_name)
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
self.driver.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
args = { 'name': instance_name }
if id:
args['id'] = id
instances = self.driver.shell.compute_manager.servers.findall(**args)
for instance in instances:
self.driver.shell.compute_manager.servers.resume(instance)
return 1
def shutdown(self, urn, options=None):
if options is None: options={}
# Update connection for the current client
xrn = Xrn(urn)
osxrn = OSXrn(xrn=urn, type='slice')
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
tenant_name = osxrn.get_hrn()
self.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
instances = self.shell.compute_manager.servers.findall(name=osxrn.get_slicename())
for instance in instances:
self.shell.compute_manager.servers.shutdown(instance.id)
return True
def delete(self, urns, options=None):
if options is None: options={}
aggregate = OSAggregate(self)
# Update connection for the current client
xrn = Xrn(urns[0], type='slice')
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
tenant_name = OSXrn(xrn=urns[0], type='slice').get_hrn()
self.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
# collect sliver ids so we can update sliver allocation states after
# we remove the slivers.
instances = aggregate.get_instances(xrn)
# Release the floating IPs of instances
servers = aggregate.check_floatingip(instances, False)
aggregate.delete_floatingip(servers)
sliver_ids = []
id_set = set()
for instance in instances:
sliver_id = OSXrn(name=('koren'+'.'+ instance.name), id=instance.id, type='node+openstack').get_urn()
sliver_ids.append(sliver_id)
# delete the instance related with requested tenant
aggregate.delete_instance(instance)
id_set.add(instance.tenant_id)
tenant_ids = list(id_set)
for tenant_id in tenant_ids:
# Delete both the router(s) and interfaces related with requested tenant
aggregate.delete_router(tenant_id=tenant_id)
# Delete both the network and subnet related with requested tenant
aggregate.delete_network(tenant_id=tenant_id)
# Delete sliver allocation states
dbsession=self.api.dbsession()
SliverAllocation.delete_allocations(sliver_ids, dbsession)
# Return geni_slivers
geni_slivers = []
for sliver_id in sliver_ids:
geni_slivers.append(
{ 'geni_sliver_urn': sliver_id,
'geni_allocation_status': 'geni_unallocated',
# 'geni_expires': datetime_to_string(utcparse(time.time())) })
'geni_expires': None })
return geni_slivers
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)
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')
keys = sfa_records.get('keys', [])
for key in keys:
keyname = OSXrn(xrn=hrn, type='user').get_slicename()
self.shell.nova_client.keypairs.create(keyname, key)
return user
def allocate (self, urn, rspec_string, expiration, options=None):
if options is None: options={}
aggregate = OSAggregate(self)
rspec = RSpec(rspec_string)
xrn = Xrn(urn)
slice_hrn = xrn.get_hrn()
tenant_name = OSXrn(xrn=slice_hrn, type='slice').get_hrn()
instance_name = hrn_to_os_slicename(slice_hrn)
tenants = self.shell.auth_manager.tenants.findall()
# collect public keys & get the user name
users = options.get('geni_users', [])
pubkeys = []
key_name = None
if len(users) >= 1:
for user in users:
# TODO: We currently support one user name.
user_name = Xrn(user.get('urn')).get_hrn()
pubkeys.extend(user['keys'])
for tenant in tenants:
# Check if the tenant of the user exists in local OS or not
if tenant_name == tenant.name:
try:
self.shell.auth_manager.users.find(name=user_name)
except:
user = self.register_federation(user_hrn=user_name, \
slice_hrn=tenant_name, keys=pubkeys, email=None)
break
else:
user = self.register_federation(user_hrn=user_name, \
slice_hrn=tenant_name, keys=None, email=None)
# Update connection for the current client
self.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
keypair_list = self.shell.compute_manager.keypairs.list()
keyname = OSXrn(xrn=user_name, type='user').get_slicename()
for keypair in keypair_list:
if keyname == keypair.name:
key_name = keypair.name
break
else:
raise SfaNotImplemented("No handle!")
# Update initial connection info
self.init_compute_manager_conn()
# key_name = aggregate.create_instance_key(slice_hrn, users[0])
# In case of federation or non-options
elif len(users) < 1:
if options.get('actual_caller_hrn') is None:
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
else:
user_name = options.get('actual_caller_hrn')
for tenant in tenants:
# Check if the tenant of the user in local OS or not
if tenant_name == tenant.name:
try:
self.shell.auth_manager.users.find(name=user_name)
except:
user = self.register_federation(user_hrn=user_name, \
slice_hrn=tenant_name, keys=pubkeys, email=None)
break
else:
user = self.register_federation(user_hrn=user_name, \
slice_hrn=tenant_name, keys=None, email=None)
# TODO: Wrapper for federation needs at least one pubkey of the user extracted by 'options'!!
# name = OSXrn(xrn=user_name, type='user').get_slicename()
# key_name = self.shell.compute_manager.keypairs.get(name).name
else:
raise SfaNotImplemented("No handle!")
slivers = aggregate.run_instances(tenant_name, user_name, rspec_string, key_name, pubkeys)
# Update sliver allocations
for sliver in slivers:
component_id = sliver.metadata.get('component_id')
sliver_id = OSXrn(name=('koren'+'.'+ sliver.name), id=sliver.id, type='node+openstack').get_urn()
record = SliverAllocation( sliver_id=sliver_id,
component_id=component_id,
allocation_state='geni_allocated')
record.sync(self.api.dbsession())
return aggregate.describe(urns=[urn], version=rspec.version)
