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 Xrn, hrn_to_urn, get_leaf
  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, xrn_to_hostname
  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         # Adding the list_leases option to the caching key
 616         if options.get('list_leases'):
 617             version_string = version_string + "_"+options.get('list_leases', 'default')
 618
 619         # Adding geni_available to caching key
 620         if options.get('geni_available'):
 621             version_string = version_string + "_" + str(options.get('geni_available'))
 622
 623         # look in cache first
 624         if cached_requested and self.cache and not slice_hrn:
 625             rspec = self.cache.get(version_string)
 626             if rspec:
 627                 logger.debug("PlDriver.ListResources: returning cached advertisement")
 628                 return rspec
 629
 630         #panos: passing user-defined options
 631         #print "manager options = ",options
 632         aggregate = PlAggregate(self)
 633         rspec =  aggregate.get_rspec(slice_xrn=slice_urn, version=rspec_version,
 634                                      options=options)
 635
 636         # cache the result
 637         if self.cache and not slice_hrn:
 638             logger.debug("PlDriver.ListResources: stores advertisement in cache")
 639             self.cache.add(version_string, rspec)
 640
 641         return rspec
 642
 643     def sliver_status (self, slice_urn, slice_hrn):
 644         # find out where this slice is currently running
 645         slicename = hrn_to_pl_slicename(slice_hrn)
 646
 647         slices = self.shell.GetSlices([slicename], ['slice_id', 'node_ids','person_ids','name','expires'])
 648         if len(slices) == 0:
 649             raise SliverDoesNotExist("%s (used %s as slicename internally)" % (slice_hrn, slicename))
 650         slice = slices[0]
 651
 652         # report about the local nodes only
 653         nodes = self.shell.GetNodes({'node_id':slice['node_ids'],'peer_id':None},
 654                               ['node_id', 'hostname', 'site_id', 'boot_state', 'last_contact'])
 655
 656         if len(nodes) == 0:
 657             raise SliverDoesNotExist("You have not allocated any slivers here")
 658
 659         # get login info
 660         user = {}
 661         if slice['person_ids']:
 662             persons = self.shell.GetPersons(slice['person_ids'], ['key_ids'])
 663             key_ids = [key_id for person in persons for key_id in person['key_ids']]
 664             person_keys = self.shell.GetKeys(key_ids)
 665             keys = [key['key'] for key in person_keys]
 666
 667             user.update({'urn': slice_urn,
 668                          'login': slice['name'],
 669                          'protocol': ['ssh'],
 670                          'port': ['22'],
 671                          'keys': keys})
 672
 673         site_ids = [node['site_id'] for node in nodes]
 674
 675         result = {}
 676         top_level_status = 'unknown'
 677         if nodes:
 678             top_level_status = 'ready'
 679         result['geni_urn'] = slice_urn
 680         result['pl_login'] = slice['name']
 681         result['pl_expires'] = datetime_to_string(utcparse(slice['expires']))
 682         result['geni_expires'] = datetime_to_string(utcparse(slice['expires']))
 683
 684         resources = []
 685         for node in nodes:
 686             res = {}
 687             res['pl_hostname'] = node['hostname']
 688             res['pl_boot_state'] = node['boot_state']
 689             res['pl_last_contact'] = node['last_contact']
 690             res['geni_expires'] = datetime_to_string(utcparse(slice['expires']))
 691             if node['last_contact'] is not None:
 692
 693                 res['pl_last_contact'] = datetime_to_string(utcparse(node['last_contact']))
 694             sliver_id = Xrn(slice_urn, type='slice', id=node['node_id'], authority=self.hrn).urn
 695             res['geni_urn'] = sliver_id
 696             if node['boot_state'] == 'boot':
 697                 res['geni_status'] = 'ready'
 698             else:
 699                 res['geni_status'] = 'failed'
 700                 top_level_status = 'failed'
 701
 702             res['geni_error'] = ''
 703             res['users'] = [user]
 704
 705             resources.append(res)
 706
 707         result['geni_status'] = top_level_status
 708         result['geni_resources'] = resources
 709         return result
 710
 711     def create_sliver (self, slice_urn, slice_hrn, creds, rspec_string, users, options):
 712
 713         aggregate = PlAggregate(self)
 714         slices = PlSlices(self)
 715         peer = slices.get_peer(slice_hrn)
 716         sfa_peer = slices.get_sfa_peer(slice_hrn)
 717         slice_record=None
 718         if users:
 719             slice_record = users[0].get('slice_record', {})
 720
 721         # parse rspec
 722         rspec = RSpec(rspec_string)
 723         requested_attributes = rspec.version.get_slice_attributes()
 724
 725         # ensure site record exists
 726         site = slices.verify_site(slice_hrn, slice_record, peer, sfa_peer, options=options)
 727         # ensure slice record exists
 728         slice = slices.verify_slice(slice_hrn, slice_record, peer, sfa_peer, options=options)
 729         # ensure person records exists
 730         persons = slices.verify_persons(slice_hrn, slice, users, peer, sfa_peer, options=options)
 731         # ensure slice attributes exists
 732         slices.verify_slice_attributes(slice, requested_attributes, options=options)
 733
 734         # add/remove slice from nodes
 735         requested_slivers = []
 736         for node in rspec.version.get_nodes_with_slivers():
 737             hostname = None
 738             if node.get('component_name'):
 739                 hostname = node.get('component_name').strip()
 740             elif node.get('component_id'):
 741                 hostname = xrn_to_hostname(node.get('component_id').strip())
 742             if hostname:
 743                 requested_slivers.append(hostname)
 744         nodes = slices.verify_slice_nodes(slice, requested_slivers, peer)
 745
 746         # add/remove links links
 747         slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
 748
 749         # add/remove leases
 750         requested_leases = []
 751         kept_leases = []
 752         for lease in rspec.version.get_leases():
 753             requested_lease = {}
 754             if not lease.get('lease_id'):
 755                requested_lease['hostname'] = xrn_to_hostname(lease.get('component_id').strip())
 756                requested_lease['start_time'] = lease.get('start_time')
 757                requested_lease['duration'] = lease.get('duration')
 758             else:
 759                kept_leases.append(int(lease['lease_id']))
 760             if requested_lease.get('hostname'):
 761                 requested_leases.append(requested_lease)
 762
 763         leases = slices.verify_slice_leases(slice, requested_leases, kept_leases, peer)
 764
 765         # handle MyPLC peer association.
 766         # only used by plc and ple.
 767         slices.handle_peer(site, slice, persons, peer)
 768
 769         return aggregate.get_rspec(slice_xrn=slice_urn, version=rspec.version)
 770
 771     def delete_sliver (self, slice_urn, slice_hrn, creds, options):
 772         slicename = hrn_to_pl_slicename(slice_hrn)
 773         slices = self.shell.GetSlices({'name': slicename})
 774         if not slices:
 775             return True
 776         slice = slices[0]
 777
 778         # determine if this is a peer slice
 779         # xxx I wonder if this would not need to use PlSlices.get_peer instead
 780         # in which case plc.peers could be deprecated as this here
 781         # is the only/last call to this last method in plc.peers
 782         peer = peers.get_peer(self, slice_hrn)
 783         try:
 784             if peer:
 785                 self.shell.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
 786             self.shell.DeleteSliceFromNodes(slicename, slice['node_ids'])
 787         finally:
 788             if peer:
 789                 self.shell.BindObjectToPeer('slice', slice['slice_id'], peer, slice['peer_slice_id'])
 790         return True
 791
 792     def renew_sliver (self, slice_urn, slice_hrn, creds, expiration_time, options):
 793         slicename = hrn_to_pl_slicename(slice_hrn)
 794         slices = self.shell.GetSlices({'name': slicename}, ['slice_id'])
 795         if not slices:
 796             raise RecordNotFound(slice_hrn)
 797         slice = slices[0]
 798         requested_time = utcparse(expiration_time)
 799         record = {'expires': int(datetime_to_epoch(requested_time))}
 800         try:
 801             self.shell.UpdateSlice(slice['slice_id'], record)
 802             return True
 803         except:
 804             return False
 805
 806     # remove the 'enabled' tag
 807     def start_slice (self, slice_urn, slice_hrn, creds):
 808         slicename = hrn_to_pl_slicename(slice_hrn)
 809         slices = self.shell.GetSlices({'name': slicename}, ['slice_id'])
 810         if not slices:
 811             raise RecordNotFound(slice_hrn)
 812         slice_id = slices[0]['slice_id']
 813         slice_tags = self.shell.GetSliceTags({'slice_id': slice_id, 'tagname': 'enabled'}, ['slice_tag_id'])
 814         # just remove the tag if it exists
 815         if slice_tags:
 816             self.shell.DeleteSliceTag(slice_tags[0]['slice_tag_id'])
 817         return 1
 818
 819     # set the 'enabled' tag to 0
 820     def stop_slice (self, slice_urn, slice_hrn, creds):
 821         slicename = hrn_to_pl_slicename(slice_hrn)
 822         slices = self.shell.GetSlices({'name': slicename}, ['slice_id'])
 823         if not slices:
 824             raise RecordNotFound(slice_hrn)
 825         slice_id = slices[0]['slice_id']
 826         slice_tags = self.shell.GetSliceTags({'slice_id': slice_id, 'tagname': 'enabled'})
 827         if not slice_tags:
 828             self.shell.AddSliceTag(slice_id, 'enabled', '0')
 829         elif slice_tags[0]['value'] != "0":
 830             tag_id = slice_tags[0]['slice_tag_id']
 831             self.shell.UpdateSliceTag(tag_id, '0')
 832         return 1
 833
 834     def reset_slice (self, slice_urn, slice_hrn, creds):
 835         raise SfaNotImplemented ("reset_slice not available at this interface")
 836
 837     # xxx this code is quite old and has not run for ages
 838     # it is obviously totally broken and needs a rewrite
 839     def get_ticket (self, slice_urn, slice_hrn, creds, rspec_string, options):
 840         raise SfaNotImplemented,"PlDriver.get_ticket needs a rewrite"
 841 # please keep this code for future reference
 842 #        slices = PlSlices(self)
 843 #        peer = slices.get_peer(slice_hrn)
 844 #        sfa_peer = slices.get_sfa_peer(slice_hrn)
 845 #
 846 #        # get the slice record
 847 #        credential = api.getCredential()
 848 #        interface = api.registries[api.hrn]
 849 #        registry = api.server_proxy(interface, credential)
 850 #        records = registry.Resolve(xrn, credential)
 851 #
 852 #        # make sure we get a local slice record
 853 #        record = None
 854 #        for tmp_record in records:
 855 #            if tmp_record['type'] == 'slice' and \
 856 #               not tmp_record['peer_authority']:
 857 #    #Error (E0602, GetTicket): Undefined variable 'SliceRecord'
 858 #                slice_record = SliceRecord(dict=tmp_record)
 859 #        if not record:
 860 #            raise RecordNotFound(slice_hrn)
 861 #
 862 #        # similar to CreateSliver, we must verify that the required records exist
 863 #        # at this aggregate before we can issue a ticket
 864 #        # parse rspec
 865 #        rspec = RSpec(rspec_string)
 866 #        requested_attributes = rspec.version.get_slice_attributes()
 867 #
 868 #        # ensure site record exists
 869 #        site = slices.verify_site(slice_hrn, slice_record, peer, sfa_peer)
 870 #        # ensure slice record exists
 871 #        slice = slices.verify_slice(slice_hrn, slice_record, peer, sfa_peer)
 872 #        # ensure person records exists
 873 #    # xxx users is undefined in this context
 874 #        persons = slices.verify_persons(slice_hrn, slice, users, peer, sfa_peer)
 875 #        # ensure slice attributes exists
 876 #        slices.verify_slice_attributes(slice, requested_attributes)
 877 #
 878 #        # get sliver info
 879 #        slivers = slices.get_slivers(slice_hrn)
 880 #
 881 #        if not slivers:
 882 #            raise SliverDoesNotExist(slice_hrn)
 883 #
 884 #        # get initscripts
 885 #        initscripts = []
 886 #        data = {
 887 #            'timestamp': int(time.time()),
 888 #            'initscripts': initscripts,
 889 #            'slivers': slivers
 890 #        }
 891 #
 892 #        # create the ticket
 893 #        object_gid = record.get_gid_object()
 894 #        new_ticket = SfaTicket(subject = object_gid.get_subject())
 895 #        new_ticket.set_gid_caller(api.auth.client_gid)
 896 #        new_ticket.set_gid_object(object_gid)
 897 #        new_ticket.set_issuer(key=api.key, subject=self.hrn)
 898 #        new_ticket.set_pubkey(object_gid.get_pubkey())
 899 #        new_ticket.set_attributes(data)
 900 #        new_ticket.set_rspec(rspec)
 901 #        #new_ticket.set_parent(api.auth.hierarchy.get_auth_ticket(auth_hrn))
 902 #        new_ticket.encode()
 903 #        new_ticket.sign()
 904 #
 905 #        return new_ticket.save_to_string(save_parents=True)