def testPipeline2(self):
arena = test_lib.MakeArena('testPipeline')
ex = test_lib.InitExecutor(arena=arena)
Banner('ls | cut -d . -f 1 | head')
p = process.Pipeline()
p.Add(_ExtProc(['ls']))
p.Add(_ExtProc(['cut', '-d', '.', '-f', '1']))
node = _CommandNode('head', arena)
p.AddLast((ex, node))
fd_state = process.FdState()
print(p.Run(_WAITER, _FD_STATE))
# Simulating subshell for each command
node1 = _CommandNode('ls', arena)
node2 = _CommandNode('head', arena)
node3 = _CommandNode('sort --reverse', arena)
p = process.Pipeline()
p.Add(Process(process.SubProgramThunk(ex, node1)))
p.Add(Process(process.SubProgramThunk(ex, node2)))
p.Add(Process(process.SubProgramThunk(ex, node3)))
last_thunk = (ex, _CommandNode('cat', arena))
p.AddLast(last_thunk)
print(p.Run(_WAITER, _FD_STATE))
def testPipeline2(self):
cmd_ev = test_lib.InitCommandEvaluator(arena=_ARENA, ext_prog=_EXT_PROG)
Banner('ls | cut -d . -f 1 | head')
p = process.Pipeline()
p.Add(_ExtProc(['ls']))
p.Add(_ExtProc(['cut', '-d', '.', '-f', '1']))
node = _CommandNode('head', _ARENA)
p.AddLast((cmd_ev, node))
fd_state = process.FdState(_ERRFMT, _JOB_STATE)
print(p.Run(_WAITER, _FD_STATE))
# Simulating subshell for each command
node1 = _CommandNode('ls', _ARENA)
node2 = _CommandNode('head', _ARENA)
node3 = _CommandNode('sort --reverse', _ARENA)
p = process.Pipeline()
p.Add(Process(process.SubProgramThunk(cmd_ev, node1), _JOB_STATE))
p.Add(Process(process.SubProgramThunk(cmd_ev, node2), _JOB_STATE))
p.Add(Process(process.SubProgramThunk(cmd_ev, node3), _JOB_STATE))
last_thunk = (cmd_ev, _CommandNode('cat', _ARENA))
p.AddLast(last_thunk)
print(p.Run(_WAITER, _FD_STATE))
def testPipeline2(self):
Banner('ls | cut -d . -f 1 | head')
p = process.Pipeline()
p.Add(_ExtProc(['ls']))
p.Add(_ExtProc(['cut', '-d', '.', '-f', '1']))
p.Add(_ExtProc(['head']))
print(p.Run(_WAITER))
ex = InitExecutor()
# Simulating subshell for each command
w1 = ast.CompoundWord()
w1.parts.append(ast.LiteralPart(ast.token(Id.Lit_Chars, 'ls')))
node1 = ast.SimpleCommand()
node1.words = [w1]
w2 = ast.CompoundWord()
w2.parts.append(ast.LiteralPart(ast.token(Id.Lit_Chars, 'head')))
node2 = ast.SimpleCommand()
node2.words = [w2]
w3 = ast.CompoundWord()
w3.parts.append(ast.LiteralPart(ast.token(Id.Lit_Chars, 'sort')))
w4 = ast.CompoundWord()
w4.parts.append(ast.LiteralPart(ast.token(Id.Lit_Chars, '--reverse')))
node3 = ast.SimpleCommand()
node3.words = [w3, w4]
p = process.Pipeline()
p.Add(Process(process.SubProgramThunk(ex, node1)))
p.Add(Process(process.SubProgramThunk(ex, node2)))
p.Add(Process(process.SubProgramThunk(ex, node3)))
print(p.Run(_WAITER))
def testPipeline2(self):
cmd_ev = test_lib.InitCommandEvaluator(arena=self.arena,
ext_prog=self.ext_prog)
Banner('ls | cut -d . -f 1 | head')
p = process.Pipeline()
p.Add(self._ExtProc(['ls']))
p.Add(self._ExtProc(['cut', '-d', '.', '-f', '1']))
node = _CommandNode('head', self.arena)
p.AddLast((cmd_ev, node))
print(p.Run(self.waiter, self.fd_state))
# Simulating subshell for each command
node1 = _CommandNode('ls', self.arena)
node2 = _CommandNode('head', self.arena)
node3 = _CommandNode('sort --reverse', self.arena)
p = process.Pipeline()
p.Add(
Process(process.SubProgramThunk(cmd_ev, node1), self.job_state,
self.tracer))
p.Add(
Process(process.SubProgramThunk(cmd_ev, node2), self.job_state,
self.tracer))
p.Add(
Process(process.SubProgramThunk(cmd_ev, node3), self.job_state,
self.tracer))
last_thunk = (cmd_ev, _CommandNode('cat', self.arena))
p.AddLast(last_thunk)
print(p.Run(self.waiter, self.fd_state))
def _MakeProcess(self, node, job_state=None, disable_errexit=False):
"""
Assume we will run the node in another process. Return a process.
"""
if node.tag == command_e.ControlFlow:
# Pipeline or subshells with control flow are invalid, e.g.:
# - break | less
# - continue | less
# - ( return )
# NOTE: This could be done at parse time too.
e_die('Invalid control flow %r in pipeline / subshell / background',
node.token.val, token=node.token)
# NOTE: If ErrExit(), we could be verbose about subprogram errors? This
# only really matters when executing 'exit 42', because the child shell
# inherits errexit and will be verbose. Other notes:
#
# - We might want errors to fit on a single line so they don't get
# interleaved.
# - We could turn the `exit` builtin into a FatalRuntimeError exception and
# get this check for "free".
thunk = process.SubProgramThunk(self, node,
disable_errexit=disable_errexit)
p = process.Process(thunk, job_state=job_state)
return p
def _GetProcessForNode(self, node):
"""
Assume we will run the node in another process. Return a process.
"""
if node.tag == command_e.SimpleCommand:
words = braces.BraceExpandWords(node.words)
argv = self.ev.EvalWordSequence(words)
more_env = self.mem.GetExported()
self._EvalEnv(node.more_env, more_env)
thunk = self._GetThunkForSimpleCommand(argv, more_env)
elif node.tag == command_e.ControlFlow:
# Pipeline or subshells with control flow are invalid, e.g.:
# - break | less
# - continue | less
# - ( return )
# NOTE: This could be done at parse time too.
e_die('Invalid control flow %r in pipeline or subshell', node.token.val,
token=node.token)
else:
thunk = process.SubProgramThunk(self, node)
redirects = self._EvalRedirects(node)
p = process.Process(thunk, fd_state=self.fd_state, redirects=redirects)
return p
def _MakeProcess(self, node, parent_pipeline=None, inherit_errexit=True):
# type: (command_t, process.Pipeline, bool) -> process.Process
"""
Assume we will run the node in another process. Return a process.
"""
UP_node = node
if node.tag_() == command_e.ControlFlow:
node = cast(command__ControlFlow, UP_node)
# Pipeline or subshells with control flow are invalid, e.g.:
# - break | less
# - continue | less
# - ( return )
# NOTE: This could be done at parse time too.
if node.token.id != Id.ControlFlow_Exit:
e_die(
'Invalid control flow %r in pipeline / subshell / background',
node.token.val,
token=node.token)
# NOTE: If ErrExit(), we could be verbose about subprogram errors? This
# only really matters when executing 'exit 42', because the child shell
# inherits errexit and will be verbose. Other notes:
#
# - We might want errors to fit on a single line so they don't get
# interleaved.
# - We could turn the `exit` builtin into a FatalRuntimeError exception and
# get this check for "free".
thunk = process.SubProgramThunk(self.cmd_ev,
node,
inherit_errexit=inherit_errexit)
p = process.Process(thunk, self.job_state)
p.Init_ParentPipeline(parent_pipeline)
return p
