rebaseline_server: only show Pending Approval tab if expectations vs actuals

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 200 matching lines @@
     """
     Args:
       actuals_dir: directory under which we will check out the latest actual
           GM results
       json_filename: basename of the JSON summary file to load for each builder
       gm_summaries_bucket: Google Storage bucket to download json_filename
           files from; if None or '', don't fetch new actual-results files
           at all, just compare to whatever files are already in actuals_dir
       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
+      editable: whether HTTP clients are allowed to submit new GM baselines
+          (SKP baseline modifications are performed using an entirely different
+          mechanism, not affected by this parameter)
       reload_seconds: polling interval with which to check for new results;
           if 0, don't check for new results at all
       config_pairs: List of (string, string) tuples; for each tuple, compare
           actual results of these two configs.  If None or empty,
           don't compare configs at all.
       builder_regex_list: List of regular expressions specifying which builders
           we will process. If None, process all builders.
       boto_file_path: Path to .boto file giving us credentials to access
           Google Storage buckets; if None, we will only be able to access
           public GS buckets.
@@ skipping 54 matching lines @@
     return self._gs
 
   @property
   def is_exported(self):
     """ Returns true iff HTTP clients on other hosts are allowed to access
     this server. """
     return self._export
 
   @property
   def is_editable(self):
-    """ Returns true iff HTTP clients are allowed to submit new baselines. """
+    """ True iff HTTP clients are allowed to submit new GM baselines. """
     return self._editable
 
   @property
   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, invalidate=False):
     """ Create or update self._results, based on the latest expectations and
@@ skipping 210 matching lines @@
               results_mod.KEY__HEADER__SCHEMA_VERSION: (
                   results_mod.VALUE__HEADER__SCHEMA_VERSION),
               results_mod.KEY__HEADER__IS_STILL_LOADING: True,
               results_mod.KEY__HEADER__TIME_UPDATED: now,
               results_mod.KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE: (
                   now + RELOAD_INTERVAL_UNTIL_READY),
           },
       }
     self.send_json_dict(response_dict)
 
+  def _get_live_results_or_prefetch(self, url_remainder, prefetch_only=False):
+    """ Handle a GET request for live-generated image diff data.
+
+    Args:
+      url_remainder: string indicating which image diffs to generate
+      prefetch_only: if True, the user isn't waiting around for results
+    """
+    param_dict = urlparse.parse_qs(url_remainder)
+    download_all_images = (
+        param_dict.get(LIVE_PARAM__DOWNLOAD_ONLY_DIFFERING, [''])[0].lower()
+        not in ['1', 'true'])
+    setA_section = self._validate_summary_section(
+        param_dict.get(LIVE_PARAM__SET_A_SECTION, [None])[0])
+    setB_section = self._validate_summary_section(
+        param_dict.get(LIVE_PARAM__SET_B_SECTION, [None])[0])
+
+    # Is the user in a position to submit new baselines?
+    #
+    # TODO(epoger): For now, we only allow rebaselining if the expectations
+    # are on the left-hand side.  In a coming CL, I would like to automatically
+    # flip the two sides if a user requests setA=actuals, setB=expected.
+    # Right now that is difficult to do, though, because the JSON generated by
+    # RenderedPicturesComparisons doesn't include full setA/setB descriptions,
+    # so the UI has to trust that whatever setA/setB were requested were also
+    # returned.
+    is_rebaselining = ((setA_section == gm_json.JSONKEY_EXPECTEDRESULTS) and
+                       (setB_section == gm_json.JSONKEY_ACTUALRESULTS))
+
+    results_obj = compare_rendered_pictures.RenderedPicturesComparisons(
+        setA_dirs=param_dict[LIVE_PARAM__SET_A_DIR],
+        setB_dirs=param_dict[LIVE_PARAM__SET_B_DIR],
+        setA_section=setA_section, setB_section=setB_section,
+        image_diff_db=_SERVER.image_diff_db,
+        diff_base_url='/static/generated-images',
+        gs=_SERVER.gs, truncate_results=_SERVER.truncate_results,
+        prefetch_only=prefetch_only, download_all_images=download_all_images)
+
+    if prefetch_only:
+      self.send_response(200)
+    else:
+      self.send_json_dict(results_obj.get_packaged_results_of_type(
+          results_mod.KEY__HEADER__RESULTS_ALL, is_editable=is_rebaselining))
+
   def do_GET_live_results(self, url_remainder):
     """ Handle a GET request for live-generated image diff data.
 
     Args:
       url_remainder: string indicating which image diffs to generate
     """
     logging.debug('do_GET_live_results: url_remainder="%s"' % url_remainder)
-    param_dict = urlparse.parse_qs(url_remainder)
-    results_obj = self._call_compare_rendered_pictures(
-        param_dict=param_dict, prefetch_only=False)
-    self.send_json_dict(results_obj.get_packaged_results_of_type(
-        results_mod.KEY__HEADER__RESULTS_ALL))
+    self._get_live_results_or_prefetch(
+        url_remainder=url_remainder, prefetch_only=False)
 
   def do_GET_prefetch_results(self, url_remainder):
     """ Prefetch image diff data for a future do_GET_live_results() call.
 
     Args:
       url_remainder: string indicating which image diffs to generate
     """
     logging.debug('do_GET_prefetch_results: url_remainder="%s"' % url_remainder)
-    param_dict = urlparse.parse_qs(url_remainder)
-    self._call_compare_rendered_pictures(
-        param_dict=param_dict, prefetch_only=True)
-    self.send_response(200)
+    self._get_live_results_or_prefetch(
+        url_remainder=url_remainder, prefetch_only=True)
 
   def do_GET_static(self, path):
     """ Handle a GET request for a file under STATIC_CONTENTS_SUBDIR .
     Only allow serving of files within STATIC_CONTENTS_SUBDIR that is a
     filesystem sibling of this script.
 
     Args:
       path: path to file (within STATIC_CONTENTS_SUBDIR) to retrieve
     """
     # Strip arguments ('?resultsToLoad=all') from the path
@@ skipping 126 matching lines @@
         mimetype.
 
     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 _call_compare_rendered_pictures(self, param_dict, prefetch_only):
-    """Instantiates RenderedPicturesComparisons object to serve a GET request.
-
-    Args:
-      param_dict: dictionary of URL parameters
-      prefetch_only: parameter to pass into RenderedPicturesComparisons
-          constructor
-
-    Returns: a reference to the new RenderedPicturesComparisons object.
-    """
-    download_all_images = (
-        param_dict.get(LIVE_PARAM__DOWNLOAD_ONLY_DIFFERING, [''])[0].lower()
-        not in ['1', 'true'])
-    setA_section = self._validate_summary_section(
-        param_dict.get(LIVE_PARAM__SET_A_SECTION, [None])[0])
-    setB_section = self._validate_summary_section(
-        param_dict.get(LIVE_PARAM__SET_B_SECTION, [None])[0])
-    return compare_rendered_pictures.RenderedPicturesComparisons(
-        setA_dirs=param_dict[LIVE_PARAM__SET_A_DIR],
-        setB_dirs=param_dict[LIVE_PARAM__SET_B_DIR],
-        setA_section=setA_section, setB_section=setB_section,
-        image_diff_db=_SERVER.image_diff_db,
-        diff_base_url='/static/generated-images',
-        gs=_SERVER.gs, truncate_results=_SERVER.truncate_results,
-        prefetch_only=prefetch_only, download_all_images=download_all_images)
-
   def _validate_summary_section(self, section_name):
     """Validates the section we have been requested to read within JSON summary.
 
     Args:
       section_name: which section of the JSON summary file has been requested
 
     Returns: the validated section name
 
     Raises: Exception if an invalid section_name was requested.
     """
@@ skipping 27 matching lines @@
   parser.add_argument('--builders', metavar='BUILDER_REGEX', nargs='+',
                       help=('Only process builders matching these regular '
                             'expressions.  If unspecified, process all '
                             'builders.'))
   parser.add_argument('--compare-configs', action='store_true',
                       help=('In addition to generating differences between '
                             'expectations and actuals, also generate '
                             'differences between these config pairs: '
                             + str(CONFIG_PAIRS_TO_COMPARE)))
   parser.add_argument('--editable', action='store_true',
-                      help=('Allow HTTP clients to submit new baselines.'))
+                      help=('Allow HTTP clients to submit new GM baselines.'))
   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('--gm-summaries-bucket',
                     help=('Google Cloud Storage bucket to download '
                           'JSON_FILENAME files from. '
                           'Defaults to %(default)s ; if set to '
@@ skipping 38 matching lines @@
                    reload_seconds=args.reload, config_pairs=config_pairs,
                    builder_regex_list=args.builders, boto_file_path=args.boto,
                    imagediffdb_threads=args.threads)
   if args.truncate:
     _SERVER.truncate_results = True
   _SERVER.run()
 
 
 if __name__ == '__main__':
   main()