Support mapping multiple local paths under the same url prefix.

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
@@ skipping 35 matching lines @@
   def handle_error(self, request, client_address):
     """Override the base class method to have conditional logging."""
     if logging.getLogger().isEnabledFor(logging.DEBUG):
       SocketServer.TCPServer.handle_error(self, request, client_address)
 
 
 def _get_handler_class_for_path(mappings):
   """Creates a handler override for SimpleHTTPServer.
 
   Args:
-    mappings: List of tuples (prefix, local_base_path), mapping path prefixes
-        without the leading slash to local filesystem directory paths. The first
-        matching prefix will be used each time.
+    mappings: List of tuples (prefix, local_base_path_list) mapping URLs that
+        start with |prefix| to one or more local directories enumerated in
+        |local_base_path_list|. The prefixes should skip the leading slash.
+        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.
     """
 
@@ skipping 62 matching lines @@
       return SimpleHTTPServer.SimpleHTTPRequestHandler.end_headers(self)
 
     # pylint: disable=W0221
     def translate_path(self, path, gzipped=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 in mappings:
+      for prefix, local_base_path_list in mappings:
         if normalized_path.startswith(prefix):
-          result = os.path.join(local_base_path, normalized_path[len(prefix):])
-          if os.path.isfile(result):
-            if gzipped:
-              gz_result = result + '.gz'
-              if (not os.path.isfile(gz_result) or
-                  os.path.getmtime(gz_result) <= os.path.getmtime(result)):
-                with open(result, 'rb') as f:
-                  with gzip.open(gz_result, 'wb') as zf:
-                    shutil.copyfileobj(f, zf)
-              result = gz_result
-          return result
-
-      # This class is only used internally, and we're adding a catch-all ''
-      # prefix at the end of |mappings|.
-      assert False
+          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
+              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
 
   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) mapping
-        URLs that start with |prefix| to local directory at |local_base_path|.
-        The prefixes should skip the leading slash. The first matching prefix
-        will be used each time.
+    mappings: List of tuples (prefix, local_base_path_list) mapping URLs that
+        start with |prefix| to one or more local directories enumerated in
+        |local_base_path_list|. The prefixes should skip the leading slash.
+        The first matching prefix and the first location that contains the
+        requested file will be used each time.
     host_port: Port on the host machine to run the server on. Pass 0 to use a
         system-assigned port.
 
   Returns:
     Tuple of the server address and the port on which it runs.
   """
   assert mappings
   handler_class = _get_handler_class_for_path(mappings)
 
   try:
     httpd = _SilentTCPServer(('127.0.0.1', host_port), handler_class)
     atexit.register(httpd.shutdown)
 
     http_thread = threading.Thread(target=httpd.serve_forever)
     http_thread.daemon = True
     http_thread.start()
     print 'Started http://%s:%d to host %s.' % (httpd.server_address[0],
                                                 httpd.server_address[1],
                                                 str(mappings))
     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