"""
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):
"""
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.iotlab_api.root_auth,
+ self.hostname_to_hrn_escaped(testbed_shell.root_auth,
node['hostname'])
self.logger.info("IOTLABIMPORTER node %s " % (node))
hrn = node['hrn']
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.iotlab_api.GetSites()
- nodes_listdict = iotlabdriver.iotlab_api.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
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.iotlab_api.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 iotlab 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)
- iotlab_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 iotlab_db.exists('testbed_xp'):
- iotlab_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.iotlab_api.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