sfa/importer/openstackimporter.py

   1 import os
   2
   3 from sfa.util.config import Config
   4 from sfa.util.xrn import Xrn, get_leaf, get_authority, hrn_to_urn
   5 from sfa.util.plxrn import hostname_to_hrn, slicename_to_hrn, email_to_hrn, hrn_to_pl_slicename
   6
   7 from sfa.trust.gid import create_uuid
   8 from sfa.trust.certificate import convert_public_key, Keypair
   9
  10 from sfa.storage.alchemy import dbsession
  11 from sfa.storage.model import RegRecord, RegAuthority, RegUser, RegSlice, RegNode
  12
  13 from sfa.openstack.nova_shell import NovaShell
  14
  15 def load_keys(filename):
  16     keys = {}
  17     tmp_dict = {}
  18     try:
  19         execfile(filename, tmp_dict)
  20         if 'keys' in tmp_dict:
  21             keys = tmp_dict['keys']
  22         return keys
  23     except:
  24         return keys
  25
  26 def save_keys(filename, keys):
  27     f = open(filename, 'w')
  28     f.write("keys = %s" % str(keys))
  29     f.close()
  30
  31 class OpenstackImporter:
  32
  33     def __init__ (self, auth_hierarchy, logger):
  34         self.auth_hierarchy = auth_hierarchy
  35         self.logger=logger
  36
  37     def add_options (self, parser):
  38         self.logger.debug ("OpenstackImporter: no options yet")
  39         pass
  40
  41     def run (self, options):
  42         # we don't have any options for now
  43         self.logger.info ("PlImporter.run : to do")
  44
  45         config = Config ()
  46         interface_hrn = config.SFA_INTERFACE_HRN
  47         root_auth = config.SFA_REGISTRY_ROOT_AUTH
  48         shell = NovaShell (config)
  49
  50         # create dict of all existing sfa records
  51         existing_records = {}
  52         existing_hrns = []
  53         key_ids = []
  54         for record in dbsession.query(RegRecord):
  55             existing_records[ (record.hrn, record.type,) ] = record
  56             existing_hrns.append(record.hrn)
  57
  58         # Get all users
  59         persons = shell.user_get_all()
  60         persons_dict = {}
  61         keys_filename = config.config_path + os.sep + 'person_keys.py'
  62         old_person_keys = load_keys(keys_filename)
  63         person_keys = {}
  64         for person in persons:
  65             hrn = config.SFA_INTERFACE_HRN + "." + person.id
  66             persons_dict[hrn] = person
  67             old_keys = old_person_keys.get(person.id, [])
  68             keys = [k.public_key for k in shell.key_pair_get_all_by_user(person.id)]
  69             person_keys[person.id] = keys
  70             update_record = False
  71             if old_keys != keys:
  72                 update_record = True
  73             if hrn not in existing_hrns or \
  74                    (hrn, 'user') not in existing_records or update_record:
  75                 urn = hrn_to_urn(hrn, 'user')
  76
  77                 if keys:
  78                     try:
  79                         pkey = convert_public_key(keys[0])
  80                     except:
  81                         logger.log_exc('unable to convert public key for %s' % hrn)
  82                         pkey = Keypair(create=True)
  83                 else:
  84                     logger.warn("OpenstackImporter: person %s does not have a PL public key"%hrn)
  85                     pkey = Keypair(create=True)
  86                 person_gid = sfaImporter.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
  87                 person_record = RegUser ()
  88                 person_record.type='user'
  89                 person_record.hrn=hrn
  90                 person_record.gid=person_gid
  91                 person_record.authority=get_authority(hrn)
  92                 dbsession.add(person_record)
  93                 dbsession.commit()
  94                 logger.info("OpenstackImporter: imported person %s" % person_record)
  95
  96         # Get all projects
  97         projects = shell.project_get_all()
  98         projects_dict = {}
  99         for project in projects:
 100             hrn = config.SFA_INTERFACE_HRN + '.' + project.id
 101             projects_dict[hrn] = project
 102             if hrn not in existing_hrns or \
 103             (hrn, 'slice') not in existing_records:
 104                 pkey = Keypair(create=True)
 105                 urn = hrn_to_urn(hrn, 'slice')
 106                 project_gid = sfaImporter.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
 107                 project_record = RegSlice ()
 108                 project_record.type='slice'
 109                 project_record.hrn=hrn
 110                 project_record.gid=project_gid
 111                 project_record.authority=get_authority(hrn)
 112                 dbsession.add(project_record)
 113                 dbsession.commit()
 114                 logger.info("OpenstackImporter: imported slice: %s" % project_record)
 115
 116         # remove stale records
 117         system_records = [interface_hrn, root_auth, interface_hrn + '.slicemanager']
 118         for (record_hrn, type) in existing_records.keys():
 119             if record_hrn in system_records:
 120                 continue
 121
 122             record = existing_records[(record_hrn, type)]
 123             if record.peer_authority:
 124                 continue
 125
 126             if type == 'user':
 127                 if record_hrn in persons_dict:
 128                     continue
 129             elif type == 'slice':
 130                 if record_hrn in projects_dict:
 131                     continue
 132             else:
 133                 continue
 134
 135             record_object = existing_records[ (record_hrn, type) ]
 136             logger.info("OpenstackImporter: removing %s " % record)
 137             dbsession.delete(record_object)
 138             dbsession.commit()
 139
 140         # save pub keys
 141         logger.info('OpenstackImporter: saving current pub keys')
 142         save_keys(keys_filename, person_keys)
 143