sfa/senslab/slabdriver.py

   1 import sys
   2
   3 from sfa.util.faults import MissingSfaInfo
   4 from sfa.util.sfalogging import logger
   5 from sfa.util.table import SfaTable
   6 from sfa.util.defaultdict import defaultdict
   7
   8 from sfa.managers.driver import Driver
   9 from sfa.rspecs.version_manager import VersionManager
  10
  11 from sfa.util.xrn import hrn_to_urn
  12 from sfa.util.plxrn import slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, hrn_to_pl_login_base
  13
  14 ## thierry: everything that is API-related (i.e. handling incoming requests)
  15 # is taken care of
  16 # SlabDriver should be really only about talking to the senslab testbed
  17
  18 ## thierry : please avoid wildcard imports :)
  19 from sfa.senslab.OARrestapi import OARapi, OARrestapi
  20 from sfa.senslab.LDAPapi import LDAPapi
  21 from sfa.senslab.SenslabImportUsers import SenslabImportUsers
  22 from sfa.senslab.parsing import parse_filter
  23 from sfa.senslab.slabpostgres import SlabDB
  24
  25 def list_to_dict(recs, key):
  26     """
  27     convert a list of dictionaries into a dictionary keyed on the
  28     specified dictionary key
  29     """
  30    # print>>sys.stderr, " \r\n \t\t 1list_to_dict : rec %s  \r\n \t\t list_to_dict key %s" %(recs,key)
  31     keys = [rec[key] for rec in recs]
  32     #print>>sys.stderr, " \r\n \t\t list_to_dict : rec %s  \r\n \t\t list_to_dict keys %s" %(recs,keys)
  33     return dict(zip(keys, recs))
  34
  35 # thierry : note
  36 # this inheritance scheme is so that the driver object can receive
  37 # GetNodes or GetSites sorts of calls directly
  38 # and thus minimize the differences in the managers with the pl version
  39 class SlabDriver(Driver):
  40
  41     def __init__(self, config):
  42         Driver.__init__ (self, config)
  43         self.config=config
  44         self.hrn = config.SFA_INTERFACE_HRN
  45
  46         self.root_auth = config.SFA_REGISTRY_ROOT_AUTH
  47
  48
  49         print >>sys.stderr, "\r\n_____________ SFA SENSLAB DRIVER \r\n"
  50         # thierry - just to not break the rest of this code
  51         #self.oar = OARapi()
  52         #self.users = SenslabImportUsers()
  53         self.oar = OARapi()
  54         self.ldap = LDAPapi()
  55         self.users = SenslabImportUsers()
  56         self.time_format = "%Y-%m-%d %H:%M:%S"
  57         self.db = SlabDB()
  58         #self.logger=sfa_logger()
  59         self.cache=None
  60
  61
  62
  63     def create_sliver (self, slice_urn, slice_hrn, creds, rspec_string, users, options):
  64
  65         aggregate = SlabAggregate(self)
  66         slices = SlabSlices(self)
  67         peer = slices.get_peer(slice_hrn)
  68         sfa_peer = slices.get_sfa_peer(slice_hrn)
  69         slice_record=None
  70         if users:
  71             slice_record = users[0].get('slice_record', {})
  72
  73         # parse rspec
  74         rspec = RSpec(rspec_string)
  75         requested_attributes = rspec.version.get_slice_attributes()
  76
  77         # ensure site record exists
  78         site = slices.verify_site(slice_hrn, slice_record, peer, sfa_peer, options=options)
  79         # ensure slice record exists
  80         slice = slices.verify_slice(slice_hrn, slice_record, peer, sfa_peer, options=options)
  81         # ensure person records exists
  82         persons = slices.verify_persons(slice_hrn, slice, users, peer, sfa_peer, options=options)
  83         # ensure slice attributes exists
  84         #slices.verify_slice_attributes(slice, requested_attributes, options=options)
  85
  86         # add/remove slice from nodes
  87         requested_slivers = [node.get('component_name') for node in rspec.version.get_nodes_with_slivers()]
  88         nodes = slices.verify_slice_nodes(slice, requested_slivers, peer)
  89
  90         # add/remove links links
  91         #slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
  92
  93         # handle MyPLC peer association.
  94         # only used by plc and ple.
  95         #slices.handle_peer(site, slice, persons, peer)
  96
  97         return aggregate.get_rspec(slice_xrn=slice_urn, version=rspec.version)
  98
  99
 100     def delete_sliver (self, slice_urn, slice_hrn, creds, options):
 101
 102         slices = self.GetSlices({'slice_hrn': slice_hrn})
 103         if not slices:
 104             return 1
 105         slice = slices[0]
 106
 107         # determine if this is a peer slice
 108         # xxx I wonder if this would not need to use PlSlices.get_peer instead
 109         # in which case plc.peers could be deprecated as this here
 110         # is the only/last call to this last method in plc.peers
 111         peer = peers.get_peer(self, slice_hrn)
 112         try:
 113             if peer:
 114                 self.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
 115             self.DeleteSliceFromNodes(slice_hrn, slice['node_ids'])
 116         finally:
 117             if peer:
 118                 self.BindObjectToPeer('slice', slice['slice_id'], peer, slice['peer_slice_id'])
 119         return 1
 120
 121
 122
 123
 124     # first 2 args are None in case of resource discovery
 125     def list_resources (self, slice_urn, slice_hrn, creds, options):
 126         #cached_requested = options.get('cached', True)
 127
 128         version_manager = VersionManager()
 129         # get the rspec's return format from options
 130         rspec_version = version_manager.get_version(options.get('geni_rspec_version'))
 131         version_string = "rspec_%s" % (rspec_version)
 132
 133         #panos adding the info option to the caching key (can be improved)
 134         if options.get('info'):
 135             version_string = version_string + "_"+options.get('info', 'default')
 136
 137         # look in cache first
 138         #if cached_requested and self.cache and not slice_hrn:
 139             #rspec = self.cache.get(version_string)
 140             #if rspec:
 141                 #logger.debug("SlabDriver.ListResources: returning cached advertisement")
 142                 #return rspec
 143
 144         #panos: passing user-defined options
 145         #print "manager options = ",options
 146         aggregate = SlabAggregate(self)
 147         rspec =  aggregate.get_rspec(slice_xrn=slice_urn, version=rspec_version,
 148                                      options=options)
 149
 150         # cache the result
 151         #if self.cache and not slice_hrn:
 152             #logger.debug("Slab.ListResources: stores advertisement in cache")
 153             #self.cache.add(version_string, rspec)
 154
 155         return rspec
 156
 157     def GetPersons(self, person_filter=None, return_fields=None):
 158
 159         person_list = self.ldap.ldapFind({'authority': self.root_auth })
 160
 161         #check = False
 162         #if person_filter and isinstance(person_filter, dict):
 163             #for k in  person_filter.keys():
 164                 #if k in person_list[0].keys():
 165                     #check = True
 166
 167         return_person_list = parse_filter(person_list,person_filter ,'persons', return_fields)
 168         if return_person_list:
 169             print>>sys.stderr, " \r\n GetPersons person_filter %s return_fields %s return_person_list %s " %(person_filter,return_fields,return_person_list)
 170             return return_person_list
 171
 172     def GetNodes(self,node_filter= None, return_fields=None):
 173
 174         self.oar.parser.SendRequest("GET_resources_full")
 175         node_dict = self.oar.parser.GetNodesFromOARParse()
 176         return_node_list = []
 177
 178         if not (node_filter or return_fields):
 179                 return_node_list = node_dict.values()
 180                 return return_node_list
 181
 182         return_node_list= parse_filter(node_dict.values(),node_filter ,'node', return_fields)
 183         return return_node_list
 184
 185     def GetSites(self, auth, site_filter = None, return_fields=None):
 186         self.oar.parser.SendRequest("GET_resources_full")
 187         site_dict = self.oar.parser.GetSitesFromOARParse()
 188         return_site_list = []
 189         site = site_dict.values()[0]
 190         if not (site_filter or return_fields):
 191                 return_site_list = site_dict.values()
 192                 return return_site_list
 193
 194         return_site_list = parse_filter(site_dict.values(),site_filter ,'site', return_fields)
 195         return return_site_list
 196
 197     def GetSlices(self,slice_filter = None, return_fields=None):
 198
 199         return_slice_list =[]
 200         sliceslist = self.db.find('slice',columns = ['slice_hrn', 'record_id_slice','record_id_user'])
 201         print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY  GetSlices  slices %s" %(sliceslist)
 202         #slicesdict = sliceslist[0]
 203         if not (slice_filter or return_fields):
 204                 return_slice_list = sliceslist
 205                 return  return_slice_list
 206
 207         return_slice_list  = parse_filter(sliceslist, slice_filter,'slice', return_fields)
 208         print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY  GetSlices  return_slice_list %s" %(return_slice_list)
 209         return return_slice_list
 210
 211     def testbed_name (self): return "senslab2"
 212
 213     # 'geni_request_rspec_versions' and 'geni_ad_rspec_versions' are mandatory
 214     def aggregate_version (self):
 215         version_manager = VersionManager()
 216         ad_rspec_versions = []
 217         request_rspec_versions = []
 218         for rspec_version in version_manager.versions:
 219             if rspec_version.content_type in ['*', 'ad']:
 220                 ad_rspec_versions.append(rspec_version.to_dict())
 221             if rspec_version.content_type in ['*', 'request']:
 222                 request_rspec_versions.append(rspec_version.to_dict())
 223         return {
 224             'testbed':self.testbed_name(),
 225             'geni_request_rspec_versions': request_rspec_versions,
 226             'geni_ad_rspec_versions': ad_rspec_versions,
 227             }
 228
 229
 230
 231
 232
 233
 234     ##
 235     # Convert SFA fields to PLC fields for use when registering up updating
 236     # registry record in the PLC database
 237     #
 238     # @param type type of record (user, slice, ...)
 239     # @param hrn human readable name
 240     # @param sfa_fields dictionary of SFA fields
 241     # @param pl_fields dictionary of PLC fields (output)
 242
 243     def sfa_fields_to_pl_fields(self, type, hrn, record):
 244
 245         def convert_ints(tmpdict, int_fields):
 246             for field in int_fields:
 247                 if field in tmpdict:
 248                     tmpdict[field] = int(tmpdict[field])
 249
 250         pl_record = {}
 251         #for field in record:
 252         #    pl_record[field] = record[field]
 253
 254         if type == "slice":
 255             if not "instantiation" in pl_record:
 256                 pl_record["instantiation"] = "plc-instantiated"
 257             pl_record["name"] = hrn_to_pl_slicename(hrn)
 258             if "url" in record:
 259                pl_record["url"] = record["url"]
 260             if "description" in record:
 261                 pl_record["description"] = record["description"]
 262             if "expires" in record:
 263                 pl_record["expires"] = int(record["expires"])
 264
 265         elif type == "node":
 266             if not "hostname" in pl_record:
 267                 if not "hostname" in record:
 268                     raise MissingSfaInfo("hostname")
 269                 pl_record["hostname"] = record["hostname"]
 270             if not "model" in pl_record:
 271                 pl_record["model"] = "geni"
 272
 273         elif type == "authority":
 274             pl_record["login_base"] = hrn_to_pl_login_base(hrn)
 275
 276             if not "name" in pl_record:
 277                 pl_record["name"] = hrn
 278
 279             if not "abbreviated_name" in pl_record:
 280                 pl_record["abbreviated_name"] = hrn
 281
 282             if not "enabled" in pl_record:
 283                 pl_record["enabled"] = True
 284
 285             if not "is_public" in pl_record:
 286                 pl_record["is_public"] = True
 287
 288         return pl_record
 289
 290     def fill_record_pl_info(self, records):
 291         """
 292         Fill in the planetlab specific fields of a SFA record. This
 293         involves calling the appropriate PLC method to retrieve the
 294         database record for the object.
 295
 296         PLC data is filled into the pl_info field of the record.
 297
 298         @param record: record to fill in field (in/out param)
 299         """
 300         # get ids by type
 301         #print>>sys.stderr, "\r\n \r\rn \t\t >>>>>>>>>>fill_record_pl_info  records %s : "%(records)
 302         node_ids, site_ids, slice_ids = [], [], []
 303         person_ids, key_ids = [], []
 304         type_map = {'node': node_ids, 'authority': site_ids,
 305                     'slice': slice_ids, 'user': person_ids}
 306
 307         for record in records:
 308             for type in type_map:
 309                 #print>>sys.stderr, "\r\n \t\t \t fill_record_pl_info : type %s. record['pointer'] %s "%(type,record['pointer'])
 310                 if type == record['type']:
 311                     type_map[type].append(record['pointer'])
 312         #print>>sys.stderr, "\r\n \t\t \t fill_record_pl_info : records %s... \r\n \t\t \t fill_record_pl_info : type_map   %s"%(records,type_map)
 313         # get pl records
 314         nodes, sites, slices, persons, keys = {}, {}, {}, {}, {}
 315         if node_ids:
 316             node_list = self.GetNodes( node_ids)
 317             #print>>sys.stderr, " \r\n \t\t\t BEFORE LIST_TO_DICT_NODES node_ids : %s" %(node_ids)
 318             nodes = list_to_dict(node_list, 'node_id')
 319         if site_ids:
 320             site_list = self.oar.GetSites( site_ids)
 321             sites = list_to_dict(site_list, 'site_id')
 322             #print>>sys.stderr, " \r\n \t\t\t  site_ids %s sites  : %s" %(site_ids,sites)
 323         if slice_ids:
 324             slice_list = self.users.GetSlices( slice_ids)
 325             slices = list_to_dict(slice_list, 'slice_id')
 326         if person_ids:
 327             #print>>sys.stderr, " \r\n \t\t \t fill_record_pl_info BEFORE GetPersons  person_ids: %s" %(person_ids)
 328             person_list = self.GetPersons( person_ids)
 329             persons = list_to_dict(person_list, 'person_id')
 330             #print>>sys.stderr, "\r\n  fill_record_pl_info persons %s \r\n \t\t person_ids %s " %(persons, person_ids)
 331             for person in persons:
 332                 key_ids.extend(persons[person]['key_ids'])
 333                 #print>>sys.stderr, "\r\n key_ids %s " %(key_ids)
 334
 335         pl_records = {'node': nodes, 'authority': sites,
 336                       'slice': slices, 'user': persons}
 337
 338         if key_ids:
 339             key_list = self.users.GetKeys( key_ids)
 340             keys = list_to_dict(key_list, 'key_id')
 341            # print>>sys.stderr, "\r\n  fill_record_pl_info persons %s \r\n \t\t keys %s " %(keys)
 342         # fill record info
 343         for record in records:
 344             # records with pointer==-1 do not have plc info.
 345             # for example, the top level authority records which are
 346             # authorities, but not PL "sites"
 347             if record['pointer'] == -1:
 348                 continue
 349
 350             for type in pl_records:
 351                 if record['type'] == type:
 352                     if record['pointer'] in pl_records[type]:
 353                         record.update(pl_records[type][record['pointer']])
 354                         break
 355             # fill in key info
 356             if record['type'] == 'user':
 357                  if 'key_ids' not in record:
 358                         #print>>sys.stderr, " NO_KEY_IDS fill_record_pl_info key_ids record: %s" %(record)
 359                         logger.info("user record has no 'key_ids' - need to import  ?")
 360                  else:
 361                         pubkeys = [keys[key_id]['key'] for key_id in record['key_ids'] if key_id in keys]
 362                         record['keys'] = pubkeys
 363
 364         #print>>sys.stderr, "\r\n \r\rn \t\t <<<<<<<<<<<<<<<<<< fill_record_pl_info  records %s : "%(records)
 365         # fill in record hrns
 366         records = self.fill_record_hrns(records)
 367
 368         return records
 369
 370
 371
 372     def AddSliceToNodes(self,  slice_name, added_nodes, slice_user=None):
 373         print>>sys.stderr, "\r\n \r\n AddSliceToNodes  slice_name %s added_nodes %s username %s" %(slice_name,added_nodes,slice_user )
 374         site_list = []
 375         nodeid_list =[]
 376         resource = ""
 377         reqdict = {}
 378         reqdict['property'] ="network_address in ("
 379         for node in added_nodes:
 380             #Get the ID of the node : remove the root auth and put the site in a separate list
 381             tmp = node.strip(self.root_auth+".")
 382             l = tmp.split("_")
 383
 384             nodeid= (l[len(l)-1])
 385             reqdict['property'] += "'"+ nodeid +"', "
 386             nodeid_list.append(nodeid)
 387             site_list.append( l[0] )
 388
 389         reqdict['property'] =  reqdict['property'][0: len( reqdict['property'])-2] +")"
 390         reqdict['resource'] ="network_address="+ str(len(nodeid_list))
 391         reqdict['resource']+= ",walltime=" + str(00) + ":" + str(05) + ":" + str(00)
 392         reqdict['script_path'] = "/bin/sleep "
 393
 394         print>>sys.stderr, "\r\n \r\n AddSliceToNodes reqdict   %s \r\n site_list   %s"  %(reqdict,site_list)
 395         #OAR = OARrestapi()
 396         #answer = OAR.POSTRequestToOARRestAPI('POST_job',reqdict,slice_user)
 397         #print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid   %s "  %(answer)
 398         #self.db.update('slice',['oar_job_id'], [answer['id']], 'slice_hrn', slice_name)
 399         return
 400
 401
 402
 403
 404     def DeleteSliceFromNodes(self, slice_name, deleted_nodes):
 405         return
 406
 407     def fill_record_hrns(self, records):
 408         """
 409         convert pl ids to hrns
 410         """
 411         #print>>sys.stderr, "\r\n \r\rn \t\t \t >>>>>>>>>>>>>>>>>>>>>> fill_record_hrns records %s : "%(records)
 412         # get ids
 413         slice_ids, person_ids, site_ids, node_ids = [], [], [], []
 414         for record in records:
 415             #print>>sys.stderr, "\r\n \r\rn \t\t \t record %s : "%(record)
 416             if 'site_id' in record:
 417                 site_ids.append(record['site_id'])
 418             if 'site_ids' in records:
 419                 site_ids.extend(record['site_ids'])
 420             if 'person_ids' in record:
 421                 person_ids.extend(record['person_ids'])
 422             if 'slice_ids' in record:
 423                 slice_ids.extend(record['slice_ids'])
 424             if 'node_ids' in record:
 425                 node_ids.extend(record['node_ids'])
 426
 427         # get pl records
 428         slices, persons, sites, nodes = {}, {}, {}, {}
 429         if site_ids:
 430             site_list = self.oar.GetSites( site_ids, ['site_id', 'login_base'])
 431             sites = list_to_dict(site_list, 'site_id')
 432             #print>>sys.stderr, " \r\n \r\n \t\t ____ site_list %s \r\n \t\t____ sites %s " % (site_list,sites)
 433         if person_ids:
 434             person_list = self.GetPersons( person_ids, ['person_id', 'email'])
 435             #print>>sys.stderr, " \r\n \r\n   \t\t____ person_lists %s " %(person_list)
 436             persons = list_to_dict(person_list, 'person_id')
 437         if slice_ids:
 438             slice_list = self.users.GetSlices( slice_ids, ['slice_id', 'name'])
 439             slices = list_to_dict(slice_list, 'slice_id')
 440         if node_ids:
 441             node_list = self.GetNodes( node_ids, ['node_id', 'hostname'])
 442             nodes = list_to_dict(node_list, 'node_id')
 443
 444         # convert ids to hrns
 445         for record in records:
 446
 447             # get all relevant data
 448             type = record['type']
 449             pointer = record['pointer']
 450             auth_hrn = self.hrn
 451             login_base = ''
 452             if pointer == -1:
 453                 continue
 454
 455             #print>>sys.stderr, " \r\n \r\n \t\t fill_record_hrns : sites %s \r\n \t\t record %s " %(sites, record)
 456             if 'site_id' in record:
 457                 site = sites[record['site_id']]
 458                 #print>>sys.stderr, " \r\n \r\n \t\t \t fill_record_hrns : sites %s \r\n \t\t\t site sites[record['site_id']] %s " %(sites,site)
 459                 login_base = site['login_base']
 460                 record['site'] = ".".join([auth_hrn, login_base])
 461             if 'person_ids' in record:
 462                 emails = [persons[person_id]['email'] for person_id in record['person_ids'] \
 463                           if person_id in  persons]
 464                 usernames = [email.split('@')[0] for email in emails]
 465                 person_hrns = [".".join([auth_hrn, login_base, username]) for username in usernames]
 466                 #print>>sys.stderr, " \r\n \r\n \t\t ____ person_hrns : %s " %(person_hrns)
 467                 record['persons'] = person_hrns
 468             if 'slice_ids' in record:
 469                 slicenames = [slices[slice_id]['name'] for slice_id in record['slice_ids'] \
 470                               if slice_id in slices]
 471                 slice_hrns = [slicename_to_hrn(auth_hrn, slicename) for slicename in slicenames]
 472                 record['slices'] = slice_hrns
 473             if 'node_ids' in record:
 474                 hostnames = [nodes[node_id]['hostname'] for node_id in record['node_ids'] \
 475                              if node_id in nodes]
 476                 node_hrns = [hostname_to_hrn(auth_hrn, login_base, hostname) for hostname in hostnames]
 477                 record['nodes'] = node_hrns
 478             if 'site_ids' in record:
 479                 login_bases = [sites[site_id]['login_base'] for site_id in record['site_ids'] \
 480                                if site_id in sites]
 481                 site_hrns = [".".join([auth_hrn, lbase]) for lbase in login_bases]
 482                 record['sites'] = site_hrns
 483         #print>>sys.stderr, "\r\n \r\rn \t\t \t <<<<<<<<<<<<<<<<<<<<<<<<  fill_record_hrns records %s : "%(records)
 484         return records
 485
 486     def fill_record_sfa_info(self, records):
 487
 488         def startswith(prefix, values):
 489             return [value for value in values if value.startswith(prefix)]
 490
 491         # get person ids
 492         person_ids = []
 493         site_ids = []
 494         for record in records:
 495             person_ids.extend(record.get("person_ids", []))
 496             site_ids.extend(record.get("site_ids", []))
 497             if 'site_id' in record:
 498                 site_ids.append(record['site_id'])
 499
 500         #print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___person_ids %s \r\n \t\t site_ids %s " %(person_ids, site_ids)
 501
 502         # get all pis from the sites we've encountered
 503         # and store them in a dictionary keyed on site_id
 504         site_pis = {}
 505         if site_ids:
 506             pi_filter = {'|roles': ['pi'], '|site_ids': site_ids}
 507             pi_list = self.GetPersons( pi_filter, ['person_id', 'site_ids'])
 508             #print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___ GetPersons ['person_id', 'site_ids'] pi_ilist %s" %(pi_list)
 509
 510             for pi in pi_list:
 511                 # we will need the pi's hrns also
 512                 person_ids.append(pi['person_id'])
 513
 514                 # we also need to keep track of the sites these pis
 515                 # belong to
 516                 for site_id in pi['site_ids']:
 517                     if site_id in site_pis:
 518                         site_pis[site_id].append(pi)
 519                     else:
 520                         site_pis[site_id] = [pi]
 521
 522         # get sfa records for all records associated with these records.
 523         # we'll replace pl ids (person_ids) with hrns from the sfa records
 524         # we obtain
 525
 526         # get the sfa records
 527         table = SfaTable()
 528         person_list, persons = [], {}
 529         person_list = table.find({'type': 'user', 'pointer': person_ids})
 530         # create a hrns keyed on the sfa record's pointer.
 531         # Its possible for  multiple records to have the same pointer so
 532         # the dict's value will be a list of hrns.
 533         persons = defaultdict(list)
 534         for person in person_list:
 535             persons[person['pointer']].append(person)
 536
 537         # get the pl records
 538         pl_person_list, pl_persons = [], {}
 539         pl_person_list = self.GetPersons(person_ids, ['person_id', 'roles'])
 540         pl_persons = list_to_dict(pl_person_list, 'person_id')
 541         #print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___  _list %s \r\n \t\t SenslabUsers.GetPersons ['person_id', 'roles'] pl_persons %s \r\n records %s" %(pl_person_list, pl_persons,records)
 542         # fill sfa info
 543
 544         for record in records:
 545             # skip records with no pl info (top level authorities)
 546             #Sandrine 24 oct 11 2 lines
 547             #if record['pointer'] == -1:
 548                 #continue
 549             sfa_info = {}
 550             type = record['type']
 551             if (type == "slice"):
 552                 # all slice users are researchers
 553                 #record['geni_urn'] = hrn_to_urn(record['hrn'], 'slice')  ? besoin ou pas ?
 554                 record['PI'] = []
 555                 record['researcher'] = []
 556                 for person_id in record.get('person_ids', []):
 557                          #Sandrine 24 oct 11 line
 558                 #for person_id in record['person_ids']:
 559                     hrns = [person['hrn'] for person in persons[person_id]]
 560                     record['researcher'].extend(hrns)
 561
 562                 # pis at the slice's site
 563                 pl_pis = site_pis[record['site_id']]
 564                 pi_ids = [pi['person_id'] for pi in pl_pis]
 565                 for person_id in pi_ids:
 566                     hrns = [person['hrn'] for person in persons[person_id]]
 567                     record['PI'].extend(hrns)
 568                 record['geni_urn'] = hrn_to_urn(record['hrn'], 'slice')
 569                 record['geni_creator'] = record['PI']
 570
 571             elif (type == "authority"):
 572                 record['PI'] = []
 573                 record['operator'] = []
 574                 record['owner'] = []
 575                 for pointer in record['person_ids']:
 576                     if pointer not in persons or pointer not in pl_persons:
 577                         # this means there is not sfa or pl record for this user
 578                         continue
 579                     hrns = [person['hrn'] for person in persons[pointer]]
 580                     roles = pl_persons[pointer]['roles']
 581                     if 'pi' in roles:
 582                         record['PI'].extend(hrns)
 583                     if 'tech' in roles:
 584                         record['operator'].extend(hrns)
 585                     if 'admin' in roles:
 586                         record['owner'].extend(hrns)
 587                     # xxx TODO: OrganizationName
 588             elif (type == "node"):
 589                 sfa_info['dns'] = record.get("hostname", "")
 590                 # xxx TODO: URI, LatLong, IP, DNS
 591
 592             elif (type == "user"):
 593                  sfa_info['email'] = record.get("email", "")
 594                  sfa_info['geni_urn'] = hrn_to_urn(record['hrn'], 'user')
 595                  sfa_info['geni_certificate'] = record['gid']
 596                 # xxx TODO: PostalAddress, Phone
 597
 598             #print>>sys.stderr, "\r\n \r\rn \t\t \t <<<<<<<<<<<<<<<<<<<<<<<<  fill_record_sfa_info sfa_info %s  \r\n record %s : "%(sfa_info,record)
 599             record.update(sfa_info)
 600
 601     def augment_records_with_testbed_info (self, sfa_records):
 602         return self.fill_record_info (sfa_records)
 603
 604     def fill_record_info(self, records):
 605         """
 606         Given a SFA record, fill in the senslab specific and SFA specific
 607         fields in the record.
 608         """
 609         print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records)
 610         if isinstance(records, list):
 611             records = records[0]
 612         #print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records)
 613
 614
 615         if records['type'] == 'slice':
 616
 617             sfatable = SfaTable()
 618             recslice = self.db.find('slice',str(records['hrn']))
 619             if isinstance(recslice,list) and len(recslice) == 1:
 620                 recslice = recslice[0]
 621             recuser = sfatable.find(  recslice['record_id_user'], ['hrn'])
 622
 623             print >>sys.stderr, "\r\n \t\t  SLABDRIVER.PY fill_record_info %s" %(recuser)
 624             records['type']
 625             if isinstance(recuser,list) and len(recuser) == 1:
 626                 recuser = recuser[0]
 627             records.update({'PI':[recuser['hrn']],
 628             'researcher': [recuser['hrn']],
 629             'name':records['hrn'], 'oar_job_id':recslice['oar_job_id'],
 630
 631             'node_ids': [],
 632             'person_ids':[recslice['record_id_user']]})
 633
 634         #self.fill_record_pl_info(records)
 635         ##print >>sys.stderr, "\r\n \t\t after fill_record_pl_info %s" %(records)
 636         #self.fill_record_sfa_info(records)
 637         #print >>sys.stderr, "\r\n \t\t after fill_record_sfa_info"
 638
 639     def update_membership_list(self, oldRecord, record, listName, addFunc, delFunc):
 640         # get a list of the HRNs tht are members of the old and new records
 641         if oldRecord:
 642             oldList = oldRecord.get(listName, [])
 643         else:
 644             oldList = []
 645         newList = record.get(listName, [])
 646
 647         # if the lists are the same, then we don't have to update anything
 648         if (oldList == newList):
 649             return
 650
 651         # build a list of the new person ids, by looking up each person to get
 652         # their pointer
 653         newIdList = []
 654         table = SfaTable()
 655         records = table.find({'type': 'user', 'hrn': newList})
 656         for rec in records:
 657             newIdList.append(rec['pointer'])
 658
 659         # build a list of the old person ids from the person_ids field
 660         if oldRecord:
 661             oldIdList = oldRecord.get("person_ids", [])
 662             containerId = oldRecord.get_pointer()
 663         else:
 664             # if oldRecord==None, then we are doing a Register, instead of an
 665             # update.
 666             oldIdList = []
 667             containerId = record.get_pointer()
 668
 669     # add people who are in the new list, but not the oldList
 670         for personId in newIdList:
 671             if not (personId in oldIdList):
 672                 addFunc(self.plauth, personId, containerId)
 673
 674         # remove people who are in the old list, but not the new list
 675         for personId in oldIdList:
 676             if not (personId in newIdList):
 677                 delFunc(self.plauth, personId, containerId)
 678
 679     def update_membership(self, oldRecord, record):
 680         print >>sys.stderr, " \r\n \r\n ***SLABDRIVER.PY update_membership record ", record
 681         if record.type == "slice":
 682             self.update_membership_list(oldRecord, record, 'researcher',
 683                                         self.users.AddPersonToSlice,
 684                                         self.users.DeletePersonFromSlice)
 685         elif record.type == "authority":
 686             # xxx TODO
 687             pass
 688
 689 ### thierry
 690 # I don't think you plan on running a component manager at this point
 691 # let me clean up the mess of ComponentAPI that is deprecated anyways