X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fplc%2Fpldriver.py;h=a93ebd523eee18b57eaa86f30bd71e301b9a2445;hb=1a5299af32460c03bab9e7d32c46e65e3e0a7843;hp=2b9607ea7a706daf02bf9f1167a20622f1cd419b;hpb=63e8fdcc8554793bc2766e674a6b558338d29b56;p=sfa.git diff --git a/sfa/plc/pldriver.py b/sfa/plc/pldriver.py index 2b9607ea..a93ebd52 100644 --- a/sfa/plc/pldriver.py +++ b/sfa/plc/pldriver.py @@ -1,5 +1,5 @@ # -from sfa.util.faults import MissingSfaInfo +from sfa.util.faults import MissingSfaInfo, UnknownSfaType from sfa.util.sfalogging import logger from sfa.util.table import SfaTable from sfa.util.defaultdict import defaultdict @@ -17,20 +17,17 @@ def list_to_dict(recs, key): convert a list of dictionaries into a dictionary keyed on the specified dictionary key """ - keys = [rec[key] for rec in recs] - return dict(zip(keys, recs)) + return dict ( [ (rec[key],rec) for rec in recs ] ) # -# inheriting Driver is not very helpful in the PL case but -# makes sense in the general case -# # PlShell is just an xmlrpc serverproxy where methods # can be sent as-is; it takes care of authentication # from the global config # -# so OTOH we inherit PlShell just so one can do driver.GetNodes +# so we inherit PlShell just so one can do driver.GetNodes # which would not make much sense in the context of other testbeds -# so ultimately PlDriver might just as well drop the PlShell inheritance +# so ultimately PlDriver should drop the PlShell inheritance +# and would have a driver.shell reference to a PlShell instead # class PlDriver (Driver, PlShell): @@ -38,24 +35,20 @@ class PlDriver (Driver, PlShell): PlShell.__init__ (self, config) self.hrn = config.SFA_INTERFACE_HRN - # xxx thgen fixme - use SfaTable hardwired for now - # will need to extend generic to support multiple storage systems - #self.SfaTable = SfaTable - # Initialize the PLC shell only if SFA wraps a myPLC - rspec_type = config.get_aggregate_type() - assert (rspec_type == 'pl' or rspec_type == 'vini' or \ - rspec_type == 'eucalyptus' or rspec_type == 'max') ########## disabled users - def is_enabled_entity (self, record, aggregates): - self.fill_record_info(record, api.aggregates) + def is_enabled (self, record): + # the incoming record was augmented already, so 'enabled' should be set if record['type'] == 'user': return record['enabled'] # only users can be disabled return True + def augment_records_with_testbed_info (self, sfa_records): + return self.fill_record_info (sfa_records) + ########## - def register (self, hrn, sfa_record, pub_key): + def register (self, sfa_record, hrn, pub_key): type = sfa_record['type'] pl_record = self.sfa_fields_to_pl_fields(type, hrn, sfa_record) @@ -108,6 +101,86 @@ class PlDriver (Driver, PlShell): return pointer + ########## + # 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): + pointer = old_sfa_record['pointer'] + type = old_sfa_record['type'] + + # new_key implemented for users only + if new_key and type not in [ 'user' ]: + raise UnknownSfaType(type) + + if (type == "authority"): + self.UpdateSite(pointer, new_sfa_record) + + 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.UpdateSlice(pointer, pl_record) + + elif type == "user": + # SMBAKER: UpdatePerson only allows a limited set of fields to be + # updated. Ideally we should have a more generic way of doing + # this. I copied the field names from UpdatePerson.py... + update_fields = {} + all_fields = new_sfa_record + for key in all_fields.keys(): + if key in ['first_name', 'last_name', 'title', 'email', + 'password', 'phone', 'url', 'bio', 'accepted_aup', + 'enabled']: + update_fields[key] = all_fields[key] + self.UpdatePerson(pointer, update_fields) + + if new_key: + # must check this key against the previous one if it exists + persons = self.GetPersons([pointer], ['key_ids']) + person = persons[0] + keys = person['key_ids'] + keys = self.GetKeys(person['key_ids']) + + # Delete all stale keys + key_exists = False + for key in keys: + if new_key != key['key']: + self.DeleteKey(key['key_id']) + else: + key_exists = True + if not key_exists: + self.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key}) + + elif type == "node": + self.UpdateNode(pointer, new_sfa_record) + + return True + + + ########## + def remove (self, sfa_record): + type=sfa_record['type'] + pointer=sfa_record['pointer'] + if type == 'user': + persons = self.GetPersons(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.DeletePerson(pointer) + elif type == 'slice': + if self.GetSlices(pointer): + self.DeleteSlice(pointer) + elif type == 'node': + if self.GetNodes(pointer): + self.DeleteNode(pointer) + elif type == 'authority': + if self.GetSites(pointer): + self.DeleteSite(pointer) + + return True + + + + ## # Convert SFA fields to PLC fields for use when registering up updating @@ -156,7 +229,7 @@ class PlDriver (Driver, PlShell): return pl_record #################### - def fill_record_info(self, records, aggregates): + def fill_record_info(self, records): """ Given a (list of) SFA record, fill in the PLC specific and SFA specific fields in the record. @@ -165,16 +238,16 @@ class PlDriver (Driver, PlShell): records = [records] self.fill_record_pl_info(records) - self.fill_record_sfa_info(records, aggregates) + self.fill_record_hrns(records) + self.fill_record_sfa_info(records) + return records def fill_record_pl_info(self, records): """ Fill in the planetlab specific fields of a SFA record. This involves calling the appropriate PLC method to retrieve the database record for the object. - - PLC data is filled into the pl_info field of the record. - + @param record: record to fill in field (in/out param) """ # get ids by type @@ -233,9 +306,6 @@ class PlDriver (Driver, PlShell): pubkeys = [keys[key_id]['key'] for key_id in record['key_ids'] if key_id in keys] record['keys'] = pubkeys - # fill in record hrns - records = self.fill_record_hrns(records) - return records def fill_record_hrns(self, records): @@ -311,7 +381,7 @@ class PlDriver (Driver, PlShell): return records # aggregates is basically api.aggregates - def fill_record_sfa_info(self, records, aggregates): + def fill_record_sfa_info(self, records): def startswith(prefix, values): return [value for value in values if value.startswith(prefix)] @@ -392,10 +462,6 @@ class PlDriver (Driver, PlShell): elif (type.startswith("authority")): record['url'] = None - if record['hrn'] in aggregates: - - record['url'] = aggregates[record['hrn']].get_url() - if record['pointer'] != -1: record['PI'] = [] record['operator'] = [] @@ -424,54 +490,24 @@ class PlDriver (Driver, PlShell): # xxx TODO: PostalAddress, Phone record.update(sfa_info) + #################### - def update_membership(self, oldRecord, record): - if record.type == "slice": - self.update_membership_list(oldRecord, record, 'researcher', - self.AddPersonToSlice, - self.DeletePersonFromSlice) - elif record.type == "authority": - # xxx TODO - pass - - def update_membership_list(self, oldRecord, record, listName, addFunc, delFunc): - # get a list of the HRNs that are members of the old and new records - if oldRecord: - oldList = oldRecord.get(listName, []) + # plcapi works by changes, compute what needs to be added/deleted + 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.GetSlices (subject_id)[0] + current_target_ids = subject['person_ids'] + add_target_ids = list ( set (target_ids).difference(current_target_ids)) + del_target_ids = list ( set (current_target_ids).difference(target_ids)) + logger.info ("subject_id = %s (type=%s)"%(subject_id,type(subject_id))) + for target_id in add_target_ids: + self.AddPersonToSlice (target_id,subject_id) + logger.info ("add_target_id = %s (type=%s)"%(target_id,type(target_id))) + for target_id in del_target_ids: + logger.info ("del_target_id = %s (type=%s)"%(target_id,type(target_id))) + self.DeletePersonFromSlice (target_id, subject_id) else: - oldList = [] - newList = record.get(listName, []) - - # if the lists are the same, then we don't have to update anything - if (oldList == newList): - return + logger.info('unexpected relation to maintain, %s -> %s'%(subject_type,target_type)) - # build a list of the new person ids, by looking up each person to get - # their pointer - newIdList = [] - # xxx thgen fixme - use SfaTable hardwired for now - #table = self.SfaTable() - table = SfaTable() - records = table.find({'type': 'user', 'hrn': newList}) - for rec in records: - newIdList.append(rec['pointer']) - - # build a list of the old person ids from the person_ids field - if oldRecord: - oldIdList = oldRecord.get("person_ids", []) - containerId = oldRecord.get_pointer() - else: - # if oldRecord==None, then we are doing a Register, instead of an - # update. - oldIdList = [] - containerId = record.get_pointer() - - # add people who are in the new list, but not the oldList - for personId in newIdList: - if not (personId in oldIdList): - addFunc(personId, containerId) - - # remove people who are in the old list, but not the new list - for personId in oldIdList: - if not (personId in newIdList): - delFunc(personId, containerId) +