Zen

Source string Source string

``stdin``, ``stdout``, and ``stderr`` reflect the status of the parent's end of a piped stream. If a stream is not piped, the field is not present (``nil``). If it is piped, the status may be either ``popen.stream.OPEN`` (== ``'open'``) or ``popen.stream.CLOSED`` (== ``'closed'``). The status may be changed from ``'open'`` to ``'closed'`` by a :ref:`popen_handle:shutdown({std... = true}) <popen-shutdown>` call.
414/10000 · 414
English Actions
SystemError: no permission to send a signal to a process or a process group (this is returned on Mac OS when a signal is sent to a process group, where a group leader is a zombie (or when all processes in it are zombies, details re uncertain) (this may also appear due to other reasons, details are uncertain)
If ``opts.setsid`` and ``opts.group_signal`` are set for the handle, the signal is sent to the process group rather than to the process. See :ref:`popen.new() <popen-new>` for details about group signaling. Warning: On Mac OS it is possible that a process in the group will not receive the signal, particularly if the process has just been forked (this may be due to a race condition).
Note: The module offers ``popen.signal.SIG*`` constants, because some signals have different numbers on different platforms.
Return information about the popen handle.
(if success) formatted result
res
IllegalParams: an incorrect handle parameter
IllegalParams: called on a closed handle
The result format is:
{
pid = <number> or <nil>,
command = <string>,
opts = <table>,
status = <table>,
stdin = one-of(
popen.stream.OPEN (== 'open'),
popen.stream.CLOSED (== 'closed'),
nil,
),
stdout = one-of(
popen.stream.OPEN (== 'open'),
popen.stream.CLOSED (== 'closed'),
nil,
),
stderr = one-of(
popen.stream.OPEN (== 'open'),
popen.stream.CLOSED (== 'closed'),
nil,
),
}
``pid`` is a process id of the process when it is alive, otherwise ``pid`` is nil.
``command`` is a concatenation of space-separated arguments that were passed to ``execve()``. Multiword arguments are quoted. Quotes inside arguments are not escaped.
``opts`` is a table of handle options as in the :ref:`popen.new() <popen-new>` ``opts`` parameter. ``opts.env`` is not shown here, because the environment variables map is not stored in a handle.
``status`` is a table that represents a process status in the following format:
{
state = one-of(
popen.state.ALIVE (== 'alive'),
popen.state.EXITED (== 'exited'),
popen.state.SIGNALED (== 'signaled'),
)
-- Present when `state` is 'exited'.
exit_code = <number>,
-- Present when `state` is 'signaled'.
signo = <number>,
signame = <string>,
}
``stdin``, ``stdout``, and ``stderr`` reflect the status of the parent's end of a piped stream. If a stream is not piped, the field is not present (``nil``). If it is piped, the status may be either ``popen.stream.OPEN`` (== ``'open'``) or ``popen.stream.CLOSED`` (== ``'closed'``). The status may be changed from ``'open'`` to ``'closed'`` by a :ref:`popen_handle:shutdown({std... = true}) <popen-shutdown>` call.
(on Tarantool console)
tarantool> require('popen').new({'/usr/bin/touch', '/tmp/foo'})
---
- command: /usr/bin/touch /tmp/foo
status:
state: alive
opts:
stdout: inherit
stdin: inherit
group_signal: false
keep_child: false
close_fds: true
restore_signals: true
shell: false
setsid: false
stderr: inherit
pid: 9499
...
tarantool> require('popen').shell('grep foo', 'wrR')
---
- stdout: open
command: sh -c 'grep foo'
stderr: open
status:
state: alive
stdin: open
opts:
stdout: pipe
stdin: pipe
group_signal: true
keep_child: false
close_fds: true
restore_signals: true
shell: true
setsid: true
stderr: pipe
pid: 10497
...
Wait until a child process gets exited or signaled.
The formatted result is a process status table (the same as the ``status`` component of the table returned by :ref:`popen_handle:info() <popen-info>`).
Close a popen handle.
(if success) true
Possible diagnostics when ``nil, err`` is returned (do not consider them as errors):
SystemError: no permission to send a signal to a process or a process group (This diagnostic may appear due to Mac OS behavior on zombies when ``opts.group_signal`` is set, see :ref:`popen_handle:signal() <popen-signal>`. It may appear for other reasons, details are unclear.)
The return is always ``true`` when a process is known to be dead (for example, after :ref:`popen_handle:wait() <popen-wait>` no signal will be sent, so no 'failure' may appear).
``close()`` kills a process using SIGKILL and releases all resources associated with the popen handle.
Details about signaling:
The signal is sent only when opts.keep_child is not set.
The signal is sent only when a process is alive according to the information available on current event loop iteration. (There is a gap here: a zombie may be signaled; it is harmless.)
The signal is sent to a process or a process group depending on ``opts.group_signal``. (See :ref:`popen.new() <popen-new>` for details of group signaling).

Loading…

User avatar None

New source string

testing_project / Documentation: reference/reference_lua/popen — English

``stdin``, ``stdout``, and ``stderr`` reflect the status of the parent's end of a piped stream. If a stream is not piped, the field is not present (``nil``). If it is piped, the status may be either ``popen.stream.OPEN`` (== ``'open'``) or ``popen.stream.CLOSED`` (== ``'closed'``). The status may be changed from ``'open'`` to ``'closed'`` by a :ref:`popen_handle:shutdown({std... = true}) <popen-shutdown>` call.
a year ago
Browse all string changes

Things to check

Ellipsis 1

The string uses three dots (...) instead of an ellipsis character (…)

Reset

Glossary

English English
No related strings found in the glossary.

String information

Flags
read-only
String age
a year ago
Last updated
a year ago
Source string age
a year ago
Translation file
string 193