+"""
+This file defines the IotlabSlices class by which all the slice checkings
+upon lease creation are done.
+"""
from sfa.util.xrn import get_authority, urn_to_hrn
from sfa.util.sfalogging import logger
MAXINT = 2L**31-1
-class IotlabSlices:
+class IotlabSlices:
+ """
+ This class is responsible for checking the slice when creating a
+ lease or a sliver. Those checks include verifying that the user is valid,
+ that the slice is known from the testbed or from our peers, that the list
+ of nodes involved has not changed (in this case the lease is modified
+ accordingly).
+ """
rspec_to_slice_tag = {'max_rate': 'net_max_rate'}
-
def __init__(self, driver):
"""
Get the reference to the driver here.
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
site_authority = get_authority(slice_authority).lower()
# get this site's authority (sfa root authority or sub authority)
- logger.debug("IOTLABSLICES \ get_peer slice_authority %s \
+ logger.debug("IOTLABSLICES \t get_peer slice_authority %s \
site_authority %s hrn %s"
- % (slice_authority, site_authority, hrn))
+ % (slice_authority, site_authority, hrn))
# 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 \tget_peer peer %s " %(peer))
+ logger.debug(" IOTLABSLICES \tget_peer peer %s " % (peer))
return peer
def get_sfa_peer(self, xrn):
return sfa_peer
-
def verify_slice_leases(self, sfa_slice, requested_jobs_dict, peer):
"""
Compare requested leases with the leases already scheduled/
:param sfa_slice: sfa slice record
:param requested_jobs_dict: dictionary of requested leases
- :param peer: sfa peer
+ :param peer: sfa peer record
:type sfa_slice: dict
:type requested_jobs_dict: dict
- :type peer:
+ :type peer: dict
:returns: leases list of dictionary
:rtype: list
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({'name': 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))
#First remove job whose duration is too short
for job in requested_jobs_dict.values():
- if job['duration'] < self.driver.iotlab_api.GetLeaseGranularity():
+ job['duration'] = \
+ str(int(job['duration']) \
+ * 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']))
:returns: list requested nodes hostnames
:rtype: list
+ .. warning:: UNUSED SQA 24/07/13
.. seealso:: DeleteSliceFromNodes
.. todo:: check what to do with the peer? Can not remove peer nodes from
slice here. Anyway, in this case, the peer should have gotten the
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
if slices_list:
for sl in slices_list:
- logger.debug("SLABSLICE \t verify_slice slicename %s \
+ logger.debug("IOTLABSLICES \t verify_slice slicename %s \
slices_list %s sl %s \r slice_record %s"
% (slicename, slices_list, sl, slice_record))
sfa_slice = sl
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
Checking that a user exist is based on the user's email. If the user is
still not found in the LDAP, it means that the user comes from another
- federated. In this case an account has to be created in LDAP
+ federated testbed. In this case an account has to be created in LDAP
so as to enable the user to use the testbed, since we trust the testbed
he comes from. This is done by calling AddPerson.
for info in users:
if 'slice_record' in info:
slice_rec = info['slice_record']
- user = slice_rec['user']
+ if 'user' in slice_rec :
+ user = slice_rec['user']
- if 'email' in user:
- users_by_email[user['email']] = user
- users_dict[user['email']] = user
+ if 'email' in user:
+ users_by_email[user['email']] = user
+ users_dict[user['email']] = user
- logger.debug("SLABSLICE.PY \t verify_person \
+ logger.debug("IOTLABSLICES.PY \t verify_person \
users_dict %s \r\n user_by_email %s \r\n \
\tusers_by_id %s "
% (users_dict, users_by_email, users_by_id))
#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)
- logger.debug(" \r\n SLABSLICE.PY \tverify_person 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))
#User is in iotlab LDAP
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(" SLABSLICE.PY \tverify_person users \
+ logger.debug(" IOTLABSLICES.PY \tverify_person users \
USER already in Iotlab \t ldap_reslt %s \
" % (ldap_reslt))
existing_users.append(ldap_reslt[1])
else:
#User not existing in LDAP
- logger.debug("SLABSLICE.PY \tverify_person users \
+ logger.debug("IOTLABSLICES.PY \tverify_person users \
not in ldap ...NEW ACCOUNT NEEDED %s \r\n \t \
ldap_reslt %s " % (users, ldap_reslt))
requested_user_emails = users_by_email.keys()
requested_user_hrns = \
[users_by_email[user]['hrn'] for user in users_by_email]
- logger.debug("SLABSLICE.PY \tverify_person \
+ logger.debug("IOTLABSLICES.PY \tverify_person \
users_by_email %s " % (users_by_email))
#Check that the user of the slice in the slice record
#matches one of the existing users
try:
if slice_record['PI'][0] in requested_user_hrns:
- logger.debug(" SLABSLICE \tverify_person ['PI']\
+ logger.debug(" IOTLABSLICES \tverify_person ['PI']\
slice_record %s" % (slice_record))
except KeyError:
#requested_user_email is in existing_user_emails
if len(added_user_emails) == 0:
slice_record['login'] = users_dict[requested_user_emails[0]]['uid']
- logger.debug(" SLABSLICE \tverify_person QUICK DIRTY %s"
+ logger.debug(" IOTLABSLICES \tverify_person QUICK DIRTY %s"
% (slice_record))
for added_user_email in added_user_emails:
added_user = users_dict[added_user_email]
- logger.debug(" SLABSLICE \r\n \r\n \t THE SECOND verify_person \
+ logger.debug(" IOTLABSLICES \r\n \r\n \t verify_person \
added_user %s" % (added_user))
person = {}
person['peer_person_id'] = None
person['email'] = added_user['email']
person['key_ids'] = added_user.get('key_ids', [])
- ret = self.driver.iotlab_api.AddPerson(person)
- if type(ret) == int:
- person['uid'] = ret
+ ret = self.driver.testbed_shell.AddPerson(person)
+ if 'uid' in ret:
+ # meaning bool is True and the AddPerson was successful
+ person['uid'] = ret['uid']
+ slice_record['login'] = person['uid']
+ else:
+ # error message in ret
+ logger.debug(" IOTLABSLICES ret message %s" %(ret))
- logger.debug(" SLABSLICE \r\n \r\n \t THE SECOND verify_person\
+ logger.debug(" IOTLABSLICES \r\n \r\n \t THE SECOND verify_person\
person %s" % (person))
#Update slice_Record with the id now known to LDAP
- slice_record['login'] = person['uid']
+
added_persons.append(person)
return added_persons
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('person',
- #person['person_id'], peer['shortname'])
- ret = self.driver.iotlab_api.AddPersonKey(\
- user['email'], key)
+ #self.driver.testbed_shell.UnBindObjectFromPeer(
+ # 'person',person['person_id'],
+ # peer['shortname'])
+ 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'])
# remove old keys (only if we are not appending)
append = options.get('append', True)
- if append == False:
+ if append is False:
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
git://git.onelab.eu / sfa.git / blobdiff