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
 567         existing_record = existing_record_list[0]
 568         pointer = existing_record.get_pointer()
 569
 570         # update the PLC information that was specified with the record
 571
 572         if (type == "sa") or (type == "ma"):
 573             self.shell.UpdateSite(self.pl_auth, pointer, record.get_pl_info())
 574
 575         elif type == "slice":
 576             self.shell.UpdateSlice(self.pl_auth, pointer, record.get_pl_info())
 577
 578         elif type == "user":
 579             # SMBAKER: UpdatePerson only allows a limited set of fields to be
 580             #    updated. Ideally we should have a more generic way of doing
 581             #    this. I copied the field names from UpdatePerson.py...
 582             update_fields = {}
 583             all_fields = record.get_pl_info()
 584             for key in all_fields.keys():
 585                 if key in ['first_name', 'last_name', 'title', 'email',
 586                            'password', 'phone', 'url', 'bio', 'accepted_aup',\r
 587                            'enabled']:
 588                     update_fields[key] = all_fields[key]
 589             self.shell.UpdatePerson(self.pl_auth, pointer, update_fields)
 590
 591         elif type == "node":
 592             self.shell.UpdateNode(self.pl_auth, pointer, record.get_pl_info())
 593
 594         else:
 595             raise UnknownGeniType(type)
 596
 597         # update membership for researchers, pis, owners, operators\r
 598         self.update_membership(existing_record, record)
 599
 600     ##
 601     # List the records in an authority. The objectGID in the supplied credential
 602     # should name the authority that will be listed.
 603     #
 604     # TODO: List doesn't take an hrn and uses the hrn contained in the
 605     #    objectGid of the credential. Does this mean the only way to list an
 606     #    authority is by having a credential for that authority?
 607     #
 608     # @param cred credential string specifying rights of the caller
 609     #
 610     # @return list of record dictionaries
 611     def list(self, cred, auth_hrn):
 612         self.decode_authentication(cred, "list")
 613
 614         if not self.hierarchy.auth_exists(auth_hrn):
 615             raise MissingAuthority(auth_hrn)
 616
 617         table = self.get_auth_table(auth_hrn)
 618
 619         records = table.list()
 620
 621         good_records = []
 622         for record in records:
 623             try:
 624                 self.fill_record_info(record)
 625                 good_records.append(record)
 626             except PlanetLabRecordDoesNotExist:
 627                 # silently drop the ones that are missing in PL.
 628                 # is this the right thing to do?
 629                 print "ignoring geni record ", record.get_name(), " because pl record does not exist"
 630                 table.remove(record)
 631
 632         dicts = []
 633         for record in good_records:
 634             dicts.append(record.as_dict())
 635
 636         return dicts
 637
 638         return dict_list
 639
 640     ##
 641     # Resolve a record. This is an internal version of the Resolve API call
 642     # and returns records in record object format rather than dictionaries
 643     # that may be sent over XMLRPC.
 644     #
 645     # @param type type of record to resolve (user | sa | ma | slice | node)
 646     # @param name human readable name of object
 647     # @param must_exist if True, throw an exception if no records are found
 648     #
 649     # @return a list of record objects, or an empty list []
 650
 651     def resolve_raw(self, type, name, must_exist=True):
 652         auth_name = get_authority(name)
 653
 654         table = self.get_auth_table(auth_name)
 655
 656         records = table.resolve(type, name)
 657
 658         if (not records) and must_exist:
 659             raise RecordNotFound(name)
 660
 661         good_records = []
 662         for record in records:
 663             try:
 664                 self.fill_record_info(record)
 665                 good_records.append(record)
 666             except PlanetLabRecordDoesNotExist:
 667                 # silently drop the ones that are missing in PL.
 668                 # is this the right thing to do?
 669                 print "ignoring geni record ", record.get_name(), "because pl record does not exist"
 670                 table.remove(record)
 671
 672         return good_records
 673
 674     ##
 675     # GENI API: Resolve
 676     #
 677     # This is a wrapper around resolve_raw that converts records objects into
 678     # dictionaries before returning them to the user.
 679     #
 680     # @param cred credential string authorizing the caller
 681     # @param name human readable name to resolve
 682     #
 683     # @return a list of record dictionaries, or an empty list
 684
 685     def resolve(self, cred, name):
 686         self.decode_authentication(cred, "resolve")
 687
 688         records = self.resolve_raw("*", name)
 689         dicts = []
 690         for record in records:
 691             dicts.append(record.as_dict())
 692
 693         return dicts
 694
 695     ##
 696     # GENI API: get_gid
 697     #
 698     # Retrieve the GID for an object. This function looks up a record in the
 699     # registry and returns the GID of the record if it exists.
 700     # TODO: Is this function needed? It's a shortcut for Resolve()
 701     #
 702     # @param name hrn to look up
 703     #
 704     # @return the string representation of a GID object
 705
 706     def get_gid(self, name):
 707         self.verify_object_belongs_to_me(name)
 708         records = self.resolve_raw("*", name)
 709         gid_string_list = []
 710         for record in records:
 711             gid = record.get_gid()
 712             gid_string_list.append(gid.save_to_string(save_parents=True))
 713         return gid_string_list
 714
 715     ##
 716     # Determine tje rights that an object should have. The rights are entirely
 717     # dependent on the type of the object. For example, users automatically
 718     # get "refresh", "resolve", and "info".
 719     #
 720     # @param type the type of the object (user | sa | ma | slice | node)
 721     # @param name human readable name of the object (not used at this time)
 722     #
 723     # @return RightList object containing rights
 724
 725     def determine_rights(self, type, name):
 726         rl = RightList()
 727
 728         # rights seem to be somewhat redundant with the type of the credential.
 729         # For example, a "sa" credential implies the authority right, because
 730         # a sa credential cannot be issued to a user who is not an owner of
 731         # the authority
 732
 733         if type == "user":
 734             rl.add("refresh")
 735             rl.add("resolve")
 736             rl.add("info")
 737         elif type == "sa":
 738             rl.add("authority,sa")
 739         elif type == "ma":
 740             rl.add("authority,ma")
 741         elif type == "slice":
 742             rl.add("refresh")
 743             rl.add("embed")
 744             rl.add("bind")
 745             rl.add("control")
 746             rl.add("info")
 747         elif type == "component":
 748             rl.add("operator")
 749
 750         return rl
 751
 752     ##
 753     # GENI API: Get_self_credential
 754     #
 755     # Get_self_credential a degenerate version of get_credential used by a
 756     # client to get his initial credential when he doesn't have one. This is
 757     # the same as get_credential(..., cred=None,...).
 758     #
 759     # The registry ensures that the client is the principal that is named by
 760     # (type, name) by comparing the public key in the record's GID to the
 761     # private key used to encrypt the client-side of the HTTPS connection. Thus
 762     # it is impossible for one principal to retrieve another principal's
 763     # credential without having the appropriate private key.
 764     #
 765     # @param type type of object (user | slice | sa | ma | node
 766     # @param name human readable name of object
 767     #
 768     # @return the string representation of a credential object
 769
 770     def get_self_credential(self, type, name):
 771         self.verify_object_belongs_to_me(name)
 772
 773         auth_hrn = get_authority(name)
 774         auth_info = self.get_auth_info(auth_hrn)
 775
 776         # find a record that matches
 777         records = self.resolve_raw(type, name, must_exist=True)
 778         record = records[0]
 779
 780         gid = record.get_gid_object()
 781         peer_cert = self.server.peer_cert
 782         if not peer_cert.is_pubkey(gid.get_pubkey()):
 783            raise ConnectionKeyGIDMismatch(gid.get_subject())
 784
 785         # create the credential
 786         gid = record.get_gid_object()
 787         cred = Credential(subject = gid.get_subject())
 788         cred.set_gid_caller(gid)
 789         cred.set_gid_object(gid)
 790         cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 791         cred.set_pubkey(gid.get_pubkey())
 792
 793         rl = self.determine_rights(type, name)
 794         cred.set_privileges(rl)
 795
 796         # determine the type of credential that we want to use as a parent for
 797         # this credential.
 798
 799         if (type == "ma") or (type == "node"):
 800             auth_kind = "authority,ma"
 801         else: # user, slice, sa
 802             auth_kind = "authority,sa"
 803
 804         cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
 805
 806         cred.encode()
 807         cred.sign()
 808
 809         return cred.save_to_string(save_parents=True)
 810
 811     ##
 812     # GENI API: Get_credential
 813     #
 814     # Retrieve a credential for an object.
 815     #
 816     # If cred==None, then the behavior reverts to get_self_credential()
 817     #
 818     # @param cred credential object specifying rights of the caller
 819     # @param type type of object (user | slice | sa | ma | node)
 820     # @param name human readable name of object
 821     #
 822     # @return the string representation of a credental object
 823
 824     def get_credential(self, cred, type, name):
 825         if not cred:
 826             return get_self_credential(self, type, name)
 827
 828         self.decode_authentication(cred, "getcredential")
 829
 830         self.verify_object_belongs_to_me(name)
 831
 832         auth_hrn = get_authority(name)
 833         auth_info = self.get_auth_info(auth_hrn)
 834
 835         records = self.resolve_raw(type, name, must_exist=True)
 836         record = records[0]
 837
 838         # TODO: Check permission that self.client_cred can access the object
 839
 840         object_gid = record.get_gid_object()
 841         new_cred = Credential(subject = object_gid.get_subject())
 842         new_cred.set_gid_caller(self.client_gid)
 843         new_cred.set_gid_object(object_gid)
 844         new_cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 845         new_cred.set_pubkey(object_gid.get_pubkey())
 846
 847         rl = self.determine_rights(type, name)
 848         new_cred.set_privileges(rl)
 849
 850         # determine the type of credential that we want to use as a parent for
 851         # this credential.
 852
 853         if (type == "ma") or (type == "node"):
 854             auth_kind = "authority,ma"
 855         else: # user, slice, sa
 856             auth_kind = "authority,sa"
 857
 858         new_cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
 859
 860         new_cred.encode()
 861         new_cred.sign()
 862
 863         return new_cred.save_to_string(save_parents=True)
 864
 865     ##
 866     # GENI API: get_ticket
 867     #
 868     # Retrieve a ticket. This operation is currently implemented on PLC
 869     # only (see SFA, engineering decisions); it is not implemented on
 870     # components.
 871     #
 872     # The ticket is filled in with information from the PLC database. This
 873     # information includes resources, and attributes such as user keys and
 874     # initscripts.
 875     #
 876     # @param cred credential string
 877     # @param name name of the slice to retrieve a ticket for
 878     # @param rspec resource specification dictionary
 879     #
 880     # @return the string representation of a ticket object
 881
 882     def get_ticket(self, cred, name, rspec):
 883         self.decode_authentication(cred, "getticket")
 884
 885         self.verify_object_belongs_to_me(name)
 886
 887         self.verify_object_permission(name)
 888
 889         # XXX much of this code looks like get_credential... are they so similar
 890         # that they should be combined?
 891
 892         auth_hrn = get_authority(name)
 893         auth_info = self.get_auth_info(auth_hrn)
 894
 895         records = self.resolve_raw("slice", name, must_exist=True)
 896         record = records[0]
 897
 898         object_gid = record.get_gid_object()
 899         new_ticket = Ticket(subject = object_gid.get_subject())
 900         new_ticket.set_gid_caller(self.client_gid)
 901         new_ticket.set_gid_object(object_gid)
 902         new_ticket.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 903         new_ticket.set_pubkey(object_gid.get_pubkey())
 904
 905         self.fill_record_info(record)
 906
 907         (attributes, rspec) = self.record_to_slice_info(record)
 908
 909         new_ticket.set_attributes(attributes)
 910         new_ticket.set_rspec(rspec)
 911
 912         new_ticket.set_parent(AuthHierarchy.get_auth_ticket(auth_hrn))
 913
 914         new_ticket.encode()
 915         new_ticket.sign()
 916
 917         return new_ticket.save_to_string(save_parents=True)
 918
 919     ##
 920     # GENI_API: Create_gid
 921     #
 922     # Create a new GID. For MAs and SAs that are physically located on the
 923     # registry, this allows a owner/operator/PI to create a new GID and have it
 924     # signed by his respective authority.
 925     #
 926     # @param cred credential of caller
 927     # @param name hrn for new GID
 928     # @param uuid unique identifier for new GID
 929     # @param pkey_string public-key string (TODO: why is this a string and not a keypair object?)
 930     #
 931     # @return the string representation of a GID object
 932
 933     def create_gid(self, cred, name, uuid, pubkey_str):
 934         self.decode_authentication(cred, "getcredential")
 935
 936         self.verify_object_belongs_to_me(name)
 937
 938         self.verify_object_permission(name)
 939
 940         if uuid == None:
 941             uuid = create_uuid()
 942
 943         pkey = Keypair()
 944         pkey.load_pubkey_from_string(pubkey_str)
 945         gid = self.hierarchy.create_gid(name, uuid, pkey)
 946
 947         return gid.save_to_string(save_parents=True)
 948