X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fplanetlab%2Fpldriver.py;h=d16b23a666186e317fa70ca8e83975875551acd6;hb=82d0355774b73966cbe0c838c611808dfd2f1c7a;hp=d12bc7a1466f028fb70a1c9e89c5afc6f69de99a;hpb=eeef683b4ed20be3fb83ba0c7cc688154e95e257;p=sfa.git diff --git a/sfa/planetlab/pldriver.py b/sfa/planetlab/pldriver.py index d12bc7a1..d16b23a6 100644 --- a/sfa/planetlab/pldriver.py +++ b/sfa/planetlab/pldriver.py @@ -10,7 +10,6 @@ from sfa.util.xrn import Xrn, hrn_to_urn, get_leaf from sfa.util.cache import Cache # one would think the driver should not need to mess with the SFA db, but.. -from sfa.storage.alchemy import dbsession from sfa.storage.model import RegRecord, SliverAllocation from sfa.trust.credential import Credential @@ -22,10 +21,9 @@ from sfa.rspecs.rspec import RSpec # the driver interface, mostly provides default behaviours from sfa.managers.driver import Driver from sfa.planetlab.plshell import PlShell -import sfa.planetlab.peers as peers from sfa.planetlab.plaggregate import PlAggregate from sfa.planetlab.plslices import PlSlices -from sfa.planetlab.plxrn import PlXrn, slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, xrn_to_hostname +from sfa.planetlab.plxrn import PlXrn, slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, top_auth, hash_loginbase def list_to_dict(recs, key): @@ -45,8 +43,9 @@ class PlDriver (Driver): # the cache instance is a class member so it survives across incoming requests cache = None - def __init__ (self, config): - Driver.__init__ (self, config) + def __init__ (self, api): + Driver.__init__ (self, api) + config=api.config self.shell = PlShell (config) self.cache=None if config.SFA_AGGREGATE_CACHING: @@ -56,12 +55,16 @@ class PlDriver (Driver): def sliver_to_slice_xrn(self, xrn): sliver_id_parts = Xrn(xrn).get_sliver_id_parts() - slice_id = int(sliver_id_parts[0]) - slices = self.shell.GetSlices(slice_id) + filter = {'peer_id': None} + try: + filter['slice_id'] = int(sliver_id_parts[0]) + except ValueError: + filter['name'] = sliver_id_parts[0] + slices = self.shell.GetSlices(filter,['hrn']) if not slices: raise Forbidden("Unable to locate slice record for sliver: %s" % xrn) slice = slices[0] - slice_xrn = PlXrn(auth=self.hrn, slicename=slice['name']) + slice_xrn = slice['hrn'] return slice_xrn def check_sliver_credentials(self, creds, urns): @@ -69,13 +72,25 @@ class PlDriver (Driver): slice_cred_names = [] for cred in creds: slice_cred_hrn = Credential(cred=cred).get_gid_object().get_hrn() - slice_cred_names.append(PlXrn(xrn=slice_cred_hrn).pl_slicename()) + top_auth_hrn = top_auth(slice_cred_hrn) + site_hrn = '.'.join(slice_cred_hrn.split('.')[:-1]) + slice_part = slice_cred_hrn.split('.')[-1] + if top_auth_hrn == self.hrn: + login_base = slice_cred_hrn.split('.')[-2][:12] + else: + login_base = hash_loginbase(site_hrn) + + slicename = '_'.join([login_base, slice_part]) + slice_cred_names.append(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]) + try: + slice_ids.append(int(sliver_id_parts[0])) + except ValueError: + pass if not slice_ids: raise Forbidden("sliver urn not provided") @@ -102,12 +117,13 @@ class PlDriver (Driver): pl_record = self.sfa_fields_to_pl_fields(type, hrn, sfa_record) if type == 'authority': - sites = self.shell.GetSites([pl_record['login_base']]) + sites = self.shell.GetSites({'peer_id': None, 'login_base': pl_record['login_base']}) if not sites: # xxx when a site gets registered through SFA we need to set its max_slices if 'max_slices' not in pl_record: pl_record['max_slices']=2 pointer = self.shell.AddSite(pl_record) + self.shell.SetSiteHrn(int(pointer), hrn) else: pointer = sites[0]['site_id'] @@ -116,14 +132,19 @@ class PlDriver (Driver): for key in pl_record.keys(): if key not in acceptable_fields: pl_record.pop(key) - slices = self.shell.GetSlices([pl_record['name']]) + slices = self.shell.GetSlices({'peer_id': None, 'name': pl_record['name']}) if not slices: + if not pl_record.get('url', None) or not pl_record.get('description', None): + pl_record['url'] = hrn + pl_record['description'] = hrn + pointer = self.shell.AddSlice(pl_record) + self.shell.SetSliceHrn(int(pointer), hrn) else: pointer = slices[0]['slice_id'] elif type == 'user': - persons = self.shell.GetPersons({'email':sfa_record['email']}) + persons = self.shell.GetPersons({'peer_id': None, 'email': sfa_record['email']}) if not persons: for key in ['first_name','last_name']: if key not in sfa_record: sfa_record[key]='*from*sfa*' @@ -131,16 +152,15 @@ class PlDriver (Driver): can_add = ['first_name', 'last_name', 'title','email', 'password', 'phone', 'url', 'bio'] add_person_dict=dict ( [ (k,sfa_record[k]) for k in sfa_record if k in can_add ] ) pointer = self.shell.AddPerson(add_person_dict) + self.shell.SetPersonHrn(int(pointer), hrn) else: pointer = persons[0]['person_id'] - if 'enabled' in sfa_record and sfa_record['enabled']: - self.shell.UpdatePerson(pointer, {'enabled': sfa_record['enabled']}) - # add this person to the site only if she is being added for the first - # time by sfa and doesont already exist in plc - if not persons or not persons[0]['site_ids']: - login_base = get_leaf(sfa_record['authority']) - self.shell.AddPersonToSite(pointer, login_base) + # enable the person's account + self.shell.UpdatePerson(pointer, {'enabled': True}) + # add this person to the site + login_base = get_leaf(sfa_record['authority']) + self.shell.AddPersonToSite(pointer, login_base) # What roles should this user have? roles=[] @@ -157,10 +177,11 @@ class PlDriver (Driver): self.shell.AddPersonKey(pointer, {'key_type' : 'ssh', 'key' : pub_key}) elif type == 'node': - login_base = PlXrn(xrn=sfa_record['authority'],type='node').pl_login_base() - nodes = self.shell.GetNodes([pl_record['hostname']]) + login_base = PlXrn(xrn=sfa_record['authority'],type='authority').pl_login_base() + nodes = self.shell.GetNodes({'peer_id': None, 'hostname': pl_record['hostname']}) if not nodes: pointer = self.shell.AddNode(login_base, pl_record) + self.shell.SetNodeHrn(int(pointer), hrn) else: pointer = nodes[0]['node_id'] @@ -171,6 +192,7 @@ class PlDriver (Driver): def update (self, old_sfa_record, new_sfa_record, hrn, new_key): pointer = old_sfa_record['pointer'] type = old_sfa_record['type'] + new_key_pointer = None # new_key implemented for users only if new_key and type not in [ 'user' ]: @@ -178,12 +200,14 @@ class PlDriver (Driver): if (type == "authority"): self.shell.UpdateSite(pointer, new_sfa_record) + self.shell.SetSiteHrn(pointer, hrn) elif type == "slice": pl_record=self.sfa_fields_to_pl_fields(type, hrn, new_sfa_record) if 'name' in pl_record: pl_record.pop('name') self.shell.UpdateSlice(pointer, pl_record) + self.shell.SetSliceHrn(pointer, hrn) elif type == "user": # SMBAKER: UpdatePerson only allows a limited set of fields to be @@ -201,28 +225,28 @@ class PlDriver (Driver): if 'email' in update_fields and not update_fields['email']: del update_fields['email'] self.shell.UpdatePerson(pointer, update_fields) + self.shell.SetPersonHrn(pointer, hrn) if new_key: # must check this key against the previous one if it exists - persons = self.shell.GetPersons([pointer], ['key_ids']) + persons = self.shell.GetPersons({'peer_id': None, 'person_id': pointer}, ['key_ids']) person = persons[0] keys = person['key_ids'] keys = self.shell.GetKeys(person['key_ids']) - # Delete all stale keys key_exists = False for key in keys: - if new_key != key['key']: - self.shell.DeleteKey(key['key_id']) - else: + if new_key == key['key']: key_exists = True + new_key_pointer = key['key_id'] + break if not key_exists: - self.shell.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key}) + new_key_pointer = self.shell.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key}) elif type == "node": self.shell.UpdateNode(pointer, new_sfa_record) - return True + return (pointer, new_key_pointer) ########## @@ -230,19 +254,19 @@ class PlDriver (Driver): type=sfa_record['type'] pointer=sfa_record['pointer'] if type == 'user': - persons = self.shell.GetPersons(pointer) + persons = self.shell.GetPersons({'peer_id': None, 'person_id': pointer}) # only delete this person if he has site ids. if he doesnt, it probably means # he was just removed from a site, not actually deleted if persons and persons[0]['site_ids']: self.shell.DeletePerson(pointer) elif type == 'slice': - if self.shell.GetSlices(pointer): + if self.shell.GetSlices({'peer_id': None, 'slice_id': pointer}): self.shell.DeleteSlice(pointer) elif type == 'node': - if self.shell.GetNodes(pointer): + if self.shell.GetNodes({'peer_id': None, 'node_id': pointer}): self.shell.DeleteNode(pointer) elif type == 'authority': - if self.shell.GetSites(pointer): + if self.shell.GetSites({'peer_id': None, 'site_id': pointer}): self.shell.DeleteSite(pointer) return True @@ -335,16 +359,16 @@ class PlDriver (Driver): # get pl records nodes, sites, slices, persons, keys = {}, {}, {}, {}, {} if node_ids: - node_list = self.shell.GetNodes(node_ids) + node_list = self.shell.GetNodes({'peer_id': None, 'node_id': node_ids}) nodes = list_to_dict(node_list, 'node_id') if site_ids: - site_list = self.shell.GetSites(site_ids) + site_list = self.shell.GetSites({'peer_id': None, 'site_id': site_ids}) sites = list_to_dict(site_list, 'site_id') if slice_ids: - slice_list = self.shell.GetSlices(slice_ids) + slice_list = self.shell.GetSlices({'peer_id': None, 'slice_id': slice_ids}) slices = list_to_dict(slice_list, 'slice_id') if person_ids: - person_list = self.shell.GetPersons(person_ids) + person_list = self.shell.GetPersons({'peer_id': None, 'person_id': person_ids}) persons = list_to_dict(person_list, 'person_id') for person in persons: key_ids.extend(persons[person]['key_ids']) @@ -401,16 +425,16 @@ class PlDriver (Driver): # get pl records slices, persons, sites, nodes = {}, {}, {}, {} if site_ids: - site_list = self.shell.GetSites(site_ids, ['site_id', 'login_base']) + site_list = self.shell.GetSites({'peer_id': None, 'site_id': site_ids}, ['site_id', 'login_base']) sites = list_to_dict(site_list, 'site_id') if person_ids: - person_list = self.shell.GetPersons(person_ids, ['person_id', 'email']) + person_list = self.shell.GetPersons({'peer_id': None, 'person_id': person_ids}, ['person_id', 'email']) persons = list_to_dict(person_list, 'person_id') if slice_ids: - slice_list = self.shell.GetSlices(slice_ids, ['slice_id', 'name']) + slice_list = self.shell.GetSlices({'peer_id': None, 'slice_id': slice_ids}, ['slice_id', 'name']) slices = list_to_dict(slice_list, 'slice_id') if node_ids: - node_list = self.shell.GetNodes(node_ids, ['node_id', 'hostname']) + node_list = self.shell.GetNodes({'peer_id': None, 'node_id': node_ids}, ['node_id', 'hostname']) nodes = list_to_dict(node_list, 'node_id') # convert ids to hrns @@ -474,7 +498,7 @@ class PlDriver (Driver): # and store them in a dictionary keyed on site_id site_pis = {} if site_ids: - pi_filter = {'|roles': ['pi'], '|site_ids': site_ids} + pi_filter = {'peer_id': None, '|roles': ['pi'], '|site_ids': site_ids} pi_list = self.shell.GetPersons(pi_filter, ['person_id', 'site_ids']) for pi in pi_list: # we will need the pi's hrns also @@ -494,7 +518,7 @@ class PlDriver (Driver): # get the registry records person_list, persons = [], {} - person_list = dbsession.query (RegRecord).filter(RegRecord.pointer.in_(person_ids)) + person_list = self.api.dbsession().query (RegRecord).filter(RegRecord.pointer.in_(person_ids)) # create a hrns keyed on the sfa record's pointer. # Its possible for multiple records to have the same pointer so # the dict's value will be a list of hrns. @@ -585,7 +609,7 @@ class PlDriver (Driver): elif subject_type == 'authority' and target_type == 'user' and relation_name == 'pi': # due to the plcapi limitations this means essentially adding pi role to all people in the list # it's tricky to remove any pi role here, although it might be desirable - persons = self.shell.GetPersons (target_ids) + persons = self.shell.GetPersons ({'peer_id': None, 'person_id': target_ids}) for person in persons: if 'pi' not in person['roles']: self.shell.AddRoleToPerson('pi',person['person_id']) @@ -603,30 +627,34 @@ class PlDriver (Driver): return {} # first 2 args are None in case of resource discovery - def list_resources (self, version=None, options={}): + def list_resources (self, version=None, options=None): + if options is None: options={} aggregate = PlAggregate(self) rspec = aggregate.list_resources(version=version, options=options) return rspec - def describe(self, urns, version, options={}): + def describe(self, urns, version, options=None): + if options is None: options={} aggregate = PlAggregate(self) return aggregate.describe(urns, version=version, options=options) - def status (self, urns, options={}): + def status (self, urns, options=None): + if options is None: options={} aggregate = PlAggregate(self) - desc = aggregate.describe(urns) + desc = aggregate.describe(urns, version='GENI 3') 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=None): + if options is None: options={} xrn = Xrn(urn) aggregate = PlAggregate(self) slices = PlSlices(self) - peer = slices.get_peer(xrn.get_hrn()) sfa_peer = slices.get_sfa_peer(xrn.get_hrn()) slice_record=None users = options.get('geni_users', []) + if users: slice_record = users[0].get('slice_record', {}) @@ -635,82 +663,95 @@ class PlDriver (Driver): requested_attributes = rspec.version.get_slice_attributes() # ensure site record exists - site = slices.verify_site(xrn.hrn, slice_record, peer, sfa_peer, options=options) + site = slices.verify_site(xrn.hrn, slice_record, sfa_peer, options=options) # ensure slice record exists - slice = slices.verify_slice(xrn.hrn, slice_record, peer, sfa_peer, options=options) + slice = slices.verify_slice(xrn.hrn, slice_record, sfa_peer, expiration=expiration, options=options) # ensure person records exists - persons = slices.verify_persons(xrn.hrn, slice, users, peer, sfa_peer, options=options) + persons = slices.verify_persons(xrn.hrn, slice, users, sfa_peer, options=options) # ensure slice attributes exists slices.verify_slice_attributes(slice, requested_attributes, options=options) # add/remove slice from nodes request_nodes = rspec.version.get_nodes_with_slivers() - nodes = slices.verify_slice_nodes(urn, slice, request_nodes, peer) + nodes = slices.verify_slice_nodes(urn, slice, request_nodes) # add/remove links links slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes) # add/remove leases - requested_leases = [] - kept_leases = [] - for lease in rspec.version.get_leases(): - requested_lease = {} - if not lease.get('lease_id'): - requested_lease['hostname'] = xrn_to_hostname(lease.get('component_id').strip()) - requested_lease['start_time'] = lease.get('start_time') - requested_lease['duration'] = lease.get('duration') - else: - kept_leases.append(int(lease['lease_id'])) - if requested_lease.get('hostname'): - requested_leases.append(requested_lease) - - leases = slices.verify_slice_leases(slice, requested_leases, kept_leases, peer) - # handle MyPLC peer association. - # only used by plc and ple. - slices.handle_peer(site, slice, persons, peer) - + rspec_requested_leases = rspec.version.get_leases() + leases = slices.verify_slice_leases(slice, rspec_requested_leases) + return aggregate.describe([xrn.get_urn()], version=rspec.version) - def provision(self, urns, options={}): - # update sliver allocation states and set them to geni_provisioned + def provision(self, urns, options=None): + if options is None: options={} + # update users + slices = PlSlices(self) aggregate = PlAggregate(self) slivers = aggregate.get_slivers(urns) - sliver_ids = [sliver['sliver_id'] for sliver in slivers] - SliverAllocation.set_allocations(sliver_ids, 'geni_provisioned') + if not slivers: + sliver_id_parts = Xrn(urns[0]).get_sliver_id_parts() + # allow to be called with an empty rspec, meaning flush reservations + if sliver_id_parts: + filter = {} + try: + filter['slice_id'] = int(sliver_id_parts[0]) + except ValueError: + filter['name'] = sliver_id_parts[0] + slices = self.shell.GetSlices(filter,['hrn']) + if not slices: + raise Forbidden("Unable to locate slice record for sliver: %s" % xrn) + slice = slices[0] + slice_urn = hrn_to_urn(slice['hrn'], type='slice') + urns = [slice_urn] + else: + slice_id = slivers[0]['slice_id'] + slice_hrn = self.shell.GetSliceHrn(slice_id) + slice = self.shell.GetSlices({'slice_id': slice_id})[0] + slice['hrn'] = slice_hrn + sfa_peer = slices.get_sfa_peer(slice['hrn']) + users = options.get('geni_users', []) + persons = slices.verify_persons(slice['hrn'], slice, users, sfa_peer, options=options) + # update sliver allocation states and set them to geni_provisioned + sliver_ids = [sliver['sliver_id'] for sliver in slivers] + 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 delete(self, urns, 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 = PlAggregate(self) slivers = aggregate.get_slivers(urns) if slivers: slice_id = slivers[0]['slice_id'] + slice_name = slivers[0]['name'] node_ids = [] sliver_ids = [] for sliver in slivers: node_ids.append(sliver['node_id']) sliver_ids.append(sliver['sliver_id']) - # determine if this is a peer slice - # xxx I wonder if this would not need to use PlSlices.get_peer instead - # in which case plc.peers could be deprecated as this here - # is the only/last call to this last method in plc.peers - slice_hrn = PlXrn(auth=self.hrn, slicename=slivers[0]['name']).get_hrn() - peer = peers.get_peer(self, slice_hrn) + # leases + leases = self.shell.GetLeases({'name': slice_name, 'node_id': node_ids}) + leases_ids = [lease['lease_id'] for lease in leases ] + + slice_hrn = self.shell.GetSliceHrn(int(slice_id)) try: - if peer: - self.shell.UnBindObjectFromPeer('slice', slice_id, peer) - self.shell.DeleteSliceFromNodes(slice_id, node_ids) + if len(leases_ids) > 0: + self.shell.DeleteLeases(leases_ids) # delete sliver allocation states - SliverAllocation.delete_allocations(sliver_ids) + dbsession=self.api.dbsession() + SliverAllocation.delete_allocations(sliver_ids,dbsession) finally: - if peer: - self.shell.BindObjectToPeer('slice', slice_id, peer, slice['peer_slice_id']) + pass # prepare return struct geni_slivers = [] @@ -720,26 +761,23 @@ class PlDriver (Driver): 'geni_allocation_status': 'geni_unallocated', 'geni_expires': datetime_to_string(utcparse(sliver['expires']))}) return geni_slivers - - def renew (self, urns, expiration_time, options={}): - # we can only renew slices, not individual slivers. ignore sliver - # ids in the urn - names = [] - for urn in urns: - xrn = PlXrn(xrn=urn, type='slice') - names.append(xrn.pl_slicename()) - slices = self.shell.GetSlices(names, ['slice_id']) - if not slices: + + def renew (self, urns, expiration_time, options=None): + if options is None: options={} + aggregate = PlAggregate(self) + slivers = aggregate.get_slivers(urns) + if not slivers: raise SearchFailed(urns) - slice = slices[0] + slice = slivers[0] requested_time = utcparse(expiration_time) record = {'expires': int(datetime_to_epoch(requested_time))} self.shell.UpdateSlice(slice['slice_id'], record) - description = self.describe(urns, None, options) + description = self.describe(urns, 'GENI 3', options) return description['geni_slivers'] - def perform_operational_action (self, urns, action, options={}): + def perform_operational_action (self, urns, action, options=None): + if options is None: options={} # MyPLC doesn't support operational actions. Lets pretend like it # supports start, but reject everything else. action = action.lower() @@ -747,7 +785,7 @@ class PlDriver (Driver): raise UnsupportedOperation(action) # fault if sliver is not full allocated (operational status is geni_pending_allocation) - description = self.describe(urns, None, options) + description = self.describe(urns, 'GENI 3', 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)") @@ -755,14 +793,24 @@ class PlDriver (Driver): # Perform Operational Action Here # - geni_slivers = self.describe(urns, None, options)['geni_slivers'] + geni_slivers = self.describe(urns, 'GENI 3', options)['geni_slivers'] return geni_slivers # set the 'enabled' tag to 0 - def shutdown (self, xrn, options={}): - xrn = PlXrn(xrn=xrn, type='slice') - slicename = xrn.pl_slicename() - slices = self.shell.GetSlices({'name': slicename}, ['slice_id']) + def shutdown (self, xrn, options=None): + if options is None: options={} + hrn, _ = urn_to_hrn(xrn) + top_auth_hrn = top_auth(hrn) + site_hrn = '.'.join(hrn.split('.')[:-1]) + slice_part = hrn.split('.')[-1] + if top_auth_hrn == self.hrn: + login_base = slice_hrn.split('.')[-2][:12] + else: + login_base = hash_loginbase(site_hrn) + + slicename = '_'.join([login_base, slice_part]) + + slices = self.shell.GetSlices({'peer_id': None, 'name': slicename}, ['slice_id']) if not slices: raise RecordNotFound(slice_hrn) slice_id = slices[0]['slice_id']