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