Contains methods to get information on slice, slivers, nodes and leases,
formatting them and turn it into a RSpec.
"""
-from sfa.util.xrn import hrn_to_urn, urn_to_hrn, get_authority
-
+from sfa.util.sfatime import utcparse, datetime_to_string
+from sfa.util.xrn import Xrn, hrn_to_urn, urn_to_hrn, get_authority
+from sfa.iotlab.iotlabxrn import IotlabXrn
from sfa.rspecs.rspec import RSpec
#from sfa.rspecs.elements.location import Location
from sfa.rspecs.elements.hardware_type import HardwareType
from sfa.rspecs.elements.lease import Lease
from sfa.rspecs.elements.granularity import Granularity
from sfa.rspecs.version_manager import VersionManager
-
+from sfa.storage.model import SliverAllocation
from sfa.rspecs.elements.versions.iotlabv1Node import IotlabPosition, \
IotlabNode, IotlabLocation
-
+from sfa.iotlab.iotlabxrn import xrn_object
from sfa.util.sfalogging import logger
-from sfa.util.xrn import Xrn
-
-
-
-
+import time
class IotlabAggregate:
"""Aggregate manager class for Iotlab. """
# return (rspec_nodes)
return nodes_dict
- def node_to_rspec_node(self, node, grain):
+ def node_to_rspec_node(self, node):
+
+ grain = self.driver.testbed_shell.GetLeaseGranularity()
+
rspec_node = IotlabNode()
# xxx how to retrieve site['login_base']
#site_id=node['site_id']
return rspec_node
+
+ def rspec_node_to_geni_sliver(self, rspec_node, sliver_allocations = {}):
+ if rspec_node['sliver_id'] in sliver_allocations:
+ # set sliver allocation and operational status
+ sliver_allocation = sliver_allocations[rspec_node['sliver_id']]
+ if sliver_allocation:
+ allocation_status = sliver_allocation.allocation_state
+ if allocation_status == 'geni_allocated':
+ op_status = 'geni_pending_allocation'
+ elif allocation_status == 'geni_provisioned':
+ op_status = 'geni_ready'
+ else:
+ op_status = 'geni_unknown'
+ else:
+ allocation_status = 'geni_unallocated'
+ else:
+ allocation_status = 'geni_unallocated'
+ op_status = 'geni_failed'
+ # required fields
+ geni_sliver = {'geni_sliver_urn': rspec_node['sliver_id'],
+ 'geni_expires': rspec_node['expires'],
+ 'geni_allocation_status' : allocation_status,
+ 'geni_operational_status': op_status,
+ 'geni_error': '',
+ }
+ return geni_sliver
+
+
+ def sliver_to_rspec_node(self, sliver, sliver_allocations):
+ rspec_node = self.node_to_rspec_node(sliver)
+ rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
+ # add sliver info
+ logger.debug("IOTLABAGGREGATE api \t sliver_to_rspec_node sliverr %s \r\nsliver_allocations %s"
+ % (sliver, sliver_allocations))
+ rspec_sliver = Sliver({'sliver_id': sliver['urn'],
+ 'name': sliver['slice_id'],
+ 'type': 'iotlab-exclusive',
+ 'tags': []})
+ rspec_node['sliver_id'] = rspec_sliver['sliver_id']
+ if sliver['urn'] in sliver_allocations:
+ rspec_node['client_id'] = sliver_allocations[sliver['urn']].client_id
+ if sliver_allocations[sliver['urn']].component_id:
+ rspec_node['component_id'] = sliver_allocations[sliver['urn']].component_id
+ rspec_node['slivers'] = [rspec_sliver]
+
+ # slivers always provide the ssh service
+ login = Login({'authentication': 'ssh-keys',
+ 'hostname': sliver['hostname'],
+ 'port':'22',
+ 'username': sliver['slice_name'],
+ 'login': sliver['slice_name']
+ })
+ return rspec_node
+
+
def get_all_leases(self, ldap_username):
"""
FINAL RSPEC %s \r\n" % (rspec.toxml()))
return rspec.toxml()
+ def get_slivers(self, urns, options={}):
+ """
+
+ """
+
+
+ slice_ids = set()
+ node_ids = []
+ for urn in urns:
+ xrn = IotlabXrn(xrn=urn)
+ if xrn.type == 'sliver':
+ # id: slice_id-node_id
+ try:
+ sliver_id_parts = xrn.get_sliver_id_parts()
+ slice_id = int(sliver_id_parts[0])
+ node_id = int(sliver_id_parts[1])
+ slice_ids.add(slice_id)
+ node_ids.append(node_id)
+ except ValueError:
+ pass
+ else:
+ slice_names = set()
+ slice_names.add(xrn.hrn)
+
+
+ logger.debug("IotlabAggregate \t get_slivers urns %s slice_ids %s \
+ node_ids %s\r\n" % (urns, slice_ids, node_ids))
+ logger.debug("IotlabAggregate \t get_slivers xrn %s slice_names %s \
+ \r\n" % (xrn, slice_names))
+ filter = {}
+ if slice_names:
+ filter['slice_hrn'] = list(slice_names)
+ slice_hrn = filter['slice_hrn'][0]
+
+ slice_filter_type = 'slice_hrn'
+ logger.debug("IotlabAggregate \t get_slivers slice_hrn%s \
+ \r\n" % (slice_hrn ))
+ # if slice_ids:
+ # filter['slice_id'] = list(slice_ids)
+ # # get slices
+ if slice_hrn:
+ slices = self.driver.testbed_shell.GetSlices(slice_hrn,
+ slice_filter_type)
+ leases = self.driver.testbed_shell.GetLeases(
+ {'slice_hrn':slice_hrn})
+ logger.debug("IotlabAggregate \t get_slivers \
+ slices %s leases %s\r\n" % (slices, leases ))
+ if not slices:
+ return []
+ # slice = slices[0]
+ # slice['hrn'] = DummyXrn(auth=self.driver.hrn, slicename=slice['slice_name']).hrn
+ single_slice = slices[0]
+ # get sliver users
+ # users = []
+ # user_ids = []
+ # for slice in slices:
+ # user_ids.extend(slice['user_ids'])
+ # if user_ids:
+ # users = self.driver.shell.GetUsers({'user_ids': user_ids})
+
+ user = single_slice['reg_researchers'][0].__dict__
+ logger.debug("IotlabAggregate \t get_slivers user %s \
+ \r\n" % (user))
+
+ # construct user key info
+ # users_list = []
+ # for user in users:
+ person = self.driver.testbed_shell.ldap.LdapFindUser(record=user)
+ logger.debug("IotlabAggregate \t get_slivers person %s \
+ \r\n" % (person))
+ name = person['last_name']
+ user['login'] = person['uid']
+ user['user_urn'] = hrn_to_urn(user['hrn'], 'user')
+ user['keys'] = person['pkey']
+ # name = user['email'][0:user['email'].index('@')]
+ # user = {
+ # 'login': slice['slice_name'],
+ # 'user_urn': Xrn('%s.%s' % (self.driver.hrn, name), type='user').urn,
+ # 'keys': user['keys']
+ # }
+ # users_list.append(user)
+
+ try:
+ node_ids = single_slice['node_ids']
+ node_list = self.driver.testbed_shell.GetNodes(
+ {'hostname':single_slice['node_ids']})
+ node_by_hostname = dict([(node['hostname'], node) for node in node_list])
+ except KeyError:
+ logger.warning("\t get_slivers No slivers in slice")
+ # slice['node_ids'] = node_ids
+ # nodes_dict = self.get_slice_nodes(slice, options)
+ logger.debug("IotlabAggregate \t get_slivers node_by_hostname%s \
+ \r\n" % (node_by_hostname))
+ slivers = []
+ for current_lease in leases:
+ for hostname in current_lease['reserved_nodes']:
+ node = {}
+ node['slice_id'] = current_lease['slice_id']
+ node['slice_hrn'] = current_lease['slice_hrn']
+ slice_name = current_lease['slice_hrn'].split(".")[1]
+ node['slice_name'] = slice_name
+ index = current_lease['reserved_nodes'].index(hostname)
+ node_id = current_lease['resource_ids'][index]
+ # node['slice_name'] = user['login']
+ # node.update(single_slice)
+ more_info = node_by_hostname[hostname]
+ node.update(more_info)
+ # oar_job_id is the slice_id (lease_id)
+ sliver_hrn = '%s.%s-%s' % (self.driver.hrn,
+ current_lease['lease_id'], node_id)
+ node['node_id'] = node_id
+ node['expires'] = current_lease['t_until']
+ node['sliver_id'] = Xrn(sliver_hrn, type='sliver').urn
+ node['urn'] = node['sliver_id']
+ node['services_user'] = [user]
+ logger.debug("IotlabAggregate \t get_slivers node %s current_lease %s\
+ \r\n more_info %s" % (node, current_lease, more_info))
+ slivers.append(node)
+ return slivers
def list_resources(self, version = None, options={}):
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, 'ad')
rspec = RSpec(version=rspec_version, user_options=options)
-
+ # variable ldap_username to be compliant with the get_all_leases
+ # prototype. Now unused in geni-v3 since we are getting all the leases
+ # here
+ ldap_username = None
if not options.get('list_leases') or options['list_leases'] != 'leases':
# get nodes
nodes_dict = self.get_nodes(options)
# node_tags = self.get_node_tags({'node_tag_id': tag_ids})
# pl_initscripts = self.get_pl_initscripts()
# convert nodes to rspec nodes
- grain = self.driver.testbed_shell.GetLeaseGranularity()
rspec_nodes = []
for node_id in nodes_dict:
node = nodes_dict[node_id]
# rspec_node = self.node_to_rspec_node(node, sites, interfaces, node_tags, pl_initscripts)
- rspec_node = self.node_to_rspec_node(node, grain)
+ rspec_node = self.node_to_rspec_node(node)
rspec_nodes.append(rspec_node)
rspec.version.add_nodes(rspec_nodes)
# links = self.get_links(sites, nodes_dict, interfaces)
# rspec.version.add_links(links)
- if not options.get('list_leases') or options.get('list_leases') and options['list_leases'] != 'resources':
- leases = self.get_all_leases()
- rspec.version.add_leases(leases)
+ if not options.get('list_leases') or options.get('list_leases') \
+ and options['list_leases'] != 'resources':
+ leases = self.get_all_leases(ldap_username)
+ rspec.version.add_leases(leases)
return rspec.toxml()
def describe(self, urns, version=None, options={}):
+ """
+ Retrieve a manifest RSpec describing the resources contained by the
+ named entities, e.g. a single slice or a set of the slivers in a slice.
+ This listing and description should be sufficiently descriptive to allow
+ experimenters to use the resources.
+
+ returns: On success returns the following struct:
+ {
+ geni_rspec: <geni.rspec, a Manifest RSpec>
+ geni_urn: <string slice urn of the containing slice>
+ geni_slivers:{
+ geni_sliver_urn: <string sliver urn>
+ geni_expires: <dateTime.rfc3339
+ allocation expiration string, as in geni_expires
+ from SliversStatus>,
+ geni_allocation_status: <string sliver state -
+ e.g. geni_allocated or geni_provisioned >,
+ geni_operational_status: <string sliver operational
+ state>,
+ geni_error: <optional string. The field may be omitted
+ entirely but may not be null/None, explaining any
+ failure for a sliver.>
+ },
+ ]}
+ .. seealso:: http://groups.geni.net/geni/wiki/GAPI_AM_API_V3#Describe
+ """
version_manager = VersionManager()
version = version_manager.get_version(version)
- rspec_version = version_manager._get_version(version.type,
- version.version, 'manifest')
+ rspec_version = version_manager._get_version(
+ version.type, version.version, 'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# get slivers
# lookup the sliver allocations
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
+ logger.debug(" IOTLAB_API.PY \tDescribe sliver_ids %s "
+ % (sliver_ids))
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
- sliver_allocations = self.driver.api.dbsession().query(SliverAllocation).filter(constraint)
+ logger.debug(" IOTLAB_API.PY \tDescribe constraint %s "
+ % (constraint))
+ sliver_allocations = self.driver.api.dbsession().query(SliverAllocation).filter((constraint)).all()
+ logger.debug(" IOTLAB_API.PY \tDescribe sliver_allocations %s "
+ % (sliver_allocations))
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
for sliver in slivers:
rspec_node = self.sliver_to_rspec_node(sliver, sliver_allocation_dict)
rspec_nodes.append(rspec_node)
+ logger.debug(" IOTLAB_API.PY \tDescribe sliver_allocation_dict %s "
+ % (sliver_allocation_dict))
geni_sliver = self.rspec_node_to_geni_sliver(rspec_node, sliver_allocation_dict)
geni_slivers.append(geni_sliver)
+
+ logger.debug(" IOTLAB_API.PY \tDescribe rspec_nodes %s\
+ rspec %s "
+ % (rspec_nodes, rspec))
rspec.version.add_nodes(rspec_nodes)
return {'geni_urn': geni_urn,
from sfa.util.faults import SliverDoesNotExist, UnknownSfaType
from sfa.util.sfalogging import logger
from sfa.storage.model import RegRecord
+from sfa.util.sfatime import utcparse, datetime_to_string
from sfa.managers.driver import Driver
from sfa.rspecs.version_manager import VersionManager
from sfa.rspecs.rspec import RSpec
-from sfa.util.xrn import Xrn, hrn_to_urn, get_authority
+from sfa.iotlab.iotlabxrn import xrn_object
+from sfa.util.xrn import Xrn, hrn_to_urn, get_authority, urn_to_hrn
from sfa.iotlab.iotlabaggregate import IotlabAggregate
from sfa.iotlab.iotlabxrn import xrn_to_hostname
from sfa.iotlab.iotlabslices import IotlabSlices
-
+from sfa.storage.model import SliverAllocation
from sfa.iotlab.iotlabshell import IotlabShell
Driver.__init__(self, api)
self.api = api
config = api.config
- self.testbed_shell = IotlabShell(config)
+ self.testbed_shell = IotlabShell(api)
self.cache = None
def augment_records_with_testbed_info(self, record_list):
login=sfa_slice['login'],
version=rspec.version)
- def delete_sliver(self, slice_urn, slice_hrn, creds, options):
+ def delete(self, slice_urns, options):
"""
Deletes the lease associated with the slice hrn and the credentials
if the slice belongs to iotlab. Answer to DeleteSliver.
:param slice_urn: urn of the slice
- :param slice_hrn: name of the slice
- :param creds: slice credenials
:type slice_urn: string
- :type slice_hrn: string
- :type creds: ? unused
+
:returns: 1 if the slice to delete was not found on iotlab,
True if the deletion was successful, False otherwise otherwise.
.. note:: creds are unused, and are not used either in the dummy driver
delete_sliver .
"""
+ # collect sliver ids so we can update sliver allocation states after
+ # we remove the slivers.
+ aggregate = IotlabAggregate(self)
+ slivers = aggregate.get_slivers(slice_urns)
+ if slivers:
+ slice_id = slivers[0]['slice_id']
+ node_ids = []
+ sliver_ids = []
+ for sliver in slivers:
+ node_ids.append(sliver['node_id'])
+ sliver_ids.append(sliver['sliver_id'])
+ logger.debug("IOTLABDRIVER.PY delete_sliver slivers %s slice_urns %s"
+ % (slivers, slice_urns))
+ slice_hrn = urn_to_hrn(slice_urns[0])[0]
sfa_slice_list = self.testbed_shell.GetSlices(
slice_filter=slice_hrn,
\r\n \t sfa_slice %s " % (peer, sfa_slice))
try:
self.testbed_shell.DeleteSliceFromNodes(sfa_slice)
- return True
+ dbsession = self.api.dbsession()
+ SliverAllocation.delete_allocations(sliver_ids,dbsession)
except:
- return False
+ logger.log_exc("IOTLABDRIVER.PY delete error ")
+
+ # prepare return struct
+ geni_slivers = []
+ for sliver in slivers:
+ geni_slivers.append(
+ {'geni_sliver_urn': sliver['sliver_id'],
+ 'geni_allocation_status': 'geni_unallocated',
+ 'geni_expires': datetime_to_string(utcparse(sliver['expires']))})
+ return geni_slivers
def list_resources (self, slice_urn, slice_hrn, creds, options):
"""
slice_record = None
users = options.get('geni_users', [])
- if users:
- slice_record = users[0].get('slice_record', {})
- logger.debug("IOTLABDRIVER.PY \t ===============allocatte \t\
- \r\n \r\n users %s" % (users))
+
+ sfa_users = options.get('sfa_users', [])
+ if sfa_users:
+ slice_record = sfa_users[0].get('slice_record', [])
+ logger.debug("IOTLABDRIVER.PY \t ===============allocate \t\
+ \r\n \r\n options %s slice_record %s" % (options,slice_record))
# parse rspec
rspec = RSpec(rspec_string)
# requested_attributes = rspec.version.get_slice_attributes()
# ensure site record exists
# site = slices.verify_site(xrn.hrn, slice_record, peer, sfa_peer, options=options)
# ensure slice record exists
- current_slice = slices.verify_slice(xrn.hrn, slice_record, peer, sfa_peer, expiration=expiration, options=options)
+
+ current_slice = slices.verify_slice(xrn.hrn, slice_record, sfa_peer)
+ logger.debug("IOTLABDRIVER.PY \t ===============allocate \t\
+ \r\n \r\n current_slice %s" % (current_slice))
# ensure person records exists
- persons = slices.verify_persons(xrn.hrn, slice, users, peer, sfa_peer, options=options)
+
+ # oui c'est degueulasse, le slice_record se retrouve modifie
+ # dans la methode avec les infos du user, els infos sont propagees
+ # dans verify_slice_leases
+ persons = slices.verify_persons(xrn.hrn, slice_record, users, options=options)
# ensure slice attributes exists
# slices.verify_slice_attributes(slice, requested_attributes, options=options)
# add/remove slice from nodes
requested_xp_dict = self._process_requested_xp_dict(rspec)
- logger.debug("IOTLABDRIVER.PY \tcreate_sliver requested_xp_dict %s "
+ logger.debug("IOTLABDRIVER.PY \tallocate requested_xp_dict %s "
% (requested_xp_dict))
- # request_nodes = rspec.version.get_nodes_with_slivers()
- # nodes = slices.verify_slice_nodes(urn, slice, request_nodes, peer)
+ request_nodes = rspec.version.get_nodes_with_slivers()
+ nodes_list = []
+ for start_time in requested_xp_dict:
+ lease = requested_xp_dict[start_time]
+ for hostname in lease['hostname']:
+ nodes_list.append(hostname)
+
+ # nodes = slices.verify_slice_nodes(slice_record,request_nodes, peer)
+ logger.debug("IOTLABDRIVER.PY \tallocate nodes_list %s slice_record %s"
+ % (nodes_list, slice_record))
+ # add/remove leases
+ rspec_requested_leases = rspec.version.get_leases()
+ leases = slices.verify_slice_leases(slice_record, requested_xp_dict, peer)
+ logger.debug("IOTLABDRIVER.PY \tallocate leases %s rspec_requested_leases %s"
+ % (leases,rspec_requested_leases))
+ # update sliver allocations
+ for hostname in nodes_list:
+ client_id = hostname
+ node_urn = xrn_object(self.testbed_shell.root_auth, hostname).urn
+ component_id = node_urn
+ slice_urn = current_slice['reg-urn']
+ for lease in leases:
+ if hostname in lease['reserved_nodes']:
+ index = lease['reserved_nodes'].index(hostname)
+ sliver_hrn = '%s.%s-%s' % (self.hrn, lease['lease_id'],
+ lease['resource_ids'][index] )
+ sliver_id = Xrn(sliver_hrn, type='sliver').urn
+ record = SliverAllocation(sliver_id=sliver_id, client_id=client_id,
+ component_id=component_id,
+ slice_urn = slice_urn,
+ allocation_state='geni_allocated')
+
+ logger.debug("\r\n \
+ ===============================IOTLABDRIVER.PY \tallocate sliver_id %s slice_urn %s \r\n"
+ % (sliver_id,slice_urn))
+ record.sync(self.api.dbsession())
# add/remove links links
# slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
- # add/remove leases
- # rspec_requested_leases = rspec.version.get_leases()
- leases = slices.verify_slice_leases(current_slice, requested_xp_dict, peer)
- # handle MyPLC peer association.
- # only used by plc and ple.
- slices.handle_peer(site, slice, None, peer)
return aggregate.describe([xrn.get_urn()], version=rspec.version)
peer = slices.get_peer(current_slice['hrn'])
sfa_peer = slices.get_sfa_peer(current_slice['hrn'])
users = options.get('geni_users', [])
- persons = slices.verify_persons(current_slice['hrn'],
- current_slice, users, peer, sfa_peer, options=options)
- slices.handle_peer(None, None, persons, peer)
+ # persons = slices.verify_persons(current_slice['hrn'],
+ # current_slice, users, peer, sfa_peer, options=options)
+ # slices.handle_peer(None, None, persons, peer)
# update sliver allocation states and set them to geni_provisioned
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
- dbsession=self.api.dbsession()
+ dbsession =self.api.dbsession()
SliverAllocation.set_allocations(sliver_ids, 'geni_provisioned',dbsession)
version_manager = VersionManager()
rspec_version = version_manager.get_version(options['geni_rspec_version'])
_MINIMUM_DURATION = 10 # 10 units of granularity 60 s, 10 mins
- def __init__(self, config):
+ def __init__(self, api):
"""Creates an instance of OARrestapi and LDAPapi which will be used to
issue calls to OAR or LDAP methods.
Set the time format and the testbed granularity used for OAR
:param config: configuration object from sfa.util.config
:type config: Config object
"""
- # self.api=api
- # config=api.config
+ self.api = api
+ config = api.config
self.leases_db = TestbedAdditionalSfaDB(config)
self.oar = OARrestapi()
self.ldap = LDAPapi()
:type slice_record: dict
:type lease_start_time: integer
:type lease_duration: integer
+ :returns: job_id, can be None if the job request failed.
"""
logger.debug("IOTLAB_API \r\n \r\n \t AddLeases hostname_list %s \
slice_record['hrn'], \
lease_start_time, lease_duration, \
username)
- start_time = \
- datetime.fromtimestamp(int(lease_start_time)).\
- strftime(self.time_format)
- end_time = lease_start_time + lease_duration
+ if job_id is not None:
+ start_time = \
+ datetime.fromtimestamp(int(lease_start_time)).\
+ strftime(self.time_format)
+ end_time = lease_start_time + lease_duration
- logger.debug("IOTLAB_API \r\n \r\n \t AddLeases TURN ON LOGGING SQL \
- %s %s %s "%(slice_record['hrn'], job_id, end_time))
+ logger.debug("IOTLAB_API \r\n \r\n \t AddLeases TURN ON LOGGING SQL \
+ %s %s %s "%(slice_record['hrn'], job_id, end_time))
- logger.debug("IOTLAB_API \r\n \r\n \t AddLeases %s %s %s " \
- %(type(slice_record['hrn']), type(job_id), type(end_time)))
+ logger.debug("IOTLAB_API \r\n \r\n \t AddLeases %s %s %s " \
+ %(type(slice_record['hrn']), type(job_id), type(end_time)))
- iotlab_ex_row = LeaseTableXP(slice_hrn = slice_record['hrn'], experiment_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("IOTLAB_API \r\n \r\n \t AddLeases iotlab_ex_row %s" \
- %(iotlab_ex_row))
- self.leases_db.testbed_session.add(iotlab_ex_row)
- self.leases_db.testbed_session.commit()
+ logger.debug("IOTLAB_API \r\n \r\n \t AddLeases iotlab_ex_row %s" \
+ %(iotlab_ex_row))
+ self.leases_db.testbed_session.add(iotlab_ex_row)
+ self.leases_db.testbed_session.commit()
- logger.debug("IOTLAB_API \t AddLeases hostname_list start_time %s " \
- %(start_time))
+ logger.debug("IOTLAB_API \t AddLeases hostname_list start_time %s " \
+ %(start_time))
- return
+ return job_id
#Delete the jobs from job_iotlab table
logger.debug("IOTLABSLICES \
NEWLEASE slice %s job %s"
% (sfa_slice, job))
- self.driver.testbed_shell.AddLeases(
+ job_id = self.driver.testbed_shell.AddLeases(
job['hostname'],
sfa_slice, int(job['start_time']),
int(job['duration']))
+ if job_id is not None:
+ new_leases = self.driver.testbed_shell.GetLeases(login=
+ sfa_slice['login'])
+ for new_lease in new_leases:
+ leases.append(new_lease)
#Deleted leases are the ones with lease id not declared in the Rspec
if deleted_leases:
logger.debug("IOTLABSLICES \tverify_persons \tslice_hrn %s \
\t slice_record %s\r\n users %s \t "
% (slice_hrn, slice_record, users))
- users_by_id = {}
users_by_email = {}
#users_dict : dict whose keys can either be the user's hrn or its id.
#First create dicts by hrn and id for each user in the user record list:
for info in users:
- if 'slice_record' in info:
- slice_rec = info['slice_record']
- if 'user' in slice_rec :
- user = slice_rec['user']
+ # if 'slice_record' in info:
+ # slice_rec = info['slice_record']
+ # 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 info:
+ users_by_email[info['email']] = info
+ users_dict[info['email']] = info
logger.debug("SLABSLICE.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))
+ users_dict %s \r\n user_by_email %s \r\n "
+ % (users_dict, users_by_email))
existing_user_ids = []
existing_user_emails = []
#Needed because what if the user has been deleted in LDAP but
#is still in SFA?
existing_users = self.driver.testbed_shell.GetPersons(filter_user)
- logger.debug(" \r\n IOTLABSLICES.PY \tverify_person filter_user \
- %s existing_users %s "
+ logger.debug(" \r\n IOTLABSLICES.PY \tverify_person filter_user %s\
+ existing_users %s "
% (filter_user, existing_users))
#User is in iotlab LDAP
if existing_users:
for user in existing_users:
+ user['login'] = user['uid']
users_dict[user['email']].update(user)
existing_user_emails.append(
users_dict[user['email']]['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:
+ if slice_record['reg-researchers'][0] in requested_user_hrns:
logger.debug(" SLABSLICE \tverify_person ['PI']\
slice_record %s" % (slice_record))
class IotlabXrn (Xrn):
@staticmethod
- def site_hrn (auth, testbed_name):
- return '.'.join([auth, testbed_name])
+ def site_hrn (auth):
+ return auth
def __init__ (self, auth=None, hostname=None, login=None, slicename=None,**kwargs):
#def hostname_to_hrn(auth_hrn, login_base, hostname):
self.hrn_to_urn()
# split at the first _
-
-
else:
Xrn.__init__ (self,**kwargs)
network_elem.set('login', unicode(iotlab_network_dict['login']))
@staticmethod
- def add_nodes(xml, nodes):
+ def add_nodes(xml, nodes,rspec_content_type=None):
"""Adds the nodes to the xml.
Adds the nodes as well as dedicated iotlab fields to the node xml
#'value': initscript['name']})
Iotlabv1Sliver.add_slivers(node_elem, slivers)
+ # add sliver tag in Request Rspec
+ if rspec_content_type == "request":
+ node_elem.add_instance('sliver', '', [])
return node_elems
@staticmethod
<?xml version="1.0"?>
<RSpec type="SFA" expires="2013-02-27T15:14:10Z" generated="2013-02-27T14:14:10Z">
<network name="iotlab">
- <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+wsn430-8.devlille.iot-lab.info" boot_state="Alive" component_name="wsn430-8.devlille.iot-lab.info.info" site_id="urn:publicid:IDN+senslab+authority+sa">
+ <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+wsn430-8.devlille.iot-lab.info" boot_state="Alive" component_name="wsn430-8.devlille.iot-lab.info.info" site_id="urn:publicid:IDN+iotlab+authority+sa">
<hostname>wsn430-8.devlille.iot-lab.info</hostname>
<location country="France"/>
<exclusive>TRUE</exclusive>
<granularity grain="600"/>
<sliver/>
</node>
- <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+wsn430-5.devlille.iot-lab.info" boot_state="Alive" component_name="wsn430-5.devlille.iot-lab.info" site_id="urn:publicid:IDN+senslab+authority+sa">
+ <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+wsn430-5.devlille.iot-lab.info" boot_state="Alive" component_name="wsn430-5.devlille.iot-lab.info" site_id="urn:publicid:IDN+iotlab+authority+sa">
<hostname>wsn430-5.devlille.iot-lab.info</hostname>
<location country="France"/>
<exclusive>TRUE</exclusive>
<?xml version="1.0"?>
<RSpec type="SFA" expires="2013-02-27T15:14:10Z" generated="2013-02-27T14:14:10Z">
<network name="iotlab">
- <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+wsn430-12.devlille.iot-lab.info" boot_state="Alive" component_name="wsn430-12.devlille.iot-lab.info" site_id="urn:publicid:IDN+senslab+authority+sa">
+ <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+wsn430-12.devlille.iot-lab.info" boot_state="Alive" component_name="wsn430-12.devlille.iot-lab.info" site_id="urn:publicid:IDN+iotlab+authority+sa">
<hostname>wsn430-12.devlille.iot-lab.info</hostname>
<location country="France"/>
<exclusive>TRUE</exclusive>
<granularity grain="600"/>
<sliver/>
</node>
- <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+a8-11.devgrenoble.iot-lab.info" boot_state="Alive" component_name="a8-11.devgrenoble.iot-lab.info" site_id="urn:publicid:IDN+senslab+authority+sa">
+ <node component_manager_id="urn:publicid:IDN+iotlab+authority+sa" component_id="urn:publicid:IDN+iotlab+node+a8-11.devgrenoble.iot-lab.info" boot_state="Alive" component_name="a8-11.devgrenoble.iot-lab.info" site_id="urn:publicid:IDN+iotlab+authority+sa">
<hostname>"a8-11.devgrenoble.iot-lab.info</hostname>
<location country="France"/>
<exclusive>TRUE</exclusive>
git://git.onelab.eu / sfa.git / commitdiff