Handle slice table update upon creation of a job.
[sfa.git] / sfa / senslab / slabdriver.py
index d24aec3..47788c5 100644 (file)
@@ -1,3 +1,5 @@
+import sys
+
 from sfa.util.faults import MissingSfaInfo
 from sfa.util.sfalogging import logger
 from sfa.util.table import SfaTable
@@ -11,8 +13,11 @@ from sfa.util.plxrn import slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicenam
 # 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):
     """
@@ -44,22 +49,33 @@ class SlabDriver ():
        #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
@@ -67,6 +83,32 @@ class SlabDriver ():
         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
@@ -149,7 +191,7 @@ class SlabDriver ():
         # 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:
@@ -161,7 +203,7 @@ class SlabDriver ():
             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:
@@ -202,7 +244,44 @@ class SlabDriver ():
         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
@@ -230,14 +309,14 @@ class SlabDriver ():
             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
@@ -286,8 +365,7 @@ class SlabDriver ():
 
         def startswith(prefix, values):
             return [value for value in values if value.startswith(prefix)]
-       
-       SenslabUsers = SenslabImportUsers()
+
         # get person ids
         person_ids = []
         site_ids = []
@@ -304,7 +382,7 @@ class SlabDriver ():
         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:
@@ -336,7 +414,7 @@ class SlabDriver ():
 
         # 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
@@ -400,16 +478,37 @@ class SlabDriver ():
 
     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):
@@ -453,6 +552,7 @@ class SlabDriver ():
                 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,