类 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

许可证¶ ↑

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

公共类方法

check(pid, raise = false) → Process::Status 或 nil 点击以切换源代码

check(pid, true) → nil 或引发 PTY::ChildExited

检查由 pid 指定的子进程的状态。如果进程仍然存活，则返回 nil。

如果进程不再存活，并且 raise 为 true，则将引发 PTY::ChildExited 异常。否则将返回 Process::Status 实例。

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

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);
}

getpty

别名：spawn

open → [master_io, slave_file] 点击以切换源代码

open {|(master_io, slave_file)| ... } → 块值

分配 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: pty 的主设备，作为 IO。
slave_file: pty 的从设备，作为 File。终端设备的路径可以通过 slave_file.path 获取。

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

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

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;
}

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]

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

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

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

# sets FOO to "bar"
PTY.spawn({"FOO"=>"bar"}, "printenv", "FOO") { |r,w,pid| p r.read } #=> "bar\r\n"
# unsets FOO
PTY.spawn({"FOO"=>nil}, "printenv", "FOO") { |r,w,pid| p r.read } #=> ""

command 和 command_line 是要运行的完整命令，以 String 格式给出。任何额外的 arguments 将被传递给命令。

返回值¶ ↑

在非阻塞形式中，这将返回一个大小为三的数组，[r, w, pid]。

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

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

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;
}

也称为：getpty