std.process

@trusted Pid spawnProcess(in 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, in char[] workDir = null);

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

@trusted Pid spawnProcess(in 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, in char[] workDir = null);

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

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

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

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

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

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

// Запуск исполняемого файла под названием «prog»,  
// расположенного в текущем рабочем каталоге:
auto pid = spawnProcess("./prog");
scope(exit) wait(pid);
// Мы можем делать что-то ещё во время работы программы. 
// Защита области видимости scope гарантирует, 
// что ожидание процесса произойдёт в конце этой области видимости.
...

// Запуск DMD с файлом «myprog.d», с указанием нескольких опций компилятора:
auto dmdPid = spawnProcess(["dmd", "-O", "-release", "-inline", "myprog.d" ]);
if (wait(dmdPid) != 0)
    writeln("Compilation failed!");

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

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

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

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

// Запуск DMD с файлом myprog.d, с записью всех сообщений об ошибках 
// в файле с именем 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. Дочерний процесс наследует низкоуровневое исходное смещение чтения/записи, связанное с нижележащим файловым дескриптором, но он не будет знать о каких-либо буферизованных данных. В случаях, когда это имеет значение (например, когда файл должен быть выровнен перед передачей дочернему процессу), может быть хорошей идеей использовать небуферизованные потоки, или, по крайней мере, выполнить flush для всех соответствующих буферов.

Параметры:

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 пуст.

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

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

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

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

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

// Обработать файл с именем "my file.txt" командой/программой "foo", и 
// перенаправить её вывод в файл 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");

// Запуск программы с подавлением консольного окна (только для Windows) и   
// перенаправлением потока ошибок в logFile. 
// logFile остаётся открытым в родительском процессе. 
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 открытые дескрипторы файлов по умолчанию унаследуются дочерним процессом. Поскольку это может привести к трудноуловимым ошибкам в случае, когда задействованы каналы pipe или множество потоков, spawnProcess гарантирует, что все дескрипторы файлов, кроме тех, которые соответствуют стандартным потокам ввода/вывода/ошибок, закрываются в дочернем процессе при его запуске. Используйте inheritFDs, чтобы предотвратить такое поведение.

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

class Pid;

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

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

Идентификационный номер процесса.

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

pure nothrow @property @safe pid_t osHandle();

Дескриптор операционной системы для процесса.

Этот дескриптор используется для точной идентификации процесса в OS-специфичных 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, и возвращает его статус выхода.

В общем, всегда нужно ждать завершения дочерних процессов до выхода из родительского процесса. В противном случае они могут стать «зомби» – процессами, которые являются умершими, но всё ещё занимают слот в таблице процессов операционной системы.

Если процесс уже завершён, эта функция возвращает управление немедленно. Статус выхода кэшируется, поэтому, если 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("Компиляция прошла успешно!");
    else writeln("Ошибка компиляции");
}
else writeln("Всё ещё компилируется...");
...

Обратите внимание, что в этом примере первый вызов 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, который соответствует заголовочному файлу POSIX signal.h. Если параметр codeOrSignal опущен, будет отправлен сигнал SIGTERM. (Это соответствует поведению shell-команды kill.)

import core.sys.posix.signal : SIGKILL;
auto pid = spawnProcess("some_app");
kill(pid, SIGKILL);
assert (wait(pid) == -SIGKILL); // Отрицательное возвращаемое значение для POSIX!

Исключения:

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

@trusted Pipe pipe();

Создаёт однонаправленный канал pipe.

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

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

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

// cURL используйтся для загрузки главной страницы dlang.org, её вывод 
// перенаправляется в grep, чтобы извлечь список ссылок на ZIP-файлы, 
// и полученный список пишется в файл "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(in char[][] args, Redirect redirect = Redirect.all, const string[string] env = null, Config config = Config.none, in char[] workDir = null);

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

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

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

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

Пример:

// my_application пишет в stdout и может писать в stderr
auto pipes = pipeProcess("my_application", Redirect.stdout | Redirect.stderr);
scope(exit) wait(pipes.pid);

// Сохранение строк вывода.
string[] output;
foreach (line; pipes.stdout.byLine) output ~= line.idup;

// Сохранение строк ошибок.
string[] errors;
foreach (line; pipes.stderr.byLine) errors ~= line.idup;


// sendmail будет читать из 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);

// единичная точка сообщает sendmail, что мы закончили
pipes.stdin.writeln(".");

// но в этот момент sendmail, возможно, не увидит её, нам нужно выполнить flush
pipes.stdin.flush();

// sendmail выходит из системы по ".", но вы должны закрыть файл: 
pipes.stdin.close();

// иначе это ожидание будет вечным
wait(pipes.pid);

enum Redirect: int;

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

stdin

stdout

stderr

Перенаправлять стандартный поток ввода, вывода или ошибок, соответственно.

all

Перенаправлять все три потока. Это эквивалентно Redirect.stdin | Redirect.stdout | Redirect.stderr.

stderrToStdout

Перенапралять стандартный поток ошибок в стандартный поток вывода. Этот флаг нельзя комбинировать с Redirect.stderr.

stdoutToStderr

Перенапралять стандартный поток вывода в стандартный поток ошибок. Этот флаг нельзя комбинировать с Redirect.stdout.

struct 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, если стандартный поток ошибок дочернего процесса не был перенаправлен.

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

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

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

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

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

auto dmd = execute(["dmd", "myapp.d"]);
if (dmd.status != 0) writeln("Ошибка компиляции:\n", dmd.output);

auto ls = executeShell("ls -l");
if (ls.status != 0) writeln("Не удалось получить список файлов");
else writeln(ls.output);

Параметры args/program/command, env и config перенаправляются непосредственно в лежащие в основе порождающие функции, и подробно описаны в документации по этим функциям.

Параметры:

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

Возвращает:

std.typecons.Tuple!(int, "status", string, "output").

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

Исключения:

ProcessException в случае сбоя при запуске процесса.
std.stdio.StdioException в случае сбоя при перехвате вывода.

class 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.

nothrow @property @trusted int thisProcessID();

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

Пример:

writefln("ID текущего процесса: %d", thisProcessID);

nothrow @property @trusted ThreadID thisThreadID();

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

Возвращает:

Значение core.thread.ThreadID для вызывающего потока.

Пример:

writefln("ID текущего потока: %s", thisThreadID);

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

Экранирует массив аргументов в стиле argv для использования со spawnShell, pipeShell или executeShell. Escapes an argv-style argument array to be used with spawnShell, pipeShell or executeShell.

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

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

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

Исключения:

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

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

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

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

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

abstract class environment;

Манипулирует переменными среды, используя интерфейс, подобный ассоциативному массиву.

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

static @safe string opIndex(in char[] name);

Получить значение переменной окружения с заданным именем name.

auto path = environment["PATH"];

Исключения:

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

Смотрите также:

environment.get, которая не выбрасывает исключений.

static @safe string get(in char[] name, string defaultValue = null);

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

В отличие от environment.opIndex, эта функция не выбрасывает исключений. (Хм... А std.utf.UTFException не считается, что-ли? – удивление пер.)

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

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

auto myVar = environment.get("MYVAR");
if (myVar is null)
{
    // Переменная окружения не существует.
    // Обратите внимание, что мы должны использовать 'is' для сравнения,  
    // так как myVar == null также вернёт истину,
    // если переменная существует, но является пустой.
}

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

static @trusted inout(char)[] opIndexAssign(inout char[] value, in char[] name);

Присваивает заданное значение value переменной среды с заданным именем name.

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

environment["foo"] = "bar";

Исключения:

Exception, если переменная среды не может быть добавлена (например, если name является недействительным именем).

static nothrow @nogc @trusted void remove(in char[] name);

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

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

static @trusted string[string] toAA();

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

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

Исключения:

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

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' дополнительно принимают переменные среды нового процесса в виде массива строк формы key=value.

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

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

auto commandLine = [ "program", "arg1", "arg2" ];
version (Posix)
{
    execv(commandLine[0], commandLine);
    throw new Exception("Не удалось выполнить программу");
}
else version (Windows)
{
    import core.stdc.stdlib : _exit;
    _exit(wait(spawnProcess(commandLine)));
}

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

Иногда лучшим вариантом может быть завершение текущей программы сразу после порождения дочернего процесса. Это поведение, проявляемое функциями_exec в библиотеке времени выполнения Microsoft C, и именно так работали в D устаревшие в данный момент функции execv* для Windows. Пример:

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(const(char)[] url);

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