slice_name = slice_hrn
# GetSlices always returns a list, even if there is only one element
- slices = self.driver.cortexlab_api.GetSlices(slice_filter=str(slice_name),
+ slices = self.driver.testbed_shell.GetSlices(slice_filter=str(slice_name),
slice_filter_type='slice_hrn',
login=login)
researchers = [sfa_slice['reg_researchers'][0].__dict__]
# look in ldap:
ldap_username = None
- ret = self.driver.iotlab_api.GetPersons(researchers)
+ ret = self.driver.testbed_shell.GetPersons(researchers)
if len(ret) != 0:
ldap_username = ret[0]['uid']
return []
# get the granularity in second for the reservation system
- grain = self.driver.cortexlab_api.GetLeaseGranularity()
+ grain = self.driver.testbed_shell.GetLeaseGranularity()
- nodes = self.driver.cortexlab_api.GetNodes()
+ nodes = self.driver.testbed_shell.GetNodes()
nodes_dict = {}
logger.debug("CortexlabAggregate api get_nodes slices %s "
% (slices))
- reserved_nodes = self.driver.cortexlab_api.GetNodesCurrentlyInUse()
+ reserved_nodes = self.driver.testbed_shell.GetNodesCurrentlyInUse()
logger.debug("CortexlabAggregate api get_nodes slice_nodes_list %s "
% (slice_nodes_list))
for node in nodes:
- cortexlab_xrn = cortexlab_xrn_object(self.driver.cortexlab_api.root_auth,
+ cortexlab_xrn = cortexlab_xrn_object(self.driver.testbed_shell.root_auth,
node['hostname'])
rspec_node['component_id'] = cortexlab_xrn.urn
rspec_node['component_name'] = node['hostname']
rspec_node['component_manager_id'] = \
- hrn_to_urn(self.driver.cortexlab_api.root_auth,
+ hrn_to_urn(self.driver.testbed_shell.root_auth,
'authority+sa')
# Iotlab's nodes are federated : there is only one authority
logger.debug("CortexlabAggregate get_all_leases ldap_username %s "
% (ldap_username))
- leases = self.driver.cortexlab_api.GetLeases(login=ldap_username)
- grain = self.driver.cortexlab_api.GetLeaseGranularity()
+ leases = self.driver.testbed_shell.GetLeases(login=ldap_username)
+ grain = self.driver.testbed_shell.GetLeaseGranularity()
# site_ids = []
rspec_leases = []
for lease in leases:
rspec_lease['lease_id'] = lease['lease_id']
cortexlab_xrn = cortexlab_xrn_object(
- self.driver.cortexlab_api.root_auth, node)
+ self.driver.testbed_shell.root_auth, node)
rspec_lease['component_id'] = cortexlab_xrn.urn
#rspec_lease['component_id'] = hostname_to_urn(self.driver.hrn,\
#site, node['hostname'])
from sfa.iotlab.iotlabslices import CortexlabSlices
-from sfa.cortexlab.cortexlabapi import CortexlabTestbedAPI
+from sfa.cortexlab.cortexlabshell import CortexlabShell
class CortexlabDriver(Driver):
"""
Driver.__init__(self, config)
self.config = config
- self.cortexlab_api = CortexlabTestbedAPI(config)
+ self.testbed_shell = CortexlabShell(config)
self.cache = None
def augment_records_with_testbed_info(self, record_list):
# look for node info using GetNodes
# the record is about one node only
filter_dict = {'hrn': [record['hrn']]}
- node_info = self.cortexlab_api.GetNodes(filter_dict)
+ node_info = self.testbed_shell.GetNodes(filter_dict)
# the node_info is about one node only, but it is formatted
# as a list
record.update(node_info[0])
'key_ids': ''})
#Get iotlab slice record and oar job id if any.
- recslice_list = self.cortexlab_api.GetSlices(
+ recslice_list = self.testbed_shell.GetSlices(
slice_filter=str(record['hrn']),
slice_filter_type='slice_hrn')
fill_record_info experiment_id %s "
% (rec['experiment_id']))
- record['node_ids'] = [self.cortexlab_api.root_auth +
+ record['node_ids'] = [self.testbed_shell.root_auth +
'.' + hostname for hostname
in rec['node_ids']]
except KeyError:
#The record is a SFA user record.
#Get the information about his slice from Iotlab's DB
#and add it to the user record.
- recslice_list = self.cortexlab_api.GetSlices(
+ recslice_list = self.testbed_shell.GetSlices(
slice_filter=record['record_id'],
slice_filter_type='record_id_user')
'hrn': recslice_list[0]['hrn']})
#GetPersons takes [] as filters
- user_cortexlab = self.cortexlab_api.GetPersons([record])
+ user_cortexlab = self.testbed_shell.GetPersons([record])
record.update(user_cortexlab[0])
#For client_helper.py compatibility
"""
#First get the slice with the slice hrn
- slice_list = self.cortexlab_api.GetSlices(slice_filter=slice_hrn,
+ slice_list = self.testbed_shell.GetSlices(slice_filter=slice_hrn,
slice_filter_type='slice_hrn')
if len(slice_list) == 0:
slice_nodes_list = []
slice_nodes_list = one_slice['node_ids']
#Get all the corresponding nodes details
- nodes_all = self.cortexlab_api.GetNodes(
+ nodes_all = self.testbed_shell.GetNodes(
{'hostname': slice_nodes_list},
['node_id', 'hostname', 'site', 'boot_state'])
nodeall_byhostname = dict([(one_node['hostname'], one_node)
if not lease.get('lease_id'):
if get_authority(lease['component_id']) == \
- self.cortexlab_api.root_auth:
+ self.testbed_shell.root_auth:
single_requested_lease['hostname'] = \
cortexlab_xrn_to_hostname(\
lease.get('component_id').strip())
#the lease to the requested leases list
duration_in_seconds = \
int(single_requested_lease['duration'])
- if duration_in_seconds >= self.cortexlab_api.GetMinExperimentDurationInGranularity():
+ if duration_in_seconds >= self.testbed_shell.GetMinExperimentDurationInGranularity():
requested_lease_list.append(single_requested_lease)
return requested_lease_list
#requested_slivers = [node.get('component_id') \
#for node in rspec.version.get_nodes_with_slivers()\
- #if node.get('authority_id') is self.cortexlab_api.root_auth]
+ #if node.get('authority_id') is self.testbed_shell.root_auth]
#l = [ node for node in rspec.version.get_nodes_with_slivers() ]
#logger.debug("SLADRIVER \tcreate_sliver requested_slivers \
#requested_slivers %s listnodes %s" \
delete_sliver .
"""
- sfa_slice_list = self.cortexlab_api.GetSlices(
+ sfa_slice_list = self.testbed_shell.GetSlices(
slice_filter=slice_hrn,
slice_filter_type='slice_hrn')
logger.debug("CORTEXLABDRIVER.PY delete_sliver peer %s \
\r\n \t sfa_slice %s " % (peer, sfa_slice))
try:
- self.cortexlab_api.DeleteSliceFromNodes(sfa_slice)
+ self.testbed_shell.DeleteSliceFromNodes(sfa_slice)
return True
except:
return False
# get data from db
- slices = self.cortexlab_api.GetSlices()
+ slices = self.testbed_shell.GetSlices()
logger.debug("CORTEXLABDRIVER.PY \tlist_slices hrn %s \r\n \r\n"
% (slices))
slice_hrns = [iotlab_slice['hrn'] for iotlab_slice in slices]
if new_key:
# must check this key against the previous one if it exists
- persons = self.cortexlab_api.GetPersons([old_sfa_record])
+ persons = self.testbed_shell.GetPersons([old_sfa_record])
person = persons[0]
keys = [person['pkey']]
#Get all the person's keys
- keys_dict = self.cortexlab_api.GetKeys(keys)
+ keys_dict = self.testbed_shell.GetKeys(keys)
# Delete all stale keys, meaning the user has only one key
#at a time
else:
#remove all the other keys
for key in keys_dict:
- self.cortexlab_api.DeleteKey(person, key)
- self.cortexlab_api.AddPersonKey(
+ self.testbed_shell.DeleteKey(person, key)
+ self.testbed_shell.AddPersonKey(
person, {'sshPublicKey': person['pkey']},
{'sshPublicKey': new_key})
return True
if sfa_record_type == 'user':
#get user from iotlab ldap
- person = self.cortexlab_api.GetPersons(sfa_record)
+ person = self.testbed_shell.GetPersons(sfa_record)
#No registering at a given site in Iotlab.
#Once registered to the LDAP, all iotlab sites are
#accesible.
if person:
#Mark account as disabled in ldap
- return self.cortexlab_api.DeletePerson(sfa_record)
+ return self.testbed_shell.DeletePerson(sfa_record)
elif sfa_record_type == 'slice':
- if self.cortexlab_api.GetSlices(slice_filter=hrn,
+ if self.testbed_shell.GetSlices(slice_filter=hrn,
slice_filter_type='slice_hrn'):
- ret = self.cortexlab_api.DeleteSlice(sfa_record)
+ ret = self.testbed_shell.DeleteSlice(sfa_record)
return True
slice_authority = get_authority(hrn)
#Iotlab stuff
#This slice belongs to the current site
- if slice_authority == self.driver.iotlab_api.root_auth:
+ if slice_authority == self.driver.testbed_shell.root_auth:
site_authority = slice_authority
return None
# check if we are already peered with this site_authority
#if so find the peer record
- peers = self.driver.iotlab_api.GetPeers(peer_filter=site_authority)
+ peers = self.driver.testbed_shell.GetPeers(peer_filter=site_authority)
for peer_record in peers:
if site_authority == peer_record.hrn:
peer = peer_record
logger.debug("IOTLABSLICES verify_slice_leases sfa_slice %s "
% (sfa_slice))
#First get the list of current leases from OAR
- leases = self.driver.iotlab_api.GetLeases({'slice_hrn': sfa_slice['hrn']})
+ leases = self.driver.testbed_shell.GetLeases({'slice_hrn': sfa_slice['hrn']})
logger.debug("IOTLABSLICES verify_slice_leases requested_jobs_dict %s \
leases %s " % (requested_jobs_dict, leases))
for job in requested_jobs_dict.values():
job['duration'] = \
str(int(job['duration']) \
- * self.driver.iotlab_api.GetLeaseGranularity())
- if job['duration'] < self.driver.iotlab_api.GetLeaseGranularity():
+ * self.driver.testbed_shell.GetLeaseGranularity())
+ if job['duration'] < self.driver.testbed_shell.GetLeaseGranularity():
del requested_jobs_dict[job['start_time']]
#Requested jobs
logger.debug("IOTLABSLICES \
NEWLEASE slice %s job %s"
% (sfa_slice, job))
- self.driver.iotlab_api.AddLeases(
+ self.driver.testbed_shell.AddLeases(
job['hostname'],
sfa_slice, int(job['start_time']),
int(job['duration']))
#Deleted leases are the ones with lease id not declared in the Rspec
if deleted_leases:
- self.driver.iotlab_api.DeleteLeases(deleted_leases,
+ self.driver.testbed_shell.DeleteLeases(deleted_leases,
sfa_slice['user']['uid'])
logger.debug("IOTLABSLICES \
verify_slice_leases slice %s deleted_leases %s"
if reschedule_jobs_dict:
for start_time in reschedule_jobs_dict:
job = reschedule_jobs_dict[start_time]
- self.driver.iotlab_api.AddLeases(
+ self.driver.testbed_shell.AddLeases(
job['hostname'],
sfa_slice, int(job['start_time']),
int(job['duration']))
deleted_nodes = []
if 'node_ids' in sfa_slice:
- nodes = self.driver.iotlab_api.GetNodes(
+ nodes = self.driver.testbed_shell.GetNodes(
sfa_slice['list_node_ids'],
['hostname'])
current_slivers = [node['hostname'] for node in nodes]
if deleted_nodes:
#Delete the entire experience
- self.driver.iotlab_api.DeleteSliceFromNodes(sfa_slice)
+ self.driver.testbed_shell.DeleteSliceFromNodes(sfa_slice)
return nodes
def verify_slice(self, slice_hrn, slice_record, sfa_peer):
slicename = slice_hrn
# check if slice belongs to Iotlab
- slices_list = self.driver.iotlab_api.GetSlices(
+ slices_list = self.driver.testbed_shell.GetSlices(
slice_filter=slicename, slice_filter_type='slice_hrn')
sfa_slice = None
else:
#Search for user in ldap based on email SA 14/11/12
- ldap_user = self.driver.iotlab_api.ldap.LdapFindUser(\
+ ldap_user = self.driver.testbed_shell.ldap.LdapFindUser(\
slice_record['user'])
logger.debug(" IOTLABSLICES \tverify_slice Oups \
slice_record %s sfa_peer %s ldap_user %s"
}
if ldap_user:
- hrn = self.driver.iotlab_api.root_auth + '.' + ldap_user['uid']
+ hrn = self.driver.testbed_shell.root_auth + '.' + ldap_user['uid']
user = self.driver.get_user_record(hrn)
logger.debug(" IOTLABSLICES \tverify_slice hrn %s USER %s"
# add the external slice to the local SFA iotlab DB
if sfa_slice:
- self.driver.iotlab_api.AddSlice(sfa_slice, user)
+ self.driver.testbed_shell.AddSlice(sfa_slice, user)
logger.debug("IOTLABSLICES \tverify_slice ADDSLICE OK")
return sfa_slice
#Check user i in LDAP with GetPersons
#Needed because what if the user has been deleted in LDAP but
#is still in SFA?
- existing_users = self.driver.iotlab_api.GetPersons(filter_user)
+ existing_users = self.driver.testbed_shell.GetPersons(filter_user)
logger.debug(" \r\n IOTLABSLICES.PY \tverify_person filter_user \
%s existing_users %s "
% (filter_user, existing_users))
req += users[0]['email']
else:
req += users['email']
- ldap_reslt = self.driver.iotlab_api.ldap.LdapSearch(req)
+ ldap_reslt = self.driver.testbed_shell.ldap.LdapSearch(req)
if ldap_reslt:
logger.debug(" IOTLABSLICES.PY \tverify_person users \
person['email'] = added_user['email']
person['key_ids'] = added_user.get('key_ids', [])
- ret = self.driver.iotlab_api.AddPerson(person)
+ ret = self.driver.testbed_shell.AddPerson(person)
if 'uid' in ret:
# meaning bool is True and the AddPerson was successful
person['uid'] = ret['uid']
key_ids = []
for person in persons:
key_ids.extend(person['key_ids'])
- keylist = self.driver.iotlab_api.GetKeys(key_ids, ['key_id', 'key'])
+ keylist = self.driver.testbed_shell.GetKeys(key_ids, ['key_id', 'key'])
keydict = {}
for key in keylist:
#try:
##if peer:
#person = persondict[user['email']]
- #self.driver.iotlab_api.UnBindObjectFromPeer(
+ #self.driver.testbed_shell.UnBindObjectFromPeer(
# 'person',person['person_id'],
# peer['shortname'])
- ret = self.driver.iotlab_api.AddPersonKey(
+ ret = self.driver.testbed_shell.AddPersonKey(
user['email'], key)
#if peer:
#key_index = user_keys.index(key['key'])
#remote_key_id = user['key_ids'][key_index]
- #self.driver.iotlab_api.BindObjectToPeer('key', \
+ #self.driver.testbed_shell.BindObjectToPeer('key', \
#key['key_id'], peer['shortname'], \
#remote_key_id)
#finally:
#if peer:
- #self.driver.iotlab_api.BindObjectToPeer('person', \
+ #self.driver.testbed_shell.BindObjectToPeer('person', \
#person['person_id'], peer['shortname'], \
#user['person_id'])
removed_keys = set(existing_keys).difference(requested_keys)
for key in removed_keys:
#if peer:
- #self.driver.iotlab_api.UnBindObjectFromPeer('key', \
+ #self.driver.testbed_shell.UnBindObjectFromPeer('key', \
#key, peer['shortname'])
user = users_by_key_string[key]
- self.driver.iotlab_api.DeleteKey(user, key)
+ self.driver.testbed_shell.DeleteKey(user, key)
return