+import sys
+
from sfa.util.faults import MissingSfaInfo
from sfa.util.sfalogging import logger
from sfa.util.table import SfaTable
# SlabDriver should be really only about talking to the senslab testbed
## thierry : please avoid wildcard imports :)
-from sfa.senslab.OARrestapi import *
-from sfa.senslab.LDAPapi import *
+from sfa.senslab.OARrestapi import OARapi, OARrestapi
+from sfa.senslab.LDAPapi import LDAPapi
+from sfa.senslab.SenslabImportUsers import SenslabImportUsers
+from sfa.senslab.parsing import parse_filter
+from sfa.senslab.slabpostgres import SlabDB
def list_to_dict(recs, key):
"""
#self.users = SenslabImportUsers()
self.oar = OARapi()
self.ldap = LDAPapi()
+ self.users = SenslabImportUsers()
self.time_format = "%Y-%m-%d %H:%M:%S"
+ self.db = SlabDB()
#self.logger=sfa_logger()
def GetPersons(self, person_filter=None, return_fields=None):
-
+
person_list = self.ldap.ldapFind({'authority': self.root_auth })
+
+ #check = False
+ #if person_filter and isinstance(person_filter, dict):
+ #for k in person_filter.keys():
+ #if k in person_list[0].keys():
+ #check = True
+
return_person_list = parse_filter(person_list,person_filter ,'persons', return_fields)
- return return_person_list
+ if return_person_list:
+ print>>sys.stderr, " \r\n GetPersons person_filter %s return_fields %s return_person_list %s " %(person_filter,return_fields,return_person_list)
+ return return_person_list
def GetNodes(self,node_filter= None, return_fields=None):
self.oar.parser.SendRequest("GET_resources_full")
node_dict = self.oar.parser.GetNodesFromOARParse()
return_node_list = []
- print>>sys.stderr, " \r\n GetNodes node_dict %s" %(node_dict)
+
if not (node_filter or return_fields):
return_node_list = node_dict.values()
return return_node_list
return_node_list= parse_filter(node_dict.values(),node_filter ,'node', return_fields)
return return_node_list
+ def GetSites(self, auth, site_filter = None, return_fields=None):
+ self.oar.parser.SendRequest("GET_resources_full")
+ site_dict = self.oar.parser.GetSitesFromOARParse()
+ return_site_list = []
+ site = site_dict.values()[0]
+ if not (site_filter or return_fields):
+ return_site_list = site_dict.values()
+ return return_site_list
+
+ return_site_list = parse_filter(site_dict.values(),site_filter ,'site', return_fields)
+ return return_site_list
+
+ def GetSlices(self,slice_filter = None, return_fields=None):
+
+ return_slice_list =[]
+ sliceslist = self.db.find('slice',columns = ['slice_hrn', 'record_id_slice','record_id_user'])
+ print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY GetSlices slices %s" %(sliceslist)
+ #slicesdict = sliceslist[0]
+ if not (slice_filter or return_fields):
+ return_slice_list = sliceslist
+ return return_slice_list
+
+ return_slice_list = parse_filter(sliceslist, slice_filter,'slice', return_fields)
+ print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY GetSlices return_slice_list %s" %(return_slice_list)
+ return return_slice_list
+
##
# Convert SFA fields to PLC fields for use when registering up updating
# registry record in the PLC database
# get pl records
nodes, sites, slices, persons, keys = {}, {}, {}, {}, {}
if node_ids:
- node_list = self.oar.GetNodes( node_ids)
+ node_list = self.GetNodes( node_ids)
#print>>sys.stderr, " \r\n \t\t\t BEFORE LIST_TO_DICT_NODES node_ids : %s" %(node_ids)
nodes = list_to_dict(node_list, 'node_id')
if site_ids:
slices = list_to_dict(slice_list, 'slice_id')
if person_ids:
#print>>sys.stderr, " \r\n \t\t \t fill_record_pl_info BEFORE GetPersons person_ids: %s" %(person_ids)
- person_list = self.users.GetPersons( person_ids)
+ person_list = self.GetPersons( person_ids)
persons = list_to_dict(person_list, 'person_id')
#print>>sys.stderr, "\r\n fill_record_pl_info persons %s \r\n \t\t person_ids %s " %(persons, person_ids)
for person in persons:
records = self.fill_record_hrns(records)
return records
+
+
+
+ def AddSliceToNodes(self, slice_name, added_nodes, slice_user=None):
+ print>>sys.stderr, "\r\n \r\n AddSliceToNodes slice_name %s added_nodes %s username %s" %(slice_name,added_nodes,slice_user )
+ site_list = []
+ nodeid_list =[]
+ resource = ""
+ reqdict = {}
+ reqdict['property'] ="network_address in ("
+ for node in added_nodes:
+ #Get the ID of the node : remove the root auth and put the site in a separate list
+ tmp = node.strip(self.root_auth+".")
+ l = tmp.split("_")
+
+ nodeid= (l[len(l)-1])
+ reqdict['property'] += "'"+ nodeid +"', "
+ nodeid_list.append(nodeid)
+ site_list.append( l[0] )
+
+ reqdict['property'] = reqdict['property'][0: len( reqdict['property'])-2] +")"
+ reqdict['resource'] ="network_address="+ str(len(nodeid_list))
+ reqdict['resource']+= ",walltime=" + str(00) + ":" + str(05) + ":" + str(00)
+ reqdict['script_path'] = "/bin/sleep "
+
+ print>>sys.stderr, "\r\n \r\n AddSliceToNodes reqdict %s \r\n site_list %s" %(reqdict,site_list)
+ OAR = OARrestapi()
+ answer = OAR.POSTRequestToOARRestAPI('POST_job',reqdict,slice_user)
+ print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s " %(answer)
+ self.db.update('slice',['oar_job_id'], [answer['id']], 'slice_hrn', slice_name)
+ return
+
+
+
+ def DeleteSliceFromNodes(self, slice_name, deleted_nodes):
+ return
+
def fill_record_hrns(self, records):
"""
convert pl ids to hrns
sites = list_to_dict(site_list, 'site_id')
#print>>sys.stderr, " \r\n \r\n \t\t ____ site_list %s \r\n \t\t____ sites %s " % (site_list,sites)
if person_ids:
- person_list = self.users.GetPersons( person_ids, ['person_id', 'email'])
+ person_list = self.GetPersons( person_ids, ['person_id', 'email'])
#print>>sys.stderr, " \r\n \r\n \t\t____ person_lists %s " %(person_list)
persons = list_to_dict(person_list, 'person_id')
if slice_ids:
slice_list = self.users.GetSlices( slice_ids, ['slice_id', 'name'])
slices = list_to_dict(slice_list, 'slice_id')
if node_ids:
- node_list = self.oar.GetNodes( node_ids, ['node_id', 'hostname'])
+ node_list = self.GetNodes( node_ids, ['node_id', 'hostname'])
nodes = list_to_dict(node_list, 'node_id')
# convert ids to hrns
def startswith(prefix, values):
return [value for value in values if value.startswith(prefix)]
-
- SenslabUsers = SenslabImportUsers()
+
# get person ids
person_ids = []
site_ids = []
site_pis = {}
if site_ids:
pi_filter = {'|roles': ['pi'], '|site_ids': site_ids}
- pi_list = SenslabUsers.GetPersons( pi_filter, ['person_id', 'site_ids'])
+ pi_list = self.GetPersons( pi_filter, ['person_id', 'site_ids'])
#print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___ GetPersons ['person_id', 'site_ids'] pi_ilist %s" %(pi_list)
for pi in pi_list:
# get the pl records
pl_person_list, pl_persons = [], {}
- pl_person_list = SenslabUsers.GetPersons(person_ids, ['person_id', 'roles'])
+ pl_person_list = self.GetPersons(person_ids, ['person_id', 'roles'])
pl_persons = list_to_dict(pl_person_list, 'person_id')
#print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___ _list %s \r\n \t\t SenslabUsers.GetPersons ['person_id', 'roles'] pl_persons %s \r\n records %s" %(pl_person_list, pl_persons,records)
# fill sfa info
def fill_record_info(self, records):
"""
- Given a SFA record, fill in the PLC specific and SFA specific
+ Given a SFA record, fill in the senslab specific and SFA specific
fields in the record.
"""
- #print >>sys.stderr, "\r\n \t\t fill_record_info %s"%(records)
- if not isinstance(records, list):
- records = [records]
+ print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records)
+ if isinstance(records, list):
+ records = records[0]
#print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records)
- self.fill_record_pl_info(records)
- #print >>sys.stderr, "\r\n \t\t after fill_record_pl_info %s" %(records)
- self.fill_record_sfa_info(records)
+
+
+ if records['type'] == 'slice':
+
+ sfatable = SfaTable()
+ recslice = self.db.find('slice',str(records['hrn']))
+ if isinstance(recslice,list) and len(recslice) == 1:
+ recslice = recslice[0]
+ recuser = sfatable.find( recslice['record_id_user'], ['hrn'])
+
+ print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info %s" %(recuser)
+ records['type']
+ if isinstance(recuser,list) and len(recuser) == 1:
+ recuser = recuser[0]
+ records.update({'PI':[recuser['hrn']],
+ 'researcher': [recuser['hrn']],
+ 'name':records['hrn'], 'oar_job_id':recslice['oar_job_id'],
+
+ 'node_ids': [],
+ 'person_ids':[recslice['record_id_user']]})
+
+ #self.fill_record_pl_info(records)
+ ##print >>sys.stderr, "\r\n \t\t after fill_record_pl_info %s" %(records)
+ #self.fill_record_sfa_info(records)
#print >>sys.stderr, "\r\n \t\t after fill_record_sfa_info"
def update_membership_list(self, oldRecord, record, listName, addFunc, delFunc):
delFunc(self.plauth, personId, containerId)
def update_membership(self, oldRecord, record):
+ print >>sys.stderr, " \r\n \r\n ***SLABDRIVER.PY update_membership record ", record
if record.type == "slice":
self.update_membership_list(oldRecord, record, 'researcher',
self.users.AddPersonToSlice,
git://git.onelab.eu / sfa.git / blobdiff