Add support for LUCI_CONTEXT.

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 pprint
 import re
 import StringIO
 import sys
 import tempfile
 import time
 import traceback
 
 from . import recipe_api
 from . import recipe_test_api
 from . import stream
 from . import types
 from . import util
 
+from libs import luci_context as luci_ctx
+
 import subprocess42
 
 
 if sys.platform == "win32":
   # Windows has a bad habit of opening a dialog when a console program
   # crashes, rather than just letting it crash.  Therefore, when a
   # program crashes on Windows, we don't find out until the build step
   # times out.  This code prevents the dialog from appearing, so that we
   # find out immediately and don't waste time waiting for a user to
   # close the dialog.
@@ skipping 168 matching lines @@
             'stderr': step_stream,
             'stdin': None,
           }
           for key in handles:
             fileName = getattr(step_config, key)
             if fileName:
               handles[key] = open(fileName, 'rb' if key == 'stdin' else 'wb')
           # The subprocess will inherit and close these handles.
           retcode = self._run_cmd(
               cmd=step_config.cmd, timeout=step_config.timeout, handles=handles,
-              env=step_env, cwd=step_config.cwd)
+              env=step_env, luci_context=rendered_step.config.luci_context,
+              cwd=step_config.cwd)
         except subprocess42.TimeoutExpired as e:
           #FIXME: Make this respect the infra_step argument
           step_stream.set_step_status('FAILURE')
           raise recipe_api.StepTimeout(step_config.name, e.timeout)
         except OSError:
           with step_stream.new_log_stream('exception') as l:
             trace = traceback.format_exc().splitlines()
             for line in trace:
               l.write_line(line)
           step_stream.set_step_status('EXCEPTION')
@@ skipping 75 matching lines @@
       yield 'in dir %s:' % (cwd,)
       for key, value in sorted(step.config._asdict().items()):
         if value is not None:
           yield ' %s: %s' % (key, self._render_step_value(value))
       yield 'full environment:'
       for key, value in sorted(env.items()):
         yield ' %s: %s' % (key, value)
       yield ''
     stream.output_iter(step_stream, gen_step_prelude())
 
-  def _run_cmd(self, cmd, timeout, handles, env, cwd):
+  def _run_cmd(self, cmd, timeout, handles, env, luci_context, cwd):
     """Runs cmd (subprocess-style).
 
     Args:
       cmd: a subprocess-style command list, with command first then args.
       handles: A dictionary from ('stdin', 'stdout', 'stderr'), each value
         being *either* a stream.StreamEngine.Stream or a python file object
         to direct that subprocess's filehandle to.
+      luci_context: full value of LUCI_CONTEXT dict.

[iannucci, 2017/08/04 18:55:50]

Maybe "entire intended value of the LUCI_CONTEXT dict for this step. e.g. if
this is empty, then the step will be run without any LUCI_CONTEXT parameters at
all"

       env: the full environment to run the command in -- this is passed
         unaltered to subprocess.Popen.
       cwd: the working directory of the command.
     """
     fhandles = {}
 
     # If we are given StreamEngine.Streams, map them to PIPE for subprocess.
     # We will manually forward them to their corresponding stream.
     for key in ('stdout', 'stderr'):
       handle = handles.get(key)
       if isinstance(handle, stream.StreamEngine.Stream):
         fhandles[key] = subprocess42.PIPE
       else:
         fhandles[key] = handle
 
     # stdin must be a real handle, if it exists
     fhandles['stdin'] = handles.get('stdin')
 
-    with _modify_lookup_path(env.get('PATH')):
-      proc = subprocess42.Popen(
-          cmd,
-          env=env,
-          cwd=cwd,
-          detached=True,
-          universal_newlines=True,
-          **fhandles)
+    with luci_ctx.replace(luci_context) as path:

[Vadim Sh., 2017/07/29 00:40:55]

no changes here except lines 340-343
Rietveld is too dumb to realize.

+      if path:

[iannucci, 2017/08/04 18:55:50]

nit: I would rename path to luci_ctx_path or something, since this with
statement holds a bunch of lines where 'path' may be ambiguous

+        env = env.copy()
+        env['LUCI_CONTEXT'] = path
 
-    # Safe to close file handles now that subprocess has inherited them.
-    for handle in fhandles.itervalues():
-      if isinstance(handle, file):
-        handle.close()
+      with _modify_lookup_path(env.get('PATH')):
+        proc = subprocess42.Popen(
+            cmd,
+            env=env,
+            cwd=cwd,
+            detached=True,
+            universal_newlines=True,
+            **fhandles)
 
-    outstreams = {}
-    linebufs = {}
+      # Safe to close file handles now that subprocess has inherited them.
+      for handle in fhandles.itervalues():
+        if isinstance(handle, file):
+          handle.close()
 
-    for key in ('stdout', 'stderr'):
-      handle = handles.get(key)
-      if isinstance(handle, stream.StreamEngine.Stream):
-        outstreams[key] = handle
-        linebufs[key] = _streamingLinebuf()
+      outstreams = {}
+      linebufs = {}
 
-    if linebufs:
-      # manually check the timeout, because we poll
-      start_time = time.time()
-      for pipe, data in proc.yield_any(timeout=1):
-        if timeout and time.time() - start_time > timeout:
-          # Don't know the name of the step, so raise this and it'll get caught
-          raise subprocess42.TimeoutExpired(cmd, timeout)
+      for key in ('stdout', 'stderr'):
+        handle = handles.get(key)
+        if isinstance(handle, stream.StreamEngine.Stream):
+          outstreams[key] = handle
+          linebufs[key] = _streamingLinebuf()
 
-        if pipe is None:
-          continue
-        buf = linebufs.get(pipe)
-        if not buf:
-          continue
-        buf.ingest(data)
-        for line in buf.get_buffered():
-          outstreams[pipe].write_line(line)
-    else:
-      proc.wait(timeout)
+      if linebufs:
+        # manually check the timeout, because we poll
+        start_time = time.time()
+        for pipe, data in proc.yield_any(timeout=1):
+          if timeout and time.time() - start_time > timeout:
+            # Don't know the name of the step, so raise this and it'll get caught
+            raise subprocess42.TimeoutExpired(cmd, timeout)
+
+          if pipe is None:
+            continue
+          buf = linebufs.get(pipe)
+          if not buf:
+            continue
+          buf.ingest(data)
+          for line in buf.get_buffered():
+            outstreams[pipe].write_line(line)
+      else:
+        proc.wait(timeout)
 
     return proc.returncode
 
   def _trigger_builds(self, step, trigger_specs):
     assert trigger_specs is not None
     for trig in trigger_specs:
       builder_name = trig.builder_name
       if not builder_name:
         raise ValueError('Trigger spec: builder_name is not set')
 
@@ skipping 441 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