from sfa.rspecs.version_manager import VersionManager
from sfa.rspecs.rspec import RSpec
-from sfa.iotlab.iotlabxrn import IotlabXrn, xrn_object
+from sfa.iotlab.iotlabxrn import IotlabXrn, xrn_object, xrn_to_hostname
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.trust.credential import Credential
"""
Sets the iotlab SFA config parameters,
- instanciates the testbed api and the iotlab database.
+ instanciates the testbed api .
- :param config: iotlab SFA configuration object
- :type config: Config object
+ :param api: SfaApi configuration object. Holds reference to the
+ database.
+ :type api: SfaApi object
"""
Driver.__init__(self, api)
" %(user_dict))
hrn = user_dict['hrn']
person_urn = hrn_to_urn(hrn, 'user')
- pubkey = user_dict['pkey']
try:
+ pubkey = user_dict['pkey']
pkey = convert_public_key(pubkey)
except TypeError:
#key not good. create another pkey
- logger.warn('__add_person_to_db: unable to convert public \
+ logger.warn('__add_person_to_db: no public key or unable to convert public \
key for %s' %(hrn ))
pkey = Keypair(create=True)
user_record = RegUser(hrn=hrn , pointer= '-1', \
authority=get_authority(hrn), \
email=user_dict['email'], gid = person_gid)
- user_record.reg_keys = [RegKey(user_dict['pkey'])]
+ #user_record.reg_keys = [RegKey(user_dict['pkey'])]
user_record.just_created()
self.api.dbsession().add (user_record)
self.api.dbsession().commit()
"""
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
- reg_researcher relationship.
+ reg_researchers relationship.
:param slice_filter: the slice hrn we are looking for
:type slice_filter: string
raw_slicerec = self.api.dbsession().query(RegSlice).options(joinedload('reg_researchers')).filter_by(hrn=slice_filter).first()
#raw_slicerec = self.api.dbsession().query(RegRecord).filter_by(hrn = slice_filter).first()
if raw_slicerec:
- #load_reg_researcher
+ #load_reg_researchers
#raw_slicerec.reg_researchers
raw_slicerec = raw_slicerec.__dict__
logger.debug(" IOTLAB_API \t _sql_get_slice_info slice_filter %s \
return_slicerec_dictlist.append(slicerec_dict)
- logger.debug("IOTLAB_API.PY \tGetSlices \
- OHOHOHOH %s" %(return_slicerec_dictlist))
logger.debug("IOTLAB_API.PY \tGetSlices \
slicerec_dict %s return_slicerec_dictlist %s \
Two purposes:
-Fetch all the jobs from OAR (running, waiting..)
complete the reservation information with slice hrn
- found in testbed_xp table. If not available in the table,
+ found in lease_table . If not available in the table,
assume it is a iotlab slice.
-Updates the iotlab table, deleting jobs when necessary.
if lease_filter_dict is None:
reservation_list = unfiltered_reservation_list
- self.update_experiments_in_additional_sfa_db(job_oar_list, jobs_psql_id_list)
+ self.update_experiments_in_lease_table(job_oar_list, jobs_psql_id_list)
logger.debug(" IOTLAB_API.PY \tGetLeases reservation_list %s"
% (reservation_list))
- def update_experiments_in_additional_sfa_db(self,
+ def update_experiments_in_lease_table(self,
experiment_list_from_testbed, experiment_list_in_db):
- """ Cleans the iotlab db by deleting expired and cancelled jobs.
+ """ Cleans the lease_table by deleting expired and cancelled jobs.
Compares the list of experiment ids given by the testbed with the
experiment ids that are already in the database, deletes the
set_experiment_list_in_db = set(experiment_list_in_db)
kept_experiments = set(experiment_list_from_testbed).intersection(set_experiment_list_in_db)
- logger.debug("\r\n \t update_experiments_in_additional_sfa_db \
+ logger.debug("\r\n \t update_experiments_in_lease_table \
experiment_list_in_db %s \r\n \
experiment_list_from_testbed %s \
kept_experiments %s "
request.filter(LeaseTableXP.experiment_id.in_(deleted_experiments)).delete(synchronize_session='fetch')
self.api.dbsession().commit()
return
+
+
def AddSlice(self, slice_record, user_record):
"""
sfa_record.just_created()
self.api.dbsession().add(sfa_record)
self.api.dbsession().commit()
- #Update the reg-researcher dependance table
+ #Update the reg-researchers dependency table
sfa_record.reg_researchers = [user_record]
self.api.dbsession().commit()
sfa_peer = slices.get_sfa_peer(xrn.get_hrn())
- slice_record = None
+ slice_record = {}
users = options.get('geni_users', [])
sfa_users = options.get('sfa_users', [])
if sfa_users:
- slice_record = sfa_users[0].get('slice_record', [])
+ # XXX Always empty ??? no slice_record in the Allocate call
+ #slice_record = sfa_users[0].get('slice_record', [])
+ user_xrn = Xrn(sfa_users[0]['urn'])
+ user_hrn = user_xrn.get_hrn()
+
+ slice_record = sfa_users[0].get('slice_record', {})
+ slice_record['user'] = {'keys': users[0]['keys'],
+ 'email': users[0]['email'],
+ 'hrn': user_hrn}
+ slice_record['authority'] = xrn.get_authority_hrn()
+
+ logger.debug("IOTLABDRIVER.PY \t urn %s allocate options %s "
+ % (urn, options))
# parse rspec
rspec = RSpec(rspec_string)
# 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
+ logger.debug("IOTLABDRIVER.PY BEFORE slices.verify_persons")
persons = slices.verify_persons(xrn.hrn, slice_record, users,
options=options)
+ logger.debug("IOTLABDRIVER.PY AFTER slices.verify_persons")
# ensure slice attributes exists
# slices.verify_slice_attributes(slice, requested_attributes,
# options=options)
client_id = hostname
node_urn = xrn_object(self.testbed_shell.root_auth, hostname).urn
component_id = node_urn
- slice_urn = current_slice['reg-urn']
+ if 'reg-urn' in current_slice:
+ slice_urn = current_slice['reg-urn']
+ else:
+ slice_urn = current_slice['urn']
for lease in leases:
if hostname in lease['reserved_nodes']:
index = lease['reserved_nodes'].index(hostname)
git://git.onelab.eu / sfa.git / blobdiff