rebaseline_server: remove deprecated-expectations-dir option

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 23 matching lines @@
 TRUNK_DIRECTORY = os.path.dirname(os.path.dirname(PARENT_DIRECTORY))
 TOOLS_DIRECTORY = os.path.join(TRUNK_DIRECTORY, 'tools')
 if TOOLS_DIRECTORY not in sys.path:
   sys.path.append(TOOLS_DIRECTORY)
 import svn
 
 # Imports from local dir
 import results
 
 ACTUALS_SVN_REPO = 'http://skia-autogen.googlecode.com/svn/gm-actual'
-EXPECTATIONS_SVN_REPO = 'http://skia.googlecode.com/svn/trunk/expectations/gm'
 PATHSPLIT_RE = re.compile('/([^/]+)/(.+)')
 TRUNK_DIRECTORY = os.path.dirname(os.path.dirname(os.path.dirname(
     os.path.realpath(__file__))))
+EXPECTATIONS_DIR = os.path.join(TRUNK_DIRECTORY, 'expectations', 'gm')
 GENERATED_IMAGES_ROOT = os.path.join(PARENT_DIRECTORY, 'static',
                                      'generated-images')
 
 # A simple dictionary of file name extensions to MIME types. The empty string
 # entry is used as the default when no extension was given or if the extension
 # has no entry in this dictionary.
 MIME_TYPE_MAP = {'': 'application/octet-stream',
                  'html': 'text/html',
                  'css': 'text/css',
                  'png': 'image/png',
                  'js': 'application/javascript',
                  'json': 'application/json'
                  }
 
 DEFAULT_ACTUALS_DIR = '.gm-actuals'
-DEFAULT_EXPECTATIONS_DIR = os.path.join(TRUNK_DIRECTORY, 'expectations', 'gm')
 DEFAULT_PORT = 8888
 
 _HTTP_HEADER_CONTENT_LENGTH = 'Content-Length'
 _HTTP_HEADER_CONTENT_TYPE = 'Content-Type'
 
 _SERVER = None   # This gets filled in by main()
 
 def _get_routable_ip_address():
   """Returns routable IP address of this host (the IP address of its network
      interface that would be used for most traffic, not its localhost
@@ skipping 20 matching lines @@
     os.makedirs(dir_path)
     local_checkout.Checkout(repo_url, '.')
   return local_checkout
 
 
 class Server(object):
   """ HTTP server for our HTML rebaseline viewer. """
 
   def __init__(self,
                actuals_dir=DEFAULT_ACTUALS_DIR,
-               expectations_dir=DEFAULT_EXPECTATIONS_DIR,
                port=DEFAULT_PORT, export=False, editable=True,
                reload_seconds=0):
     """
     Args:
       actuals_dir: directory under which we will check out the latest actual
                    GM results
-      expectations_dir: DEPRECATED: directory under which to find
-                        GM expectations (they must already be in that directory)
       port: which TCP port to listen on for HTTP requests
       export: whether to allow HTTP clients on other hosts to access this server
       editable: whether HTTP clients are allowed to submit new baselines
       reload_seconds: polling interval with which to check for new results;
                       if 0, don't check for new results at all
     """
     self._actuals_dir = actuals_dir
-    self._expectations_dir = expectations_dir
     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_SVN_REPO)
 
     # We only update the expectations dir if the server was run with a
     # nonzero --reload argument; otherwise, we expect the user to maintain
     # her own expectations as she sees fit.
     #
-    # TODO(epoger): Use git instead of svn to check out expectations, since
+    # TODO(epoger): Use git instead of svn to update the expectations dir, since
     # the Skia repo is moving to git.
+    # When we make that change, we will have to update the entire workspace,
+    # not just the expectations dir, because git only operates on the repo
+    # as a whole.
+    # And since Skia uses depot_tools to manage its dependencies, we will have
+    # to run "gclient sync" rather than a raw "git pull".
     if reload_seconds:
-      self._expectations_repo = _create_svn_checkout(
-          dir_path=expectations_dir, repo_url=EXPECTATIONS_SVN_REPO)
+      self._expectations_repo = svn.Svn(EXPECTATIONS_DIR)
     else:
       self._expectations_repo = None
 
   def is_exported(self):
     """ Returns true iff HTTP clients on other hosts are allowed to access
     this server. """
     return self._export
 
   def is_editable(self):
     """ Returns true iff HTTP clients are allowed to submit new baselines. """
     return self._editable
 
   def reload_seconds(self):
     """ Returns the result reload period in seconds, or 0 if we don't reload
     results. """
     return self._reload_seconds
 
   def update_results(self):
     """ Create or update self.results, based on the expectations in
-    self._expectations_dir and the latest actuals from skia-autogen.
+    EXPECTATIONS_DIR and the latest actuals from skia-autogen.
     """
     logging.info('Updating actual GM results in %s from SVN repo %s ...' % (
         self._actuals_dir, ACTUALS_SVN_REPO))
     self._actuals_repo.Update('.')
 
     if self._expectations_repo:
       logging.info(
-          'Updating expected GM results in %s from SVN repo %s ...' % (
-              self._expectations_dir, EXPECTATIONS_SVN_REPO))
+          'Updating expected GM results in %s ...' % EXPECTATIONS_DIR)
       self._expectations_repo.Update('.')
 
     logging.info(
           ('Parsing results from actuals in %s and expectations in %s, '
           + 'and generating pixel diffs (may take a while) ...') % (
-          self._actuals_dir, self._expectations_dir))
+          self._actuals_dir, EXPECTATIONS_DIR))
     self.results = results.Results(
         actuals_root=self._actuals_dir,
-        expected_root=self._expectations_dir,
+        expected_root=EXPECTATIONS_DIR,
         generated_images_root=GENERATED_IMAGES_ROOT)
 
   def _result_reloader(self):
     """ If --reload argument was specified, reload results at the appropriate
     interval.
     """
     while self._reload_seconds:
       time.sleep(self._reload_seconds)
       self.update_results()
 
@@ skipping 242 matching lines @@
 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('--editable', action='store_true',
                       help=('Allow HTTP clients to submit new baselines.'))
-  # Deprecated the --expectations-dir option, because once our GM expectations
-  # are maintained within git we will no longer be able to check out and update
-  # them in isolation (in SVN you can update a single directory subtree within
-  # a checkout, but you cannot do that with git).
-  #
-  # In a git world, we will force the user to refer to expectations
-  # within the same checkout as this tool (at the relative path
-  # ../../expectations/gm ).  If they specify the --reload option, we will
-  # periodically run "git pull" on the entire Skia checkout, which will update
-  # the GM expectations along with everything else (such as this script).
-  #
-  # We can still allow --actuals-dir to be specified, though, because the
-  # actual results will continue to be maintained in the skia-autogen
-  # SVN repository.
-  parser.add_argument('--deprecated-expectations-dir',
-                    help=('DEPRECATED due to our transition from SVN to git '
-                          '(formerly known as --expectations-dir).  '
-                          'If you still need this option, contact '
-                          'epoger@google.com as soon as possible.  WAS: '
-                          '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, if combined with --editable.'))
   parser.add_argument('--port', type=int,
                       help=('Which TCP port to listen on for HTTP requests; '
                             'defaults to %(default)s'),
                       default=DEFAULT_PORT)
   parser.add_argument('--reload', type=int,
                       help=('How often (a period in seconds) to update the '
-                            'results.  If specified, both '
-                            'DEPRECATED_EXPECTATIONS_DIR and '
-                            'ACTUAL_DIR will be updated.  '
+                            'results.  If specified, both expected and actual '
+                            'results will be updated.  '
                             'By default, we do not reload at all, and you '
                             'must restart the server to pick up new data.'),
                       default=0)
   args = parser.parse_args()
   global _SERVER
   _SERVER = Server(actuals_dir=args.actuals_dir,
-                   expectations_dir=args.deprecated_expectations_dir,
                    port=args.port, export=args.export, editable=args.editable,
                    reload_seconds=args.reload)
   _SERVER.run()
 
 if __name__ == '__main__':
   main()