Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1)

Unified Diff: gm/rebaseline_server/server.py

Issue 855003006: delete old things! (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Add makefiles back :( Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « gm/rebaseline_server/rs_fixpypath.py ('k') | gm/rebaseline_server/static/.gitignore » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: gm/rebaseline_server/server.py
diff --git a/gm/rebaseline_server/server.py b/gm/rebaseline_server/server.py
deleted file mode 100755
index 85874eb6667bb1353741e9fbe7b4e07dfc53d125..0000000000000000000000000000000000000000
--- a/gm/rebaseline_server/server.py
+++ /dev/null
@@ -1,967 +0,0 @@
-#!/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 socket
-import subprocess
-import thread
-import threading
-import time
-import urllib
-import urlparse
-
-# Must fix up PYTHONPATH before importing from within Skia
-import rs_fixpypath # pylint: disable=W0611
-
-# Imports from within Skia
-from py.utils import gs_utils
-import buildbot_globals
-import gm_json
-
-# Imports from local dir
-#
-# pylint: disable=C0301
-# Note: we import results under a different name, to avoid confusion with the
-# Server.results() property. See discussion at
-# https://codereview.chromium.org/195943004/diff/1/gm/rebaseline_server/server.py#newcode44
-# pylint: enable=C0301
-import compare_configs
-import compare_rendered_pictures
-import compare_to_expectations
-import download_actuals
-import imagediffdb
-import imagepairset
-import results as results_mod
-import writable_expectations as writable_expectations_mod
-
-
-PATHSPLIT_RE = re.compile('/([^/]+)/(.+)')
-
-# 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'
- }
-
-# Keys that server.py uses to create the toplevel content header.
-# NOTE: Keep these in sync with static/constants.js
-KEY__EDITS__MODIFICATIONS = 'modifications'
-KEY__EDITS__OLD_RESULTS_HASH = 'oldResultsHash'
-KEY__EDITS__OLD_RESULTS_TYPE = 'oldResultsType'
-KEY__LIVE_EDITS__MODIFICATIONS = 'modifications'
-KEY__LIVE_EDITS__SET_A_DESCRIPTIONS = 'setA'
-KEY__LIVE_EDITS__SET_B_DESCRIPTIONS = 'setB'
-
-DEFAULT_ACTUALS_DIR = results_mod.DEFAULT_ACTUALS_DIR
-DEFAULT_GM_SUMMARIES_BUCKET = download_actuals.GM_SUMMARIES_BUCKET
-DEFAULT_JSON_FILENAME = download_actuals.DEFAULT_JSON_FILENAME
-DEFAULT_PORT = 8888
-
-PARENT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
-TRUNK_DIRECTORY = os.path.dirname(os.path.dirname(PARENT_DIRECTORY))
-
-# Directory, relative to PARENT_DIRECTORY, within which the server will serve
-# out static files.
-STATIC_CONTENTS_SUBDIR = 'static'
-# All of the GENERATED_*_SUBDIRS are relative to STATIC_CONTENTS_SUBDIR
-GENERATED_HTML_SUBDIR = 'generated-html'
-GENERATED_IMAGES_SUBDIR = 'generated-images'
-GENERATED_JSON_SUBDIR = 'generated-json'
-
-# Directives associated with various HTTP GET requests.
-GET__LIVE_RESULTS = 'live-results'
-GET__PRECOMPUTED_RESULTS = 'results'
-GET__PREFETCH_RESULTS = 'prefetch'
-GET__STATIC_CONTENTS = 'static'
-
-# Parameters we use within do_GET_live_results() and do_GET_prefetch_results()
-LIVE_PARAM__DOWNLOAD_ONLY_DIFFERING = 'downloadOnlyDifferingImages'
-LIVE_PARAM__SET_A_DIR = 'setADir'
-LIVE_PARAM__SET_A_SECTION = 'setASection'
-LIVE_PARAM__SET_B_DIR = 'setBDir'
-LIVE_PARAM__SET_B_SECTION = 'setBSection'
-
-# How often (in seconds) clients should reload while waiting for initial
-# results to load.
-RELOAD_INTERVAL_UNTIL_READY = 10
-
-_GM_SUMMARY_TYPES = [
- results_mod.KEY__HEADER__RESULTS_FAILURES,
- results_mod.KEY__HEADER__RESULTS_ALL,
-]
-# If --compare-configs is specified, compare these configs.
-CONFIG_PAIRS_TO_COMPARE = [('8888', 'gpu')]
-
-# SKP results that are available to compare.
-#
-# TODO(stephana): We don't actually want to maintain this list of platforms.
-# We are just putting them in here for now, as "convenience" links for testing
-# SKP diffs.
-# Ultimately, we will depend on buildbot steps linking to their own diffs on
-# the shared rebaseline_server instance.
-_SKP_BASE_GS_URL = 'gs://' + buildbot_globals.Get('skp_summaries_bucket')
-_SKP_BASE_REPO_URL = (
- compare_rendered_pictures.REPO_URL_PREFIX + posixpath.join(
- 'expectations', 'skp'))
-_SKP_PLATFORMS = [
- 'Test-Mac10.8-MacMini4.1-GeForce320M-x86_64-Debug',
- 'Test-Ubuntu12-ShuttleA-GTX660-x86-Release',
-]
-
-_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:
- args: the command to run, as a list of arguments
- directory: directory within which to run the command
-
- Returns: stdout, as a string
-
- Raises an Exception if the command failed (exited with nonzero return code).
- """
- logging.debug('_run_command: %s in directory %s' % (args, directory))
- proc = subprocess.Popen(args, cwd=directory,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
- (stdout, stderr) = proc.communicate()
- if proc.returncode is not 0:
- raise Exception('command "%s" failed in dir "%s": %s' %
- (args, directory, stderr))
- return stdout
-
-
-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
- interface). See http://stackoverflow.com/a/166589 """
- sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- sock.connect(('8.8.8.8', 80))
- host = sock.getsockname()[0]
- sock.close()
- return host
-
-
-def _create_index(file_path, config_pairs):
- """Creates an index file linking to all results available from this server.
-
- Prior to https://codereview.chromium.org/215503002 , we had a static
- index.html within our repo. But now that the results may or may not include
- config comparisons, index.html needs to be generated differently depending
- on which results are included.
-
- TODO(epoger): Instead of including raw HTML within the Python code,
- consider restoring the index.html file as a template and using django (or
- similar) to fill in dynamic content.
-
- Args:
- file_path: path on local disk to write index to; any directory components
- of this path that do not already exist will be created
- config_pairs: what pairs of configs (if any) we compare actual results of
- """
- dir_path = os.path.dirname(file_path)
- if not os.path.isdir(dir_path):
- os.makedirs(dir_path)
- with open(file_path, 'w') as file_handle:
- file_handle.write(
- '<!DOCTYPE html><html>'
- '<head><title>rebaseline_server</title></head>'
- '<body><ul>')
-
- if _GM_SUMMARY_TYPES:
- file_handle.write('<li>GM Expectations vs Actuals</li><ul>')
- for summary_type in _GM_SUMMARY_TYPES:
- file_handle.write(
- '\n<li><a href="/{static_directive}/view.html#/view.html?'
- 'resultsToLoad=/{results_directive}/{summary_type}">'
- '{summary_type}</a></li>'.format(
- results_directive=GET__PRECOMPUTED_RESULTS,
- static_directive=GET__STATIC_CONTENTS,
- summary_type=summary_type))
- file_handle.write('</ul>')
-
- if config_pairs:
- file_handle.write(
- '\n<li>Comparing configs within actual GM results</li><ul>')
- for config_pair in config_pairs:
- file_handle.write('<li>%s vs %s:' % config_pair)
- for summary_type in _GM_SUMMARY_TYPES:
- file_handle.write(
- ' <a href="/%s/view.html#/view.html?'
- 'resultsToLoad=/%s/%s/%s-vs-%s_%s.json">%s</a>' % (
- GET__STATIC_CONTENTS, GET__STATIC_CONTENTS,
- GENERATED_JSON_SUBDIR, config_pair[0], config_pair[1],
- summary_type, summary_type))
- file_handle.write('</li>')
- file_handle.write('</ul>')
-
- if _SKP_PLATFORMS:
- file_handle.write('\n<li>Rendered SKPs:<ul>')
- for builder in _SKP_PLATFORMS:
- file_handle.write(
- '\n<li><a href="../live-view.html#live-view.html?%s">' %
- urllib.urlencode({
- LIVE_PARAM__SET_A_SECTION:
- gm_json.JSONKEY_EXPECTEDRESULTS,
- LIVE_PARAM__SET_A_DIR:
- posixpath.join(_SKP_BASE_REPO_URL, builder),
- LIVE_PARAM__SET_B_SECTION:
- gm_json.JSONKEY_ACTUALRESULTS,
- LIVE_PARAM__SET_B_DIR:
- posixpath.join(_SKP_BASE_GS_URL, builder),
- }))
- file_handle.write('expected vs actuals on %s</a></li>' % builder)
- file_handle.write(
- '\n<li><a href="../live-view.html#live-view.html?%s">' %
- urllib.urlencode({
- LIVE_PARAM__SET_A_SECTION:
- gm_json.JSONKEY_ACTUALRESULTS,
- LIVE_PARAM__SET_A_DIR:
- posixpath.join(_SKP_BASE_GS_URL, _SKP_PLATFORMS[0]),
- LIVE_PARAM__SET_B_SECTION:
- gm_json.JSONKEY_ACTUALRESULTS,
- LIVE_PARAM__SET_B_DIR:
- posixpath.join(_SKP_BASE_GS_URL, _SKP_PLATFORMS[1]),
- }))
- file_handle.write('actuals on %s vs %s</a></li>' % (
- _SKP_PLATFORMS[0], _SKP_PLATFORMS[1]))
- file_handle.write('</li>')
-
- file_handle.write('\n</ul></body></html>')
-
-
-class Server(object):
- """ HTTP server for our HTML rebaseline viewer. """
-
- def __init__(self,
- actuals_source,
- actuals_dir=DEFAULT_ACTUALS_DIR,
- json_filename=DEFAULT_JSON_FILENAME,
- port=DEFAULT_PORT, export=False, editable=True,
- reload_seconds=0, config_pairs=None, builder_regex_list=None,
- boto_file_path=None,
- imagediffdb_threads=imagediffdb.DEFAULT_NUM_WORKER_THREADS):
- """
- Args:
- actuals_source: actuals_source.get_builders() ->
- {builder:string -> [ bucket:string, path:string, generation:string ]}
- If None, don't fetch new actual-results files
- at all, just compare to whatever files are already in actuals_dir
- 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
- 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 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.
- imagediffdb_threads: How many threads to spin up within imagediffdb.
- """
- self._actuals_source = actuals_source
- self._actuals_dir = actuals_dir
- self._json_filename = json_filename
- self._port = port
- self._export = export
- self._editable = editable
- self._reload_seconds = reload_seconds
- self._config_pairs = config_pairs or []
- self._builder_regex_list = builder_regex_list
- self.truncate_results = False
-
- if boto_file_path:
- self._gs = gs_utils.GSUtils(boto_file_path=boto_file_path)
- else:
- self._gs = gs_utils.GSUtils()
-
- _create_index(
- file_path=os.path.join(
- PARENT_DIRECTORY, STATIC_CONTENTS_SUBDIR, GENERATED_HTML_SUBDIR,
- "index.html"),
- config_pairs=config_pairs)
-
- # Reentrant lock that must be held whenever updating EITHER of:
- # 1. self._results
- # 2. the expected or actual results on local disk
- self.results_rlock = threading.RLock()
-
- # Create a single ImageDiffDB instance that is used by all our differs.
- self._image_diff_db = imagediffdb.ImageDiffDB(
- gs=self._gs,
- storage_root=os.path.join(
- PARENT_DIRECTORY, STATIC_CONTENTS_SUBDIR,
- GENERATED_IMAGES_SUBDIR),
- num_worker_threads=imagediffdb_threads)
-
- # This will be filled in by calls to update_results()
- self._results = None
-
- @property
- def results(self):
- """ Returns the most recently generated results, or None if we don't have
- any valid results (update_results() has not completed yet). """
- return self._results
-
- @property
- def image_diff_db(self):
- """ Returns reference to our ImageDiffDB object."""
- return self._image_diff_db
-
- @property
- def gs(self):
- """ Returns reference to our GSUtils object."""
- 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):
- """ True iff HTTP clients are allowed to submit new GM baselines.
-
- TODO(epoger): This only pertains to GM baselines; SKP baselines are
- editable whenever expectations vs actuals are shown.
- Once we move the GM baselines to use the same code as the SKP baselines,
- we can delete this property.
- """
- 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
- actuals.
-
- We hold self.results_rlock while we do this, to guarantee that no other
- thread attempts to update either self._results or the underlying files at
- the same time.
-
- Args:
- invalidate: if True, invalidate self._results immediately upon entry;
- otherwise, we will let readers see those results until we
- replace them
- """
- with self.results_rlock:
- if invalidate:
- self._results = None
-
- if self._actuals_source:
- logging.info(
- 'Updating GM result summaries in %s from %s ...'
- % (self._actuals_dir, self._actuals_source.description()))
-
- # Clean out actuals_dir first, in case some builders have gone away
- # since we last ran.
- if os.path.isdir(self._actuals_dir):
- shutil.rmtree(self._actuals_dir)
-
- # Get the list of actuals we care about.
- all_actuals = self._actuals_source.get_builders()
-
- if self._builder_regex_list:
- matching_builders = []
- for builder in all_actuals:
- for regex in self._builder_regex_list:
- if re.match(regex, builder):
- matching_builders.append(builder)
- break # go on to the next builder, no need to try more regexes
- else:
- matching_builders = all_actuals.keys()
-
- # Download the JSON file for each builder we care about.
- #
- # TODO(epoger): When this is a large number of builders, we would be
- # better off downloading them in parallel!
- for builder in matching_builders:
- self._gs.download_file(
- source_bucket=all_actuals[builder].bucket,
- source_path=all_actuals[builder].path,
- source_generation=all_actuals[builder].generation,
- dest_path=os.path.join(self._actuals_dir, builder,
- self._json_filename),
- create_subdirs_if_needed=True)
-
- # 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.
- #
- # Because the Skia repo is hosted using git, and git does not
- # support updating a single directory tree, we have to update the entire
- # repo checkout.
- #
- # Because Skia uses depot_tools, we have to update using "gclient sync"
- # instead of raw git commands.
- #
- # TODO(epoger): Fetch latest expectations in some other way.
- # Eric points out that our official documentation recommends an
- # unmanaged Skia checkout, so "gclient sync" will not bring down updated
- # expectations from origin/master-- you'd have to do a "git pull" of
- # some sort instead.
- # However, the live rebaseline_server at
- # http://skia-tree-status.appspot.com/redirect/rebaseline-server (which
- # is probably the only user of the --reload flag!) uses a managed
- # checkout, so "gclient sync" works in that case.
- # Probably the best idea is to avoid all of this nonsense by fetching
- # updated expectations into a temp directory, and leaving the rest of
- # the checkout alone. This could be done using "git show", or by
- # downloading individual expectation JSON files from
- # skia.googlesource.com .
- if self._reload_seconds:
- logging.info(
- 'Updating expected GM results in %s by syncing Skia repo ...' %
- compare_to_expectations.DEFAULT_EXPECTATIONS_DIR)
- _run_command(['gclient', 'sync'], TRUNK_DIRECTORY)
-
- self._results = compare_to_expectations.ExpectationComparisons(
- image_diff_db=self._image_diff_db,
- actuals_root=self._actuals_dir,
- diff_base_url=posixpath.join(
- os.pardir, STATIC_CONTENTS_SUBDIR, GENERATED_IMAGES_SUBDIR),
- builder_regex_list=self._builder_regex_list)
-
- json_dir = os.path.join(
- PARENT_DIRECTORY, STATIC_CONTENTS_SUBDIR, GENERATED_JSON_SUBDIR)
- if not os.path.isdir(json_dir):
- os.makedirs(json_dir)
-
- for config_pair in self._config_pairs:
- config_comparisons = compare_configs.ConfigComparisons(
- configs=config_pair,
- actuals_root=self._actuals_dir,
- generated_images_root=os.path.join(
- PARENT_DIRECTORY, STATIC_CONTENTS_SUBDIR,
- GENERATED_IMAGES_SUBDIR),
- diff_base_url=posixpath.join(
- os.pardir, GENERATED_IMAGES_SUBDIR),
- builder_regex_list=self._builder_regex_list)
- for summary_type in _GM_SUMMARY_TYPES:
- gm_json.WriteToFile(
- config_comparisons.get_packaged_results_of_type(
- results_type=summary_type),
- os.path.join(
- json_dir, '%s-vs-%s_%s.json' % (
- config_pair[0], config_pair[1], summary_type)))
-
- 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!)
- """
- 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):
- 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)
- # pylint: disable=W0201
- http_server = BaseHTTPServer.HTTPServer(server_address, HTTPRequestHandler)
- 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.
-
- If we see any Exceptions, return a 404. This fixes http://skbug.com/2147
- """
- try:
- logging.debug('do_GET: path="%s"' % self.path)
- if self.path == '' or self.path == '/' or self.path == '/index.html' :
- self.redirect_to('/%s/%s/index.html' % (
- GET__STATIC_CONTENTS, GENERATED_HTML_SUBDIR))
- return
- if self.path == '/favicon.ico' :
- self.redirect_to('/%s/favicon.ico' % GET__STATIC_CONTENTS)
- 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.
- (dispatcher_name, remainder) = PATHSPLIT_RE.match(self.path).groups()
- dispatchers = {
- GET__LIVE_RESULTS: self.do_GET_live_results,
- GET__PRECOMPUTED_RESULTS: self.do_GET_precomputed_results,
- GET__PREFETCH_RESULTS: self.do_GET_prefetch_results,
- GET__STATIC_CONTENTS: self.do_GET_static,
- }
- dispatcher = dispatchers[dispatcher_name]
- dispatcher(remainder)
- except:
- self.send_error(404)
- raise
-
- def do_GET_precomputed_results(self, results_type):
- """ Handle a GET request for part of the precomputed _SERVER.results object.
-
- Args:
- results_type: string indicating which set of results to return;
- must be one of the results_mod.RESULTS_* constants
- """
- logging.debug('do_GET_precomputed_results: sending results of type "%s"' %
- results_type)
- # Since we must make multiple calls to the ExpectationComparisons object,
- # grab a reference to it in case it is updated to point at a new
- # ExpectationComparisons 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
- if results_obj:
- response_dict = results_obj.get_packaged_results_of_type(
- results_type=results_type, reload_seconds=_SERVER.reload_seconds,
- is_editable=_SERVER.is_editable, is_exported=_SERVER.is_exported)
- else:
- now = int(time.time())
- response_dict = {
- imagepairset.KEY__ROOT__HEADER: {
- 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_dir = param_dict[LIVE_PARAM__SET_A_DIR][0]
- setB_dir = param_dict[LIVE_PARAM__SET_B_DIR][0]
- 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])
-
- # If the sets show expectations vs actuals, always show expectations on
- # the left (setA).
- if ((setA_section == gm_json.JSONKEY_ACTUALRESULTS) and
- (setB_section == gm_json.JSONKEY_EXPECTEDRESULTS)):
- setA_dir, setB_dir = setB_dir, setA_dir
- setA_section, setB_section = setB_section, setA_section
-
- # Are we comparing some actuals against expectations stored in the repo?
- # If so, we can allow the user to submit new baselines.
- is_editable = (
- (setA_section == gm_json.JSONKEY_EXPECTEDRESULTS) and
- (setA_dir.startswith(compare_rendered_pictures.REPO_URL_PREFIX)) and
- (setB_section == gm_json.JSONKEY_ACTUALRESULTS))
-
- results_obj = compare_rendered_pictures.RenderedPicturesComparisons(
- setA_dir=setA_dir, setB_dir=setB_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_type=results_mod.KEY__HEADER__RESULTS_ALL,
- is_editable=is_editable))
-
- 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)
- 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)
- 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
- 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_CONTENTS_SUBDIR))
- full_path = os.path.realpath(os.path.join(static_dir, path))
- if full_path.startswith(static_dir):
- self.send_file(full_path)
- else:
- logging.error(
- 'Attempted do_GET_static() of path [%s] outside of static dir [%s]'
- % (full_path, static_dir))
- self.send_error(404)
-
- def do_POST(self):
- """ Handles all POST requests, forwarding them to the appropriate
- do_POST_* dispatcher. """
- # All requests must be of this form:
- # /dispatcher
- # where 'dispatcher' indicates which do_POST_* dispatcher to run.
- logging.debug('do_POST: path="%s"' % self.path)
- normpath = posixpath.normpath(self.path)
- dispatchers = {
- '/edits': self.do_POST_edits,
- '/live-edits': self.do_POST_live_edits,
- }
- try:
- dispatcher = dispatchers[normpath]
- dispatcher()
- except:
- self.send_error(404)
- raise
-
- def do_POST_edits(self):
- """ Handle a POST request with modifications to GM expectations, in this
- format:
-
- {
- KEY__EDITS__OLD_RESULTS_TYPE: 'all', # type of results that the client
- # loaded and then made
- # modifications to
- KEY__EDITS__OLD_RESULTS_HASH: 39850913, # hash of results when the client
- # loaded them (ensures that the
- # client and server apply
- # modifications to the same base)
- KEY__EDITS__MODIFICATIONS: [
- # as needed by compare_to_expectations.edit_expectations()
- ...
- ],
- }
-
- Raises an Exception if there were any problems.
- """
- if not _SERVER.is_editable:
- raise Exception('this server is not running in --editable mode')
-
- content_type = self.headers[_HTTP_HEADER_CONTENT_TYPE]
- if content_type != 'application/json;charset=UTF-8':
- raise Exception('unsupported %s [%s]' % (
- _HTTP_HEADER_CONTENT_TYPE, content_type))
-
- content_length = int(self.headers[_HTTP_HEADER_CONTENT_LENGTH])
- json_data = self.rfile.read(content_length)
- data = json.loads(json_data)
- logging.debug('do_POST_edits: received new GM expectations data [%s]' %
- data)
-
- # Update the results on disk with the information we received from the
- # client.
- # We must hold _SERVER.results_rlock while we do this, to guarantee that
- # no other thread updates expectations (from the Skia repo) while we are
- # updating them (using the info we received from the client).
- with _SERVER.results_rlock:
- oldResultsType = data[KEY__EDITS__OLD_RESULTS_TYPE]
- oldResults = _SERVER.results.get_results_of_type(oldResultsType)
- oldResultsHash = str(hash(repr(
- oldResults[imagepairset.KEY__ROOT__IMAGEPAIRS])))
- if oldResultsHash != data[KEY__EDITS__OLD_RESULTS_HASH]:
- raise Exception('results of type "%s" changed while the client was '
- 'making modifications. The client should reload the '
- 'results and submit the modifications again.' %
- oldResultsType)
- _SERVER.results.edit_expectations(data[KEY__EDITS__MODIFICATIONS])
-
- # Read the updated results back from disk.
- # We can do this in a separate thread; we should return our success message
- # to the UI as soon as possible.
- thread.start_new_thread(_SERVER.update_results, (True,))
- self.send_response(200)
-
- def do_POST_live_edits(self):
- """ Handle a POST request with modifications to SKP expectations, in this
- format:
-
- {
- KEY__LIVE_EDITS__SET_A_DESCRIPTIONS: {
- # setA descriptions from the original data
- },
- KEY__LIVE_EDITS__SET_B_DESCRIPTIONS: {
- # setB descriptions from the original data
- },
- KEY__LIVE_EDITS__MODIFICATIONS: [
- # as needed by writable_expectations.modify()
- ],
- }
-
- Raises an Exception if there were any problems.
- """
- content_type = self.headers[_HTTP_HEADER_CONTENT_TYPE]
- if content_type != 'application/json;charset=UTF-8':
- raise Exception('unsupported %s [%s]' % (
- _HTTP_HEADER_CONTENT_TYPE, content_type))
-
- content_length = int(self.headers[_HTTP_HEADER_CONTENT_LENGTH])
- json_data = self.rfile.read(content_length)
- data = json.loads(json_data)
- logging.debug('do_POST_live_edits: received new GM expectations data [%s]' %
- data)
- with writable_expectations_mod.WritableExpectations(
- data[KEY__LIVE_EDITS__SET_A_DESCRIPTIONS]) as writable_expectations:
- writable_expectations.modify(data[KEY__LIVE_EDITS__MODIFICATIONS])
- diffs = writable_expectations.get_diffs()
- # TODO(stephana): Move to a simpler web framework so we don't have to
- # call these functions. See http://skbug.com/2856 ('rebaseline_server:
- # Refactor server to use a simple web framework')
- self.send_response(200)
- self.send_header('Content-type', 'text/plain')
- self.end_headers()
- self.wfile.write(diffs)
-
- 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)
- self.end_headers()
-
- def send_file(self, path):
- """ Send the contents of the file at this path, with a mimetype based
- on the filename extension.
-
- Args:
- path: path of file whose contents to send to the HTTP client
- """
- # Grab the extension if there is one
- extension = os.path.splitext(path)[1]
- if len(extension) >= 1:
- extension = extension[1:]
-
- # Determine the MIME type of the file from its extension
- mime_type = MIME_TYPE_MAP.get(extension, MIME_TYPE_MAP[''])
-
- # Open the file and send it over HTTP
- if os.path.isfile(path):
- with open(path, 'rb') as sending_file:
- self.send_response(200)
- self.send_header('Content-type', mime_type)
- self.end_headers()
- self.wfile.write(sending_file.read())
- else:
- self.send_error(404)
-
- def send_json_dict(self, json_dict):
- """ Send the contents of this dictionary in JSON format, with a JSON
- 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 _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.
- """
- if section_name not in compare_rendered_pictures.ALLOWED_SECTION_NAMES:
- raise Exception('requested section name "%s" not in allowed list %s' % (
- section_name, compare_rendered_pictures.ALLOWED_SECTION_NAMES))
- return section_name
-
-
-def main():
- logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
- datefmt='%m/%d/%Y %H:%M:%S',
- 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('--boto',
- help=('Path to .boto file giving us credentials to access '
- 'Google Storage buckets. If not specified, we will '
- 'only be able to access public GS buckets (and thus '
- 'won\'t be able to download SKP images).'),
- default='')
- # TODO(epoger): Before https://codereview.chromium.org/310093003 ,
- # when this tool downloaded the JSON summaries from skia-autogen,
- # it had an --actuals-revision the caller could specify to download
- # actual results as of a specific point in time. We should add similar
- # functionality when retrieving the summaries from Google Storage.
- 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 GM baselines; '
- 'SKP baselines can be edited regardless of this '
- 'setting.'))
- 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('--rietveld-issue',
- help=('Download json_filename files from latest trybot'
- 'runs on this codereview.chromium.org issue.'
- 'Overrides --gm-summaries-bucket.'))
- parser.add_argument('--gm-summaries-bucket',
- help=('Google Cloud Storage bucket to download '
- 'JSON_FILENAME files from. '
- 'Defaults to %(default)s ; if set to '
- 'empty string, just compare to actual-results '
- 'already found in ACTUALS_DIR.'),
- default=DEFAULT_GM_SUMMARIES_BUCKET)
- parser.add_argument('--json-filename',
- help=('JSON summary filename to read for each builder; '
- 'defaults to %(default)s.'),
- default=DEFAULT_JSON_FILENAME)
- 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 expected and actual '
- 'results will be updated by running "gclient sync" '
- 'on your Skia checkout as a whole. '
- 'By default, we do not reload at all, and you '
- 'must restart the server to pick up new data.'),
- default=0)
- parser.add_argument('--threads', type=int,
- help=('How many parallel threads we use to download '
- 'images and generate diffs; defaults to '
- '%(default)s'),
- default=imagediffdb.DEFAULT_NUM_WORKER_THREADS)
- parser.add_argument('--truncate', action='store_true',
- help=('FOR TESTING ONLY: truncate the set of images we '
- 'process, to speed up testing.'))
- args = parser.parse_args()
- if args.compare_configs:
- config_pairs = CONFIG_PAIRS_TO_COMPARE
- else:
- config_pairs = None
-
- if args.rietveld_issue:
- actuals_source = download_actuals.RietveldIssueActuals(args.rietveld_issue,
- args.json_filename)
- else:
- actuals_source = download_actuals.TipOfTreeActuals(args.gm_summaries_bucket,
- args.json_filename)
-
- global _SERVER
- _SERVER = Server(actuals_source,
- actuals_dir=args.actuals_dir,
- json_filename=args.json_filename,
- port=args.port, export=args.export, editable=args.editable,
- 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()
« no previous file with comments | « gm/rebaseline_server/rs_fixpypath.py ('k') | gm/rebaseline_server/static/.gitignore » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698