module PTY

创建和管理伪终端（PTY）。另请参阅 en.wikipedia.org/wiki/Pseudo_terminal

PTY 允许您使用 ::open 分配新终端，或使用 ::spawn 启动一个带有特定命令的新终端。

示例

在此示例中，我们将更改 factor 命令的缓冲类型，假设 factor 使用 stdio 作为 stdout 缓冲。

如果使用 IO.pipe 而不是 PTY.open，则此代码将死锁，因为 factor 的 stdout 是全缓冲的。

# start by requiring the standard library PTY
require 'pty'

master, slave = PTY.open
read, write = IO.pipe
pid = spawn("factor", :in=>read, :out=>slave)
read.close     # we dont need the read
slave.close    # or the slave

# pipe "42" to the factor command
write.puts "42"
# output the response from factor
p master.gets #=> "42: 2 3 7\n"

# pipe "144" to factor and print out the response
write.puts "144"
p master.gets #=> "144: 2 2 2 2 3 3\n"
write.close # close the pipe

# The result of read operation when pty slave is closed is platform
# dependent.
ret = begin
        master.gets     # FreeBSD returns nil.
      rescue Errno::EIO # GNU/Linux raises EIO.
        nil
      end
p ret #=> nil

许可证

此软件按“原样”提供，不附带任何明示或暗示的保证，包括但不限于对特定用途的适用性、适销性或使用此软件所得结果的保证。

Public Class Methods

check(pid, raise = false) → Process::Status or nil

check(pid, true) → nil or raises PTY::ChildExited

Source

static VALUE
pty_check(int argc, VALUE *argv, VALUE self)
{
    VALUE pid, exc;
    rb_pid_t cpid;
    int status;
    const int flag =
#ifdef WNOHANG
        WNOHANG|
#endif
#ifdef WUNTRACED
        WUNTRACED|
#endif
        0;

    rb_scan_args(argc, argv, "11", &pid, &exc);
    cpid = rb_waitpid(NUM2PIDT(pid), &status, flag);
    if (cpid == -1 || cpid == 0) return Qnil;

    if (!RTEST(exc)) return rb_last_status_get();
    raise_from_check(cpid, status);

    UNREACHABLE_RETURN(Qnil);
}

检查由 pid 指定的子进程的状态。如果进程仍在运行，则返回 nil。

如果进程已退出，并且 raise 为 true，则会引发 PTY::ChildExited 异常。否则，它将返回一个 Process::Status 实例。

pid: 要检查的进程 ID
raise: 如果 true 且由 pid 标识的进程已不再存活，则会引发 PTY::ChildExited。

getpty

别名： spawn

open → [master_io, slave_file]

open {|(master_io, slave_file)| ... } → block value

Source

static VALUE
pty_open(VALUE klass)
{
    int master_fd, slave_fd;
    char slavename[DEVICELEN];

    getDevice(&master_fd, &slave_fd, slavename, 1);

    VALUE master_path = rb_obj_freeze(rb_sprintf("masterpty:%s", slavename));
    VALUE master_io = rb_io_open_descriptor(rb_cIO, master_fd, FMODE_READWRITE | FMODE_SYNC | FMODE_DUPLEX, master_path, RUBY_IO_TIMEOUT_DEFAULT, NULL);

    VALUE slave_path = rb_obj_freeze(rb_str_new_cstr(slavename));
    VALUE slave_file = rb_io_open_descriptor(rb_cFile, slave_fd, FMODE_READWRITE | FMODE_SYNC | FMODE_DUPLEX | FMODE_TTY, slave_path, RUBY_IO_TIMEOUT_DEFAULT, NULL);

    VALUE assoc = rb_assoc_new(master_io, slave_file);

    if (rb_block_given_p()) {
        return rb_ensure(rb_yield, assoc, pty_close_pty, assoc);
    }

    return assoc;
}

分配一个 pty（伪终端）。

在块形式中，将产生一个包含两个元素的数组（master_io, slave_file），并且该块的值将从 open 返回。

如果未关闭，则 IO 和 File 在块完成后都会被关闭。

PTY.open {|master, slave|
  p master      #=> #<IO:masterpty:/dev/pts/1>
  p slave      #=> #<File:/dev/pts/1>
  p slave.path #=> "/dev/pts/1"
}

在非块形式中，返回一个包含两个元素的数组 [master_io, slave_file]。

master, slave = PTY.open
# do something with master for IO, or the slave file

两种形式中的参数是

master_io: pt y 的主设备，作为 IO。
slave_file: pt y 的从设备，作为 File。终端设备的路径可通过 slave_file.path 获取

IO#raw! 可用于禁用换行符转换

require 'io/console'
PTY.open {|m, s|
  s.raw!
  # ...
}

spawn([env,] command_line) { |r, w, pid| ... }

spawn([env,] command_line) → [r, w, pid]

spawn([env,] command, arguments, ...) { |r, w, pid| ... }

spawn([env,] command, arguments, ...) → [r, w, pid]

Source

static VALUE
pty_getpty(int argc, VALUE *argv, VALUE self)
{
    VALUE res;
    struct pty_info info;
    char SlaveName[DEVICELEN];

    establishShell(argc, argv, &info, SlaveName);

    VALUE pty_path = rb_obj_freeze(rb_str_new_cstr(SlaveName));
    VALUE rport = rb_io_open_descriptor(
        rb_cFile, info.fd, FMODE_READABLE, pty_path, RUBY_IO_TIMEOUT_DEFAULT, NULL
    );

    int wpty_fd = rb_cloexec_dup(info.fd);
    if (wpty_fd == -1) {
        rb_sys_fail("dup()");
    }
    VALUE wport = rb_io_open_descriptor(
        rb_cFile, wpty_fd, FMODE_WRITABLE | FMODE_TRUNC | FMODE_CREATE | FMODE_SYNC,
        pty_path, RUBY_IO_TIMEOUT_DEFAULT, NULL
    );

    res = rb_ary_new2(3);
    rb_ary_store(res, 0, rport);
    rb_ary_store(res, 1, wport);
    rb_ary_store(res,2,PIDT2NUM(info.child_pid));

    if (rb_block_given_p()) {
        rb_ensure(rb_yield, res, pty_detach_process, (VALUE)&info);
        return Qnil;
    }
    return res;
}

在新分配的 pty 上启动指定的命令。您也可以使用别名 ::getpty。

命令的控制 tty 被设置为 pty 的从设备，并且其标准输入/输出/错误被重定向到从设备。

env 是一个可选的哈希，它为启动的 pty 提供额外的环境变量。

# sets FOO to "bar"
PTY.spawn({"FOO"=>"bar"}, "printenv", "FOO") do |r, w, pid|
  p r.read #=> "bar\r\n"
ensure
  r.close; w.close; Process.wait(pid)
end
# unsets FOO
PTY.spawn({"FOO"=>nil}, "printenv", "FOO") do |r, w, pid|
  p r.read #=> ""
ensure
  r.close; w.close; Process.wait(pid)
end

command 和 command_line 是要运行的完整命令，给定一个 String。任何额外的 arguments 将传递给命令。

返回值

在非块形式中，此函数返回一个包含三个元素的数组 [r, w, pid]。

在块形式中，这些相同的 值 将被传递给块

r: 一个可读的 IO，其中包含命令的标准输出和标准错误
w: 一个可写的 IO，它是命令的标准输入
pid: 命令的进程标识符。

清理

此方法不会像关闭 IO 或等待子进程那样进行清理，除了在块形式中分离进程以防止其变成僵尸进程（请参阅 Process.detach）。任何其他清理均由调用者负责。如果等待 pid，请务必在执行此操作之前关闭 r 和 w；在某些操作系统上，以相反的顺序执行可能会导致死锁。

别名： getpty