एक पॉपन काम के भीतर टाइमआउट, लेकिन एक टाइमआउट के अंदर पॉपन नहीं करता है?

Question

यह कोड में समझाने के लिए सबसे आसान है:

require 'timeout' 

puts "this block will properly kill the sleep after a second" 

IO.popen("sleep 60") do |io| 
    begin 
    Timeout.timeout(1) do 
     while (line=io.gets) do 
     output += line 
     end 
    end 
    rescue Timeout::Error => ex 
    Process.kill 9, io.pid 
    puts "timed out: this block worked correctly" 
    end 
end 

puts "but this one blocks for >1 minute" 

begin 
    pid = 0 
    Timeout.timeout(1) do 
    IO.popen("sleep 60") do |io| 
     pid = io.pid 
     while (line=io.gets) do 
     output += line 
     end 
    end 
    end 
rescue Timeout::Error => ex 
    puts "timed out: the exception gets thrown, but much too late" 
end 

मेरे दो ब्लॉकों के मानसिक मॉडल समान होता है:

तो, मुझे याद आ रही?

संपादित करें: ट्विटर पर सुझाव दिया गया है कि पहले मामले में, किसी कारण से, पाइप सॉकेट गैर-अवरोधन मोड में जाती है, लेकिन दूसरे में यह नहीं होती है। मैं किसी भी कारण से नहीं सोच सकता कि ऐसा क्यों होगा, और न ही मैं यह समझ सकता हूं कि वर्णनकर्ता के झंडे कैसे प्राप्त करें, लेकिन कम से कम एक व्यावहारिक उत्तर है? उस संभावना पर काम करना।

Answer 1

अहा, सूक्ष्म देखें।

दूसरे मामले में आईओ # पॉपन ब्लॉक के अंत में एक छिपी हुई, ensure खंड अवरुद्ध है। टाइमआउट :: त्रुटि समय पर उठाया गया है, लेकिन आप rescue नहीं कर सकते हैं जब तक कि निष्पादन उस अंतर्निहित ensure खंड से निष्पादन न हो जाए।

Under the hood, IO.popen(cmd) { |io| ... } कुछ इस तरह है:

def my_illustrative_io_popen(cmd, &block) 
    begin 
    pio = IO.popen(cmd) 
    block.call(pio)  # This *is* interrupted... 
    ensure 
    pio.close   # ...but then control goes here, which blocks on cmd's termination 
    end 

और आईओ # पास कॉल वास्तव में है और अधिक या कम एक pclose(3), जो सो बच्चे बाहर निकलता है जब तक waitpid(2) में आप ब्लॉक कर रहा है।

तुम इतनी तरह इस की पुष्टि कर सकते हैं:

#!/usr/bin/env ruby 

require 'timeout' 

BEGIN { $BASETIME = Time.now.to_i } 

def xputs(msg) 
    puts "%4.2f: %s" % [(Time.now.to_f - $BASETIME), msg] 
end 

begin 
    Timeout.timeout(3) do 
    begin 
     xputs "popen(sleep 10)" 
     pio = IO.popen("sleep 10") 
     sleep 100      # or loop over pio.gets or whatever 
    ensure 
     xputs "Entering ensure block" 
     #Process.kill 9, pio.pid  # <--- This would solve your problem! 
     pio.close 
     xputs "Leaving ensure block" 
    end 
    end 
rescue Timeout::Error => ex 
    xputs "rescuing: #{ex}" 
end 

तो, आप क्या कर सकते हैं?

आपको इसे स्पष्ट तरीके से करना होगा, क्योंकि दुभाषिया आईओ # पॉपन ensure तर्क को ओवरराइड करने का कोई तरीका नहीं दिखाता है। आप उपरोक्त कोड को प्रारंभिक टेम्पलेट के रूप में उपयोग कर सकते हैं और उदाहरण के लिए kill() लाइन को असम्बद्ध कर सकते हैं।

Answer 2

पहले ब्लॉक में, टाइमआउट बच्चे में उठाया जाता है, इसे मारता है और माता-पिता को नियंत्रण वापस कर देता है। दूसरे ब्लॉक में, माता-पिता में टाइमआउट उठाया जाता है। बच्चे को संकेत कभी नहीं मिलता है।

io.chttps://github.com/ruby/ruby/blob/trunk/io.c#L6021 और timeout.rbhttps://github.com/ruby/ruby/blob/trunk/lib/timeout.rb#L51