git://git.onelab.eu / sfa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Quick fix in AddLEases.
[sfa.git] / sfa / iotlab / iotlabapi.py
diff --git a/sfa/iotlab/iotlabapi.py b/sfa/iotlab/iotlabapi.py
index 0e3e900..f50441d 100644 (file)
--- a/sfa/iotlab/iotlabapi.py
+++ b/sfa/iotlab/iotlabapi.py
@@ -11,7 +11,7 @@ from sfa.util.sfalogging import logger
 from sfa.storage.alchemy import dbsession
 from sqlalchemy.orm import joinedload
 from sfa.storage.model import RegRecord, RegUser, RegSlice, RegKey
 from sfa.storage.alchemy import dbsession
 from sqlalchemy.orm import joinedload
 from sfa.storage.model import RegRecord, RegUser, RegSlice, RegKey
-from sfa.iotlab.iotlabpostgres import IotlabDB, IotlabXP
+from sfa.iotlab.iotlabpostgres import TestbedAdditionalSfaDB, LeaseTableXP
 from sfa.iotlab.OARrestapi import OARrestapi
 from sfa.iotlab.LDAPapi import LDAPapi
 
 from sfa.iotlab.OARrestapi import OARrestapi
 from sfa.iotlab.LDAPapi import LDAPapi
 
@@ -26,7 +26,7 @@ from sfa.iotlab.iotlabaggregate import iotlab_xrn_object
 class IotlabTestbedAPI():
     """ Class enabled to use LDAP and OAR api calls. """
 
 class IotlabTestbedAPI():
     """ Class enabled to use LDAP and OAR api calls. """
 
-    _MINIMUM_DURATION = 600
+    _MINIMUM_DURATION = 10  # 10 units of granularity 60 s, 10 mins
 
     def __init__(self, config):
         """Creates an instance of OARrestapi and LDAPapi which will be used to
 
     def __init__(self, config):
         """Creates an instance of OARrestapi and LDAPapi which will be used to
@@ -37,12 +37,12 @@ class IotlabTestbedAPI():
         :param config: configuration object from sfa.util.config
         :type config: Config object
         """
         :param config: configuration object from sfa.util.config
         :type config: Config object
         """
-        self.iotlab_db = IotlabDB(config)
+        self.iotlab_db = TestbedAdditionalSfaDB(config)
         self.oar = OARrestapi()
         self.ldap = LDAPapi()
         self.time_format = "%Y-%m-%d %H:%M:%S"
         self.root_auth = config.SFA_REGISTRY_ROOT_AUTH
         self.oar = OARrestapi()
         self.ldap = LDAPapi()
         self.time_format = "%Y-%m-%d %H:%M:%S"
         self.root_auth = config.SFA_REGISTRY_ROOT_AUTH
-        self.grain = 1  # 10 mins lease minimum, 1 sec granularity
+        self.grain = 60  # 10 mins lease minimum, 60 sec granularity
         #import logging, logging.handlers
         #from sfa.util.sfalogging import _SfaLogger
         #sql_logger = _SfaLogger(loggername = 'sqlalchemy.engine', \
         #import logging, logging.handlers
         #from sfa.util.sfalogging import _SfaLogger
         #sql_logger = _SfaLogger(loggername = 'sqlalchemy.engine', \
@@ -50,7 +50,7 @@ class IotlabTestbedAPI():
         return
 
     @staticmethod
         return
 
     @staticmethod
-    def GetMinExperimentDurationInSec():
+    def GetMinExperimentDurationInGranularity():
         """ Returns the minimum allowed duration for an experiment on the
         testbed. In seconds.
 
         """ Returns the minimum allowed duration for an experiment on the
         testbed. In seconds.
 
@@ -58,7 +58,7 @@ class IotlabTestbedAPI():
         return IotlabTestbedAPI._MINIMUM_DURATION
 
     @staticmethod
         return IotlabTestbedAPI._MINIMUM_DURATION
 
     @staticmethod
-    def GetPeers (peer_filter=None ):
+    def GetPeers(peer_filter=None ):
         """ Gathers registered authorities in SFA DB and looks for specific peer
         if peer_filter is specified.
         :param peer_filter: name of the site authority looked for.
         """ Gathers registered authorities in SFA DB and looks for specific peer
         if peer_filter is specified.
         :param peer_filter: name of the site authority looked for.
@@ -69,8 +69,7 @@ class IotlabTestbedAPI():
 
         existing_records = {}
         existing_hrns_by_types = {}
 
         existing_records = {}
         existing_hrns_by_types = {}
-        logger.debug("IOTLABDRIVER \tGetPeers peer_filter %s, \
-                    " %(peer_filter))
+        logger.debug("IOTLAB_API \tGetPeers peer_filter %s " % (peer_filter))
         all_records = dbsession.query(RegRecord).filter(RegRecord.type.like('%authority%')).all()
 
         for record in all_records:
         all_records = dbsession.query(RegRecord).filter(RegRecord.type.like('%authority%')).all()
 
         for record in all_records:
@@ -80,26 +79,26 @@ class IotlabTestbedAPI():
             else:
                 existing_hrns_by_types[record.type].append(record.hrn)
 
             else:
                 existing_hrns_by_types[record.type].append(record.hrn)
 
-
-        logger.debug("IOTLABDRIVER \tGetPeer\texisting_hrns_by_types %s "\
-                                             %( existing_hrns_by_types))
+        logger.debug("IOTLAB_API \tGetPeer\texisting_hrns_by_types %s "
+                     % (existing_hrns_by_types))
         records_list = []
 
         try:
             if peer_filter:
         records_list = []
 
         try:
             if peer_filter:
-                records_list.append(existing_records[(peer_filter,'authority')])
+                records_list.append(existing_records[(peer_filter,
+                                                     'authority')])
             else:
                 for hrn in existing_hrns_by_types['authority']:
             else:
                 for hrn in existing_hrns_by_types['authority']:
-                    records_list.append(existing_records[(hrn,'authority')])
+                    records_list.append(existing_records[(hrn, 'authority')])
 
 
-            logger.debug("IOTLABDRIVER \tGetPeer \trecords_list  %s " \
-                                            %(records_list))
+            logger.debug("IOTLAB_API \tGetPeer \trecords_list  %s "
+                         % (records_list))
 
         except KeyError:
             pass
 
         return_records = records_list
 
         except KeyError:
             pass
 
         return_records = records_list
-        logger.debug("IOTLABDRIVER \tGetPeer return_records %s "
+        logger.debug("IOTLAB_API \tGetPeer return_records %s "
                      % (return_records))
         return return_records
 
                      % (return_records))
         return return_records
 
@@ -112,15 +111,16 @@ class IotlabTestbedAPI():
         If a filter is specified, looks for the user whose properties match
         the filter, otherwise returns the whole enabled users'list.
 
         If a filter is specified, looks for the user whose properties match
         the filter, otherwise returns the whole enabled users'list.
 
-        :param person_filter: Must be a list of dictionnaries
-            with users properties when not set to None.
-        :param person_filter: list of dict
-        :returns:Returns a list of users whose accounts are enabled
+        :param person_filter: Must be a list of dictionnaries with users
+            properties when not set to None.
+        :type person_filter: list of dict
+
+        :returns: Returns a list of users whose accounts are enabled
             found in ldap.
         :rtype: list of dicts
 
         """
             found in ldap.
         :rtype: list of dicts
 
         """
-        logger.debug("IOTLABDRIVER \tGetPersons person_filter %s"
+        logger.debug("IOTLAB_API \tGetPersons person_filter %s"
                      % (person_filter))
         person_list = []
         if person_filter and isinstance(person_filter, list):
                      % (person_filter))
         person_list = []
         if person_filter and isinstance(person_filter, list):
@@ -171,7 +171,7 @@ class IotlabTestbedAPI():
         :rtype: dict
 
         """
         :rtype: dict
 
         """
-        logger.debug("IOTLABDRIVER \tDeleteJobs jobid  %s username %s "
+        logger.debug("IOTLAB_API \tDeleteJobs jobid  %s username %s "
                      % (job_id, username))
         if not job_id or job_id is -1:
             return
                      % (job_id, username))
         if not job_id or job_id is -1:
             return
@@ -186,7 +186,7 @@ class IotlabTestbedAPI():
             ret = {job_id: True}
         else:
             ret = {job_id: False}
             ret = {job_id: True}
         else:
             ret = {job_id: False}
-        logger.debug("IOTLABDRIVER \tDeleteJobs jobid  %s \r\n answer %s \
+        logger.debug("IOTLAB_API \tDeleteJobs jobid  %s \r\n answer %s \
                                 username %s" % (job_id, answer, username))
         return ret
 
                                 username %s" % (job_id, answer, username))
         return ret
 
@@ -205,19 +205,19 @@ class IotlabTestbedAPI():
         ##Get job info from OAR
         #job_info = self.oar.parser.SendRequest(req, job_id, username)
 
         ##Get job info from OAR
         #job_info = self.oar.parser.SendRequest(req, job_id, username)
 
-        #logger.debug("IOTLABDRIVER \t GetJobsId  %s " %(job_info))
+        #logger.debug("IOTLAB_API \t GetJobsId  %s " %(job_info))
         #try:
             #if job_info['state'] == 'Terminated':
         #try:
             #if job_info['state'] == 'Terminated':
-                #logger.debug("IOTLABDRIVER \t GetJobsId job %s TERMINATED"\
+                #logger.debug("IOTLAB_API \t GetJobsId job %s TERMINATED"\
                                                             #%(job_id))
                 #return None
             #if job_info['state'] == 'Error':
                                                             #%(job_id))
                 #return None
             #if job_info['state'] == 'Error':
-                #logger.debug("IOTLABDRIVER \t GetJobsId ERROR message %s "\
+                #logger.debug("IOTLAB_API \t GetJobsId ERROR message %s "\
                                                             #%(job_info))
                 #return None
 
         #except KeyError:
                                                             #%(job_info))
                 #return None
 
         #except KeyError:
-            #logger.error("IOTLABDRIVER \tGetJobsId KeyError")
+            #logger.error("IOTLAB_API \tGetJobsId KeyError")
             #return None
 
         #parsed_job_info  = self.get_info_on_reserved_nodes(job_info, \
             #return None
 
         #parsed_job_info  = self.get_info_on_reserved_nodes(job_info, \
@@ -227,7 +227,7 @@ class IotlabTestbedAPI():
         ##with "node_ids"
         #job_info.update({'node_ids':parsed_job_info[node_list_k]})
         #del job_info[node_list_k]
         ##with "node_ids"
         #job_info.update({'node_ids':parsed_job_info[node_list_k]})
         #del job_info[node_list_k]
-        #logger.debug(" \r\nIOTLABDRIVER \t GetJobsId job_info %s " %(job_info))
+        #logger.debug(" \r\nIOTLAB_API \t GetJobsId job_info %s " %(job_info))
         #return job_info
 
 
         #return job_info
 
 
@@ -244,6 +244,7 @@ class IotlabTestbedAPI():
 
         :returns: dicionary with nodes' hostnames belonging to the job.
         :rtype: dict
 
         :returns: dicionary with nodes' hostnames belonging to the job.
         :rtype: dict
+        .. warning: Unused. SA 16/10/13
         """
 
         req = "GET_jobs_id_resources"
         """
 
         req = "GET_jobs_id_resources"
@@ -251,7 +252,7 @@ class IotlabTestbedAPI():
 
         #Get job resources list from OAR
         node_id_list = self.oar.parser.SendRequest(req, job_id, username)
 
         #Get job resources list from OAR
         node_id_list = self.oar.parser.SendRequest(req, job_id, username)
-        logger.debug("IOTLABDRIVER \t GetJobsResources  %s " %(node_id_list))
+        logger.debug("IOTLAB_API \t GetJobsResources  %s " %(node_id_list))
 
         hostname_list = \
             self.__get_hostnames_from_oar_node_ids(node_id_list)
 
         hostname_list = \
             self.__get_hostnames_from_oar_node_ids(node_id_list)
@@ -283,11 +284,11 @@ class IotlabTestbedAPI():
                 #reserved_node_hostname_list[index] = \
                         #node_dict[job_info[node_list_name][index]]['hostname']
 
                 #reserved_node_hostname_list[index] = \
                         #node_dict[job_info[node_list_name][index]]['hostname']
 
-            #logger.debug("IOTLABDRIVER \t get_info_on_reserved_nodes \
+            #logger.debug("IOTLAB_API \t get_info_on_reserved_nodes \
                         #reserved_node_hostname_list %s" \
                         #%(reserved_node_hostname_list))
         #except KeyError:
                         #reserved_node_hostname_list %s" \
                         #%(reserved_node_hostname_list))
         #except KeyError:
-            #logger.error("IOTLABDRIVER \t get_info_on_reserved_nodes KEYERROR " )
+            #logger.error("IOTLAB_API \t get_info_on_reserved_nodes KEYERROR " )
 
         #return reserved_node_hostname_list
 
 
         #return reserved_node_hostname_list
 
@@ -298,18 +299,15 @@ class IotlabTestbedAPI():
         """
         return self.oar.parser.SendRequest("GET_running_jobs")
 
         """
         return self.oar.parser.SendRequest("GET_running_jobs")
 
-    def __get_hostnames_from_oar_node_ids(self, resource_id_list ):
+    def __get_hostnames_from_oar_node_ids(self, oar_id_node_dict,
+            resource_id_list ):
         """Get the hostnames of the nodes from their OAR identifiers.
         Get the list of nodes dict using GetNodes and find the hostname
         associated with the identifier.
         """Get the hostnames of the nodes from their OAR identifiers.
         Get the list of nodes dict using GetNodes and find the hostname
         associated with the identifier.
+        :param oar_id_node_dict: full node dictionary list keyed by oar node id
         :param resource_id_list: list of nodes identifiers
         :returns: list of node hostnames.
         """
         :param resource_id_list: list of nodes identifiers
         :returns: list of node hostnames.
         """
-        full_nodes_dict_list = self.GetNodes()
-        #Put the full node list into a dictionary keyed by oar node id
-        oar_id_node_dict = {}
-        for node in full_nodes_dict_list:
-            oar_id_node_dict[node['oar_id']] = node
 
         hostname_list = []
         for resource_id in resource_id_list:
 
         hostname_list = []
         for resource_id in resource_id_list:
@@ -321,7 +319,7 @@ class IotlabTestbedAPI():
             #hostname_list.append(oar_id_node_dict[resource_id]['hostname'])
         return hostname_list
 
             #hostname_list.append(oar_id_node_dict[resource_id]['hostname'])
         return hostname_list
 
-    def GetReservedNodes(self, username = None):
+    def GetReservedNodes(self, username=None):
         """ Get list of leases. Get the leases for the username if specified,
         otherwise get all the leases. Finds the nodes hostnames for each
         OAR node identifier.
         """ Get list of leases. Get the leases for the username if specified,
         otherwise get all the leases. Finds the nodes hostnames for each
         OAR node identifier.
@@ -336,12 +334,21 @@ class IotlabTestbedAPI():
                         self.oar.parser.SendRequest("GET_reserved_nodes", \
                         username = username)
 
                         self.oar.parser.SendRequest("GET_reserved_nodes", \
                         username = username)
 
+        # Get the full node dict list once for all
+        # so that we can get the hostnames given their oar node id afterwards
+        # when the reservations are checked.
+        full_nodes_dict_list = self.GetNodes()
+        #Put the full node list into a dictionary keyed by oar node id
+        oar_id_node_dict = {}
+        for node in full_nodes_dict_list:
+            oar_id_node_dict[node['oar_id']] = node
 
         for resa in reservation_dict_list:
             logger.debug ("GetReservedNodes resa %s"%(resa))
             #dict list of hostnames and their site
             resa['reserved_nodes'] = \
 
         for resa in reservation_dict_list:
             logger.debug ("GetReservedNodes resa %s"%(resa))
             #dict list of hostnames and their site
             resa['reserved_nodes'] = \
-                self.__get_hostnames_from_oar_node_ids(resa['resource_ids'])
+                self.__get_hostnames_from_oar_node_ids(oar_id_node_dict,
+                    resa['resource_ids'])
 
         #del resa['resource_ids']
         return reservation_dict_list
 
         #del resa['resource_ids']
         return reservation_dict_list
@@ -368,7 +375,7 @@ class IotlabTestbedAPI():
         """
         node_dict_by_id = self.oar.parser.SendRequest("GET_resources_full")
         node_dict_list = node_dict_by_id.values()
         """
         node_dict_by_id = self.oar.parser.SendRequest("GET_resources_full")
         node_dict_list = node_dict_by_id.values()
-        logger.debug (" IOTLABDRIVER GetNodes  node_filter_dict %s \
+        logger.debug (" IOTLAB_API GetNodes  node_filter_dict %s \
             return_fields_list %s " % (node_filter_dict, return_fields_list))
         #No  filtering needed return the list directly
         if not (node_filter_dict or return_fields_list):
             return_fields_list %s " % (node_filter_dict, return_fields_list))
         #No  filtering needed return the list directly
         if not (node_filter_dict or return_fields_list):
@@ -420,7 +427,7 @@ class IotlabTestbedAPI():
                               gid=slice_record['gid'],
                               pointer=slice_record['slice_id'],
                               authority=slice_record['authority'])
                               gid=slice_record['gid'],
                               pointer=slice_record['slice_id'],
                               authority=slice_record['authority'])
-        logger.debug("IOTLABDRIVER.PY AddSlice  sfa_record %s user_record %s"
+        logger.debug("IOTLAB_API.PY AddSlice  sfa_record %s user_record %s"
                      % (sfa_record, user_record))
         sfa_record.just_created()
         dbsession.add(sfa_record)
                      % (sfa_record, user_record))
         sfa_record.just_created()
         dbsession.add(sfa_record)
@@ -434,8 +441,13 @@ class IotlabTestbedAPI():
 
     def GetSites(self, site_filter_name_list=None, return_fields_list=None):
         """Returns the list of Iotlab's sites with the associated nodes and
 
     def GetSites(self, site_filter_name_list=None, return_fields_list=None):
         """Returns the list of Iotlab's sites with the associated nodes and
-        their properties as dictionaries.
+        the sites' properties as dictionaries.
 
 
+        Site properties:
+        ['address_ids', 'slice_ids', 'name', 'node_ids', 'url', 'person_ids',
+        'site_tag_ids', 'enabled', 'site', 'longitude', 'pcu_ids',
+        'max_slivers', 'max_slices', 'ext_consortium_id', 'date_created',
+        'latitude', 'is_public', 'peer_site_id', 'peer_id', 'abbreviated_name']
         Uses the OAR request GET_sites to find the Iotlab's sites.
 
         :param site_filter_name_list: used to specify specific sites
         Uses the OAR request GET_sites to find the Iotlab's sites.
 
         :param site_filter_name_list: used to specify specific sites
@@ -443,7 +455,7 @@ class IotlabTestbedAPI():
         :type site_filter_name_list: list
         :type return_fields_list: list
 
         :type site_filter_name_list: list
         :type return_fields_list: list
 
-        .. warning:: unused
+
         """
         site_dict = self.oar.parser.SendRequest("GET_sites")
         #site_dict : dict where the key is the sit ename
         """
         site_dict = self.oar.parser.SendRequest("GET_sites")
         #site_dict : dict where the key is the sit ename
@@ -486,7 +498,7 @@ class IotlabTestbedAPI():
         """
         #Disable user account in iotlab LDAP
         ret = self.ldap.LdapMarkUserAsDeleted(person_record)
         """
         #Disable user account in iotlab LDAP
         ret = self.ldap.LdapMarkUserAsDeleted(person_record)
-        logger.warning("IOTLABDRIVER DeletePerson %s " % (person_record))
+        logger.warning("IOTLAB_API DeletePerson %s " % (person_record))
         return ret['bool']
 
     def DeleteSlice(self, slice_record):
         return ret['bool']
 
     def DeleteSlice(self, slice_record):
@@ -510,7 +522,7 @@ class IotlabTestbedAPI():
                     delete_failed = []
                 delete_failed.append(job_id)
 
                     delete_failed = []
                 delete_failed.append(job_id)
 
-        logger.info("IOTLABDRIVER DeleteSlice %s  answer %s"%(slice_record, \
+        logger.info("IOTLAB_API DeleteSlice %s  answer %s"%(slice_record, \
                     delete_failed))
         return delete_failed or True
 
                     delete_failed))
         return delete_failed or True
 
@@ -520,7 +532,7 @@ class IotlabTestbedAPI():
         Add a federated user straight to db when the user issues a lease
         request with iotlab nodes and that he has not registered with iotlab
         yet (that is he does not have a LDAP entry yet).
         Add a federated user straight to db when the user issues a lease
         request with iotlab nodes and that he has not registered with iotlab
         yet (that is he does not have a LDAP entry yet).
-        Uses parts of the routines in SlabImport when importing user from LDAP.
+        Uses parts of the routines in IotlabImport when importing user from LDAP.
         Called by AddPerson, right after LdapAddUser.
         :param user_dict: Must contain email, hrn and pkey to get a GID
         and be added to the SFA db.
         Called by AddPerson, right after LdapAddUser.
         :param user_dict: Must contain email, hrn and pkey to get a GID
         and be added to the SFA db.
@@ -573,21 +585,23 @@ class IotlabTestbedAPI():
             LdapAddUser.
 
         :param record: dictionary with the sfa user's properties.
             LdapAddUser.
 
         :param record: dictionary with the sfa user's properties.
-        :returns: The uid of the added person if sucessful, otherwise returns
-            the error message from LDAP.
-        :rtype: interger or string
+        :returns: a dicitonary with the status. If successful, the dictionary
+            boolean is set to True and there is a 'uid' key with the new login
+            added to LDAP, otherwise the bool is set to False and a key
+            'message' is in the dictionary, with the error message.
+        :rtype: dict
 
         """
         ret = self.ldap.LdapAddUser(record)
 
         if ret['bool'] is True:
             record['hrn'] = self.root_auth + '.' + ret['uid']
 
         """
         ret = self.ldap.LdapAddUser(record)
 
         if ret['bool'] is True:
             record['hrn'] = self.root_auth + '.' + ret['uid']
-            logger.debug("IOTLABDRIVER AddPerson return code %s record %s \r\n "\
-                                                                %(ret, record))
+            logger.debug("IOTLAB_API AddPerson return code %s record %s  "
+                         % (ret, record))
             self.__add_person_to_db(record)
             self.__add_person_to_db(record)
-            return ret['uid']
-        else:
-            return ret['message']
+        return ret
+
+
 
 
 
 
 
 
@@ -610,7 +624,7 @@ class IotlabTestbedAPI():
         """
         ret = self.ldap.LdapModify(person_uid, old_attributes_dict, \
                                                                 new_key_dict)
         """
         ret = self.ldap.LdapModify(person_uid, old_attributes_dict, \
                                                                 new_key_dict)
-        logger.warning("IOTLABDRIVER AddPersonKey EMPTY - DO NOTHING \r\n ")
+        logger.warning("IOTLAB_API AddPersonKey EMPTY - DO NOTHING \r\n ")
         return ret['bool']
 
     def DeleteLeases(self, leases_id_list, slice_hrn):
         return ret['bool']
 
     def DeleteLeases(self, leases_id_list, slice_hrn):
@@ -632,7 +646,7 @@ class IotlabTestbedAPI():
             there was no easy way to report it to the user.
 
         """
             there was no easy way to report it to the user.
 
         """
-        logger.debug("IOTLABDRIVER DeleteLeases leases_id_list %s slice_hrn %s \
+        logger.debug("IOTLAB_API DeleteLeases leases_id_list %s slice_hrn %s \
                 \r\n " %(leases_id_list, slice_hrn))
         for job_id in leases_id_list:
             self.DeleteJobs(job_id, slice_hrn)
                 \r\n " %(leases_id_list, slice_hrn))
         for job_id in leases_id_list:
             self.DeleteJobs(job_id, slice_hrn)
@@ -755,21 +769,21 @@ class IotlabTestbedAPI():
         lease_dict['time_format'] = self.time_format
 
 
         lease_dict['time_format'] = self.time_format
 
 
-        logger.debug("IOTLABDRIVER.PY \tLaunchExperimentOnOAR slice_user %s\
+        logger.debug("IOTLAB_API.PY \tLaunchExperimentOnOAR slice_user %s\
                              \r\n "  %(slice_user))
         #Create the request for OAR
         reqdict = self._create_job_structure_request_for_OAR(lease_dict)
          # first step : start the OAR job and update the job
                              \r\n "  %(slice_user))
         #Create the request for OAR
         reqdict = self._create_job_structure_request_for_OAR(lease_dict)
          # first step : start the OAR job and update the job
-        logger.debug("IOTLABDRIVER.PY \tLaunchExperimentOnOAR reqdict %s\
+        logger.debug("IOTLAB_API.PY \tLaunchExperimentOnOAR reqdict %s\
                              \r\n "  %(reqdict))
 
         answer = self.oar.POSTRequestToOARRestAPI('POST_job', \
                                                 reqdict, slice_user)
                              \r\n "  %(reqdict))
 
         answer = self.oar.POSTRequestToOARRestAPI('POST_job', \
                                                 reqdict, slice_user)
-        logger.debug("IOTLABDRIVER \tLaunchExperimentOnOAR jobid  %s " %(answer))
+        logger.debug("IOTLAB_API \tLaunchExperimentOnOAR jobid  %s " %(answer))
         try:
             jobid = answer['id']
         except KeyError:
         try:
             jobid = answer['id']
         except KeyError:
-            logger.log_exc("IOTLABDRIVER \tLaunchExperimentOnOAR \
+            logger.log_exc("IOTLAB_API \tLaunchExperimentOnOAR \
                                 Impossible to create job  %s "  %(answer))
             return None
 
                                 Impossible to create job  %s "  %(answer))
             return None
 
@@ -777,7 +791,7 @@ class IotlabTestbedAPI():
 
 
         if jobid :
 
 
         if jobid :
-            logger.debug("IOTLABDRIVER \tLaunchExperimentOnOAR jobid %s \
+            logger.debug("IOTLAB_API \tLaunchExperimentOnOAR jobid %s \
                     added_nodes %s slice_user %s" %(jobid, added_nodes, \
                                                             slice_user))
 
                     added_nodes %s slice_user %s" %(jobid, added_nodes, \
                                                             slice_user))
 
@@ -785,8 +799,8 @@ class IotlabTestbedAPI():
         return jobid
 
 
         return jobid
 
 
-    def AddLeases(self, hostname_list, slice_record, \
-                                        lease_start_time, lease_duration):
+    def AddLeases(self, hostname_list, slice_record,
+                  lease_start_time, lease_duration):
 
         """Creates a job in OAR corresponding to the information provided
         as parameters. Adds the job id and the slice hrn in the iotlab
 
         """Creates a job in OAR corresponding to the information provided
         as parameters. Adds the job id and the slice hrn in the iotlab
@@ -803,7 +817,7 @@ class IotlabTestbedAPI():
         :type lease_duration: integer
 
         """
         :type lease_duration: integer
 
         """
-        logger.debug("IOTLABDRIVER \r\n \r\n \t AddLeases hostname_list %s  \
+        logger.debug("IOTLAB_API \r\n \r\n \t AddLeases hostname_list %s  \
                 slice_record %s lease_start_time %s lease_duration %s  "\
                  %( hostname_list, slice_record , lease_start_time, \
                  lease_duration))
                 slice_record %s lease_start_time %s lease_duration %s  "\
                  %( hostname_list, slice_record , lease_start_time, \
                  lease_duration))
@@ -821,22 +835,22 @@ class IotlabTestbedAPI():
         end_time = lease_start_time + lease_duration
 
 
         end_time = lease_start_time + lease_duration
 
 
-        logger.debug("IOTLABDRIVER \r\n \r\n \t AddLeases TURN ON LOGGING SQL \
+        logger.debug("IOTLAB_API \r\n \r\n \t AddLeases TURN ON LOGGING SQL \
                         %s %s %s "%(slice_record['hrn'], job_id, end_time))
 
 
                         %s %s %s "%(slice_record['hrn'], job_id, end_time))
 
 
-        logger.debug("IOTLABDRIVER \r\n \r\n \t AddLeases %s %s %s " \
+        logger.debug("IOTLAB_API \r\n \r\n \t AddLeases %s %s %s " \
                 %(type(slice_record['hrn']), type(job_id), type(end_time)))
 
                 %(type(slice_record['hrn']), type(job_id), type(end_time)))
 
-        iotlab_ex_row = IotlabXP(slice_hrn = slice_record['hrn'], \
-                job_id = job_id, end_time= end_time)
+        iotlab_ex_row = LeaseTableXP(slice_hrn = slice_record['hrn'], experiment_id=job_id,
+                                 end_time= end_time)
 
 
-        logger.debug("IOTLABDRIVER \r\n \r\n \t AddLeases iotlab_ex_row %s" \
+        logger.debug("IOTLAB_API \r\n \r\n \t AddLeases iotlab_ex_row %s" \
                 %(iotlab_ex_row))
                 %(iotlab_ex_row))
-        self.iotlab_db.iotlab_session.add(iotlab_ex_row)
-        self.iotlab_db.iotlab_session.commit()
+        self.iotlab_db.testbed_session.add(iotlab_ex_row)
+        self.iotlab_db.testbed_session.commit()
 
 
-        logger.debug("IOTLABDRIVER \t AddLeases hostname_list start_time %s " \
+        logger.debug("IOTLAB_API \t AddLeases hostname_list start_time %s " \
                 %(start_time))
 
         return
                 %(start_time))
 
         return
@@ -857,7 +871,7 @@ class IotlabTestbedAPI():
         :rtype: dict
 
         """
         :rtype: dict
 
         """
-        logger.debug("IOTLABDRIVER \t  DeleteSliceFromNodes %s "
+        logger.debug("IOTLAB_API \t  DeleteSliceFromNodes %s "
                      % (slice_record))
 
         if isinstance(slice_record['oar_job_id'], list):
                      % (slice_record))
 
         if isinstance(slice_record['oar_job_id'], list):
@@ -884,7 +898,7 @@ class IotlabTestbedAPI():
 
 
     # @staticmethod
 
 
     # @staticmethod
-    # def update_jobs_in_iotlabdb( job_oar_list, jobs_psql):
+    # def update_experiments_in_additional_sfa_db( job_oar_list, jobs_psql):
     #     """ Cleans the iotlab db by deleting expired and cancelled jobs.
     #     Compares the list of job ids given by OAR with the job ids that
     #     are already in the database, deletes the jobs that are no longer in
     #     """ Cleans the iotlab db by deleting expired and cancelled jobs.
     #     Compares the list of job ids given by OAR with the job ids that
     #     are already in the database, deletes the jobs that are no longer in
@@ -898,16 +912,41 @@ class IotlabTestbedAPI():
     #     set_jobs_psql = set(jobs_psql)
 
     #     kept_jobs = set(job_oar_list).intersection(set_jobs_psql)
     #     set_jobs_psql = set(jobs_psql)
 
     #     kept_jobs = set(job_oar_list).intersection(set_jobs_psql)
-    #     logger.debug ( "\r\n \t\ update_jobs_in_iotlabdb jobs_psql %s \r\n \t \
+    #     logger.debug ( "\r\n \t\ update_experiments_in_additional_sfa_db jobs_psql %s \r\n \t \
     #         job_oar_list %s kept_jobs %s "%(set_jobs_psql, job_oar_list, kept_jobs))
     #     deleted_jobs = set_jobs_psql.difference(kept_jobs)
     #     deleted_jobs = list(deleted_jobs)
     #     if len(deleted_jobs) > 0:
     #         job_oar_list %s kept_jobs %s "%(set_jobs_psql, job_oar_list, kept_jobs))
     #     deleted_jobs = set_jobs_psql.difference(kept_jobs)
     #     deleted_jobs = list(deleted_jobs)
     #     if len(deleted_jobs) > 0:
-    #         self.iotlab_db.iotlab_session.query(IotlabXP).filter(IotlabXP.job_id.in_(deleted_jobs)).delete(synchronize_session='fetch')
-    #         self.iotlab_db.iotlab_session.commit()
+    #         self.iotlab_db.testbed_session.query(LeaseTableXP).filter(LeaseTableXP.job_id.in_(deleted_jobs)).delete(synchronize_session='fetch')
+    #         self.iotlab_db.testbed_session.commit()
 
     #     return
 
 
     #     return
 
+    @staticmethod
+    def filter_lease_name(reservation_list, filter_value):
+        filtered_reservation_list = list(reservation_list)
+        logger.debug("IOTLAB_API \t filter_lease_name reservation_list %s" \
+                        % (reservation_list))
+        for reservation in reservation_list:
+            if 'slice_hrn' in reservation and \
+                reservation['slice_hrn'] != filter_value:
+                filtered_reservation_list.remove(reservation)
+
+        logger.debug("IOTLAB_API \t filter_lease_name filtered_reservation_list %s" \
+                        % (filtered_reservation_list))
+        return filtered_reservation_list
+
+    @staticmethod
+    def filter_lease_start_time(reservation_list, filter_value):
+        filtered_reservation_list = list(reservation_list)
+
+        for reservation in reservation_list:
+            if 't_from' in reservation and \
+                reservation['t_from'] > filter_value:
+                filtered_reservation_list.remove(reservation)
+
+        return filtered_reservation_list
+
 
     def GetLeases(self, lease_filter_dict=None, login=None):
         """
 
     def GetLeases(self, lease_filter_dict=None, login=None):
         """
@@ -917,7 +956,7 @@ class IotlabTestbedAPI():
             Two purposes:
             -Fetch all the jobs from OAR (running, waiting..)
             complete the reservation information with slice hrn
             Two purposes:
             -Fetch all the jobs from OAR (running, waiting..)
             complete the reservation information with slice hrn
-            found in iotlab_xp table. If not available in the table,
+            found in testbed_xp table. If not available in the table,
             assume it is a iotlab slice.
             -Updates the iotlab table, deleting jobs when necessary.
 
             assume it is a iotlab slice.
             -Updates the iotlab table, deleting jobs when necessary.
 
@@ -932,23 +971,23 @@ class IotlabTestbedAPI():
 
         reservation_list = []
         #Find the slice associated with this user iotlab ldap uid
 
         reservation_list = []
         #Find the slice associated with this user iotlab ldap uid
-        logger.debug(" IOTLABDRIVER.PY \tGetLeases login %s\
+        logger.debug(" IOTLAB_API.PY \tGetLeases login %s\
                         unfiltered_reservation_list %s "
                      % (login, unfiltered_reservation_list))
         #Create user dict first to avoid looking several times for
         #the same user in LDAP SA 27/07/12
         job_oar_list = []
 
                         unfiltered_reservation_list %s "
                      % (login, unfiltered_reservation_list))
         #Create user dict first to avoid looking several times for
         #the same user in LDAP SA 27/07/12
         job_oar_list = []
 
-        jobs_psql_query = self.iotlab_db.iotlab_session.query(IotlabXP).all()
-        jobs_psql_dict = dict([(row.job_id, row.__dict__)
+        jobs_psql_query = self.iotlab_db.testbed_session.query(LeaseTableXP).all()
+        jobs_psql_dict = dict([(row.experiment_id, row.__dict__)
                                for row in jobs_psql_query])
         #jobs_psql_dict = jobs_psql_dict)
                                for row in jobs_psql_query])
         #jobs_psql_dict = jobs_psql_dict)
-        logger.debug("IOTLABDRIVER \tGetLeases jobs_psql_dict %s"
+        logger.debug("IOTLAB_API \tGetLeases jobs_psql_dict %s"
                      % (jobs_psql_dict))
                      % (jobs_psql_dict))
-        jobs_psql_id_list = [row.job_id for row in jobs_psql_query]
+        jobs_psql_id_list = [row.experiment_id for row in jobs_psql_query]
 
         for resa in unfiltered_reservation_list:
 
         for resa in unfiltered_reservation_list:
-            logger.debug("IOTLABDRIVER \tGetLeases USER %s"
+            logger.debug("IOTLAB_API \tGetLeases USER %s"
                          % (resa['user']))
             #Construct list of jobs (runing, waiting..) in oar
             job_oar_list.append(resa['lease_id'])
                          % (resa['user']))
             #Construct list of jobs (runing, waiting..) in oar
             job_oar_list.append(resa['lease_id'])
@@ -956,8 +995,8 @@ class IotlabTestbedAPI():
             #(slice used and job id)
             if resa['lease_id'] in jobs_psql_dict:
                 job_info = jobs_psql_dict[resa['lease_id']]
             #(slice used and job id)
             if resa['lease_id'] in jobs_psql_dict:
                 job_info = jobs_psql_dict[resa['lease_id']]
-                logger.debug("IOTLABDRIVER \tGetLeases job_info %s"
-                             % (job_info))
+                logger.debug("IOTLAB_API \tGetLeases job_info %s"
+                          % (job_info))
                 resa['slice_hrn'] = job_info['slice_hrn']
                 resa['slice_id'] = hrn_to_urn(resa['slice_hrn'], 'slice')
 
                 resa['slice_hrn'] = job_info['slice_hrn']
                 resa['slice_id'] = hrn_to_urn(resa['slice_hrn'], 'slice')
 
@@ -974,19 +1013,40 @@ class IotlabTestbedAPI():
                 iotlab_xrn = iotlab_xrn_object(self.root_auth, node)
                 resa['component_id_list'].append(iotlab_xrn.urn)
 
                 iotlab_xrn = iotlab_xrn_object(self.root_auth, node)
                 resa['component_id_list'].append(iotlab_xrn.urn)
 
-            if lease_filter_dict:
-                logger.debug("IOTLABDRIVER \tGetLeases resa_ %s \
-                        \r\n leasefilter %s" % (resa, lease_filter_dict))
+        if lease_filter_dict:
+            logger.debug("IOTLAB_API \tGetLeases  \
+                    \r\n leasefilter %s" % ( lease_filter_dict))
+
+            filter_dict_functions = {
+            'slice_hrn' : IotlabTestbedAPI.filter_lease_name,
+            't_from' : IotlabTestbedAPI.filter_lease_start_time
+            }
+            reservation_list = list(unfiltered_reservation_list)
+            for filter_type in lease_filter_dict:
+                logger.debug("IOTLAB_API \tGetLeases reservation_list %s" \
+                    % (reservation_list))
+                reservation_list = filter_dict_functions[filter_type](\
+                    reservation_list,lease_filter_dict[filter_type] )
+
+                # Filter the reservation list with a maximum timespan so that the
+                # leases and jobs running after this timestamp do not appear
+                # in the result leases.
+                # if 'start_time' in :
+                #     if resa['start_time'] < lease_filter_dict['start_time']:
+                #        reservation_list.append(resa)
+
+
+                # if 'name' in lease_filter_dict and \
+                #     lease_filter_dict['name'] == resa['slice_hrn']:
+                #     reservation_list.append(resa)
 
 
-                if lease_filter_dict['name'] == resa['slice_hrn']:
-                    reservation_list.append(resa)
 
         if lease_filter_dict is None:
             reservation_list = unfiltered_reservation_list
 
 
         if lease_filter_dict is None:
             reservation_list = unfiltered_reservation_list
 
-        self.iotlab_db.update_jobs_in_iotlabdb(job_oar_list, jobs_psql_id_list)
+        self.iotlab_db.update_experiments_in_additional_sfa_db(job_oar_list, jobs_psql_id_list)
 
 
-        logger.debug(" IOTLABDRIVER.PY \tGetLeases reservation_list %s"
+        logger.debug(" IOTLAB_API.PY \tGetLeases reservation_list %s"
                      % (reservation_list))
         return reservation_list
 
                      % (reservation_list))
         return reservation_list
 
@@ -1014,7 +1074,7 @@ class IotlabTestbedAPI():
         #FROM PLC DOC
 
         #"""
         #FROM PLC DOC
 
         #"""
-        #logger.warning("IOTLABDRIVER \tUnBindObjectFromPeer EMPTY-\
+        #logger.warning("IOTLAB_API \tUnBindObjectFromPeer EMPTY-\
                         #DO NOTHING \r\n ")
         #return
 
                         #DO NOTHING \r\n ")
         #return
 
@@ -1033,7 +1093,7 @@ class IotlabTestbedAPI():
         #FROM PLC API DOC
 
         #"""
         #FROM PLC API DOC
 
         #"""
-        #logger.warning("IOTLABDRIVER \tBindObjectToPeer EMPTY - DO NOTHING \r\n ")
+        #logger.warning("IOTLAB_API \tBindObjectToPeer EMPTY - DO NOTHING \r\n ")
         #return
 
     ##TODO UpdateSlice 04/07/2012 SA || Commented out 28/05/13 SA
         #return
 
     ##TODO UpdateSlice 04/07/2012 SA || Commented out 28/05/13 SA
@@ -1050,7 +1110,7 @@ class IotlabTestbedAPI():
         #FROM PLC API DOC
 
         #"""
         #FROM PLC API DOC
 
         #"""
-        #logger.warning("IOTLABDRIVER UpdateSlice EMPTY - DO NOTHING \r\n ")
+        #logger.warning("IOTLAB_API UpdateSlice EMPTY - DO NOTHING \r\n ")
         #return
 
     #Unused SA 30/05/13, we only update the user's key or we delete it.
         #return
 
     #Unused SA 30/05/13, we only update the user's key or we delete it.
@@ -1065,10 +1125,10 @@ class IotlabTestbedAPI():
 
         #"""
         ##new_row = FederatedToIotlab(iotlab_hrn, federated_hrn)
 
         #"""
         ##new_row = FederatedToIotlab(iotlab_hrn, federated_hrn)
-        ##self.iotlab_db.iotlab_session.add(new_row)
-        ##self.iotlab_db.iotlab_session.commit()
+        ##self.iotlab_db.testbed_session.add(new_row)
+        ##self.iotlab_db.testbed_session.commit()
 
 
-        #logger.debug("IOTLABDRIVER UpdatePerson EMPTY - DO NOTHING \r\n ")
+        #logger.debug("IOTLAB_API UpdatePerson EMPTY - DO NOTHING \r\n ")
         #return
 
     @staticmethod
         #return
 
     @staticmethod
@@ -1100,7 +1160,7 @@ class IotlabTestbedAPI():
         #user_by_email = dict((user[1]['mail'][0], user[1]['sshPublicKey']) \
                                         #for user in ldap_rslt)
 
         #user_by_email = dict((user[1]['mail'][0], user[1]['sshPublicKey']) \
                                         #for user in ldap_rslt)
 
-        logger.debug("IOTLABDRIVER  GetKeys  -key_dict %s \r\n " % (key_dict))
+        logger.debug("IOTLAB_API  GetKeys  -key_dict %s \r\n " % (key_dict))
         return key_dict
 
     #TODO : test
         return key_dict
 
     #TODO : test
@@ -1122,14 +1182,14 @@ class IotlabTestbedAPI():
         all_user_keys.remove(key_string)
         new_attributes = {'sshPublicKey':all_user_keys}
         ret = self.ldap.LdapModifyUser(user_record, new_attributes)
         all_user_keys.remove(key_string)
         new_attributes = {'sshPublicKey':all_user_keys}
         ret = self.ldap.LdapModifyUser(user_record, new_attributes)
-        logger.debug("IOTLABDRIVER  DeleteKey  %s- " % (ret))
+        logger.debug("IOTLAB_API  DeleteKey  %s- " % (ret))
         return ret['bool']
 
 
 
 
     @staticmethod
         return ret['bool']
 
 
 
 
     @staticmethod
-    def _sql_get_slice_info( slice_filter ):
+    def _sql_get_slice_info(slice_filter):
         """
         Get the slice record based on the slice hrn. Fetch the record of the
         user associated with the slice by using joinedload based on the
         """
         Get the slice record based on the slice hrn. Fetch the record of the
         user associated with the slice by using joinedload based on the
@@ -1146,7 +1206,7 @@ class IotlabTestbedAPI():
         #of the user otherwise will mess up the RegRecord in
         #Resolve, don't know why - SA 08/08/2012
 
         #of the user otherwise will mess up the RegRecord in
         #Resolve, don't know why - SA 08/08/2012
 
-        #Only one entry for one user  = one slice in iotlab_xp table
+        #Only one entry for one user  = one slice in testbed_xp table
         #slicerec = dbsession.query(RegRecord).filter_by(hrn = slice_filter).first()
         raw_slicerec = dbsession.query(RegSlice).options(joinedload('reg_researchers')).filter_by(hrn=slice_filter).first()
         #raw_slicerec = dbsession.query(RegRecord).filter_by(hrn = slice_filter).first()
         #slicerec = dbsession.query(RegRecord).filter_by(hrn = slice_filter).first()
         raw_slicerec = dbsession.query(RegSlice).options(joinedload('reg_researchers')).filter_by(hrn=slice_filter).first()
         #raw_slicerec = dbsession.query(RegRecord).filter_by(hrn = slice_filter).first()
@@ -1154,7 +1214,7 @@ class IotlabTestbedAPI():
             #load_reg_researcher
             #raw_slicerec.reg_researchers
             raw_slicerec = raw_slicerec.__dict__
             #load_reg_researcher
             #raw_slicerec.reg_researchers
             raw_slicerec = raw_slicerec.__dict__
-            logger.debug(" IOTLABDRIVER \t  get_slice_info slice_filter %s  \
+            logger.debug(" IOTLAB_API \t  _sql_get_slice_info slice_filter %s  \
                             raw_slicerec %s" % (slice_filter, raw_slicerec))
             slicerec = raw_slicerec
             #only one researcher per slice so take the first one
                             raw_slicerec %s" % (slice_filter, raw_slicerec))
             slicerec = raw_slicerec
             #only one researcher per slice so take the first one
@@ -1250,6 +1310,8 @@ class IotlabTestbedAPI():
                     #login = fixed_slicerec_dict['hrn'].split(".")[1].split("_")[0]
             #return login, fixed_slicerec_dict
             return fixed_slicerec_dict
                     #login = fixed_slicerec_dict['hrn'].split(".")[1].split("_")[0]
             #return login, fixed_slicerec_dict
             return fixed_slicerec_dict
+        else:
+            return None
 
 
     def GetSlices(self, slice_filter=None, slice_filter_type=None,
 
 
     def GetSlices(self, slice_filter=None, slice_filter_type=None,
@@ -1279,9 +1341,13 @@ class IotlabTestbedAPI():
         if slice_filter_type in authorized_filter_types_list:
             fixed_slicerec_dict = self._get_slice_records(slice_filter,
                                                           slice_filter_type)
         if slice_filter_type in authorized_filter_types_list:
             fixed_slicerec_dict = self._get_slice_records(slice_filter,
                                                           slice_filter_type)
+            # if the slice was not found in the sfa db
+            if fixed_slicerec_dict is None:
+                return return_slicerec_dictlist
+
             slice_hrn = fixed_slicerec_dict['hrn']
 
             slice_hrn = fixed_slicerec_dict['hrn']
 
-            logger.debug(" IOTLABDRIVER \tGetSlices login %s \
+            logger.debug(" IOTLAB_API \tGetSlices login %s \
                             slice record %s slice_filter %s \
                             slice_filter_type %s " % (login,
                             fixed_slicerec_dict, slice_filter,
                             slice record %s slice_filter %s \
                             slice_filter_type %s " % (login,
                             fixed_slicerec_dict, slice_filter,
@@ -1307,7 +1373,7 @@ class IotlabTestbedAPI():
             # each lease information dict
             for lease in leases_list:
                 slicerec_dict = {}
             # each lease information dict
             for lease in leases_list:
                 slicerec_dict = {}
-                logger.debug("IOTLABDRIVER.PY  \tGetSlices slice_filter %s   \
+                logger.debug("IOTLAB_API.PY  \tGetSlices slice_filter %s   \
                         \t lease['slice_hrn'] %s"
                              % (slice_filter, lease['slice_hrn']))
                 if lease['slice_hrn'] == slice_hrn:
                         \t lease['slice_hrn'] %s"
                              % (slice_filter, lease['slice_hrn']))
                 if lease['slice_hrn'] == slice_hrn:
@@ -1331,16 +1397,16 @@ class IotlabTestbedAPI():
 
 
                     return_slicerec_dictlist.append(slicerec_dict)
 
 
                     return_slicerec_dictlist.append(slicerec_dict)
-                    logger.debug("IOTLABDRIVER.PY  \tGetSlices  \
+                    logger.debug("IOTLAB_API.PY  \tGetSlices  \
                         OHOHOHOH %s" %(return_slicerec_dictlist))
 
                         OHOHOHOH %s" %(return_slicerec_dictlist))
 
-                logger.debug("IOTLABDRIVER.PY  \tGetSlices  \
+                logger.debug("IOTLAB_API.PY  \tGetSlices  \
                         slicerec_dict %s return_slicerec_dictlist %s \
                         lease['reserved_nodes'] \
                         %s" % (slicerec_dict, return_slicerec_dictlist,
                                lease['reserved_nodes']))
 
                         slicerec_dict %s return_slicerec_dictlist %s \
                         lease['reserved_nodes'] \
                         %s" % (slicerec_dict, return_slicerec_dictlist,
                                lease['reserved_nodes']))
 
-            logger.debug("IOTLABDRIVER.PY  \tGetSlices  RETURN \
+            logger.debug("IOTLAB_API.PY  \tGetSlices  RETURN \
                         return_slicerec_dictlist  %s"
                           % (return_slicerec_dictlist))
 
                         return_slicerec_dictlist  %s"
                           % (return_slicerec_dictlist))
 
@@ -1377,7 +1443,7 @@ class IotlabTestbedAPI():
                         slicerec_dict['oar_job_id'] = lease['lease_id']
 
                         #for reserved_node in lease['reserved_nodes']:
                         slicerec_dict['oar_job_id'] = lease['lease_id']
 
                         #for reserved_node in lease['reserved_nodes']:
-                        logger.debug("IOTLABDRIVER.PY  \tGetSlices lease %s "
+                        logger.debug("IOTLAB_API.PY  \tGetSlices lease %s "
                                      % (lease))
                         slicerec_dict.update(fixed_slicerec_dict)
                         slicerec_dict.update({'node_ids':
                                      % (lease))
                         slicerec_dict.update(fixed_slicerec_dict)
                         slicerec_dict.update({'node_ids':
@@ -1391,7 +1457,7 @@ class IotlabTestbedAPI():
                         #return_slicerec_dictlist.append(slicerec_dict)
                         fixed_slicerec_dict.update(slicerec_dict)
 
                         #return_slicerec_dictlist.append(slicerec_dict)
                         fixed_slicerec_dict.update(slicerec_dict)
 
-            logger.debug("IOTLABDRIVER.PY  \tGetSlices RETURN \
+            logger.debug("IOTLAB_API.PY  \tGetSlices RETURN \
                         return_slicerec_dictlist %s \slice_filter %s " \
                         %(return_slicerec_dictlist, slice_filter))
 
                         return_slicerec_dictlist %s \slice_filter %s " \
                         %(return_slicerec_dictlist, slice_filter))
 
@@ -1418,7 +1484,7 @@ class IotlabTestbedAPI():
             ##Unused hrn_to_pl_slicename because Iotlab's hrn already
             ##in the appropriate form SA 23/07/12
             #iotlab_record["hrn"] = hrn
             ##Unused hrn_to_pl_slicename because Iotlab's hrn already
             ##in the appropriate form SA 23/07/12
             #iotlab_record["hrn"] = hrn
-            #logger.debug("IOTLABDRIVER.PY sfa_fields_to_iotlab_fields \
+            #logger.debug("IOTLAB_API.PY sfa_fields_to_iotlab_fields \
                         #iotlab_record %s  " %(iotlab_record['hrn']))
             #if "url" in record:
                 #iotlab_record["url"] = record["url"]
                         #iotlab_record %s  " %(iotlab_record['hrn']))
             #if "url" in record:
                 #iotlab_record["url"] = record["url"]
sfa