review update_relation (formerly update_membership) between manager
Thierry Parmentelat [Mon, 28 Nov 2011 18:06:59 +0000 (19:06 +0100)]
and driver

sfa/managers/registry_manager.py
sfa/plc/pldriver.py

index 3fcc516..41531a1 100644 (file)
@@ -212,6 +212,22 @@ class RegistryManager:
         gid = api.auth.hierarchy.create_gid(xrn, create_uuid(), pkey) 
         return gid.save_to_string(save_parents=True)
         
+    # utility for handling relationships among the SFA objects 
+    # given that the SFA db does not handle this sort of relationsships
+    # it will rely on side-effects in the testbed to keep this persistent
+    # field_key is the name of one field in the record, typically 'researcher' for a 'slice' record
+    # hrns is the list of hrns that should be linked to the subject from now on
+    # target_type would be e.g. 'user' in the 'slice' x 'researcher' example
+    def update_relation (self, sfa_record, field_key, hrns, target_type):
+        # locate the linked objects in our db
+        subject_type=sfa_record['type']
+        subject_id=sfa_record['pointer']
+        table = SfaTable()
+        link_sfa_records = table.find ({'type':target_type, 'hrn': hrns})
+        link_ids = [ rec.get('pointer') for rec in link_sfa_records ]
+        self.driver.update_relation (subject_type, target_type, subject_id, link_ids)
+        
+
     def Register(self, api, record):
     
         hrn, type = record['hrn'], record['type']
@@ -264,7 +280,7 @@ class RegistryManager:
         record['record_id'] = record_id
     
         # update membership for researchers, pis, owners, operators
-        self.driver.update_membership(None, record)
+        self.update_relation(record, 'researcher', record.get('researcher'), 'user')
     
         return record.get_gid_object().save_to_string(save_parents=True)
     
@@ -297,10 +313,6 @@ class RegistryManager:
                 if isinstance (new_key,types.ListType):
                     new_key=new_key[0]
 
-        # Update_membership needs the membership lists in the existing record
-        # filled in, so it can see if members were added or removed
-        self.driver.fill_record_info(record)
-    
         # update the PLC information that was specified with the record
         if not self.driver.update (record, new_record, hrn, new_key):
             logger.warning("driver.update failed")
@@ -317,7 +329,7 @@ class RegistryManager:
             table.update(record)
         
         # update membership for researchers, pis, owners, operators
-        self.driver.update_membership(record, new_record)
+        self.update_relation(record, 'researcher', new_record.get('researcher'), 'user')
         
         return 1 
     
index 71ef7c2..1ec55b0 100644 (file)
@@ -20,14 +20,11 @@ def list_to_dict(recs, key):
     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 should drop the PlShell inheritance
 # and would have a driver.shell reference to a PlShell instead
@@ -498,54 +495,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":
-            logger.info("update_membership 'authority' not implemented")
-            pass
-        else:
-            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
+        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, [])
+            logger.info('unexpected relation to maintain, %s -> %s'%(subject_type,target_type))
 
-        # if the lists are the same, then we don't have to update anything
-        if (oldList == newList):
-            return
-
-        # build a list of the new person ids, by looking up each person to get
-        # their pointer
-        newIdList = []
-        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)
+