класс Process::Status

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

Process::Status encapsulates the information on the status of a running or terminated system process. The built-in variable $? is either nil or a Process::Status object.

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

success? → true, false или 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 → целое число или 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 → целое число Показать исходный код

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

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

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

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

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.