класс Process::Status

Родитель:: Объект

Process::Status инкапсулирует информацию о состоянии выполняемого или завершенного системного процесса. Встроенная переменная $? — это либо nil, либо объект Process::Status.

fork { exit 99 }   #=> 26557
Process.wait       #=> 26557
$?.class           #=> Process::Status
$?.to_i            #=> 25344
$? >> 8            #=> 99
$?.stopped?        #=> false
$?.exited?         #=> true
$?.exitstatus      #=> 99

Системы Posix записывают информацию о процессах, используя 16-битовое целое число. Младшие биты записывают состояние процесса (остановлен, завершен, сигнализирован), а старшие биты, возможно, содержат дополнительную информацию (например, код возврата программы в случае завершения процесса). До Ruby 1.8 эти биты напрямую передавались программе Ruby. Сейчас Ruby инкапсулирует их в объект Process::Status. Однако для максимальной совместимости эти объекты сохраняют побитовый интерфейс. В описаниях ниже, когда мы говорим о целочисленном значении stat, мы имеем в виду это 16-битовое значение.

Публичные методы класса

Process::Status.wait(pid=-1, flags=0) → Process::Status Показать исходный код

VALUE
rb_process_status_waitv(int argc, VALUE *argv, VALUE _)
{
    rb_check_arity(argc, 0, 2);

    rb_pid_t pid = -1;
    int flags = 0;

    if (argc >= 1) {
        pid = NUM2PIDT(argv[0]);
    }

    if (argc >= 2) {
        flags = RB_NUM2INT(argv[1]);
    }

    return rb_process_status_wait(pid, flags);
}

Ожидает завершения дочернего процесса и возвращает объект Process::Status, содержащий информацию об этом процессе. Какой дочерний процесс ожидает, зависит от значения pid:

> 0: Ожидает дочернего процесса с идентификатором процесса, равным pid.
0: Ожидает любого дочернего процесса, группа процессов которого совпадает с группой процесса вызывающего.
-1: Ожидает любой дочерний процесс (значение по умолчанию, если pid не задано).
< -1: Ожидает любой дочерний процесс, группа процессов которого совпадает со значением по модулю pid.

Аргумент flags может быть логическим ИЛИ значений флагов Process::WNOHANG (не блокировать, если нет доступного дочернего процесса) или Process::WUNTRACED (возвращать остановленные дочерние процессы, которые еще не были отображены). Не все флаги доступны на всех платформах, но значение нуля будет работать на всех платформах.

Возвращает nil, если нет дочерних процессов. Недоступно на всех платформах.

Может вызвать обработчик планировщика process_wait.

fork { exit 99 }                              #=> 27429
Process::Status.wait                          #=> pid 27429 exit 99
$?                                            #=> nil

pid = fork { sleep 3 }                        #=> 27440
Time.now                                      #=> 2008-03-08 19:56:16 +0900
Process::Status.wait(pid, Process::WNOHANG)   #=> nil
Time.now                                      #=> 2008-03-08 19:56:16 +0900
Process::Status.wait(pid, 0)                  #=> pid 27440 exit 99
Time.now                                      #=> 2008-03-08 19:56:19 +0900

ЭТА ФУНКЦИЯ ЯВЛЯЕТСЯ ЭКСПЕРИМЕНТАЛЬНОЙ.

Публичные методы экземпляров

stat & num → целое число Показать исходный код

static VALUE
pst_bitand(VALUE st1, VALUE st2)
{
    int status = PST2INT(st1) & NUM2INT(st2);

    return INT2NUM(status);
}

Логическое И поразрядное для битов в stat и num.

fork { exit 0x37 }
Process.wait
sprintf('%04x', $?.to_i)       #=> "3700"
sprintf('%04x', $? & 0x1e00)   #=> "1600"

stat == other → true или false Показать исходный код

static VALUE
pst_equal(VALUE st1, VALUE st2)
{
    if (st1 == st2) return Qtrue;
    return rb_equal(pst_to_i(st1), st2);
}

Возвращает true если целое значение stat равно other.

stat >> num → целое число Показать исходный код

static VALUE
pst_rshift(VALUE st1, VALUE st2)
{
    int status = PST2INT(st1) >> NUM2INT(st2);

    return INT2NUM(status);
}

Сдвиг битов в stat вправо на num позиций.

fork { exit 99 }   #=> 26563
Process.wait       #=> 26563
$?.to_i            #=> 25344
$? >> 8            #=> 99

coredump? → true или false Показать исходный код

static VALUE
pst_wcoredump(VALUE st)
{
#ifdef WCOREDUMP
    int status = PST2INT(st);

    return RBOOL(WCOREDUMP(status));
#else
    return Qfalse;
#endif
}

Возвращает true если stat сгенерировал дамп памяти при завершении. Не доступно на всех платформах.

exited? → true или false Показать исходный код

static VALUE
pst_wifexited(VALUE st)
{
    int status = PST2INT(st);

    return RBOOL(WIFEXITED(status));
}

Возвращает true если stat завершился нормально (например, с помощью вызова exit(), или завершением программы).

exitstatus → целое число или nil Показать исходный код

static VALUE
pst_wexitstatus(VALUE st)
{
    int status = PST2INT(st);

    if (WIFEXITED(status))
        return INT2NUM(WEXITSTATUS(status));
    return Qnil;
}

Возвращает восемь младших битов кода возврата stat. Доступно только если exited? равно true.

fork { }           #=> 26572
Process.wait       #=> 26572
$?.exited?         #=> true
$?.exitstatus      #=> 0

fork { exit 99 }   #=> 26573
Process.wait       #=> 26573
$?.exited?         #=> true
$?.exitstatus      #=> 99

inspect → строка Показать исходный код

static VALUE
pst_inspect(VALUE st)
{
    rb_pid_t pid;
    int status;
    VALUE str;

    pid = pst_pid(st);
    if (!pid) {
        return rb_sprintf("#<%s: uninitialized>", rb_class2name(CLASS_OF(st)));
    }
    status = PST2INT(st);

    str = rb_sprintf("#<%s: ", rb_class2name(CLASS_OF(st)));
    pst_message(str, pid, status);
    rb_str_cat2(str, ">");
    return str;
}

Переопределяет метод инспекции.

system("false")
p $?.inspect #=> "#<Process::Status: pid 12861 exit 1>"

pid → целое число Показать исходный код

static VALUE
pst_pid_m(VALUE self)
{
    rb_pid_t pid = pst_pid(self);
    return PIDT2NUM(pid);
}

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

fork { exit }   #=> 26569
Process.wait    #=> 26569
$?.pid          #=> 26569

signaled? → true или false Показать исходный код

static VALUE
pst_wifsignaled(VALUE st)
{
    int status = PST2INT(st);

    return RBOOL(WIFSIGNALED(status));
}

Возвращает true если stat завершился из-за незахваченного сигнала.

stopped? → true или false Показать исходный код

static VALUE
pst_wifstopped(VALUE st)
{
    int status = PST2INT(st);

    return RBOOL(WIFSTOPPED(status));
}

Возвращает true если этот процесс остановлен. Возвращается только если соответствующий вызов wait имел установленный флаг Process::WUNTRACED.

stopsig → целое число или nil Показать исходный код

static VALUE
pst_wstopsig(VALUE st)
{
    int status = PST2INT(st);

    if (WIFSTOPPED(status))
        return INT2NUM(WSTOPSIG(status));
    return Qnil;
}

Возвращает номер сигнала, который вызвал остановку stat (или nil если self не остановлен).

success? → true, false or nil Показать исходный код

static VALUE
pst_success_p(VALUE st)
{
    int status = PST2INT(st);

    if (!WIFEXITED(status))
        return Qnil;
    return RBOOL(WEXITSTATUS(status) == EXIT_SUCCESS);
}

Возвращает true, если stat успешен, false, если нет. Возвращает nil, если exited? не является true.

termsig → integer or nil Показать исходный код

static VALUE
pst_wtermsig(VALUE st)
{
    int status = PST2INT(st);

    if (WIFSIGNALED(status))
        return INT2NUM(WTERMSIG(status));
    return Qnil;
}

Возвращает номер сигнала, вызвавшего завершение stat (или nil, если self не был завершен неуловленным сигналом).

to_i → integer Показать исходный код

static VALUE
pst_to_i(VALUE self)
{
    int status = pst_status(self);
    return RB_INT2NUM(status);
}

Возвращает биты в stat в виде целого числа. целого числа. Обращение к этим битам зависит от платформы.

fork { exit 0xab }         #=> 26566
Process.wait               #=> 26566
sprintf('%04x', $?.to_i)   #=> "ab00"

to_s → string Показать исходный код

static VALUE
pst_to_s(VALUE st)
{
    rb_pid_t pid;
    int status;
    VALUE str;

    pid = pst_pid(st);
    status = PST2INT(st);

    str = rb_str_buf_new(0);
    pst_message(str, pid, status);
    return str;
}

Отображает pid и код выхода в виде строки.

system("false")
p $?.to_s         #=> "pid 12766 exit 1"

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.