sfa/planetlab/pldriver.py

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