Devtools: gzip the file being served using a temporary file.

mojo/devtools/common/devtoolslib/http_server.py

 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import atexit
 import datetime
 import email.utils
 import errno
 import gzip
 import hashlib
 import logging
 import math
 import os.path
 import shutil
 import socket
 import threading
+import tempfile
 
 import SimpleHTTPServer
 import SocketServer
 
 _ZERO = datetime.timedelta(0)
 
 
 class UTC_TZINFO(datetime.tzinfo):
   """UTC time zone representation."""
 
@@ skipping 32 matching lines @@
         The first matching prefix and the first location that contains the
         requested file will be used each time.
   """
   for prefix, _ in mappings:
     assert not prefix.startswith('/'), ('Prefixes for the http server mappings '
                                         'should skip the leading slash.')
 
   class RequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
     """Handler for SocketServer.TCPServer that will serve the files from
     local directiories over http.
+
+    A new instance is created for each request.
     """
 
     def __init__(self, *args, **kwargs):
       self.etag = None
+      self.gzipped_file = None
       SimpleHTTPServer.SimpleHTTPRequestHandler.__init__(self, *args, **kwargs)
 
     def get_etag(self):
       if self.etag:
         return self.etag
 
       path = self.translate_path(self.path, False)
       if not os.path.isfile(path):
         return None
 
@@ skipping 57 matching lines @@
       normalized_path = os.path.relpath(
           SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path(self, path))
 
       for prefix, local_base_path_list in mappings:
         if normalized_path.startswith(prefix):
           for local_base_path in local_base_path_list:
             candidate = os.path.join(local_base_path,
                                      normalized_path[len(prefix):])
             if os.path.isfile(candidate):
               if gzipped:
-                gz_result = candidate + '.gz'
-                if (not os.path.isfile(gz_result) or
-                    os.path.getmtime(gz_result) <= os.path.getmtime(candidate)):
-                  with open(candidate, 'rb') as f:
-                    with gzip.open(gz_result, 'wb') as zf:
-                      shutil.copyfileobj(f, zf)
-                return gz_result
+                if not self.gzipped_file:
+                  self.gzipped_file = tempfile.NamedTemporaryFile(delete=False)
+                  with open(candidate, 'rb') as source:
+                    with gzip.GzipFile(fileobj=self.gzipped_file) as target:
+                      shutil.copyfileobj(source, target)
+                  self.gzipped_file.close()
+                return self.gzipped_file.name
               return candidate
           else:
             self.send_response(404)
             return None
       self.send_response(404)
       return None
 
     def guess_type(self, path):
       # This is needed so that exploded Sky apps without shebang can still run
       # thanks to content-type mappings.
       # TODO(ppi): drop this part once we can rely on the Sky files declaring
       # correct shebang.
       if path.endswith('.dart') or path.endswith('.dart.gz'):
         return 'application/dart'
       return SimpleHTTPServer.SimpleHTTPRequestHandler.guess_type(self, path)
 
     def log_message(self, *_):
       """Override the base class method to disable logging."""
       pass
 
+    def __del__(self):
+      if self.gzipped_file:
+        os.remove(self.gzipped_file.name)
+
   RequestHandler.protocol_version = 'HTTP/1.1'
   return RequestHandler
 
 
 def start_http_server(mappings, host_port=0):
   """Starts an http server serving files from |local_dir_path| on |host_port|.
 
   Args:
     mappings: List of tuples (prefix, local_base_path_list) mapping URLs that
         start with |prefix| to one or more local directories enumerated in
@@ skipping 19 matching lines @@
     return httpd.server_address
   except socket.error as v:
     error_code = v[0]
     print 'Failed to start http server for %s on port %d: %s.' % (
         str(mappings), host_port, os.strerror(error_code))
     if error_code == errno.EADDRINUSE:
       print ('  Run `fuser %d/tcp` to find out which process is using the port.'
              % host_port)
     print '---'
     raise