mojo_run: support parallel Android runs of mojo_run.

mojo/devtools/common/devtoolslib/shell_arguments.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.
 
 """Produces configured shell abstractions.
 
 This module knows how to produce a configured shell abstraction based on
 shell_config.ShellConfig.
 """
 
 import os.path
 import sys
 import urlparse
 
 from devtoolslib.android_shell import AndroidShell
 from devtoolslib.linux_shell import LinuxShell
 from devtoolslib.shell_config import ShellConfigurationException
 
 # When spinning up servers for local origins, we want to use predictable ports
 # so that caching works between subsequent runs with the same command line.
 _LOCAL_ORIGIN_PORT = 31840
 _MAPPINGS_BASE_PORT = 31841
 
 
 def _is_web_url(dest):
   return True if urlparse.urlparse(dest).scheme else False
 
 
-def _host_local_url_destination(shell, dest_file, port):
+def _host_local_url_destination(shell, dest_file, port, free_host_port):
   """Starts a local server to host |dest_file|.
 
   Returns:
     Url of the hosted file.
   """
   directory = os.path.dirname(dest_file)
   if not os.path.exists(directory):
     raise ValueError('local path passed as --map-url destination '
                      'does not exist')
-  server_url = shell.serve_local_directory(directory, port)
+  server_url = shell.serve_local_directory(directory, port, free_host_port)
   return server_url + os.path.relpath(dest_file, directory)
 
 
-def _host_local_origin_destination(shell, dest_dir, port):
+def _host_local_origin_destination(shell, dest_dir, port, free_host_port):
   """Starts a local server to host |dest_dir|.
 
   Returns:
     Url of the hosted directory.
   """
-  return shell.serve_local_directory(dest_dir, port)
+  return shell.serve_local_directory(dest_dir, port, free_host_port)
 
 
-def _rewrite(mapping, host_destination_functon, shell, port):
+def _rewrite(mapping, host_destination_functon, shell, port, free_host_port):
   """Takes a mapping given as <src>=<dest> and rewrites the <dest> part to be
   hosted locally using the given function if <dest> is not a web url.
   """
   parts = mapping.split('=')
   if len(parts) != 2:
     raise ValueError('each mapping value should be in format '
                      '"<url>=<url-or-local-path>"')
   if _is_web_url(parts[1]):
     # The destination is a web url, do nothing.
     return mapping
 
   src = parts[0]
-  dest = host_destination_functon(shell, parts[1], port)
+  dest = host_destination_functon(shell, parts[1], port, free_host_port)
   return src + '=' + dest
 
 
-def _apply_mappings(shell, original_arguments, map_urls, map_origins):
+def _apply_mappings(shell, original_arguments, map_urls, map_origins,
+                    free_host_ports):
   """Applies mappings for specified urls and origins. For each local path
   specified as destination a local server will be spawned and the mapping will
   be rewritten accordingly.
 
   Args:
     shell: The shell that is being configured.
     original_arguments: Current list of shell arguments.
     map_urls: List of url mappings, each in the form of
-      <url>=<url-or-local-path>.
+        <url>=<url-or-local-path>.
     map_origins: List of origin mappings, each in the form of
         <origin>=<url-or-local-path>.
 
   Returns:
     The updated argument list.
   """
   next_port = _MAPPINGS_BASE_PORT
   args = original_arguments
   if map_urls:
     # Sort the mappings to preserve caching regardless of argument order.
     for map_url in sorted(map_urls):
-      mapping = _rewrite(map_url, _host_local_url_destination, shell, next_port)
+      mapping = _rewrite(map_url, _host_local_url_destination, shell, next_port,
+                         free_host_ports)
       next_port += 1
       # All url mappings need to be coalesced into one shell argument.
       args = append_to_argument(args, '--url-mappings=', mapping)
 
   if map_origins:
     for map_origin in sorted(map_origins):
       mapping = _rewrite(map_origin, _host_local_origin_destination, shell,
-                         next_port)
+                         next_port, free_host_ports)
       next_port += 1
       # Origin mappings are specified as separate, repeated shell arguments.
       args.append('--map-origin=' + mapping)
   return args
 
 
-def configure_local_origin(shell, local_dir, fixed_port=True):

[qsr, 2015/10/14 07:35:39]

Was someone using this? If no, no problem, but otherwise you changed the
behavior => previously, fixed_port=False would have changed the port on the
device too...

[ppi, 2015/10/14 16:53:19]

According to git grep, no-one was using this.

+def configure_local_origin(shell, local_dir, free_host_port):
   """Sets up a local http server to serve files in |local_dir| along with
   device port forwarding if needed.
 
   Returns:
     The list of arguments to be appended to the shell argument list.
   """
 
   origin_url = shell.serve_local_directory(
-      local_dir, _LOCAL_ORIGIN_PORT if fixed_port else 0)
+      local_dir, _LOCAL_ORIGIN_PORT, free_host_port)
   return ["--origin=" + origin_url]
 
 
 def append_to_argument(arguments, key, value, delimiter=","):
   """Looks for an argument of the form "key=val1,val2" within |arguments| and
   appends |value| to it.
 
   If the argument is not present in |arguments| it is added.
 
   Args:
@@ skipping 13 matching lines @@
     if not argument.startswith(key):
       continue
     arguments[i] = argument + delimiter + value
     break
   else:
     arguments.append(key + value)
 
   return arguments
 
 
-def _configure_dev_server(shell, shell_args, dev_server_config, verbose):
+def _configure_dev_server(shell, shell_args, dev_server_config, free_host_port,
+                          verbose):
   """Sets up a dev server on the host according to |dev_server_config|.
 
   Args:
     shell: The shell that is being configured.
     shell_arguments: Current list of shell arguments.
     dev_server_config: Instance of shell_config.DevServerConfig describing the
         dev server to be set up.
 
   Returns:
     The updated argument list.
   """
   port = dev_server_config.port if dev_server_config.port else 0
   server_url = shell.serve_local_directories(dev_server_config.mappings,
-                                             port=port)
+                                             port=port,
+                                             free_host_port=free_host_port)
   shell_args.append('--map-origin=%s=%s' % (dev_server_config.host, server_url))
 
   if verbose:
     print "Configured %s locally at %s to serve:" % (dev_server_config.host,
                                                      server_url)
     for mapping_prefix, mapping_path in dev_server_config.mappings:
       print "  /%s -> %s" % (mapping_prefix, mapping_path)
   return shell_args
 
 
@@ skipping 30 matching lines @@
       shell.install_apk(shell_config.shell_path)
   else:
     if not shell_config.shell_path:
       raise ShellConfigurationException('Can not run without a shell binary. '
                                         'Please pass --shell-path.')
     shell = LinuxShell(shell_config.shell_path)
     if shell_config.use_osmesa:
       shell_args.append('--args-for=mojo:native_viewport_service --use-osmesa')
 
   shell_args = _apply_mappings(shell, shell_args, shell_config.map_url_list,
-                               shell_config.map_origin_list)
+                               shell_config.map_origin_list,
+                               shell_config.free_host_ports)
 
   if shell_config.origin:
     if _is_web_url(shell_config.origin):
       shell_args.append('--origin=' + shell_config.origin)
     else:
       shell_args.extend(configure_local_origin(shell, shell_config.origin,
-                                               fixed_port=True))
+                                               shell_config.free_host_ports))
 
   if shell_config.content_handlers:
     for (mime_type,
          content_handler_url) in shell_config.content_handlers.iteritems():
       shell_args = append_to_argument(shell_args, '--content-handlers=',
                                       '%s,%s' % (mime_type,
                                                  content_handler_url))
 
   for dev_server_config in shell_config.dev_servers:
     shell_args = _configure_dev_server(shell, shell_args, dev_server_config,
+                                       shell_config.free_host_ports,
                                        shell_config.verbose)
 
   return shell, shell_args