# Open stdin, stdout, and stderr streams and start external executable.

# In addition, a thread to wait for the started process is created.

# The thread has a pid method and a thread variable :pid which is the pid of

# the started process.

#

# Block form:

#

# Open3.popen3([env,] cmd... [, opts]) {|stdin, stdout, stderr, wait_thr|

# pid = wait_thr.pid # pid of the started process.

# ...

# exit_status = wait_thr.value # Process::Status object returned.

# }

#

# Non-block form:

#

# stdin, stdout, stderr, wait_thr = Open3.popen3([env,] cmd... [, opts])

# pid = wait_thr[:pid] # pid of the started process

# ...

# stdin.close # stdin, stdout and stderr should be closed explicitly in this form.

# stdout.close

# stderr.close

# exit_status = wait_thr.value # Process::Status object returned.

#

# The parameters env, cmd, and opts are passed to Process.spawn.

# A commandline string and a list of argument strings can be accepted as follows:

#

# Open3.popen3("echo abc") {|i, o, e, t| ... }

# Open3.popen3("echo", "abc") {|i, o, e, t| ... }

# Open3.popen3(["echo", "argv0"], "abc") {|i, o, e, t| ... }

#

# If the last parameter, opts, is a Hash, it is recognized as an option for Process.spawn.

#

# Open3.popen3("pwd", :chdir=>"/") {|i,o,e,t|

# p o.read.chomp #=> "/"

# }

#

# wait_thr.value waits for the termination of the process.

# The block form also waits for the process when it returns.

#

# Closing stdin, stdout and stderr does not wait for the process to complete.

#

# You should be careful to avoid deadlocks.

# Since pipes are fixed length buffers,

# Open3.popen3("prog") {|i, o, e, t| o.read } deadlocks if

# the program generates too much output on stderr.

# You should read stdout and stderr simultaneously (using threads or IO.select).

# However, if you don't need stderr output, you can use Open3.popen2.

# If merged stdout and stderr output is not a problem, you can use Open3.popen2e.

# If you really need stdout and stderr output as separate strings, you can consider Open3.capture3.

#

def popen3(*cmd, &block)

if Hash === cmd.last

opts = cmd.pop.dup

else

opts = {}

end

in_r, in_w = IO.pipe

opts[:in] = in_r

in_w.sync = true

out_r, out_w = IO.pipe

opts[:out] = out_w

err_r, err_w = IO.pipe

opts[:err] = err_w

popen_run(cmd, opts, [in_r, out_w, err_w], [in_w, out_r, err_r], &block)

end

module_function :popen3

# Open3.popen2 is similar to Open3.popen3 except that it doesn't create a pipe for

# the standard error stream.

#

# Block form:

#

# Open3.popen2([env,] cmd... [, opts]) {|stdin, stdout, wait_thr|

# pid = wait_thr.pid # pid of the started process.

# ...

# exit_status = wait_thr.value # Process::Status object returned.

# }

#

# Non-block form:

#

# stdin, stdout, wait_thr = Open3.popen2([env,] cmd... [, opts])

# ...

# stdin.close # stdin and stdout should be closed explicitly in this form.

# stdout.close

#

# See Process.spawn for the optional hash arguments _env_ and _opts_.

#

# Example:

#

# Open3.popen2("wc -c") {|i,o,t|

# i.print "answer to life the universe and everything"

# i.close

# p o.gets #=> "42\n"

# }

#

# Open3.popen2("bc -q") {|i,o,t|

# i.puts "obase=13"

# i.puts "6 * 9"

# p o.gets #=> "42\n"

# }

#

# Open3.popen2("dc") {|i,o,t|

# i.print "42P"

# i.close

# p o.read #=> "*"

# }

#

def popen2(*cmd, &block)

if Hash === cmd.last

opts = cmd.pop.dup

else

opts = {}

end

in_r, in_w = IO.pipe

opts[:in] = in_r

in_w.sync = true

out_r, out_w = IO.pipe

opts[:out] = out_w

popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)

end

module_function :popen2

# Open3.popen2e is similar to Open3.popen3 except that it merges

# the standard output stream and the standard error stream.

#

# Block form:

#

# Open3.popen2e([env,] cmd... [, opts]) {|stdin, stdout_and_stderr, wait_thr|

# pid = wait_thr.pid # pid of the started process.

# ...

# exit_status = wait_thr.value # Process::Status object returned.

# }

#

# Non-block form:

#

# stdin, stdout_and_stderr, wait_thr = Open3.popen2e([env,] cmd... [, opts])

# ...

# stdin.close # stdin and stdout_and_stderr should be closed explicitly in this form.

# stdout_and_stderr.close

#

# See Process.spawn for the optional hash arguments _env_ and _opts_.

#

# Example:

# # check gcc warnings

# source = "foo.c"

# Open3.popen2e("gcc", "-Wall", source) {|i,oe,t|

# oe.each {|line|

# if /warning/ =~ line

# ...

# end

# }

# }

#

def popen2e(*cmd, &block)

if Hash === cmd.last

opts = cmd.pop.dup

else

opts = {}

end

in_r, in_w = IO.pipe

opts[:in] = in_r

in_w.sync = true

out_r, out_w = IO.pipe

opts[[:out, :err]] = out_w

popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)

end

module_function :popen2e

def popen_run(cmd, opts, child_io, parent_io) # :nodoc:

pid = spawn(*cmd, opts)

wait_thr = Process.detach(pid)

child_io.each(&:close)

result = [*parent_io, wait_thr]

if defined? yield

begin

return yield(*result)

ensure

parent_io.each(&:close)

wait_thr.join

end

end

result

end

module_function :popen_run

class << self

private :popen_run

end

# Open3.capture3 captures the standard output and the standard error of a command.

#

# stdout_str, stderr_str, status = Open3.capture3([env,] cmd... [, opts])

#

# The arguments env, cmd and opts are passed to Open3.popen3 except

# <code>opts[:stdin_data]</code> and <code>opts[:binmode]</code>. See Process.spawn.

#

# If <code>opts[:stdin_data]</code> is specified, it is sent to the command's standard input.

#

# If <code>opts[:binmode]</code> is true, internal pipes are set to binary mode.

#

# Examples:

#

# # dot is a command of graphviz.

# graph = <<'End'

# digraph g {

# a -> b

# }

# End

# drawn_graph, dot_log = Open3.capture3("dot -v", :stdin_data=>graph)

#

# o, e, s = Open3.capture3("echo abc; sort >&2", :stdin_data=>"foo\nbar\nbaz\n")

# p o #=> "abc\n"

# p e #=> "bar\nbaz\nfoo\n"

# p s #=> #<Process::Status: pid 32682 exit 0>

#

# # generate a thumbnail image using the convert command of ImageMagick.

# # However, if the image is really stored in a file,

# # system("convert", "-thumbnail", "80", "png:#{filename}", "png:-") is better

# # because of reduced memory consumption.

# # But if the image is stored in a DB or generated by the gnuplot Open3.capture2 example,

# # Open3.capture3 should be considered.

# #

# image = File.read("/usr/share/openclipart/png/animals/mammals/sheep-md-v0.1.png", :binmode=>true)

# thumbnail, err, s = Open3.capture3("convert -thumbnail 80 png:- png:-", :stdin_data=>image, :binmode=>true)

# if s.success?

# STDOUT.binmode; print thumbnail

# end

#

def capture3(*cmd)

if Hash === cmd.last

opts = cmd.pop.dup

else

opts = {}

end

stdin_data = opts.delete(:stdin_data) || ''

binmode = opts.delete(:binmode)

popen3(*cmd, opts) {|i, o, e, t|

if binmode

i.binmode

o.binmode

e.binmode

end

out_reader = Thread.new { o.read }

err_reader = Thread.new { e.read }

begin

if stdin_data.respond_to? :readpartial

IO.copy_stream(stdin_data, i)

else

i.write stdin_data

end

rescue Errno::EPIPE

end

i.close

[out_reader.value, err_reader.value, t.value]

}

end

module_function :capture3

# Open3.capture2 captures the standard output of a command.

#

# stdout_str, status = Open3.capture2([env,] cmd... [, opts])

#

# The arguments env, cmd and opts are passed to Open3.popen3 except