sfa/importer/sfa-import-plc.py

   1 #!/usr/bin/python
   2 #
   3 ##
   4 # Import PLC records into the SFA database. It is indended that this tool be
   5 # run once to create SFA records that reflect the current state of the
   6 # planetlab database.
   7 #
   8 # The import tool assumes that the existing PLC hierarchy should all be part
   9 # of "planetlab.us" (see the root_auth and level1_auth variables below).
  10 #
  11 # Public keys are extracted from the users' SSH keys automatically and used to
  12 # create GIDs. This is relatively experimental as a custom tool had to be
  13 # written to perform conversion from SSH to OpenSSL format. It only supports
  14 # RSA keys at this time, not DSA keys.
  15 ##
  16
  17 import os
  18 import getopt
  19 import sys
  20
  21 from sfa.util.config import Config
  22 from sfa.util.xrn import Xrn, get_leaf, get_authority, hrn_to_urn
  23 from sfa.util.plxrn import hostname_to_hrn, slicename_to_hrn, email_to_hrn, hrn_to_pl_slicename
  24 from sfa.storage.table import SfaTable
  25 from sfa.storage.record import SfaRecord
  26 from sfa.trust.gid import create_uuid
  27 from sfa.trust.certificate import convert_public_key, Keypair
  28 from sfa.importer.sfaImport import sfaImport, _cleanup_string
  29 from sfa.util.sfalogging import logger
  30
  31 def process_options():
  32
  33    (options, args) = getopt.getopt(sys.argv[1:], '', [])
  34    for opt in options:
  35        name = opt[0]
  36        val = opt[1]
  37
  38
  39 def load_keys(filename):
  40     keys = {}
  41     tmp_dict = {}
  42     try:
  43         execfile(filename, tmp_dict)
  44         if 'keys' in tmp_dict:
  45             keys = tmp_dict['keys']
  46         return keys
  47     except:
  48         return keys
  49
  50 def save_keys(filename, keys):
  51     f = open(filename, 'w')
  52     f.write("keys = %s" % str(keys))
  53     f.close()
  54
  55 def _get_site_hrn(interface_hrn, site):
  56     # Hardcode 'internet2' into the hrn for sites hosting
  57     # internet2 nodes. This is a special operation for some vini
  58     # sites only
  59     hrn = ".".join([interface_hrn, site['login_base']])
  60     if ".vini" in interface_hrn and interface_hrn.endswith('vini'):
  61         if site['login_base'].startswith("i2") or site['login_base'].startswith("nlr"):
  62             hrn = ".".join([interface_hrn, "internet2", site['login_base']])
  63     return hrn
  64
  65 def main():
  66
  67     process_options()
  68     config = Config()
  69     if not config.SFA_REGISTRY_ENABLED:
  70         sys.exit(0)
  71     root_auth = config.SFA_REGISTRY_ROOT_AUTH
  72     interface_hrn = config.SFA_INTERFACE_HRN
  73     keys_filename = config.config_path + os.sep + 'person_keys.py'
  74     sfaImporter = sfaImport()
  75     sfaImporter.create_top_level_records()
  76     logger=sfaImporter.logger
  77     logger.setLevelFromOptVerbose(config.SFA_API_LOGLEVEL)
  78     shell = sfaImporter.shell
  79
  80     # special case for vini
  81     if ".vini" in interface_hrn and interface_hrn.endswith('vini'):
  82         # create a fake internet2 site first
  83         i2site = {'name': 'Internet2', 'abbreviated_name': 'I2',
  84                     'login_base': 'internet2', 'site_id': -1}
  85         sfaImporter.import_site(interface_hrn, i2site)
  86
  87     # create dict of all existing sfa records
  88     existing_records = {}
  89     existing_hrns = []
  90     key_ids = []
  91     person_keys = {}
  92     table = SfaTable()
  93     results = table.find()
  94     for result in results:
  95         existing_records[(result['hrn'], result['type'])] = result
  96         existing_hrns.append(result['hrn'])
  97
  98     # Get all plc sites
  99     sites = shell.GetSites({'peer_id': None})
 100     sites_dict = {}
 101     for site in sites:
 102         sites_dict[site['login_base']] = site
 103
 104     # Get all plc users
 105     persons = shell.GetPersons({'peer_id': None, 'enabled': True},
 106                                ['person_id', 'email', 'key_ids', 'site_ids'])
 107     persons_dict = {}
 108     for person in persons:
 109         persons_dict[person['person_id']] = person
 110         key_ids.extend(person['key_ids'])
 111
 112     # Get all public keys
 113     keys = shell.GetKeys( {'peer_id': None, 'key_id': key_ids})
 114     keys_dict = {}
 115     for key in keys:
 116         keys_dict[key['key_id']] = key['key']
 117
 118     # create a dict of person keys keyed on key_id
 119     old_person_keys = load_keys(keys_filename)
 120     for person in persons:
 121         pubkeys = []
 122         for key_id in person['key_ids']:
 123             pubkeys.append(keys_dict[key_id])
 124         person_keys[person['person_id']] = pubkeys
 125
 126     # Get all plc nodes
 127     nodes = shell.GetNodes( {'peer_id': None}, ['node_id', 'hostname', 'site_id'])
 128     nodes_dict = {}
 129     for node in nodes:
 130         nodes_dict[node['node_id']] = node
 131
 132     # Get all plc slices
 133     slices = shell.GetSlices( {'peer_id': None}, ['slice_id', 'name'])
 134     slices_dict = {}
 135     for slice in slices:
 136         slices_dict[slice['slice_id']] = slice
 137     # start importing
 138     for site in sites:
 139         site_hrn = _get_site_hrn(interface_hrn, site)
 140         logger.info("Importing site: %s" % site_hrn)
 141
 142         # import if hrn is not in list of existing hrns or if the hrn exists
 143         # but its not a site record
 144         if site_hrn not in existing_hrns or \
 145            (site_hrn, 'authority') not in existing_records:
 146             logger.info("Import: site %s " % site_hrn)
 147             urn = hrn_to_urn(site_hrn, 'authority')
 148             if not sfaImporter.AuthHierarchy.auth_exists(urn):
 149                 sfaImporter.AuthHierarchy.create_auth(urn)
 150             auth_info = sfaImporter.AuthHierarchy.get_auth_info(urn)
 151             auth_record = SfaRecord(hrn=site_hrn, gid=auth_info.get_gid_object(), type="authority", pointer=site['site_id'])
 152             auth_record.sync(verbose=True)
 153
 154         # import node records
 155         for node_id in site['node_ids']:
 156             if node_id not in nodes_dict:
 157                 continue
 158             node = nodes_dict[node_id]
 159             site_auth = get_authority(site_hrn)
 160             site_name = get_leaf(site_hrn)
 161             hrn =  hostname_to_hrn(site_auth, site_name, node['hostname'])
 162             if len(hrn) > 64:
 163                 hrn = hrn[:64]
 164             if hrn not in existing_hrns or \
 165                (hrn, 'node') not in existing_records:
 166                 pkey = Keypair(create=True)
 167                 urn = hrn_to_urn(hrn, 'node')
 168                 node_gid = sfaImporter.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
 169                 node_record = SfaRecord(hrn=hrn, gid=node_gid, type="node", pointer=node['node_id'], authority=get_authority(hrn))
 170                 node_record.sync(verbose=True)
 171
 172         # import slices
 173         for slice_id in site['slice_ids']:
 174             if slice_id not in slices_dict:
 175                 continue
 176             slice = slices_dict[slice_id]
 177             hrn = slicename_to_hrn(interface_hrn, slice['name'])
 178             #slicename = slice['name'].split("_",1)[-1]
 179             #slicename = _cleanup_string(slicename)
 180             if hrn not in existing_hrns or \
 181                (hrn, 'slice') not in existing_records:
 182                 pkey = Keypair(create=True)
 183                 urn = hrn_to_urn(hrn, 'slice')
 184                 slice_gid = sfaImporter.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
 185                 slice_record = SfaRecord(hrn=hrn, gid=slice_gid, type="slice", pointer=slice['slice_id'],
 186                                          authority=get_authority(hrn))
 187                 slice_record.sync(verbose=True)
 188
 189         # import persons
 190         for person_id in site['person_ids']:
 191             if person_id not in persons_dict:
 192                 continue
 193             person = persons_dict[person_id]
 194             hrn = email_to_hrn(site_hrn, person['email'])
 195             if len(hrn) > 64:
 196                 hrn = hrn[:64]
 197
 198             # if user's primary key has chnaged then we need to update the
 199             # users gid by forcing a update here
 200             old_keys = []
 201             new_keys = []
 202             if person_id in old_person_keys:
 203                 old_keys = old_person_keys[person_id]
 204             if person_id in person_keys:
 205                 new_keys = person_keys[person_id]
 206             update_record = False
 207             for key in new_keys:
 208                 if key not in old_keys:
 209                     update_record = True
 210
 211             if hrn not in existing_hrns or \
 212                (hrn, 'user') not in existing_records or update_record:
 213                 if 'key_ids' in person and person['key_ids']:
 214                     key = new_keys[0]
 215                     try:
 216                         pkey = convert_public_key(key)
 217                     except:
 218                         logger.warn('unable to convert public key for %s' % hrn)
 219                         pkey = Keypair(create=True)
 220                 else:
 221                     # the user has no keys. Creating a random keypair for the user's gid
 222                     logger.warn("Import: person %s does not have a PL public key"%hrn)
 223                     pkey = Keypair(create=True)
 224                 urn = hrn_to_urn(hrn, 'user')
 225                 person_gid = sfaImporter.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
 226                 person_record = SfaRecord(hrn=hrn, gid=person_gid, type="user", \
 227                                           pointer=person['person_id'], authority=get_authority(hrn))
 228                 person_record.sync(verbose=True)
 229
 230     # remove stale records
 231     system_records = [interface_hrn, root_auth, interface_hrn + '.slicemanager']
 232     for (record_hrn, type) in existing_records.keys():
 233         if record_hrn in system_records:
 234             continue
 235
 236         record = existing_records[(record_hrn, type)]
 237         if record['peer_authority']:
 238             continue
 239
 240         # dont delete vini's internet2 placeholdder record
 241         # normally this would be deleted becuase it does not have a plc record
 242         if ".vini" in interface_hrn and interface_hrn.endswith('vini') and \
 243            record_hrn.endswith("internet2"):
 244             continue
 245
 246         found = False
 247
 248         if type == 'authority':
 249             for site in sites:
 250                 site_hrn = interface_hrn + "." + site['login_base']
 251                 if site_hrn == record_hrn and site['site_id'] == record['pointer']:
 252                     found = True
 253                     break
 254
 255         elif type == 'user':
 256             login_base = get_leaf(get_authority(record_hrn))
 257             username = get_leaf(record_hrn)
 258             if login_base in sites_dict:
 259                 site = sites_dict[login_base]
 260                 for person in persons:
 261                     tmp_username = person['email'].split("@")[0]
 262                     alt_username = person['email'].split("@")[0].replace(".", "_").replace("+", "_")
 263                     if username in [tmp_username, alt_username] and \
 264                        site['site_id'] in person['site_ids'] and \
 265                        person['person_id'] == record['pointer']:
 266                         found = True
 267                         break
 268
 269         elif type == 'slice':
 270             slicename = hrn_to_pl_slicename(record_hrn)
 271             for slice in slices:
 272                 if slicename == slice['name'] and \
 273                    slice['slice_id'] == record['pointer']:
 274                     found = True
 275                     break
 276
 277         elif type == 'node':
 278             login_base = get_leaf(get_authority(record_hrn))
 279             nodename = Xrn.unescape(get_leaf(record_hrn))
 280             if login_base in sites_dict:
 281                 site = sites_dict[login_base]
 282                 for node in nodes:
 283                     tmp_nodename = node['hostname']
 284                     if tmp_nodename == nodename and \
 285                        node['site_id'] == site['site_id'] and \
 286                        node['node_id'] == record['pointer']:
 287                         found = True
 288                         break
 289         else:
 290             continue
 291
 292         if not found:
 293             record_object = existing_records[(record_hrn, type)]
 294             record = SfaRecord(dict=record_object)
 295             record.delete()
 296
 297     # save pub keys
 298     logger.info('Import: saving current pub keys')
 299     save_keys(keys_filename, person_keys)
 300
 301 if __name__ == "__main__":
 302     main()