""" 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.iotlabshell import IotlabShell
# from sfa.iotlab.iotlabdriver import IotlabDriver
-from sfa.iotlab.iotlabpostgres import TestbedAdditionalSfaDB
+# 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
# 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)
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()
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
: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 = testbed_shell.GetPersons()
self.logger.info("IOTLABIMPORT \t ldap_person_listdict %s \r\n"
#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.
root_auth = config.SFA_REGISTRY_ROOT_AUTH
testbed_shell = IotlabShell(config)
- leases_db = TestbedAdditionalSfaDB(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(testbed_shell)
#import users and slice into the SFA DB.
- self.import_persons_and_slices(testbed_shell)
+ #self.import_persons_and_slices(testbed_shell)
### remove stale records
# special records must be preserved