std.process

Функции для запуска и взаимодействия с другими процессами, а также для работы со средой выполнения текущего процесса.

Обработка процессов

spawnProcess запускает новый процесс, необязательно назначив ему произвольный набор потоков стандартного ввода, вывода и ошибок. Функция возвращает немедленно, оставляя дочерний процесс для выполнения параллельно с родительским. Все остальные функции в этом модуле, запускающие процессы, построены вокруг spawnProcess.
wait заставляет родительский процесс ожидать завершения дочернего процесса. В общем случае это всегда следует делать, чтобы избежать превращения дочерних процессов в «зомби» при завершении родительского процесса. Блокирующие конструкции идеально подходят для этого – см. документацию spawnProcess для примеров. tryWait похожа на wait, но не блокирует, если процесс ещё не завершился.
pipeProcess также запускает дочерний процесс, который выполняется параллельно с родительским. Однако вместо произвольных потоков он автоматически создаёт набор каналов, позволяющих родительскому процессу общаться с дочерним через стандартный ввод, вывод и/или потоки ошибок дочернего. Эта функция примерно соответствует функции C popen.
execute запускает новый процесс и ожидает его завершения перед возвратом. Кроме того, он перехватывает стандартные потоки вывода и ошибок процесса и возвращает вывод этих потоков в виде строки.
spawnShell, pipeShell и executeShell работают как spawnProcess, pipeProcess и execute, соответственно, за исключением того, что они принимают одну строку команды и запускают её через интерпретатор команд по умолчанию текущего пользователя. executeShell примерно соответствует функции C system.
kill пытается завершить запущенный процесс.

Следующая таблица компактно обобщает различные функции создания процессов и то, как они связаны друг с другом:

	Запускает программу напрямую	Запускает командную строку
Создание процесса низкого уровня	`spawnProcess`	`spawnShell`
Автоматическое перенаправление ввода/вывода с использованием каналов	`pipeProcess`	`pipeShell`
Выполнить и дождаться завершения, собрать вывод	`execute`	`executeShell`

Другие функциональности

pipe используется для создания однонаправленных каналов.
environment — это интерфейс, посредством которого можно читать и изменять переменные среды текущего процесса.
escapeShellCommand и escapeShellFileName полезны для построения командных строк оболочки портативным способом.

Авторы:: Lars Tandle Kyllingstad, Steven Schveighoffer, Vladimir Panteleev

Лицензия:: Boost License 1.0.

Исходный код: std/process.d

Примечание: Большая часть функциональности в этом модуле недоступна в iOS, tvOS и watchOS. Доступными функциями на этих платформах являются: environment, thisProcessID и thisThreadID.

абстрактный класс environment;

Управляет переменными среды с помощью интерфейса, похожем на ассоциативный массив.

Этот класс содержит только статические методы и не может быть экземпляризован. Ниже приведены примеры использования.

статический @safe string opIndex(scope const(char)[] name);

Извлекает значение переменной среды с заданным name.

auto path = environment["PATH"];

Исключения:: Exception, если переменная среды не существует, или std.utf.UTFException, если переменная содержит недопустимые символы UTF-16 (только Windows).

См. также:: environment.get, который не генерирует исключение при неудаче.

статический @safe string get(scope const(char)[] name, string defaultValue = null);

Извлекает значение переменной среды с заданным name, или значение по умолчанию, если переменная не существует.

В отличие от environment.opIndex, эта функция никогда не генерирует исключение в Posix.

auto sh = environment.get("SHELL", "/bin/sh");

Эта функция также полезна для проверки существования переменной среды.

auto myVar = environment.get("MYVAR");
if (myVar is null)
{
    // Environment variable doesn't exist.
    // Note that we have to use 'is' for the comparison, since
    // myVar == null is also true if the variable exists but is
    // empty.
}

Параметры:

const(char)[] `name`	имя переменной среды для извлечения
string `defaultValue`	значение по умолчанию, которое будет возвращено, если переменная среды не существует.

Возвращает:: значение переменной среды, если найдена, в противном случае null если переменной не существует.

Исключения:: std.utf.UTFException, если переменная содержит недопустимые символы UTF-16 (только Windows).

статический @trusted inout(char)[] opIndexAssign(inout char[] value, scope const(char)[] name);

Присваивает данное value переменной среды с заданным name. Если value равно null, переменная удаляется из среды.

Если переменная не существует, она будет создана. Если она уже существует, она будет перезаписана.

environment["foo"] = "bar";

Исключения:: Exception, если переменная среды не может быть добавлена (например, если имя некорректно).

Примечание: На некоторых платформах изменение переменных среды может быть недоступно в многопоточных программах. См., например, glibc.

статический nothrow @nogc @trusted void remove(scope const(char)[] name);

Удаляет переменную среды с заданным name.

Если переменная не существует в среде, функция успешно возвращается, ничего не делая.

Примечание: На некоторых платформах изменение переменных среды может быть недоступно в многопоточных программах. См., например, glibc.

@trusted bool opBinaryRight(string op : "in")(scope const(char)[] name);

Определяет, определена ли переменная в среде.

Поскольку она не возвращает значение, эта функция быстрее, чем get. Однако, если вам также нужно значение, вы должны просто проверить результат get на null вместо того, чтобы сначала использовать эту функцию.

Пример

// good usage
if ("MY_ENV_FLAG" in environment)
    doSomething();

// bad usage
if ("MY_ENV_VAR" in environment)
    doSomething(environment["MY_ENV_VAR"]);

// do this instead
if (auto var = environment.get("MY_ENV_VAR"))
    doSomething(var);

статический @trusted string[string] toAA();

Копирует все переменные среды в ассоциативный массив.

Специфично для Windows: Хотя имена переменных среды Windows нечувствительны к регистру, встроенные ассоциативные массивы D нечувствительны. Эта функция будет хранить все имена переменных в верхнем регистре (например, PATH).

Исключения:: Exception, если переменные среды не могут быть извлечены (только Windows).

nothrow @property @trusted int thisProcessID();

Возвращает идентификатор процесса текущего процесса, который гарантированно уникален в системе.

Пример

writefln("Current process ID: %d", thisProcessID);

nothrow @property @trusted ThreadID thisThreadID();

Возвращает идентификатор процесса текущей нити, который гарантированно уникален в пределах текущего процесса.

Возвращает:: Значение core.thread.ThreadID для вызывающей нити.

Пример

writefln("Current thread ID: %s", thisThreadID);

@safe Pid spawnProcess(scope const(char[])[] args, File stdin = std.stdio.stdin, File stdout = std.stdio.stdout, File stderr = std.stdio.stderr, const string[string] env = null, Config config = Config.none, scope const char[] workDir = null);

@trusted Pid spawnProcess(scope const(char[])[] args, const string[string] env, Config config = Config.none, scope const(char)[] workDir = null);

@trusted Pid spawnProcess(scope const(char)[] program, File stdin = std.stdio.stdin, File stdout = std.stdio.stdout, File stderr = std.stdio.stderr, const string[string] env = null, Config config = Config.none, scope const(char)[] workDir = null);

@trusted Pid spawnProcess(scope const(char)[] program, const string[string] env, Config config = Config.none, scope const(char)[] workDir = null);

Создаёт новый процесс, необязательно присваивая ему произвольный набор стандартных потоков ввода, вывода и ошибок.

Функция возвращает немедленно, оставляя дочерний процесс для выполнения параллельно с родительским. Рекомендуется всегда вызывать wait по возвращаемому Pid, если процесс не был запущен с флагом Config.detached, как подробно описано в документации для wait.

Командная строка: Существует четыре перегрузки этой функции. Первые две принимают массив строк, args, который должен содержать имя программы в качестве нулевого элемента и любые аргументы командной строки в последующих элементах. Третья и четвёртая версии включены для удобства и могут использоваться, когда нет аргументов командной строки. Они принимают одну строку, program, которая определяет имя программы.

Если каталог не указан в args[0] или program, spawnProcess будет искать программу в зависимости от платформы. В системах POSIX он будет искать исполняемый файл в каталогах, перечисленных в переменной среды PATH, в порядке их перечисления. В Windows он будет искать исполняемый файл в следующей последовательности:

Каталог, из которого загружено приложение.
Текущий каталог для родительского процесса.
32-битный системный каталог Windows.
16-битный системный каталог Windows.
Каталог Windows.
Каталоги, перечисленные в переменной среды PATH.

// Run an executable called "prog" located in the current working
// directory:
auto pid = spawnProcess("./prog");
scope(exit) wait(pid);
// We can do something else while the program runs.  The scope guard
// ensures that the process is waited for at the end of the scope.
...

// Run DMD on the file "myprog.d", specifying a few compiler switches:
auto dmdPid = spawnProcess(["dmd", "-O", "-release", "-inline", "myprog.d" ]);
if (wait(dmdPid) != 0)
    writeln("Compilation failed!");

Переменные среды: По умолчанию дочерний процесс наследует среду родительского процесса, а также любые дополнительные переменные, указанные в параметре env. Если одна и та же переменная существует как в среде родителя, так и в env, то последняя имеет приоритет.

Если флаг Config.newEnv установлен в config, дочерний процесс не будет наследовать среду родителя. Вся его среда будет определяться значением env.

wait(spawnProcess("myapp", ["foo" : "bar"], Config.newEnv));

Стандартные потоки: Необязательные аргументы stdin, stdout и stderr могут использоваться для присвоения произвольных объектов std.stdio.File как стандартных потоков ввода, вывода и ошибок дочернего процесса соответственно. Первый должен быть открыт для чтения, а два других — для записи. По умолчанию дочерний процесс наследует стандартные потоки родителя.

// Run DMD on the file myprog.d, logging any error messages to a
// file named errors.log.
auto logFile = File("errors.log", "w");
auto pid = spawnProcess(["dmd", "myprog.d"],
                        std.stdio.stdin,
                        std.stdio.stdout,
                        logFile);
if (wait(pid) != 0)
    writeln("Compilation failed. See errors.log for details.");

Обратите внимание, что если вы передаёте объект File, который не является одним из стандартных потоков ввода/вывода/ошибок родительского процесса, этот поток по умолчанию будет закрыт в родительском процессе при возврате этой функции. См. документацию Config ниже для получения информации о том, как отключить это поведение. Будьте осторожны с проблемами буферизации при передаче объектов File функциям spawnProcess. Дочерний процесс унаследует низкоуровневый сырой смещение чтения/записи, связанное с базовым дескриптором файла, но не будет знать о каких-либо буферизованных данных. В тех случаях, когда это имеет значение (например, когда файл должен быть выровнен перед передачей дочернему процессу), может быть хорошей идеей использовать небуферизованные потоки или, по крайней мере, гарантировать, что все соответствующие буферы будут сброшены.

Параметры:

const(char[])[] `args`	Массив, содержащий имя программы в качестве нулевого элемента и любые аргументы командной строки в последующих элементах.
File `stdin`	Поток стандартного ввода дочернего процесса. Это может быть любой `std.stdio.File`, открытый для чтения. По умолчанию дочерний процесс наследует поток ввода родителя.
File `stdout`	Поток стандартного вывода дочернего процесса. Это может быть любой `std.stdio.File`, открытый для записи. По умолчанию дочерний процесс наследует поток вывода родителя.
File `stderr`	Поток стандартной ошибки дочернего процесса. Это может быть любой `std.stdio.File`, открытый для записи. По умолчанию дочерний процесс наследует поток ошибки родителя.
string[string] `env`	Дополнительные переменные среды для дочернего процесса.
Config `config`	Флаги, управляющие созданием процесса. См. `Config` для обзора доступных флагов.
char[] `workDir`	Рабочий каталог для нового процесса. По умолчанию дочерний процесс наследует рабочий каталог родителя.

Возвращает:: Объект Pid, соответствующий запущенному процессу.

Исключения:: ProcessException при неудачном запуске процесса.
std.stdio.StdioException при неудаче передачи одного из потоков дочернему процессу (только Windows).
core.exception.RangeError если args пусто.

@safe Pid spawnShell(scope const(char)[] command, File stdin = std.stdio.stdin, File stdout = std.stdio.stdout, File stderr = std.stdio.stderr, scope const string[string] env = null, Config config = Config.none, scope const(char)[] workDir = null, scope string shellPath = nativeShell);

@trusted Pid spawnShell(scope const(char)[] command, scope const string[string] env, Config config = Config.none, scope const(char)[] workDir = null, scope string shellPath = nativeShell);

Вариант функции spawnProcess, который выполняет заданную команду через предпочтительный интерпретатор команд текущего пользователя (т.е. оболочку).

Строка command передаётся в оболочку буквально и поэтому подчиняется её правилам относительно структуры команд, цитирования аргументов/имен файлов и экранирования специальных символов. Путь к исполняемому файлу оболочки по умолчанию равен nativeShell.

Во всех остальных отношениях эта функция работает так же, как и spawnProcess. Обратитесь к документации spawnProcess для описаний других параметров функции, значения возврата и возможных исключений.

// Run the command/program "foo" on the file named "my file.txt", and
// redirect its output into foo.log.
auto pid = spawnShell(`foo "my file.txt" > foo.log`);
wait(pid);

См. также:: escapeShellCommand, которая может быть полезна при построении правильно цитируемой и экранированной командной строки оболочки для текущей платформы.

enum Config: int;

Флаги, контролирующие поведение функций создания процессов в этом модуле. Большинство флагов применяются только к функциям spawnProcess и spawnShell.

Используйте побитовое ИЛИ для объединения флагов.

Пример

auto logFile = File("myapp_error.log", "w");

// Start program, suppressing the console window (Windows only),
// redirect its error stream to logFile, and leave logFile open
// in the parent process as well.
auto pid = spawnProcess("myapp", stdin, stdout, logFile,
                        Config.retainStderr | Config.suppressConsole);
scope(exit)
{
    auto exitCode = wait(pid);
    logFile.writeln("myapp exited with code ", exitCode);
    logFile.close();
}

newEnv

По умолчанию дочерний процесс наследует среду родителя, а любые переменные среды, переданные в spawnProcess, будут добавлены к ней. Если этот флаг установлен, единственными переменными в среде дочернего процесса будут те, которые указаны для spawnProcess.

retainStdin

retainStdout

retainStderr

Если дочерний процесс не наследует стандартные потоки ввода/вывода/ошибок родителя, почти всегда необходимо закрывать эти потоки в родительском процессе, когда spawnProcess возвращает значение. Поэтому по умолчанию это делается. Если это нежелательно, передайте соответствующий параметр в spawnProcess.

suppressConsole

В Windows, если дочерний процесс — консольное приложение, этот флаг предотвратит создание консольного окна. В противном случае он будет проигнорирован. В POSIX suppressConsole не оказывает никакого влияния.

inheritFDs

В POSIX, открытые дескрипторы файлов по умолчанию наследуются дочерним процессом. Поскольку это может привести к скрытым ошибкам при использовании каналов или нескольких потоков, spawnProcess гарантирует, что все дескрипторы файлов, кроме тех, которые соответствуют стандартному вводу/выводу/ошибке, будут закрыты в дочернем процессе при его запуске. Используйте inheritFDs для предотвращения этого.

В Windows этот параметр не имеет эффекта, и любые дескрипторы, которые были явно помечены как наследуемые, всегда будут унаследованы дочерним процессом.

detached

Запустить процесс в откреплённом состоянии. Это избавляет от необходимости вызова wait для очистки ресурсов процесса.

Примечание: Вызов wait или kill с полученным Pid некорректен.

stderrPassThrough

По умолчанию функции execute и executeShell будут捕获 дочерних процессов stdout и stderr. Это может быть нежелательно, если стандартный вывод должен быть обработан или использован вызывающей программой, так как результат execute будет содержать смесь вывода и сообщений об ошибках/предупреждениях.

Укажите этот флаг при вызове execute или executeShell для того, чтобы поток stderr вызываемого процесса был отправлен в std.stdio.stderr, и только захвачен и возвращён стандартный вывод.

Этот флаг не влияет на spawnProcess или spawnShell.

class Pid;

Дескриптор, соответствующий запущенному процессу.

const pure nothrow @property @safe int processID();

Номер идентификатора процесса.

Это число, которое однозначно идентифицирует процесс в операционной системе, по крайней мере, до тех пор, пока процесс работает. После вызова wait для Pid этот метод вернёт недействительный (отрицательный) идентификатор процесса.

pure nothrow @nogc @property @safe pid_t osHandle();

Дескриптор процесса в операционной системе.

Этот дескриптор используется для указания процесса в специфичных для ОС API. В POSIX этот метод возвращает core.sys.posix.sys.types.pid_t с тем же значением, что и Pid.processID, а в Windows возвращает core.sys.windows.windows.HANDLE.

После вызова wait для Pid этот метод вернёт недействительный дескриптор.

@safe int wait(Pid pid);

Ожидает завершения процесса, связанного с pid, и возвращает его код завершения.

В общем случае, следует всегда ожидать завершения дочерних процессов перед завершением родительского процесса, если процесс не был запущен в отсоединённом режиме (с флагом Config.detached). В противном случае, они могут стать «зомби» — процессами, которые неактивны, но всё ещё занимают слот в таблице процессов ОС. Не следует и не нужно ожидать завершения отсоединённых процессов, поскольку вы не владеете ими.

Если процесс уже завершился, эта функция возвращается сразу. Код завершения кешируется, так что если wait() вызывается несколько раз для одного и того же Pid, она всегда вернёт то же значение.

Специфично для POSIX: Если процесс завершился по сигналу, эта функция возвращает отрицательное число, абсолютное значение которого равно номеру сигнала. Поскольку POSIX ограничивает обычные коды завершения диапазоном от 0 до 255, отрицательное значение всегда указывает на завершение по сигналу. Коды сигналов определены в модуле core.sys.posix.signal (который соответствует POSIX заголовочному файлу signal.h).

Исключения:: ProcessException при ошибке или при попытке ожидать завершения отсоединённого процесса.

Пример: См. документацию spawnProcess.

См. также:: tryWait для неблокирующей функции.

@safe auto tryWait(Pid pid);

Неблокирующая версия wait.

Если процесс, связанный с pid, уже завершился, вызов tryWait имеет точно такой же эффект, как wait. В этом случае она возвращает кортеж, где поле terminated установлено в true, а поле status имеет такое же толкование, как возвращаемое значение wait.

Если процесс ещё не завершился, эта функция отличается от wait тем, что не ждёт этого события, а возвращает значение немедленно. Поле terminated возвращаемого кортежа будет установлено в false, а поле status всегда будет 0 (ноль). wait или tryWait следует затем вызвать снова для того же Pid в какой-то момент позже; не только для получения кода завершения, но и для предотвращения превращения процесса в «зомби», когда он, наконец, завершится. (См. wait для подробностей).

Возвращает:: std.typecons.Tuple!(bool, "terminated", int, "status").

Исключения:: ProcessException при ошибке или при попытке ожидать завершения отсоединённого процесса.

Пример

auto pid = spawnProcess("dmd myapp.d");
scope(exit) wait(pid);
...
auto dmd = tryWait(pid);
if (dmd.terminated)
{
    if (dmd.status == 0) writeln("Compilation succeeded!");
    else writeln("Compilation failed");
}
else writeln("Still compiling...");
...

Обратите внимание, что в этом примере первый вызов wait не повлияет, если процесс уже завершился к моменту вызова tryWait. Однако в противоположном случае, оператор scope гарантирует, что мы всегда ждём завершения процесса, если оно не завершилось к моменту достижения конца области видимости.

void kill(Pid pid);

void kill(Pid pid, int codeOrSignal);

Попытка завершить процесс, связанный с pid.

Действие этой функции, а также значение codeOrSignal, сильно зависят от платформы. Подробности приведены ниже. Общим для всех платформ является то, что эта функция только инициирует завершение процесса и возвращается немедленно. Она не ждёт завершения процесса и не гарантирует, что процесс фактически будет завершён.

Всегда вызывайте wait для ожидания завершения процесса, даже если kill был вызван для него.

Специфично для Windows: Процесс будет принудительно и резко завершён. Если codeOrSignal указан, он должен быть неотрицательным числом, которое будет использовано в качестве кода завершения процесса. Если нет, процесс завершится с кодом 1. Не используйте codeOrSignal = 259, так как это специальное значение (также известное как STILL_ACTIVE), используемое Windows для сигнализации о том, что процесс фактически ещё не завершился.

auto pid = spawnProcess("some_app");
kill(pid, 10);
assert(wait(pid) == 10);

Специфично для POSIX: Процессу будет отправлен сигнал со значением codeOrSignal. В зависимости от отправленного сигнала, это может или не может привести к завершению процесса. Символьные константы для различных POSIX сигналов определены в core.sys.posix.signal, что соответствует заголовочному файлу signal.h. Если codeOrSignal опущено, будет отправлен сигнал SIGTERM. (Это соответствует поведению команды оболочки _kill).

import core.sys.posix.signal : SIGKILL;
auto pid = spawnProcess("some_app");
kill(pid, SIGKILL);
assert(wait(pid) == -SIGKILL); // Negative return value on POSIX!

Исключения:: ProcessException при ошибке (например, если codeOrSignal некорректен) или при попытке завершить отсоединённый процесс. Обратите внимание, что невозможность завершить процесс считается «нормальным» результатом, а не ошибкой.

@trusted Pipe pipe();

Создаёт однонаправленную трубу.

Данные записываются в один конец трубы и считываются с другого.

auto p = pipe();
p.writeEnd.writeln("Hello World");
p.writeEnd.flush();
assert(p.readEnd.readln().chomp() == "Hello World");

Трубы, например, могут быть использованы для межпроцессного взаимодействия, запуска нового процесса и передачи одного конца трубы дочернему процессу, в то время как родительский процесс использует другой конец. (См. также pipeProcess и pipeShell для более простого способа реализации.)

// Use cURL to download the dlang.org front page, pipe its
// output to grep to extract a list of links to ZIP files,
// and write the list to the file "D downloads.txt":
auto p = pipe();
auto outFile = File("D downloads.txt", "w");
auto cpid = spawnProcess(["curl", "http://dlang.org/download.html"],
                         std.stdio.stdin, p.writeEnd);
scope(exit) wait(cpid);
auto gpid = spawnProcess(["grep", "-o", `http://\S*\.zip`],
                         p.readEnd, outFile);
scope(exit) wait(gpid);

Возвращает:: Объект Pipe, соответствующий созданной трубе.

Исключения:: std.stdio.StdioException при ошибке.

struct Pipe;

Интерфейс к трубе, созданной функцией pipe.

nothrow @property @safe File readEnd();

Конец трубы для чтения.

nothrow @property @safe File writeEnd();

Конец трубы для записи.

@safe void close();

Закрывает оба конца трубы.

Обычно нет необходимости делать это вручную, так как объекты std.stdio.File автоматически закрываются, когда на них больше нет ссылок.

Обратите внимание, что если любой конец трубы был передан дочернему процессу, он будет закрыт только в родительском процессе. (Что происходит в дочернем процессе, зависит от платформы.)

Исключения:: std.exception.ErrnoException при возникновении ошибки.

@safe ProcessPipes pipeProcess(scope const(char[])[] args, Redirect redirect = Redirect.all, const string[string] env = null, Config config = Config.none, scope const(char)[] workDir = null);

@safe ProcessPipes pipeProcess(scope const(char)[] program, Redirect redirect = Redirect.all, const string[string] env = null, Config config = Config.none, scope const(char)[] workDir = null);

@safe ProcessPipes pipeShell(scope const(char)[] command, Redirect redirect = Redirect.all, const string[string] env = null, Config config = Config.none, scope const(char)[] workDir = null, string shellPath = nativeShell);

Запускает новый процесс, создавая каналы для перенаправления стандартных потоков ввода, вывода и/или ошибок.

pipeProcess и pipeShell являются удобными оболочками вокруг spawnProcess и spawnShell соответственно, и автоматизируют задачу перенаправления одного или нескольких стандартных потоков дочернего процесса через каналы. Подобно обернутым функциям, эти функции возвращают немедленно, оставляя дочерний процесс для выполнения параллельно с вызывающим процессом. Рекомендуется всегда вызывать wait на возвращённом ProcessPipes.pid, как подробно описано в документации для wait.

Параметры args/program/command, env и config передаются непосредственно в основополагающие функции запуска, и мы рекомендуем обратиться к их документации для получения подробностей.

Параметры:

const(char[])[] `args`	Массив, содержащий имя программы в качестве нулевого элемента и любые аргументы командной строки в последующих элементах. (См. `spawnProcess` для подробностей.)
const(char)[] `program`	Имя программы без аргументов командной строки. (См. `spawnProcess` для подробностей.)
const(char)[] `command`	Команда оболочки, которая передаётся в командный интерпретатор без изменений. (См. `spawnShell` для подробностей.)
Перенаправление `redirect`	Флаги, определяющие, какие потоки перенаправляются и как. См. `Redirect` для обзора доступных флагов.
string[string] `env`	Дополнительные переменные окружения для дочернего процесса. (См. `spawnProcess` для подробностей.)
Config `config`	Флаги, управляющие созданием процесса. См. `Config` для обзора доступных флагов, и обратите внимание, что флаги `retainStd...` не имеют эффекта в этой функции.
const(char)[] `workDir`	Рабочий каталог для нового процесса. По умолчанию дочерний процесс наследует рабочий каталог родительского процесса.
string `shellPath`	Путь к оболочке, которая будет использоваться для запуска указанной программы. По умолчанию это `nativeShell`.

Возвращает:: Объект ProcessPipes, который содержит дескрипторы std.stdio.File для связи с перенаправленными потоками дочернего процесса, а также объект Pid, соответствующий запущенному процессу.

Выбрасывает:: ProcessException при неудачном запуске процесса.
std.stdio.StdioException при неудачном перенаправлении любого из потоков.

Пример

// my_application writes to stdout and might write to stderr
auto pipes = pipeProcess("my_application", Redirect.stdout | Redirect.stderr);
scope(exit) wait(pipes.pid);

// Store lines of output.
string[] output;
foreach (line; pipes.stdout.byLine) output ~= line.idup;

// Store lines of errors.
string[] errors;
foreach (line; pipes.stderr.byLine) errors ~= line.idup;


// sendmail expects to read from stdin
pipes = pipeProcess(["/usr/bin/sendmail", "-t"], Redirect.stdin);
pipes.stdin.writeln("To: you");
pipes.stdin.writeln("From: me");
pipes.stdin.writeln("Subject: dlang");
pipes.stdin.writeln("");
pipes.stdin.writeln(message);

// a single period tells sendmail we are finished
pipes.stdin.writeln(".");

// but at this point sendmail might not see it, we need to flush
pipes.stdin.flush();

// sendmail happens to exit on ".", but some you have to close the file:
pipes.stdin.close();

// otherwise this wait will wait forever
wait(pipes.pid);

перечисление Redirect: int;

Флаги, которые могут быть переданы функциям pipeProcess и pipeShell для указания того, какие стандартные потоки дочернего процесса перенаправляются. Используйте побитовое ИЛИ для объединения флагов.

stdin

stdout

stderr: Перенаправить стандартный поток ввода, вывода или ошибок соответственно.
all: Перенаправить все три потока. Это эквивалентно Redirect.stdin | Redirect.stdout | Redirect.stderr.
stderrToStdout: Перенаправить поток стандартной ошибки в поток стандартного вывода. Это нельзя комбинировать с Redirect.stderr.
stdoutToStderr: Перенаправить поток стандартного вывода в поток стандартной ошибки. Это нельзя комбинировать с Redirect.stdout.

структура ProcessPipes;

Объект, содержащий дескрипторы std.stdio.File, которые позволяют общаться с дочерним процессом через его стандартные потоки.

nothrow @property @safe Pid pid();

Идентификатор процесса (Pid) дочернего процесса.

nothrow @property @safe File stdin();

Объект std.stdio.File, который позволяет писать в стандартный поток ввода дочернего процесса.

Выбрасывает:: Error, если стандартный поток ввода дочернего процесса не был перенаправлен.

nothrow @property @safe File stdout();

Объект std.stdio.File, который позволяет читать из стандартного потока вывода дочернего процесса.

Выбрасывает:: Error, если стандартный поток вывода дочернего процесса не был перенаправлен.

nothrow @property @safe File stderr();

Объект std.stdio.File, который позволяет читать из стандартного потока ошибок дочернего процесса.

Выбрасывает:: Error, если стандартный поток ошибок дочернего процесса не был перенаправлен.

@safe auto execute(scope const(char[])[] args, const string[string] env = null, Config config = Config.none, size_t maxOutput = size_t.max, scope const(char)[] workDir = null);

@safe auto execute(scope const(char)[] program, const string[string] env = null, Config config = Config.none, size_t maxOutput = size_t.max, scope const(char)[] workDir = null);

@safe auto executeShell(scope const(char)[] command, const string[string] env = null, Config config = Config.none, size_t maxOutput = size_t.max, scope const(char)[] workDir = null, string shellPath = nativeShell);

Выполняет заданную программу или командную строку оболочки и возвращает её код выхода и вывод.

execute и executeShell запускают новый процесс, используя spawnProcess и spawnShell соответственно, и ожидают завершения процесса перед возвратом. Функции захватывают то, что дочерний процесс печатает в потоки стандартного вывода и стандартной ошибки, и возвращают это вместе с кодом выхода.

auto dmd = execute(["dmd", "myapp.d"]);
if (dmd.status != 0) writeln("Compilation failed:\n", dmd.output);

auto ls = executeShell("ls -l");
if (ls.status != 0) writeln("Failed to retrieve file listing");
else writeln(ls.output);

Параметры args/program/command, env и config передаются непосредственно в основополагающие функции запуска, и мы рекомендуем обратиться к их документации для получения подробностей.

Параметры:

const(char[])[] `args`	Массив, содержащий имя программы в качестве нулевого элемента и любые аргументы командной строки в последующих элементах. (См. `spawnProcess` для подробностей.)
const(char)[] `program`	Имя программы без аргументов командной строки. (См. `spawnProcess` для подробностей.)
const(char)[] `command`	Команда оболочки, которая передаётся в командный интерпретатор без изменений. (См. `spawnShell` для подробностей.)
string[string] `env`	Дополнительные переменные окружения для дочернего процесса. (См. `spawnProcess` для подробностей.)
Config `config`	Флаги, управляющие созданием процесса. См. `Config` для обзора доступных флагов, и обратите внимание, что флаги `retainStd...` не имеют эффекта в этой функции.
size_t `maxOutput`	Максимальное количество байтов вывода, которое должно быть захвачено.
const(char)[] `workDir`	Рабочий каталог для нового процесса. По умолчанию дочерний процесс наследует рабочий каталог родительского процесса.
string `shellPath`	Путь к оболочке, которая будет использоваться для запуска указанной программы. По умолчанию это `nativeShell`.

Возвращает:: std.typecons.Tuple!(int, "status", string, "output").

POSIX-специфичные: Если процесс завершается сигналом, поле status возвращаемого значения будет содержать отрицательное число, модуль которого равен номеру сигнала. (См. wait для подробностей.)

Выбрасывает:: ProcessException при неудачном запуске процесса.
std.stdio.StdioException при неудачном захвате вывода.

класс ProcessException: object.Exception;

Исключение, сигнализирующее о проблеме с запуском или ожиданием процесса.

@property @safe string userShell();

Определяет путь к предпочтительному интерпретатору команд текущего пользователя.

В Windows эта функция возвращает содержимое переменной окружения COMSPEC, если она существует. В противном случае она возвращает результат nativeShell.

В POSIX, userShell возвращает содержимое переменной окружения SHELL, если она существует и не пуста. В противном случае она возвращает результат nativeShell.

pure nothrow @nogc @property @safe string nativeShell();

Путь к платформенно-специфической родной оболочке.

Эта функция возвращает "cmd.exe" в Windows, "/bin/sh" в POSIX и "/system/bin/sh" в Android.

pure @safe string escapeShellCommand(scope const(char[])[] args...);

Выполняет экранирование массива аргументов в стиле argv для использования с spawnShell, pipeShell или executeShell.

string url = "http://dlang.org/";
executeShell(escapeShellCommand("wget", url, "-O", "dlang-index.html"));

Объединяет результаты нескольких escapeShellCommand и escapeShellFileName для использования операторов перенаправления оболочки или конвейеров.

executeShell(
    escapeShellCommand("curl", "http://dlang.org/download.html") ~
    "|" ~
    escapeShellCommand("grep", "-o", `http://\S*\.zip`) ~
    ">" ~
    escapeShellFileName("D download links.txt"));

Выбрасывает:: Exception, если любая часть командной строки содержит неэкранируемые символы (NUL на всех платформах, а также CR и LF в Windows).

pure nothrow @trusted string escapeWindowsArgument(scope const(char)[] arg);

Приводит аргумент командной строки в соответствие с поведением CommandLineToArgvW.

pure nothrow @trusted string escapeShellFileName(scope const(char)[] fileName);

Экранирует имя файла для использования в перенаправлении оболочки с spawnShell, pipeShell или executeShell.

int execv(in string pathname, in string[] argv);

int execve(in string pathname, in string[] argv, in string[] envp);

int execvp(in string pathname, in string[] argv);

int execvpe(in string pathname, in string[] argv, in string[] envp);

Заменяет текущий процесс, выполняя команду pathname, с аргументами в argv.

Эта функция доступна только для Posix.

Обычно, первый элемент argv — это выполняемая команда, т.е. argv[0] == pathname. Варианты функций exec с суффиксом 'p' ищут команду в переменной окружения PATH pathname. Варианты функций с суффиксом 'e' дополнительно принимают переменные окружения нового процесса в виде массива строк вида ключ=значение.

Не возвращает значение при успешном выполнении (текущий процесс будет заменён). Возвращает -1 при неудаче без указания причины ошибки.

Специфика Windows: Эти функции поддерживаются только на платформах Posix, так как операционные системы Windows не предоставляют возможности перезаписи текущего образа процесса другим. В однопоточных программах можно приблизительно имитировать эффект execv* с помощью spawnProcess и завершения текущего процесса после возвращения дочернего процесса. Например:

auto commandLine = [ "program", "arg1", "arg2" ];
version (Posix)
{
    execv(commandLine[0], commandLine);
    throw new Exception("Failed to execute program");
}
else version (Windows)
{
    import core.stdc.stdlib : _Exit;
    _Exit(wait(spawnProcess(commandLine)));
}

Это, однако, НЕ эквивалентно POSIX execv*. Во-первых, выполняемая программа запускается как отдельный процесс, со всеми вытекающими последствиями. Во-вторых, в многопоточной программе другие потоки продолжат работу, в то время как текущий поток ожидает завершения дочернего процесса. Лучшим вариантом может иногда быть немедленное завершение текущей программы после запуска дочернего процесса. Такое поведение демонстрируют функции __exec в библиотеке C Runtime от Microsoft, и так работают устаревшие функции Windows execv* D. Пример:

auto commandLine = [ "program", "arg1", "arg2" ];
version (Posix)
{
    execv(commandLine[0], commandLine);
    throw new Exception("Failed to execute program");
}
else version (Windows)
{
    spawnProcess(commandLine);
    import core.stdc.stdlib : _exit;
    _exit(0);
}

void browse(scope const(char)[] url);

Запустить браузер и установить его для просмотра страницы по адресу url.