sfa/importer/slabimporter.py

   1 import os
   2 import sys
   3 import datetime
   4 import time
   5
   6 from sfa.util.config import Config
   7 from sfa.util.xrn import Xrn, get_leaf, get_authority, hrn_to_urn
   8 from sfa.util.plxrn import PlXrn, slicename_to_hrn, email_to_hrn, hrn_to_pl_slicename
   9
  10 from sfa.senslab.LDAPapi import LDAPapi
  11 from sfa.senslab.slabdriver import SlabDriver
  12 from sfa.senslab.slabpostgres import SlabDB
  13
  14 from sfa.trust.certificate import Keypair,convert_public_key
  15 from sfa.trust.gid import create_uuid
  16
  17 from sfa.storage.alchemy import dbsession
  18 from sfa.storage.model import RegRecord, RegAuthority, RegSlice, RegNode, RegUser, RegKey
  19 from sfa.storage.dbschema import DBSchema
  20
  21
  22 def _get_site_hrn(site):
  23     hrn = site['login_base']
  24     return hrn
  25
  26 class SlabImporter:
  27
  28     def __init__ (self, auth_hierarchy, logger):
  29         self.auth_hierarchy = auth_hierarchy
  30         self.logger=logger
  31
  32     def hostname_to_hrn(self,root_auth,login_base,hostname):
  33         return PlXrn(auth=root_auth,hostname=login_base+'_'+hostname).get_hrn()
  34
  35     def slicename_to_hrn(self, person_hrn):
  36         return  (person_hrn +'_slice')
  37
  38     def add_options (self, parser):
  39         # we don't have any options for now
  40         pass
  41
  42     def find_record_by_type_hrn(self,type,hrn):
  43         return self.records_by_type_hrn.get ( (type, hrn), None)
  44
  45     def update_just_added_records_dict (self, record):
  46         tuple = (record.type, record.hrn)
  47         if tuple in self.records_by_type_hrn:
  48             self.logger.warning ("SlabImporter.update_just_added_records_dict: duplicate (%s,%s)"%tuple)
  49             return
  50         self.records_by_type_hrn [ tuple ] = record
  51
  52     def run (self, options):
  53         config = Config()
  54         interface_hrn = config.SFA_INTERFACE_HRN
  55         root_auth = config.SFA_REGISTRY_ROOT_AUTH
  56         slabdriver = SlabDriver(config)
  57
  58         #Create special slice table for senslab
  59         db = SlabDB()
  60
  61         if not db.exists('slice_senslab'):
  62             db.createtable('slice_senslab')
  63        ######## retrieve all existing SFA objects
  64         all_records = dbsession.query(RegRecord).all()
  65          # create hash by (type,hrn)
  66         # used  to know if a given record is already known to SFA
  67
  68         self.records_by_type_hrn = \
  69             dict ( [ ( (record.type, record.hrn) , record ) for record in all_records ] )
  70
  71         ## initialize record.stale to True by default, then mark stale=False on the ones that are in use
  72         #for record in all_records:
  73             #record.stale=True
  74
  75         #nodes_listdict  = slabdriver.GetNodes()
  76         #nodes_by_id = dict([(node['node_id'],node) for node in nodes_listdict])
  77         #sites_listdict  = slabdriver.GetSites()
  78
  79         #ldap_person_listdict = slabdriver.GetPersons()
  80         #slices_listdict = slabdriver.GetSlices()
  81         #for site in sites_listdict:
  82             #site_hrn = _get_site_hrn(site)
  83             #site_record = self.find_record_by_type_hrn ('authority', site_hrn)
  84             #if not site_record:
  85                 #try:
  86                     #urn = hrn_to_urn(site_hrn, 'authority')
  87                     #if not self.auth_hierarchy.auth_exists(urn):
  88                         #self.auth_hierarchy.create_auth(urn)
  89                     #auth_info = self.auth_hierarchy.get_auth_info(urn)
  90                     #site_record = RegAuthority(hrn=site_hrn, gid=auth_info.get_gid_object(),
  91                                                #pointer='-1',
  92                                                #authority=get_authority(site_hrn))
  93                     #site_record.just_created()
  94                     #dbsession.add(site_record)
  95                     #dbsession.commit()
  96                     #self.logger.info("SlabImporter: imported authority (site) : %s" % site_record)
  97                     #self.update_just_added_records_dict(site_record)
  98                 #except:
  99                     ## if the site import fails then there is no point in trying to import the
 100                     ## site's child records (node, slices, persons), so skip them.
 101                     #self.logger.log_exc("SlabImporter: failed to import site. Skipping child records")
 102                     #continue
 103             #else:
 104                 ## xxx update the record ...
 105                 #pass
 106             #site_record.stale=False
 107
 108          ## import node records in site
 109             #for node_id in site['node_ids']:
 110                 #try:
 111                     #node = nodes_by_id[node_id]
 112                 #except:
 113                     #self.logger.warning ("SlabImporter: cannot find node_id %s - ignored"%node_id)
 114                     #continue
 115                 #site_auth = get_authority(site_hrn)
 116                 #site_name = site['login_base']
 117                 #hrn =  self.hostname_to_hrn(root_auth, site_name, node['hostname'])
 118                 ## xxx this sounds suspicious
 119                 #if len(hrn) > 64: hrn = hrn[:64]
 120                 #node_record = self.find_record_by_type_hrn( 'node', hrn )
 121                 #print >>sys.stderr, " \r\n \r\n SLAB IMPORTER node_record %s " %(node_record)
 122                 #if not node_record:
 123                     #try:
 124                         #pkey = Keypair(create=True)
 125                         #urn = hrn_to_urn(hrn, 'node')
 126                         #print>>sys.stderr, "\r\n \r\n SLAB IMPORTER NODE IMPORT urn %s hrn %s" %(urn, hrn)
 127                         #node_gid = self.auth_hierarchy.create_gid(urn, create_uuid(), pkey)
 128                         #node_record = RegNode (hrn=hrn, gid=node_gid,
 129                                                 #pointer =node['node_id'],
 130                                                 #authority=get_authority(hrn))
 131                         #node_record.just_created()
 132                         #dbsession.add(node_record)
 133                         #dbsession.commit()
 134                         #self.logger.info("SlabImporter: imported node: %s" % node_record)
 135                         #print>>sys.stderr, "\r\n \t\t\t SLAB IMPORTER NODE IMPORT NOTnode_record %s " %(node_record)
 136                         #self.update_just_added_records_dict(node_record)
 137                     #except:
 138                         #self.logger.log_exc("SlabImporter: failed to import node")
 139                 #else:
 140                     ## xxx update the record ...
 141                     #pass
 142                 #node_record.stale=False
 143
 144
 145             ## import persons
 146             #for person in ldap_person_listdict :
 147
 148                 #person_hrn = person['hrn']
 149                 #slice_hrn = self.slicename_to_hrn(person['hrn'],'_slice')
 150
 151                 ## xxx suspicious again
 152                 #if len(person_hrn) > 64: person_hrn = person_hrn[:64]
 153                 #person_urn = hrn_to_urn(person_hrn, 'user')
 154
 155                 #user_record = self.find_record_by_type_hrn( 'user', person_hrn)
 156                 #slice_record = self.find_record_by_type_hrn ('slice', slice_hrn)
 157                 #print>>sys.stderr, "\r\n \r\n SLAB IMPORTER PERSON IMPORT user_record %s " %(user_record)
 158
 159
 160                 ## return a tuple pubkey (a plc key object) and pkey (a Keypair object)
 161                 #def init_person_key (person, slab_key):
 162                     #pubkey=None
 163                     #if  person['pkey']:
 164                         ## randomly pick first key in set
 165                         #pubkey = slab_key
 166                         #try:
 167                             #pkey = convert_public_key(pubkey)
 168                         #except:
 169                             #self.logger.warn('SlabImporter: unable to convert public key for %s' % person_hrn)
 170                             #pkey = Keypair(create=True)
 171                     #else:
 172                         ## the user has no keys. Creating a random keypair for the user's gid
 173                         #self.logger.warn("SlabImporter: person %s does not have a PL public key"%person_hrn)
 174                         #pkey = Keypair(create=True)
 175                     #return (pubkey, pkey)
 176
 177
 178                 #try:
 179                     #slab_key = person['pkey']
 180                     ## new person
 181                     #if not user_record:
 182                         #(pubkey,pkey) = init_person_key (person, slab_key )
 183                         #person_gid = self.auth_hierarchy.create_gid(person_urn, create_uuid(), pkey)
 184                         #person_gid.set_email(person['email'])
 185                         #user_record = RegUser (hrn=person_hrn, gid=person_gid,
 186                                                  #pointer='-1',
 187                                                  #authority=get_authority(person_hrn),
 188                                                  #email=person['email'])
 189                         #if pubkey:
 190                             #user_record.reg_keys=[RegKey (pubkey)]
 191                         #else:
 192                             #self.logger.warning("No key found for user %s"%user_record)
 193                         #user_record.just_created()
 194                         #dbsession.add (user_record)
 195                         #dbsession.commit()
 196                         #self.logger.info("SlabImporter: imported person: %s" % user_record)
 197                         #print>>sys.stderr, "\r\n \r\n SLAB IMPORTER PERSON IMPORT NOTuser_record %s " %(user_record)
 198                         #self.update_just_added_records_dict( user_record )
 199                     #else:
 200                         ## update the record ?
 201                         ## if user's primary key has changed then we need to update the
 202                         ## users gid by forcing an update here
 203                         #sfa_keys = user_record.reg_keys
 204                         ##def key_in_list (key,sfa_keys):
 205                             ##for reg_key in sfa_keys:
 206                                 ##if reg_key.key==key['key']: return True
 207                             ##return False
 208                         ## is there a new key in myplc ?
 209                         #new_keys=False
 210                         #if key is not sfa_keys :
 211                             #new_keys = True
 212                         #if new_keys:
 213                             #(pubkey,pkey) = init_person_key (person, slab_key)
 214                             #person_gid = self.auth_hierarchy.create_gid(person_urn, create_uuid(), pkey)
 215                             #if not pubkey:
 216                                 #user_record.reg_keys=[]
 217                             #else:
 218                                 #user_record.reg_keys=[ RegKey (pubkey)]
 219                             #self.logger.info("SlabImporter: updated person: %s" % user_record)
 220                     #user_record.email = person['email']
 221                     #dbsession.commit()
 222                     #user_record.stale=False
 223                 #except:
 224                     #self.logger.log_exc("SlabImporter: failed to import person  %s"%(person) )
 225
 226                 #if not slice_record:
 227                     #try:
 228                         #pkey = Keypair(create=True)
 229                         #urn = hrn_to_urn(slice_hrn, 'slice')
 230                         #slice_gid = self.auth_hierarchy.create_gid(urn, create_uuid(), pkey)
 231                         #slice_record = RegSlice (hrn=slice_hrn, gid=slice_gid,
 232                                                     #pointer='-1',
 233                                                     #authority=get_authority(slice_hrn))
 234                         #print>>sys.stderr, "\r\n \r\n SLAB IMPORTER SLICE IMPORT NOTslice_record%s " %(slice_record)
 235                         #slice_record.just_created()
 236                         #dbsession.add(slice_record)
 237                         #dbsession.commit()
 238                         #self.logger.info("SlabImporter: imported slice: %s" % slice_record)
 239                         #self.remember_record ( slice_record )
 240                     #except:
 241                         #self.logger.log_exc("SlabImporter: failed to import slice")
 242                 #else:
 243                     ## xxx update the record ...
 244                     #self.logger.warning ("Slice update not yet implemented")
 245                     #pass
 246                 ## record current users affiliated with the slice
 247                 #slice_record.reg_researchers = \
 248                     #[ self.locate_by_type_pointer ('user',user_id) for user_id in slice['person_ids'] ]
 249                 #dbsession.commit()
 250                 #slice_record.stale=False
 251
 252
 253
 254          #### remove stale records
 255         ## special records must be preserved
 256         #system_hrns = [interface_hrn, root_auth, interface_hrn + '.slicemanager']
 257         #for record in all_records:
 258             #if record.hrn in system_hrns:
 259                 #record.stale=False
 260             #if record.peer_authority:
 261                 #record.stale=False
 262
 263
 264         #for record in all_records:
 265             #try:
 266                 #stale=record.stale
 267             #except:
 268                 #stale=True
 269                 #self.logger.warning("stale not found with %s"%record)
 270             #if stale:
 271                 #self.logger.info("SlabImporter: deleting stale record: %s" % record)
 272                 #dbsession.delete(record)
 273                 #dbsession.commit()
 274
 275
 276