# RSA keys at this time, not DSA keys.
##
-import getopt
-import sys
-import tempfile
+from sfa.util.sfalogging import _SfaLogger
-from sfa.util.sfalogging import sfa_import_logger
-from sfa.util.record import *
+from sfa.util.record import SfaRecord
from sfa.util.table import SfaTable
-from sfa.util.namespace import *
+from sfa.util.xrn import get_authority, hrn_to_urn
+from sfa.util.plxrn import email_to_hrn
from sfa.util.config import Config
from sfa.trust.certificate import convert_public_key, Keypair
-from sfa.trust.trustedroot import *
-from sfa.trust.hierarchy import *
+from sfa.trust.trustedroots import TrustedRoots
+from sfa.trust.hierarchy import Hierarchy
from sfa.trust.gid import create_uuid
class sfaImport:
def __init__(self):
- self.logger = sfa_import_logger
- self.AuthHierarchy = Hierarchy()
- self.config = Config()
- self.TrustedRoots = TrustedRootList(Config.get_trustedroots_dir(self.config))
- self.plc_auth = self.config.get_plc_auth()
- self.root_auth = self.config.SFA_REGISTRY_ROOT_AUTH
+ self.logger = _SfaLogger(logfile='/var/log/sfa_import.log', loggername='importlog')
+ self.AuthHierarchy = Hierarchy()
+ self.config = Config()
+ self.TrustedRoots = TrustedRoots(Config.get_trustedroots_dir(self.config))
+ self.plc_auth = self.config.get_plc_auth()
+ self.root_auth = self.config.SFA_REGISTRY_ROOT_AUTH
- # connect to planetlab
- self.shell = None
- if "Url" in self.plc_auth:
- from sfa.plc.remoteshell import RemoteShell
- self.shell = RemoteShell(self.logger)
- else:
- import PLC.Shell
- self.shell = PLC.Shell.Shell(globals = globals())
-
+ # connect to planetlab
+ self.shell = None
+ if "Url" in self.plc_auth:
+ from sfa.plc.remoteshell import RemoteShell
+ self.shell = RemoteShell(self.logger)
+ else:
+ import PLC.Shell
+ self.shell = PLC.Shell.Shell(globals = globals())
def create_top_level_auth_records(self, hrn):
+ """
+ Create top level records (includes root and sub authorities (local/remote)
+ """
urn = hrn_to_urn(hrn, 'authority')
# make sure parent exists
parent_hrn = get_authority(hrn)
# create the authority if it doesnt already exist
if not self.AuthHierarchy.auth_exists(urn):
- self.logger.info("Import: creating top level authorites")
+ self.logger.info("Import: creating top level authorities")
self.AuthHierarchy.create_auth(urn)
# create the db record if it doesnt already exist
if not auth_record:
auth_record = SfaRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=-1)
auth_record['authority'] = get_authority(auth_record['hrn'])
- self.logger.info("Import: inserting authority record for " + hrn)
+ self.logger.info("Import: inserting authority record for %s"%hrn)
table.insert(auth_record)
+ def create_sm_client_record(self):
+ """
+ Create a user record for the Slicemanager service.
+ """
+ hrn = self.config.SFA_INTERFACE_HRN + '.slicemanager'
+ urn = hrn_to_urn(hrn, 'user')
+ if not self.AuthHierarchy.auth_exists(urn):
+ self.logger.info("Import: creating Slice Manager user")
+ self.AuthHierarchy.create_auth(urn)
+
+ auth_info = self.AuthHierarchy.get_auth_info(hrn)
+ table = SfaTable()
+ sm_user_record = table.find({'type': 'user', 'hrn': hrn})
+ if not sm_user_record:
+ record = SfaRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="user", pointer=-1)
+ record['authority'] = get_authority(record['hrn'])
+ table.insert(record)
+
+ def create_interface_records(self):
+ """
+ Create a record for each SFA interface
+ """
+ # just create certs for all sfa interfaces even if they
+ # arent enabled
+ interface_hrn = self.config.SFA_INTERFACE_HRN
+ interfaces = ['authority+sa', 'authority+am', 'authority+sm']
+ table = SfaTable()
+ auth_info = self.AuthHierarchy.get_auth_info(interface_hrn)
+ pkey = auth_info.get_pkey_object()
+ for interface in interfaces:
+ interface_record = table.find({'type': interface, 'hrn': interface_hrn})
+ if not interface_record:
+ self.logger.info("Import: interface %s %s " % (interface_hrn, interface))
+ urn = hrn_to_urn(interface_hrn, interface)
+ gid = self.AuthHierarchy.create_gid(urn, create_uuid(), pkey)
+ record = SfaRecord(hrn=interface_hrn, gid=gid, type=interface, pointer=-1)
+ record['authority'] = get_authority(interface_hrn)
+ table.insert(record)
+
+
def import_person(self, parent_hrn, person):
+ """
+ Register a user record
+ """
hrn = email_to_hrn(parent_hrn, person['email'])
# ASN.1 will have problems with hrn's longer than 64 characters
if len(hrn) > 64:
hrn = hrn[:64]
- self.logger.info("Import: importing person " + hrn)
+ self.logger.info("Import: person %s"%hrn)
key_ids = []
if 'key_ids' in person and person['key_ids']:
key_ids = person["key_ids"]
# to planetlab
keys = self.shell.GetKeys(self.plc_auth, key_ids)
key = keys[0]['key']
- pkey = convert_public_key(key)
+ pkey = None
+ try:
+ pkey = convert_public_key(key)
+ except:
+ self.logger.warn('unable to convert public key for %s' % hrn)
if not pkey:
pkey = Keypair(create=True)
else:
# the user has no keys
- self.logger.info(" person " + hrn + " does not have a PL public key")
+ self.logger.warn("Import: person %s does not have a PL public key"%hrn)
# if a key is unavailable, then we still need to put something in the
# user's GID. So make one up.
pkey = Keypair(create=True)
slicename = _cleanup_string(slicename)
if not slicename:
- self.logger.error("Import_Slice: failed to parse slice name " + slice['name'])
+ self.logger.error("Import: failed to parse slice name %s" %slice['name'])
return
hrn = parent_hrn + "." + slicename
- self.logger.info("Import: importing slice " + hrn)
+ self.logger.info("Import: slice %s"%hrn)
pkey = Keypair(create=True)
urn = hrn_to_urn(hrn, 'slice')
slice_record['record_id'] = existing_record['record_id']
table.update(slice_record)
- def import_node(self, parent_hrn, node):
- nodename = node['hostname'].split(".")[0]
- nodename = _cleanup_string(nodename)
-
- if not nodename:
- self.logger.error("Import_node: failed to parse node name " + node['hostname'])
- return
-
- hrn = parent_hrn + "." + nodename
- self.logger.info("Import: importing node " + hrn)
+ def import_node(self, hrn, node):
+ self.logger.info("Import: node %s" % hrn)
# ASN.1 will have problems with hrn's longer than 64 characters
if len(hrn) > 64:
hrn = hrn[:64]
table.update(node_record)
- def import_site(self, parent_hrn, site):
- shell = self.shell
- plc_auth = self.plc_auth
- sitename = site['login_base']
- sitename = _cleanup_string(sitename)
- print 'importing site %s' % sitename
- hrn = parent_hrn + "." + sitename
- # Hardcode 'internet2' into the hrn for sites hosting
- # internet2 nodes. This is a special operation for some vini
- # sites only
- if ".vini" in parent_hrn and parent_hrn.endswith('vini'):
- if sitename.startswith("i2"):
- #sitename = sitename.replace("ii", "")
- hrn = ".".join([parent_hrn, "internet2", sitename])
- elif sitename.startswith("nlr"):
- #sitename = sitename.replace("nlr", "")
- hrn = ".".join([parent_hrn, "internet2", sitename])
-
+ def import_site(self, hrn, site):
urn = hrn_to_urn(hrn, 'authority')
- self.logger.info("Import: importing site " + hrn)
+ self.logger.info("Import: site %s"%hrn)
# create the authority
if not self.AuthHierarchy.auth_exists(urn):
table = SfaTable()
record_list = table.find({'type': type, 'hrn': hrn})
for record in record_list:
- self.logger.info("Import: Removing record %s %s" % (type, hrn))
+ self.logger.info("Import: removing record %s %s" % (type, hrn))
table.remove(record)
git://git.onelab.eu / sfa.git / blobdiff