plc/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 util.credential import Credential
  10 from util.hierarchy import Hierarchy
  11 from util.trustedroot import TrustedRootList
  12 from util.cert import Keypair, Certificate
  13 from util.gid import GID, create_uuid
  14 from util.geniserver import GeniServer
  15 from util.record import GeniRecord
  16 from util.rights import RightList
  17 from util.genitable import GeniTable
  18 from util.geniticket import Ticket
  19 from util.excep import *
  20 from util.misc import *
  21
  22 from util.config import *
  23
  24 ##
  25 # Convert geni fields to PLC fields for use when registering up updating
  26 # registry record in the PLC database
  27 #
  28 # @param type type of record (user, slice, ...)
  29 # @param hrn human readable name
  30 # @param geni_fields dictionary of geni fields
  31 # @param pl_fields dictionary of PLC fields (output)
  32
  33 def geni_fields_to_pl_fields(type, hrn, geni_fields, pl_fields):
  34     if type == "user":
  35         if not "email" in pl_fields:
  36             if not "email" in geni_fields:
  37                 raise MissingGeniInfo("email")
  38             pl_fields["email"] = geni_fields["email"]
  39
  40         if not "first_name" in pl_fields:
  41             pl_fields["first_name"] = "geni"
  42
  43         if not "last_name" in pl_fields:
  44             pl_fields["last_name"] = hrn
  45
  46     elif type == "slice":
  47         if not "instantiation" in pl_fields:
  48             pl_fields["instantiation"] = "delegated"  # "plc-instantiated"
  49         if not "name" in pl_fields:
  50             pl_fields["name"] = hrn_to_pl_slicename(hrn)
  51         if not "max_nodes" in pl_fields:
  52             pl_fields["max_nodes"] = 10
  53
  54     elif type == "node":
  55         if not "hostname" in pl_fields:
  56             if not "dns" in geni_fields:
  57                 raise MissingGeniInfo("dns")
  58             pl_fields["hostname"] = geni_fields["dns"]
  59
  60         if not "model" in pl_fields:
  61             pl_fields["model"] = "geni"
  62
  63     elif type == "sa":
  64         pl_fields["login_base"] = hrn_to_pl_login_base(hrn)
  65
  66         if not "name" in pl_fields:
  67             pl_fields["name"] = hrn
  68
  69         if not "abbreviated_name" in pl_fields:
  70             pl_fields["abbreviated_name"] = hrn
  71
  72         if not "enabled" in pl_fields:
  73             pl_fields["enabled"] = True
  74
  75         if not "is_public" in pl_fields:
  76             pl_fields["is_public"] = True
  77
  78 ##
  79 # Registry is a GeniServer that serves registry and slice operations at PLC.
  80
  81 class Registry(GeniServer):
  82     ##
  83     # Create a new registry object.
  84     #
  85     # @param ip the ip address to listen on
  86     # @param port the port to listen on
  87     # @param key_file private key filename of registry
  88     # @param cert_file certificate filename containing public key (could be a GID file)
  89
  90     def __init__(self, ip, port, key_file, cert_file):
  91         GeniServer.__init__(self, ip, port, key_file, cert_file)
  92
  93         # get PL account settings from config module
  94         self.pl_auth = get_pl_auth()
  95
  96         # connect to planetlab
  97         if "Url" in self.pl_auth:
  98             self.connect_remote_shell()
  99         else:
 100             self.connect_local_shell()
 101
 102     ##
 103     # Connect to a remote shell via XMLRPC
 104
 105     def connect_remote_shell(self):
 106         import remoteshell
 107         self.shell = remoteshell.RemoteShell()
 108
 109     ##
 110     # Connect to a local shell via local API functions
 111
 112     def connect_local_shell(self):
 113         import PLC.Shell
 114         self.shell = PLC.Shell.Shell(globals = globals())
 115
 116     ##
 117     # Register the server RPCs for the registry
 118
 119     def register_functions(self):
 120         GeniServer.register_functions(self)
 121         # registry interface
 122         self.server.register_function(self.create_gid)
 123         self.server.register_function(self.get_self_credential)
 124         self.server.register_function(self.get_credential)
 125         self.server.register_function(self.get_gid)
 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     ##
 324     # GENI API: register
 325     #
 326     # Register an object with the registry. In addition to being stored in the
 327     # Geni database, the appropriate records will also be created in the
 328     # PLC databases
 329     #
 330     # @param cred credential string
 331     # @param record_dict dictionary containing record fields
 332
 333     def register(self, cred, record_dict):
 334         self.decode_authentication(cred, "register")
 335
 336         record = GeniRecord(dict = record_dict)
 337         type = record.get_type()
 338         name = record.get_name()
 339
 340         auth_name = get_authority(name)
 341         self.verify_object_permission(auth_name)
 342         auth_info = self.get_auth_info(auth_name)
 343         table = self.get_auth_table(auth_name)
 344
 345         pkey = None
 346
 347         # check if record already exists
 348         existing_records = table.resolve(type, name)
 349         if existing_records:
 350             raise ExistingRecord(name)
 351
 352         if (type == "sa") or (type=="ma"):
 353             # update the tree
 354             if not self.hierarchy.auth_exists(name):
 355                 self.hierarchy.create_auth(name)
 356
 357             # authorities are special since they are managed by the registry
 358             # rather than by the caller. We create our own GID for the
 359             # authority rather than relying on the caller to supply one.
 360
 361             # get the GID from the newly created authority
 362             child_auth_info = self.get_auth_info(name)
 363             gid = auth_info.get_gid_object()
 364             record.set_gid(gid.save_to_string(save_parents=True))
 365
 366             geni_fields = record.get_geni_info()
 367             site_fields = record.get_pl_info()
 368
 369             # if registering a sa, see if a ma already exists
 370             # if registering a ma, see if a sa already exists
 371             if (type == "sa"):
 372                 other_rec = table.resolve("ma", record.get_name())
 373             elif (type == "ma"):
 374                 other_rec = table.resolve("sa", record.get_name())
 375
 376             if other_rec:
 377                 print "linking ma and sa to the same plc site"
 378                 pointer = other_rec[0].get_pointer()
 379             else:
 380                 geni_fields_to_pl_fields(type, name, geni_fields, site_fields)
 381                 print "adding site with fields", site_fields
 382                 pointer = self.shell.AddSite(self.pl_auth, site_fields)
 383
 384             record.set_pointer(pointer)
 385
 386         elif (type == "slice"):
 387             geni_fields = record.get_geni_info()
 388             slice_fields = record.get_pl_info()
 389
 390             geni_fields_to_pl_fields(type, name, geni_fields, slice_fields)
 391
 392             pointer = self.shell.AddSlice(self.pl_auth, slice_fields)
 393             record.set_pointer(pointer)
 394
 395         elif (type == "user"):
 396             geni_fields = record.get_geni_info()
 397             user_fields = record.get_pl_info()
 398
 399             geni_fields_to_pl_fields(type, name, geni_fields, user_fields)
 400
 401             pointer = self.shell.AddPerson(self.pl_auth, user_fields)
 402             record.set_pointer(pointer)
 403
 404         elif (type == "node"):
 405             geni_fields = record.get_geni_info()
 406             node_fields = record.get_pl_info()
 407
 408             geni_fields_to_pl_fields(type, name, geni_fields, node_fields)
 409
 410             login_base = hrn_to_pl_login_base(auth_name)
 411
 412             print "calling addnode with", login_base, node_fields
 413             pointer = self.shell.AddNode(self.pl_auth, login_base, node_fields)
 414             record.set_pointer(pointer)
 415
 416         else:
 417             raise UnknownGeniType(type)
 418
 419         table.insert(record)
 420
 421         return record.get_gid_object().save_to_string(save_parents=True)
 422
 423     ##
 424     # GENI API: remove
 425     #
 426     # Remove an object from the registry. If the object represents a PLC object,
 427     # then the PLC records will also be removed.
 428     #
 429     # @param cred credential string
 430     # @param record_dict dictionary containing record fields. The only relevant
 431     #     fields of the record are 'name' and 'type', which are used to lookup
 432     #     the current copy of the record in the Geni database, to make sure
 433     #     that the appopriate record is removed.
 434
 435     def remove(self, cred, type, hrn):
 436         self.decode_authentication(cred, "remove")
 437
 438         self.verify_object_permission(hrn)
 439
 440         auth_name = get_authority(hrn)
 441         table = self.get_auth_table(auth_name)
 442
 443         record_list = table.resolve(type, hrn)
 444         if not record_list:
 445             raise RecordNotFound(name)
 446         record = record_list[0]
 447
 448         # TODO: sa, ma
 449         if type == "user":
 450             self.shell.DeletePerson(self.pl_auth, record.get_pointer())
 451         elif type == "slice":
 452             self.shell.DeleteSlice(self.pl_auth, record.get_pointer())
 453         elif type == "node":
 454             self.shell.DeleteNode(self.pl_auth, record.get_pointer())
 455         elif (type == "sa") or (type == "ma"):
 456             if (type == "sa"):
 457                 other_rec = table.resolve("ma", record.get_name())
 458             elif (type == "ma"):
 459                 other_rec = table.resolve("sa", record.get_name())
 460
 461             if other_rec:
 462                 # sa and ma both map to a site, so if we are deleting one
 463                 # but the other still exists, then do not delete the site
 464                 print "not removing site", record.get_name(), "because either sa or ma still exists"
 465                 pass
 466             else:
 467                 print "removing site", record.get_name()
 468                 self.shell.DeleteSite(self.pl_auth, record.get_pointer())
 469         else:
 470             raise UnknownGeniType(type)
 471
 472         table.remove(record)
 473
 474         return True
 475
 476     ##
 477     # GENI API: Register
 478     #
 479     # Update an object in the registry. Currently, this only updates the
 480     # PLC information associated with the record. The Geni fields (name, type,
 481     # GID) are fixed.
 482     #
 483     # The record is expected to have the pl_info field filled in with the data
 484     # that should be updated.
 485     #
 486     # TODO: The geni_info member of the record should be parsed and the pl_info
 487     # adjusted as necessary (add/remove users from a slice, etc)
 488     #
 489     # @param cred credential string specifying rights of the caller
 490     # @param record a record dictionary to be updated
 491
 492     def update(self, cred, record_dict):
 493         self.decode_authentication(cred, "update")
 494
 495         record = GeniRecord(dict = record_dict)
 496         type = record.get_type()
 497
 498         self.verify_object_permission(record.get_name())
 499
 500         auth_name = get_authority(record.get_name())
 501         table = self.get_auth_table(auth_name)
 502
 503         # make sure the record exists
 504         existing_record_list = table.resolve(type, record.get_name())
 505         if not existing_record_list:
 506             raise RecordNotFound(record.get_name())
 507
 508         existing_record = existing_record_list[0]
 509         pointer = existing_record.get_pointer()
 510
 511         # update the PLC information that was specified with the record
 512
 513         if (type == "sa") or (type == "ma"):
 514             self.shell.UpdateSite(self.pl_auth, pointer, record.get_pl_info())
 515
 516         elif type == "slice":
 517             self.shell.UpdateSlice(self.pl_auth, pointer, record.get_pl_info())
 518
 519         elif type == "user":
 520             # SMBAKER: UpdatePerson only allows a limited set of fields to be
 521             #    updated. Ideally we should have a more generic way of doing
 522             #    this. I copied the field names from UpdatePerson.py...
 523             update_fields = {}
 524             all_fields = record.get_pl_info()
 525             for key in all_fields.keys():
 526                 if key in ['first_name', 'last_name', 'title', 'email',
 527                            'password', 'phone', 'url', 'bio', 'accepted_aup',\r
 528                            'enabled']:
 529                     update_fields[key] = all_fields[key]
 530             self.shell.UpdatePerson(self.pl_auth, pointer, update_fields)
 531
 532         elif type == "node":
 533             self.shell.UpdateNode(self.pl_auth, pointer, record.get_pl_info())
 534
 535         else:
 536             raise UnknownGeniType(type)
 537
 538     ##
 539     # List the records in an authority. The objectGID in the supplied credential
 540     # should name the authority that will be listed.
 541     #
 542     # TODO: List doesn't take an hrn and uses the hrn contained in the
 543     #    objectGid of the credential. Does this mean the only way to list an
 544     #    authority is by having a credential for that authority?
 545     #
 546     # @param cred credential string specifying rights of the caller
 547     #
 548     # @return list of record dictionaries
 549     def list(self, cred, auth_hrn):
 550         self.decode_authentication(cred, "list")
 551
 552         if not self.hierarchy.auth_exists(auth_hrn):
 553             raise MissingAuthority(auth_hrn)
 554
 555         table = self.get_auth_table(auth_hrn)
 556
 557         records = table.list()
 558
 559         good_records = []
 560         for record in records:
 561             try:
 562                 self.fill_record_info(record)
 563                 good_records.append(record)
 564             except PlanetLabRecordDoesNotExist:
 565                 # silently drop the ones that are missing in PL.
 566                 # is this the right thing to do?
 567                 print "ignoring geni record ", record.get_name(), " because pl record does not exist"
 568                 table.remove(record)
 569
 570         dicts = []
 571         for record in good_records:
 572             dicts.append(record.as_dict())
 573
 574         return dicts
 575
 576         return dict_list
 577
 578     ##
 579     # Resolve a record. This is an internal version of the Resolve API call
 580     # and returns records in record object format rather than dictionaries
 581     # that may be sent over XMLRPC.
 582     #
 583     # @param type type of record to resolve (user | sa | ma | slice | node)
 584     # @param name human readable name of object
 585     # @param must_exist if True, throw an exception if no records are found
 586     #
 587     # @return a list of record objects, or an empty list []
 588
 589     def resolve_raw(self, type, name, must_exist=True):
 590         auth_name = get_authority(name)
 591
 592         table = self.get_auth_table(auth_name)
 593
 594         records = table.resolve(type, name)
 595
 596         if (not records) and must_exist:
 597             raise RecordNotFound(name)
 598
 599         good_records = []
 600         for record in records:
 601             try:
 602                 self.fill_record_info(record)
 603                 good_records.append(record)
 604             except PlanetLabRecordDoesNotExist:
 605                 # silently drop the ones that are missing in PL.
 606                 # is this the right thing to do?
 607                 print "ignoring geni record ", record.get_name(), "because pl record does not exist"
 608                 table.remove(record)
 609
 610         return good_records
 611
 612     ##
 613     # GENI API: Resolve
 614     #
 615     # This is a wrapper around resolve_raw that converts records objects into
 616     # dictionaries before returning them to the user.
 617     #
 618     # @param cred credential string authorizing the caller
 619     # @param name human readable name to resolve
 620     #
 621     # @return a list of record dictionaries, or an empty list
 622
 623     def resolve(self, cred, name):
 624         self.decode_authentication(cred, "resolve")
 625
 626         records = self.resolve_raw("*", name)
 627         dicts = []
 628         for record in records:
 629             dicts.append(record.as_dict())
 630
 631         return dicts
 632
 633     ##
 634     # GENI API: get_gid
 635     #
 636     # Retrieve the GID for an object. This function looks up a record in the
 637     # registry and returns the GID of the record if it exists.
 638     # TODO: Is this function needed? It's a shortcut for Resolve()
 639     #
 640     # @param name hrn to look up
 641     #
 642     # @return the string representation of a GID object
 643
 644     def get_gid(self, name):
 645         self.verify_object_belongs_to_me(name)
 646         records = self.resolve_raw("*", name)
 647         gid_string_list = []
 648         for record in records:
 649             gid = record.get_gid()
 650             gid_string_list.append(gid.save_to_string(save_parents=True))
 651         return gid_string_list
 652
 653     ##
 654     # Determine tje rights that an object should have. The rights are entirely
 655     # dependent on the type of the object. For example, users automatically
 656     # get "refresh", "resolve", and "info".
 657     #
 658     # @param type the type of the object (user | sa | ma | slice | node)
 659     # @param name human readable name of the object (not used at this time)
 660     #
 661     # @return RightList object containing rights
 662
 663     def determine_rights(self, type, name):
 664         rl = RightList()
 665
 666         # rights seem to be somewhat redundant with the type of the credential.
 667         # For example, a "sa" credential implies the authority right, because
 668         # a sa credential cannot be issued to a user who is not an owner of
 669         # the authority
 670
 671         if type == "user":
 672             rl.add("refresh")
 673             rl.add("resolve")
 674             rl.add("info")
 675         elif type == "sa":
 676             rl.add("authority")
 677         elif type == "ma":
 678             rl.add("authority")
 679         elif type == "slice":
 680             rl.add("embed")
 681             rl.add("bind")
 682             rl.add("control")
 683             rl.add("info")
 684         elif type == "component":
 685             rl.add("operator")
 686
 687         return rl
 688
 689     ##
 690     # GENI API: Get_self_credential
 691     #
 692     # Get_self_credential a degenerate version of get_credential used by a
 693     # client to get his initial credential when he doesn't have one. This is
 694     # the same as get_credential(..., cred=None,...).
 695     #
 696     # The registry ensures that the client is the principal that is named by
 697     # (type, name) by comparing the public key in the record's GID to the
 698     # private key used to encrypt the client-side of the HTTPS connection. Thus
 699     # it is impossible for one principal to retrieve another principal's
 700     # credential without having the appropriate private key.
 701     #
 702     # @param type type of object (user | slice | sa | ma | node
 703     # @param name human readable name of object
 704     #
 705     # @return the string representation of a credential object
 706
 707     def get_self_credential(self, type, name):
 708         self.verify_object_belongs_to_me(name)
 709
 710         auth_hrn = get_authority(name)
 711         auth_info = self.get_auth_info(auth_hrn)
 712
 713         # find a record that matches
 714         records = self.resolve_raw(type, name, must_exist=True)
 715         record = records[0]
 716
 717         gid = record.get_gid_object()
 718         peer_cert = self.server.peer_cert
 719         if not peer_cert.is_pubkey(gid.get_pubkey()):
 720            raise ConnectionKeyGIDMismatch(gid.get_subject())
 721
 722         # create the credential
 723         gid = record.get_gid_object()
 724         cred = Credential(subject = gid.get_subject())
 725         cred.set_gid_caller(gid)
 726         cred.set_gid_object(gid)
 727         cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 728         cred.set_pubkey(gid.get_pubkey())
 729
 730         rl = self.determine_rights(type, name)
 731         cred.set_privileges(rl)
 732
 733         cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn))
 734
 735         cred.encode()
 736         cred.sign()
 737
 738         return cred.save_to_string(save_parents=True)
 739
 740     ##
 741     # GENI API: Get_credential
 742     #
 743     # Retrieve a credential for an object.
 744     #
 745     # If cred==None, then the behavior reverts to get_self_credential()
 746     #
 747     # @param cred credential object specifying rights of the caller
 748     # @param type type of object (user | slice | sa | ma | node)
 749     # @param name human readable name of object
 750     #
 751     # @return the string representation of a credental object
 752
 753     def get_credential(self, cred, type, name):
 754         if not cred:
 755             return get_self_credential(self, type, name)
 756
 757         self.decode_authentication(cred, "getcredential")
 758
 759         self.verify_object_belongs_to_me(name)
 760
 761         auth_hrn = get_authority(name)
 762         auth_info = self.get_auth_info(auth_hrn)
 763
 764         records = self.resolve_raw(type, name, must_exist=True)
 765         record = records[0]
 766
 767         # TODO: Check permission that self.client_cred can access the object
 768
 769         object_gid = record.get_gid_object()
 770         new_cred = Credential(subject = object_gid.get_subject())
 771         new_cred.set_gid_caller(self.client_gid)
 772         new_cred.set_gid_object(object_gid)
 773         new_cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 774         new_cred.set_pubkey(object_gid.get_pubkey())
 775
 776         rl = self.determine_rights(type, name)
 777         new_cred.set_privileges(rl)
 778
 779         new_cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn))
 780
 781         new_cred.encode()
 782         new_cred.sign()
 783
 784         return new_cred.save_to_string(save_parents=True)
 785
 786     ##
 787     # GENI_API: Create_gid
 788     #
 789     # Create a new GID. For MAs and SAs that are physically located on the
 790     # registry, this allows a owner/operator/PI to create a new GID and have it
 791     # signed by his respective authority.
 792     #
 793     # @param cred credential of caller
 794     # @param name hrn for new GID
 795     # @param uuid unique identifier for new GID
 796     # @param pkey_string public-key string (TODO: why is this a string and not a keypair object?)
 797     #
 798     # @return the string representation of a GID object
 799
 800     def create_gid(self, cred, name, uuid, pubkey_str):
 801         self.decode_authentication(cred, "getcredential")
 802
 803         self.verify_object_belongs_to_me(name)
 804
 805         self.verify_object_permission(name)
 806
 807         if uuid == None:
 808             uuid = create_uuid()
 809
 810         pkey = Keypair()
 811         pkey.load_pubkey_from_string(pubkey_str)
 812         gid = self.hierarchy.create_gid(name, uuid, pkey)
 813
 814         return gid.save_to_string(save_parents=True)
 815