类 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(*args)

在新分配的 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 是要运行的完整命令，以字符串形式给出。任何额外的 arguments 将传递给命令。

返回值¶ ↑

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

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

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

别名： spawn

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

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

分配一个 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]