rebaseline_server: allow client to pull all results, or just failures

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.
 """
 
 # System-level imports
 import argparse
 import BaseHTTPServer
 import json
+import logging
 import os
 import posixpath
 import re
 import shutil
 import sys
+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*
 # 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')
@@ skipping 53 matching lines @@
     return self._export
 
   def fetch_results(self):
     """ Create self.results, based on the expectations in
     self._expectations_dir and the latest actuals from skia-autogen.
 
     TODO(epoger): Add a new --browseonly mode setting.  In that mode,
     the gm-actuals and expectations will automatically be updated every few
     minutes.  See discussion in https://codereview.chromium.org/24274003/ .
     """
-    print 'Checking out latest actual GM results from %s into %s ...' % (
-        ACTUALS_SVN_REPO, self._actuals_dir)
+    logging.info('Checking out latest actual GM results from %s into %s ...' % (
+        ACTUALS_SVN_REPO, self._actuals_dir))
     actuals_repo = svn.Svn(self._actuals_dir)
     if not os.path.isdir(self._actuals_dir):
       os.makedirs(self._actuals_dir)
       actuals_repo.Checkout(ACTUALS_SVN_REPO, '.')
     else:
       actuals_repo.Update('.')
-    print 'Parsing results from actuals in %s and expectations in %s ...' % (
-        self._actuals_dir, self._expectations_dir)
+    logging.info(
+        'Parsing results from actuals in %s and expectations in %s ...' % (
+        self._actuals_dir, self._expectations_dir))
     self.results = results.Results(
       actuals_root=self._actuals_dir,
       expected_root=self._expectations_dir)
 
   def run(self):
     self.fetch_results()
     if self._export:
       server_address = ('', self._port)
-      print ('WARNING: Running in "export" mode. Users on other machines will '
-             'be able to modify your GM expectations!')
+      logging.warning('Running in "export" mode. Users on other machines will '
+                      'be able to modify your GM expectations!')
     else:
       server_address = ('127.0.0.1', self._port)
     http_server = BaseHTTPServer.HTTPServer(server_address, HTTPRequestHandler)
-    print 'Ready for requests on http://%s:%d' % (
-        http_server.server_name, http_server.server_port)
+    logging.info('Ready for requests on http://%s:%d' % (
+        http_server.server_name, http_server.server_port))
     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. """
     if self.path == '' or self.path == '/' or self.path == '/index.html' :
-      self.redirect_to('/static/view.html')
+      self.redirect_to('/static/view.html?resultsToLoad=all')
       return
     if self.path == '/favicon.ico' :
       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)
 
-  def do_GET_results(self, result_type):
+  def do_GET_results(self, type):
     """ Handle a GET request for GM results.
-    For now, we ignore the remaining path info, because we only know how to
-    return all results.
 
     Args:
-      result_type: currently unused
-
-    TODO(epoger): Unless we start making use of result_type, remove that
-    parameter."""
-    print 'do_GET_results: sending results of type "%s"' % result_type
-    # TODO(epoger): Cache response_dict rather than the results object, to save
-    # time on subsequent fetches (no need to regenerate the header, etc.)
-    response_dict = _SERVER.results.GetAll()
-    if response_dict:
+      type: string indicating which set of results to return;
+            must be one of the results.RESULTS_* constants
+    """
+    logging.debug('do_GET_results: sending results of type "%s"' % type)
+    try:
+      response_dict = _SERVER.results.get_results_of_type(type)
       response_dict['header'] = {
         # Hash of testData, which the client must return with any edits--
         # this ensures that the edits were made to a particular dataset.
         'data-hash': str(hash(repr(response_dict['testData']))),
 
         # Whether the server will accept edits back.
         # TODO(epoger): Not yet implemented, so hardcoding to False;
         # once we implement the 'browseonly' mode discussed in
         # https://codereview.chromium.org/24274003/#msg6 , this value will vary.
         'isEditable': False,
 
         # Whether the service is accessible from other hosts.
         'isExported': _SERVER.is_exported(),
       }
       self.send_json_dict(response_dict)
-    else:
+    except:
       self.send_error(404)
 
   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
     """
-    print 'do_GET_static: sending file "%s"' % path
+    # 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):
       self.send_file(full_path)
     else:
-      print ('Attempted do_GET_static() of path [%s] outside of static dir [%s]'
-             % (full_path, static_dir))
+      logging.error(
+          'Attempted do_GET_static() of path [%s] outside of static dir [%s]'
+          % (full_path, static_dir))
       self.send_error(404)
 
   def redirect_to(self, url):
     """ Redirect the HTTP client to a different url.
 
     Args:
       url: URL to redirect the HTTP client to
     """
     self.send_response(301)
     self.send_header('Location', url)
@@ skipping 31 matching lines @@
     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(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'),
                     default=DEFAULT_ACTUALS_DIR)
   parser.add_argument('--expectations-dir',
                     help=('Directory under which to find GM expectations; '
                           'defaults to %(default)s'),
                     default=DEFAULT_EXPECTATIONS_DIR)
   parser.add_argument('--export', action='store_true',
                       help=('Instead of only allowing access from HTTP clients '
                             'on localhost, allow HTTP clients on other hosts '
                             'to access this server.  WARNING: doing so will '
                             'allow users on other hosts to modify your '
                             'GM expectations!'))
   parser.add_argument('--port', type=int,
                       help=('Which TCP port to listen on for HTTP requests; '
                             'defaults to %(default)s'),
                       default=DEFAULT_PORT)
   args = parser.parse_args()
   global _SERVER

[jcgregorio, 2013/10/11 18:15:15]

The global really bothers me, why doesn't Server subclass from HTTPServer, then
it would be available to the handler via the .server instance variable of
handler?

This doesn't have to be fixed in this CL, it could go in another CL.

[epoger, 2013/10/11 18:37:21]

Good point, thanks.  Added a TODO above.

   _SERVER = Server(expectations_dir=args.expectations_dir,
                    port=args.port, export=args.export)
   _SERVER.run()
 
 if __name__ == '__main__':
   main()