Marshal (Ruby) 管道：将序列化对象发送到子进程

我需要使用 Marshal 序列化 Ruby 中的对象，并通过管道将其发送到子进程。我怎样才能做到这一点？

我的代码如下所示，我的问题在评论中：

data = Marshal.dump(data)
#call sub-process
`ruby -r a_lib -e 'a_method'` #### how to send the stdout to the subprocess?

a_method 看起来像：

def a_method
  ...
  data = Marshal.load(data) #### how to load the stdout of the parent process?
  ...
end

是的，您可以通过管道在不同的 ruby​​/非 ruby​​ 进程之间发送序列化对象！

让我向您展示我是如何做到的。

在此示例中，主进程启动子进程，然后子进程使用 Marshal 序列化传输简单的 Hash 对象。

主源码：

首先声明一些辅助方法会很有用run_ruby在进程类中：

#encoding: UTF-8
require 'rbconfig'
module Process
  RUBY = RbConfig::CONFIG.values_at('bindir', 'BASERUBY').join('/')
# @param [String] command
# @param [Hash] options
  def Process.run_ruby(command, options)
    spawn("#{Process::RUBY} -- #{command}", options)
  end
end

此代码只是定位 ruby​​ 可执行文件并将完整路径保存到 RUBY 常量中。

重要的: 如果你要使用Jruby或其他一些可执行文件 - 您应该重写此代码并提供执行它的路径！

接下来，我们应该启动子进程。
此时我们可以重写STDIN, STDOUT and STDERR对于新流程。
让我们创建一个pipe并重定向孩子的STDOUT到这个管道：

  rd, wr = IO.pipe
  Process.run_ruby("./test/pipetest.rb param1 param2", {:out => wr})
  wr.close

请注意选项哈希：{：输出=> wr}- 它告诉spawn命令重定向STDOUT to wr流描述符。

此外，您还可以指定参数（请参阅param1 and param2）在命令行中。

请注意，我们调用wr.close因为在本例中我们没有在父进程中使用它。

master 如何接收对象：

message = rd.gets         # read message header with size in bytes
cb = message[5..-1].to_i  # message is in form: "data <byte_size>\n"
data = rd.read(cb)        # read message with binary object
puts "Parent read #{data.length} from #{cb} bytes:"
obj = Marshal::load(data) # unserialize object
puts obj.inspect

子源代码：

现在，序列化对象将如何传输？
首先孩子会序列化对象，
然后它将以以下形式发送父消息："data <byte_size>\n"
之后它将发送序列化对象本身。
子进程将发送对象到STDOUT因为我们已经指定将此通道用作管道。

#encoding: UTF-8

# obj is an example Hash object to be transmitted
obj = {
    1 => 'asd',
    'data' => 255,
    0 => 0.55
}

data = Marshal::dump(obj)             # serializing object (obj)
$stdout.puts "data #{data.length}"    # sending message header
$stdout.write data                    # sending message itself
$stdout.flush                         # Important: flush data!

在上面的代码中，子进程只是输出一个序列化对象并终止。
当然，您可以编写更复杂的行为。
例如，我启动许多子进程，每个子进程共享同一根管子到父进程STDOUT。为了避免两个孩子同时写入管道的问题，我必须使用系统级互斥体（不是 Ruby Mutex）来控制对此管道的访问。