import tempfile
from sfa.util.record import *
-from sfa.util.genitable import GeniTable
-from sfa.util.misc import *
+from sfa.util.table import SfaTable
+from sfa.util.namespace import *
from sfa.util.config import Config
from sfa.util.report import trace, error
-
from sfa.trust.certificate import convert_public_key, Keypair
from sfa.trust.trustedroot import *
from sfa.trust.hierarchy import *
class sfaImport:
- def __init__(self):
+ def __init__(self, logger=None):
+ self.logger = logger
self.AuthHierarchy = Hierarchy()
- self.TrustedRoots = TrustedRootList()
-
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.level1_auth = self.config.SFA_REGISTRY_LEVEL1_AUTH
- if not self.level1_auth or self.level1_auth in ['']:
- self.level1_auth = None
# connect to planetlab
self.shell = None
def create_top_level_auth_records(self, hrn):
AuthHierarchy = self.AuthHierarchy
-
- # if auth records for this hrn dont exist, create it
- if not AuthHierarchy.auth_exists(hrn):
- AuthHierarchy.create_auth(hrn)
-
-
- # get the auth info of the newly created root auth (parent)
- # or level1_auth if it exists
- if self.level1_auth:
- auth_info = AuthHierarchy.get_auth_info(hrn)
+ urn = hrn_to_urn(hrn, 'authority')
+ # make sure parent exists
+ parent_hrn = get_authority(hrn)
+ if not parent_hrn:
parent_hrn = hrn
- else:
- parent_hrn = get_authority(hrn)
- if not parent_hrn:
- parent_hrn = hrn
- auth_info = AuthHierarchy.get_auth_info(parent_hrn)
-
- table = GeniTable()
+ if not parent_hrn == hrn:
+ self.create_top_level_auth_records(parent_hrn)
+
+ # create the authority if it doesnt already exist
+ if not AuthHierarchy.auth_exists(urn):
+ trace("Import: creating top level authorites", self.logger)
+ AuthHierarchy.create_auth(urn)
+
+ # create the db record if it doesnt already exist
+ auth_info = AuthHierarchy.get_auth_info(hrn)
+ table = SfaTable()
auth_record = table.find({'type': 'authority', 'hrn': hrn})
if not auth_record:
- auth_record = GeniRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=-1)
- trace(" inserting authority record for " + hrn)
+ auth_record = SfaRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=-1)
+ auth_record['authority'] = get_authority(auth_record['hrn'])
+ trace("Import: inserting authority record for " + hrn, self.logger)
table.insert(auth_record)
if len(hrn) > 64:
hrn = hrn[:64]
- trace("Import: importing person " + hrn)
+ trace("Import: importing person " + hrn, self.logger)
key_ids = []
if 'key_ids' in person and person['key_ids']:
key_ids = person["key_ids"]
pkey = Keypair(create=True)
else:
# the user has no keys
- trace(" person " + hrn + " does not have a PL public key")
+ trace(" person " + hrn + " does not have a PL public key", self.logger)
# 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)
# create the gid
- person_gid = AuthHierarchy.create_gid(hrn, create_uuid(), pkey)
- table = GeniTable()
- person_record = GeniRecord(hrn=hrn, gid=person_gid, type="user", pointer=person['person_id'])
+ urn = hrn_to_urn(hrn, 'user')
+ person_gid = AuthHierarchy.create_gid(urn, create_uuid(), pkey)
+ table = SfaTable()
+ person_record = SfaRecord(hrn=hrn, gid=person_gid, type="user", pointer=person['person_id'])
person_record['authority'] = get_authority(person_record['hrn'])
existing_records = table.find({'hrn': hrn, 'type': 'user', 'pointer': person['person_id']})
if not existing_records:
table.insert(person_record)
else:
- trace("Import: %s exists, updating " % hrn)
+ trace("Import: %s exists, updating " % hrn, self.logger)
existing_record = existing_records[0]
person_record['record_id'] = existing_record['record_id']
table.update(person_record)
slicename = cleanup_string(slicename)
if not slicename:
- error("Import_Slice: failed to parse slice name " + slice['name'])
+ error("Import_Slice: failed to parse slice name " + slice['name'], self.logger)
return
hrn = parent_hrn + "." + slicename
- trace("Import: importing slice " + hrn)
+ trace("Import: importing slice " + hrn, self.logger)
pkey = Keypair(create=True)
- slice_gid = AuthHierarchy.create_gid(hrn, create_uuid(), pkey)
- slice_record = GeniRecord(hrn=hrn, gid=slice_gid, type="slice", pointer=slice['slice_id'])
+ urn = hrn_to_urn(hrn, 'slice')
+ slice_gid = AuthHierarchy.create_gid(urn, create_uuid(), pkey)
+ slice_record = SfaRecord(hrn=hrn, gid=slice_gid, type="slice", pointer=slice['slice_id'])
slice_record['authority'] = get_authority(slice_record['hrn'])
- table = GeniTable()
+ table = SfaTable()
existing_records = table.find({'hrn': hrn, 'type': 'slice', 'pointer': slice['slice_id']})
if not existing_records:
table.insert(slice_record)
else:
- trace("Import: %s exists, updating " % hrn)
+ trace("Import: %s exists, updating " % hrn, self.logger)
existing_record = existing_records[0]
slice_record['record_id'] = existing_record['record_id']
table.update(slice_record)
nodename = cleanup_string(nodename)
if not nodename:
- error("Import_node: failed to parse node name " + node['hostname'])
+ error("Import_node: failed to parse node name " + node['hostname'], self.logger)
return
hrn = parent_hrn + "." + nodename
- trace("Import: importing node " + hrn)
+ trace("Import: importing node " + hrn, self.logger)
# ASN.1 will have problems with hrn's longer than 64 characters
if len(hrn) > 64:
hrn = hrn[:64]
- table = GeniTable()
+ table = SfaTable()
node_record = table.find({'type': 'node', 'hrn': hrn})
pkey = Keypair(create=True)
- node_gid = AuthHierarchy.create_gid(hrn, create_uuid(), pkey)
- node_record = GeniRecord(hrn=hrn, gid=node_gid, type="node", pointer=node['node_id'])
+ urn = hrn_to_urn(hrn, 'node')
+ node_gid = AuthHierarchy.create_gid(urn, create_uuid(), pkey)
+ node_record = SfaRecord(hrn=hrn, gid=node_gid, type="node", pointer=node['node_id'])
node_record['authority'] = get_authority(node_record['hrn'])
existing_records = table.find({'hrn': hrn, 'type': 'node', 'pointer': node['node_id']})
if not existing_records:
table.insert(node_record)
else:
- trace("Import: %s exists, updating " % hrn)
+ trace("Import: %s exists, updating " % hrn, self.logger)
existing_record = existing_records[0]
node_record['record_id'] = existing_record['record_id']
table.update(node_record)
plc_auth = self.plc_auth
sitename = site['login_base']
sitename = cleanup_string(sitename)
-
+ print 'importing site %s' % sitename
hrn = parent_hrn + "." + sitename
-
+ urn = hrn_to_urn(hrn, 'authority')
# 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("ii"):
- sitename = sitename.replace("ii", "")
+ 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])
- sitename = sitename.replace("nlr", "")
- trace("Import_Site: importing site " + hrn)
+ trace("Import: importing site " + hrn, self.logger)
# create the authority
- if not AuthHierarchy.auth_exists(hrn):
- AuthHierarchy.create_auth(hrn)
+ if not AuthHierarchy.auth_exists(urn):
+ AuthHierarchy.create_auth(urn)
- auth_info = AuthHierarchy.get_auth_info(hrn)
+ auth_info = AuthHierarchy.get_auth_info(urn)
- table = GeniTable()
- auth_record = GeniRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=site['site_id'])
+ table = SfaTable()
+ auth_record = SfaRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=site['site_id'])
auth_record['authority'] = get_authority(auth_record['hrn'])
existing_records = table.find({'hrn': hrn, 'type': 'authority', 'pointer': site['site_id']})
if not existing_records:
table.insert(auth_record)
else:
- trace("Import: %s exists, updating " % hrn)
- existing_record = existing_record[0]
+ trace("Import: %s exists, updating " % hrn, self.logger)
+ existing_record = existing_records[0]
auth_record['record_id'] = existing_record['record_id']
table.update(auth_record)
+ return hrn
+
def delete_record(self, hrn, type):
# delete the record
- table = GeniTable()
+ table = SfaTable()
record_list = table.find({'type': type, 'hrn': hrn})
for record in record_list:
+ trace("Import: Removing record %s %s" % (type, hrn), self.logger)
table.remove(record)
git://git.onelab.eu / sfa.git / blobdiff