geni/registry.py

   1 ##
   2 # Registry is a GeniServer that implements the Registry interface
   3
   4 import tempfile
   5 import os
   6 import time
   7 import sys
   8
   9 from geni.util.credential import Credential
  10 from geni.util.hierarchy import Hierarchy
  11 from geni.util.trustedroot import TrustedRootList
  12 from geni.util.cert import Keypair, Certificate
  13 from geni.util.gid import GID, create_uuid
  14 from geni.util.geniserver import GeniServer
  15 from geni.util.record import GeniRecord
  16 from geni.util.rights import RightList
  17 from geni.util.genitable import GeniTable
  18 from geni.util.geniticket import Ticket
  19 from geni.util.excep import *
  20 from geni.util.misc import *
  21 from geni.util.config import *
  22
  23 ##
  24 # Convert geni fields to PLC fields for use when registering up updating
  25 # registry record in the PLC database
  26 #
  27 # @param type type of record (user, slice, ...)
  28 # @param hrn human readable name
  29 # @param geni_fields dictionary of geni fields
  30 # @param pl_fields dictionary of PLC fields (output)
  31
  32 def geni_fields_to_pl_fields(type, hrn, geni_fields, pl_fields):
  33     if type == "user":
  34         if not "email" in pl_fields:
  35             if not "email" in geni_fields:
  36                 raise MissingGeniInfo("email")
  37             pl_fields["email"] = geni_fields["email"]
  38
  39         if not "first_name" in pl_fields:
  40             pl_fields["first_name"] = "geni"
  41
  42         if not "last_name" in pl_fields:
  43             pl_fields["last_name"] = hrn
  44
  45     elif type == "slice":
  46         if not "instantiation" in pl_fields:
  47             pl_fields["instantiation"] = "delegated"  # "plc-instantiated"
  48         if not "name" in pl_fields:
  49             pl_fields["name"] = hrn_to_pl_slicename(hrn)
  50         if not "max_nodes" in pl_fields:
  51             pl_fields["max_nodes"] = 10
  52
  53     elif type == "node":
  54         if not "hostname" in pl_fields:
  55             if not "dns" in geni_fields:
  56                 raise MissingGeniInfo("dns")
  57             pl_fields["hostname"] = geni_fields["dns"]
  58
  59         if not "model" in pl_fields:
  60             pl_fields["model"] = "geni"
  61
  62     elif type == "sa":
  63         pl_fields["login_base"] = hrn_to_pl_login_base(hrn)
  64
  65         if not "name" in pl_fields:
  66             pl_fields["name"] = hrn
  67
  68         if not "abbreviated_name" in pl_fields:
  69             pl_fields["abbreviated_name"] = hrn
  70
  71         if not "enabled" in pl_fields:
  72             pl_fields["enabled"] = True
  73
  74         if not "is_public" in pl_fields:
  75             pl_fields["is_public"] = True
  76
  77 ##
  78 # Registry is a GeniServer that serves registry and slice operations at PLC.
  79
  80 class Registry(GeniServer):
  81     ##
  82     # Create a new registry object.
  83     #
  84     # @param ip the ip address to listen on
  85     # @param port the port to listen on
  86     # @param key_file private key filename of registry
  87     # @param cert_file certificate filename containing public key (could be a GID file)
  88
  89     def __init__(self, ip, port, key_file, cert_file):
  90         GeniServer.__init__(self, ip, port, key_file, cert_file)
  91
  92         # get PL account settings from config module
  93         self.pl_auth = get_pl_auth()
  94
  95         # connect to planetlab
  96         if "Url" in self.pl_auth:
  97             self.connect_remote_shell()
  98         else:
  99             self.connect_local_shell()
 100
 101     ##
 102     # Connect to a remote shell via XMLRPC
 103
 104     def connect_remote_shell(self):
 105         from geni.util import remoteshell
 106         self.shell = remoteshell.RemoteShell()
 107
 108     ##
 109     # Connect to a local shell via local API functions
 110
 111     def connect_local_shell(self):
 112         import PLC.Shell
 113         self.shell = PLC.Shell.Shell(globals = globals())
 114
 115     ##
 116     # Register the server RPCs for the registry
 117
 118     def register_functions(self):
 119         GeniServer.register_functions(self)
 120         # registry interface
 121         self.server.register_function(self.create_gid)
 122         self.server.register_function(self.get_self_credential)
 123         self.server.register_function(self.get_credential)
 124         self.server.register_function(self.get_gid)
 125         self.server.register_function(self.get_ticket)
 126         self.server.register_function(self.register)
 127         self.server.register_function(self.remove)
 128         self.server.register_function(self.update)
 129         self.server.register_function(self.list)
 130         self.server.register_function(self.resolve)
 131
 132     ##
 133     # Given an authority name, return the information for that authority. This
 134     # is basically a stub that calls the hierarchy module.
 135     #
 136     # @param auth_hrn human readable name of authority
 137
 138     def get_auth_info(self, auth_hrn):
 139         return self.hierarchy.get_auth_info(auth_hrn)
 140
 141     ##
 142     # Given an authority name, return the database table for that authority. If
 143     # the database table does not exist, then one will be automatically
 144     # created.
 145     #
 146     # @param auth_name human readable name of authority
 147
 148     def get_auth_table(self, auth_name):
 149         auth_info = self.get_auth_info(auth_name)
 150
 151         table = GeniTable(hrn=auth_name,
 152                           cninfo=auth_info.get_dbinfo())
 153
 154         # if the table doesn't exist, then it means we haven't put any records
 155         # into this authority yet.
 156
 157         if not table.exists():
 158             print "Registry: creating table for authority", auth_name
 159             table.create()
 160
 161         return table
 162
 163     ##
 164     # Verify that an authority belongs to this registry. This is basically left
 165     # up to the implementation of the hierarchy module. If the specified name
 166     # does not belong to this registry, an exception is thrown indicating the
 167     # caller should contact someone else.
 168     #
 169     # @param auth_name human readable name of authority
 170
 171     def verify_auth_belongs_to_me(self, name):
 172         # get_auth_info will throw an exception if the authority does not
 173         # exist
 174         self.get_auth_info(name)
 175
 176     ##
 177     # Verify that an object belongs to this registry. By extension, this implies
 178     # that the authority that owns the object belongs to this registry. If the
 179     # object does not belong to this registry, then an exception is thrown.
 180     #
 181     # @param name human readable name of object
 182
 183     def verify_object_belongs_to_me(self, name):
 184         auth_name = get_authority(name)
 185         if not auth_name:
 186             # the root authority belongs to the registry by default?
 187             # TODO: is this true?
 188             return
 189         self.verify_auth_belongs_to_me(auth_name)
 190
 191     ##
 192     # Verify that the object_gid that was specified in the credential allows
 193     # permission to the object 'name'. This is done by a simple prefix test.
 194     # For example, an object_gid for planetlab.us.arizona would match the
 195     # objects planetlab.us.arizona.slice1 and planetlab.us.arizona.
 196     #
 197     # @param name human readable name to test
 198
 199     def verify_object_permission(self, name):
 200         object_hrn = self.object_gid.get_hrn()
 201         if object_hrn == name:
 202             return
 203         if name.startswith(object_hrn + "."):
 204             return
 205         raise PermissionError(name)
 206
 207     ##
 208     # Fill in the planetlab-specific fields of a Geni record. This involves
 209     # calling the appropriate PLC methods to retrieve the database record for
 210     # the object.
 211     #
 212     # PLC data is filled into the pl_info field of the record.
 213     #
 214     # @param record record to fill in fields (in/out param)
 215
 216     def fill_record_pl_info(self, record):
 217         type = record.get_type()
 218         pointer = record.get_pointer()
 219
 220         # records with pointer==-1 do not have plc info associated with them.
 221         # for example, the top level authority records which are
 222         # authorities, but not PL "sites"
 223         if pointer == -1:
 224             record.set_pl_info({})
 225             return
 226
 227         if (type == "sa") or (type == "ma"):
 228             pl_res = self.shell.GetSites(self.pl_auth, [pointer])
 229         elif (type == "slice"):
 230             pl_res = self.shell.GetSlices(self.pl_auth, [pointer])
 231         elif (type == "user"):
 232             pl_res = self.shell.GetPersons(self.pl_auth, [pointer])
 233         elif (type == "node"):
 234             pl_res = self.shell.GetNodes(self.pl_auth, [pointer])
 235         else:
 236             raise UnknownGeniType(type)
 237
 238         if not pl_res:
 239             # the planetlab record no longer exists
 240             # TODO: delete the geni record ?
 241             raise PlanetLabRecordDoesNotExist(record.get_name())
 242
 243         record.set_pl_info(pl_res[0])
 244
 245     ##
 246     # Look up user records given PLC user-ids. This is used as part of the
 247     # process for reverse-mapping PLC records into Geni records.
 248     #
 249     # @param auth_table database table for the authority that holds the user records
 250     # @param user_id_list list of user ids
 251     # @param role either "*" or a string describing the role to look for ("pi", "user", ...)
 252     #
 253     # TODO: This function currently only searches one authority because it would
 254     # be inefficient to brute-force search all authorities for a user id. The
 255     # solution would likely be to implement a reverse mapping of user-id to
 256     # (type, hrn) pairs.
 257
 258     def lookup_users(self, auth_table, user_id_list, role="*"):
 259         record_list = []
 260         for person_id in user_id_list:
 261             user_records = auth_table.find("user", person_id, "pointer")
 262             for user_record in user_records:
 263                 self.fill_record_info(user_record)
 264
 265                 user_roles = user_record.get_pl_info().get("roles")
 266                 if (role=="*") or (role in user_roles):
 267                     record_list.append(user_record.get_name())
 268         return record_list
 269
 270     ##
 271     # Fill in the geni-specific fields of the record.
 272     #
 273     # Note: It is assumed the fill_record_pl_info() has already been performed
 274     # on the record.
 275
 276     def fill_record_geni_info(self, record):
 277         geni_info = {}
 278         type = record.get_type()
 279
 280         if (type == "slice"):
 281             auth_table = self.get_auth_table(get_authority(record.get_name()))
 282             person_ids = record.pl_info.get("person_ids", [])
 283             researchers = self.lookup_users(auth_table, person_ids)
 284             geni_info['researcher'] = researchers
 285
 286         elif (type == "sa"):
 287             auth_table = self.get_auth_table(record.get_name())
 288             person_ids = record.pl_info.get("person_ids", [])
 289             pis = self.lookup_users(auth_table, person_ids, "pi")
 290             geni_info['pi'] = pis
 291             # TODO: OrganizationName
 292
 293         elif (type == "ma"):
 294             auth_table = self.get_auth_table(record.get_name())
 295             person_ids = record.pl_info.get("person_ids", [])
 296             operators = self.lookup_users(auth_table, person_ids, "tech")
 297             geni_info['operator'] = operators
 298             # TODO: OrganizationName
 299
 300             auth_table = self.get_auth_table(record.get_name())
 301             person_ids = record.pl_info.get("person_ids", [])
 302             owners = self.lookup_users(auth_table, person_ids, "admin")
 303             geni_info['owner'] = owners
 304
 305         elif (type == "node"):
 306             geni_info['dns'] = record.pl_info.get("hostname", "")
 307             # TODO: URI, LatLong, IP, DNS
 308
 309         elif (type == "user"):
 310             geni_info['email'] = record.pl_info.get("email", "")
 311             # TODO: PostalAddress, Phone
 312
 313         record.set_geni_info(geni_info)
 314
 315     ##
 316     # Given a Geni record, fill in the PLC-specific and Geni-specific fields
 317     # in the record.
 318
 319     def fill_record_info(self, record):
 320         self.fill_record_pl_info(record)
 321         self.fill_record_geni_info(record)
 322
 323     def update_membership_list(self, oldRecord, record, listName, addFunc, delFunc):
 324         # get a list of the HRNs tht are members of the old and new records\r
 325         if oldRecord:\r
 326             if oldRecord.pl_info == None:\r
 327                 oldRecord.pl_info = {}\r
 328             oldList = oldRecord.get_geni_info().get(listName, [])\r
 329         else:\r
 330             oldList = []\r
 331         newList = record.get_geni_info().get(listName, [])\r
 332 \r
 333         # if the lists are the same, then we don't have to update anything\r
 334         if (oldList == newList):\r
 335             return\r
 336 \r
 337         # build a list of the new person ids, by looking up each person to get\r
 338         # their pointer\r
 339         newIdList = []\r
 340         for hrn in newList:\r
 341             userRecord = self.resolve_raw("user", hrn)[0]\r
 342             newIdList.append(userRecord.get_pointer())\r
 343 \r
 344         # build a list of the old person ids from the person_ids field of the\r
 345         # pl_info\r
 346         if oldRecord:\r
 347             oldIdList = oldRecord.pl_info.get("person_ids", [])\r
 348             containerId = oldRecord.get_pointer()\r
 349         else:\r
 350             # if oldRecord==None, then we are doing a Register, instead of an\r
 351             # update.\r
 352             oldIdList = []\r
 353             containerId = record.get_pointer()\r
 354 \r
 355         # add people who are in the new list, but not the oldList\r
 356         for personId in newIdList:\r
 357             if not (personId in oldIdList):\r
 358                 print "adding id", personId, "to", record.get_name()\r
 359                 addFunc(self.pl_auth, personId, containerId)\r
 360 \r
 361         # remove people who are in the old list, but not the new list\r
 362         for personId in oldIdList:\r
 363             if not (personId in newIdList):\r
 364                 print "removing id", personId, "from", record.get_name()\r
 365                 delFunc(self.pl_auth, personId, containerId)\r
 366 \r
 367     def update_membership(self, oldRecord, record):\r
 368         if record.type == "slice":\r
 369             self.update_membership_list(oldRecord, record, 'researcher',\r
 370                                         self.shell.AddPersonToSlice,\r
 371                                         self.shell.DeletePersonFromSlice)\r
 372         elif record.type == "sa":\r
 373             # TODO\r
 374             pass\r
 375         elif record.type == "ma":\r
 376             # TODO\r
 377             pass
 378
 379     ##
 380     # GENI API: register
 381     #
 382     # Register an object with the registry. In addition to being stored in the
 383     # Geni database, the appropriate records will also be created in the
 384     # PLC databases
 385     #
 386     # @param cred credential string
 387     # @param record_dict dictionary containing record fields
 388
 389     def register(self, cred, record_dict):
 390         self.decode_authentication(cred, "register")
 391
 392         record = GeniRecord(dict = record_dict)
 393         type = record.get_type()
 394         name = record.get_name()
 395
 396         auth_name = get_authority(name)
 397         self.verify_object_permission(auth_name)
 398         auth_info = self.get_auth_info(auth_name)
 399         table = self.get_auth_table(auth_name)
 400
 401         pkey = None
 402
 403         # check if record already exists
 404         existing_records = table.resolve(type, name)
 405         if existing_records:
 406             raise ExistingRecord(name)
 407
 408         if (type == "sa") or (type=="ma"):
 409             # update the tree
 410             if not self.hierarchy.auth_exists(name):
 411                 self.hierarchy.create_auth(name)
 412
 413             # authorities are special since they are managed by the registry
 414             # rather than by the caller. We create our own GID for the
 415             # authority rather than relying on the caller to supply one.
 416
 417             # get the GID from the newly created authority
 418             child_auth_info = self.get_auth_info(name)
 419             gid = auth_info.get_gid_object()
 420             record.set_gid(gid.save_to_string(save_parents=True))
 421
 422             geni_fields = record.get_geni_info()
 423             site_fields = record.get_pl_info()
 424
 425             # if registering a sa, see if a ma already exists
 426             # if registering a ma, see if a sa already exists
 427             if (type == "sa"):
 428                 other_rec = table.resolve("ma", record.get_name())
 429             elif (type == "ma"):
 430                 other_rec = table.resolve("sa", record.get_name())
 431
 432             if other_rec:
 433                 print "linking ma and sa to the same plc site"
 434                 pointer = other_rec[0].get_pointer()
 435             else:
 436                 geni_fields_to_pl_fields(type, name, geni_fields, site_fields)
 437                 print "adding site with fields", site_fields
 438                 pointer = self.shell.AddSite(self.pl_auth, site_fields)
 439
 440             record.set_pointer(pointer)
 441
 442         elif (type == "slice"):
 443             geni_fields = record.get_geni_info()
 444             slice_fields = record.get_pl_info()
 445
 446             geni_fields_to_pl_fields(type, name, geni_fields, slice_fields)
 447
 448             pointer = self.shell.AddSlice(self.pl_auth, slice_fields)
 449             record.set_pointer(pointer)
 450
 451         elif (type == "user"):
 452             geni_fields = record.get_geni_info()
 453             user_fields = record.get_pl_info()
 454
 455             geni_fields_to_pl_fields(type, name, geni_fields, user_fields)
 456
 457             pointer = self.shell.AddPerson(self.pl_auth, user_fields)
 458             record.set_pointer(pointer)
 459
 460         elif (type == "node"):
 461             geni_fields = record.get_geni_info()
 462             node_fields = record.get_pl_info()
 463
 464             geni_fields_to_pl_fields(type, name, geni_fields, node_fields)
 465
 466             login_base = hrn_to_pl_login_base(auth_name)
 467
 468             print "calling addnode with", login_base, node_fields
 469             pointer = self.shell.AddNode(self.pl_auth, login_base, node_fields)
 470             record.set_pointer(pointer)
 471
 472         else:
 473             raise UnknownGeniType(type)
 474
 475         table.insert(record)
 476
 477         # update membership for researchers, pis, owners, operators
 478         self.update_membership(None, record)
 479
 480         return record.get_gid_object().save_to_string(save_parents=True)
 481
 482     ##
 483     # GENI API: remove
 484     #
 485     # Remove an object from the registry. If the object represents a PLC object,
 486     # then the PLC records will also be removed.
 487     #
 488     # @param cred credential string
 489     # @param record_dict dictionary containing record fields. The only relevant
 490     #     fields of the record are 'name' and 'type', which are used to lookup
 491     #     the current copy of the record in the Geni database, to make sure
 492     #     that the appopriate record is removed.
 493
 494     def remove(self, cred, type, hrn):
 495         self.decode_authentication(cred, "remove")
 496
 497         self.verify_object_permission(hrn)
 498
 499         auth_name = get_authority(hrn)
 500         table = self.get_auth_table(auth_name)
 501
 502         record_list = table.resolve(type, hrn)
 503         if not record_list:
 504             raise RecordNotFound(hrn)
 505         record = record_list[0]
 506
 507         # TODO: sa, ma
 508         if type == "user":
 509             self.shell.DeletePerson(self.pl_auth, record.get_pointer())
 510         elif type == "slice":
 511             self.shell.DeleteSlice(self.pl_auth, record.get_pointer())
 512         elif type == "node":
 513             self.shell.DeleteNode(self.pl_auth, record.get_pointer())
 514         elif (type == "sa") or (type == "ma"):
 515             if (type == "sa"):
 516                 other_rec = table.resolve("ma", record.get_name())
 517             elif (type == "ma"):
 518                 other_rec = table.resolve("sa", record.get_name())
 519
 520             if other_rec:
 521                 # sa and ma both map to a site, so if we are deleting one
 522                 # but the other still exists, then do not delete the site
 523                 print "not removing site", record.get_name(), "because either sa or ma still exists"
 524                 pass
 525             else:
 526                 print "removing site", record.get_name()
 527                 self.shell.DeleteSite(self.pl_auth, record.get_pointer())
 528         else:
 529             raise UnknownGeniType(type)
 530
 531         table.remove(record)
 532
 533         return True
 534
 535     ##
 536     # GENI API: Update
 537     #
 538     # Update an object in the registry. Currently, this only updates the
 539     # PLC information associated with the record. The Geni fields (name, type,
 540     # GID) are fixed.
 541     #
 542     # The record is expected to have the pl_info field filled in with the data
 543     # that should be updated.
 544     #
 545     # TODO: The geni_info member of the record should be parsed and the pl_info
 546     # adjusted as necessary (add/remove users from a slice, etc)
 547     #
 548     # @param cred credential string specifying rights of the caller
 549     # @param record a record dictionary to be updated
 550
 551     def update(self, cred, record_dict):
 552         self.decode_authentication(cred, "update")
 553
 554         record = GeniRecord(dict = record_dict)
 555         type = record.get_type()
 556
 557         self.verify_object_permission(record.get_name())
 558
 559         auth_name = get_authority(record.get_name())
 560         table = self.get_auth_table(auth_name)
 561
 562         # make sure the record exists
 563         existing_record_list = table.resolve(type, record.get_name())
 564         if not existing_record_list:
 565             raise RecordNotFound(record.get_name())
 566         existing_record = existing_record_list[0]
 567
 568         # Update_membership needs the membership lists in the existing record
 569         # filled in, so it can see if members were added or removed
 570         self.fill_record_info(existing_record)
 571
 572         # Use the pointer from the existing record, not the one that the user
 573         # gave us. This prevents the user from inserting a forged pointer
 574         pointer = existing_record.get_pointer()
 575
 576         # update the PLC information that was specified with the record
 577
 578         if (type == "sa") or (type == "ma"):
 579             self.shell.UpdateSite(self.pl_auth, pointer, record.get_pl_info())
 580
 581         elif type == "slice":
 582             self.shell.UpdateSlice(self.pl_auth, pointer, record.get_pl_info())
 583
 584         elif type == "user":
 585             # SMBAKER: UpdatePerson only allows a limited set of fields to be
 586             #    updated. Ideally we should have a more generic way of doing
 587             #    this. I copied the field names from UpdatePerson.py...
 588             update_fields = {}
 589             all_fields = record.get_pl_info()
 590             for key in all_fields.keys():
 591                 if key in ['first_name', 'last_name', 'title', 'email',
 592                            'password', 'phone', 'url', 'bio', 'accepted_aup',\r
 593                            'enabled']:
 594                     update_fields[key] = all_fields[key]
 595             self.shell.UpdatePerson(self.pl_auth, pointer, update_fields)
 596
 597         elif type == "node":
 598             self.shell.UpdateNode(self.pl_auth, pointer, record.get_pl_info())
 599
 600         else:
 601             raise UnknownGeniType(type)
 602
 603         # update membership for researchers, pis, owners, operators\r
 604         self.update_membership(existing_record, record)
 605
 606     ##
 607     # List the records in an authority. The objectGID in the supplied credential
 608     # should name the authority that will be listed.
 609     #
 610     # TODO: List doesn't take an hrn and uses the hrn contained in the
 611     #    objectGid of the credential. Does this mean the only way to list an
 612     #    authority is by having a credential for that authority?
 613     #
 614     # @param cred credential string specifying rights of the caller
 615     #
 616     # @return list of record dictionaries
 617     def list(self, cred, auth_hrn):
 618         self.decode_authentication(cred, "list")
 619
 620         if not self.hierarchy.auth_exists(auth_hrn):
 621             raise MissingAuthority(auth_hrn)
 622
 623         table = self.get_auth_table(auth_hrn)
 624
 625         records = table.list()
 626
 627         good_records = []
 628         for record in records:
 629             try:
 630                 self.fill_record_info(record)
 631                 good_records.append(record)
 632             except PlanetLabRecordDoesNotExist:
 633                 # silently drop the ones that are missing in PL.
 634                 # is this the right thing to do?
 635                 print "ignoring geni record ", record.get_name(), " because pl record does not exist"
 636                 table.remove(record)
 637
 638         dicts = []
 639         for record in good_records:
 640             dicts.append(record.as_dict())
 641
 642         return dicts
 643
 644         return dict_list
 645
 646     ##
 647     # Resolve a record. This is an internal version of the Resolve API call
 648     # and returns records in record object format rather than dictionaries
 649     # that may be sent over XMLRPC.
 650     #
 651     # @param type type of record to resolve (user | sa | ma | slice | node)
 652     # @param name human readable name of object
 653     # @param must_exist if True, throw an exception if no records are found
 654     #
 655     # @return a list of record objects, or an empty list []
 656
 657     def resolve_raw(self, type, name, must_exist=True):
 658         auth_name = get_authority(name)
 659
 660         table = self.get_auth_table(auth_name)
 661
 662         records = table.resolve(type, name)
 663
 664         if (not records) and must_exist:
 665             raise RecordNotFound(name)
 666
 667         good_records = []
 668         for record in records:
 669             try:
 670                 self.fill_record_info(record)
 671                 good_records.append(record)
 672             except PlanetLabRecordDoesNotExist:
 673                 # silently drop the ones that are missing in PL.
 674                 # is this the right thing to do?
 675                 print "ignoring geni record ", record.get_name(), "because pl record does not exist"
 676                 table.remove(record)
 677
 678         return good_records
 679
 680     ##
 681     # GENI API: Resolve
 682     #
 683     # This is a wrapper around resolve_raw that converts records objects into
 684     # dictionaries before returning them to the user.
 685     #
 686     # @param cred credential string authorizing the caller
 687     # @param name human readable name to resolve
 688     #
 689     # @return a list of record dictionaries, or an empty list
 690
 691     def resolve(self, cred, name):
 692         self.decode_authentication(cred, "resolve")
 693
 694         records = self.resolve_raw("*", name)
 695         dicts = []
 696         for record in records:
 697             dicts.append(record.as_dict())
 698
 699         return dicts
 700
 701     ##
 702     # GENI API: get_gid
 703     #
 704     # Retrieve the GID for an object. This function looks up a record in the
 705     # registry and returns the GID of the record if it exists.
 706     # TODO: Is this function needed? It's a shortcut for Resolve()
 707     #
 708     # @param name hrn to look up
 709     #
 710     # @return the string representation of a GID object
 711
 712     def get_gid(self, name):
 713         self.verify_object_belongs_to_me(name)
 714         records = self.resolve_raw("*", name)
 715         gid_string_list = []
 716         for record in records:
 717             gid = record.get_gid()
 718             gid_string_list.append(gid.save_to_string(save_parents=True))
 719         return gid_string_list
 720
 721     ##
 722     # Determine tje rights that an object should have. The rights are entirely
 723     # dependent on the type of the object. For example, users automatically
 724     # get "refresh", "resolve", and "info".
 725     #
 726     # @param type the type of the object (user | sa | ma | slice | node)
 727     # @param name human readable name of the object (not used at this time)
 728     #
 729     # @return RightList object containing rights
 730
 731     def determine_rights(self, type, name):
 732         rl = RightList()
 733
 734         # rights seem to be somewhat redundant with the type of the credential.
 735         # For example, a "sa" credential implies the authority right, because
 736         # a sa credential cannot be issued to a user who is not an owner of
 737         # the authority
 738
 739         if type == "user":
 740             rl.add("refresh")
 741             rl.add("resolve")
 742             rl.add("info")
 743         elif type == "sa":
 744             rl.add("authority,sa")
 745         elif type == "ma":
 746             rl.add("authority,ma")
 747         elif type == "slice":
 748             rl.add("refresh")
 749             rl.add("embed")
 750             rl.add("bind")
 751             rl.add("control")
 752             rl.add("info")
 753         elif type == "component":
 754             rl.add("operator")
 755
 756         return rl
 757
 758     ##
 759     # GENI API: Get_self_credential
 760     #
 761     # Get_self_credential a degenerate version of get_credential used by a
 762     # client to get his initial credential when he doesn't have one. This is
 763     # the same as get_credential(..., cred=None,...).
 764     #
 765     # The registry ensures that the client is the principal that is named by
 766     # (type, name) by comparing the public key in the record's GID to the
 767     # private key used to encrypt the client-side of the HTTPS connection. Thus
 768     # it is impossible for one principal to retrieve another principal's
 769     # credential without having the appropriate private key.
 770     #
 771     # @param type type of object (user | slice | sa | ma | node
 772     # @param name human readable name of object
 773     #
 774     # @return the string representation of a credential object
 775
 776     def get_self_credential(self, type, name):
 777         self.verify_object_belongs_to_me(name)
 778
 779         auth_hrn = get_authority(name)
 780         auth_info = self.get_auth_info(auth_hrn)
 781
 782         # find a record that matches
 783         records = self.resolve_raw(type, name, must_exist=True)
 784         record = records[0]
 785
 786         gid = record.get_gid_object()
 787         peer_cert = self.server.peer_cert
 788         if not peer_cert.is_pubkey(gid.get_pubkey()):
 789            raise ConnectionKeyGIDMismatch(gid.get_subject())
 790
 791         # create the credential
 792         gid = record.get_gid_object()
 793         cred = Credential(subject = gid.get_subject())
 794         cred.set_gid_caller(gid)
 795         cred.set_gid_object(gid)
 796         cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 797         cred.set_pubkey(gid.get_pubkey())
 798
 799         rl = self.determine_rights(type, name)
 800         cred.set_privileges(rl)
 801
 802         # determine the type of credential that we want to use as a parent for
 803         # this credential.
 804
 805         if (type == "ma") or (type == "node"):
 806             auth_kind = "authority,ma"
 807         else: # user, slice, sa
 808             auth_kind = "authority,sa"
 809
 810         cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
 811
 812         cred.encode()
 813         cred.sign()
 814
 815         return cred.save_to_string(save_parents=True)
 816
 817     ##
 818     # verify_cancreate_credential
 819     #
 820     # Verify that a user can retrieve a particular type of credential. For
 821     # slices, the user must be on the researcher list. For SA and MA the user
 822     # must be on the pi and operator lists respectively.
 823
 824     def verify_cancreate_credential(self, src_cred, record):
 825         type = record.get_type()
 826         cred_object_hrn = src_cred.get_gid_object().get_hrn()
 827         if type=="slice":
 828             researchers = record.get_geni_info().get("researcher", [])
 829             if not (cred_object_hrn in researchers):
 830                 raise PermissionError(cred_object_hrn + " is not in researcher list for " + record.get_name())
 831         elif type == "sa":
 832             pis = record.get_geni_info().get("pi", [])
 833             if not (cred_object_hrn in pis):
 834                 raise PermissionError(cred_object_hrn + " is not in pi list for " + record.get_name())
 835         elif type == "ma":
 836             operators = record.get_geni_info().get("operator", [])
 837             if not (cred_object_hrn in operators):
 838                 raise PermissionError(cred_object_hrn + " is not in operator list for " + record.get_name())
 839
 840     ##
 841     # GENI API: Get_credential
 842     #
 843     # Retrieve a credential for an object.
 844     #
 845     # If cred==None, then the behavior reverts to get_self_credential()
 846     #
 847     # @param cred credential object specifying rights of the caller
 848     # @param type type of object (user | slice | sa | ma | node)
 849     # @param name human readable name of object
 850     #
 851     # @return the string representation of a credental object
 852
 853     def get_credential(self, cred, type, name):
 854         if not cred:
 855             return get_self_credential(self, type, name)
 856
 857         self.decode_authentication(cred, "getcredential")
 858
 859         self.verify_object_belongs_to_me(name)
 860
 861         auth_hrn = get_authority(name)
 862         auth_info = self.get_auth_info(auth_hrn)
 863
 864         records = self.resolve_raw(type, name, must_exist=True)
 865         record = records[0]
 866
 867         # verify_cancreate_credential requires that the member lists
 868         # (researchers, pis, etc) be filled in
 869         self.fill_record_info(record)
 870
 871         self.verify_cancreate_credential(self.client_cred, record)
 872
 873         # TODO: Check permission that self.client_cred can access the object
 874
 875         object_gid = record.get_gid_object()
 876         new_cred = Credential(subject = object_gid.get_subject())
 877         new_cred.set_gid_caller(self.client_gid)
 878         new_cred.set_gid_object(object_gid)
 879         new_cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 880         new_cred.set_pubkey(object_gid.get_pubkey())
 881
 882         rl = self.determine_rights(type, name)
 883         new_cred.set_privileges(rl)
 884
 885         # determine the type of credential that we want to use as a parent for
 886         # this credential.
 887
 888         if (type == "ma") or (type == "node"):
 889             auth_kind = "authority,ma"
 890         else: # user, slice, sa
 891             auth_kind = "authority,sa"
 892
 893         new_cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
 894
 895         new_cred.encode()
 896         new_cred.sign()
 897
 898         return new_cred.save_to_string(save_parents=True)
 899
 900     ##
 901     # GENI API: get_ticket
 902     #
 903     # Retrieve a ticket. This operation is currently implemented on PLC
 904     # only (see SFA, engineering decisions); it is not implemented on
 905     # components.
 906     #
 907     # The ticket is filled in with information from the PLC database. This
 908     # information includes resources, and attributes such as user keys and
 909     # initscripts.
 910     #
 911     # @param cred credential string
 912     # @param name name of the slice to retrieve a ticket for
 913     # @param rspec resource specification dictionary
 914     #
 915     # @return the string representation of a ticket object
 916
 917     def get_ticket(self, cred, name, rspec):
 918         self.decode_authentication(cred, "getticket")
 919
 920         self.verify_object_belongs_to_me(name)
 921
 922         self.verify_object_permission(name)
 923
 924         # XXX much of this code looks like get_credential... are they so similar
 925         # that they should be combined?
 926
 927         auth_hrn = get_authority(name)
 928         auth_info = self.get_auth_info(auth_hrn)
 929
 930         records = self.resolve_raw("slice", name, must_exist=True)
 931         record = records[0]
 932
 933         object_gid = record.get_gid_object()
 934         new_ticket = Ticket(subject = object_gid.get_subject())
 935         new_ticket.set_gid_caller(self.client_gid)
 936         new_ticket.set_gid_object(object_gid)
 937         new_ticket.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 938         new_ticket.set_pubkey(object_gid.get_pubkey())
 939
 940         self.fill_record_info(record)
 941
 942         (attributes, rspec) = self.record_to_slice_info(record)
 943
 944         new_ticket.set_attributes(attributes)
 945         new_ticket.set_rspec(rspec)
 946
 947         new_ticket.set_parent(AuthHierarchy.get_auth_ticket(auth_hrn))
 948
 949         new_ticket.encode()
 950         new_ticket.sign()
 951
 952         return new_ticket.save_to_string(save_parents=True)
 953
 954     ##
 955     # GENI_API: Create_gid
 956     #
 957     # Create a new GID. For MAs and SAs that are physically located on the
 958     # registry, this allows a owner/operator/PI to create a new GID and have it
 959     # signed by his respective authority.
 960     #
 961     # @param cred credential of caller
 962     # @param name hrn for new GID
 963     # @param uuid unique identifier for new GID
 964     # @param pkey_string public-key string (TODO: why is this a string and not a keypair object?)
 965     #
 966     # @return the string representation of a GID object
 967
 968     def create_gid(self, cred, name, uuid, pubkey_str):
 969         self.decode_authentication(cred, "getcredential")
 970
 971         self.verify_object_belongs_to_me(name)
 972
 973         self.verify_object_permission(name)
 974
 975         if uuid == None:
 976             uuid = create_uuid()
 977
 978         pkey = Keypair()
 979         pkey.load_pubkey_from_string(pubkey_str)
 980         gid = self.hierarchy.create_gid(name, uuid, pkey)
 981
 982         return gid.save_to_string(save_parents=True)
 983