rebaseline_server: start HTTP server immediately, auto-reload once results are available

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 44 matching lines @@
                  'html': 'text/html',
                  'css': 'text/css',
                  'png': 'image/png',
                  'js': 'application/javascript',
                  'json': 'application/json'
                  }
 
 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'
 
 _SERVER = None   # This gets filled in by main()
 
 
 def _run_command(args, directory):
   """Runs a command and returns stdout as a single string.
 
   Args:
@@ skipping 131 matching lines @@
 
       logging.info(
           ('Parsing results from actuals in %s and expectations in %s, '
            + 'and generating pixel diffs (may take a while) ...') % (
                self._actuals_dir, EXPECTATIONS_DIR))
       self._results = results.Results(
           actuals_root=self._actuals_dir,
           expected_root=EXPECTATIONS_DIR,
           generated_images_root=GENERATED_IMAGES_ROOT)
 
-  def _result_reloader(self):
-    """ Reload results at the appropriate interval.  This never exits, so it
-    should be run in its own thread.
+  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!)
     """
-    while True:
-      time.sleep(self._reload_seconds)
-      self.update_results()
+    self.update_results()
+    logging.info('Initial results loaded. Ready for requests on %s' % self._url)
+    if reload_seconds:
+      while True:
+        time.sleep(reload_seconds)
+        self.update_results()
 
   def run(self):
-    self.update_results()
-    if self._reload_seconds:
-      thread.start_new_thread(self._result_reloader, ())
+    arg_tuple = (self._reload_seconds,)  # start_new_thread needs a tuple,
+                                         # even though it holds just one param
+    thread.start_new_thread(self._result_loader, arg_tuple)
 
     if self._export:
       server_address = ('', self._port)
       host = _get_routable_ip_address()
       if self._editable:
         logging.warning('Running with combination of "export" and "editable" '
                         'flags.  Users on other machines will '
                         'be able to modify your GM expectations!')
     else:
       host = '127.0.0.1'
       server_address = (host, self._port)
     http_server = BaseHTTPServer.HTTPServer(server_address, HTTPRequestHandler)
-    logging.info('Ready for requests on http://%s:%d' % (
-        host, http_server.server_port))
+    self._url = 'http://%s:%d' % (host, http_server.server_port)
+    logging.info('Listening for requests on %s' % self._url)
     http_server.serve_forever()
 
 
 class HTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
   """ HTTP request handlers for various types of queries this server knows
       how to handle (static HTML and Javascript, expected/actual results, etc.)
   """
   def do_GET(self):
     """ Handles all GET requests, forwarding them to the appropriate
         do_GET_* dispatcher. """
@@ skipping 28 matching lines @@
     try:
       # 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
-      response_dict = results_obj.get_results_of_type(type)
-      time_updated = results_obj.get_timestamp()
+      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,
+            },
+        }
+      self.send_json_dict(response_dict)
+    except:
+      self.send_error(404)
+      raise
 
-      response_dict['header'] = {
+  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'] = {
         # 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': (
             (time_updated+_SERVER.reload_seconds) if _SERVER.reload_seconds
             else None),
 
         # The type we passed to get_results_of_type()
         'type': type,
 
         # Hash of testData, 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']))),
 
         # Whether the server will accept edits back.
         'isEditable': _SERVER.is_editable,
 
         # Whether the service is accessible from other hosts.
         'isExported': _SERVER.is_exported,
-      }
-      self.send_json_dict(response_dict)
-    except:
-      self.send_error(404)
-      raise
+    }
+    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
@@ skipping 163 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()