sfa/planetlab/pldriver.py

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