rebaseline_server: serve JSON from static file, rather than generating it live

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 10 matching lines @@
 import socket
 import subprocess
 import sys
 import thread
 import threading
 import time
 import urlparse
 
 # Imports from within Skia
 #
-# We need to add the 'tools' directory, so that we can import svn.py within
-# that directory.
-# Make sure that the 'tools' dir is in the PYTHONPATH, but add it at the *end*
+# We need to add the 'tools' directory for svn.py, and the 'gm' directory for
+# gm_json.py .
+# Make sure that these dirs are in the PYTHONPATH, but add them 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))
+GM_DIRECTORY = os.path.dirname(PARENT_DIRECTORY)
+TRUNK_DIRECTORY = os.path.dirname(GM_DIRECTORY)
 TOOLS_DIRECTORY = os.path.join(TRUNK_DIRECTORY, 'tools')
 if TOOLS_DIRECTORY not in sys.path:
   sys.path.append(TOOLS_DIRECTORY)
 import svn
+if GM_DIRECTORY not in sys.path:
+  sys.path.append(GM_DIRECTORY)
+import gm_json
 
 # Imports from local dir
 #
 # Note: we import results under a different name, to avoid confusion with the
 # Server.results() property. See discussion at
 # https://codereview.chromium.org/195943004/diff/1/gm/rebaseline_server/server.py#newcode44
 import imagepairset
 import results as results_mod
 
 PATHSPLIT_RE = re.compile('/([^/]+)/(.+)')
@@ skipping 13 matching lines @@
 # 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'
 
 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
 
+# Directory within which the server will serve out static files.
+STATIC_CONTENTS_DIR = os.path.realpath(os.path.join(PARENT_DIRECTORY, 'static'))
+GENERATED_IMAGES_DIR = os.path.join(STATIC_CONTENTS_DIR, 'generated-images')
+GENERATED_JSON_DIR = os.path.join(STATIC_CONTENTS_DIR, 'generated-json')

[epoger, 2014/03/19 21:13:51]

FOR NOW we still need the server running so the client can download diff images
anyway, so this is a convenient place to serve the JSON files from.

+
 # 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'
 
 _SERVER = None   # This gets filled in by main()
 
 
@@ skipping 141 matching lines @@
       #
       # 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 ...' %
             results_mod.DEFAULT_EXPECTATIONS_DIR)
         _run_command(['gclient', 'sync'], TRUNK_DIRECTORY)
 
-      self._results = results_mod.Results(actuals_root=self._actuals_dir)
+      new_results = results_mod.Results(
+          actuals_root=self._actuals_dir,
+          generated_images_root=GENERATED_IMAGES_DIR,
+          diff_base_url=os.path.relpath(

[epoger, 2014/03/19 21:13:51]

Because this uses a relative diff_base_url, this CL depends on
https://codereview.chromium.org/205273002/ ('rebaseline_server: image URLs are
relative to JSON file's location')

+              GENERATED_IMAGES_DIR, GENERATED_JSON_DIR))
+      if not os.path.isdir(GENERATED_JSON_DIR):
+        os.makedirs(GENERATED_JSON_DIR)
+      for summary_type in [results_mod.KEY__HEADER__RESULTS_ALL,
+                           results_mod.KEY__HEADER__RESULTS_FAILURES]:
+        gm_json.WriteToFile(
+            new_results.get_packaged_results_of_type(results_type=summary_type),
+            os.path.join(GENERATED_JSON_DIR, '%s.json' % summary_type))
+
+      self._results = new_results

[epoger, 2014/03/19 21:13:51]

Even though we no longer serve the JSON from the live Results object, we still
need to hold onto it in case the client sends us edits to apply to it.

 
   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 43 matching lines @@
         self.redirect_to('/static/favicon.ico')
         return
 
       # All requests must be of this form:
       #   /dispatcher/remainder
       # where 'dispatcher' indicates which do_GET_* dispatcher to run
       # and 'remainder' is the remaining path sent to that dispatcher.
       normpath = posixpath.normpath(self.path)
       (dispatcher_name, remainder) = PATHSPLIT_RE.match(normpath).groups()
       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, results_type):
-    """ Handle a GET request for GM results.
-
-    Args:
-      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"' % 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 = 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 = {
-          results_mod.KEY__HEADER: {
-              results_mod.KEY__HEADER__SCHEMA_VERSION: (
-                  results_mod.REBASELINE_SERVER_SCHEMA_VERSION_NUMBER),
-              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 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
 
     logging.debug('do_GET_static: sending file "%s"' % path)
-    static_dir = os.path.realpath(os.path.join(PARENT_DIRECTORY, 'static'))
-    full_path = os.path.realpath(os.path.join(static_dir, path))
-    if full_path.startswith(static_dir):
+    full_path = os.path.realpath(os.path.join(STATIC_CONTENTS_DIR, path))
+    if full_path.startswith(STATIC_CONTENTS_DIR):
       self.send_file(full_path)
     else:
       logging.error(
           'Attempted do_GET_static() of path [%s] outside of static dir [%s]'
-          % (full_path, static_dir))
+          % (full_path, STATIC_CONTENTS_DIR))
       self.send_error(404)
 
   def do_POST(self):
     """ Handles all POST requests, forwarding them to the appropriate
         do_POST_* dispatcher. """
     # All requests must be of this form:
     #   /dispatcher
     # where 'dispatcher' indicates which do_POST_* dispatcher to run.
     logging.debug('do_POST: path="%s"' % self.path)
     normpath = posixpath.normpath(self.path)
@@ skipping 91 matching lines @@
     # Open the file and send it over HTTP
     if os.path.isfile(path):
       with open(path, 'rb') as sending_file:
         self.send_response(200)
         self.send_header('Content-type', mime_type)
         self.end_headers()
         self.wfile.write(sending_file.read())
     else:
       self.send_error(404)
 
-  def send_json_dict(self, json_dict):
-    """ Send the contents of this dictionary in JSON format, with a JSON
-        mimetype.
-
-    Args:
-      json_dict: dictionary to send
-    """
-    self.send_response(200)
-    self.send_header('Content-type', 'application/json')
-    self.end_headers()
-    json.dump(json_dict, self.wfile)
-
 
 def main():
   logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
                       datefmt='%m/%d/%Y %H:%M:%S',
                       level=logging.INFO)
   parser = argparse.ArgumentParser()
   parser.add_argument('--actuals-dir',
                     help=('Directory into which we will check out the latest '
                           'actual GM results. If this directory does not '
                           'exist, it will be created. Defaults to %(default)s'),
@@ skipping 33 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()