- return True
-
- def GetPeers (self,auth = None, peer_filter=None, return_fields=None):
-
- existing_records = {}
- existing_hrns_by_types= {}
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers auth = %s, peer_filter %s, return_field %s " %(auth , peer_filter, return_fields)
- all_records = dbsession.query(RegRecord).filter(RegRecord.type.like('%authority%')).all()
- for record in all_records:
- existing_records[(record.hrn,record.type)] = record
- if record.type not in existing_hrns_by_types:
- existing_hrns_by_types[record.type] = [record.hrn]
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers \t NOT IN existing_hrns_by_types %s " %( existing_hrns_by_types)
- else:
-
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers \t INNN type %s hrn %s " %( record.type,record.hrn )
- existing_hrns_by_types[record.type].append(record.hrn)
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers \t INNN existing_hrns_by_types %s " %( existing_hrns_by_types)
- #existing_hrns_by_types.update({record.type:(existing_hrns_by_types[record.type].append(record.hrn))})
-
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers existing_hrns_by_types %s " %( existing_hrns_by_types)
- records_list= []
-
- try:
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers existing_hrns_by_types['authority+sa'] %s \t\t existing_records %s " %(existing_hrns_by_types['authority'],existing_records)
- if peer_filter:
- records_list.append(existing_records[(peer_filter,'authority')])
- else :
- for hrn in existing_hrns_by_types['authority']:
- records_list.append(existing_records[(hrn,'authority')])
-
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers records_list %s " %(records_list)
-
- except:
- pass
-
- return_records = records_list
- if not peer_filter and not return_fields:
- return records_list
- #return_records = parse_filter(records_list,peer_filter, 'peers', return_fields)
-
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers return_records %s " %(return_records)
- return return_records
-
-
- #TODO : Handling OR request in make_ldap_filters_from_records instead of the for loop
- #over the records' list
- def GetPersons(self, person_filter=None, return_fields=None):
- """
- person_filter should be a list of dictionnaries when not set to None.
- Returns a list of users found.
-
- """
- print>>sys.stderr, "\r\n \r\n \t\t\t GetPersons person_filter %s" %(person_filter)
- person_list = []
- if person_filter and isinstance(person_filter,list):
- #If we are looking for a list of users (list of dict records)
- #Usually the list contains only one user record
- for f in person_filter:
- person = self.ldap.ldapFindHrn(f)
- person_list.append(person)
-
- else:
- person_list = self.ldap.ldapFindHrn()
-
- return person_list
- #person_list = self.ldap.ldapFindHrn({'authority': self.root_auth })
- ##check = False
- ##if person_filter and isinstance(person_filter, dict):
- ##for k in person_filter.keys():
- ##if k in person_list[0].keys():
- ##check = True
-
- #return_person_list = parse_filter(person_list,person_filter ,'persons', return_fields)
- #if return_person_list:
- #print>>sys.stderr, " \r\n GetPersons person_filter %s return_fields %s " %(person_filter,return_fields)
- #return return_person_list
-
- def GetTimezone(self):
- server_timestamp,server_tz = self.oar.parser.SendRequest("GET_timezone")
- return server_timestamp,server_tz
-
-
- def DeleteJobs(self, job_id, slice_hrn):
- if not job_id:
- return
- username = slice_hrn.split(".")[-1].rstrip("_slice")
- reqdict = {}
- reqdict['method'] = "delete"
- reqdict['strval'] = str(job_id)
- answer = self.oar.POSTRequestToOARRestAPI('DELETE_jobs_id',reqdict,username)
- print>>sys.stderr, "\r\n \r\n jobid DeleteJobs %s " %(answer)
-
-
- def GetJobs(self,job_id= None, resources=True,return_fields=None, username = None):
- #job_resources=['reserved_resources', 'assigned_resources','job_id', 'job_uri', 'assigned_nodes',\
- #'api_timestamp']
- #assigned_res = ['resource_id', 'resource_uri']
- #assigned_n = ['node', 'node_uri']
-
- if job_id and resources is False:
- req = "GET_jobs_id"
- node_list_k = 'assigned_network_address'
-
- if job_id and resources :
- req = "GET_jobs_id_resources"
- node_list_k = 'reserved_resources'
-
- #Get job info from OAR
- job_info = self.oar.parser.SendRequest(req, job_id, username)
- print>>sys.stderr, "\r\n \r\n \t\t GetJobs %s " %(job_info)
-
- if 'state' in job_info :
- if job_info['state'] == 'Terminated':
- print>>sys.stderr, "\r\n \r\n \t\t GetJobs TERMINELEBOUSIN "
- return None
- if job_info['state'] == 'Error':
- print>>sys.stderr, "\r\n \r\n \t\t GetJobs ERROR message %s " %(job_info)
- return None
-
- #Get a dict of nodes . Key :hostname of the node
- node_list = self.GetNodes()
- node_hostname_list = []
- for node in node_list:
- node_hostname_list.append(node['hostname'])
- node_dict = dict(zip(node_hostname_list,node_list))
- try :
- liste =job_info[node_list_k]
- for k in range(len(liste)):
- job_info[node_list_k][k] = node_dict[job_info[node_list_k][k]]['hostname']
-
- #Replaces the previous entry "assigned_network_address" / "reserved_resources"
- #with "node_ids"
- job_info.update({'node_ids':job_info[node_list_k]})
- del job_info[node_list_k]
- return job_info
-
- except KeyError:
- print>>sys.stderr, "\r\n \r\n \t\t GetJobs KEYERROR "
-
- def GetReservedNodes(self):
- # this function returns a list of all the nodes already involved in an oar job
- #jobs=self.oar.parser.SendRequest("GET_reserved_nodes")
- jobs=self.oar.parser.SendRequest("GET_jobs_details")
- nodes=[]
- for j in jobs :
- nodes=j['assigned_network_address']+nodes
- return nodes
-
- def GetNodes(self,node_filter= None, return_fields=None):
- node_dict =self.oar.parser.SendRequest("GET_resources_full")
-
- return_node_list = []
- if not (node_filter or return_fields):
- return_node_list = node_dict.values()
- return return_node_list
-
- return_node_list= parse_filter(node_dict.values(),node_filter ,'node', return_fields)
- return return_node_list
-
-
- def GetSites(self, site_filter = None, return_fields=None):
- site_dict =self.oar.parser.SendRequest("GET_sites")
- return_site_list = []
- if not ( site_filter or return_fields):
- return_site_list = site_dict.values()
- return return_site_list
-
- return_site_list = parse_filter(site_dict.values(), site_filter,'site', return_fields)
- return return_site_list
-
-
- def GetSlices(self,slice_filter = None, filter_type = None, return_fields=None):
- return_slice_list = []
- slicerec = {}
- rec = {}
- ftypes = ['slice_hrn', 'record_id_user']
- if filter_type and filter_type in ftypes:
- if filter_type == 'slice_hrn':
- slicerec = slab_dbsession.query(SliceSenslab).filter_by(slice_hrn = slice_filter).first()
- if filter_type == 'record_id_user':
- slicerec = slab_dbsession.query(SliceSenslab).filter_by(record_id_user = slice_filter).first()
-
- if slicerec:
- rec = slicerec.dumpquerytodict()
- login = slicerec.slice_hrn.split(".")[1].split("_")[0]
- #print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY slicerec GetSlices %s " %(slicerec)
- if slicerec.oar_job_id is not -1:
- rslt = self.GetJobs( slicerec.oar_job_id, resources=False, username = login )
- #print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY GetSlices GetJobs %s " %(rslt)
- if rslt :
- rec.update(rslt)
- rec.update({'hrn':str(rec['slice_hrn'])})
- #If GetJobs is empty, this means the job is now in the 'Terminated' state
- #Update the slice record
- else :
- self.db.update_job(slice_filter, job_id = -1)
- rec['oar_job_id'] = -1
- rec.update({'hrn':str(rec['slice_hrn'])})
-
- try:
- rec['node_ids'] = rec['node_list']
- except KeyError:
- pass
-
- #print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY GetSlices rec %s" %(rec)
-
- return rec
-
-
- else:
- return_slice_list = slab_dbsession.query(SliceSenslab).all()
-
- print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY GetSlices slices %s slice_filter %s " %(return_slice_list,slice_filter)
-
- #if return_fields:
- #return_slice_list = parse_filter(sliceslist, slice_filter,'slice', return_fields)
-
-
-
- return return_slice_list
-
-
-
-
- def testbed_name (self): return "senslab2"
-
- # 'geni_request_rspec_versions' and 'geni_ad_rspec_versions' are mandatory
- def aggregate_version (self):
- version_manager = VersionManager()
- ad_rspec_versions = []
- request_rspec_versions = []
- for rspec_version in version_manager.versions:
- if rspec_version.content_type in ['*', 'ad']:
- ad_rspec_versions.append(rspec_version.to_dict())
- if rspec_version.content_type in ['*', 'request']:
- request_rspec_versions.append(rspec_version.to_dict())
- return {
- 'testbed':self.testbed_name(),
- 'geni_request_rspec_versions': request_rspec_versions,
- 'geni_ad_rspec_versions': ad_rspec_versions,
- }
-
-
-
-
-
-
- ##
- # Convert SFA fields to PLC fields for use when registering up updating
- # registry record in the PLC database
- #
- # @param type type of record (user, slice, ...)
- # @param hrn human readable name
- # @param sfa_fields dictionary of SFA fields
- # @param slab_fields dictionary of PLC fields (output)
-
- def sfa_fields_to_slab_fields(self, type, hrn, record):
-
- def convert_ints(tmpdict, int_fields):
- for field in int_fields:
- if field in tmpdict:
- tmpdict[field] = int(tmpdict[field])
-
- slab_record = {}
- #for field in record:
- # slab_record[field] = record[field]
-
- if type == "slice":
- #instantion used in get_slivers ?
- if not "instantiation" in slab_record:
- slab_record["instantiation"] = "senslab-instantiated"
- slab_record["hrn"] = hrn_to_pl_slicename(hrn)
- print >>sys.stderr, "\r\n \r\n \t SLABDRIVER.PY sfa_fields_to_slab_fields slab_record %s hrn_to_pl_slicename(hrn) hrn %s " %(slab_record['hrn'], hrn)
- if "url" in record:
- slab_record["url"] = record["url"]
- if "description" in record:
- slab_record["description"] = record["description"]
- if "expires" in record:
- slab_record["expires"] = int(record["expires"])
-
- #nodes added by OAR only and then imported to SFA
- #elif type == "node":
- #if not "hostname" in slab_record:
- #if not "hostname" in record:
- #raise MissingSfaInfo("hostname")
- #slab_record["hostname"] = record["hostname"]
- #if not "model" in slab_record:
- #slab_record["model"] = "geni"
-
- #One authority only
- #elif type == "authority":
- #slab_record["login_base"] = hrn_to_slab_login_base(hrn)
-
- #if not "name" in slab_record:
- #slab_record["name"] = hrn
-
- #if not "abbreviated_name" in slab_record:
- #slab_record["abbreviated_name"] = hrn
-
- #if not "enabled" in slab_record:
- #slab_record["enabled"] = True
-
- #if not "is_public" in slab_record:
- #slab_record["is_public"] = True
-
- return slab_record
-
-
- def LaunchExperimentOnOAR(self, slice_dict, added_nodes, slice_user=None):
-
- site_list = []
- nodeid_list =[]
- resource = ""
- reqdict = {}
- slice_name = slice_dict['name']
- try:
- slot = slice_dict['timeslot']
- print>>sys.stderr, "\r\n \r\n \t\tLaunchExperimentOnOAR slot %s " %(slot)
- except KeyError:
- #Running on default parameters
- #XP immediate , 10 mins
- slot = {'date':None,'start_time':None, 'timezone':None,'duration':None }#10 min
-
-
- reqdict['property'] ="network_address in ("
- for node in added_nodes:
- #Get the ID of the node : remove the root auth and put the site in a separate list
- s=node.split(".")
- # NT: it's not clear for me if the nodenames will have the senslab prefix
- # so lets take the last part only, for now.
- lastpart=s[-1]
- #if s[0] == self.root_auth :
- # Again here it's not clear if nodes will be prefixed with <site>_, lets split and tanke the last part for now.
- s=lastpart.split("_")
- nodeid=s[-1]
- reqdict['property'] += "'"+ nodeid +"', "
- nodeid_list.append(nodeid)
- #site_list.append( l[0] )
-
-
- reqdict['property'] = reqdict['property'][0: len( reqdict['property'])-2] +")"
- reqdict['resource'] ="network_address="+ str(len(nodeid_list))
-
- if slot['duration']:
- walltime = slot['duration'].split(":")
- # Fixing the walltime by adding a few delays. First put the walltime in seconds
- # oarAdditionalDelay = 20; additional delay for /bin/sleep command to
- # take in account prologue and epilogue scripts execution
- # int walltimeAdditionalDelay = 120; additional delay
-
- desired_walltime = int(walltime[0])*3600 + int(walltime[1]) * 60 + int(walltime[2])
- total_walltime = desired_walltime + 140 #+2 min 20
- sleep_walltime = desired_walltime + 20 #+20 sec
- print>>sys.stderr, "\r\n \r\n \t\tLaunchExperimentOnOAR desired_walltime %s total_walltime %s sleep_walltime %s " %(desired_walltime,total_walltime,sleep_walltime)
- #Put the walltime back in str form
- #First get the hours
- walltime[0] = str(total_walltime / 3600)
- total_walltime = total_walltime - 3600 * int(walltime[0])
- #Get the remaining minutes
- walltime[1] = str(total_walltime / 60)
- total_walltime = total_walltime - 60 * int(walltime[1])
- #Get the seconds
- walltime[2] = str(total_walltime)
- print>>sys.stderr, "\r\n \r\n \t\tLaunchExperimentOnOAR walltime %s " %(walltime)
-
- reqdict['resource']+= ",walltime=" + str(walltime[0]) + ":" + str(walltime[1]) + ":" + str(walltime[2])
- reqdict['script_path'] = "/bin/sleep " + str(sleep_walltime)
- else:
- reqdict['resource']+= ",walltime=" + str(00) + ":" + str(12) + ":" + str(20) #+2 min 20
- reqdict['script_path'] = "/bin/sleep 620" #+20 sec
- #In case of a scheduled experiment (not immediate)
- #To run an XP immediately, don't specify date and time in RSpec
- #They will be set to None.
- if slot['date'] and slot['start_time']:
- if slot['timezone'] is '' or slot['timezone'] is None:
- #assume it is server timezone
- server_timestamp,server_tz = self.GetTimezone()
- from_zone=tz.gettz(server_tz)
- print>>sys.stderr, "\r\n \r\n \t\tLaunchExperimentOnOAR timezone not specified server_tz %s from_zone %s" %(server_tz,from_zone)
- else:
- #Get zone of the user from the reservation time given in the rspec
- from_zone = tz.gettz(slot['timezone'])
-
- date = str(slot['date']) + " " + str(slot['start_time'])
- user_datetime = datetime.datetime.strptime(date, self.time_format)
- user_datetime = user_datetime.replace(tzinfo = from_zone)
-
- #Convert to UTC zone
- to_zone = tz.tzutc()
- utc_date = user_datetime.astimezone(to_zone)
- #Readable time accpeted by OAR
- reqdict['reservation']= utc_date.strftime(self.time_format)
-
- print>>sys.stderr, "\r\n \r\n \t\tLaunchExperimentOnOAR reqdict['reservation'] %s " %(reqdict['reservation'])
-
- else:
- # Immediate XP
- # reservations are performed in the oar server timebase, so :
- # 1- we get the server time(in UTC tz )/server timezone
- # 2- convert the server UTC time in its timezone
- # 3- add a custom delay to this time
- # 4- convert this time to a readable form and it for the reservation request.
- server_timestamp,server_tz = self.GetTimezone()
- s_tz=tz.gettz(server_tz)
- UTC_zone = tz.gettz("UTC")
- #weird... datetime.fromtimestamp should work since we do from datetime import datetime
- utc_server= datetime.datetime.fromtimestamp(float(server_timestamp)+20,UTC_zone)
- server_localtime=utc_server.astimezone(s_tz)
-
- print>>sys.stderr, "\r\n \r\n \t\tLaunchExperimentOnOAR server_timestamp %s server_tz %s slice_name %s added_nodes %s username %s reqdict %s " %(server_timestamp,server_tz,slice_name,added_nodes,slice_user, reqdict )
- readable_time = server_localtime.strftime(self.time_format)
-
- print >>sys.stderr," \r\n \r\n \t\t\t\tAPRES ParseTimezone readable_time %s timestanp %s " %(readable_time ,server_timestamp)
- reqdict['reservation'] = readable_time
-
-
- reqdict['type'] = "deploy"
- reqdict['directory']= ""
- reqdict['name']= "TestSandrine"
-
-
- # first step : start the OAR job and update the job
- print>>sys.stderr, "\r\n \r\n LaunchExperimentOnOAR reqdict %s \r\n site_list %s" %(reqdict,site_list)
-
- answer = self.oar.POSTRequestToOARRestAPI('POST_job',reqdict,slice_user)
- print>>sys.stderr, "\r\n \r\n LaunchExperimentOnOAR jobid %s " %(answer)
- try:
- jobid = answer['id']
- except KeyError:
- print>>sys.stderr, "\r\n AddSliceTonode Impossible to create job %s " %( answer)
- return
-
- print>>sys.stderr, "\r\n \r\n LaunchExperimentOnOAR jobid %s added_nodes %s slice_user %s" %(jobid,added_nodes,slice_user)
- self.db.update_job( slice_name, jobid ,added_nodes)
-
-
- # second step : configure the experiment
- # we need to store the nodes in a yaml (well...) file like this :
- # [1,56,23,14,45,75] with name /tmp/sfa<jobid>.json
- f=open('/tmp/sfa/'+str(jobid)+'.json','w')
- f.write('[')
- f.write(str(added_nodes[0].strip('node')))
- for node in added_nodes[1:len(added_nodes)] :
- f.write(','+node.strip('node'))
- f.write(']')
- f.close()
-
- # third step : call the senslab-experiment wrapper
- #command= "java -jar target/sfa-1.0-jar-with-dependencies.jar "+str(jobid)+" "+slice_user
- javacmdline="/usr/bin/java"
- jarname="/opt/senslabexperimentwrapper/sfa-1.0-jar-with-dependencies.jar"
- #ret=subprocess.check_output(["/usr/bin/java", "-jar", ", str(jobid), slice_user])
- output = subprocess.Popen([javacmdline, "-jar", jarname, str(jobid), slice_user],stdout=subprocess.PIPE).communicate()[0]
-
- print>>sys.stderr, "\r\n \r\n LaunchExperimentOnOAR wrapper returns %s " %(output)
- return
-
-
- #Delete the jobs and updates the job id in the senslab table
- #to set it to -1
- #Does not clear the node list
- def DeleteSliceFromNodes(self, slice_record):
- # Get user information
-
- self.DeleteJobs(slice_record['oar_job_id'], slice_record['hrn'])
- self.db.update_job(slice_record['hrn'], job_id = -1)
- return
-
-
-
-
-
- def augment_records_with_testbed_info (self, sfa_records):
- return self.fill_record_info (sfa_records)
-
- def fill_record_info(self, records):
- """
- Given a SFA record, fill in the senslab specific and SFA specific
- fields in the record.
- """
-
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info 000000000 fill_record_info %s " %(records)
- if not isinstance(records, list):
- records = [records]
-
- parkour = records
- try:
- for record in parkour:
-
- if str(record['type']) == 'slice':
- #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t \t record %s" %(record)
- #sfatable = SfaTable()
-
- #existing_records_by_id = {}
- #all_records = dbsession.query(RegRecord).all()
- #for rec in all_records:
- #existing_records_by_id[rec.record_id] = rec
- #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t\t existing_records_by_id %s" %(existing_records_by_id[record['record_id']])
-
- #recslice = self.db.find('slice',{'slice_hrn':str(record['hrn'])})
- #recslice = slab_dbsession.query(SliceSenslab).filter_by(slice_hrn = str(record['hrn'])).first()
- recslice = self.GetSlices(slice_filter = str(record['hrn']), filter_type = 'slice_hrn')
- #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t\t HOY HOY reclise %s" %(recslice)
- #if isinstance(recslice,list) and len(recslice) == 1:
- #recslice = recslice[0]
-
- recuser = dbsession.query(RegRecord).filter_by(record_id = recslice['record_id_user']).first()
- #existing_records_by_id[recslice['record_id_user']]
- #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t\t recuser %s" %(recuser)
-
-
- record.update({'PI':[recuser.hrn],
- 'researcher': [recuser.hrn],
- 'name':record['hrn'],
- 'oar_job_id':recslice['oar_job_id'],
- 'node_ids': [],
- 'person_ids':[recslice['record_id_user']],
- 'geni_urn':'', #For client_helper.py compatibility
- 'keys':'', #For client_helper.py compatibility
- 'key_ids':''}) #For client_helper.py compatibility
-
- elif str(record['type']) == 'user':
- #Add the data about slice
- rec = self.GetSlices(slice_filter = record['record_id'], filter_type = 'record_id_user')
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info USEEEEEEEEEERDESU! rec %s \r\n \t rec['record_id_user'] %s " %(rec,rec['record_id_user'])
- #Append record in records list, therfore fetches user and slice info again(one more loop)
- #Will update PIs and researcher for the slice
- recuser = dbsession.query(RegRecord).filter_by(record_id = rec['record_id_user']).first()
- rec.update({'PI':[recuser.hrn],
- 'researcher': [recuser.hrn],
- 'name':record['hrn'],
- 'oar_job_id':rec['oar_job_id'],
- 'node_ids': [],
- 'person_ids':[rec['record_id_user']]})
- #retourne une liste 100512
-
- #GetPersons takes [] as filters
- user_slab = self.GetPersons([{'hrn':recuser.hrn}])
-
-
- rec.update({'type':'slice','hrn':rec['slice_hrn']})
- record.update(user_slab[0])
- #For client_helper.py compatibility
- record.update( { 'geni_urn':'',
- 'keys':'',
- 'key_ids':'' })
- records.append(rec)
-
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info ADDING SLICEINFO TO USER records %s" %(records)
-
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info OKrecords %s" %(records)
- except TypeError:
- print >>sys.stderr, "\r\n \t\t SLABDRIVER fill_record_info EXCEPTION RECORDS : %s" %(records)
- return
-
- #self.fill_record_slab_info(records)
- ##print >>sys.stderr, "\r\n \t\t after fill_record_slab_info %s" %(records)
- #self.fill_record_sfa_info(records)
- #print >>sys.stderr, "\r\n \t\t after fill_record_sfa_info"
-
-
-
-
-
- #def update_membership_list(self, oldRecord, record, listName, addFunc, delFunc):
- ## get a list of the HRNs tht are members of the old and new records
- #if oldRecord:
- #oldList = oldRecord.get(listName, [])
- #else:
- #oldList = []
- #newList = record.get(listName, [])
-
- ## 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(self.plauth, 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(self.plauth, personId, containerId)
-
- #def update_membership(self, oldRecord, record):
- #print >>sys.stderr, " \r\n \r\n ***SLABDRIVER.PY update_membership record ", record
- #if record.type == "slice":
- #self.update_membership_list(oldRecord, record, 'researcher',
- #self.users.AddPersonToSlice,
- #self.users.DeletePersonFromSlice)
- #elif record.type == "authority":
- ## xxx TODO
- #pass
-
-### thierry
-# I don't think you plan on running a component manager at this point
-# let me clean up the mess of ComponentAPI that is deprecated anyways