crazy_ivan 0.3.3 → 1.0.0

data/lib/crazy_ivan/vendor/open4-1.0.1/lib/open4.rb

@@ -0,0 +1,401 @@
+# vim: ts=2:sw=2:sts=2:et:fdm=marker
+require 'fcntl'
+require 'timeout'
+require 'thread'
+
+module Open4
+#--{{{
+  VERSION = '1.0.1'
+  def self.version() VERSION end
+
+  class Error < ::StandardError; end
+
+  def popen4(*cmd, &b)
+#--{{{
+    pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+    verbose = $VERBOSE
+    begin
+      $VERBOSE = nil
+      ps.first.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+      cid = fork {
+        pw.last.close
+        STDIN.reopen pw.first
+        pw.first.close
+
+        pr.first.close
+        STDOUT.reopen pr.last
+        pr.last.close
+
+        pe.first.close
+        STDERR.reopen pe.last
+        pe.last.close
+
+        STDOUT.sync = STDERR.sync = true
+
+        begin
+          exec(*cmd)
+          raise 'forty-two' 
+        rescue Exception => e
+          Marshal.dump(e, ps.last)
+          ps.last.flush
+        end
+        ps.last.close unless (ps.last.closed?)
+        exit!
+      }
+    ensure
+      $VERBOSE = verbose
+    end
+
+    [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
+
+    begin
+      e = Marshal.load ps.first
+      raise(Exception === e ? e : "unknown failure!")
+    rescue EOFError # If we get an EOF error, then the exec was successful
+      42
+    ensure
+      ps.first.close
+    end
+
+    pw.last.sync = true
+
+    pi = [pw.last, pr.first, pe.first]
+
+    if b 
+      begin
+        b[cid, *pi]
+        Process.waitpid2(cid).last
+      ensure
+        pi.each{|fd| fd.close unless fd.closed?}
+      end
+    else
+      [cid, pw.last, pr.first, pe.first]
+    end
+#--}}}
+  end
+  alias open4 popen4
+  module_function :popen4
+  module_function :open4
+
+  class SpawnError < Error
+#--{{{
+    attr 'cmd'
+    attr 'status'
+    attr 'signals'
+    def exitstatus
+      @status.exitstatus
+    end
+    def initialize cmd, status
+      @cmd, @status = cmd, status
+      @signals = {} 
+      if status.signaled?
+        @signals['termsig'] = status.termsig
+        @signals['stopsig'] = status.stopsig
+      end
+      sigs = @signals.map{|k,v| "#{ k }:#{ v.inspect }"}.join(' ')
+      super "cmd <#{ cmd }> failed with status <#{ exitstatus.inspect }> signals <#{ sigs }>"
+    end
+#--}}}
+  end
+
+  class ThreadEnsemble
+#--{{{
+    attr 'threads'
+
+    def initialize cid
+      @cid, @threads, @argv, @done, @running = cid, [], [], Queue.new, false
+      @killed = false
+    end
+
+    def add_thread *a, &b
+      @running ? raise : (@argv << [a, b])
+    end
+
+#
+# take down process more nicely
+#
+    def killall
+      c = Thread.critical
+      return nil if @killed
+      Thread.critical = true
+      (@threads - [Thread.current]).each{|t| t.kill rescue nil}
+      @killed = true
+    ensure
+      Thread.critical = c
+    end
+
+    def run
+      @running = true
+
+      begin
+        @argv.each do |a, b|
+          @threads << Thread.new(*a) do |*a|
+            begin
+              b[*a]
+            ensure
+              killall rescue nil if $!
+              @done.push Thread.current
+            end
+          end
+        end
+      rescue
+        killall
+        raise
+      ensure
+        all_done
+      end
+
+      @threads.map{|t| t.value}
+    end
+
+    def all_done
+      @threads.size.times{ @done.pop }
+    end
+#--}}}
+  end
+
+  def to timeout = nil
+#--{{{
+    Timeout.timeout(timeout){ yield }
+#--}}}
+  end
+  module_function :to
+
+  def new_thread *a, &b
+#--{{{
+    cur = Thread.current
+    Thread.new(*a) do |*a|
+      begin
+        b[*a]
+      rescue Exception => e
+        cur.raise e
+      end
+    end
+#--}}}
+  end
+  module_function :new_thread
+
+  def getopts opts = {}
+#--{{{
+    lambda do |*args|
+      keys, default, ignored = args
+      catch('opt') do
+        [keys].flatten.each do |key|
+          [key, key.to_s, key.to_s.intern].each do |key|
+            throw 'opt', opts[key] if opts.has_key?(key)
+          end
+        end
+        default
+      end
+    end
+#--}}}
+  end
+  module_function :getopts
+
+  def relay src, dst = nil, t = nil
+#--{{{
+    send_dst =
+      if dst.respond_to?(:call)
+        lambda{|buf| dst.call(buf)}
+      else
+        lambda{|buf| dst << buf}
+      end
+
+    unless src.nil?
+      if src.respond_to? :gets
+        while buf = to(t){ src.gets }
+          send_dst[buf]
+        end
+
+      elsif src.respond_to? :each
+        q = Queue.new
+        th = nil
+
+        timer_set = lambda do |t|
+          th = new_thread{ to(t){ q.pop } }
+        end
+
+        timer_cancel = lambda do |t|
+          th.kill if th rescue nil
+        end
+
+        timer_set[t]
+        begin
+          src.each do |buf|
+            timer_cancel[t]
+            send_dst[buf]
+            timer_set[t]
+          end
+        ensure
+          timer_cancel[t]
+        end
+
+      elsif src.respond_to? :read
+        buf = to(t){ src.read }
+        send_dst[buf]
+
+      else
+        buf = to(t){ src.to_s }
+        send_dst[buf]
+      end
+    end
+#--}}}
+  end
+  module_function :relay
+
+  def spawn arg, *argv 
+#--{{{
+    argv.unshift(arg)
+    opts = ((argv.size > 1 and Hash === argv.last) ? argv.pop : {})
+    argv.flatten!
+    cmd = argv.join(' ')
+
+
+    getopt = getopts opts
+
+    ignore_exit_failure = getopt[ 'ignore_exit_failure', getopt['quiet', false] ]
+    ignore_exec_failure = getopt[ 'ignore_exec_failure', !getopt['raise', true] ]
+    exitstatus = getopt[ %w( exitstatus exit_status status ) ]
+    stdin = getopt[ %w( stdin in i 0 ) << 0 ]
+    stdout = getopt[ %w( stdout out o 1 ) << 1 ]
+    stderr = getopt[ %w( stderr err e 2 ) << 2 ]
+    pid = getopt[ 'pid' ]
+    timeout = getopt[ %w( timeout spawn_timeout ) ]
+    stdin_timeout = getopt[ %w( stdin_timeout ) ]
+    stdout_timeout = getopt[ %w( stdout_timeout io_timeout ) ]
+    stderr_timeout = getopt[ %w( stderr_timeout ) ]
+    status = getopt[ %w( status ) ]
+    cwd = getopt[ %w( cwd dir ) ]
+
+    exitstatus =
+      case exitstatus
+        when TrueClass, FalseClass
+          ignore_exit_failure = true if exitstatus
+          [0]
+        else
+          [*(exitstatus || 0)].map{|i| Integer i}
+      end
+
+    stdin ||= '' if stdin_timeout
+    stdout ||= '' if stdout_timeout
+    stderr ||= '' if stderr_timeout
+
+    started = false
+
+    status =
+      begin
+        chdir(cwd) do
+          Timeout::timeout(timeout) do
+            popen4(*argv) do |c, i, o, e|
+              started = true
+
+              %w( replace pid= << push update ).each do |msg|
+                break(pid.send(msg, c)) if pid.respond_to? msg 
+              end
+
+              te = ThreadEnsemble.new c
+
+              te.add_thread(i, stdin) do |i, stdin|
+                relay stdin, i, stdin_timeout
+                i.close rescue nil
+              end
+
+              te.add_thread(o, stdout) do |o, stdout|
+                relay o, stdout, stdout_timeout
+              end
+
+              te.add_thread(e, stderr) do |o, stderr|
+                relay e, stderr, stderr_timeout
+              end
+
+              te.run
+            end
+          end
+        end
+      rescue
+        raise unless(not started and ignore_exec_failure)
+      end
+
+    raise SpawnError.new(cmd, status) unless
+      (ignore_exit_failure or (status.nil? and ignore_exec_failure) or exitstatus.include?(status.exitstatus))
+
+    status
+#--}}}
+  end
+  module_function :spawn
+
+  def chdir cwd, &block
+    return(block.call Dir.pwd) unless cwd
+    Dir.chdir cwd, &block
+  end
+  module_function :chdir
+
+  def background arg, *argv 
+#--{{{
+    require 'thread'
+    q = Queue.new
+    opts = { 'pid' => q, :pid => q }
+    case argv.last
+      when Hash
+        argv.last.update opts
+      else
+        argv.push opts
+    end
+    thread = Thread.new(arg, argv){|arg, argv| spawn arg, *argv}
+    sc = class << thread; self; end
+    sc.module_eval {
+      define_method(:pid){ @pid ||= q.pop }
+      define_method(:spawn_status){ @spawn_status ||= value }
+      define_method(:exitstatus){ @exitstatus ||= spawn_status.exitstatus }
+    }
+    thread
+#--}}}
+  end
+  alias bg background
+  module_function :background
+  module_function :bg
+
+  def maim pid, opts = {}
+#--{{{
+    getopt = getopts opts
+    sigs = getopt[ 'signals', %w(SIGTERM SIGQUIT SIGKILL) ]
+    suspend = getopt[ 'suspend', 4 ]
+    pid = Integer pid
+    existed = false
+    sigs.each do |sig|
+      begin
+        Process.kill sig, pid
+        existed = true 
+      rescue Errno::ESRCH
+        return(existed ? nil : true)
+      end
+      return true unless alive? pid
+      sleep suspend
+      return true unless alive? pid
+    end
+    return(not alive?(pid)) 
+#--}}}
+  end
+  module_function :maim
+
+  def alive pid
+#--{{{
+    pid = Integer pid
+    begin
+      Process.kill 0, pid
+      true
+    rescue Errno::ESRCH
+      false
+    end
+#--}}}
+  end
+  alias alive? alive
+  module_function :alive
+  module_function :'alive?'
+#--}}}
+end
+
+def open4(*cmd, &b) cmd.size == 0 ? Open4 : Open4::popen4(*cmd, &b) end

data/lib/crazy_ivan/vendor/open4-1.0.1/open4.gemspec

@@ -0,0 +1,28 @@
+## open4.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "open4"
+  spec.version = "1.0.1"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "open4"
+
+  spec.description = "manage child processes and their io handles easily"
+
+  spec.files = ["lib", "lib/open4.rb", "open4.gemspec", "Rakefile", "README", "README.erb", "samples", "samples/bg.rb", "samples/block.rb", "samples/exception.rb", "samples/simple.rb", "samples/spawn.rb", "samples/stdin_timeout.rb", "samples/timeout.rb", "white_box", "white_box/leak.rb"]
+  spec.executables = []
+  
+  spec.require_path = "lib"
+
+  spec.has_rdoc = true
+  spec.test_files = nil
+  #spec.add_dependency 'lib', '>= version'
+  #spec.add_dependency 'fattr'
+
+  spec.extensions.push(*[])
+
+  spec.rubyforge_project = "codeforpeople"
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://github.com/ahoward/open4/tree/master"
+end

data/lib/crazy_ivan/vendor/open4-1.0.1/samples/bg.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+require 'open4'
+include Open4
+
+stdin = '42'
+stdout = ''
+stderr = ''
+
+t = bg 'ruby -e"sleep 4; puts ARGF.read"', 0=>stdin, 1=>stdout, 2=>stderr
+
+waiter = Thread.new{ y t.pid => t.exitstatus } # t.exitstatus is a blocking call!
+
+while((status = t.status))
+  y "status" => status
+  sleep 1
+end
+
+waiter.join
+
+y "stdout" => stdout
+

data/lib/crazy_ivan/vendor/open4-1.0.1/samples/block.rb

@@ -0,0 +1,19 @@
+require 'open4'
+#
+# when using block form the child process is automatically waited using
+# waitpid2
+#
+
+status =
+  Open4::popen4("sh") do |pid, stdin, stdout, stderr|
+    stdin.puts "echo 42.out"
+    stdin.puts "echo 42.err 1>&2"
+    stdin.close
+
+    puts "pid        : #{ pid }"
+    puts "stdout     : #{ stdout.read.strip }"
+    puts "stderr     : #{ stderr.read.strip }"
+  end
+
+    puts "status     : #{ status.inspect }"
+    puts "exitstatus : #{ status.exitstatus }"

data/lib/crazy_ivan/vendor/open4-1.0.1/samples/exception.rb

@@ -0,0 +1,3 @@
+require "open4"
+
+Open4::popen4 "noexist"

data/lib/crazy_ivan/vendor/open4-1.0.1/samples/simple.rb

@@ -0,0 +1,15 @@
+require "open4"
+
+pid, stdin, stdout, stderr = Open4::popen4 "sh"
+
+stdin.puts "echo 42.out"
+stdin.puts "echo 42.err 1>&2"
+stdin.close
+
+ignored, status = Process::waitpid2 pid
+
+puts "pid        : #{ pid }"
+puts "stdout     : #{ stdout.read.strip }"
+puts "stderr     : #{ stderr.read.strip }"
+puts "status     : #{ status.inspect }"
+puts "exitstatus : #{ status.exitstatus }"

data/lib/crazy_ivan/vendor/open4-1.0.1/samples/spawn.rb

@@ -0,0 +1,16 @@
+require 'open4'
+include Open4
+
+cat = 'ruby -e"  ARGF.each{|line| STDOUT << line}  "'
+
+stdout, stderr = '', ''
+status = spawn cat, 'stdin' => '42', 'stdout' => stdout, 'stderr' => stderr
+p status
+p stdout
+p stderr
+
+stdout, stderr = '', ''
+status = spawn cat, 0=>'42', 1=>stdout, 2=>stderr
+p status
+p stdout
+p stderr

data/lib/crazy_ivan/vendor/open4-1.0.1/samples/stdin_timeout.rb

@@ -0,0 +1,9 @@
+require 'open4'
+
+producer = 'ruby -e" STDOUT.sync = true; loop{sleep(rand+rand) and puts 42} " 2>/dev/null'
+
+consumer = 'ruby -e" STDOUT.sync = true; STDIN.each{|line| puts line} "'
+
+open4(producer) do |pid, i, o, e|
+  open4.spawn consumer, 0=>o, 1=>STDOUT, :stdin_timeout => 1.4
+end

data/lib/crazy_ivan/vendor/open4-1.0.1/samples/timeout.rb

@@ -0,0 +1,37 @@
+
+require 'open4'
+
+def show_failure
+  fork{ yield }
+  Process.wait
+  puts
+end
+
+#
+# command timeout
+#
+  show_failure{
+    open4.spawn 'sleep 42', 'timeout' => 1
+  }
+
+#
+# stdin timeout
+#
+  show_failure{
+
+    producer = 'ruby -e" STDOUT.sync = true; loop{sleep(rand+rand) and puts 42} " 2>/dev/null'
+
+    consumer = 'ruby -e" STDOUT.sync = true; STDIN.each{|line| puts line} "'
+
+    open4(producer) do |pid, i, o, e|
+      open4.spawn consumer, 0=>o, 1=>STDOUT, :stdin_timeout => 1.4
+    end
+  }
+
+#
+# stdout timeout (stderr is similar)
+#
+
+  show_failure{
+    open4.spawn 'ruby -e"  sleep 2 and puts 42  "', 'stdout_timeout' => 1
+  }

data/lib/crazy_ivan/vendor/open4-1.0.1/white_box/leak.rb

@@ -0,0 +1,17 @@
+require 'open4'
+
+pid = Process.pid
+fds = lambda{|pid| Dir["/proc/#{ pid }/fd/*"]}
+
+loop do
+  before = fds[pid] 
+  Open4.popen4 'ruby -e"buf = STDIN.read; STDOUT.puts buf; STDERR.puts buf "' do |p,i,o,e|
+    i.puts 42
+    i.close_write
+    o.read
+    e.read
+  end
+  after = fds[pid] 
+  p(after - before)
+  puts
+end

data/lib/crazy_ivan/vendor/open4.rb

@@ -0,0 +1,10 @@
+# Prefer gems to the bundled libs.
+require 'rubygems'
+
+begin
+  gem 'open4', '>= 1.0.1'
+rescue LoadError
+  $:.unshift "#{File.dirname(__FILE__)}/open4-1.0.1"
+end
+
+require 'open4'

data/lib/crazy_ivan/version.rb

@@ -1,8 +1,8 @@
 module CrazyIvan
   module VERSION #:nodoc:
-    MAJOR = 3
-    MINOR = 2
-    TINY  = 3
+    MAJOR = 0
+    MINOR = 4
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end