X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fopenstack%2Fnova_driver.py;h=e0afd07fa7e2270043f4f169dfe11ba30af04028;hb=1cc8e9613cab8b5b22478de369f259e591c54e6d;hp=7a84c2e6b65345f56865854680f10d116e68a2f7;hpb=c15c2b3202c7a796dc3bd583996b2d7ebb8995af;p=sfa.git diff --git a/sfa/openstack/nova_driver.py b/sfa/openstack/nova_driver.py index 7a84c2e6..e0afd07f 100644 --- a/sfa/openstack/nova_driver.py +++ b/sfa/openstack/nova_driver.py @@ -2,7 +2,7 @@ import time import datetime from sfa.util.faults import MissingSfaInfo, UnknownSfaType, \ - RecordNotFound, SfaNotImplemented, SfaInvalidArgument + RecordNotFound, SfaNotImplemented, SfaInvalidArgument, UnsupportedOperation from sfa.util.sfalogging import logger from sfa.util.defaultdict import defaultdict @@ -13,9 +13,10 @@ from sfa.util.cache import Cache from sfa.trust.credential import Credential # used to be used in get_ticket #from sfa.trust.sfaticket import SfaTicket - from sfa.rspecs.version_manager import VersionManager from sfa.rspecs.rspec import RSpec +from sfa.storage.alchemy import dbsession +from sfa.storage.model import RegRecord, SliverAllocation # the driver interface, mostly provides default behaviours from sfa.managers.driver import Driver @@ -48,6 +49,41 @@ class NovaDriver(Driver): if NovaDriver.cache is None: NovaDriver.cache = Cache() self.cache = NovaDriver.cache + + def sliver_to_slice_xrn(self, xrn): + 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) + slice_xrn = OSXrn(name=slice.name, type='slice') + return slice_xrn + + def check_sliver_credentials(self, creds, urns): + # build list of cred object hrns + slice_cred_names = [] + for cred in creds: + slice_cred_hrn = Credential(cred=cred).get_gid_object().get_hrn() + slice_cred_names.append(OSXrn(xrn=slice_cred_hrn).get_slicename()) + + # look up slice name of slivers listed in urns arg + slice_ids = [] + for urn in urns: + sliver_id_parts = Xrn(xrn=urn).get_sliver_id_parts() + slice_ids.append(sliver_id_parts[0]) + + if not slice_ids: + raise Forbidden("sliver urn not provided") + + sliver_names = [] + for slice_id in slice_ids: + 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 + for sliver_name in sliver_names: + if sliver_name not in slice_cred_names: + msg = "Valid credential not found for target: %s" % sliver_name + raise Forbidden(msg) ######################################## ########## registry oriented @@ -319,21 +355,23 @@ class NovaDriver(Driver): return {} # first 2 args are None in case of resource discovery - def list_resources (self, version, options): + def list_resources (self, version=None, options={}): aggregate = OSAggregate(self) rspec = aggregate.list_resources(version=version, options=options) return rspec - def describe(self, urns, version, options): + def describe(self, urns, version=None, options={}): aggregate = OSAggregate(self) return aggregate.describe(urns, version=version, options=options) def status (self, urns, options={}): aggregate = OSAggregate(self) desc = aggregate.describe(urns) - return desc['geni_slivers'] + status = {'geni_urn': desc['geni_urn'], + 'geni_slivers': desc['geni_slivers']} + return status - def allocate (self, urn, rspec_string, options): + def allocate (self, urn, rspec_string, expiration, options={}): xrn = Xrn(urn) aggregate = OSAggregate(self) @@ -353,99 +391,92 @@ class NovaDriver(Driver): rspec = RSpec(rspec_string) instance_name = hrn_to_os_slicename(slice_hrn) tenant_name = OSXrn(xrn=slice_hrn, type='slice').get_tenant_name() - aggregate.run_instances(instance_name, tenant_name, rspec_string, key_name, pubkeys) + slivers = aggregate.run_instances(instance_name, tenant_name, \ + rspec_string, key_name, pubkeys) + + # update all sliver allocation states setting then to geni_allocated + sliver_ids = [sliver.id for sliver in slivers] + SliverAllocation.set_allocations(sliver_ids, 'geni_allocated') - return aggregate.describe(slice_xrn=slice_urn, version=rspec.version) + return aggregate.describe(urns=[urn], version=rspec.version) - def provision(self, urns, version, options): + def provision(self, urns, options={}): + # update sliver allocation states and set them to geni_provisioned aggregate = OSAggregate(self) - return aggregate.describe(urns, version=version, options=options) - - def delete (self, urns, options): + instances = aggregate.get_instances(urns) + sliver_ids = [] + for instance in instances: + sliver_hrn = "%s.%s" % (self.driver.hrn, instance.id) + sliver_ids.append(Xrn(sliver_hrn, type='sliver').urn) + SliverAllocation.set_allocations(sliver_ids, 'geni_provisioned') + version_manager = VersionManager() + rspec_version = version_manager.get_version(options['geni_rspec_version']) + return self.describe(urns, rspec_version, options=options) + + def delete (self, urns, options={}): + # collect sliver ids so we can update sliver allocation states after + # we remove the slivers. aggregate = OSAggregate(self) - for urn in urns: - xrn = OSXrn(xrn=urn, type='slice') - tenant_name = xrn.get_tenant_name() - project_name = xrn.get_slicename() - id = xrn.id - aggregate.delete_instance(tenant_name, project_name, id) - return 1 - - def renew (self, urns, expiration_time, options): - return True - - def perform_operational_action (self, urns, action, options): - tenant_name = OSXrn(xrn=slice_hrn, type='slice').get_tenant_name() - name = OSXrn(xrn=slice_urn).name + instances = aggregate.get_instances(urns) + sliver_ids = [] + 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 + SliverAllocation.delete_allocations(sliver_ids) + + # return geni_slivers + geni_slivers = [] + for sliver_id in sliver_ids: + geni_slivers.append( + {'geni_sliver_urn': sliver['sliver_id'], + 'geni_allocation_status': 'geni_unallocated', + 'geni_expires': None}) + return geni_slivers + + def renew (self, urns, expiration_time, options={}): + description = self.describe(urns, None, options) + return description['geni_slivers'] + + def perform_operational_action (self, urns, action, options={}): aggregate = OSAggregate(self) - return aggregate.stop_instances(name, tenant_name) - - # xxx this code is quite old and has not run for ages - # it is obviously totally broken and needs a rewrite - def get_ticket (self, slice_urn, slice_hrn, creds, rspec_string, options): - raise SfaNotImplemented,"OpenStackDriver.get_ticket needs a rewrite" -# please keep this code for future reference -# slices = PlSlices(self) -# peer = slices.get_peer(slice_hrn) -# sfa_peer = slices.get_sfa_peer(slice_hrn) -# -# # get the slice record -# credential = api.getCredential() -# interface = api.registries[api.hrn] -# registry = api.server_proxy(interface, credential) -# records = registry.Resolve(xrn, credential) -# -# # make sure we get a local slice record -# record = None -# for tmp_record in records: -# if tmp_record['type'] == 'slice' and \ -# not tmp_record['peer_authority']: -# #Error (E0602, GetTicket): Undefined variable 'SliceRecord' -# slice_record = SliceRecord(dict=tmp_record) -# if not record: -# raise RecordNotFound(slice_hrn) -# -# # similar to CreateSliver, we must verify that the required records exist -# # at this aggregate before we can issue a ticket -# # parse rspec -# rspec = RSpec(rspec_string) -# requested_attributes = rspec.version.get_slice_attributes() -# -# # ensure site record exists -# site = slices.verify_site(slice_hrn, slice_record, peer, sfa_peer) -# # ensure slice record exists -# slice = slices.verify_slice(slice_hrn, slice_record, peer, sfa_peer) -# # ensure person records exists -# # xxx users is undefined in this context -# persons = slices.verify_persons(slice_hrn, slice, users, peer, sfa_peer) -# # ensure slice attributes exists -# slices.verify_slice_attributes(slice, requested_attributes) -# -# # get sliver info -# slivers = slices.get_slivers(slice_hrn) -# -# if not slivers: -# raise SliverDoesNotExist(slice_hrn) -# -# # get initscripts -# initscripts = [] -# data = { -# 'timestamp': int(time.time()), -# 'initscripts': initscripts, -# 'slivers': slivers -# } -# -# # create the ticket -# object_gid = record.get_gid_object() -# new_ticket = SfaTicket(subject = object_gid.get_subject()) -# new_ticket.set_gid_caller(api.auth.client_gid) -# new_ticket.set_gid_object(object_gid) -# new_ticket.set_issuer(key=api.key, subject=self.hrn) -# new_ticket.set_pubkey(object_gid.get_pubkey()) -# new_ticket.set_attributes(data) -# new_ticket.set_rspec(rspec) -# #new_ticket.set_parent(api.auth.hierarchy.get_auth_ticket(auth_hrn)) -# new_ticket.encode() -# new_ticket.sign() -# -# return new_ticket.save_to_string(save_parents=True) + action = action.lower() + if action == 'geni_start': + action_method = aggregate.start_instances + elif action == 'geni_stop': + action_method = aggregate.stop_instances + elif action == 'geni_restart': + action_method = aggreate.restart_instances + else: + raise UnsupportedOperation(action) + + # 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)") + # + # Perform Operational Action Here + # + + 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) + description = self.describe(urns) + geni_slivers = self.describe(urns, None, options)['geni_slivers'] + return geni_slivers + + def shutdown(self, xrn, options={}): + xrn = OSXrn(xrn=xrn, type='slice') + tenant_name = xrn.get_tenant_name() + name = xrn.get_slicename() + self.driver.shell.nova_manager.connect(tenant=tenant_name) + instances = self.driver.shell.nova_manager.servers.findall(name=name) + for instance in instances: + self.driver.shell.nova_manager.servers.shutdown(instance) + return True