mirror of
https://github.com/git/git
synced 2024-08-24 10:15:51 +00:00
![Stefan Beller](/assets/img/avatar_default.png)
This allows to run external commands in parallel with ordered output on stderr. If we run external commands in parallel we cannot pipe the output directly to the our stdout/err as it would mix up. So each process's output will flow through a pipe, which we buffer. One subprocess can be directly piped to out stdout/err for a low latency feedback to the user. Example: Let's assume we have 5 submodules A,B,C,D,E and each fetch takes a different amount of time as the different submodules vary in size, then the output of fetches in sequential order might look like this: time --> output: |---A---| |-B-| |-------C-------| |-D-| |-E-| When we schedule these submodules into maximal two parallel processes, a schedule and sample output over time may look like this: process 1: |---A---| |-D-| |-E-| process 2: |-B-| |-------C-------| output: |---A---|B|---C-------|DE So A will be perceived as it would run normally in the single child version. As B has finished by the time A is done, we can dump its whole progress buffer on stderr, such that it looks like it finished in no time. Once that is done, C is determined to be the visible child and its progress will be reported in real time. So this way of output is really good for human consumption, as it only changes the timing, not the actual output. For machine consumption the output needs to be prepared in the tasks, by either having a prefix per line or per block to indicate whose tasks output is displayed, because the output order may not follow the original sequential ordering: |----A----| |--B--| |-C-| will be scheduled to be all parallel: process 1: |----A----| process 2: |--B--| process 3: |-C-| output: |----A----|CB This happens because C finished before B did, so it will be queued for output before B. To detect when a child has finished executing, we check interleaved with other actions (such as checking the liveliness of children or starting new processes) whether the stderr pipe still exists. Once a child closed its stderr stream, we assume it is terminating very soon, and use `finish_command()` from the single external process execution interface to collect the exit status. By maintaining the strong assumption of stderr being open until the very end of a child process, we can avoid other hassle such as an implementation using `waitpid(-1)`, which is not implemented in Windows. Signed-off-by: Stefan Beller <sbeller@google.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
206 lines
7.1 KiB
C
206 lines
7.1 KiB
C
#ifndef RUN_COMMAND_H
|
|
#define RUN_COMMAND_H
|
|
|
|
#ifndef NO_PTHREADS
|
|
#include <pthread.h>
|
|
#endif
|
|
|
|
#include "argv-array.h"
|
|
|
|
struct child_process {
|
|
const char **argv;
|
|
struct argv_array args;
|
|
struct argv_array env_array;
|
|
pid_t pid;
|
|
/*
|
|
* Using .in, .out, .err:
|
|
* - Specify 0 for no redirections (child inherits stdin, stdout,
|
|
* stderr from parent).
|
|
* - Specify -1 to have a pipe allocated as follows:
|
|
* .in: returns the writable pipe end; parent writes to it,
|
|
* the readable pipe end becomes child's stdin
|
|
* .out, .err: returns the readable pipe end; parent reads from
|
|
* it, the writable pipe end becomes child's stdout/stderr
|
|
* The caller of start_command() must close the returned FDs
|
|
* after it has completed reading from/writing to it!
|
|
* - Specify > 0 to set a channel to a particular FD as follows:
|
|
* .in: a readable FD, becomes child's stdin
|
|
* .out: a writable FD, becomes child's stdout/stderr
|
|
* .err: a writable FD, becomes child's stderr
|
|
* The specified FD is closed by start_command(), even in case
|
|
* of errors!
|
|
*/
|
|
int in;
|
|
int out;
|
|
int err;
|
|
const char *dir;
|
|
const char *const *env;
|
|
unsigned no_stdin:1;
|
|
unsigned no_stdout:1;
|
|
unsigned no_stderr:1;
|
|
unsigned git_cmd:1; /* if this is to be git sub-command */
|
|
unsigned silent_exec_failure:1;
|
|
unsigned stdout_to_stderr:1;
|
|
unsigned use_shell:1;
|
|
unsigned clean_on_exit:1;
|
|
};
|
|
|
|
#define CHILD_PROCESS_INIT { NULL, ARGV_ARRAY_INIT, ARGV_ARRAY_INIT }
|
|
void child_process_init(struct child_process *);
|
|
void child_process_clear(struct child_process *);
|
|
|
|
int start_command(struct child_process *);
|
|
int finish_command(struct child_process *);
|
|
int finish_command_in_signal(struct child_process *);
|
|
int run_command(struct child_process *);
|
|
|
|
/*
|
|
* Returns the path to the hook file, or NULL if the hook is missing
|
|
* or disabled. Note that this points to static storage that will be
|
|
* overwritten by further calls to find_hook and run_hook_*.
|
|
*/
|
|
extern const char *find_hook(const char *name);
|
|
LAST_ARG_MUST_BE_NULL
|
|
extern int run_hook_le(const char *const *env, const char *name, ...);
|
|
extern int run_hook_ve(const char *const *env, const char *name, va_list args);
|
|
|
|
#define RUN_COMMAND_NO_STDIN 1
|
|
#define RUN_GIT_CMD 2 /*If this is to be git sub-command */
|
|
#define RUN_COMMAND_STDOUT_TO_STDERR 4
|
|
#define RUN_SILENT_EXEC_FAILURE 8
|
|
#define RUN_USING_SHELL 16
|
|
#define RUN_CLEAN_ON_EXIT 32
|
|
int run_command_v_opt(const char **argv, int opt);
|
|
|
|
/*
|
|
* env (the environment) is to be formatted like environ: "VAR=VALUE".
|
|
* To unset an environment variable use just "VAR".
|
|
*/
|
|
int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env);
|
|
|
|
/**
|
|
* Execute the given command, capturing its stdout in the given strbuf.
|
|
* Returns -1 if starting the command fails or reading fails, and otherwise
|
|
* returns the exit code of the command. The output collected in the
|
|
* buffer is kept even if the command returns a non-zero exit. The hint field
|
|
* gives a starting size for the strbuf allocation.
|
|
*
|
|
* The fields of "cmd" should be set up as they would for a normal run_command
|
|
* invocation. But note that there is no need to set cmd->out; the function
|
|
* sets it up for the caller.
|
|
*/
|
|
int capture_command(struct child_process *cmd, struct strbuf *buf, size_t hint);
|
|
|
|
/*
|
|
* The purpose of the following functions is to feed a pipe by running
|
|
* a function asynchronously and providing output that the caller reads.
|
|
*
|
|
* It is expected that no synchronization and mutual exclusion between
|
|
* the caller and the feed function is necessary so that the function
|
|
* can run in a thread without interfering with the caller.
|
|
*/
|
|
struct async {
|
|
/*
|
|
* proc reads from in; closes it before return
|
|
* proc writes to out; closes it before return
|
|
* returns 0 on success, non-zero on failure
|
|
*/
|
|
int (*proc)(int in, int out, void *data);
|
|
void *data;
|
|
int in; /* caller writes here and closes it */
|
|
int out; /* caller reads from here and closes it */
|
|
#ifdef NO_PTHREADS
|
|
pid_t pid;
|
|
#else
|
|
pthread_t tid;
|
|
int proc_in;
|
|
int proc_out;
|
|
#endif
|
|
};
|
|
|
|
int start_async(struct async *async);
|
|
int finish_async(struct async *async);
|
|
int in_async(void);
|
|
|
|
/**
|
|
* This callback should initialize the child process and preload the
|
|
* error channel if desired. The preloading of is useful if you want to
|
|
* have a message printed directly before the output of the child process.
|
|
* pp_cb is the callback cookie as passed to run_processes_parallel.
|
|
* You can store a child process specific callback cookie in pp_task_cb.
|
|
*
|
|
* Even after returning 0 to indicate that there are no more processes,
|
|
* this function will be called again until there are no more running
|
|
* child processes.
|
|
*
|
|
* Return 1 if the next child is ready to run.
|
|
* Return 0 if there are currently no more tasks to be processed.
|
|
* To send a signal to other child processes for abortion,
|
|
* return the negative signal number.
|
|
*/
|
|
typedef int (*get_next_task_fn)(struct child_process *cp,
|
|
struct strbuf *err,
|
|
void *pp_cb,
|
|
void **pp_task_cb);
|
|
|
|
/**
|
|
* This callback is called whenever there are problems starting
|
|
* a new process.
|
|
*
|
|
* You must not write to stdout or stderr in this function. Add your
|
|
* message to the strbuf err instead, which will be printed without
|
|
* messing up the output of the other parallel processes.
|
|
*
|
|
* pp_cb is the callback cookie as passed into run_processes_parallel,
|
|
* pp_task_cb is the callback cookie as passed into get_next_task_fn.
|
|
*
|
|
* Return 0 to continue the parallel processing. To abort return non zero.
|
|
* To send a signal to other child processes for abortion, return
|
|
* the negative signal number.
|
|
*/
|
|
typedef int (*start_failure_fn)(struct child_process *cp,
|
|
struct strbuf *err,
|
|
void *pp_cb,
|
|
void *pp_task_cb);
|
|
|
|
/**
|
|
* This callback is called on every child process that finished processing.
|
|
*
|
|
* You must not write to stdout or stderr in this function. Add your
|
|
* message to the strbuf err instead, which will be printed without
|
|
* messing up the output of the other parallel processes.
|
|
*
|
|
* pp_cb is the callback cookie as passed into run_processes_parallel,
|
|
* pp_task_cb is the callback cookie as passed into get_next_task_fn.
|
|
*
|
|
* Return 0 to continue the parallel processing. To abort return non zero.
|
|
* To send a signal to other child processes for abortion, return
|
|
* the negative signal number.
|
|
*/
|
|
typedef int (*task_finished_fn)(int result,
|
|
struct child_process *cp,
|
|
struct strbuf *err,
|
|
void *pp_cb,
|
|
void *pp_task_cb);
|
|
|
|
/**
|
|
* Runs up to n processes at the same time. Whenever a process can be
|
|
* started, the callback get_next_task_fn is called to obtain the data
|
|
* required to start another child process.
|
|
*
|
|
* The children started via this function run in parallel. Their output
|
|
* (both stdout and stderr) is routed to stderr in a manner that output
|
|
* from different tasks does not interleave.
|
|
*
|
|
* If start_failure_fn or task_finished_fn are NULL, default handlers
|
|
* will be used. The default handlers will print an error message on
|
|
* error without issuing an emergency stop.
|
|
*/
|
|
int run_processes_parallel(int n,
|
|
get_next_task_fn,
|
|
start_failure_fn,
|
|
task_finished_fn,
|
|
void *pp_cb);
|
|
|
|
#endif
|