sfa/iotlab/OARrestapi.py

   1 """
   2 File used to handle issuing request to OAR and parse OAR's JSON responses.
   3 Contains the following classes:
   4 - JsonPage : handles multiple pages OAR answers.
   5 - OARRestapi : handles issuing POST or GET requests to OAR.
   6 - ParsingResourcesFull : dedicated to parsing OAR's answer to a get resources
   7 full request.
   8 - OARGETParser : handles parsing the Json answers to different GET requests.
   9
  10 """
  11 from httplib import HTTPConnection, HTTPException, NotConnected
  12 import json
  13 from sfa.util.config import Config
  14 from sfa.util.sfalogging import logger
  15 import os.path
  16
  17
  18 class JsonPage:
  19
  20     """Class used to manipulate json pages given by OAR.
  21
  22     In case the json answer from a GET request is too big to fit in one json
  23     page, this class provides helper methods to retrieve all the pages and
  24     store them in a list before putting them into one single json dictionary,
  25     facilitating the parsing.
  26
  27     """
  28
  29     def __init__(self):
  30         """Defines attributes to manipulate and parse the json pages.
  31
  32         """
  33         #All are boolean variables
  34         self.concatenate = False
  35         #Indicates end of data, no more pages to be loaded.
  36         self.end = False
  37         self.next_page = False
  38         #Next query address
  39         self.next_offset = None
  40         #Json page
  41         self.raw_json = None
  42
  43     def FindNextPage(self):
  44         """
  45         Gets next data page from OAR when the query's results are too big to
  46         be transmitted in a single page. Uses the "links' item in the json
  47         returned to check if an additionnal page has to be loaded. Updates
  48         object attributes next_page, next_offset, and end.
  49
  50         """
  51         if "links" in self.raw_json:
  52             for page in self.raw_json['links']:
  53                 if page['rel'] == 'next':
  54                     self.concatenate = True
  55                     self.next_page = True
  56                     self.next_offset = "?" + page['href'].split("?")[1]
  57                     return
  58
  59         if self.concatenate:
  60             self.end = True
  61             self.next_page = False
  62             self.next_offset = None
  63
  64             return
  65
  66         #Otherwise, no next page and no concatenate, must be a single page
  67         #Concatenate the single page and get out of here.
  68         else:
  69             self.next_page = False
  70             self.concatenate = True
  71             self.next_offset = None
  72             return
  73
  74     @staticmethod
  75     def ConcatenateJsonPages(saved_json_list):
  76         """
  77         If the json answer is too big to be contained in a single page,
  78         all the pages have to be loaded and saved before being appended to the
  79         first page.
  80
  81         :param saved_json_list: list of all the stored pages, including the
  82             first page.
  83         :type saved_json_list: list
  84         :returns: Returns a dictionary with all the pages saved in the
  85             saved_json_list. The key of the dictionary is 'items'.
  86         :rtype: dict
  87
  88
  89         .. seealso:: SendRequest
  90         .. warning:: Assumes the apilib is 0.2.10 (with the 'items' key in the
  91             raw json dictionary)
  92
  93         """
  94         #reset items list
  95
  96         tmp = {}
  97         tmp['items'] = []
  98
  99         for page in saved_json_list:
 100             tmp['items'].extend(page['items'])
 101         return tmp
 102
 103     def ResetNextPage(self):
 104         """
 105         Resets all the Json page attributes (next_page, next_offset,
 106         concatenate, end). Has to be done before getting another json answer
 107         so that the previous page status does not affect the new json load.
 108
 109         """
 110         self.next_page = True
 111         self.next_offset = None
 112         self.concatenate = False
 113         self.end = False
 114
 115
 116 class OARrestapi:
 117     """Class used to connect to the OAR server and to send GET and POST
 118     requests.
 119
 120     """
 121
 122     # classes attributes
 123
 124     OAR_REQUEST_POST_URI_DICT = {'POST_job': {'uri': '/oarapi/jobs.json'},
 125                                  'DELETE_jobs_id':
 126                                  {'uri': '/oarapi/jobs/id.json'},
 127                                  }
 128
 129     POST_FORMAT = {'json': {'content': "application/json", 'object': json}}
 130
 131     #OARpostdatareqfields = {'resource' :"/nodes=", 'command':"sleep", \
 132                             #'workdir':"/home/", 'walltime':""}
 133
 134     def __init__(self, config_file='/etc/sfa/oar_config.py'):
 135         self.oarserver = {}
 136         self.oarserver['uri'] = None
 137         self.oarserver['postformat'] = 'json'
 138
 139         try:
 140             execfile(config_file, self.__dict__)
 141
 142             self.config_file = config_file
 143             # path to configuration data
 144             self.config_path = os.path.dirname(config_file)
 145
 146         except IOError:
 147             raise IOError, "Could not find or load the configuration file: %s" \
 148                 % config_file
 149         #logger.setLevelDebug()
 150         self.oarserver['ip'] = self.OAR_IP
 151         self.oarserver['port'] = self.OAR_PORT
 152         self.jobstates = ['Terminated', 'Hold', 'Waiting', 'toLaunch',
 153                           'toError', 'toAckReservation', 'Launching',
 154                           'Finishing', 'Running', 'Suspended', 'Resuming',
 155                           'Error']
 156
 157         self.parser = OARGETParser(self)
 158
 159
 160     def GETRequestToOARRestAPI(self, request, strval=None,
 161                                next_page=None, username=None):
 162
 163         """Makes a GET request to OAR.
 164
 165         Fetch the uri associated with the resquest stored in
 166         OARrequests_uri_dict, adds the username if needed and if available, adds
 167         strval to the request uri if needed, connects to OAR and issues the GET
 168         request. Gets the json reply.
 169
 170         :param request: One of the known get requests that are keys in the
 171             OARrequests_uri_dict.
 172         :param strval: used when a job id has to be specified.
 173         :param next_page: used to tell OAR to send the next page for this
 174             Get request. Is appended to the GET uri.
 175         :param username: used when a username has to be specified, when looking
 176             for jobs scheduled by a particular user  for instance.
 177
 178         :type request: string
 179         :type strval: integer
 180         :type next_page: boolean
 181         :type username: string
 182         :returns: a json dictionary if OAR successfully processed the GET
 183             request.
 184
 185         .. seealso:: OARrequests_uri_dict
 186         """
 187         self.oarserver['uri'] = \
 188             OARGETParser.OARrequests_uri_dict[request]['uri']
 189         #Get job details with username
 190         if 'owner' in OARGETParser.OARrequests_uri_dict[request] and username:
 191             self.oarserver['uri'] += \
 192                 OARGETParser.OARrequests_uri_dict[request]['owner'] + username
 193         headers = {}
 194         data = json.dumps({})
 195         logger.debug("OARrestapi \tGETRequestToOARRestAPI %s" % (request))
 196         if strval:
 197             self.oarserver['uri'] = self.oarserver['uri'].\
 198                 replace("id", str(strval))
 199
 200         if next_page:
 201             self.oarserver['uri'] += next_page
 202
 203         if username:
 204             headers['X-REMOTE_IDENT'] = username
 205
 206         logger.debug("OARrestapi: \t  GETRequestToOARRestAPI  \
 207                         self.oarserver['uri'] %s strval %s"
 208                      % (self.oarserver['uri'], strval))
 209         try:
 210             #seems that it does not work if we don't add this
 211             headers['content-length'] = '0'
 212
 213             conn = HTTPConnection(self.oarserver['ip'],
 214                                   self.oarserver['port'])
 215             conn.request("GET", self.oarserver['uri'], data, headers)
 216             resp = (conn.getresponse()).read()
 217             conn.close()
 218
 219         except HTTPException, error:
 220             logger.log_exc("GET_OAR_SRVR : Problem with OAR server : %s "
 221                            % (error))
 222             #raise ServerError("GET_OAR_SRVR : Could not reach OARserver")
 223         try:
 224             js_dict = json.loads(resp)
 225             #print "\r\n \t\t\t js_dict keys" , js_dict.keys(), " \r\n", js_dict
 226             return js_dict
 227
 228         except ValueError, error:
 229             logger.log_exc("Failed to parse Server Response: %s ERROR %s"
 230                            % (js_dict, error))
 231             #raise ServerError("Failed to parse Server Response:" + js)
 232
 233
 234     def POSTRequestToOARRestAPI(self, request, datadict, username=None):
 235         """ Used to post a job on OAR , along with data associated
 236         with the job.
 237
 238         """
 239
 240         #first check that all params for are OK
 241         try:
 242             self.oarserver['uri'] = \
 243                 self.OAR_REQUEST_POST_URI_DICT[request]['uri']
 244
 245         except KeyError:
 246             logger.log_exc("OARrestapi \tPOSTRequestToOARRestAPI request not \
 247                              valid")
 248             return
 249         if datadict and 'strval' in datadict:
 250             self.oarserver['uri'] = self.oarserver['uri'].replace("id", \
 251                                                 str(datadict['strval']))
 252             del datadict['strval']
 253
 254         data = json.dumps(datadict)
 255         headers = {'X-REMOTE_IDENT':username, \
 256                 'content-type': self.POST_FORMAT['json']['content'], \
 257                 'content-length':str(len(data))}
 258         try :
 259
 260             conn = HTTPConnection(self.oarserver['ip'], \
 261                                         self.oarserver['port'])
 262             conn.request("POST", self.oarserver['uri'], data, headers)
 263             resp = (conn.getresponse()).read()
 264             conn.close()
 265         except NotConnected:
 266             logger.log_exc("POSTRequestToOARRestAPI NotConnected ERROR: \
 267                             data %s \r\n \t\n \t\t headers %s uri %s" \
 268                             %(data,headers,self.oarserver['uri']))
 269
 270             #raise ServerError("POST_OAR_SRVR : error")
 271
 272         try:
 273             answer = json.loads(resp)
 274             logger.debug("POSTRequestToOARRestAPI : answer %s" % (answer))
 275             return answer
 276
 277         except ValueError, error:
 278             logger.log_exc("Failed to parse Server Response: error %s  \
 279                             %s" %(error))
 280             #raise ServerError("Failed to parse Server Response:" + answer)
 281
 282
 283 class ParsingResourcesFull():
 284     """
 285     Class dedicated to parse the json response from a GET_resources_full from
 286     OAR.
 287
 288     """
 289     def __init__(self):
 290         """
 291         Set the parsing dictionary. Works like a switch case, if the key is
 292         found in the dictionary, then the associated function is called.
 293         This is used in ParseNodes to create an usable dictionary from
 294         the Json returned by OAR when issuing a GET resources full request.
 295
 296         .. seealso:: ParseNodes
 297
 298         """
 299         self.resources_fulljson_dict = {
 300         'network_address': self.AddNodeNetworkAddr,
 301         'site':  self.AddNodeSite,
 302         # 'radio':  self.AddNodeRadio,
 303         'mobile':  self.AddMobility,
 304         'x':  self.AddPosX,
 305         'y':  self.AddPosY,
 306         'z': self.AddPosZ,
 307         'archi': self.AddHardwareType,
 308         'state': self.AddBootState,
 309         'id': self.AddOarNodeId,
 310         'mobility_type': self.AddMobilityType,
 311         }
 312
 313
 314
 315     def AddOarNodeId(self, tuplelist, value):
 316         """Adds Oar internal node id to the nodes' attributes.
 317
 318         Appends tuple ('oar_id', node_id) to the tuplelist. Used by ParseNodes.
 319
 320         .. seealso:: ParseNodes
 321
 322         """
 323
 324         tuplelist.append(('oar_id', int(value)))
 325
 326
 327     def AddNodeNetworkAddr(self, dictnode, value):
 328         """First parsing function to be called to parse the json returned by OAR
 329         answering a GET_resources (/oarapi/resources.json) request.
 330
 331         When a new node is found in the json, this function is responsible for
 332         creating a new entry in the dictionary for storing information on this
 333         specific node. The key is the node network address, which is also the
 334         node's hostname.
 335         The value associated with the key is a tuple list.It contains all
 336         the nodes attributes. The tuplelist will later be turned into a dict.
 337
 338         :param dictnode: should be set to the OARGETParser atribute
 339             node_dictlist. It will store the information on the nodes.
 340         :param value: the node_id is the network_address in the raw json.
 341         :type value: string
 342         :type dictnode: dictionary
 343
 344         .. seealso: ParseResources, ParseNodes
 345         """
 346
 347         node_id = value
 348         dictnode[node_id] = [('node_id', node_id),('hostname', node_id) ]
 349
 350         return node_id
 351
 352     def AddNodeSite(self, tuplelist, value):
 353         """Add the site's node to the dictionary.
 354
 355
 356         :param tuplelist: tuple list on which to add the node's site.
 357             Contains the other node attributes as well.
 358         :param value: value to add to the tuple list, in this case the node's
 359             site.
 360         :type tuplelist: list
 361         :type value: string
 362
 363         .. seealso:: AddNodeNetworkAddr
 364
 365         """
 366         tuplelist.append(('site', str(value)))
 367
 368     # def AddNodeRadio(tuplelist, value):
 369     #     """Add thenode's radio chipset type to the tuple list.
 370
 371     #     :param tuplelist: tuple list on which to add the node's mobility
 372                 # status. The tuplelist is the value associated with the node's
 373                 # id in the OARGETParser
 374     #          's dictionary node_dictlist.
 375     #     :param value: name of the radio chipset on the node.
 376     #     :type tuplelist: list
 377     #     :type value: string
 378
 379     #     .. seealso:: AddNodeNetworkAddr
 380
 381     #     """
 382     #     tuplelist.append(('radio', str(value)))
 383
 384     def AddMobilityType(self, tuplelist, value):
 385         """Adds  which kind of mobility it is, train or roomba robot.
 386
 387         :param tuplelist: tuple list on which to add the node's mobility status.
 388             The tuplelist is the value associated with the node's id in the
 389             OARGETParser's dictionary node_dictlist.
 390         :param value: tells if a node is a mobile node or not. The value is
 391             found in the json.
 392
 393         :type tuplelist: list
 394         :type value: integer
 395
 396         """
 397         tuplelist.append(('mobility_type', str(value)))
 398
 399
 400     def AddMobility(self, tuplelist, value):
 401         """Add if the node is a mobile node or not to the tuple list.
 402
 403         :param tuplelist: tuple list on which to add the node's mobility status.
 404             The tuplelist is the value associated with the node's id in the
 405             OARGETParser's dictionary node_dictlist.
 406         :param value: tells if a node is a mobile node or not. The value is
 407             found in the json.
 408
 409         :type tuplelist: list
 410         :type value: integer
 411
 412         .. seealso:: AddNodeNetworkAddr
 413
 414         """
 415         # future support of mobility type
 416
 417         if value is 0:
 418             tuplelist.append(('mobile', 'False'))
 419         else:
 420             tuplelist.append(('mobile', 'True'))
 421
 422
 423     def AddPosX(self, tuplelist, value):
 424         """Add the node's position on the x axis.
 425
 426         :param tuplelist: tuple list on which to add the node's position . The
 427             tuplelist is the value associated with the node's id in the
 428             OARGETParser's dictionary node_dictlist.
 429         :param value: the position x.
 430
 431         :type tuplelist: list
 432         :type value: integer
 433
 434          .. seealso:: AddNodeNetworkAddr
 435
 436         """
 437         tuplelist.append(('posx', value))
 438
 439
 440
 441     def AddPosY(self, tuplelist, value):
 442         """Add the node's position on the y axis.
 443
 444         :param tuplelist: tuple list on which to add the node's position . The
 445             tuplelist is the value associated with the node's id in the
 446             OARGETParser's dictionary node_dictlist.
 447         :param value: the position y.
 448
 449         :type tuplelist: list
 450         :type value: integer
 451
 452          .. seealso:: AddNodeNetworkAddr
 453
 454         """
 455         tuplelist.append(('posy', value))
 456
 457
 458
 459     def AddPosZ(self, tuplelist, value):
 460         """Add the node's position on the z axis.
 461
 462         :param tuplelist: tuple list on which to add the node's position . The
 463             tuplelist is the value associated with the node's id in the
 464             OARGETParser's dictionary node_dictlist.
 465         :param value: the position z.
 466
 467         :type tuplelist: list
 468         :type value: integer
 469
 470          .. seealso:: AddNodeNetworkAddr
 471
 472         """
 473
 474         tuplelist.append(('posz', value))
 475
 476
 477
 478     def AddBootState(tself, tuplelist, value):
 479         """Add the node's state, Alive or Suspected.
 480
 481         :param tuplelist: tuple list on which to add the node's state . The
 482             tuplelist is the value associated with the node's id in the
 483             OARGETParser 's dictionary node_dictlist.
 484         :param value: node's state.
 485
 486         :type tuplelist: list
 487         :type value: string
 488
 489          .. seealso:: AddNodeNetworkAddr
 490
 491         """
 492         tuplelist.append(('boot_state', str(value)))
 493
 494
 495     def AddHardwareType(self, tuplelist, value):
 496         """Add the node's hardware model and radio chipset type to the tuple
 497         list.
 498
 499         :param tuplelist: tuple list on which to add the node's architecture
 500             and radio chipset type.
 501         :param value: hardware type: radio chipset. The value contains both the
 502             architecture and the radio chipset, separated by a colon.
 503         :type tuplelist: list
 504         :type value: string
 505
 506         .. seealso:: AddNodeNetworkAddr
 507
 508         """
 509
 510         value_list = value.split(':')
 511         tuplelist.append(('archi', value_list[0]))
 512         tuplelist.append(('radio', value_list[1]))
 513
 514
 515 class OARGETParser:
 516     """Class providing parsing methods associated to specific GET requests.
 517
 518     """
 519
 520     def __init__(self, srv):
 521         self.version_json_dict = {
 522             'api_version': None, 'apilib_version': None,
 523             'api_timezone': None, 'api_timestamp': None, 'oar_version': None}
 524         self.config = Config()
 525         self.interface_hrn = self.config.SFA_INTERFACE_HRN
 526         self.timezone_json_dict = {
 527             'timezone': None, 'api_timestamp': None, }
 528         #self.jobs_json_dict = {
 529             #'total' : None, 'links' : [],\
 530             #'offset':None , 'items' : [], }
 531         #self.jobs_table_json_dict = self.jobs_json_dict
 532         #self.jobs_details_json_dict = self.jobs_json_dict
 533         self.server = srv
 534         self.node_dictlist = {}
 535
 536         self.json_page = JsonPage()
 537         self.parsing_resourcesfull = ParsingResourcesFull()
 538         self.site_dict = {}
 539         self.jobs_list = []
 540         self.SendRequest("GET_version")
 541
 542
 543     def ParseVersion(self):
 544         """Parses the OAR answer to the GET_version ( /oarapi/version.json.)
 545
 546         Finds the OAR apilib version currently used. Has an impact on the json
 547         structure returned by OAR, so the version has to be known before trying
 548         to parse the jsons returned after a get request has been issued.
 549         Updates the attribute version_json_dict.
 550
 551         """
 552
 553         if 'oar_version' in self.json_page.raw_json:
 554             self.version_json_dict.update(
 555                 api_version=self.json_page.raw_json['api_version'],
 556                 apilib_version=self.json_page.raw_json['apilib_version'],
 557                 api_timezone=self.json_page.raw_json['api_timezone'],
 558                 api_timestamp=self.json_page.raw_json['api_timestamp'],
 559                 oar_version=self.json_page.raw_json['oar_version'])
 560         else:
 561             self.version_json_dict.update(
 562                 api_version=self.json_page.raw_json['api'],
 563                 apilib_version=self.json_page.raw_json['apilib'],
 564                 api_timezone=self.json_page.raw_json['api_timezone'],
 565                 api_timestamp=self.json_page.raw_json['api_timestamp'],
 566                 oar_version=self.json_page.raw_json['oar'])
 567
 568         print self.version_json_dict['apilib_version']
 569
 570
 571     def ParseTimezone(self):
 572         """Get the timezone used by OAR.
 573
 574         Get the timezone from the answer to the GET_timezone request.
 575         :return: api_timestamp and api timezone.
 576         :rype: integer, integer
 577
 578         .. warning:: unused.
 579         """
 580         api_timestamp = self.json_page.raw_json['api_timestamp']
 581         api_tz = self.json_page.raw_json['timezone']
 582         return api_timestamp, api_tz
 583
 584     def ParseJobs(self):
 585         """Called when a GET_jobs request has been issued to OAR.
 586
 587         Corresponds to /oarapi/jobs.json uri. Currently returns the raw json
 588         information dict.
 589         :returns: json_page.raw_json
 590         :rtype: dictionary
 591
 592         .. warning:: Does not actually parse the information in the json. SA
 593             15/07/13.
 594
 595         """
 596         self.jobs_list = []
 597         print " ParseJobs "
 598         return self.json_page.raw_json
 599
 600     def ParseJobsTable(self):
 601         """In case we need to use the job table in the future.
 602
 603         Associated with the GET_jobs_table : '/oarapi/jobs/table.json uri.
 604         .. warning:: NOT USED. DOES NOTHING.
 605         """
 606         print "ParseJobsTable"
 607
 608     def ParseJobsDetails(self):
 609         """Currently only returns the same json in self.json_page.raw_json.
 610
 611         .. todo:: actually parse the json
 612         .. warning:: currently, this function is not used a lot, so I have no
 613             idea what could  be useful to parse, returning the full json. NT
 614         """
 615
 616         #logger.debug("ParseJobsDetails %s " %(self.json_page.raw_json))
 617         return self.json_page.raw_json
 618
 619
 620     def ParseJobsIds(self):
 621         """Associated with the GET_jobs_id OAR request.
 622
 623         Parses the json dict (OAR answer) to the GET_jobs_id request
 624         /oarapi/jobs/id.json.
 625
 626
 627         :returns: dictionary whose keys are listed in the local variable
 628             job_resources and values that are in the json dictionary returned
 629             by OAR with the job information.
 630         :rtype: dict
 631
 632         """
 633         job_resources = ['wanted_resources', 'name', 'id', 'start_time',
 634                          'state', 'owner', 'walltime', 'message']
 635
 636         # Unused variable providing the contents of the json dict returned from
 637         # get job resources full request
 638         job_resources_full = [
 639             'launching_directory', 'links',
 640             'resubmit_job_id', 'owner', 'events', 'message',
 641             'scheduled_start', 'id', 'array_id', 'exit_code',
 642             'properties', 'state', 'array_index', 'walltime',
 643             'type', 'initial_request', 'stop_time', 'project',
 644             'start_time',  'dependencies', 'api_timestamp', 'submission_time',
 645             'reservation', 'stdout_file', 'types', 'cpuset_name',
 646             'name', 'wanted_resources', 'queue', 'stderr_file', 'command']
 647
 648
 649         job_info = self.json_page.raw_json
 650         #logger.debug("OARESTAPI ParseJobsIds %s" %(self.json_page.raw_json))
 651         values = []
 652         try:
 653             for k in job_resources:
 654                 values.append(job_info[k])
 655             return dict(zip(job_resources, values))
 656
 657         except KeyError:
 658             logger.log_exc("ParseJobsIds KeyError ")
 659
 660
 661     def ParseJobsIdResources(self):
 662         """ Parses the json produced by the request
 663         /oarapi/jobs/id/resources.json.
 664         Returns a list of oar node ids that are scheduled for the
 665         given job id.
 666
 667         """
 668         job_resources = []
 669         for resource in self.json_page.raw_json['items']:
 670             job_resources.append(resource['id'])
 671
 672         return job_resources
 673
 674     def ParseResources(self):
 675         """ Parses the json produced by a get_resources request on oar."""
 676
 677         #logger.debug("OARESTAPI \tParseResources " )
 678         #resources are listed inside the 'items' list from the json
 679         self.json_page.raw_json = self.json_page.raw_json['items']
 680         self.ParseNodes()
 681
 682     def ParseReservedNodes(self):
 683         """  Returns an array containing the list of the jobs scheduled
 684         with the reserved nodes if available.
 685
 686         :returns: list of job dicts, each dict containing the following keys:
 687             t_from, t_until, resources_ids (of the reserved nodes for this job).
 688             If the information is not available, default values will be set for
 689             these keys. The other keys are : state, lease_id and user.
 690         :rtype: list
 691
 692         """
 693
 694         #resources are listed inside the 'items' list from the json
 695         reservation_list = []
 696         job = {}
 697         #Parse resources info
 698         for json_element in self.json_page.raw_json['items']:
 699             #In case it is a real reservation (not asap case)
 700             if json_element['scheduled_start']:
 701                 job['t_from'] = json_element['scheduled_start']
 702                 job['t_until'] = int(json_element['scheduled_start']) + \
 703                     int(json_element['walltime'])
 704                 #Get resources id list for the job
 705                 job['resource_ids'] = [node_dict['id'] for node_dict
 706                                        in json_element['resources']]
 707             else:
 708                 job['t_from'] = "As soon as possible"
 709                 job['t_until'] = "As soon as possible"
 710                 job['resource_ids'] = ["Undefined"]
 711
 712             job['state'] = json_element['state']
 713             job['lease_id'] = json_element['id']
 714
 715             job['user'] = json_element['owner']
 716             #logger.debug("OARRestapi \tParseReservedNodes job %s" %(job))
 717             reservation_list.append(job)
 718             #reset dict
 719             job = {}
 720         return reservation_list
 721
 722     def ParseRunningJobs(self):
 723         """ Gets the list of nodes currently in use from the attributes of the
 724         running jobs.
 725
 726         :returns: list of hostnames, the nodes that are currently involved in
 727             running jobs.
 728         :rtype: list
 729
 730
 731         """
 732         logger.debug("OARESTAPI \tParseRunningJobs_________________ ")
 733         #resources are listed inside the 'items' list from the json
 734         nodes = []
 735         for job in self.json_page.raw_json['items']:
 736             for node in job['nodes']:
 737                 nodes.append(node['network_address'])
 738         return nodes
 739
 740     def ChangeRawJsonDependingOnApilibVersion(self):
 741         """
 742         Check if the OAR apilib version is different from 0.2.10, in which case
 743         the Json answer is also dict instead as a plain list.
 744
 745         .. warning:: the whole code is assuming the json contains a 'items' key
 746         .. seealso:: ConcatenateJsonPages, ParseJobs, ParseReservedNodes,
 747             ParseJobsIdResources, ParseResources, ParseRunningJobs
 748         .. todo:: Clean the whole code. Either suppose the  apilib will always
 749             provide the 'items' key, or handle different options.
 750         """
 751
 752         if self.version_json_dict['apilib_version'] != "0.2.10":
 753             self.json_page.raw_json = self.json_page.raw_json['items']
 754
 755     def ParseDeleteJobs(self):
 756         """ No need to parse anything in this function.A POST
 757         is done to delete the job.
 758
 759         """
 760         return
 761
 762     def ParseResourcesFull(self):
 763         """ This method is responsible for parsing all the attributes
 764         of all the nodes returned by OAR when issuing a get resources full.
 765         The information from the nodes and the sites are separated.
 766         Updates the node_dictlist so that the dictionnary of the platform's
 767         nodes is available afterwards.
 768
 769         :returns: node_dictlist, a list of dictionaries about the nodes and
 770             their properties.
 771         :rtype: list
 772
 773         """
 774         logger.debug("OARRESTAPI ParseResourcesFull___________ ")
 775         #print self.json_page.raw_json[1]
 776         #resources are listed inside the 'items' list from the json
 777         self.ChangeRawJsonDependingOnApilibVersion()
 778         self.ParseNodes()
 779         self.ParseSites()
 780         return self.node_dictlist
 781
 782     def ParseResourcesFullSites(self):
 783         """ Called by GetSites which is unused.
 784         Originally used to get information from the sites, with for each site
 785         the list of nodes it has, along with their properties.
 786
 787         :return: site_dict, dictionary of sites
 788         :rtype: dict
 789
 790         .. warning:: unused
 791         .. seealso:: GetSites (IotlabTestbedAPI)
 792
 793         """
 794         self.ChangeRawJsonDependingOnApilibVersion()
 795         self.ParseNodes()
 796         self.ParseSites()
 797         return self.site_dict
 798
 799
 800     def ParseNodes(self):
 801         """ Parse nodes properties from OAR
 802         Put them into a dictionary with key = node id and value is a dictionary
 803         of the node properties and properties'values.
 804
 805         """
 806         node_id = None
 807         _resources_fulljson_dict = \
 808             self.parsing_resourcesfull.resources_fulljson_dict
 809         keys = _resources_fulljson_dict.keys()
 810         keys.sort()
 811
 812         for dictline in self.json_page.raw_json:
 813             node_id = None
 814             # dictionary is empty and/or a new node has to be inserted
 815             node_id = _resources_fulljson_dict['network_address'](
 816                 self.node_dictlist, dictline['network_address'])
 817             for k in keys:
 818                 if k in dictline:
 819                     if k == 'network_address':
 820                         continue
 821
 822                     _resources_fulljson_dict[k](
 823                         self.node_dictlist[node_id], dictline[k])
 824
 825             #The last property has been inserted in the property tuple list,
 826             #reset node_id
 827             #Turn the property tuple list (=dict value) into a dictionary
 828             self.node_dictlist[node_id] = dict(self.node_dictlist[node_id])
 829             node_id = None
 830
 831     @staticmethod
 832     def iotlab_hostname_to_hrn(root_auth,  hostname):
 833         """
 834         Transforms a node hostname into a SFA hrn.
 835
 836         :param root_auth: Name of the root authority of the SFA server. In
 837             our case, it is set to iotlab.
 838         :param hostname: node's hotname, given by OAR.
 839         :type root_auth: string
 840         :type hostname: string
 841         :returns: inserts the root_auth and '.' before the hostname.
 842         :rtype: string
 843
 844         """
 845         return root_auth + '.' + hostname
 846
 847     def ParseSites(self):
 848         """ Returns a list of dictionnaries containing the sites' attributes."""
 849
 850         nodes_per_site = {}
 851         config = Config()
 852         #logger.debug(" OARrestapi.py \tParseSites  self.node_dictlist %s"\
 853                                                         #%(self.node_dictlist))
 854         # Create a list of nodes per site_id
 855         for node_id in self.node_dictlist:
 856             node = self.node_dictlist[node_id]
 857
 858             if node['site'] not in nodes_per_site:
 859                 nodes_per_site[node['site']] = []
 860                 nodes_per_site[node['site']].append(node['node_id'])
 861             else:
 862                 if node['node_id'] not in nodes_per_site[node['site']]:
 863                     nodes_per_site[node['site']].append(node['node_id'])
 864
 865         #Create a site dictionary whose key is site_login_base
 866         # (name of the site) and value is a dictionary of properties,
 867         # including the list of the node_ids
 868         for node_id in self.node_dictlist:
 869             node = self.node_dictlist[node_id]
 870             node.update({'hrn': self.iotlab_hostname_to_hrn(self.interface_hrn,
 871                                                             node['hostname'])})
 872             self.node_dictlist.update({node_id: node})
 873
 874             if node['site'] not in self.site_dict:
 875                 self.site_dict[node['site']] = {
 876                     'site': node['site'],
 877                     'node_ids': nodes_per_site[node['site']],
 878                     'latitude': "48.83726",
 879                     'longitude': "- 2.10336",
 880                     'name': config.SFA_REGISTRY_ROOT_AUTH,
 881                     'pcu_ids': [], 'max_slices': None,
 882                     'ext_consortium_id': None,
 883                     'max_slivers': None, 'is_public': True,
 884                     'peer_site_id': None,
 885                     'abbreviated_name': "iotlab", 'address_ids': [],
 886                     'url': "https://portal.senslab.info", 'person_ids': [],
 887                     'site_tag_ids': [], 'enabled': True,  'slice_ids': [],
 888                     'date_created': None, 'peer_id': None
 889                 }
 890
 891     OARrequests_uri_dict = {
 892         'GET_version':
 893         {'uri': '/oarapi/version.json', 'parse_func': ParseVersion},
 894
 895         'GET_timezone':
 896         {'uri': '/oarapi/timezone.json', 'parse_func': ParseTimezone},
 897
 898         'GET_jobs':
 899         {'uri': '/oarapi/jobs.json', 'parse_func': ParseJobs},
 900
 901         'GET_jobs_id':
 902         {'uri': '/oarapi/jobs/id.json', 'parse_func': ParseJobsIds},
 903
 904         'GET_jobs_id_resources':
 905         {'uri': '/oarapi/jobs/id/resources.json',
 906         'parse_func': ParseJobsIdResources},
 907
 908         'GET_jobs_table':
 909         {'uri': '/oarapi/jobs/table.json', 'parse_func': ParseJobsTable},
 910
 911         'GET_jobs_details':
 912         {'uri': '/oarapi/jobs/details.json', 'parse_func': ParseJobsDetails},
 913
 914         'GET_reserved_nodes':
 915         {'uri':
 916         '/oarapi/jobs/details.json?state=Running,Waiting,Launching',
 917         'owner': '&user=', 'parse_func': ParseReservedNodes},
 918
 919         'GET_running_jobs':
 920         {'uri': '/oarapi/jobs/details.json?state=Running',
 921         'parse_func': ParseRunningJobs},
 922
 923         'GET_resources_full':
 924         {'uri': '/oarapi/resources/full.json',
 925         'parse_func': ParseResourcesFull},
 926
 927         'GET_sites':
 928         {'uri': '/oarapi/resources/full.json',
 929         'parse_func': ParseResourcesFullSites},
 930
 931         'GET_resources':
 932         {'uri': '/oarapi/resources.json', 'parse_func': ParseResources},
 933
 934         'DELETE_jobs_id':
 935         {'uri': '/oarapi/jobs/id.json', 'parse_func': ParseDeleteJobs}}
 936
 937
 938     def SendRequest(self, request, strval=None, username=None):
 939         """ Connects to OAR , sends the valid GET requests and uses
 940         the appropriate json parsing functions.
 941
 942         :returns: calls to the appropriate parsing function, associated with the
 943             GET request
 944         :rtype: depends on the parsing function called.
 945
 946         .. seealso:: OARrequests_uri_dict
 947         """
 948         save_json = None
 949
 950         self.json_page.ResetNextPage()
 951         save_json = []
 952
 953         if request in self.OARrequests_uri_dict:
 954             while self.json_page.next_page:
 955                 self.json_page.raw_json = self.server.GETRequestToOARRestAPI(
 956                     request,
 957                     strval,
 958                     self.json_page.next_offset,
 959                     username)
 960                 self.json_page.FindNextPage()
 961                 if self.json_page.concatenate:
 962                     save_json.append(self.json_page.raw_json)
 963
 964             if self.json_page.concatenate and self.json_page.end:
 965                 self.json_page.raw_json = \
 966                     self.json_page.ConcatenateJsonPages(save_json)
 967
 968             return self.OARrequests_uri_dict[request]['parse_func'](self)
 969         else:
 970             logger.error("OARRESTAPI OARGetParse __init__ : ERROR_REQUEST "
 971                          % (request))