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     ##
 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(hrn)
 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,sa")
 677         elif type == "ma":
 678             rl.add("authority,ma")
 679         elif type == "slice":
 680             rl.add("refresh")
 681             rl.add("embed")
 682             rl.add("bind")
 683             rl.add("control")
 684             rl.add("info")
 685         elif type == "component":
 686             rl.add("operator")
 687
 688         return rl
 689
 690     ##
 691     # GENI API: Get_self_credential
 692     #
 693     # Get_self_credential a degenerate version of get_credential used by a
 694     # client to get his initial credential when he doesn't have one. This is
 695     # the same as get_credential(..., cred=None,...).
 696     #
 697     # The registry ensures that the client is the principal that is named by
 698     # (type, name) by comparing the public key in the record's GID to the
 699     # private key used to encrypt the client-side of the HTTPS connection. Thus
 700     # it is impossible for one principal to retrieve another principal's
 701     # credential without having the appropriate private key.
 702     #
 703     # @param type type of object (user | slice | sa | ma | node
 704     # @param name human readable name of object
 705     #
 706     # @return the string representation of a credential object
 707
 708     def get_self_credential(self, type, name):
 709         self.verify_object_belongs_to_me(name)
 710
 711         auth_hrn = get_authority(name)
 712         auth_info = self.get_auth_info(auth_hrn)
 713
 714         # find a record that matches
 715         records = self.resolve_raw(type, name, must_exist=True)
 716         record = records[0]
 717
 718         gid = record.get_gid_object()
 719         peer_cert = self.server.peer_cert
 720         if not peer_cert.is_pubkey(gid.get_pubkey()):
 721            raise ConnectionKeyGIDMismatch(gid.get_subject())
 722
 723         # create the credential
 724         gid = record.get_gid_object()
 725         cred = Credential(subject = gid.get_subject())
 726         cred.set_gid_caller(gid)
 727         cred.set_gid_object(gid)
 728         cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 729         cred.set_pubkey(gid.get_pubkey())
 730
 731         rl = self.determine_rights(type, name)
 732         cred.set_privileges(rl)
 733
 734         # determine the type of credential that we want to use as a parent for
 735         # this credential.
 736
 737         if (type == "ma") or (type == "node"):
 738             auth_kind = "authority,ma"
 739         else: # user, slice, sa
 740             auth_kind = "authority,sa"
 741
 742         cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
 743
 744         cred.encode()
 745         cred.sign()
 746
 747         return cred.save_to_string(save_parents=True)
 748
 749     ##
 750     # GENI API: Get_credential
 751     #
 752     # Retrieve a credential for an object.
 753     #
 754     # If cred==None, then the behavior reverts to get_self_credential()
 755     #
 756     # @param cred credential object specifying rights of the caller
 757     # @param type type of object (user | slice | sa | ma | node)
 758     # @param name human readable name of object
 759     #
 760     # @return the string representation of a credental object
 761
 762     def get_credential(self, cred, type, name):
 763         if not cred:
 764             return get_self_credential(self, type, name)
 765
 766         self.decode_authentication(cred, "getcredential")
 767
 768         self.verify_object_belongs_to_me(name)
 769
 770         auth_hrn = get_authority(name)
 771         auth_info = self.get_auth_info(auth_hrn)
 772
 773         records = self.resolve_raw(type, name, must_exist=True)
 774         record = records[0]
 775
 776         # TODO: Check permission that self.client_cred can access the object
 777
 778         object_gid = record.get_gid_object()
 779         new_cred = Credential(subject = object_gid.get_subject())
 780         new_cred.set_gid_caller(self.client_gid)
 781         new_cred.set_gid_object(object_gid)
 782         new_cred.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 783         new_cred.set_pubkey(object_gid.get_pubkey())
 784
 785         rl = self.determine_rights(type, name)
 786         new_cred.set_privileges(rl)
 787
 788         # determine the type of credential that we want to use as a parent for
 789         # this credential.
 790
 791         if (type == "ma") or (type == "node"):
 792             auth_kind = "authority,ma"
 793         else: # user, slice, sa
 794             auth_kind = "authority,sa"
 795
 796         new_cred.set_parent(self.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
 797
 798         new_cred.encode()
 799         new_cred.sign()
 800
 801         return new_cred.save_to_string(save_parents=True)
 802
 803     ##
 804     # GENI API: get_ticket
 805     #
 806     # Retrieve a ticket. This operation is currently implemented on PLC
 807     # only (see SFA, engineering decisions); it is not implemented on
 808     # components.
 809     #
 810     # The ticket is filled in with information from the PLC database. This
 811     # information includes resources, and attributes such as user keys and
 812     # initscripts.
 813     #
 814     # @param cred credential string
 815     # @param name name of the slice to retrieve a ticket for
 816     # @param rspec resource specification dictionary
 817     #
 818     # @return the string representation of a ticket object
 819
 820     def get_ticket(self, cred, name, rspec):
 821         self.decode_authentication(cred, "getticket")
 822
 823         self.verify_object_belongs_to_me(name)
 824
 825         self.verify_object_permission(name)
 826
 827         # XXX much of this code looks like get_credential... are they so similar
 828         # that they should be combined?
 829
 830         auth_hrn = get_authority(name)
 831         auth_info = self.get_auth_info(auth_hrn)
 832
 833         records = self.resolve_raw("slice", name, must_exist=True)
 834         record = records[0]
 835
 836         object_gid = record.get_gid_object()
 837         new_ticket = Ticket(subject = object_gid.get_subject())
 838         new_ticket.set_gid_caller(self.client_gid)
 839         new_ticket.set_gid_object(object_gid)
 840         new_ticket.set_issuer(key=auth_info.get_pkey_object(), subject=auth_hrn)
 841         new_ticket.set_pubkey(object_gid.get_pubkey())
 842
 843         self.fill_record_info(record)
 844
 845         (attributes, rspec) = self.record_to_slice_info(record)
 846
 847         new_ticket.set_attributes(attributes)
 848         new_ticket.set_rspec(rspec)
 849
 850         new_ticket.set_parent(AuthHierarchy.get_auth_ticket(auth_hrn))
 851
 852         new_ticket.encode()
 853         new_ticket.sign()
 854
 855         return new_ticket.save_to_string(save_parents=True)
 856
 857     ##
 858     # GENI_API: Create_gid
 859     #
 860     # Create a new GID. For MAs and SAs that are physically located on the
 861     # registry, this allows a owner/operator/PI to create a new GID and have it
 862     # signed by his respective authority.
 863     #
 864     # @param cred credential of caller
 865     # @param name hrn for new GID
 866     # @param uuid unique identifier for new GID
 867     # @param pkey_string public-key string (TODO: why is this a string and not a keypair object?)
 868     #
 869     # @return the string representation of a GID object
 870
 871     def create_gid(self, cred, name, uuid, pubkey_str):
 872         self.decode_authentication(cred, "getcredential")
 873
 874         self.verify_object_belongs_to_me(name)
 875
 876         self.verify_object_permission(name)
 877
 878         if uuid == None:
 879             uuid = create_uuid()
 880
 881         pkey = Keypair()
 882         pkey.load_pubkey_from_string(pubkey_str)
 883         gid = self.hierarchy.create_gid(name, uuid, pkey)
 884
 885         return gid.save_to_string(save_parents=True)
 886