sfa/managers/registry_manager.py

   1 import types
   2 import time
   3 # for get_key_from_incoming_ip
   4 import tempfile
   5 import os
   6 import commands
   7
   8 from sfa.util.faults import RecordNotFound, AccountNotEnabled, PermissionError, MissingAuthority, \
   9     UnknownSfaType, ExistingRecord, NonExistingRecord
  10 from sfa.util.prefixTree import prefixTree
  11 from sfa.util.xrn import Xrn, get_authority, hrn_to_urn, urn_to_hrn
  12 from sfa.util.plxrn import hrn_to_pl_login_base
  13 from sfa.util.version import version_core
  14 from sfa.util.sfalogging import logger
  15
  16 from sfa.trust.gid import GID
  17 from sfa.trust.credential import Credential
  18 from sfa.trust.certificate import Certificate, Keypair, convert_public_key
  19 from sfa.trust.gid import create_uuid
  20
  21 from sfa.storage.record import SfaRecord
  22 from sfa.storage.table import SfaTable
  23
  24 class RegistryManager:
  25
  26     def __init__ (self): pass
  27
  28     # The GENI GetVersion call
  29     def GetVersion(self, api):
  30         peers = dict ( [ (hrn,interface._ServerProxy__host) for (hrn,interface) in api.registries.iteritems()
  31                        if hrn != api.hrn])
  32         xrn=Xrn(api.hrn)
  33         return version_core({'interface':'registry',
  34                              'hrn':xrn.get_hrn(),
  35                              'urn':xrn.get_urn(),
  36                              'peers':peers})
  37
  38     def GetCredential(self, api, xrn, type, is_self=False):
  39         # convert xrn to hrn
  40         if type:
  41             hrn = urn_to_hrn(xrn)[0]
  42         else:
  43             hrn, type = urn_to_hrn(xrn)
  44
  45         # Is this a root or sub authority
  46         auth_hrn = api.auth.get_authority(hrn)
  47         if not auth_hrn or hrn == api.config.SFA_INTERFACE_HRN:
  48             auth_hrn = hrn
  49         # get record info
  50         auth_info = api.auth.get_auth_info(auth_hrn)
  51         table = SfaTable()
  52         records = table.findObjects({'type': type, 'hrn': hrn})
  53         if not records:
  54             raise RecordNotFound(hrn)
  55         record = records[0]
  56
  57         # verify_cancreate_credential requires that the member lists
  58         # (researchers, pis, etc) be filled in
  59         self.driver.augment_records_with_testbed_info (record)
  60         if not self.driver.is_enabled (record):
  61               raise AccountNotEnabled(": PlanetLab account %s is not enabled. Please contact your site PI" %(record['email']))
  62
  63         # get the callers gid
  64         # if this is a self cred the record's gid is the caller's gid
  65         if is_self:
  66             caller_hrn = hrn
  67             caller_gid = record.get_gid_object()
  68         else:
  69             caller_gid = api.auth.client_cred.get_gid_caller()
  70             caller_hrn = caller_gid.get_hrn()
  71
  72         object_hrn = record.get_gid_object().get_hrn()
  73         rights = api.auth.determine_user_rights(caller_hrn, record)
  74         # make sure caller has rights to this object
  75         if rights.is_empty():
  76             raise PermissionError(caller_hrn + " has no rights to " + record['name'])
  77
  78         object_gid = GID(string=record['gid'])
  79         new_cred = Credential(subject = object_gid.get_subject())
  80         new_cred.set_gid_caller(caller_gid)
  81         new_cred.set_gid_object(object_gid)
  82         new_cred.set_issuer_keys(auth_info.get_privkey_filename(), auth_info.get_gid_filename())
  83         #new_cred.set_pubkey(object_gid.get_pubkey())
  84         new_cred.set_privileges(rights)
  85         new_cred.get_privileges().delegate_all_privileges(True)
  86         if 'expires' in record:
  87             new_cred.set_expiration(int(record['expires']))
  88         auth_kind = "authority,ma,sa"
  89         # Parent not necessary, verify with certs
  90         #new_cred.set_parent(api.auth.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
  91         new_cred.encode()
  92         new_cred.sign()
  93
  94         return new_cred.save_to_string(save_parents=True)
  95
  96
  97     def Resolve(self, api, xrns, type=None, full=True):
  98
  99         if not isinstance(xrns, types.ListType):
 100             xrns = [xrns]
 101             # try to infer type if not set and we get a single input
 102             if not type:
 103                 type = Xrn(xrns).get_type()
 104         hrns = [urn_to_hrn(xrn)[0] for xrn in xrns]
 105         # load all known registry names into a prefix tree and attempt to find
 106         # the longest matching prefix
 107         # create a dict where key is a registry hrn and its value is a
 108         # hrns at that registry (determined by the known prefix tree).
 109         xrn_dict = {}
 110         registries = api.registries
 111         tree = prefixTree()
 112         registry_hrns = registries.keys()
 113         tree.load(registry_hrns)
 114         for xrn in xrns:
 115             registry_hrn = tree.best_match(urn_to_hrn(xrn)[0])
 116             if registry_hrn not in xrn_dict:
 117                 xrn_dict[registry_hrn] = []
 118             xrn_dict[registry_hrn].append(xrn)
 119
 120         records = []
 121         for registry_hrn in xrn_dict:
 122             # skip the hrn without a registry hrn
 123             # XX should we let the user know the authority is unknown?
 124             if not registry_hrn:
 125                 continue
 126
 127             # if the best match (longest matching hrn) is not the local registry,
 128             # forward the request
 129             xrns = xrn_dict[registry_hrn]
 130             if registry_hrn != api.hrn:
 131                 credential = api.getCredential()
 132                 interface = api.registries[registry_hrn]
 133                 server_proxy = api.server_proxy(interface, credential)
 134                 peer_records = server_proxy.Resolve(xrns, credential)
 135                 records.extend([SfaRecord(dict=record).as_dict() for record in peer_records])
 136
 137         # try resolving the remaining unfound records at the local registry
 138         local_hrns = list ( set(hrns).difference([record['hrn'] for record in records]) )
 139         #
 140         table = SfaTable()
 141         local_records = table.findObjects({'hrn': local_hrns})
 142
 143         if full:
 144             # in full mode we get as much info as we can, which involves contacting the
 145             # testbed for getting implementation details about the record
 146             self.driver.augment_records_with_testbed_info(local_records)
 147             # also we fill the 'url' field for known authorities
 148             # used to be in the driver code, sounds like a poorman thing though
 149             def solve_neighbour_url (record):
 150                 if not record['type'].startswith('authority'): return
 151                 hrn=record['hrn']
 152                 for neighbour_dict in [ api.aggregates, api.registries ]:
 153                     if hrn in neighbour_dict:
 154                         record['url']=neighbour_dict[hrn].get_url()
 155                         return
 156             [ solve_neighbour_url (record) for record in local_records ]
 157
 158
 159
 160         # convert local record objects to dicts
 161         records.extend([dict(record) for record in local_records])
 162         if type:
 163             records = filter(lambda rec: rec['type'] in [type], records)
 164
 165         if not records:
 166             raise RecordNotFound(str(hrns))
 167
 168         return records
 169
 170     def List(self, api, xrn, origin_hrn=None):
 171         hrn, type = urn_to_hrn(xrn)
 172         # load all know registry names into a prefix tree and attempt to find
 173         # the longest matching prefix
 174         records = []
 175         registries = api.registries
 176         registry_hrns = registries.keys()
 177         tree = prefixTree()
 178         tree.load(registry_hrns)
 179         registry_hrn = tree.best_match(hrn)
 180
 181         #if there was no match then this record belongs to an unknow registry
 182         if not registry_hrn:
 183             raise MissingAuthority(xrn)
 184         # if the best match (longest matching hrn) is not the local registry,
 185         # forward the request
 186         records = []
 187         if registry_hrn != api.hrn:
 188             credential = api.getCredential()
 189             interface = api.registries[registry_hrn]
 190             server_proxy = api.server_proxy(interface, credential)
 191             record_list = server_proxy.List(xrn, credential)
 192             records = [SfaRecord(dict=record).as_dict() for record in record_list]
 193
 194         # if we still have not found the record yet, try the local registry
 195         if not records:
 196             if not api.auth.hierarchy.auth_exists(hrn):
 197                 raise MissingAuthority(hrn)
 198
 199             table = SfaTable()
 200             records = table.find({'authority': hrn})
 201
 202         return records
 203
 204
 205     def CreateGid(self, api, xrn, cert):
 206         # get the authority
 207         authority = Xrn(xrn=xrn).get_authority_hrn()
 208         auth_info = api.auth.get_auth_info(authority)
 209         if not cert:
 210             pkey = Keypair(create=True)
 211         else:
 212             certificate = Certificate(string=cert)
 213             pkey = certificate.get_pubkey()
 214         gid = api.auth.hierarchy.create_gid(xrn, create_uuid(), pkey)
 215         return gid.save_to_string(save_parents=True)
 216
 217     ####################
 218     # utility for handling relationships among the SFA objects
 219     # given that the SFA db does not handle this sort of relationsships
 220     # it will rely on side-effects in the testbed to keep this persistent
 221
 222     # subject_record describes the subject of the relationships
 223     # ref_record contains the target values for the various relationships we need to manage
 224     # (to begin with, this is just the slice x person relationship)
 225     def update_relations (self, subject_record, ref_record):
 226         type=subject_record['type']
 227         if type=='slice':
 228             self.update_relation(subject_record, 'researcher', ref_record.get('researcher'), 'user')
 229
 230     # field_key is the name of one field in the record, typically 'researcher' for a 'slice' record
 231     # hrns is the list of hrns that should be linked to the subject from now on
 232     # target_type would be e.g. 'user' in the 'slice' x 'researcher' example
 233     def update_relation (self, sfa_record, field_key, hrns, target_type):
 234         # locate the linked objects in our db
 235         subject_type=sfa_record['type']
 236         subject_id=sfa_record['pointer']
 237         table = SfaTable()
 238         link_sfa_records = table.find ({'type':target_type, 'hrn': hrns})
 239         link_ids = [ rec.get('pointer') for rec in link_sfa_records ]
 240         self.driver.update_relation (subject_type, target_type, subject_id, link_ids)
 241
 242
 243     def Register(self, api, record):
 244
 245         hrn, type = record['hrn'], record['type']
 246         urn = hrn_to_urn(hrn,type)
 247         # validate the type
 248         if type not in ['authority', 'slice', 'node', 'user']:
 249             raise UnknownSfaType(type)
 250
 251         # check if record already exists
 252         table = SfaTable()
 253         existing_records = table.find({'type': type, 'hrn': hrn})
 254         if existing_records:
 255             raise ExistingRecord(hrn)
 256
 257         record = SfaRecord(dict = record)
 258         record['authority'] = get_authority(record['hrn'])
 259         auth_info = api.auth.get_auth_info(record['authority'])
 260         pub_key = None
 261         # make sure record has a gid
 262         if 'gid' not in record:
 263             uuid = create_uuid()
 264             pkey = Keypair(create=True)
 265             if 'keys' in record and record['keys']:
 266                 pub_key=record['keys']
 267                 # use only first key in record
 268                 if isinstance(record['keys'], types.ListType):
 269                     pub_key = record['keys'][0]
 270                 pkey = convert_public_key(pub_key)
 271
 272             gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
 273             gid = gid_object.save_to_string(save_parents=True)
 274             record['gid'] = gid
 275             record.set_gid(gid)
 276
 277         if type in ["authority"]:
 278             # update the tree
 279             if not api.auth.hierarchy.auth_exists(hrn):
 280                 api.auth.hierarchy.create_auth(hrn_to_urn(hrn,'authority'))
 281
 282             # get the GID from the newly created authority
 283             gid = auth_info.get_gid_object()
 284             record.set_gid(gid.save_to_string(save_parents=True))
 285
 286         # update testbed-specific data f needed
 287         logger.info("Getting driver from manager=%s"%self)
 288         pointer = self.driver.register (record, hrn, pub_key)
 289
 290         record.set_pointer(pointer)
 291         record_id = table.insert(record)
 292         record['record_id'] = record_id
 293
 294         # update membership for researchers, pis, owners, operators
 295         self.update_relations (record, record)
 296
 297         return record.get_gid_object().save_to_string(save_parents=True)
 298
 299     def Update(self, api, record_dict):
 300         new_record = SfaRecord(dict = record_dict)
 301         type = new_record['type']
 302         hrn = new_record['hrn']
 303         urn = hrn_to_urn(hrn,type)
 304         table = SfaTable()
 305         # make sure the record exists
 306         records = table.findObjects({'type': type, 'hrn': hrn})
 307         if not records:
 308             raise RecordNotFound(hrn)
 309         record = records[0]
 310         record['last_updated'] = time.gmtime()
 311
 312         # validate the type
 313         if type not in ['authority', 'slice', 'node', 'user']:
 314             raise UnknownSfaType(type)
 315
 316         # Use the pointer from the existing record, not the one that the user
 317         # gave us. This prevents the user from inserting a forged pointer
 318         pointer = record['pointer']
 319
 320         # is the a change in keys ?
 321         new_key=None
 322         if type=='user':
 323             if 'keys' in new_record and new_record['keys']:
 324                 new_key=new_record['keys']
 325                 if isinstance (new_key,types.ListType):
 326                     new_key=new_key[0]
 327
 328         # update the PLC information that was specified with the record
 329         if not self.driver.update (record, new_record, hrn, new_key):
 330             logger.warning("driver.update failed")
 331
 332         # take new_key into account
 333         if new_key:
 334             # update the openssl key and gid
 335             pkey = convert_public_key(new_key)
 336             uuid = create_uuid()
 337             gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
 338             gid = gid_object.save_to_string(save_parents=True)
 339             record['gid'] = gid
 340             record = SfaRecord(dict=record)
 341             table.update(record)
 342
 343         # update membership for researchers, pis, owners, operators
 344         self.update_relations (record, new_record)
 345
 346         return 1
 347
 348     # expecting an Xrn instance
 349     def Remove(self, api, xrn, origin_hrn=None):
 350
 351         table = SfaTable()
 352         filter = {'hrn': xrn.get_hrn()}
 353         hrn=xrn.get_hrn()
 354         type=xrn.get_type()
 355         if type and type not in ['all', '*']:
 356             filter['type'] = type
 357
 358         records = table.find(filter)
 359         if not records: raise RecordNotFound(hrn)
 360         record = records[0]
 361         type = record['type']
 362
 363         if type not in ['slice', 'user', 'node', 'authority'] :
 364             raise UnknownSfaType(type)
 365
 366         credential = api.getCredential()
 367         registries = api.registries
 368
 369         # Try to remove the object from the PLCDB of federated agg.
 370         # This is attempted before removing the object from the local agg's PLCDB and sfa table
 371         if hrn.startswith(api.hrn) and type in ['user', 'slice', 'authority']:
 372             for registry in registries:
 373                 if registry not in [api.hrn]:
 374                     try:
 375                         result=registries[registry].remove_peer_object(credential, record, origin_hrn)
 376                     except:
 377                         pass
 378
 379         # call testbed callback first
 380         # IIUC this is done on the local testbed TOO because of the refreshpeer link
 381         if not self.driver.remove(record):
 382             logger.warning("driver.remove failed")
 383
 384         # delete from sfa db
 385         table.remove(record)
 386
 387         return 1
 388
 389     # This is a PLC-specific thing...
 390     def get_key_from_incoming_ip (self, api):
 391         # verify that the callers's ip address exist in the db and is an interface
 392         # for a node in the db
 393         (ip, port) = api.remote_addr
 394         interfaces = self.driver.GetInterfaces({'ip': ip}, ['node_id'])
 395         if not interfaces:
 396             raise NonExistingRecord("no such ip %(ip)s" % locals())
 397         nodes = self.driver.GetNodes([interfaces[0]['node_id']], ['node_id', 'hostname'])
 398         if not nodes:
 399             raise NonExistingRecord("no such node using ip %(ip)s" % locals())
 400         node = nodes[0]
 401
 402         # look up the sfa record
 403         table = SfaTable()
 404         records = table.findObjects({'type': 'node', 'pointer': node['node_id']})
 405         if not records:
 406             raise RecordNotFound("pointer:" + str(node['node_id']))
 407         record = records[0]
 408
 409         # generate a new keypair and gid
 410         uuid = create_uuid()
 411         pkey = Keypair(create=True)
 412         urn = hrn_to_urn(record['hrn'], record['type'])
 413         gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
 414         gid = gid_object.save_to_string(save_parents=True)
 415         record['gid'] = gid
 416         record.set_gid(gid)
 417
 418         # update the record
 419         table.update(record)
 420
 421         # attempt the scp the key
 422         # and gid onto the node
 423         # this will only work for planetlab based components
 424         (kfd, key_filename) = tempfile.mkstemp()
 425         (gfd, gid_filename) = tempfile.mkstemp()
 426         pkey.save_to_file(key_filename)
 427         gid_object.save_to_file(gid_filename, save_parents=True)
 428         host = node['hostname']
 429         key_dest="/etc/sfa/node.key"
 430         gid_dest="/etc/sfa/node.gid"
 431         scp = "/usr/bin/scp"
 432         #identity = "/etc/planetlab/root_ssh_key.rsa"
 433         identity = "/etc/sfa/root_ssh_key"
 434         scp_options=" -i %(identity)s " % locals()
 435         scp_options+="-o StrictHostKeyChecking=no " % locals()
 436         scp_key_command="%(scp)s %(scp_options)s %(key_filename)s root@%(host)s:%(key_dest)s" %\
 437                          locals()
 438         scp_gid_command="%(scp)s %(scp_options)s %(gid_filename)s root@%(host)s:%(gid_dest)s" %\
 439                          locals()
 440
 441         all_commands = [scp_key_command, scp_gid_command]
 442
 443         for command in all_commands:
 444             (status, output) = commands.getstatusoutput(command)
 445             if status:
 446                 raise Exception, output
 447
 448         for filename in [key_filename, gid_filename]:
 449             os.unlink(filename)
 450
 451         return 1