tools/skpdiff/skpdiff_server.py - skia - Git at Google

 #!/usr/bin/python
 # -*- coding: utf-8 -*-

 from __future__ import print_function
 import argparse
 import BaseHTTPServer
 import json
 import os
 import os.path
 import re
 import subprocess
 import sys
 import tempfile
 import urllib2

 # Grab the script path because that is where all the static assets are
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

 # Find the tools directory for python imports
 TOOLS_DIR = os.path.dirname(SCRIPT_DIR)

 # Find the root of the skia trunk for finding skpdiff binary
 SKIA_ROOT_DIR = os.path.dirname(TOOLS_DIR)

 # Find the default location of gm expectations
 DEFAULT_GM_EXPECTATIONS_DIR = os.path.join(SKIA_ROOT_DIR, 'expectations', 'gm')

 # Imports from within Skia
 if TOOLS_DIR not in sys.path:
     sys.path.append(TOOLS_DIR)
 GM_DIR = os.path.join(SKIA_ROOT_DIR, 'gm')
 if GM_DIR not in sys.path:
     sys.path.append(GM_DIR)
 import gm_json
 import jsondiff

 # 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'
                  }


 IMAGE_FILENAME_RE = re.compile(gm_json.IMAGE_FILENAME_PATTERN)

 SKPDIFF_INVOKE_FORMAT = '{} --jsonp=false -o {} -f {} {}'


 def get_skpdiff_path(user_path=None):
     """Find the skpdiff binary.

     @param user_path If none, searches in Release and Debug out directories of
            the skia root. If set, checks that the path is a real file and
            returns it.
     """
     skpdiff_path = None
     possible_paths = []

     # Use the user given path, or try out some good default paths.
     if user_path:
         possible_paths.append(user_path)
     else:
         possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
                                            'Release', 'skpdiff'))
         possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
                                            'Release', 'skpdiff.exe'))
         possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
                                            'Debug', 'skpdiff'))
         possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
                                            'Debug', 'skpdiff.exe'))
     # Use the first path that actually points to the binary
     for possible_path in possible_paths:
         if os.path.isfile(possible_path):
             skpdiff_path = possible_path
             break

     # If skpdiff was not found, print out diagnostic info for the user.
     if skpdiff_path is None:
         print('Could not find skpdiff binary. Either build it into the ' +
               'default directory, or specify the path on the command line.')
         print('skpdiff paths tried:')
         for possible_path in possible_paths:
             print('   ', possible_path)
     return skpdiff_path


 def download_file(url, output_path):
     """Download the file at url and place it in output_path"""
     reader = urllib2.urlopen(url)
     with open(output_path, 'wb') as writer:
         writer.write(reader.read())


 def download_gm_image(image_name, image_path, hash_val):
     """Download the gm result into the given path.

     @param image_name The GM file name, for example imageblur_gpu.png.
     @param image_path Path to place the image.
     @param hash_val   The hash value of the image.
     """
     if hash_val is None:
         return

     # Separate the test name from a image name
     image_match = IMAGE_FILENAME_RE.match(image_name)
     test_name = image_match.group(1)

     # Calculate the URL of the requested image
     image_url = gm_json.CreateGmActualUrl(
         test_name, gm_json.JSONKEY_HASHTYPE_BITMAP_64BITMD5, hash_val)

     # Download the image as requested
     download_file(image_url, image_path)


 def get_image_set_from_skpdiff(skpdiff_records):
     """Get the set of all images references in the given records.

     @param skpdiff_records An array of records, which are dictionary objects.
     """
     expected_set = frozenset([r['baselinePath'] for r in skpdiff_records])
     actual_set = frozenset([r['testPath'] for r in skpdiff_records])
     return expected_set | actual_set


 def set_expected_hash_in_json(expected_results_json, image_name, hash_value):
     """Set the expected hash for the object extracted from
     expected-results.json. Note that this only work with bitmap-64bitMD5 hash
     types.

     @param expected_results_json The Python dictionary with the results to
     modify.
     @param image_name            The name of the image to set the hash of.
     @param hash_value            The hash to set for the image.
     """
     expected_results = expected_results_json[gm_json.JSONKEY_EXPECTEDRESULTS]

     if image_name in expected_results:
         expected_results[image_name][gm_json.JSONKEY_EXPECTEDRESULTS_ALLOWEDDIGESTS][0][1] = hash_value
     else:
         expected_results[image_name] = {
             gm_json.JSONKEY_EXPECTEDRESULTS_ALLOWEDDIGESTS:
             [
                 [
                     gm_json.JSONKEY_HASHTYPE_BITMAP_64BITMD5,
                     hash_value
                 ]
             ]
         }


 def get_head_version(path):
     """Get the version of the file at the given path stored inside the HEAD of
     the git repository. It is returned as a string.

     @param path The path of the file whose HEAD is returned. It is assumed the
     path is inside a git repo rooted at SKIA_ROOT_DIR.
     """

     # git-show will not work with absolute paths. This ensures we give it a path
     # relative to the skia root. This path also has to use forward slashes, even
     # on windows.
     git_path = os.path.relpath(path, SKIA_ROOT_DIR).replace('\\', '/')
     git_show_proc = subprocess.Popen(['git', 'show', 'HEAD:' + git_path],
                                      stdout=subprocess.PIPE)

     # When invoked outside a shell, git will output the last committed version
     # of the file directly to stdout.
     git_version_content, _ = git_show_proc.communicate()
     return git_version_content


 class GMInstance:
     """Information about a GM test result on a specific device:
      - device_name = the name of the device that rendered it
      - image_name = the GM test name and config
      - expected_hash = the current expected hash value
      - actual_hash = the actual hash value
      - is_rebaselined = True if actual_hash is what is currently in the expected
                         results file, False otherwise.
     """
     def __init__(self,
                  device_name, image_name,
                  expected_hash, actual_hash,
                  is_rebaselined):
         self.device_name = device_name
         self.image_name = image_name
         self.expected_hash = expected_hash
         self.actual_hash = actual_hash
         self.is_rebaselined = is_rebaselined


 class ExpectationsManager:
     def __init__(self, expectations_dir, expected_name, updated_name,
                  skpdiff_path):
         """
         @param expectations_dir   The directory to traverse for results files.
                This should resemble expectations/gm in the Skia trunk.
         @param expected_name      The name of the expected result files. These
                are in the format of expected-results.json.
         @param updated_name       The name of the updated expected result files.
                Normally this matches --expectations-filename-output for the
                rebaseline.py tool.
         @param skpdiff_path       The path used to execute the skpdiff command.
         """
         self._expectations_dir = expectations_dir
         self._expected_name = expected_name
         self._updated_name = updated_name
         self._skpdiff_path = skpdiff_path
         self._generate_gm_comparison()

     def _generate_gm_comparison(self):
         """Generate all the data needed to compare GMs:
            - determine which GMs changed
            - download the changed images
            - compare them with skpdiff
         """

         # Get the expectations and compare them with actual hashes
         self._get_expectations()


         # Create a temporary file tree that makes sense for skpdiff to operate
         # on. We take the realpath of the new temp directory because some OSs
         # (*cough* osx) put the temp directory behind a symlink that gets
         # resolved later down the pipeline and breaks the image map.
         image_output_dir = os.path.realpath(tempfile.mkdtemp('skpdiff'))
         expected_image_dir = os.path.join(image_output_dir, 'expected')
         actual_image_dir = os.path.join(image_output_dir, 'actual')
         os.mkdir(expected_image_dir)
         os.mkdir(actual_image_dir)

         # Download expected and actual images that differed into the temporary
         # file tree.
         self._download_expectation_images(expected_image_dir, actual_image_dir)

         # Invoke skpdiff with our downloaded images and place its results in the
         # temporary directory.
         self._skpdiff_output_path = os.path.join(image_output_dir,
                                                 'skpdiff_output.json')
         skpdiff_cmd = SKPDIFF_INVOKE_FORMAT.format(self._skpdiff_path,
                                                    self._skpdiff_output_path,
                                                    expected_image_dir,
                                                    actual_image_dir)
         os.system(skpdiff_cmd)
         self._load_skpdiff_output()


     def _get_expectations(self):
         """Fills self._expectations with GMInstance objects for each test whose
         expectation is different between the following two files:
          - the local filesystem's updated results file
          - git's head version of the expected results file
         """
         differ = jsondiff.GMDiffer()
         self._expectations = []
         for root, dirs, files in os.walk(self._expectations_dir):
             for expectation_file in files:
                 # There are many files in the expectations directory. We only
                 # care about expected results.
                 if expectation_file != self._expected_name:
                     continue

                 # Get the name of the results file, and be sure there is an
                 # updated result to compare against. If there is not, there is
                 # no point in diffing this device.
                 expected_file_path = os.path.join(root, self._expected_name)
                 updated_file_path = os.path.join(root, self._updated_name)
                 if not os.path.isfile(updated_file_path):
                     continue

                 # Always get the expected results from git because we may have
                 # changed them in a previous instance of the server.
                 expected_contents = get_head_version(expected_file_path)
                 updated_contents = None
                 with open(updated_file_path, 'rb') as updated_file:
                     updated_contents = updated_file.read()

                 # Read the expected results on disk to determine what we've
                 # already rebaselined.
                 commited_contents = None
                 with open(expected_file_path, 'rb') as expected_file:
                     commited_contents = expected_file.read()

                 # Find all expectations that did not match.
                 expected_diff = differ.GenerateDiffDictFromStrings(
                     expected_contents,
                     updated_contents)

                 # Generate a set of images that have already been rebaselined
                 # onto disk.
                 rebaselined_diff = differ.GenerateDiffDictFromStrings(
                     expected_contents,
                     commited_contents)

                 rebaselined_set = set(rebaselined_diff.keys())

                 # The name of the device corresponds to the name of the folder
                 # we are in.
                 device_name = os.path.basename(root)

                 # Store old and new versions of the expectation for each GM
                 for image_name, hashes in expected_diff.iteritems():
                     self._expectations.append(
                         GMInstance(device_name, image_name,
                                    hashes['old'], hashes['new'],
                                    image_name in rebaselined_set))

     def _load_skpdiff_output(self):
         """Loads the results of skpdiff and annotates them with whether they
         have already been rebaselined or not. The resulting data is store in
         self.skpdiff_records."""
         self.skpdiff_records = None
         with open(self._skpdiff_output_path, 'rb') as skpdiff_output_file:
             self.skpdiff_records = json.load(skpdiff_output_file)['records']
             for record in self.skpdiff_records:
                 record['isRebaselined'] = self.image_map[record['baselinePath']][1].is_rebaselined


     def _download_expectation_images(self, expected_image_dir, actual_image_dir):
         """Download the expected and actual images for the _expectations array.

         @param expected_image_dir The directory to download expected images
                into.
         @param actual_image_dir   The directory to download actual images into.
         """
         image_map = {}

         # Look through expectations and download their images.
         for expectation in self._expectations:
             # Build appropriate paths to download the images into.
             expected_image_path = os.path.join(expected_image_dir,
                                                expectation.device_name + '-' +
                                                expectation.image_name)

             actual_image_path = os.path.join(actual_image_dir,
                                              expectation.device_name + '-' +
                                              expectation.image_name)

             print('Downloading %s for device %s' % (
                 expectation.image_name, expectation.device_name))

             # Download images
             download_gm_image(expectation.image_name,
                               expected_image_path,
                               expectation.expected_hash)

             download_gm_image(expectation.image_name,
                               actual_image_path,
                               expectation.actual_hash)

             # Annotate the expectations with where the images were downloaded
             # to.
             expectation.expected_image_path = expected_image_path
             expectation.actual_image_path = actual_image_path

             # Map the image paths back to the expectations.
             image_map[expected_image_path] = (False, expectation)
             image_map[actual_image_path] = (True, expectation)

         self.image_map = image_map

     def _set_expected_hash(self, device_name, image_name, hash_value):
         """Set the expected hash for the image of the given device. This always
         writes directly to the expected results file of the given device

         @param device_name The name of the device to write the hash to.
         @param image_name  The name of the image whose hash to set.
         @param hash_value  The value of the hash to set.
         """

         # Retrieve the expected results file as it is in the working tree
         json_path = os.path.join(self._expectations_dir, device_name,
                                  self._expected_name)
         expectations = gm_json.LoadFromFile(json_path)

         # Set the specified hash.
         set_expected_hash_in_json(expectations, image_name, hash_value)

         # Write it out to disk using gm_json to keep the formatting consistent.
         gm_json.WriteToFile(expectations, json_path)

     def commit_rebaselines(self, rebaselines):
         """Sets the expected results file to use the hashes of the images in
         the rebaselines list. If a expected result image is not in rebaselines
         at all, the old hash will be used.

         @param rebaselines A list of image paths to use the hash of.
         """
         # Reset all expectations to their old hashes because some of them may
         # have been set to the new hash by a previous call to this function.
         for expectation in self._expectations:
             expectation.is_rebaselined = False
             self._set_expected_hash(expectation.device_name,
                                     expectation.image_name,
                                     expectation.expected_hash)

         # Take all the images to rebaseline
         for image_path in rebaselines:
             # Get the metadata about the image at the path.
             is_actual, expectation = self.image_map[image_path]

             expectation.is_rebaselined = is_actual
             expectation_hash = expectation.actual_hash if is_actual else\
                                expectation.expected_hash

             # Write out that image's hash directly to the expected results file.
             self._set_expected_hash(expectation.device_name,
                                     expectation.image_name,
                                     expectation_hash)

         self._load_skpdiff_output()


 class SkPDiffHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     def send_file(self, file_path):
         # Grab the extension if there is one
         extension = os.path.splitext(file_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(file_path):
             with open(file_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 serve_if_in_dir(self, dir_path, file_path):
         # Determine if the file exists relative to the given dir_path AND exists
         # under the dir_path. This is to prevent accidentally serving files
         # outside the directory intended using symlinks, or '../'.
         real_path = os.path.normpath(os.path.join(dir_path, file_path))
         if os.path.commonprefix([real_path, dir_path]) == dir_path:
             if os.path.isfile(real_path):
                 self.send_file(real_path)
                 return True
         return False

     def do_GET(self):
         # Simple rewrite rule of the root path to 'viewer.html'
         if self.path == '' or self.path == '/':
             self.path = '/viewer.html'

         # The [1:] chops off the leading '/'
         file_path = self.path[1:]

         # Handle skpdiff_output.json manually because it is was processed by the
         # server when it was started and does not exist as a file.
         if file_path == 'skpdiff_output.json':
             self.send_response(200)
             self.send_header('Content-type', MIME_TYPE_MAP['json'])
             self.end_headers()

             # Add JSONP padding to the JSON because the web page expects it. It
             # expects it because it was designed to run with or without a web
             # server. Without a web server, the only way to load JSON is with
             # JSONP.
             skpdiff_records = self.server.expectations_manager.skpdiff_records
             self.wfile.write('var SkPDiffRecords = ')
             json.dump({'records': skpdiff_records}, self.wfile)
             self.wfile.write(';')
             return

         # Attempt to send static asset files first.
         if self.serve_if_in_dir(SCRIPT_DIR, file_path):
             return

         # WARNING: Serving any file the user wants is incredibly insecure. Its
         # redeeming quality is that we only serve gm files on a white list.
         if self.path in self.server.image_set:
             self.send_file(self.path)
             return

         # If no file to send was found, just give the standard 404
         self.send_error(404)

     def do_POST(self):
         if self.path == '/commit_rebaselines':
             content_length = int(self.headers['Content-length'])
             request_data = json.loads(self.rfile.read(content_length))
             rebaselines = request_data['rebaselines']
             self.server.expectations_manager.commit_rebaselines(rebaselines)
             self.send_response(200)
             self.send_header('Content-type', 'application/json')
             self.end_headers()
             self.wfile.write('{"success":true}')
             return

         # If the we have no handler for this path, give em' the 404
         self.send_error(404)


 def run_server(expectations_manager, port=8080):
     # It's important to parse the results file so that we can make a set of
     # images that the web page might request.
     skpdiff_records = expectations_manager.skpdiff_records
     image_set = get_image_set_from_skpdiff(skpdiff_records)

     # Do not bind to interfaces other than localhost because the server will
     # attempt to serve files relative to the root directory as a last resort
     # before 404ing. This means all of your files can be accessed from this
     # server, so DO NOT let this server listen to anything but localhost.
     server_address = ('127.0.0.1', port)
     http_server = BaseHTTPServer.HTTPServer(server_address, SkPDiffHandler)
     http_server.image_set = image_set
     http_server.expectations_manager = expectations_manager
     print('Navigate thine browser to: http://{}:{}/'.format(*server_address))
     http_server.serve_forever()


 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--port', '-p', metavar='PORT',
                         type=int,
                         default=8080,
                         help='port to bind the server to; ' +
                         'defaults to %(default)s',
                         )

     parser.add_argument('--expectations-dir', metavar='EXPECTATIONS_DIR',
                         default=DEFAULT_GM_EXPECTATIONS_DIR,
                         help='path to the gm expectations; ' +
                         'defaults to %(default)s'
                         )

     parser.add_argument('--expected',
                         metavar='EXPECTATIONS_FILE_NAME',
                         default='expected-results.json',
                         help='the file name of the expectations JSON; ' +
                         'defaults to %(default)s'
                         )

     parser.add_argument('--updated',
                         metavar='UPDATED_FILE_NAME',
                         default='updated-results.json',
                         help='the file name of the updated expectations JSON;' +
                         ' defaults to %(default)s'
                         )

     parser.add_argument('--skpdiff-path', metavar='SKPDIFF_PATH',
                         default=None,
                         help='the path to the skpdiff binary to use; ' +
                         'defaults to out/Release/skpdiff or out/Default/skpdiff'
                         )

     args = vars(parser.parse_args())  # Convert args into a python dict

     # Make sure we have access to an skpdiff binary
     skpdiff_path = get_skpdiff_path(args['skpdiff_path'])
     if skpdiff_path is None:
         sys.exit(1)

     # Print out the paths of things for easier debugging
     print('script dir         :', SCRIPT_DIR)
     print('tools dir          :', TOOLS_DIR)
     print('root dir           :', SKIA_ROOT_DIR)
     print('expectations dir   :', args['expectations_dir'])
     print('skpdiff path       :', skpdiff_path)

     expectations_manager = ExpectationsManager(args['expectations_dir'],
                                                args['expected'],
                                                args['updated'],
                                                skpdiff_path)

     run_server(expectations_manager, port=args['port'])

 if __name__ == '__main__':
     main()
	#!/usr/bin/python
	# -- coding: utf-8 --

	from __future__ import print_function
	import argparse
	import BaseHTTPServer
	import json
	import os
	import os.path
	import re
	import subprocess
	import sys
	import tempfile
	import urllib2

	# Grab the script path because that is where all the static assets are
	SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

	# Find the tools directory for python imports
	TOOLS_DIR = os.path.dirname(SCRIPT_DIR)

	# Find the root of the skia trunk for finding skpdiff binary
	SKIA_ROOT_DIR = os.path.dirname(TOOLS_DIR)

	# Find the default location of gm expectations
	DEFAULT_GM_EXPECTATIONS_DIR = os.path.join(SKIA_ROOT_DIR, 'expectations', 'gm')

	# Imports from within Skia
	if TOOLS_DIR not in sys.path:
	sys.path.append(TOOLS_DIR)
	GM_DIR = os.path.join(SKIA_ROOT_DIR, 'gm')
	if GM_DIR not in sys.path:
	sys.path.append(GM_DIR)
	import gm_json
	import jsondiff

	# 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'
	}


	IMAGE_FILENAME_RE = re.compile(gm_json.IMAGE_FILENAME_PATTERN)

	SKPDIFF_INVOKE_FORMAT = '{} --jsonp=false -o {} -f {} {}'


	def get_skpdiff_path(user_path=None):
	"""Find the skpdiff binary.

	@param user_path If none, searches in Release and Debug out directories of
	the skia root. If set, checks that the path is a real file and
	returns it.
	"""
	skpdiff_path = None
	possible_paths = []

	# Use the user given path, or try out some good default paths.
	if user_path:
	possible_paths.append(user_path)
	else:
	possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
	'Release', 'skpdiff'))
	possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
	'Release', 'skpdiff.exe'))
	possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
	'Debug', 'skpdiff'))
	possible_paths.append(os.path.join(SKIA_ROOT_DIR, 'out',
	'Debug', 'skpdiff.exe'))
	# Use the first path that actually points to the binary
	for possible_path in possible_paths:
	if os.path.isfile(possible_path):
	skpdiff_path = possible_path
	break

	# If skpdiff was not found, print out diagnostic info for the user.
	if skpdiff_path is None:
	print('Could not find skpdiff binary. Either build it into the ' +
	'default directory, or specify the path on the command line.')
	print('skpdiff paths tried:')
	for possible_path in possible_paths:
	print(' ', possible_path)
	return skpdiff_path


	def download_file(url, output_path):
	"""Download the file at url and place it in output_path"""
	reader = urllib2.urlopen(url)
	with open(output_path, 'wb') as writer:
	writer.write(reader.read())


	def download_gm_image(image_name, image_path, hash_val):
	"""Download the gm result into the given path.

	@param image_name The GM file name, for example imageblur_gpu.png.
	@param image_path Path to place the image.
	@param hash_val The hash value of the image.
	"""
	if hash_val is None:
	return

	# Separate the test name from a image name
	image_match = IMAGE_FILENAME_RE.match(image_name)
	test_name = image_match.group(1)

	# Calculate the URL of the requested image
	image_url = gm_json.CreateGmActualUrl(
	test_name, gm_json.JSONKEY_HASHTYPE_BITMAP_64BITMD5, hash_val)

	# Download the image as requested
	download_file(image_url, image_path)


	def get_image_set_from_skpdiff(skpdiff_records):
	"""Get the set of all images references in the given records.

	@param skpdiff_records An array of records, which are dictionary objects.
	"""
	expected_set = frozenset([r['baselinePath'] for r in skpdiff_records])
	actual_set = frozenset([r['testPath'] for r in skpdiff_records])
	return expected_set \| actual_set


	def set_expected_hash_in_json(expected_results_json, image_name, hash_value):
	"""Set the expected hash for the object extracted from
	expected-results.json. Note that this only work with bitmap-64bitMD5 hash
	types.

	@param expected_results_json The Python dictionary with the results to
	modify.
	@param image_name The name of the image to set the hash of.
	@param hash_value The hash to set for the image.
	"""
	expected_results = expected_results_json[gm_json.JSONKEY_EXPECTEDRESULTS]

	if image_name in expected_results:
	expected_results[image_name][gm_json.JSONKEY_EXPECTEDRESULTS_ALLOWEDDIGESTS][0][1] = hash_value
	else:
	expected_results[image_name] = {
	gm_json.JSONKEY_EXPECTEDRESULTS_ALLOWEDDIGESTS:
	[
	[
	gm_json.JSONKEY_HASHTYPE_BITMAP_64BITMD5,
	hash_value
	]
	]
	}


	def get_head_version(path):
	"""Get the version of the file at the given path stored inside the HEAD of
	the git repository. It is returned as a string.

	@param path The path of the file whose HEAD is returned. It is assumed the
	path is inside a git repo rooted at SKIA_ROOT_DIR.
	"""

	# git-show will not work with absolute paths. This ensures we give it a path
	# relative to the skia root. This path also has to use forward slashes, even
	# on windows.
	git_path = os.path.relpath(path, SKIA_ROOT_DIR).replace('\\', '/')
	git_show_proc = subprocess.Popen(['git', 'show', 'HEAD:' + git_path],
	stdout=subprocess.PIPE)

	# When invoked outside a shell, git will output the last committed version
	# of the file directly to stdout.
	git_version_content, _ = git_show_proc.communicate()
	return git_version_content


	class GMInstance:
	"""Information about a GM test result on a specific device:
	- device_name = the name of the device that rendered it
	- image_name = the GM test name and config
	- expected_hash = the current expected hash value
	- actual_hash = the actual hash value
	- is_rebaselined = True if actual_hash is what is currently in the expected
	results file, False otherwise.
	"""
	def __init__(self,
	device_name, image_name,
	expected_hash, actual_hash,
	is_rebaselined):
	self.device_name = device_name
	self.image_name = image_name
	self.expected_hash = expected_hash
	self.actual_hash = actual_hash
	self.is_rebaselined = is_rebaselined


	class ExpectationsManager:
	def __init__(self, expectations_dir, expected_name, updated_name,
	skpdiff_path):
	"""
	@param expectations_dir The directory to traverse for results files.
	This should resemble expectations/gm in the Skia trunk.
	@param expected_name The name of the expected result files. These
	are in the format of expected-results.json.
	@param updated_name The name of the updated expected result files.
	Normally this matches --expectations-filename-output for the
	rebaseline.py tool.
	@param skpdiff_path The path used to execute the skpdiff command.
	"""
	self._expectations_dir = expectations_dir
	self._expected_name = expected_name
	self._updated_name = updated_name
	self._skpdiff_path = skpdiff_path
	self._generate_gm_comparison()

	def _generate_gm_comparison(self):
	"""Generate all the data needed to compare GMs:
	- determine which GMs changed
	- download the changed images
	- compare them with skpdiff
	"""

	# Get the expectations and compare them with actual hashes
	self._get_expectations()


	# Create a temporary file tree that makes sense for skpdiff to operate
	# on. We take the realpath of the new temp directory because some OSs
	# (cough osx) put the temp directory behind a symlink that gets
	# resolved later down the pipeline and breaks the image map.
	image_output_dir = os.path.realpath(tempfile.mkdtemp('skpdiff'))
	expected_image_dir = os.path.join(image_output_dir, 'expected')
	actual_image_dir = os.path.join(image_output_dir, 'actual')
	os.mkdir(expected_image_dir)
	os.mkdir(actual_image_dir)

	# Download expected and actual images that differed into the temporary
	# file tree.
	self._download_expectation_images(expected_image_dir, actual_image_dir)

	# Invoke skpdiff with our downloaded images and place its results in the
	# temporary directory.
	self._skpdiff_output_path = os.path.join(image_output_dir,
	'skpdiff_output.json')
	skpdiff_cmd = SKPDIFF_INVOKE_FORMAT.format(self._skpdiff_path,
	self._skpdiff_output_path,
	expected_image_dir,
	actual_image_dir)
	os.system(skpdiff_cmd)
	self._load_skpdiff_output()


	def _get_expectations(self):
	"""Fills self._expectations with GMInstance objects for each test whose
	expectation is different between the following two files:
	- the local filesystem's updated results file
	- git's head version of the expected results file
	"""
	differ = jsondiff.GMDiffer()
	self._expectations = []
	for root, dirs, files in os.walk(self._expectations_dir):
	for expectation_file in files:
	# There are many files in the expectations directory. We only
	# care about expected results.
	if expectation_file != self._expected_name:
	continue

	# Get the name of the results file, and be sure there is an
	# updated result to compare against. If there is not, there is
	# no point in diffing this device.
	expected_file_path = os.path.join(root, self._expected_name)
	updated_file_path = os.path.join(root, self._updated_name)
	if not os.path.isfile(updated_file_path):
	continue

	# Always get the expected results from git because we may have
	# changed them in a previous instance of the server.
	expected_contents = get_head_version(expected_file_path)
	updated_contents = None
	with open(updated_file_path, 'rb') as updated_file:
	updated_contents = updated_file.read()

	# Read the expected results on disk to determine what we've
	# already rebaselined.
	commited_contents = None
	with open(expected_file_path, 'rb') as expected_file:
	commited_contents = expected_file.read()

	# Find all expectations that did not match.
	expected_diff = differ.GenerateDiffDictFromStrings(
	expected_contents,
	updated_contents)

	# Generate a set of images that have already been rebaselined
	# onto disk.
	rebaselined_diff = differ.GenerateDiffDictFromStrings(
	expected_contents,
	commited_contents)

	rebaselined_set = set(rebaselined_diff.keys())

	# The name of the device corresponds to the name of the folder
	# we are in.
	device_name = os.path.basename(root)

	# Store old and new versions of the expectation for each GM
	for image_name, hashes in expected_diff.iteritems():
	self._expectations.append(
	GMInstance(device_name, image_name,
	hashes['old'], hashes['new'],
	image_name in rebaselined_set))

	def _load_skpdiff_output(self):
	"""Loads the results of skpdiff and annotates them with whether they
	have already been rebaselined or not. The resulting data is store in
	self.skpdiff_records."""
	self.skpdiff_records = None
	with open(self._skpdiff_output_path, 'rb') as skpdiff_output_file:
	self.skpdiff_records = json.load(skpdiff_output_file)['records']
	for record in self.skpdiff_records:
	record['isRebaselined'] = self.image_map[record['baselinePath']][1].is_rebaselined


	def _download_expectation_images(self, expected_image_dir, actual_image_dir):
	"""Download the expected and actual images for the _expectations array.

	@param expected_image_dir The directory to download expected images
	into.
	@param actual_image_dir The directory to download actual images into.
	"""
	image_map = {}

	# Look through expectations and download their images.
	for expectation in self._expectations:
	# Build appropriate paths to download the images into.
	expected_image_path = os.path.join(expected_image_dir,
	expectation.device_name + '-' +
	expectation.image_name)

	actual_image_path = os.path.join(actual_image_dir,
	expectation.device_name + '-' +
	expectation.image_name)

	print('Downloading %s for device %s' % (
	expectation.image_name, expectation.device_name))

	# Download images
	download_gm_image(expectation.image_name,
	expected_image_path,
	expectation.expected_hash)

	download_gm_image(expectation.image_name,
	actual_image_path,
	expectation.actual_hash)

	# Annotate the expectations with where the images were downloaded
	# to.
	expectation.expected_image_path = expected_image_path
	expectation.actual_image_path = actual_image_path

	# Map the image paths back to the expectations.
	image_map[expected_image_path] = (False, expectation)
	image_map[actual_image_path] = (True, expectation)

	self.image_map = image_map

	def _set_expected_hash(self, device_name, image_name, hash_value):
	"""Set the expected hash for the image of the given device. This always
	writes directly to the expected results file of the given device

	@param device_name The name of the device to write the hash to.
	@param image_name The name of the image whose hash to set.
	@param hash_value The value of the hash to set.
	"""

	# Retrieve the expected results file as it is in the working tree
	json_path = os.path.join(self._expectations_dir, device_name,
	self._expected_name)
	expectations = gm_json.LoadFromFile(json_path)

	# Set the specified hash.
	set_expected_hash_in_json(expectations, image_name, hash_value)

	# Write it out to disk using gm_json to keep the formatting consistent.
	gm_json.WriteToFile(expectations, json_path)

	def commit_rebaselines(self, rebaselines):
	"""Sets the expected results file to use the hashes of the images in
	the rebaselines list. If a expected result image is not in rebaselines
	at all, the old hash will be used.

	@param rebaselines A list of image paths to use the hash of.
	"""
	# Reset all expectations to their old hashes because some of them may
	# have been set to the new hash by a previous call to this function.
	for expectation in self._expectations:
	expectation.is_rebaselined = False
	self._set_expected_hash(expectation.device_name,
	expectation.image_name,
	expectation.expected_hash)

	# Take all the images to rebaseline
	for image_path in rebaselines:
	# Get the metadata about the image at the path.
	is_actual, expectation = self.image_map[image_path]

	expectation.is_rebaselined = is_actual
	expectation_hash = expectation.actual_hash if is_actual else\
	expectation.expected_hash

	# Write out that image's hash directly to the expected results file.
	self._set_expected_hash(expectation.device_name,
	expectation.image_name,
	expectation_hash)

	self._load_skpdiff_output()


	class SkPDiffHandler(BaseHTTPServer.BaseHTTPRequestHandler):
	def send_file(self, file_path):
	# Grab the extension if there is one
	extension = os.path.splitext(file_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(file_path):
	with open(file_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 serve_if_in_dir(self, dir_path, file_path):
	# Determine if the file exists relative to the given dir_path AND exists
	# under the dir_path. This is to prevent accidentally serving files
	# outside the directory intended using symlinks, or '../'.
	real_path = os.path.normpath(os.path.join(dir_path, file_path))
	if os.path.commonprefix([real_path, dir_path]) == dir_path:
	if os.path.isfile(real_path):
	self.send_file(real_path)
	return True
	return False

	def do_GET(self):
	# Simple rewrite rule of the root path to 'viewer.html'
	if self.path == '' or self.path == '/':
	self.path = '/viewer.html'

	# The [1:] chops off the leading '/'
	file_path = self.path[1:]

	# Handle skpdiff_output.json manually because it is was processed by the
	# server when it was started and does not exist as a file.
	if file_path == 'skpdiff_output.json':
	self.send_response(200)
	self.send_header('Content-type', MIME_TYPE_MAP['json'])
	self.end_headers()

	# Add JSONP padding to the JSON because the web page expects it. It
	# expects it because it was designed to run with or without a web
	# server. Without a web server, the only way to load JSON is with
	# JSONP.
	skpdiff_records = self.server.expectations_manager.skpdiff_records
	self.wfile.write('var SkPDiffRecords = ')
	json.dump({'records': skpdiff_records}, self.wfile)
	self.wfile.write(';')
	return

	# Attempt to send static asset files first.
	if self.serve_if_in_dir(SCRIPT_DIR, file_path):
	return

	# WARNING: Serving any file the user wants is incredibly insecure. Its
	# redeeming quality is that we only serve gm files on a white list.
	if self.path in self.server.image_set:
	self.send_file(self.path)
	return

	# If no file to send was found, just give the standard 404
	self.send_error(404)

	def do_POST(self):
	if self.path == '/commit_rebaselines':
	content_length = int(self.headers['Content-length'])
	request_data = json.loads(self.rfile.read(content_length))
	rebaselines = request_data['rebaselines']
	self.server.expectations_manager.commit_rebaselines(rebaselines)
	self.send_response(200)
	self.send_header('Content-type', 'application/json')
	self.end_headers()
	self.wfile.write('{"success":true}')
	return

	# If the we have no handler for this path, give em' the 404
	self.send_error(404)


	def run_server(expectations_manager, port=8080):
	# It's important to parse the results file so that we can make a set of
	# images that the web page might request.
	skpdiff_records = expectations_manager.skpdiff_records
	image_set = get_image_set_from_skpdiff(skpdiff_records)

	# Do not bind to interfaces other than localhost because the server will
	# attempt to serve files relative to the root directory as a last resort
	# before 404ing. This means all of your files can be accessed from this
	# server, so DO NOT let this server listen to anything but localhost.
	server_address = ('127.0.0.1', port)
	http_server = BaseHTTPServer.HTTPServer(server_address, SkPDiffHandler)
	http_server.image_set = image_set
	http_server.expectations_manager = expectations_manager
	print('Navigate thine browser to: http://{}:{}/'.format(*server_address))
	http_server.serve_forever()


	def main():
	parser = argparse.ArgumentParser()
	parser.add_argument('--port', '-p', metavar='PORT',
	type=int,
	default=8080,
	help='port to bind the server to; ' +
	'defaults to %(default)s',
	)

	parser.add_argument('--expectations-dir', metavar='EXPECTATIONS_DIR',
	default=DEFAULT_GM_EXPECTATIONS_DIR,
	help='path to the gm expectations; ' +
	'defaults to %(default)s'
	)

	parser.add_argument('--expected',
	metavar='EXPECTATIONS_FILE_NAME',
	default='expected-results.json',
	help='the file name of the expectations JSON; ' +
	'defaults to %(default)s'
	)

	parser.add_argument('--updated',
	metavar='UPDATED_FILE_NAME',
	default='updated-results.json',
	help='the file name of the updated expectations JSON;' +
	' defaults to %(default)s'
	)

	parser.add_argument('--skpdiff-path', metavar='SKPDIFF_PATH',
	default=None,
	help='the path to the skpdiff binary to use; ' +
	'defaults to out/Release/skpdiff or out/Default/skpdiff'
	)

	args = vars(parser.parse_args()) # Convert args into a python dict

	# Make sure we have access to an skpdiff binary
	skpdiff_path = get_skpdiff_path(args['skpdiff_path'])
	if skpdiff_path is None:
	sys.exit(1)

	# Print out the paths of things for easier debugging
	print('script dir :', SCRIPT_DIR)
	print('tools dir :', TOOLS_DIR)
	print('root dir :', SKIA_ROOT_DIR)
	print('expectations dir :', args['expectations_dir'])
	print('skpdiff path :', skpdiff_path)

	expectations_manager = ExpectationsManager(args['expectations_dir'],
	args['expected'],
	args['updated'],
	skpdiff_path)

	run_server(expectations_manager, port=args['port'])

	if __name__ == '__main__':
	main()