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 os
 import posixpath
 import re
 import shutil
+import string
 import sys
 
 # 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))
@@ skipping 90 matching lines @@
 
 
 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
+    """
+    print 'do_GET_results: sending results of type "%s"' % type

[jcgregorio, 2013/10/10 19:59:11]

Can we use the logging module instead of print?

[epoger, 2013/10/11 17:44:49]

Done.

+    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
     """
+    i = string.find(path, '?')

[jcgregorio, 2013/10/10 19:59:11]

path = urlparse.urlparse(path).path

[epoger, 2013/10/11 17:44:49]

done.done

+    if i >= 0:
+      path = path[:i]
     print '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))
       self.send_error(404)
 
@@ skipping 67 matching lines @@
                             'defaults to %(default)s'),
                       default=DEFAULT_PORT)
   args = parser.parse_args()
   global _SERVER
   _SERVER = Server(expectations_dir=args.expectations_dir,
                    port=args.port, export=args.export)
   _SERVER.run()
 
 if __name__ == '__main__':
   main()