53f12563845251ad25ff97d886e29aa2e5ce34c6
[sfa.git] / sfa / planetlab / pldriver.py
1 import datetime
2 #
3 from sfa.util.faults import MissingSfaInfo, UnknownSfaType, \
4     RecordNotFound, SfaNotImplemented, SliverDoesNotExist, SearchFailed, \
5     UnsupportedOperation, Forbidden 
6 from sfa.util.sfalogging import logger
7 from sfa.util.defaultdict import defaultdict
8 from sfa.util.sfatime import utcparse, datetime_to_string, datetime_to_epoch
9 from sfa.util.xrn import Xrn, hrn_to_urn, get_leaf
10 from sfa.util.cache import Cache
11
12 # one would think the driver should not need to mess with the SFA db, but..
13 from sfa.storage.model import RegRecord, SliverAllocation
14 from sfa.trust.credential import Credential
15
16 # used to be used in get_ticket
17 #from sfa.trust.sfaticket import SfaTicket
18 from sfa.rspecs.version_manager import VersionManager
19 from sfa.rspecs.rspec import RSpec
20
21 # the driver interface, mostly provides default behaviours
22 from sfa.managers.driver import Driver
23 from sfa.planetlab.plshell import PlShell
24 from sfa.planetlab.plaggregate import PlAggregate
25 from sfa.planetlab.plslices import PlSlices
26 from sfa.planetlab.plxrn import PlXrn, slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, xrn_to_hostname, top_auth, hash_loginbase
27
28
29 def list_to_dict(recs, key):
30     """
31     convert a list of dictionaries into a dictionary keyed on the 
32     specified dictionary key 
33     """
34     return dict ( [ (rec[key],rec) for rec in recs ] )
35
36 #
37 # PlShell is just an xmlrpc serverproxy where methods
38 # can be sent as-is; it takes care of authentication
39 # from the global config
40
41 class PlDriver (Driver):
42
43     # the cache instance is a class member so it survives across incoming requests
44     cache = None
45
46     def __init__ (self, api):
47         Driver.__init__ (self, api)
48         config=api.config
49         self.shell = PlShell (config)
50         self.cache=None
51         if config.SFA_AGGREGATE_CACHING:
52             if PlDriver.cache is None:
53                 PlDriver.cache = Cache()
54             self.cache = PlDriver.cache
55
56     def sliver_to_slice_xrn(self, xrn):
57         sliver_id_parts = Xrn(xrn).get_sliver_id_parts()
58         filter = {'peer_id': None}
59         try:
60             filter['slice_id'] = int(sliver_id_parts[0])
61         except ValueError:
62             filter['name'] = sliver_id_parts[0] 
63         slices = self.shell.GetSlices(filter,['hrn'])
64         if not slices:
65             raise Forbidden("Unable to locate slice record for sliver:  %s" % xrn)
66         slice = slices[0]
67         slice_xrn = slice['hrn']
68         return slice_xrn 
69  
70     def check_sliver_credentials(self, creds, urns):
71         # build list of cred object hrns
72         slice_cred_names = []
73         for cred in creds:
74             slice_cred_hrn = Credential(cred=cred).get_gid_object().get_hrn() 
75             top_auth_hrn = top_auth(slice_cred_hrn)
76             site_hrn = '.'.join(slice_cred_hrn.split('.')[:-1])
77             slice_part = slice_cred_hrn.split('.')[-1]
78             if top_auth_hrn == self.hrn:
79                 login_base = slice_cred_hrn.split('.')[-2][:12]
80             else:
81                 login_base = hash_loginbase(site_hrn)
82
83             slicename = '_'.join([login_base, slice_part])   
84             slice_cred_names.append(slicename) 
85
86         # look up slice name of slivers listed in urns arg
87         slice_ids = []
88         for urn in urns:
89             sliver_id_parts = Xrn(xrn=urn).get_sliver_id_parts()
90             try:
91                 slice_ids.append(int(sliver_id_parts[0]))
92             except ValueError: 
93                 pass
94
95         if not slice_ids:
96              raise Forbidden("sliver urn not provided")
97
98         slices = self.shell.GetSlices(slice_ids)
99         sliver_names = [slice['name'] for slice in slices]
100
101         # make sure we have a credential for every specified sliver ierd
102         for sliver_name in sliver_names:
103             if sliver_name not in slice_cred_names:
104                 msg = "Valid credential not found for target: %s" % sliver_name
105                 raise Forbidden(msg)
106
107     ########################################
108     ########## registry oriented
109     ########################################
110
111     def augment_records_with_testbed_info (self, sfa_records):
112         return self.fill_record_info (sfa_records)
113
114     ########## 
115     def register (self, sfa_record, hrn, pub_key):
116         type = sfa_record['type']
117         pl_record = self.sfa_fields_to_pl_fields(type, hrn, sfa_record)
118
119         if type == 'authority':
120             sites = self.shell.GetSites({'peer_id': None, 'login_base': pl_record['login_base']})
121             if not sites:
122                 # xxx when a site gets registered through SFA we need to set its max_slices
123                 if 'max_slices' not in pl_record:
124                     pl_record['max_slices']=2
125                 pointer = self.shell.AddSite(pl_record)
126                 self.shell.SetSiteHrn(int(pointer), hrn)
127             else:
128                 pointer = sites[0]['site_id']
129
130         elif type == 'slice':
131             acceptable_fields=['url', 'instantiation', 'name', 'description']
132             for key in pl_record.keys():
133                 if key not in acceptable_fields:
134                     pl_record.pop(key)
135             slices = self.shell.GetSlices({'peer_id': None, 'name': pl_record['name']})
136             if not slices:
137                  if not pl_record.get('url', None) or not pl_record.get('description', None):
138                      pl_record['url'] = hrn
139                      pl_record['description'] = hrn
140
141                  pointer = self.shell.AddSlice(pl_record)
142                  self.shell.SetSliceHrn(int(pointer), hrn)
143             else:
144                  pointer = slices[0]['slice_id']
145
146         elif type == 'user':
147             persons = self.shell.GetPersons({'peer_id': None, 'email': sfa_record['email']})
148             if not persons:
149                 for key in ['first_name','last_name']:
150                     if key not in sfa_record: sfa_record[key]='*from*sfa*'
151                 # AddPerson does not allow everything to be set
152                 can_add = ['first_name', 'last_name', 'title','email', 'password', 'phone', 'url', 'bio']
153                 add_person_dict=dict ( [ (k,sfa_record[k]) for k in sfa_record if k in can_add ] )
154                 pointer = self.shell.AddPerson(add_person_dict)
155                 self.shell.SetPersonHrn(int(pointer), hrn)
156             else:
157                 pointer = persons[0]['person_id']
158     
159             # enable the person's account
160             self.shell.UpdatePerson(pointer, {'enabled': True})
161             # add this person to the site
162             login_base = get_leaf(sfa_record['authority'])
163             self.shell.AddPersonToSite(pointer, login_base)
164     
165             # What roles should this user have?
166             roles=[]
167             if 'roles' in sfa_record: 
168                 # if specified in xml, but only low-level roles
169                 roles = [ role for role in sfa_record['roles'] if role in ['user','tech'] ]
170             # at least user if no other cluse could be found
171             if not roles:
172                 roles=['user']
173             for role in roles:
174                 self.shell.AddRoleToPerson(role, pointer)
175             # Add the user's key
176             if pub_key:
177                 self.shell.AddPersonKey(pointer, {'key_type' : 'ssh', 'key' : pub_key})
178
179         elif type == 'node':
180             login_base = PlXrn(xrn=sfa_record['authority'],type='authority').pl_login_base()
181             nodes = self.shell.GetNodes({'peer_id': None, 'hostname': pl_record['hostname']})
182             if not nodes:
183                 pointer = self.shell.AddNode(login_base, pl_record)
184                 self.shell.SetNodeHrn(int(pointer), hrn)
185             else:
186                 pointer = nodes[0]['node_id']
187     
188         return pointer
189         
190     ##########
191     # xxx actually old_sfa_record comes filled with plc stuff as well in the original code
192     def update (self, old_sfa_record, new_sfa_record, hrn, new_key):
193         pointer = old_sfa_record['pointer']
194         type = old_sfa_record['type']
195         new_key_pointer = None
196
197         # new_key implemented for users only
198         if new_key and type not in [ 'user' ]:
199             raise UnknownSfaType(type)
200
201         if (type == "authority"):
202             self.shell.UpdateSite(pointer, new_sfa_record)
203             self.shell.SetSiteHrn(pointer, hrn)
204     
205         elif type == "slice":
206             pl_record=self.sfa_fields_to_pl_fields(type, hrn, new_sfa_record)
207             if 'name' in pl_record:
208                 pl_record.pop('name')
209                 self.shell.UpdateSlice(pointer, pl_record)
210                 self.shell.SetSliceHrn(pointer, hrn)
211     
212         elif type == "user":
213             # SMBAKER: UpdatePerson only allows a limited set of fields to be
214             #    updated. Ideally we should have a more generic way of doing
215             #    this. I copied the field names from UpdatePerson.py...
216             update_fields = {}
217             all_fields = new_sfa_record
218             for key in all_fields.keys():
219                 if key in ['first_name', 'last_name', 'title', 'email',
220                            'password', 'phone', 'url', 'bio', 'accepted_aup',
221                            'enabled']:
222                     update_fields[key] = all_fields[key]
223             # when updating a user, we always get a 'email' field at this point
224             # this is because 'email' is a native field in the RegUser object...
225             if 'email' in update_fields and not update_fields['email']:
226                 del update_fields['email']
227             self.shell.UpdatePerson(pointer, update_fields)
228             self.shell.SetPersonHrn(pointer, hrn)
229     
230             if new_key:
231                 # must check this key against the previous one if it exists
232                 persons = self.shell.GetPersons({'peer_id': None, 'person_id': pointer}, ['key_ids'])
233                 person = persons[0]
234                 keys = person['key_ids']
235                 keys = self.shell.GetKeys(person['key_ids'])
236                 
237                 key_exists = False
238                 for key in keys:
239                     if new_key == key['key']:
240                         key_exists = True
241                         new_key_pointer = key['key_id']
242                         break
243                 if not key_exists:
244                     new_key_pointer = self.shell.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key})
245     
246         elif type == "node":
247             self.shell.UpdateNode(pointer, new_sfa_record)
248
249         return (pointer, new_key_pointer)
250         
251
252     ##########
253     def remove (self, sfa_record):
254         type=sfa_record['type']
255         pointer=sfa_record['pointer']
256         if type == 'user':
257             persons = self.shell.GetPersons({'peer_id': None, 'person_id': pointer})
258             # only delete this person if he has site ids. if he doesnt, it probably means
259             # he was just removed from a site, not actually deleted
260             if persons and persons[0]['site_ids']:
261                 self.shell.DeletePerson(pointer)
262         elif type == 'slice':
263             if self.shell.GetSlices({'peer_id': None, 'slice_id': pointer}):
264                 self.shell.DeleteSlice(pointer)
265         elif type == 'node':
266             if self.shell.GetNodes({'peer_id': None, 'node_id': pointer}):
267                 self.shell.DeleteNode(pointer)
268         elif type == 'authority':
269             if self.shell.GetSites({'peer_id': None, 'site_id': pointer}):
270                 self.shell.DeleteSite(pointer)
271
272         return True
273
274
275
276
277
278     ##
279     # Convert SFA fields to PLC fields for use when registering or updating
280     # registry record in the PLC database
281     #
282
283     def sfa_fields_to_pl_fields(self, type, hrn, sfa_record):
284
285         pl_record = {}
286  
287         if type == "slice":
288             pl_record["name"] = hrn_to_pl_slicename(hrn)
289             if "instantiation" in sfa_record:
290                 pl_record['instantiation']=sfa_record['instantiation']
291             else:
292                 pl_record["instantiation"] = "plc-instantiated"
293             if "url" in sfa_record:
294                pl_record["url"] = sfa_record["url"]
295             if "description" in sfa_record:
296                 pl_record["description"] = sfa_record["description"]
297             if "expires" in sfa_record:
298                 date = utcparse(sfa_record['expires'])
299                 expires = datetime_to_epoch(date)
300                 pl_record["expires"] = expires
301
302         elif type == "node":
303             if not "hostname" in pl_record:
304                 # fetch from sfa_record
305                 if "hostname" not in sfa_record:
306                     raise MissingSfaInfo("hostname")
307                 pl_record["hostname"] = sfa_record["hostname"]
308             if "model" in sfa_record: 
309                 pl_record["model"] = sfa_record["model"]
310             else:
311                 pl_record["model"] = "geni"
312
313         elif type == "authority":
314             pl_record["login_base"] = PlXrn(xrn=hrn,type='authority').pl_login_base()
315             if "name" not in sfa_record:
316                 pl_record["name"] = hrn
317             if "abbreviated_name" not in sfa_record:
318                 pl_record["abbreviated_name"] = hrn
319             if "enabled" not in sfa_record:
320                 pl_record["enabled"] = True
321             if "is_public" not in sfa_record:
322                 pl_record["is_public"] = True
323
324         return pl_record
325
326     ####################
327     def fill_record_info(self, records):
328         """
329         Given a (list of) SFA record, fill in the PLC specific 
330         and SFA specific fields in the record. 
331         """
332         if not isinstance(records, list):
333             records = [records]
334
335         self.fill_record_pl_info(records)
336         self.fill_record_hrns(records)
337         self.fill_record_sfa_info(records)
338         return records
339
340     def fill_record_pl_info(self, records):
341         """
342         Fill in the planetlab specific fields of a SFA record. This
343         involves calling the appropriate PLC method to retrieve the 
344         database record for the object.
345             
346         @param record: record to fill in field (in/out param)     
347         """
348         # get ids by type
349         node_ids, site_ids, slice_ids = [], [], [] 
350         person_ids, key_ids = [], []
351         type_map = {'node': node_ids, 'authority': site_ids,
352                     'slice': slice_ids, 'user': person_ids}
353                   
354         for record in records:
355             for type in type_map:
356                 if type == record['type']:
357                     type_map[type].append(record['pointer'])
358
359         # get pl records
360         nodes, sites, slices, persons, keys = {}, {}, {}, {}, {}
361         if node_ids:
362             node_list = self.shell.GetNodes({'peer_id': None, 'node_id': node_ids})
363             nodes = list_to_dict(node_list, 'node_id')
364         if site_ids:
365             site_list = self.shell.GetSites({'peer_id': None, 'site_id': site_ids})
366             sites = list_to_dict(site_list, 'site_id')
367         if slice_ids:
368             slice_list = self.shell.GetSlices({'peer_id': None, 'slice_id': slice_ids})
369             slices = list_to_dict(slice_list, 'slice_id')
370         if person_ids:
371             person_list = self.shell.GetPersons({'peer_id': None, 'person_id': person_ids})
372             persons = list_to_dict(person_list, 'person_id')
373             for person in persons:
374                 key_ids.extend(persons[person]['key_ids'])
375
376         pl_records = {'node': nodes, 'authority': sites,
377                       'slice': slices, 'user': persons}
378
379         if key_ids:
380             key_list = self.shell.GetKeys(key_ids)
381             keys = list_to_dict(key_list, 'key_id')
382
383         # fill record info
384         for record in records:
385             # records with pointer==-1 do not have plc info.
386             # for example, the top level authority records which are
387             # authorities, but not PL "sites"
388             if record['pointer'] == -1:
389                 continue
390            
391             for type in pl_records:
392                 if record['type'] == type:
393                     if record['pointer'] in pl_records[type]:
394                         record.update(pl_records[type][record['pointer']])
395                         break
396             # fill in key info
397             if record['type'] == 'user':
398                 if 'key_ids' not in record:
399                     logger.info("user record has no 'key_ids' - need to import from myplc ?")
400                 else:
401                     pubkeys = [keys[key_id]['key'] for key_id in record['key_ids'] if key_id in keys] 
402                     record['keys'] = pubkeys
403
404         return records
405
406     def fill_record_hrns(self, records):
407         """
408         convert pl ids to hrns
409         """
410
411         # get ids
412         slice_ids, person_ids, site_ids, node_ids = [], [], [], []
413         for record in records:
414             if 'site_id' in record:
415                 site_ids.append(record['site_id'])
416             if 'site_ids' in record:
417                 site_ids.extend(record['site_ids'])
418             if 'person_ids' in record:
419                 person_ids.extend(record['person_ids'])
420             if 'slice_ids' in record:
421                 slice_ids.extend(record['slice_ids'])
422             if 'node_ids' in record:
423                 node_ids.extend(record['node_ids'])
424
425         # get pl records
426         slices, persons, sites, nodes = {}, {}, {}, {}
427         if site_ids:
428             site_list = self.shell.GetSites({'peer_id': None, 'site_id': site_ids}, ['site_id', 'login_base'])
429             sites = list_to_dict(site_list, 'site_id')
430         if person_ids:
431             person_list = self.shell.GetPersons({'peer_id': None, 'person_id': person_ids}, ['person_id', 'email'])
432             persons = list_to_dict(person_list, 'person_id')
433         if slice_ids:
434             slice_list = self.shell.GetSlices({'peer_id': None, 'slice_id': slice_ids}, ['slice_id', 'name'])
435             slices = list_to_dict(slice_list, 'slice_id')       
436         if node_ids:
437             node_list = self.shell.GetNodes({'peer_id': None, 'node_id': node_ids}, ['node_id', 'hostname'])
438             nodes = list_to_dict(node_list, 'node_id')
439        
440         # convert ids to hrns
441         for record in records:
442             # get all relevant data
443             type = record['type']
444             pointer = record['pointer']
445             auth_hrn = self.hrn
446             login_base = ''
447             if pointer == -1:
448                 continue
449
450             if 'site_id' in record:
451                 site = sites[record['site_id']]
452                 login_base = site['login_base']
453                 record['site'] = ".".join([auth_hrn, login_base])
454             if 'person_ids' in record:
455                 emails = [persons[person_id]['email'] for person_id in record['person_ids'] \
456                           if person_id in  persons]
457                 usernames = [email.split('@')[0] for email in emails]
458                 person_hrns = [".".join([auth_hrn, login_base, username]) for username in usernames]
459                 record['persons'] = person_hrns 
460             if 'slice_ids' in record:
461                 slicenames = [slices[slice_id]['name'] for slice_id in record['slice_ids'] \
462                               if slice_id in slices]
463                 slice_hrns = [slicename_to_hrn(auth_hrn, slicename) for slicename in slicenames]
464                 record['slices'] = slice_hrns
465             if 'node_ids' in record:
466                 hostnames = [nodes[node_id]['hostname'] for node_id in record['node_ids'] \
467                              if node_id in nodes]
468                 node_hrns = [hostname_to_hrn(auth_hrn, login_base, hostname) for hostname in hostnames]
469                 record['nodes'] = node_hrns
470             if 'site_ids' in record:
471                 login_bases = [sites[site_id]['login_base'] for site_id in record['site_ids'] \
472                                if site_id in sites]
473                 site_hrns = [".".join([auth_hrn, lbase]) for lbase in login_bases]
474                 record['sites'] = site_hrns
475
476             if 'expires' in record:
477                 date = utcparse(record['expires'])
478                 datestring = datetime_to_string(date)
479                 record['expires'] = datestring 
480             
481         return records   
482
483     def fill_record_sfa_info(self, records):
484
485         def startswith(prefix, values):
486             return [value for value in values if value.startswith(prefix)]
487
488         # get person ids
489         person_ids = []
490         site_ids = []
491         for record in records:
492             person_ids.extend(record.get("person_ids", []))
493             site_ids.extend(record.get("site_ids", [])) 
494             if 'site_id' in record:
495                 site_ids.append(record['site_id']) 
496         
497         # get all pis from the sites we've encountered
498         # and store them in a dictionary keyed on site_id 
499         site_pis = {}
500         if site_ids:
501             pi_filter = {'peer_id': None, '|roles': ['pi'], '|site_ids': site_ids} 
502             pi_list = self.shell.GetPersons(pi_filter, ['person_id', 'site_ids'])
503             for pi in pi_list:
504                 # we will need the pi's hrns also
505                 person_ids.append(pi['person_id'])
506                 
507                 # we also need to keep track of the sites these pis
508                 # belong to
509                 for site_id in pi['site_ids']:
510                     if site_id in site_pis:
511                         site_pis[site_id].append(pi)
512                     else:
513                         site_pis[site_id] = [pi]
514                  
515         # get sfa records for all records associated with these records.   
516         # we'll replace pl ids (person_ids) with hrns from the sfa records
517         # we obtain
518         
519         # get the registry records
520         person_list, persons = [], {}
521         person_list = self.api.dbsession().query (RegRecord).filter(RegRecord.pointer.in_(person_ids))
522         # create a hrns keyed on the sfa record's pointer.
523         # Its possible for multiple records to have the same pointer so
524         # the dict's value will be a list of hrns.
525         persons = defaultdict(list)
526         for person in person_list:
527             persons[person.pointer].append(person)
528
529         # get the pl records
530         pl_person_list, pl_persons = [], {}
531         pl_person_list = self.shell.GetPersons(person_ids, ['person_id', 'roles'])
532         pl_persons = list_to_dict(pl_person_list, 'person_id')
533
534         # fill sfa info
535         for record in records:
536             # skip records with no pl info (top level authorities)
537             #if record['pointer'] == -1:
538             #    continue 
539             sfa_info = {}
540             type = record['type']
541             logger.info("fill_record_sfa_info - incoming record typed %s"%type)
542             if (type == "slice"):
543                 # all slice users are researchers
544                 record['geni_urn'] = hrn_to_urn(record['hrn'], 'slice')
545                 record['PI'] = []
546                 record['researcher'] = []
547                 for person_id in record.get('person_ids', []):
548                     hrns = [person.hrn for person in persons[person_id]]
549                     record['researcher'].extend(hrns)                
550
551                 # pis at the slice's site
552                 if 'site_id' in record and record['site_id'] in site_pis:
553                     pl_pis = site_pis[record['site_id']]
554                     pi_ids = [pi['person_id'] for pi in pl_pis]
555                     for person_id in pi_ids:
556                         hrns = [person.hrn for person in persons[person_id]]
557                         record['PI'].extend(hrns)
558                         record['geni_creator'] = record['PI'] 
559                 
560             elif (type.startswith("authority")):
561                 record['url'] = None
562                 logger.info("fill_record_sfa_info - authority xherex")
563                 if record['pointer'] != -1:
564                     record['PI'] = []
565                     record['operator'] = []
566                     record['owner'] = []
567                     for pointer in record.get('person_ids', []):
568                         if pointer not in persons or pointer not in pl_persons:
569                             # this means there is not sfa or pl record for this user
570                             continue   
571                         hrns = [person.hrn for person in persons[pointer]] 
572                         roles = pl_persons[pointer]['roles']   
573                         if 'pi' in roles:
574                             record['PI'].extend(hrns)
575                         if 'tech' in roles:
576                             record['operator'].extend(hrns)
577                         if 'admin' in roles:
578                             record['owner'].extend(hrns)
579                         # xxx TODO: OrganizationName
580             elif (type == "node"):
581                 sfa_info['dns'] = record.get("hostname", "")
582                 # xxx TODO: URI, LatLong, IP, DNS
583     
584             elif (type == "user"):
585                 logger.info('setting user.email')
586                 sfa_info['email'] = record.get("email", "")
587                 sfa_info['geni_urn'] = hrn_to_urn(record['hrn'], 'user')
588                 sfa_info['geni_certificate'] = record['gid'] 
589                 # xxx TODO: PostalAddress, Phone
590             record.update(sfa_info)
591
592
593     ####################
594     # plcapi works by changes, compute what needs to be added/deleted
595     def update_relation (self, subject_type, target_type, relation_name, subject_id, target_ids):
596         # hard-wire the code for slice/user for now, could be smarter if needed
597         if subject_type =='slice' and target_type == 'user' and relation_name == 'researcher':
598             subject=self.shell.GetSlices (subject_id)[0]
599             current_target_ids = subject['person_ids']
600             add_target_ids = list ( set (target_ids).difference(current_target_ids))
601             del_target_ids = list ( set (current_target_ids).difference(target_ids))
602             logger.debug ("subject_id = %s (type=%s)"%(subject_id,type(subject_id)))
603             for target_id in add_target_ids:
604                 self.shell.AddPersonToSlice (target_id,subject_id)
605                 logger.debug ("add_target_id = %s (type=%s)"%(target_id,type(target_id)))
606             for target_id in del_target_ids:
607                 logger.debug ("del_target_id = %s (type=%s)"%(target_id,type(target_id)))
608                 self.shell.DeletePersonFromSlice (target_id, subject_id)
609         elif subject_type == 'authority' and target_type == 'user' and relation_name == 'pi':
610             # due to the plcapi limitations this means essentially adding pi role to all people in the list
611             # it's tricky to remove any pi role here, although it might be desirable
612             persons = self.shell.GetPersons ({'peer_id': None, 'person_id': target_ids})
613             for person in persons: 
614                 if 'pi' not in person['roles']:
615                     self.shell.AddRoleToPerson('pi',person['person_id'])
616         else:
617             logger.info('unexpected relation %s to maintain, %s -> %s'%(relation_name,subject_type,target_type))
618
619         
620     ########################################
621     ########## aggregate oriented
622     ########################################
623
624     def testbed_name (self): return "myplc"
625
626     def aggregate_version (self):
627         return {}
628
629     # first 2 args are None in case of resource discovery
630     def list_resources (self, version=None, options=None):
631         if options is None: options={}
632         aggregate = PlAggregate(self)
633         rspec =  aggregate.list_resources(version=version, options=options)
634         return rspec
635
636     def describe(self, urns, version, options=None):
637         if options is None: options={}
638         aggregate = PlAggregate(self)
639         return aggregate.describe(urns, version=version, options=options)
640     
641     def status (self, urns, options=None):
642         if options is None: options={}
643         aggregate = PlAggregate(self)
644         desc =  aggregate.describe(urns, version='GENI 3')
645         status = {'geni_urn': desc['geni_urn'],
646                   'geni_slivers': desc['geni_slivers']}
647         return status
648
649     def allocate (self, urn, rspec_string, expiration, options=None):
650         if options is None: options={}
651         xrn = Xrn(urn)
652         aggregate = PlAggregate(self)
653         slices = PlSlices(self)
654         sfa_peer = slices.get_sfa_peer(xrn.get_hrn())
655         slice_record=None    
656         users = options.get('geni_users', [])
657
658         if users:
659             slice_record = users[0].get('slice_record', {})
660     
661         # parse rspec
662         rspec = RSpec(rspec_string)
663         requested_attributes = rspec.version.get_slice_attributes()
664         
665         # ensure site record exists
666         site = slices.verify_site(xrn.hrn, slice_record, sfa_peer, options=options)
667         # ensure slice record exists
668         slice = slices.verify_slice(xrn.hrn, slice_record, sfa_peer, expiration=expiration, options=options)
669         # ensure person records exists
670         persons = slices.verify_persons(xrn.hrn, slice, users, sfa_peer, options=options)
671         # ensure slice attributes exists
672         slices.verify_slice_attributes(slice, requested_attributes, options=options)
673        
674         # add/remove slice from nodes
675         request_nodes = rspec.version.get_nodes_with_slivers()
676         nodes = slices.verify_slice_nodes(urn, slice, request_nodes)
677          
678         # add/remove links links 
679         slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
680
681         # add/remove leases
682         rspec_requested_leases = rspec.version.get_leases()
683         leases = slices.verify_slice_leases(slice, rspec_requested_leases)
684
685         return aggregate.describe([xrn.get_urn()], version=rspec.version)
686
687     def provision(self, urns, options=None):
688         if options is None: options={}
689         # update users
690         slices = PlSlices(self)
691         aggregate = PlAggregate(self)
692         slivers = aggregate.get_slivers(urns)
693         if not slivers:
694             sliver_id_parts = Xrn(urns[0]).get_sliver_id_parts()
695             filter = {}
696             try:
697                 filter['slice_id'] = int(sliver_id_parts[0])
698             except ValueError:
699                 filter['name'] = sliver_id_parts[0]
700             slices = self.shell.GetSlices(filter,['hrn'])
701             if not slices:
702                 raise Forbidden("Unable to locate slice record for sliver:  %s" % xrn)
703             slice = slices[0]
704             slice_urn = hrn_to_urn(slice['hrn'], type='slice')
705             urns = [slice_urn]          
706         else:    
707             slice_id = slivers[0]['slice_id']
708             slice_hrn = self.shell.GetSliceHrn(slice_id)
709             slice = self.shell.GetSlices({'slice_id': slice_id})[0]
710             slice['hrn'] = slice_hrn
711             sfa_peer = slices.get_sfa_peer(slice['hrn'])
712             users = options.get('geni_users', [])
713             persons = slices.verify_persons(slice['hrn'], slice, users, sfa_peer, options=options)
714             # update sliver allocation states and set them to geni_provisioned
715             sliver_ids = [sliver['sliver_id'] for sliver in slivers]
716             dbsession=self.api.dbsession()
717             SliverAllocation.set_allocations(sliver_ids, 'geni_provisioned',dbsession)
718
719         version_manager = VersionManager()
720         rspec_version = version_manager.get_version(options['geni_rspec_version']) 
721         return self.describe(urns, rspec_version, options=options)
722
723     def delete(self, urns, options=None):
724         if options is None: options={}
725         # collect sliver ids so we can update sliver allocation states after
726         # we remove the slivers.
727         aggregate = PlAggregate(self)
728         slivers = aggregate.get_slivers(urns)
729         if slivers:
730             slice_id = slivers[0]['slice_id'] 
731             slice_name = slivers[0]['name']
732             node_ids = []
733             sliver_ids = []
734             for sliver in slivers:
735                 node_ids.append(sliver['node_id'])
736                 sliver_ids.append(sliver['sliver_id']) 
737
738             # leases
739             leases = self.shell.GetLeases({'name': slice_name, 'node_id': node_ids})
740             leases_ids = [lease['lease_id'] for lease in leases ]
741
742             slice_hrn = self.shell.GetSliceHrn(int(slice_id))
743             try:
744                 self.shell.DeleteSliceFromNodes(slice_id, node_ids)
745                 if len(leases_ids) > 0:
746                     self.shell.DeleteLeases(leases_ids)
747      
748                 # delete sliver allocation states
749                 dbsession=self.api.dbsession()
750                 SliverAllocation.delete_allocations(sliver_ids,dbsession)
751             finally:
752                 pass
753
754         # prepare return struct
755         geni_slivers = []
756         for sliver in slivers:
757             geni_slivers.append(
758                 {'geni_sliver_urn': sliver['sliver_id'],
759                  'geni_allocation_status': 'geni_unallocated',
760                  'geni_expires': datetime_to_string(utcparse(sliver['expires']))})  
761         return geni_slivers
762
763     def renew (self, urns, expiration_time, options=None):
764         if options is None: options={}
765         aggregate = PlAggregate(self)
766         slivers = aggregate.get_slivers(urns)
767         if not slivers:
768             raise SearchFailed(urns)
769         slice = slivers[0]
770         requested_time = utcparse(expiration_time)
771         record = {'expires': int(datetime_to_epoch(requested_time))}
772         self.shell.UpdateSlice(slice['slice_id'], record)
773         description = self.describe(urns, 'GENI 3', options)
774         return description['geni_slivers']
775             
776
777     def perform_operational_action (self, urns, action, options=None):
778         if options is None: options={}
779         # MyPLC doesn't support operational actions. Lets pretend like it
780         # supports start, but reject everything else.
781         action = action.lower()
782         if action not in ['geni_start']:
783             raise UnsupportedOperation(action)
784
785         # fault if sliver is not full allocated (operational status is geni_pending_allocation)
786         description = self.describe(urns, 'GENI 3', options)
787         for sliver in description['geni_slivers']:
788             if sliver['geni_operational_status'] == 'geni_pending_allocation':
789                 raise UnsupportedOperation(action, "Sliver must be fully allocated (operational status is not geni_pending_allocation)")
790         #
791         # Perform Operational Action Here
792         #
793
794         geni_slivers = self.describe(urns, 'GENI 3', options)['geni_slivers']
795         return geni_slivers
796
797     # set the 'enabled' tag to 0
798     def shutdown (self, xrn, options=None):
799         if options is None: options={}
800         hrn, _ = urn_to_hrn(xrn)
801         top_auth_hrn = top_auth(hrn)
802         site_hrn = '.'.join(hrn.split('.')[:-1])
803         slice_part = hrn.split('.')[-1]
804         if top_auth_hrn == self.hrn:
805             login_base = slice_hrn.split('.')[-2][:12]
806         else:
807             login_base = hash_loginbase(site_hrn)
808
809         slicename = '_'.join([login_base, slice_part])
810
811         slices = self.shell.GetSlices({'peer_id': None, 'name': slicename}, ['slice_id'])
812         if not slices:
813             raise RecordNotFound(slice_hrn)
814         slice_id = slices[0]['slice_id']
815         slice_tags = self.shell.GetSliceTags({'slice_id': slice_id, 'tagname': 'enabled'})
816         if not slice_tags:
817             self.shell.AddSliceTag(slice_id, 'enabled', '0')
818         elif slice_tags[0]['value'] != "0":
819             tag_id = slice_tags[0]['slice_tag_id']
820             self.shell.UpdateSliceTag(tag_id, '0')
821         return 1