""" File defining the importer class and all the methods needed to import
the nodes, users and slices from OAR and LDAP to the SFA database.
-Also creates the iotlab specific databse and table to keep track
+Also creates the iotlab specific table to keep track
of which slice hrn contains which job.
"""
from sfa.util.config import Config
from sfa.util.xrn import Xrn, get_authority, hrn_to_urn
-
-from sfa.iotlab.iotlabdriver import IotlabDriver
-from sfa.iotlab.iotlabpostgres import TestbedAdditionalSfaDB
+from sfa.iotlab.iotlabshell import IotlabShell
+# from sfa.iotlab.iotlabdriver import IotlabDriver
+# from sfa.iotlab.iotlabpostgres import TestbedAdditionalSfaDB
from sfa.trust.certificate import Keypair, convert_public_key
from sfa.trust.gid import create_uuid
-# using global alchemy.session() here is fine
+# using global alchemy.session() here is fine
# as importer is on standalone one-shot process
-from sfa.storage.alchemy import global_dbsession
+
+from sfa.storage.alchemy import global_dbsession, engine
from sfa.storage.model import RegRecord, RegAuthority, RegSlice, RegNode, \
- RegUser, RegKey
+ RegUser, RegKey, init_tables
+from sqlalchemy import Table, MetaData
+from sqlalchemy.exc import SQLAlchemyError, NoSuchTableError
-from sqlalchemy.exc import SQLAlchemyError
class IotlabImporter:
self.auth_hierarchy = auth_hierarchy
self.logger = loc_logger
self.logger.setLevelDebug()
+
#retrieve all existing SFA objects
self.all_records = global_dbsession.query(RegRecord).all()
for record in self.all_records if record.pointer != -1])
+
+ def exists(self, tablename):
+ """
+ Checks if the table specified as tablename exists.
+ :param tablename: name of the table in the db that has to be checked.
+ :type tablename: string
+ :returns: True if the table exists, False otherwise.
+ :rtype: bool
+
+ """
+ metadata = MetaData(bind=engine)
+ try:
+ table = Table(tablename, metadata, autoload=True)
+ return True
+
+ except NoSuchTableError:
+ self.logger.log_exc("Iotlabimporter tablename %s does not exist"
+ % (tablename))
+ return False
+
+
@staticmethod
def hostname_to_hrn_escaped(root_auth, hostname):
"""
def locate_by_type_pointer(self, record_type, pointer):
"""
-
- Returns the record corresponding to the key pointer and record
- type. Returns None if the record does not exist and is not in the
- records_by_type_pointer dictionnary.
+ Returns the record corresponding to the key pointer and record type.
+ Returns None if the record does not exist and is not in the
+ records_by_type_pointer dictionnary.
:param record_type: the record's type (slice, node, authority...)
:type record_type: string
- :param pointer:Pointer to where the record is in the origin db,
+ :param pointer: Pointer to where the record is in the origin db,
used in case the record comes from a trusted authority.
:type pointer: integer
- :rtype: RegUser if user, RegSlice if slice, RegNode if node...
- or None if record does not exist.
+ :rtype: RegUser if user, RegSlice if slice, RegNode if node, or None if
+ record does not exist.
"""
return self.records_by_type_pointer.get((record_type, pointer), None)
self.records_by_type_hrn[rec_tuple] = record
- def import_nodes(self, site_node_ids, nodes_by_id, iotlabdriver):
+ def import_nodes(self, site_node_ids, nodes_by_id, testbed_shell):
"""
Creates appropriate hostnames and RegNode records for each node in
:param nodes_by_id: dictionary , key is the node id, value is the a dict
with node information.
:type nodes_by_id: dictionary
- :param iotlabdriver: IotlabDriver object, used to have access to
- iotlabdriver attributes.
- :type iotlabdriver: IotlabDriver
+ :param testbed_shell: IotlabDriver object, used to have access to
+ testbed_shell attributes.
+ :type testbed_shell: IotlabDriver
:returns: None
:rtype: None
- ignored" % (node_id))
continue
escaped_hrn = \
- self.hostname_to_hrn_escaped(iotlabdriver.testbed_shell.root_auth,
+ self.hostname_to_hrn_escaped(testbed_shell.root_auth,
node['hostname'])
self.logger.info("IOTLABIMPORTER node %s " % (node))
hrn = node['hrn']
node_gid = \
self.auth_hierarchy.create_gid(urn, create_uuid(), pkey)
- def iotlab_get_authority(hrn):
+ def testbed_get_authority(hrn):
""" Gets the authority part in the hrn.
:param hrn: hrn whose authority we are looking for.
:type hrn: string
node_record = RegNode(hrn=hrn, gid=node_gid,
pointer='-1',
- authority=iotlab_get_authority(hrn))
+ authority=testbed_get_authority(hrn))
try:
node_record.just_created()
pass
node_record.stale = False
- def import_sites_and_nodes(self, iotlabdriver):
+ def import_sites_and_nodes(self, testbed_shell):
"""
Gets all the sites and nodes from OAR, process the information,
For each site, import the site's nodes to the DB by calling
import_nodes.
- :param iotlabdriver: IotlabDriver object, used to have access to
- iotlabdriver methods and fetching info on sites and nodes.
- :type iotlabdriver: IotlabDriver
+ :param testbed_shell: IotlabDriver object, used to have access to
+ testbed_shell methods and fetching info on sites and nodes.
+ :type testbed_shell: IotlabDriver
"""
- sites_listdict = iotlabdriver.testbed_shell.GetSites()
- nodes_listdict = iotlabdriver.testbed_shell.GetNodes()
+ sites_listdict = testbed_shell.GetSites()
+ nodes_listdict = testbed_shell.GetNodes()
nodes_by_id = dict([(node['node_id'], node) for node in nodes_listdict])
for site in sites_listdict:
site_hrn = site['name']
pass
site_record.stale = False
- self.import_nodes(site['node_ids'], nodes_by_id, iotlabdriver)
+ self.import_nodes(site['node_ids'], nodes_by_id, testbed_shell)
return
def init_person_key(self, person, iotlab_key):
"""
-
Returns a tuple pubkey and pkey.
:param person Person's data.
:type person: dict
- :param iotlab_key: SSH public key, from LDAP user's data.
- RSA type supported.
+ :param iotlab_key: SSH public key, from LDAP user's data. RSA type
+ supported.
:type iotlab_key: string
- :rtype (string, Keypair)
+ :rtype: (string, Keypair)
"""
pubkey = None
pkey = Keypair(create=True)
return (pubkey, pkey)
- def import_persons_and_slices(self, iotlabdriver):
+ def import_persons_and_slices(self, testbed_shell):
"""
Gets user data from LDAP, process the information.
import the user's slice onto the database as well by calling
import_slice.
- :param iotlabdriver: IotlabDriver object, used to have access to
- iotlabdriver attributes.
- :type iotlabdriver: IotlabDriver
+ :param testbed_shell: IotlabDriver object, used to have access to
+ testbed_shell attributes.
+ :type testbed_shell: IotlabDriver
+
+ .. warning:: does not support multiple keys per user
"""
- ldap_person_listdict = iotlabdriver.testbed_shell.GetPersons()
+ ldap_person_listdict = testbed_shell.GetPersons()
self.logger.info("IOTLABIMPORT \t ldap_person_listdict %s \r\n"
% (ldap_person_listdict))
#No slice update upon import in iotlab
else:
# xxx update the record ...
- self.logger.warning("Slice update not yet implemented")
- pass
- # record current users affiliated with the slice
-
+ self.logger.warning("Iotlab Slice update not implemented")
+ # record current users affiliated with the slice
slice_record.reg_researchers = [user_record]
try:
global_dbsession.commit()
def run(self, options):
"""
- Create the special iotlab table, testbed_xp, in the iotlab database.
+ Create the special iotlab table, lease_table, in the SFA database.
Import everything (users, slices, nodes and sites from OAR
and LDAP) into the SFA database.
Delete stale records that are no longer in OAR or LDAP.
:param options:
:type options:
"""
- config = Config()
- iotlabdriver = IotlabDriver(config)
- leases_db = TestbedAdditionalSfaDB(config)
+ config = Config ()
+ interface_hrn = config.SFA_INTERFACE_HRN
+ root_auth = config.SFA_REGISTRY_ROOT_AUTH
+
+ testbed_shell = IotlabShell(config)
+ # leases_db = TestbedAdditionalSfaDB(config)
#Create special slice table for iotlab
- if not leases_db.exists('testbed_xp'):
- leases_db.createtable()
- self.logger.info("IotlabImporter.run: testbed_xp table created ")
+ if not self.exists('lease_table'):
+ init_tables(engine)
+ self.logger.info("IotlabImporter.run: lease_table table created ")
# import site and node records in site into the SFA db.
- self.import_sites_and_nodes(iotlabdriver)
+ self.import_sites_and_nodes(testbed_shell)
#import users and slice into the SFA DB.
- self.import_persons_and_slices(iotlabdriver)
+ #self.import_persons_and_slices(testbed_shell)
### remove stale records
# special records must be preserved
- system_hrns = [iotlabdriver.hrn, iotlabdriver.testbed_shell.root_auth,
- iotlabdriver.hrn + '.slicemanager']
+ system_hrns = [interface_hrn, root_auth,
+ interface_hrn + '.slicemanager']
for record in self.all_records:
if record.hrn in system_hrns:
record.stale = False
git://git.onelab.eu / sfa.git / blobdiff