blocks|key|336537|text|STDOUT.flush或STDOUT.sync+=+true|type|unstyled|depth|inlineStyleRanges|entityRanges|data|336538|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

STDOUT.flush or 
STDOUT.sync = true

blocks|key|335491|text|使用IO.popen。This就是一个很好的例子。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|335492|您的代码将变成如下所示：|335493|blender+=+nil
t+=+Thread.new+do
++IO.popen("blender+-b+mball.blend+-o+//renders/+-F+JPEG+-x+1+-f+1")+do+%7Cblender%7C
++++blender.each+do+%7Cline%7C
++++++puts+line
++++end
++end
end|code-block|syntax|javascript|335494|entityMap|0|LINK|mutability|MUTABLE|url|http://pleac.sourceforge.net/pleac_ruby/processmanagementetc.html^0|2|8|B|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

use <code>IO.popen</code>. <a href="http://pleac.sourceforge.net/pleac_ruby/processmanagementetc.html" rel="noreferrer">This</a> is a good example.

Your code would become something like:

<pre><code>blender = nil
t = Thread.new do
 IO.popen("blender -b mball.blend -o //renders/ -F JPEG -x 1 -f 1") do |blender|
 blender.each do |line|
 puts line
 end
 end
end
</code></pre>

blocks|key|3313736|text|Blender在结束程序之前可能不会打印换行符。相反，它打印回车符(\r)。最简单的解决方案可能是搜索神奇的选项，它打印带有进度指示器的换行符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3313737|问题是IO#gets+(和其他各种IO方法)使用换行符作为分隔符。它们将读取流，直到遇到"\n“字符(该混合器不会发送)。|offset|length|style|CODE|3313738|请尝试设置输入分隔符$/+=+"\r"或改用blender.gets("\r")。|3313739|顺便说一句，对于此类问题，您应该始终检查puts+someobj.inspect或p+someobj+(这两个命令做的是相同的事情)，以查看字符串中是否有隐藏的字符。|3313740|entityMap^0|0|3|7|0|A|9|M|I|0|K|K|15|9|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$]]

Blender probably doesn't print line-breaks until it is ending the program. Instead, it is printing the carriage return character (\r). The easiest solution is probably searching for the magic option which prints line-breaks with the progress indicator.

The problem is that <code>IO#gets</code> (and various other IO methods) use the line break as a delimiter. They will read the stream until they hit the "\n" character (which blender isn't sending).

Try setting the input separator <code>$/ = "\r"</code> or using <code>blender.gets("\r")</code> instead.

BTW, for problems such as these, you should always check <code>puts someobj.inspect</code> or <code>p someobj</code> (both of which do the same thing) to see any hidden characters within the string.

blocks|key|335560|text|我在解决我的这个问题上取得了一些成功。下面是一些细节，以及一些解释，以防任何有类似问题的人发现这个页面。但是如果你不关心细节，这里有一个简短的答案|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|335561|按照以下方式使用PTY.spawn+(当然是使用您自己的命令)：|335562|require+'pty'
cmd+=+"blender+-b+mball.blend+-o+//renders/+-F+JPEG+-x+1+-f+1"+
begin
++PTY.spawn(+cmd+)+do+%7Cstdout,+stdin,+pid%7C
++++begin
++++++#+Do+stuff+with+the+output+here.+Just+printing+to+show+it+works
++++++stdout.each+{+%7Cline%7C+print+line+}
++++rescue+Errno::EIO
++++++puts+"Errno:EIO+error,+but+this+probably+just+means+"+%2B
++++++++++++"that+the+process+has+finished+giving+output"
++++end
++end
rescue+PTY::ChildExited
++puts+"The+child+process+exited!"
end|code-block|syntax|javascript|335563|下面是长长的答案，包含了太多的细节：|335564|真正的问题似乎是，如果一个进程没有显式地刷新它的stdout，那么写到stdout的任何东西都会被缓冲，而不是实际发送，直到进程完成，以便最小化IO+(这显然是许多C库的实现细节，通过降低IO频率来最大化吞吐量)。如果您可以轻松地修改该进程，使其定期刷新stdout，那么这将是您的解决方案。在我的例子中，它是blender，所以对于像我这样的新手来说，修改源代码有点吓人。|335565|但是，当您从shell运行这些进程时，它们会向shell实时显示stdout，并且stdout似乎没有缓冲。我相信只有当从另一个进程调用它时，它才会被缓冲，但如果正在处理一个shell，那么stdout是实时可见的，没有缓冲。|335566|甚至可以使用ruby进程作为其输出必须实时收集的子进程来观察这种行为。只需使用以下代码行创建一个脚本random.rb：|335567|5.times+{+%7Ci%7C+sleep(+3*rand+);+puts+"#{i}"+}|335568|然后使用ruby脚本调用它并返回其输出：|335569|IO.popen(+"ruby+random.rb")+do+%7Crandom%7C
++random.each+{+%7Cline%7C+puts+line+}
end|335570|你会发现你并不是像你所期望的那样实时得到结果，而是在事后一次得到结果。STDOUT正在被缓冲，即使你自己运行random.rb，它也不被缓冲。这可以通过在random.rb中的块中添加STDOUT.flush语句来解决。但是如果你不能改变源码，你必须解决这个问题。您不能从进程外部刷新它。|CODE|335571|如果子进程可以实时打印到shell，那么一定也有办法使用Ruby实时捕获这一点。事实就是如此。你必须使用PTY模块，我相信它包含在ruby核心中(不管怎样是1.8.6)。可悲的是，它没有记录在案。但幸运的是，我找到了一些使用的例子。|335572|首先，为了解释什么是PTY，它代表pseudo+terminal。基本上，它允许ruby脚本将其自身呈现给子进程，就像它是一个真正的用户刚刚在shell中输入了命令一样。因此，只有当用户通过shell+(比如本例中没有缓冲的STDOUT+)启动进程时，才会发生任何改变的行为。隐藏另一个进程已经启动这个进程的事实允许您实时收集STDOUT，因为它没有被缓冲。|335573|要使用random.rb脚本作为子脚本，请尝试以下代码：|335574|require+'pty'
begin
++PTY.spawn(+"ruby+random.rb"+)+do+%7Cstdout,+stdin,+pid%7C
++++begin
++++++stdout.each+{+%7Cline%7C+print+line+}
++++rescue+Errno::EIO
++++end
++end
rescue+PTY::ChildExited
++puts+"The+child+process+exited!"
end|335575|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Pseudo_terminal^0|1R|A|0|0|0|0|0|0|0|0|0|0|2K|C|0|0|H|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1M|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1O|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1P|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1R|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1S|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1T|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1U|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|1V|8|@$9|1W|A|1X|B|12]]|D|@]|E|$]]|$1|13|3|14|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|1Z|8|@]|D|@$9|20|A|21|1|22]]|E|$]]|$1|17|3|18|5|6|7|23|8|@]|D|@]|E|$]]|$1|19|3|1A|5|J|7|24|8|@]|D|@]|E|$K|L]]|$1|1B|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|1C|$1D|$5|1E|1F|1G|E|$1H|1I]]]]

I've had some success in solving this problem of mine. Here are the details, with some explanations, in case anyone having a similar problem finds this page. But if you don't care for details, here's the short answer:

Use PTY.spawn in the following manner (with your own command of course):

<pre><code>require 'pty'
cmd = "blender -b mball.blend -o //renders/ -F JPEG -x 1 -f 1" 
begin
 PTY.spawn( cmd ) do |stdout, stdin, pid|
 begin
 # Do stuff with the output here. Just printing to show it works
 stdout.each { |line| print line }
 rescue Errno::EIO
 puts "Errno:EIO error, but this probably just means " +
 "that the process has finished giving output"
 end
 end
rescue PTY::ChildExited
 puts "The child process exited!"
end
</code></pre>

And here's the long answer, with way too many details:

The real issue seems to be that if a process doesn't explicitly flush its stdout, then anything written to stdout is buffered rather than actually sent, until the process is done, so as to minimize IO (this is apparently an implementation detail of many C libraries, made so that throughput is maximized through less frequent IO). If you can easily modify the process so that it flushes stdout regularly, then that would be your solution. In my case, it was blender, so a bit intimidating for a complete noob such as myself to modify the source. 

But when you run these processes from the shell, they display stdout to the shell in real-time, and the stdout doesn't seem to be buffered. It's only buffered when called from another process I believe, but if a shell is being dealt with, the stdout is seen in real time, unbuffered.

This behavior can even be observed with a ruby process as the child process whose output must be collected in real time. Just create a script, random.rb, with the following line:

<pre><code>5.times { |i| sleep( 3*rand ); puts "#{i}" }
</code></pre>

Then a ruby script to call it and return its output:

<pre><code>IO.popen( "ruby random.rb") do |random|
 random.each { |line| puts line }
end
</code></pre>

You'll see that you don't get the result in real-time as you might expect, but all at once afterwards. STDOUT is being buffered, even though if you run random.rb yourself, it isn't buffered. This can be solved by adding a <code>STDOUT.flush</code> statement inside the block in random.rb. But if you can't change the source, you have to work around this. You can't flush it from outside the process.

If the subprocess can print to shell in real-time, then there must be a way to capture this with Ruby in real-time as well. And there is. You have to use the PTY module, included in ruby core I believe (1.8.6 anyways). Sad thing is that it's not documented. But I found some examples of use fortunately.

First, to explain what PTY is, it stands for <a href="http://en.wikipedia.org/wiki/Pseudo_terminal" rel="noreferrer">pseudo terminal</a>. Basically, it allows the ruby script to present itself to the subprocess as if it's a real user who has just typed the command into a shell. So any altered behavior that occurs only when a user has started the process through a shell (such as the STDOUT not being buffered, in this case) will occur. Concealing the fact that another process has started this process allows you to collect the STDOUT in real-time, as it isn't being buffered.

To make this work with the random.rb script as the child, try the following code:

<pre><code>require 'pty'
begin
 PTY.spawn( "ruby random.rb" ) do |stdout, stdin, pid|
 begin
 stdout.each { |line| print line }
 rescue Errno::EIO
 end
 end
rescue PTY::ChildExited
 puts "The child process exited!"
end
</code></pre>

blocks|key|3313824|text|我不知道在ehsanul回答这个问题的时候，是否还有Open3::pipeline_rw()可用，但它确实让事情变得更简单。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3313825|我不理解ehsanul在搅拌机上的工作，所以我用tar和xz做了另一个例子。tar会将输入文件添加到标准输出流，然后xz获取该stdout并将其再次压缩到另一个标准输出。我们的工作是获取最后一个stdout并将其写入我们的最终文件：|3313826|require+'open3'

if+__FILE__+==+$0
++++cmd_tar+=+['tar',+'-cf',+'-',+'-T',+'-']
++++cmd_xz+=+['xz',+'-z',+'-9e']
++++list_of_files+=+[...]

++++Open3.pipeline_rw(cmd_tar,+cmd_xz)+do+%7Cfirst_stdin,+last_stdout,+wait_threads%7C
++++++++list_of_files.each+{+%7Cf%7C+first_stdin.puts+f+}
++++++++first_stdin.close

++++++++#+Now+start+writing+to+target+file
++++++++open(target_file,+'wb')+do+%7Ctarget_file_io%7C
++++++++++++while+(data+=+last_stdout.read(1024))+do
++++++++++++++++target_file_io.write+data
++++++++++++end
++++++++end+#+open
++++end+#+pipeline_rw
end|code-block|syntax|javascript|3313827|entityMap|0|LINK|mutability|MUTABLE|url|http://ruby-doc.org/stdlib-1.9.3/libdoc/open3/rdoc/Open3.html#method-c-pipeline_rw^0|Q|K|Q|K|0|0|O|3|S|2|12|3|1M|2|1R|6|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

I don't know whether at the time ehsanul answered the question, there was <a href="http://ruby-doc.org/stdlib-1.9.3/libdoc/open3/rdoc/Open3.html#method-c-pipeline_rw" rel="nofollow"><code>Open3::pipeline_rw()</code></a> available yet, but it really makes things simpler. 

I don't understand ehsanul's job with Blender, so I made another example with <code>tar</code> and <code>xz</code>. <code>tar</code> will add input file(s) to stdout stream, then <code>xz</code> take that <code>stdout</code> and compress it, again, to another stdout. Our job is to take the last stdout and write it to our final file:

<pre><code>require 'open3'

if __FILE__ == $0
 cmd_tar = ['tar', '-cf', '-', '-T', '-']
 cmd_xz = ['xz', '-z', '-9e']
 list_of_files = [...]

 Open3.pipeline_rw(cmd_tar, cmd_xz) do |first_stdin, last_stdout, wait_threads|
 list_of_files.each { |f| first_stdin.puts f }
 first_stdin.close

 # Now start writing to target file
 open(target_file, 'wb') do |target_file_io|
 while (data = last_stdout.read(1024)) do
 target_file_io.write data
 end
 end # open
 end # pipeline_rw
end
</code></pre>

blocks|key|3313844|text|老问题，但也有类似的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3313845|在没有真正改变我的Ruby代码的情况下，有一件事是有帮助的，那就是用stdbuf包装我的管道，如下所示：|offset|length|3313846|cmd+=+"stdbuf+-oL+-eL+-i0++openssl+s_client+-connect+#{xAPI_ADDRESS}:#{xAPI_PORT}"

@xSess+=+IO.popen(cmd.split+"+",+mode+=+"w%2B")++|code-block|syntax|javascript|3313847|在我的示例中，我希望与之交互的实际命令是openssl。|style|BOLD|3313848|-oL+-eL告诉它只缓冲STDOUT和STDERR到换行符。将L替换为0以完全取消缓冲。|CODE|3313849|然而，这并不总是有效的:有时目标进程会强制使用自己的流缓存类型，就像另一个答案所指出的那样。|3313850|entityMap|0|LINK|mutability|MUTABLE|url|https://www.gnu.org/software/coreutils/manual/html_node/stdbuf-invocation.html^0|0|Y|6|0|0|0|K|7|0|0|7|W|1|10|1|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|17|8|@$D|18|E|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$D|1B|E|1C|M|Q]|$D|1D|E|1E|M|Q]|$D|1F|E|1G|M|Q]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1H|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

Old question, but had similar problems.

Without really changing my Ruby code, one thing that helped was wrapping my pipe with <a href="https://www.gnu.org/software/coreutils/manual/html_node/stdbuf-invocation.html" rel="nofollow noreferrer">stdbuf</a>, like so:

<pre><code>cmd = "stdbuf -oL -eL -i0 openssl s_client -connect #{xAPI_ADDRESS}:#{xAPI_PORT}"

@xSess = IO.popen(cmd.split " ", mode = "w+") 

</code></pre>

In my example, the actual command I want to interact with as if it were a shell, is openssl.

<code>-oL -eL</code> tell it to buffer STDOUT and STDERR only upto a newline. Replace <code>L</code> with <code>0</code> to unbuffer completely.

This doesn't always work, though: sometimes the target process enforces its own stream buffer type, like another answer pointed out.

I want to run blender from the command line through a ruby script, which will then process the output given by blender line by line to update a progress bar in a GUI. It's not really important that blender is the external process whose stdout I need to read.

I can't seem to be able to catch the progress messages blender normally prints to the shell when the blender process is still running, and I've tried a few ways. I always seem to access the stdout of blender after blender has quit, not while it's still running.

Here's an example of a failed attempt. It does get and print the first 25 lines of the output of blender, but only after the blender process has exited:

<pre><code>blender = nil
t = Thread.new do
 blender = open "| blender -b mball.blend -o //renders/ -F JPEG -x 1 -f 1"
end
puts "Blender is doing its job now..."
25.times { puts blender.gets}
</code></pre>

Edit:

To make it a little clearer, the command invoking blender gives back a stream of output in the shell, indicating progress (part 1-16 completed etc). It seems that any call to "gets" the output is blocked until blender quits. The issue is how to get access to this output while blender is still running, as blender prints it's output to shell.

Continuously read from STDOUT of external process in Ruby

我想通过ruby脚本从命令行运行blender，然后它将逐行处理blender给出的输出，以更新GUI中的进度条。blender是我需要读取其stdout的外部进程并不重要。当blender进程仍在运行时，我似乎无法捕捉blender通常打印到shell的进度消息，我已经尝试了几种方法。我似乎总是在blender退出后...

问在Ruby中连续读取外部进程的STDOUT
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中连续读取外部进程的STDOUTEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中连续读取外部进程的STDOUT
EN