[step_runner] add logic to resolve absolute path of argv[0] on windows.

recipe_engine/step_runner.py

 # Copyright 2016 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import calendar
 import collections
 import contextlib
 import datetime
+import itertools
 import json
 import os
 import re
 import StringIO
 import sys
 import tempfile
 import time
 import traceback
 
 from . import recipe_api
@@ skipping 150 matching lines @@
         def stream(inner):
           return step_stream
 
       return EmptyOpenStep()
 
     rendered_step = render_step(
         step_config, recipe_test_api.DisabledTestData()
     )
     step_config = None # Make sure we use rendered step config.
 
-    rendered_step = rendered_step._replace(
-        config=rendered_step.config._replace(
-            cmd=map(str, rendered_step.config.cmd),
-        ),
-    )
-
     step_env = _merge_envs(os.environ, (rendered_step.config.env or {}))
+    # Now that the step's environment is all sorted, evaluate PATH on windows
+    # to find the actual intended executable.
+    rendered_step = _hunt_path(rendered_step, step_env)
     self._print_step(step_stream, rendered_step, step_env)
 
     class ReturnOpenStep(OpenStep):
       def run(inner):
         step_config = rendered_step.config
         try:
           # Open file handles for IO redirection based on file names in
           # step_config.
           handles = {
             'stdout': step_stream,
@@ skipping 337 matching lines @@
         # This assert ensures that:
         #   no two placeholders have the same name
         #   at most one placeholder has the default name
         assert item.name not in output_phs[module_name][placeholder_name], (
             'Step "%s" has multiple output placeholders of %s.%s. Please '
             'specify explicit and different names for them.' % (
               step_config.name, module_name, placeholder_name))
         output_phs[module_name][placeholder_name][item.name] = (item, tdata)
     else:
       new_cmd.append(item)
-  step_config = step_config._replace(cmd=new_cmd)
+  step_config = step_config._replace(cmd=map(str, new_cmd))
 
   # Process 'stdout', 'stderr' and 'stdin' placeholders, if given.
   stdio_placeholders = {}
   for key in ('stdout', 'stderr', 'stdin'):
     placeholder = getattr(step_config, key)
     tdata = None
     if placeholder:
       if key == 'stdin':
         assert isinstance(placeholder, util.InputPlaceholder), (
             '%s(%r) should be an InputPlaceholder.' % (key, placeholder))
@@ skipping 90 matching lines @@
     return result
   for k, v in override.items():
     if v is None:
       if k in result:
         del result[k]
     else:
       result[str(k)] = str(v) % original
   return result
 
 
+if sys.platform == "win32":
+  _hunt_path_exts = ('.exe', '.bat')
+  def _hunt_path(rendered_step, step_env):
+    """This takes the lazy cross-product of PATH and ('.exe', '.bat') to find
+    what cmd.exe would have found for the command if we used shell=True.
+
+    This must be called on the render_step AFTER _merge_envs has produced
+    step_env to pick up any changes to PATH.
+
+    If it succeeds, it returns a new rendered_step. If it fails, it returns the
+    same rendered_step, and subprocess will run as normal (and likely fail).
+
+    This will not attempt to do any evaluations for commands where the program
+    already has an explicit extension (.exe, .bat, etc.), and it will not
+    attempt to do any evaluations for commands where the program is an absolute
+    path.
+
+    This DOES NOT use PATHEXT to keep the recipe engine's behavior as
+    predictable as possible. We don't currently rely on any other runnable
+    extensions besides these two, and when we could, we choose to explicitly
+    invoke the interpreter (e.g. python.exe, cscript.exe, etc.).
+    """
+    cmd = rendered_step.config.cmd
+    cmd0 = cmd[0]
+    if '.' in cmd0:  # something.ext will work fine with subprocess.
+      return rendered_step
+    if os.path.isabs(cmd0):  # PATH isn't even used
+      return rendered_step
+
+    # begin the hunt
+    paths = step_env.get('PATH', '').split(os.pathsep)
+    if not paths:
+      return rendered_step
+
+    # try every extension for each path
+    for path, ext in itertools.product(paths, _hunt_path_exts):
+      candidate = os.path.join(path, cmd0+ext)
+      if os.path.isfile(candidate):
+        return rendered_step._replace(
+          config=rendered_step.config._replace(
+            cmd=[candidate]+cmd[1:],
+          ),
+        )
+    return rendered_step
+else:
+  def _hunt_path(rendered_step, _step_env):
+    return rendered_step
+
+
 def _shell_quote(arg):
   """Shell-quotes a string with minimal noise.
 
   Such that it is still reproduced exactly in a bash/zsh shell.
   """
 
   arg = arg.encode('utf-8')
 
   if arg == '':
     return "''"
@@ skipping 15 matching lines @@
   supplied command, and only uses the |env| kwarg for modifying the environment
   of the child process.
   """
   saved_path = os.environ['PATH']
   try:
     if path is not None:
       os.environ['PATH'] = path
     yield
   finally:
     os.environ['PATH'] = saved_path