2ab08a333ae6912366dc27cff8f23ff8a4455c54
[sfa.git] / 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
52
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         
158     def list_slices (self, creds, options):
159         # look in cache first
160         #if self.cache:
161             #slices = self.cache.get('slices')
162             #if slices:
163                 #logger.debug("PlDriver.list_slices returns from cache")
164                 #return slices
165     
166         # get data from db 
167         slices = self.GetSlices({'peer_id': None}, ['name'])
168         slice_hrns = [slicename_to_hrn(self.hrn, slice['name']) for slice in slices]
169         slice_urns = [hrn_to_urn(slice_hrn, 'slice') for slice_hrn in slice_hrns]
170     
171         # cache the result
172         #if self.cache:
173             #logger.debug ("SlabDriver.list_slices stores value in cache")
174             #self.cache.add('slices', slice_urns) 
175     
176         return slice_urns
177     
178     
179     def register (self, sfa_record, hrn, pub_key):
180         type = sfa_record['type']
181         pl_record = self.sfa_fields_to_pl_fields(type, hrn, sfa_record)
182     
183         if type == 'authority':
184             sites = self.shell.GetSites([pl_record['login_base']])
185             if not sites:
186                 pointer = self.shell.AddSite(pl_record)
187             else:
188                 pointer = sites[0]['site_id']
189     
190         elif type == 'slice':
191             acceptable_fields=['url', 'instantiation', 'name', 'description']
192             for key in pl_record.keys():
193                 if key not in acceptable_fields:
194                     pl_record.pop(key)
195             slices = self.shell.GetSlices([pl_record['name']])
196             if not slices:
197                     pointer = self.shell.AddSlice(pl_record)
198             else:
199                     pointer = slices[0]['slice_id']
200     
201         elif type == 'user':
202             persons = self.shell.GetPersons([sfa_record['email']])
203             if not persons:
204                 pointer = self.shell.AddPerson(dict(sfa_record))
205             else:
206                 pointer = persons[0]['person_id']
207     
208             if 'enabled' in sfa_record and sfa_record['enabled']:
209                 self.shell.UpdatePerson(pointer, {'enabled': sfa_record['enabled']})
210             # add this person to the site only if she is being added for the first
211             # time by sfa and doesont already exist in plc
212             if not persons or not persons[0]['site_ids']:
213                 login_base = get_leaf(sfa_record['authority'])
214                 self.shell.AddPersonToSite(pointer, login_base)
215     
216             # What roles should this user have?
217             self.shell.AddRoleToPerson('user', pointer)
218             # Add the user's key
219             if pub_key:
220                 self.shell.AddPersonKey(pointer, {'key_type' : 'ssh', 'key' : pub_key})
221     
222         elif type == 'node':
223             login_base = hrn_to_pl_login_base(sfa_record['authority'])
224             nodes = self.shell.GetNodes([pl_record['hostname']])
225             if not nodes:
226                 pointer = self.shell.AddNode(login_base, pl_record)
227             else:
228                 pointer = nodes[0]['node_id']
229     
230         return pointer
231             
232             
233     def GetPersons(self, person_filter=None, return_fields=None):
234         
235         person_list = self.ldap.ldapFind({'authority': self.root_auth })
236         
237         #check = False
238         #if person_filter and isinstance(person_filter, dict):
239             #for k in  person_filter.keys():
240                 #if k in person_list[0].keys():
241                     #check = True
242                     
243         return_person_list = parse_filter(person_list,person_filter ,'persons', return_fields)
244         if return_person_list:
245             print>>sys.stderr, " \r\n GetPersons person_filter %s return_fields %s return_person_list %s " %(person_filter,return_fields,return_person_list)
246             return return_person_list
247     
248     def GetNodes(self,node_filter= None, return_fields=None):
249                 
250         self.oar.parser.SendRequest("GET_resources_full")
251         node_dict = self.oar.parser.GetNodesFromOARParse()
252         return_node_list = []
253
254         if not (node_filter or return_fields):
255                 return_node_list = node_dict.values()
256                 return return_node_list
257     
258         return_node_list= parse_filter(node_dict.values(),node_filter ,'node', return_fields)
259         return return_node_list
260     
261     def GetSites(self, auth, site_filter = None, return_fields=None):
262         self.oar.parser.SendRequest("GET_resources_full")
263         site_dict = self.oar.parser.GetSitesFromOARParse()
264         return_site_list = []
265         site = site_dict.values()[0]
266         if not (site_filter or return_fields):
267                 return_site_list = site_dict.values()
268                 return return_site_list
269         
270         return_site_list = parse_filter(site_dict.values(),site_filter ,'site', return_fields)
271         return return_site_list
272     
273     def GetSlices(self,slice_filter = None, return_fields=None):
274         
275         return_slice_list =[]
276         sliceslist = self.db.find('slice',columns = ['slice_hrn', 'record_id_slice','record_id_user'])
277         print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY  GetSlices  slices %s" %(sliceslist)
278         #slicesdict = sliceslist[0]
279         if not (slice_filter or return_fields):
280                 return_slice_list = sliceslist
281                 return  return_slice_list
282         
283         return_slice_list  = parse_filter(sliceslist, slice_filter,'slice', return_fields)
284         print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY  GetSlices  return_slice_list %s" %(return_slice_list)
285         return return_slice_list
286     
287     def testbed_name (self): return "senslab2" 
288          
289     # 'geni_request_rspec_versions' and 'geni_ad_rspec_versions' are mandatory
290     def aggregate_version (self):
291         version_manager = VersionManager()
292         ad_rspec_versions = []
293         request_rspec_versions = []
294         for rspec_version in version_manager.versions:
295             if rspec_version.content_type in ['*', 'ad']:
296                 ad_rspec_versions.append(rspec_version.to_dict())
297             if rspec_version.content_type in ['*', 'request']:
298                 request_rspec_versions.append(rspec_version.to_dict()) 
299         return {
300             'testbed':self.testbed_name(),
301             'geni_request_rspec_versions': request_rspec_versions,
302             'geni_ad_rspec_versions': ad_rspec_versions,
303             }
304           
305           
306           
307           
308           
309           
310     ##
311     # Convert SFA fields to PLC fields for use when registering up updating
312     # registry record in the PLC database
313     #
314     # @param type type of record (user, slice, ...)
315     # @param hrn human readable name
316     # @param sfa_fields dictionary of SFA fields
317     # @param pl_fields dictionary of PLC fields (output)
318
319     def sfa_fields_to_pl_fields(self, type, hrn, record):
320
321         def convert_ints(tmpdict, int_fields):
322             for field in int_fields:
323                 if field in tmpdict:
324                     tmpdict[field] = int(tmpdict[field])
325
326         pl_record = {}
327         #for field in record:
328         #    pl_record[field] = record[field]
329  
330         if type == "slice":
331             #instantion used in get_slivers ? 
332             if not "instantiation" in pl_record:
333                 pl_record["instantiation"] = "senslab-instantiated"
334             pl_record["hrn"] = hrn_to_pl_slicename(hrn)
335             if "url" in record:
336                pl_record["url"] = record["url"]
337             if "description" in record:
338                 pl_record["description"] = record["description"]
339             if "expires" in record:
340                 pl_record["expires"] = int(record["expires"])
341                 
342         #nodes added by OAR only and then imported to SFA
343         #elif type == "node":
344             #if not "hostname" in pl_record:
345                 #if not "hostname" in record:
346                     #raise MissingSfaInfo("hostname")
347                 #pl_record["hostname"] = record["hostname"]
348             #if not "model" in pl_record:
349                 #pl_record["model"] = "geni"
350                 
351         #One authority only 
352         #elif type == "authority":
353             #pl_record["login_base"] = hrn_to_pl_login_base(hrn)
354
355             #if not "name" in pl_record:
356                 #pl_record["name"] = hrn
357
358             #if not "abbreviated_name" in pl_record:
359                 #pl_record["abbreviated_name"] = hrn
360
361             #if not "enabled" in pl_record:
362                 #pl_record["enabled"] = True
363
364             #if not "is_public" in pl_record:
365                 #pl_record["is_public"] = True
366
367         return pl_record
368
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  
408
409     def fill_record_sfa_info(self, records):
410
411         def startswith(prefix, values):
412             return [value for value in values if value.startswith(prefix)]
413
414         # get person ids
415         person_ids = []
416         site_ids = []
417         for record in records:
418             person_ids.extend(record.get("person_ids", []))
419             site_ids.extend(record.get("site_ids", [])) 
420             if 'site_id' in record:
421                 site_ids.append(record['site_id']) 
422                 
423         #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)
424         
425         # get all pis from the sites we've encountered
426         # and store them in a dictionary keyed on site_id 
427         site_pis = {}
428         if site_ids:
429             pi_filter = {'|roles': ['pi'], '|site_ids': site_ids} 
430             pi_list = self.GetPersons( pi_filter, ['person_id', 'site_ids'])
431             #print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___ GetPersons ['person_id', 'site_ids'] pi_ilist %s" %(pi_list)
432
433             for pi in pi_list:
434                 # we will need the pi's hrns also
435                 person_ids.append(pi['person_id'])
436                 
437                 # we also need to keep track of the sites these pis
438                 # belong to
439                 for site_id in pi['site_ids']:
440                     if site_id in site_pis:
441                         site_pis[site_id].append(pi)
442                     else:
443                         site_pis[site_id] = [pi]
444                  
445         # get sfa records for all records associated with these records.   
446         # we'll replace pl ids (person_ids) with hrns from the sfa records
447         # we obtain
448         
449         # get the sfa records
450         table = SfaTable()
451         person_list, persons = [], {}
452         person_list = table.find({'type': 'user', 'pointer': person_ids})
453         # create a hrns keyed on the sfa record's pointer.
454         # Its possible for  multiple records to have the same pointer so
455         # the dict's value will be a list of hrns.
456         persons = defaultdict(list)
457         for person in person_list:
458             persons[person['pointer']].append(person)
459
460         # get the pl records
461         pl_person_list, pl_persons = [], {}
462         pl_person_list = self.GetPersons(person_ids, ['person_id', 'roles'])
463         pl_persons = list_to_dict(pl_person_list, 'person_id')
464         #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) 
465         # fill sfa info
466         
467         for record in records:
468             # skip records with no pl info (top level authorities)
469             #Sandrine 24 oct 11 2 lines
470             #if record['pointer'] == -1:
471                 #continue 
472             sfa_info = {}
473             type = record['type']
474             if (type == "slice"):
475                 # all slice users are researchers
476                 #record['geni_urn'] = hrn_to_urn(record['hrn'], 'slice')  ? besoin ou pas ?
477                 record['PI'] = []
478                 record['researcher'] = []
479                 for person_id in record.get('person_ids', []):
480                          #Sandrine 24 oct 11 line
481                 #for person_id in record['person_ids']:
482                     hrns = [person['hrn'] for person in persons[person_id]]
483                     record['researcher'].extend(hrns)                
484
485                 # pis at the slice's site
486                 pl_pis = site_pis[record['site_id']]
487                 pi_ids = [pi['person_id'] for pi in pl_pis]
488                 for person_id in pi_ids:
489                     hrns = [person['hrn'] for person in persons[person_id]]
490                     record['PI'].extend(hrns)
491                 record['geni_urn'] = hrn_to_urn(record['hrn'], 'slice')
492                 record['geni_creator'] = record['PI'] 
493                 
494             elif (type == "authority"):
495                 record['PI'] = []
496                 record['operator'] = []
497                 record['owner'] = []
498                 for pointer in record['person_ids']:
499                     if pointer not in persons or pointer not in pl_persons:
500                         # this means there is not sfa or pl record for this user
501                         continue   
502                     hrns = [person['hrn'] for person in persons[pointer]] 
503                     roles = pl_persons[pointer]['roles']   
504                     if 'pi' in roles:
505                         record['PI'].extend(hrns)
506                     if 'tech' in roles:
507                         record['operator'].extend(hrns)
508                     if 'admin' in roles:
509                         record['owner'].extend(hrns)
510                     # xxx TODO: OrganizationName
511             elif (type == "node"):
512                 sfa_info['dns'] = record.get("hostname", "")
513                 # xxx TODO: URI, LatLong, IP, DNS
514     
515             elif (type == "user"):
516                  sfa_info['email'] = record.get("email", "")
517                  sfa_info['geni_urn'] = hrn_to_urn(record['hrn'], 'user')
518                  sfa_info['geni_certificate'] = record['gid'] 
519                 # xxx TODO: PostalAddress, Phone
520                 
521             #print>>sys.stderr, "\r\n \r\rn \t\t \t <<<<<<<<<<<<<<<<<<<<<<<<  fill_record_sfa_info sfa_info %s  \r\n record %s : "%(sfa_info,record)  
522             record.update(sfa_info)
523             
524     def augment_records_with_testbed_info (self, sfa_records):
525         return self.fill_record_info (sfa_records)
526     
527     def fill_record_info(self, records):
528         """
529         Given a SFA record, fill in the senslab specific and SFA specific
530         fields in the record. 
531         """
532         print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records)        
533         if isinstance(records, list):
534             records = records[0]
535         #print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records)       
536         
537        
538         if records['type'] == 'slice':
539
540             sfatable = SfaTable()
541             recslice = self.db.find('slice',str(records['hrn']))
542             if isinstance(recslice,list) and len(recslice) == 1:
543                 recslice = recslice[0]
544             recuser = sfatable.find(  recslice['record_id_user'], ['hrn'])
545             
546             print >>sys.stderr, "\r\n \t\t  SLABDRIVER.PY fill_record_info %s" %(recuser)
547             records['type']
548             if isinstance(recuser,list) and len(recuser) == 1:
549                 recuser = recuser[0]              
550             records.update({'PI':[recuser['hrn']],
551             'researcher': [recuser['hrn']],
552             'name':records['hrn'], 'oar_job_id':recslice['oar_job_id'],
553             
554             'node_ids': [],
555             'person_ids':[recslice['record_id_user']]})
556
557         #self.fill_record_pl_info(records)
558         ##print >>sys.stderr, "\r\n \t\t after fill_record_pl_info %s" %(records)       
559         #self.fill_record_sfa_info(records)
560         #print >>sys.stderr, "\r\n \t\t after fill_record_sfa_info"
561         
562     #def update_membership_list(self, oldRecord, record, listName, addFunc, delFunc):
563         ## get a list of the HRNs tht are members of the old and new records
564         #if oldRecord:
565             #oldList = oldRecord.get(listName, [])
566         #else:
567             #oldList = []     
568         #newList = record.get(listName, [])
569
570         ## if the lists are the same, then we don't have to update anything
571         #if (oldList == newList):
572             #return
573
574         ## build a list of the new person ids, by looking up each person to get
575         ## their pointer
576         #newIdList = []
577         #table = SfaTable()
578         #records = table.find({'type': 'user', 'hrn': newList})
579         #for rec in records:
580             #newIdList.append(rec['pointer'])
581
582         ## build a list of the old person ids from the person_ids field 
583         #if oldRecord:
584             #oldIdList = oldRecord.get("person_ids", [])
585             #containerId = oldRecord.get_pointer()
586         #else:
587             ## if oldRecord==None, then we are doing a Register, instead of an
588             ## update.
589             #oldIdList = []
590             #containerId = record.get_pointer()
591
592     ## add people who are in the new list, but not the oldList
593         #for personId in newIdList:
594             #if not (personId in oldIdList):
595                 #addFunc(self.plauth, personId, containerId)
596
597         ## remove people who are in the old list, but not the new list
598         #for personId in oldIdList:
599             #if not (personId in newIdList):
600                 #delFunc(self.plauth, personId, containerId)
601
602     #def update_membership(self, oldRecord, record):
603         #print >>sys.stderr, " \r\n \r\n ***SLABDRIVER.PY update_membership record ", record
604         #if record.type == "slice":
605             #self.update_membership_list(oldRecord, record, 'researcher',
606                                         #self.users.AddPersonToSlice,
607                                         #self.users.DeletePersonFromSlice)
608         #elif record.type == "authority":
609             ## xxx TODO
610             #pass
611
612 ### thierry
613 # I don't think you plan on running a component manager at this point
614 # let me clean up the mess of ComponentAPI that is deprecated anyways