Package ch.bailu.gtk.gio

Klasse Subprocess

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.type.PropertyHolder
ch.bailu.gtk.gio.Subprocess
Alle implementierten Schnittstellen:
PointerInterface
public class Subprocess extends PropertyHolder
`GSubprocess` allows the creation of and interaction with child
processes.

Processes can be communicated with using standard GIO-style APIs (ie:
[class@Gio.InputStream], [class@Gio.OutputStream]). There are GIO-style APIs
to wait for process termination (ie: cancellable and with an asynchronous
variant).

There is an API to force a process to terminate, as well as a
race-free API for sending UNIX signals to a subprocess.

One major advantage that GIO brings over the core GLib library is
comprehensive API for asynchronous I/O, such
[method@Gio.OutputStream.splice_async]. This makes `GSubprocess`
significantly more powerful and flexible than equivalent APIs in
some other languages such as the `subprocess.py`
included with Python. For example, using `GSubprocess` one could
create two child processes, reading standard output from the first,
processing it, and writing to the input stream of the second, all
without blocking the main loop.

A powerful [method@Gio.Subprocess.communicate] API is provided similar to the
`communicate()` method of `subprocess.py`. This enables very easy
interaction with a subprocess that has been opened with pipes.

`GSubprocess` defaults to tight control over the file descriptors open
in the child process, avoiding dangling-FD issues that are caused by
a simple `fork()`/`exec()`. The only open file descriptors in the
spawned process are ones that were explicitly specified by the
`GSubprocess` API (unless `G_SUBPROCESS_FLAGS_INHERIT_FDS` was
specified).

`GSubprocess` will quickly reap all child processes as they exit,
avoiding ‘zombie processes’ remaining around for long periods of
time. [method@Gio.Subprocess.wait] can be used to wait for this to happen,
but it will happen even without the call being explicitly made.

As a matter of principle, `GSubprocess` has no API that accepts
shell-style space-separated strings. It will, however, match the
typical shell behaviour of searching the `PATH` for executables that do
not contain a directory separator in their name. By default, the `PATH`
of the current process is used. You can specify
`G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP` to use the `PATH` of the
launcher environment instead.

`GSubprocess` attempts to have a very simple API for most uses (ie:
spawning a subprocess with arguments and support for most typical
kinds of input and output redirection). See [ctor@Gio.Subprocess.new]. The
[class@Gio.SubprocessLauncher] API is provided for more complicated cases
(advanced types of redirection, environment variable manipulation,
change of working directory, child setup functions, etc).

A typical use of `GSubprocess` will involve calling
[ctor@Gio.Subprocess.new], followed by [method@Gio.Subprocess.wait_async] or
[method@Gio.Subprocess.wait]. After the process exits, the status can be
checked using functions such as [method@Gio.Subprocess.get_if_exited] (which
are similar to the familiar `WIFEXITED`-style POSIX macros).

Note that as of GLib 2.82, creating a `GSubprocess` causes the signal
`SIGPIPE` to be ignored for the remainder of the program. If you are writing
a command-line utility that uses `GSubprocess`, you may need to take into
account the fact that your program will not automatically be killed
if it tries to write to `stdout` after it has been closed.

https://docs.gtk.org/gio/class.Subprocess.html

  • Konstruktordetails

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • communicateAsync

      public void communicateAsync(@Nullable Bytes stdin_buf, @Nullable Cancellable cancellable, Subprocess.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Asynchronous version of g_subprocess_communicate(). Complete
      invocation with g_subprocess_communicate_finish().
      Parameter:
      stdin_buf - Input data, or %NULL
      cancellable - Cancellable
      callback - Callback
      user_data - User data

    • communicateUtf8

      public boolean communicateUtf8(@Nullable Str stdin_buf, @Nullable Cancellable cancellable, @Nullable Strs stdout_buf, @Nullable Strs stderr_buf) throws AllocationError
      Like g_subprocess_communicate(), but validates the output of the
      process as UTF-8, and returns it as a regular NUL terminated string.

      On error, @stdout_buf and @stderr_buf will be set to undefined values and
      should not be used.
      Parameter:
      stdin_buf - data to send to the stdin of the subprocess, or %NULL
      cancellable - a #GCancellable
      stdout_buf - data read from the subprocess stdout
      stderr_buf - data read from the subprocess stderr
      Gibt zurück:
      Löst aus:
      AllocationError

    • communicateUtf8

      public boolean communicateUtf8(String stdin_buf, @Nullable Cancellable cancellable, @Nullable Strs stdout_buf, @Nullable Strs stderr_buf) throws AllocationError
      Like g_subprocess_communicate(), but validates the output of the
      process as UTF-8, and returns it as a regular NUL terminated string.

      On error, @stdout_buf and @stderr_buf will be set to undefined values and
      should not be used.
      Parameter:
      stdin_buf - data to send to the stdin of the subprocess, or %NULL
      cancellable - a #GCancellable
      stdout_buf - data read from the subprocess stdout
      stderr_buf - data read from the subprocess stderr
      Gibt zurück:
      Löst aus:
      AllocationError

    • communicateUtf8Async

      public void communicateUtf8Async(@Nullable Str stdin_buf, @Nullable Cancellable cancellable, Subprocess.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Asynchronous version of g_subprocess_communicate_utf8(). Complete
      invocation with g_subprocess_communicate_utf8_finish().
      Parameter:
      stdin_buf - Input data, or %NULL
      cancellable - Cancellable
      callback - Callback
      user_data - User data

    • communicateUtf8Async

      public void communicateUtf8Async(String stdin_buf, @Nullable Cancellable cancellable, Subprocess.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Asynchronous version of g_subprocess_communicate_utf8(). Complete
      invocation with g_subprocess_communicate_utf8_finish().
      Parameter:
      stdin_buf - Input data, or %NULL
      cancellable - Cancellable
      callback - Callback
      user_data - User data

    • communicateUtf8Finish

      public boolean communicateUtf8Finish(@Nonnull AsyncResult result, @Nullable Strs stdout_buf, @Nullable Strs stderr_buf) throws AllocationError
      Complete an invocation of g_subprocess_communicate_utf8_async().
      Parameter:
      result - Result
      stdout_buf - Return location for stdout data
      stderr_buf - Return location for stderr data
      Gibt zurück:
      Löst aus:
      AllocationError

    • forceExit

      public void forceExit()
      Use an operating-system specific method to attempt an immediate,
      forceful termination of the process. There is no mechanism to
      determine whether or not the request itself was successful;
      however, you can use g_subprocess_wait() to monitor the status of
      the process after calling this function.

      On Unix, this function sends %SIGKILL.

    • getExitStatus

      public int getExitStatus()
      Check the exit status of the subprocess, given that it exited
      normally. This is the value passed to the exit() system call or the
      return value from main.

      This is equivalent to the system WEXITSTATUS macro.

      It is an error to call this function before g_subprocess_wait() and
      unless g_subprocess_get_if_exited() returned %TRUE.
      Gibt zurück:
      the exit status

    • getIdentifier

      public Str getIdentifier()
      On UNIX, returns the process ID as a decimal string.
      On Windows, returns the result of GetProcessId() also as a string.
      If the subprocess has terminated, this will return %NULL.
      Gibt zurück:
      the subprocess identifier, or %NULL if the subprocess has terminated

    • getIfExited

      public boolean getIfExited()
      Check if the given subprocess exited normally (ie: by way of exit()
      or return from main()).

      This is equivalent to the system WIFEXITED macro.

      It is an error to call this function before g_subprocess_wait() has
      returned.
      Gibt zurück:
      %TRUE if the case of a normal exit

    • getIfSignaled

      public boolean getIfSignaled()
      Check if the given subprocess terminated in response to a signal.

      This is equivalent to the system WIFSIGNALED macro.

      It is an error to call this function before g_subprocess_wait() has
      returned.
      Gibt zurück:
      %TRUE if the case of termination due to a signal

    • getStatus

      public int getStatus()
      Gets the raw status code of the process, as from waitpid().

      This value has no particular meaning, but it can be used with the
      macros defined by the system headers such as WIFEXITED. It can also
      be used with g_spawn_check_wait_status().

      It is more likely that you want to use g_subprocess_get_if_exited()
      followed by g_subprocess_get_exit_status().

      It is an error to call this function before g_subprocess_wait() has
      returned.
      Gibt zurück:
      the (meaningless) waitpid() exit status from the kernel

    • getStderrPipe

      public InputStream getStderrPipe()
      Gets the #GInputStream from which to read the stderr output of
      @subprocess.

      The process must have been created with %G_SUBPROCESS_FLAGS_STDERR_PIPE,
      otherwise %NULL will be returned.
      Gibt zurück:
      the stderr pipe

    • getStdinPipe

      public OutputStream getStdinPipe()
      Gets the #GOutputStream that you can write to in order to give data
      to the stdin of @subprocess.

      The process must have been created with %G_SUBPROCESS_FLAGS_STDIN_PIPE and
      not %G_SUBPROCESS_FLAGS_STDIN_INHERIT, otherwise %NULL will be returned.
      Gibt zurück:
      the stdout pipe

    • getStdoutPipe

      public InputStream getStdoutPipe()
      Gets the #GInputStream from which to read the stdout output of
      @subprocess.

      The process must have been created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
      otherwise %NULL will be returned.
      Gibt zurück:
      the stdout pipe

    • getSuccessful

      public boolean getSuccessful()
      Checks if the process was "successful". A process is considered
      successful if it exited cleanly with an exit status of 0, either by
      way of the exit() system call or return from main().

      It is an error to call this function before g_subprocess_wait() has
      returned.
      Gibt zurück:
      %TRUE if the process exited cleanly with a exit status of 0

    • getTermSig

      public int getTermSig()
      Get the signal number that caused the subprocess to terminate, given
      that it terminated due to a signal.

      This is equivalent to the system WTERMSIG macro.

      It is an error to call this function before g_subprocess_wait() and
      unless g_subprocess_get_if_signaled() returned %TRUE.
      Gibt zurück:
      the signal causing termination

    • sendSignal

      public void sendSignal(int signal_num)
      Sends the UNIX signal @signal_num to the subprocess, if it is still
      running.

      This API is race-free. If the subprocess has terminated, it will not
      be signalled.

      This API is not available on Windows.
      Parameter:
      signal_num - the signal number to send

    • doWait

      public boolean doWait(@Nullable Cancellable cancellable) throws AllocationError
      Synchronously wait for the subprocess to terminate.

      After the process terminates you can query its exit status with
      functions such as g_subprocess_get_if_exited() and
      g_subprocess_get_exit_status().

      This function does not fail in the case of the subprocess having
      abnormal termination. See g_subprocess_wait_check() for that.

      Cancelling @cancellable doesn't kill the subprocess. Call
      g_subprocess_force_exit() if it is desirable.
      Parameter:
      cancellable - a #GCancellable
      Gibt zurück:
      %TRUE on success, %FALSE if @cancellable was cancelled
      Löst aus:
      AllocationError

    • waitAsync

      public void waitAsync(@Nullable Cancellable cancellable, Subprocess.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Wait for the subprocess to terminate.

      This is the asynchronous version of g_subprocess_wait().
      Parameter:
      cancellable - a #GCancellable, or %NULL
      callback - a #GAsyncReadyCallback to call when the operation is complete
      user_data - user_data for @callback

    • waitCheck

      public boolean waitCheck(@Nullable Cancellable cancellable) throws AllocationError
      Combines g_subprocess_wait() with g_spawn_check_wait_status().
      Parameter:
      cancellable - a #GCancellable
      Gibt zurück:
      %TRUE on success, %FALSE if process exited abnormally, or @cancellable was cancelled
      Löst aus:
      AllocationError

    • waitCheckAsync

      public void waitCheckAsync(@Nullable Cancellable cancellable, Subprocess.OnAsyncReadyCallback callback, @Nullable Pointer user_data)
      Combines g_subprocess_wait_async() with g_spawn_check_wait_status().

      This is the asynchronous version of g_subprocess_wait_check().
      Parameter:
      cancellable - a #GCancellable, or %NULL
      callback - a #GAsyncReadyCallback to call when the operation is complete
      user_data - user_data for @callback

    • waitCheckFinish

      public boolean waitCheckFinish(@Nonnull AsyncResult result) throws AllocationError
      Collects the result of a previous call to
      g_subprocess_wait_check_async().
      Parameter:
      result - the #GAsyncResult passed to your #GAsyncReadyCallback
      Gibt zurück:
      %TRUE if successful, or %FALSE with @error set
      Löst aus:
      AllocationError

    • waitFinish

      public boolean waitFinish(@Nonnull AsyncResult result) throws AllocationError
      Collects the result of a previous call to
      g_subprocess_wait_async().
      Parameter:
      result - the #GAsyncResult passed to your #GAsyncReadyCallback
      Gibt zurück:
      %TRUE if successful, or %FALSE with @error set
      Löst aus:
      AllocationError

    • asInitable

      public Initable asInitable()
      Implements interface Initable. Call this to get access to interface functions.
      Gibt zurück:
      Initable

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()