rebaseline_server: use new intermediate JSON format

gm/rebaseline_server/server.py

 #!/usr/bin/python
 
 """
 Copyright 2013 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 
 HTTP server for our HTML rebaseline viewer.
 """
@@ skipping 22 matching lines @@
 # Make sure that the 'tools' dir is in the PYTHONPATH, but add it at the *end*
 # so any dirs that are already in the PYTHONPATH will be preferred.
 PARENT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
 TRUNK_DIRECTORY = os.path.dirname(os.path.dirname(PARENT_DIRECTORY))
 TOOLS_DIRECTORY = os.path.join(TRUNK_DIRECTORY, 'tools')
 if TOOLS_DIRECTORY not in sys.path:
   sys.path.append(TOOLS_DIRECTORY)
 import svn
 
 # Imports from local dir
+import imagepairset
 import results
 
 ACTUALS_SVN_REPO = 'http://skia-autogen.googlecode.com/svn/gm-actual'
 PATHSPLIT_RE = re.compile('/([^/]+)/(.+)')
 EXPECTATIONS_DIR = os.path.join(TRUNK_DIRECTORY, 'expectations', 'gm')
 GENERATED_IMAGES_ROOT = os.path.join(PARENT_DIRECTORY, 'static',
                                      'generated-images')
 
 # A simple dictionary of file name extensions to MIME types. The empty string
 # entry is used as the default when no extension was given or if the extension
 # has no entry in this dictionary.
 MIME_TYPE_MAP = {'': 'application/octet-stream',
                  'html': 'text/html',
                  'css': 'text/css',
                  'png': 'image/png',
                  'js': 'application/javascript',
                  'json': 'application/json'
                  }
 
+# Keys that server.py uses to create the toplevel content header.
+# NOTE: Keep these in sync with static/constants.js
+KEY__EDITS__MODIFICATIONS = 'modifications'
+KEY__EDITS__OLD_RESULTS_HASH = 'oldResultsHash'
+KEY__EDITS__OLD_RESULTS_TYPE = 'oldResultsType'
+KEY__HEADER = 'header'
+KEY__HEADER__DATAHASH = 'dataHash'
+KEY__HEADER__IS_EDITABLE = 'isEditable'
+KEY__HEADER__IS_EXPORTED = 'isExported'
+KEY__HEADER__IS_STILL_LOADING = 'resultsStillLoading'
+KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE = 'timeNextUpdateAvailable'
+KEY__HEADER__TIME_UPDATED = 'timeUpdated'
+KEY__HEADER__TYPE = 'type'
+
 DEFAULT_ACTUALS_DIR = '.gm-actuals'
 DEFAULT_PORT = 8888
 
 # How often (in seconds) clients should reload while waiting for initial
 # results to load.
 RELOAD_INTERVAL_UNTIL_READY = 10
 
 _HTTP_HEADER_CONTENT_LENGTH = 'Content-Length'
 _HTTP_HEADER_CONTENT_TYPE = 'Content-Type'
 
@@ skipping 234 matching lines @@
     # TODO(epoger): Rather than using a global variable for the handler
     # to refer to the Server object, make Server a subclass of
     # HTTPServer, and then it could be available to the handler via
     # the handler's .server instance variable.
     results_obj = _SERVER.results
     if results_obj:
       response_dict = self.package_results(results_obj, type)
     else:
       now = int(time.time())
       response_dict = {
-          'header': {
-              'resultsStillLoading': True,
-              'timeUpdated': now,
-              'timeNextUpdateAvailable': now + RELOAD_INTERVAL_UNTIL_READY,
+          KEY__HEADER: {
+              KEY__HEADER__IS_STILL_LOADING: True,
+              KEY__HEADER__TIME_UPDATED: now,
+              KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE:
+                  now + RELOAD_INTERVAL_UNTIL_READY,
           },
       }
     self.send_json_dict(response_dict)
 
   def package_results(self, results_obj, type):
     """ Given a nonempty "results" object, package it as a response_dict
     as needed within do_GET_results.
 
     Args:
       results_obj: nonempty "results" object
       type: string indicating which set of results to return;
             must be one of the results.RESULTS_* constants
     """
     response_dict = results_obj.get_results_of_type(type)
     time_updated = results_obj.get_timestamp()
-    response_dict['header'] = {
+    response_dict[KEY__HEADER] = {
         # Timestamps:
         # 1. when this data was last updated
         # 2. when the caller should check back for new data (if ever)
         #
         # We only return these timestamps if the --reload argument was passed;
         # otherwise, we have no idea when the expectations were last updated
         # (we allow the user to maintain her own expectations as she sees fit).
-        'timeUpdated': time_updated if _SERVER.reload_seconds else None,
-        'timeNextUpdateAvailable': (
+        KEY__HEADER__TIME_UPDATED:
+            time_updated if _SERVER.reload_seconds else None,
+        KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE:
             (time_updated+_SERVER.reload_seconds) if _SERVER.reload_seconds
-            else None),
+            else None,
 
         # The type we passed to get_results_of_type()
-        'type': type,
+        KEY__HEADER__TYPE: type,
 
-        # Hash of testData, which the client must return with any edits--
+        # Hash of dataset, which the client must return with any edits--
         # this ensures that the edits were made to a particular dataset.
-        'dataHash': str(hash(repr(response_dict['testData']))),
+        KEY__HEADER__DATAHASH: str(hash(repr(
+            response_dict[imagepairset.KEY__IMAGEPAIRS]))),
 
         # Whether the server will accept edits back.
-        'isEditable': _SERVER.is_editable,
+        KEY__HEADER__IS_EDITABLE: _SERVER.is_editable,
 
         # Whether the service is accessible from other hosts.
-        'isExported': _SERVER.is_exported,
+        KEY__HEADER__IS_EXPORTED: _SERVER.is_exported,
     }
     return response_dict
 
   def do_GET_static(self, path):
     """ Handle a GET request for a file under the 'static' directory.
     Only allow serving of files within the 'static' directory that is a
     filesystem sibling of this script.
 
     Args:
       path: path to file (under static directory) to retrieve
@@ skipping 29 matching lines @@
       self.send_response(200)
     except:
       self.send_error(404)
       raise
 
   def do_POST_edits(self):
     """ Handle a POST request with modifications to GM expectations, in this
     format:
 
     {
-      'oldResultsType': 'all',    # type of results that the client loaded
-                                  # and then made modifications to
-      'oldResultsHash': 39850913, # hash of results when the client loaded them
-                                  # (ensures that the client and server apply
-                                  # modifications to the same base)
-      'modifications': [
-        {
-          'builder': 'Test-Android-Nexus10-MaliT604-Arm7-Debug',
-          'test': 'strokerect',
-          'config': 'gpu',
-          'expectedHashType': 'bitmap-64bitMD5',
-          'expectedHashDigest': '1707359671708613629',
-        },
+      KEY__EDITS__OLD_RESULTS_TYPE: 'all',  # type of results that the client
+                                            # loaded and then made
+                                            # modifications to
+      KEY__EDITS__OLD_RESULTS_HASH: 39850913, # hash of results when the client
+                                              # loaded them (ensures that the
+                                              # client and server apply
+                                              # modifications to the same base)
+      KEY__EDITS__MODIFICATIONS: [
+        # as needed by results.edit_expectations()
         ...
       ],
     }
 
     Raises an Exception if there were any problems.
     """
     if not _SERVER.is_editable:
       raise Exception('this server is not running in --editable mode')
 
     content_type = self.headers[_HTTP_HEADER_CONTENT_TYPE]
     if content_type != 'application/json;charset=UTF-8':
       raise Exception('unsupported %s [%s]' % (
           _HTTP_HEADER_CONTENT_TYPE, content_type))
 
     content_length = int(self.headers[_HTTP_HEADER_CONTENT_LENGTH])
     json_data = self.rfile.read(content_length)
     data = json.loads(json_data)
     logging.debug('do_POST_edits: received new GM expectations data [%s]' %
                   data)
 
     # Update the results on disk with the information we received from the
     # client.
     # We must hold _SERVER.results_rlock while we do this, to guarantee that
     # no other thread updates expectations (from the Skia repo) while we are
     # updating them (using the info we received from the client).
     with _SERVER.results_rlock:
-      oldResultsType = data['oldResultsType']
+      oldResultsType = data[KEY__EDITS__OLD_RESULTS_TYPE]
       oldResults = _SERVER.results.get_results_of_type(oldResultsType)
-      oldResultsHash = str(hash(repr(oldResults['testData'])))
-      if oldResultsHash != data['oldResultsHash']:
+      oldResultsHash = str(hash(repr(oldResults[imagepairset.KEY__IMAGEPAIRS])))
+      if oldResultsHash != data[KEY__EDITS__OLD_RESULTS_HASH]:
         raise Exception('results of type "%s" changed while the client was '
                         'making modifications. The client should reload the '
                         'results and submit the modifications again.' %
                         oldResultsType)
-      _SERVER.results.edit_expectations(data['modifications'])
+      _SERVER.results.edit_expectations(data[KEY__EDITS__MODIFICATIONS])
 
     # Read the updated results back from disk.
     # We can do this in a separate thread; we should return our success message
     # to the UI as soon as possible.
     thread.start_new_thread(_SERVER.update_results, (True,))
 
   def redirect_to(self, url):
     """ Redirect the HTTP client to a different url.
 
     Args:
@@ skipping 74 matching lines @@
   args = parser.parse_args()
   global _SERVER
   _SERVER = Server(actuals_dir=args.actuals_dir,
                    port=args.port, export=args.export, editable=args.editable,
                    reload_seconds=args.reload)
   _SERVER.run()
 
 
 if __name__ == '__main__':
   main()