sfa/senslab/OARrestapi.py

   1 # import modules used here -- sys is a very standard one
   2 import sys
   3 import httplib
   4 import json
   5 from sfa.senslab.parsing import *
   6 from sfa.senslab.SenslabImportUsers import *
   7 import urllib
   8 import urllib2
   9
  10
  11 #OARIP='10.127.255.254'
  12 OARIP='192.168.0.109'
  13
  14
  15 OARrequests_list = ["GET_version", "GET_timezone", "GET_jobs", "GET_jobs_table", "GET_jobs_details",
  16 "GET_resources_full", "GET_resources"]
  17
  18 OARrequests_uri_list = ['/oarapi/version.json','/oarapi/timezone.json', '/oarapi/jobs.json',
  19 '/oarapi/jobs/details.json', '/oarapi/resources/full.json', '/oarapi/resources.json']
  20
  21 OARrequests_get_uri_dict = { 'GET_version': '/oarapi/version.json',
  22                         'GET_timezone':'/oarapi/timezone.json' ,
  23                         'GET_jobs': '/oarapi/jobs.json',
  24                         'GET_jobs_table': '/oarapi/jobs/table.json',
  25                         'GET_jobs_details': '/oarapi/jobs/details.json',
  26                         'GET_resources_full': '/oarapi/resources/full.json',
  27                         'GET_resources':'/oarapi/resources.json',
  28 }
  29
  30 OARrequest_post_uri_dict = { 'POST_job': '/oarapi/jobs.json'}
  31
  32 POSTformat = {  #'yaml': {'content':"text/yaml", 'object':yaml}
  33 'json' : {'content':"application/json",'object':json},
  34 #'http': {'content':"applicaton/x-www-form-urlencoded",'object': html},
  35 }
  36
  37 class OARrestapi:
  38     def __init__(self):
  39         self.oarserver= {}
  40         self.oarserver['ip'] = OARIP
  41         self.oarserver['port'] = 80
  42         self.oarserver['uri'] = None
  43         self.oarserver['postformat'] = None
  44
  45     def GETRequestToOARRestAPI(self, request ):
  46         self.oarserver['uri'] = OARrequests_get_uri_dict[request]
  47         try :
  48             conn = httplib.HTTPConnection(self.oarserver['ip'],self.oarserver['port'])
  49             conn.request("GET",self.oarserver['uri'] )
  50             resp = ( conn.getresponse()).read()
  51             conn.close()
  52         except:
  53             raise ServerError("GET_OAR_SRVR : Could not reach OARserver")
  54         try:
  55             js = json.loads(resp)
  56             return js
  57
  58         except ValueError:
  59             raise ServerError("Failed to parse Server Response:" + js)
  60
  61
  62
  63     def POSTRequestToOARRestAPI(self, request,format, datadict):
  64         self.oarserver['uri'] = OARrequest_post_uri_dict[request]
  65         if format in POSTformat:
  66             if format is 'json':
  67                 data = json.dumps(datadict)
  68
  69             try :
  70                 conn = httplib.HTTPConnection(self.oarserver['ip'],self.oarserver['port'])
  71                 conn.putrequest("POST",self.oarserver['uri'] )
  72                 self.oarserver['postformat'] = POSTformat[format]
  73                 conn.putheader('content-type', self.oarserver['postformat']['content'])
  74                 conn.putheader('content-length', str(len(data)))
  75                 conn.endheaders()
  76                 conn.send(data)
  77                 resp = ( conn.getresponse()).read()
  78                 conn.close()
  79
  80             except:
  81                 raise ServerError("POST_OAR_SRVR : error")
  82
  83             try:
  84                 answer = self.oarserver['postformat']['object'].loads(resp)
  85                 return answer
  86
  87             except ValueError:
  88                 raise ServerError("Failed to parse Server Response:" + answer)
  89         else:
  90             print>>sys.stderr, "\r\n POSTRequestToOARRestAPI : ERROR_POST_FORMAT"
  91
  92
  93 class OARGETParser:
  94
  95     #Insert a new node into the dictnode dictionary
  96     def AddNodeId(self,dictnode,value):
  97         #Inserts new key. The value associated is a tuple list.
  98         node_id = int(value)
  99         dictnode[node_id] = [('node_id',node_id) ]
 100         return node_id
 101
 102     def AddNodeNetworkAddr(self,tuplelist,value):
 103         tuplelist.append(('hostname',str(value)))
 104
 105
 106     def AddNodeSite(self,tuplelist,value):
 107         tuplelist.append(('site_login_base',str(value)))
 108
 109     def AddNodeRadio(self,tuplelist,value):
 110         tuplelist.append(('radio',str(value)))
 111
 112
 113     def AddMobility(self,tuplelist,value):
 114         if value :
 115             tuplelist.append(('mobile',int(value)))
 116         return 0
 117
 118
 119     def AddPosX(self,tuplelist,value):
 120         tuplelist.append(('posx',value))
 121
 122
 123     def AddPosY(self,tuplelist,value):
 124         tuplelist.append(('posy',value))
 125
 126     def AddBootState(self,tuplelist,value):
 127         tuplelist.append(('boot_state',str(value)))
 128
 129     def ParseVersion(self) :
 130         #print self.raw_json
 131         #print >>sys.stderr, self.raw_json
 132         if 'oar_version' in self.raw_json :
 133             self.version_json_dict.update(api_version=self.raw_json['api_version'] ,
 134                             apilib_version=self.raw_json['apilib_version'],
 135                             api_timezone=self.raw_json['api_timezone'],
 136                             api_timestamp=self.raw_json['api_timestamp'],
 137                             oar_version=self.raw_json['oar_version'] )
 138         else :
 139             self.version_json_dict.update(api_version=self.raw_json['api'] ,
 140                             apilib_version=self.raw_json['apilib'],
 141                             api_timezone=self.raw_json['api_timezone'],
 142                             api_timestamp=self.raw_json['api_timestamp'],
 143                             oar_version=self.raw_json['oar'] )
 144
 145         print self.version_json_dict['apilib_version']
 146
 147
 148     def ParseTimezone(self) :
 149         print " ParseTimezone"
 150
 151     def ParseJobs(self) :
 152         self.jobs_list = []
 153         print " ParseJobs "
 154
 155     def ParseJobsTable(self) :
 156         print "ParseJobsTable"
 157
 158     def ParseJobsDetails (self):
 159         print "ParseJobsDetails"
 160
 161     def ParseResources(self) :
 162         print>>sys.stderr, " \r\n  \t\t\t ParseResources__________________________ "
 163         #resources are listed inside the 'items' list from the json
 164         self.raw_json = self.raw_json['items']
 165         self.ParseNodes()
 166
 167
 168
 169
 170     def ParseResourcesFull(self ) :
 171         print>>sys.stderr, " \r\n \t\t\t  ParseResourcesFull_____________________________ "
 172         #print self.raw_json[1]
 173         #resources are listed inside the 'items' list from the json
 174         if self.version_json_dict['apilib_version'] != "0.2.10" :
 175                 self.raw_json = self.raw_json['items']
 176         self.ParseNodes()
 177         self.ParseSites()
 178
 179
 180
 181     #Parse nodes properties from OAR
 182     #Put them into a dictionary with key = node id and value is a dictionary
 183     #of the node properties and properties'values.
 184     def ParseNodes(self):
 185         node_id = None
 186         for dictline in self.raw_json:
 187             for k in dictline.keys():
 188                 if k in self.resources_fulljson_dict:
 189                     # dictionary is empty and/or a new node has to be inserted
 190                     if node_id is None :
 191                         node_id = self.resources_fulljson_dict[k](self,self.node_dictlist, dictline[k])
 192                     else:
 193                         ret = self.resources_fulljson_dict[k](self,self.node_dictlist[node_id], dictline[k])
 194                         #If last property has been inserted in the property tuple list, reset node_id
 195                         if ret == 0:
 196                             #Turn the property tuple list (=dict value) into a dictionary
 197                             self.node_dictlist[node_id] = dict(self.node_dictlist[node_id])
 198                             node_id = None
 199
 200                 else:
 201                     pass
 202
 203     #Retourne liste de dictionnaires contenant attributs des sites
 204     def ParseSites(self):
 205         nodes_per_site = {}
 206
 207         # Create a list of nodes per  site_id
 208         for node_id in self.node_dictlist.keys():
 209             node  = self.node_dictlist[node_id]
 210             if node['site_login_base'] not in nodes_per_site.keys():
 211                 nodes_per_site[node['site_login_base']] = []
 212                 nodes_per_site[node['site_login_base']].append(node['node_id'])
 213             else:
 214                 if node['node_id'] not in nodes_per_site[node['site_login_base']]:
 215                     nodes_per_site[node['site_login_base']].append(node['node_id'])
 216         #Create a site dictionary with key is site_login_base (name of the site)
 217         # and value is a dictionary of properties, including the list of the node_ids
 218         for node_id in self.node_dictlist.keys():
 219             node  = self.node_dictlist[node_id]
 220             if node['site_login_base'] not in self.site_dict.keys():
 221                 self.site_dict[node['site_login_base']] = [('login_base', node['site_login_base']),\
 222                                                         ('node_ids',nodes_per_site[node['site_login_base']]),\
 223                                                         ('latitude',"48.83726"),\
 224                                                         ('longitude',"- 2.10336"),('name',"senslab"),\
 225                                                         ('pcu_ids', []), ('max_slices', None), ('ext_consortium_id', None),\
 226                                                         ('max_slivers', None), ('is_public', True), ('peer_site_id', None),\
 227                                                         ('abbreviated_name', "senslab"), ('address_ids', []),\
 228                                                         ('url', "http,//www.senslab.info"), ('person_ids', []),\
 229                                                         ('site_tag_ids', []), ('enabled', True),  ('slice_ids', []),\
 230                                                         ('date_created', None), ('peer_id', None),]
 231                 self.site_dict[node['site_login_base']] = dict(self.site_dict[node['site_login_base']])
 232
 233         #print>>sys.stderr, "\r\n \r\n =============\t\t ParseSites site dict %s \r\n"%(self.site_dict)
 234
 235
 236     def GetNodesFromOARParse(self):
 237         #print>>sys.stderr, " \r\n =========GetNodesFromOARParse: node_dictlist %s "%(self.node_dictlist)
 238         return self.node_dictlist
 239
 240     def GetSitesFromOARParse(self):
 241         return self.site_dict
 242
 243     def GetJobsFromOARParse(self):
 244         return self.jobs_list
 245
 246     OARrequests_uri_dict = {
 247         'GET_version': {'uri':'/oarapi/version.json', 'parse_func': ParseVersion},
 248         'GET_timezone':{'uri':'/oarapi/timezone.json' ,'parse_func': ParseTimezone },
 249         'GET_jobs': {'uri':'/oarapi/jobs.json','parse_func': ParseJobs},
 250         'GET_jobs_table': {'uri':'/oarapi/jobs/table.json','parse_func': ParseJobsTable},
 251         'GET_jobs_details': {'uri':'/oarapi/jobs/details.json','parse_func': ParseJobsDetails},
 252         'GET_resources_full': {'uri':'/oarapi/resources/full.json','parse_func': ParseResourcesFull},
 253         'GET_resources':{'uri':'/oarapi/resources.json' ,'parse_func': ParseResources},
 254         }
 255     resources_fulljson_dict= {
 256         'resource_id' : AddNodeId,
 257         'network_address' : AddNodeNetworkAddr,
 258         'site': AddNodeSite,
 259         'radio': AddNodeRadio,
 260         'mobile': AddMobility,
 261         'posx': AddPosX,
 262         'posy': AddPosY,
 263         'state':AddBootState,
 264         }
 265
 266
 267     def __init__(self, srv ):
 268         self.version_json_dict= { 'api_version' : None , 'apilib_version' :None,  'api_timezone': None, 'api_timestamp': None, 'oar_version': None ,}
 269         self.timezone_json_dict = { 'timezone': None, 'api_timestamp': None, }
 270         self.jobs_json_dict = { 'total' : None, 'links' : [] , 'offset':None , 'items' : [] , }
 271         self.jobs_table_json_dict = self.jobs_json_dict
 272         self.jobs_details_json_dict = self.jobs_json_dict
 273         self.server = srv
 274         self.node_dictlist = {}
 275         self.site_dict = {}
 276         self.SendRequest("GET_version")
 277
 278     def SendRequest(self,request):
 279         if request in OARrequests_get_uri_dict:
 280             self.raw_json = self.server.GETRequestToOARRestAPI(request)
 281             self.OARrequests_uri_dict[request]['parse_func'](self)
 282         else:
 283             print>>sys.stderr, "\r\n OARGetParse __init__ : ERROR_REQUEST "     ,request
 284
 285 class OARapi:
 286
 287     def __init__(self):
 288             self.server = OARrestapi()
 289             self.parser = OARGETParser(self.server)
 290
 291         #GetNodes moved to slabdriver.py
 292
 293     def GetSites(self, site_filter= None, return_fields=None):
 294         print>>sys.stderr, " \r\n GetSites+++++++++++++++++"
 295         self.parser.SendRequest("GET_resources_full")
 296         site_dict = self.parser.GetSitesFromOARParse()
 297         return_site_list = []
 298         site = site_dict.values()[0]
 299         Users = SenslabImportUsers()
 300
 301         #print>>sys.stderr, " \r\n  GetSites sites_dict %s site_filter %s  \r\n \r\n  \r\n \r\n------site %s" %(site_dict,site_filter,site )
 302         admins_dict ={'person_ids': Users.GetPIs(site['site_id'])}
 303         site.update(admins_dict)
 304
 305         slice_list = Users.GetSlices()
 306         for sl in slice_list:
 307                 #print>>sys.stderr, " \r\n  GetSites sl %s" %(sl)
 308                 if sl['site_id'] == site['site_id']:
 309                         site['slice_ids'].append(sl['slice_id'])
 310
 311         if not (site_filter or return_fields):
 312                 return_site_list = site_dict.values()
 313                 return return_site_list
 314
 315         return_site_list = parse_filter(site_dict.values(),site_filter ,'site', return_fields)
 316         return return_site_list
 317
 318
 319     def GetJobs(self):
 320         print>>sys.stderr, " \r\n GetJobs"
 321         self.parser.SendRequest("GET_jobs")
 322         return self.parser.GetJobsFromOARParse()
 323