[RFC] terminal: Run command using a wrapper script

Submitted by Tyler Hall on June 30, 2013, 8:16 p.m. | Patch ID: 52701


Message ID 1372623379-13963-1-git-send-email-tylerwhall@gmail.com
State Accepted
Commit 3bb96671e987ce8110ce98b9f6d9efc093f8d20e
Headers show

Commit Message

Tyler Hall June 30, 2013, 8:16 p.m.
Some terminals may not pass the environment into the child process. This
is true when using "tmux split-window." If tmux is already running, it
will start the command with the tmux session environment, ignoring the
environment where the command was issued.

This could possibly be worked around when launching tmux by injecting
variables into the user's session environment or adding the variables to
the "update-environment" tmux setting. However, both methods would
permanently alter the user's session, which is undesirable.

By using a wrapper script, we have full control over the final
environment. Replace the env dictionary with an empty data smart that
will contain the exported variables and a wrapper function that execs
the original command.

Signed-off-by: Tyler Hall <tylerwhall@gmail.com>

Currently the devshell command fails when run from tmux, because tmux doesn't
pass the environment necessary for pseudo. Tmux starts new shells using the
session environment and ignores the environment that invoked the command.

I can think of three tmux-specifc ways to fix this, but they are all

1. Modify the user's session environment before spawning the shell
    - This is a global operation that can't be done atomically and may be
    destructive to the user's session environment
2. Add variables to tmux's "update-environment" variable
    - Has the same problem as 1.
3. A multi-step process:
    A. Make a new session containing a dummy shell (with the wrong env)
    B. Set the session's environment, one variable at a time
    C. Launch the command in that session
    D. Move the window to the current session
    E. Destroy the temporary session containing the dummy shell

    - This feels too complicated and fragile

My current solution is to run the command via a wrapper script that takes the
form of a standard task run script. This achieves the desired environment
without relying on the terminal's behavior.

It also may be convenient to have the task script in the temp directory so
one can enter the devshell environment without running bitbake.

There is some code duplication with bitbake's exec_func(), particularly when
getting the script file name from BB_RUNFMT, though it is only a few lines.

 meta/classes/terminal.bbclass | 41 ++++++++++++++++++++++++++++++++---------
 1 file changed, 32 insertions(+), 9 deletions(-)

Patch hide | download patch | download mbox

diff --git a/meta/classes/terminal.bbclass b/meta/classes/terminal.bbclass
index 8cebad4..ae338e9 100644
--- a/meta/classes/terminal.bbclass
+++ b/meta/classes/terminal.bbclass
@@ -11,43 +11,66 @@  XAUTHORITY ?= "${HOME}/.Xauthority"
 SHELL ?= "bash"
+def emit_terminal_func(command, envdata, d):
+    cmd_func = 'do_terminal'
+    envdata.setVar(cmd_func, 'exec ' + command)
+    envdata.setVarFlag(cmd_func, 'func', 1)
+    runfmt = d.getVar('BB_RUNFMT', True) or "run.{func}.{pid}"
+    runfile = runfmt.format(func=cmd_func, pid=os.getpid())
+    runfile = os.path.join(d.getVar('T', True), runfile)
+    with open(runfile, 'w') as script:
+        script.write('#!/bin/sh -e\n')
+        bb.data.emit_func(cmd_func, script, envdata)
+        script.write(cmd_func)
+        script.write("\n")
+    os.chmod(runfile, 0755)
+    return runfile
 def oe_terminal(command, title, d):
     import oe.data
     import oe.terminal
-    env = dict()
+    envdata = bb.data.init()
     for v in os.environ:
-        env[v] = os.environ[v]
+        envdata.setVar(v, os.environ[v])
+        envdata.setVarFlag(v, 'export', 1)
     for export in oe.data.typed_value('OE_TERMINAL_EXPORTS', d):
         value = d.getVar(export, True)
         if value is not None:
             os.environ[export] = str(value)
-            env[export] = str(value)
+            envdata.setVar(export, str(value))
+            envdata.setVarFlag(export, 'export', 1)
         if export == "PSEUDO_DISABLED":
             if "PSEUDO_UNLOAD" in os.environ:
                 del os.environ["PSEUDO_UNLOAD"]
-            if "PSEUDO_UNLOAD" in env:
-                del env["PSEUDO_UNLOAD"]
+            envdata.delVar("PSEUDO_UNLOAD")
     # Add in all variables from the user's original environment which
     # haven't subsequntly been set/changed
     origbbenv = d.getVar("BB_ORIGENV", False) or {}
     for key in origbbenv:
-        if key in env:
+        if key in envdata:
         value = origbbenv.getVar(key, True)
         if value is not None:
             os.environ[key] = str(value)
-            env[key] = str(value)
+            envdata.setVar(key, str(value))
+            envdata.setVarFlag(key, 'export', 1)
+    # Replace command with an executable wrapper script
+    command = emit_terminal_func(command, envdata, d)
     terminal = oe.data.typed_value('OE_TERMINAL', d).lower()
     if terminal == 'none':
         bb.fatal('Devshell usage disabled with OE_TERMINAL')
     elif terminal != 'auto':
-            oe.terminal.spawn(terminal, command, title, env, d)
+            oe.terminal.spawn(terminal, command, title, None, d)
         except oe.terminal.UnsupportedTerminal:
             bb.warn('Unsupported terminal "%s", defaulting to "auto"' %
@@ -56,7 +79,7 @@  def oe_terminal(command, title, d):
             bb.fatal('Unable to spawn terminal %s: %s' % (terminal, exc))
-        oe.terminal.spawn_preferred(command, title, env, d)
+        oe.terminal.spawn_preferred(command, title, None, d)
     except oe.terminal.NoSupportedTerminals:
         bb.fatal('No valid terminal found, unable to open devshell')
     except oe.terminal.ExecutionError as exc: