rebaseline_server: generate JSON that can be viewed without a live server

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 23 matching lines @@
 # 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
+import results as results_mod

[rmistry, 2014/03/13 13:11:46]

This seems inconsistent with other imported modules in this framework, is there
a specific reason we are doing this for the results module?

[epoger, 2014/03/13 14:37:04]

Indeed.  I changed this because I noticed that I had defined a property
results() with the same name as the imported module.  While Python keeps them
distinct (you refer to one as "self.results", the other just as "results") I was
worried it might be confusing.

I'm happy to handle it some other way, such as:
1. leave it as it was before
2. leave the imported module name as "results", and replace the results()
property with a get_results() method
3. <your idea here>

Let me know what you think is best...

 
 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_ACTUALS_DIR = results_mod.DEFAULT_ACTUALS_DIR
 DEFAULT_ACTUALS_REPO_REVISION = 'HEAD'
 DEFAULT_ACTUALS_REPO_URL = 'http://skia-autogen.googlecode.com/svn/gm-actual'
 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 107 matching lines @@
     """ Returns true iff HTTP clients are allowed to submit new baselines. """
     return self._editable
 
   @property
   def reload_seconds(self):
     """ Returns the result reload period in seconds, or 0 if we don't reload
     results. """
     return self._reload_seconds
 
   def update_results(self, invalidate=False):
-    """ Create or update self._results, based on the expectations in
-    EXPECTATIONS_DIR and the latest actuals from skia-autogen.
+    """ Create or update self._results, based on the latest expectations and
+    actuals.
 
     We hold self.results_rlock while we do this, to guarantee that no other
     thread attempts to update either self._results or the underlying files at
     the same time.
 
     Args:
       invalidate: if True, invalidate self._results immediately upon entry;
                   otherwise, we will let readers see those results until we
                   replace them
     """
@@ skipping 13 matching lines @@
       # Because the Skia repo is moving from SVN to git, and git does not
       # support updating a single directory tree, we have to update the entire
       # repo checkout.
       #
       # Because Skia uses depot_tools, we have to update using "gclient sync"
       # instead of raw git (or SVN) update.  Happily, this will work whether
       # the checkout was created using git or SVN.
       if self._reload_seconds:
         logging.info(
             'Updating expected GM results in %s by syncing Skia repo ...' %
-            EXPECTATIONS_DIR)
+            results_mod.DEFAULT_EXPECTATIONS_DIR)
         _run_command(['gclient', 'sync'], TRUNK_DIRECTORY)
 
-      self._results = results.Results(
-          actuals_root=self._actuals_dir,
-          expected_root=EXPECTATIONS_DIR,
-          generated_images_root=GENERATED_IMAGES_ROOT)
+      self._results = results_mod.Results(actuals_root=self._actuals_dir)
 
   def _result_loader(self, reload_seconds=0):
     """ Call self.update_results(), either once or periodically.
 
     Params:
       reload_seconds: integer; if nonzero, reload results at this interval
           (in which case, this method will never return!)
     """
     self.update_results()
     logging.info('Initial results loaded. Ready for requests on %s' % self._url)
@@ skipping 52 matching lines @@
       dispatchers = {
           'results': self.do_GET_results,
           'static': self.do_GET_static,
       }
       dispatcher = dispatchers[dispatcher_name]
       dispatcher(remainder)
     except:
       self.send_error(404)
       raise
 
-  def do_GET_results(self, type):
+  def do_GET_results(self, results_type):
     """ Handle a GET request for GM results.
 
     Args:
-      type: string indicating which set of results to return;
-            must be one of the results.RESULTS_* constants
+      results_type: string indicating which set of results to return;
+            must be one of the results_mod.RESULTS_* constants
     """
-    logging.debug('do_GET_results: sending results of type "%s"' % type)
+    logging.debug('do_GET_results: sending results of type "%s"' % results_type)
     # Since we must make multiple calls to the Results object, grab a
     # reference to it in case it is updated to point at a new Results
     # object within another thread.
     #
     # 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)
+      response_dict = results_obj.get_packaged_results_of_type(
+          results_type=results_type, reload_seconds=_SERVER.reload_seconds,
+          is_editable=_SERVER.is_editable, is_exported=_SERVER.is_exported)
     else:
       now = int(time.time())
       response_dict = {
-          KEY__HEADER: {
-              KEY__HEADER__IS_STILL_LOADING: True,
-              KEY__HEADER__TIME_UPDATED: now,
-              KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE: (
+          results_mod.KEY__HEADER: {
+              results_mod.KEY__HEADER__IS_STILL_LOADING: True,
+              results_mod.KEY__HEADER__TIME_UPDATED: now,
+              results_mod.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[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).
-        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,
-
-        # The type we passed to get_results_of_type()
-        KEY__HEADER__TYPE: type,
-
-        # Hash of dataset, which the client must return with any edits--
-        # this ensures that the edits were made to a particular dataset.
-        KEY__HEADER__DATAHASH: str(hash(repr(
-            response_dict[imagepairset.KEY__IMAGEPAIRS]))),
-
-        # Whether the server will accept edits back.
-        KEY__HEADER__IS_EDITABLE: _SERVER.is_editable,
-
-        # Whether the service is accessible from other hosts.
-        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
     """
     # Strip arguments ('?resultsToLoad=all') from the path
     path = urlparse.urlparse(path).path
@@ skipping 34 matching lines @@
 
     {
       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()
+        # as needed by results_mod.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]
@@ skipping 121 matching lines @@
   _SERVER = Server(actuals_dir=args.actuals_dir,
                    actuals_repo_revision=args.actuals_revision,
                    actuals_repo_url=args.actuals_repo,
                    port=args.port, export=args.export, editable=args.editable,
                    reload_seconds=args.reload)
   _SERVER.run()
 
 
 if __name__ == '__main__':
   main()