Call `gzip` in subprocess instead of gzipping in Python in http_server.

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 subprocess
+import tempfile
 import threading
-import tempfile
 
 import SimpleHTTPServer
 import SocketServer
 
 _ZERO = datetime.timedelta(0)
 
 
 class UTC_TZINFO(datetime.tzinfo):
   """UTC time zone representation."""
 
   def utcoffset(self, _):
     return _ZERO
 
   def tzname(self, _):
     return "UTC"
 
   def dst(self, _):
      return _ZERO
 
 _UTC = UTC_TZINFO()
 
 
+def _gzip(file_path):
+  """Gzips the given file storing the result in a temporary file.
+
+  Returns:
+    Path to the resulting file.
+  """
+  gzipped_file = tempfile.NamedTemporaryFile(delete=False)
+  try:
+    subprocess.check_call(['gzip', '-c', file_path],
+                          stdout=gzipped_file)
+  except Exception:
+    print ('http_server: call to gzip failed, make sure that '
+           'gzip is installed on the host.')
+    raise
+  gzipped_file.close()
+  return gzipped_file.name
+
+
 class _SilentTCPServer(SocketServer.TCPServer):
   """A TCPServer that won't display any error, unless debugging is enabled. This
   is useful because the client might stop while it is fetching an URL, which
   causes spurious error messages.
   """
   allow_reuse_address = True
 
   def handle_error(self, request, client_address):
     """Override the base class method to have conditional logging."""
     if logging.getLogger().isEnabledFor(logging.DEBUG):
@@ skipping 16 matching lines @@
 
   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
+      self.gzipped_file_name = None
       self.original_file_name = 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 44 matching lines @@
       if os.path.isfile(path):
         self.send_header('Content-Encoding', 'gzip')
         etag = self.get_etag()
         if etag:
           self.send_header('ETag', etag)
           self.send_header('Cache-Control', 'must-revalidate')
 
       return SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
 
     # pylint: disable=W0221
-    def translate_path(self, path, gzipped=True):
+    def translate_path(self, path, gzip=True):
       # Parent translate_path() will strip away the query string and fragment
       # identifier, but also will prepend the cwd to the path. relpath() gives
       # us the relative path back.
       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:
-                if not self.gzipped_file:
-                  self.gzipped_file = tempfile.NamedTemporaryFile(delete=False)
-                  self.original_file_name = candidate
-                  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
+        if not normalized_path.startswith(prefix):
+          continue
+
+        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 gzip:
+              if not self.gzipped_file_name:
+                self.original_file_name = candidate
+                self.gzipped_file_name = _gzip(candidate)
+              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.
       actual_path = self.original_file_name or path
 
       if actual_path.endswith('.dart'):
         return 'application/dart'
       return SimpleHTTPServer.SimpleHTTPRequestHandler.guess_type(self,
                                                                   actual_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)
+      if self.gzipped_file_name:
+        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
@@ skipping 21 matching lines @@
   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 ('  or `fuser -k %d/tcp` terminate it.' % host_port)
     print '---'
     raise