rebaseline_server: when first started, tell client results are still being generated

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 69 matching lines @@
 GENERATED_IMAGES_DIR = os.path.join(STATIC_CONTENTS_DIR, 'generated-images')
 GENERATED_JSON_DIR = os.path.join(STATIC_CONTENTS_DIR, 'generated-json')
 
 # 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'
 
+SUMMARY_TYPES = [
+    results_mod.KEY__HEADER__RESULTS_ALL,
+    results_mod.KEY__HEADER__RESULTS_FAILURES,
+]
+
 _SERVER = None   # This gets filled in by main()
 
 
 def _run_command(args, directory):
   """Runs a command and returns stdout as a single string.
 
   Args:
     args: the command to run, as a list of arguments
     directory: directory within which to run the command
 
@@ skipping 65 matching lines @@
     self._actuals_dir = actuals_dir
     self._actuals_repo_revision = actuals_repo_revision
     self._actuals_repo_url = actuals_repo_url
     self._port = port
     self._export = export
     self._editable = editable
     self._reload_seconds = reload_seconds
     self._actuals_repo = _create_svn_checkout(
         dir_path=actuals_dir, repo_url=actuals_repo_url)
 
+    # Since we don't have any results ready yet, prepare a dummy results file

[epoger, 2014/03/20 18:26:44]

Reason for the change:

Since https://code.google.com/p/skia/source/detail?r=13876 ('rebaseline_server:
serve JSON from static file, rather than generating it live'), when you run the
rebaseline_server locally, you will get an error when you try to load results in
the web client (until the results are ready).

Previously, the server had provided a "try again" message that the web client
would reload periodically until the results were available.  This CL restores
that functionality.

+    # telling any clients that we're still working on the results.
+    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: 0,
+            results_mod.KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE: (
+                RELOAD_INTERVAL_UNTIL_READY),
+        },
+    }
+    if not os.path.isdir(GENERATED_JSON_DIR):
+      os.makedirs(GENERATED_JSON_DIR)
+    for summary_type in SUMMARY_TYPES:
+      gm_json.WriteToFile(
+          response_dict,
+          os.path.join(GENERATED_JSON_DIR, '%s.json' % summary_type))
+
     # Reentrant lock that must be held whenever updating EITHER of:
     # 1. self._results
     # 2. the expected or actual results on local disk
     self.results_rlock = threading.RLock()
     # self._results will be filled in by calls to update_results()
     self._results = None
 
   @property
   def results(self):
     """ Returns the most recently generated results, or None if we don't have
@@ skipping 54 matching lines @@
         logging.info(
             'Updating expected GM results in %s by syncing Skia repo ...' %
             results_mod.DEFAULT_EXPECTATIONS_DIR)
         _run_command(['gclient', 'sync'], TRUNK_DIRECTORY)
 
       new_results = results_mod.Results(
           actuals_root=self._actuals_dir,
           generated_images_root=GENERATED_IMAGES_DIR,
           diff_base_url=os.path.relpath(
               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]:
+      for summary_type in SUMMARY_TYPES:
         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
 
   def _result_loader(self, reload_seconds=0):
     """ Call self.update_results(), either once or periodically.
 
     Params:
@@ skipping 239 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()