scmd 2.1.1 → 2.1.2

data/Gemfile

@@ -3,3 +3,5 @@ source "https://rubygems.org"
 gemspec
 
 gem 'rake'
+gem 'pry'
+gem "whysoslow"

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-Present Kelly Redding, Collin Redding
+Copyright (c) 2012-Present Kelly Redding and Collin Redding
 
 MIT License
 

data/Rakefile

@@ -1 +1 @@
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"

data/bench/results.txt

@@ -0,0 +1,80 @@
+echo hi: 1 times
+----------------
+whysoslow? ..
+
+mem @ start             29 MB                   ??
+mem @ finish            29 MB                   +   0 MB,   0%
+
+         user     system   total    real
+time     0.0 ms   0.0 ms   0.0 ms   1.928 ms
+
+echo hi: 10 times
+-----------------
+whysoslow? ..
+
+mem @ start             38 MB                   ??
+mem @ finish            38 MB                   -   0 MB,   0%
+
+          user      system    total     real
+time      0.0 ms    0.0 ms    10.0 ms   16.874 ms
+
+echo hi: 100 times
+------------------
+whysoslow? ..
+
+mem @ start             38 MB                   ??
+mem @ finish            38 MB                   -   0 MB,   0%
+
+           user       system     total      real
+time       20.0 ms    20.0 ms    130.0 ms   147.925 ms
+
+echo hi: 1000 times
+-------------------
+whysoslow? ..
+
+mem @ start             38 MB                   ??
+mem @ finish            41 MB                   +   3 MB,   7%
+
+            user        system      total       real
+time        170.0 ms    180.0 ms    1320.0 ms   1390.406 ms
+
+cat test/support/bigger-than-64k.txt: 1 times
+---------------------------------------------
+whysoslow? ..
+
+mem @ start             41 MB                   ??
+mem @ finish            41 MB                   -   0 MB,   0%
+
+         user     system   total    real
+time     0.0 ms   0.0 ms   0.0 ms   3.487 ms
+
+cat test/support/bigger-than-64k.txt: 10 times
+----------------------------------------------
+whysoslow? ..
+
+mem @ start             41 MB                   ??
+mem @ finish            43 MB                   +   2 MB,   4%
+
+          user      system    total     real
+time      0.0 ms    0.0 ms    20.0 ms   30.533 ms
+
+cat test/support/bigger-than-64k.txt: 100 times
+-----------------------------------------------
+whysoslow? ..
+
+mem @ start             43 MB                   ??
+mem @ finish            85 MB                   +  42 MB,  98%
+
+          user      system    total     real
+time      40.0 ms   40.0 ms   250.0 ms  274.06 ms
+
+cat test/support/bigger-than-64k.txt: 1000 times
+------------------------------------------------
+whysoslow? ..
+
+mem @ start             85 MB                   ??
+mem @ finish            506 MB                  + 421 MB, 497%
+
+            user        system      total       real
+time        360.0 ms    400.0 ms    2540.0 ms   2649.686 ms
+

data/bench/runner.rb

@@ -0,0 +1,29 @@
+require 'whysoslow'
+require 'scmd'
+
+class ScmdBenchRunner
+
+  attr_reader :result
+
+  def self.run(*args)
+    self.new(*args).run
+  end
+
+  def initialize(printer_io, cmd, num_times = 10)
+    @cmd = cmd
+    @proc = proc do
+      num_times.times{ cmd.run! }
+    end
+
+    @printer = Whysoslow::DefaultPrinter.new(printer_io, {
+      :title => "#{@cmd.cmd_str}: #{num_times} times",
+      :verbose => true
+    })
+    @runner = Whysoslow::Runner.new(@printer)
+  end
+
+  def run
+    @runner.run &@proc
+  end
+
+end

data/lib/scmd.rb

@@ -7,4 +7,13 @@ module Scmd
     Command.new(*args, &block)
   end
 
+  TimeoutError = Class.new(::RuntimeError)
+
+  class RunError < ::RuntimeError
+    def initialize(stderr, called_from = nil)
+      super(stderr)
+      set_backtrace(called_from || caller)
+    end
+  end
+
 end

data/lib/scmd/command.rb

@@ -1,4 +1,6 @@
+require 'thread'
 require 'posix-spawn'
+require 'scmd'
 
 # Scmd::Command is a base wrapper for handling system commands. Initialize it
 # with with a string specifying the command to execute.  You can then run the
@@ -7,73 +9,77 @@ require 'posix-spawn'
 
 module Scmd
 
-  class RunError < ::RuntimeError
-    def initialize(stderr, called_from)
-      super(stderr)
-      set_backtrace(called_from)
-    end
-  end
-
-  TimeoutError = Class.new(::RuntimeError)
-
   class Command
-    WAIT_INTERVAL = 0.1 # seconds
-    STOP_TIMEOUT  = 3   # seconds
-    RunData = Class.new(Struct.new(:pid, :stdin, :stdout, :stderr))
+    READ_SIZE            = 10240 # bytes
+    READ_CHECK_TIMEOUT   = 0.001 # seconds
+    DEFAULT_STOP_TIMEOUT = 3     # seconds
 
     attr_reader :cmd_str
     attr_reader :pid, :exitstatus, :stdout, :stderr
 
     def initialize(cmd_str)
       @cmd_str = cmd_str
-      setup
+      reset_attrs
     end
 
-    def run(input=nil)
+    def run(input = nil)
       run!(input) rescue RunError
       self
     end
 
-    def run!(input=nil)
-      called_from = caller
-
+    def run!(input = nil)
+      start_err_msg, start_err_bt = nil, nil
       begin
         start(input)
+      rescue StandardError => err
+        start_err_msg, start_err_bt = err.message, err.backtrace
       ensure
         wait # indefinitely until cmd is done running
-        raise RunError.new(@stderr, called_from) if !success?
+        raise RunError.new(start_err_msg || @stderr, start_err_bt || caller) if !success?
       end
 
       self
     end
 
-    def start(input=nil)
-      setup
-      @run_data = RunData.new(*POSIX::Spawn::popen4(@cmd_str))
-      @pid = @run_data.pid.to_i
-      if !input.nil?
-        [*input].each{|line| @run_data.stdin.puts line.to_s}
-        @run_data.stdin.close
+    def start(input = nil)
+      setup_run
+
+      @pid = @child_process.pid.to_i
+      @child_process.write(input)
+      @read_output_thread = Thread.new do
+        while @child_process.check_for_exit
+          begin
+            read_output
+          rescue EOFError => err
+          end
+        end
+        @stop_w.write_nonblock('.')
       end
     end
 
-    def wait(timeout=nil)
+    def wait(timeout = nil)
       return if !running?
 
-      pidnum, pidstatus = wait_for_exit(timeout)
-      @stdout     += @run_data.stdout.read.strip
-      @stderr     += @run_data.stderr.read.strip
-      @exitstatus  = pidstatus.exitstatus || pidstatus.termsig
+      wait_for_exit(timeout)
+      if @child_process.running?
+        kill
+        raise(TimeoutError, "`#{@cmd_str}` timed out (#{timeout}s).")
+      end
+      @read_output_thread.join
 
-      teardown
+      @stdout << @child_process.flush_stdout
+      @stderr << @child_process.flush_stderr
+      @exitstatus = @child_process.exitstatus
+
+      teardown_run
     end
 
-    def stop(timeout=nil)
+    def stop(timeout = nil)
       return if !running?
 
       send_term
       begin
-        wait(timeout || STOP_TIMEOUT)
+        wait(timeout || DEFAULT_STOP_TIMEOUT)
       rescue TimeoutError => err
         kill
       end
@@ -87,7 +93,7 @@ module Scmd
     end
 
     def running?
-      !@run_data.nil?
+      !@child_process.nil?
     end
 
     def success?
@@ -107,32 +113,31 @@ module Scmd
 
     private
 
+    def read_output
+      @child_process.read(READ_SIZE){ |out, err| @stdout += out; @stderr += err }
+    end
+
     def wait_for_exit(timeout)
-      if timeout.nil?
-        ::Process::waitpid2(@run_data.pid)
-      else
-        timeout_time = Time.now + timeout
-        pid, status = nil, nil
-        while pid.nil? &&  Time.now < timeout_time
-          sleep WAIT_INTERVAL
-          pid, status = ::Process.waitpid2(@run_data.pid, ::Process::WNOHANG)
-          pid = nil if pid == 0 # may happen on jruby
-        end
-        raise(TimeoutError, "`#{@cmd_str}` timed out (#{timeout}s).") if pid.nil?
-        [pid, status]
-      end
+      ios, _, _ = IO.select([ @stop_r ], nil, nil, timeout)
+      @stop_r.read_nonblock(1) if ios && ios.include?(@stop_r)
     end
 
-    def setup
-      @pid = @exitstatus = @run_data = nil
-      @stdout = @stderr = ''
+    def reset_attrs
+      @stdout, @stderr, @pid, @exitstatus = '', '', nil, nil
     end
 
-    def teardown
-      [@run_data.stdin, @run_data.stdout, @run_data.stderr].each do |io|
-        io.close if !io.closed?
-      end
-      @run_data = nil
+    def setup_run
+      reset_attrs
+      @stop_r, @stop_w = IO.pipe
+      @read_output_thread = nil
+      @child_process = ChildProcess.new(@cmd_str)
+    end
+
+    def teardown_run
+      @child_process.teardown
+      [@stop_r, @stop_w].each{ |fd| fd.close if fd && !fd.closed? }
+      @stop_r, @stop_w = nil, nil
+      @child_process, @read_output_thread = nil, nil
       true
     end
 
@@ -146,7 +151,66 @@ module Scmd
 
     def send_signal(sig)
       return if !running?
-      ::Process.kill sig, @run_data.pid
+      ::Process.kill sig, @child_process.pid
+    end
+
+    class ChildProcess
+
+      attr_reader :pid, :stdin, :stdout, :stderr
+
+      def initialize(cmd_str)
+        @pid, @stdin, @stdout, @stderr = *::POSIX::Spawn::popen4(cmd_str)
+        @wait_pid, @wait_status = nil, nil
+      end
+
+      def check_for_exit
+        if @wait_pid.nil?
+          @wait_pid, @wait_status = ::Process.waitpid2(@pid, ::Process::WNOHANG)
+          @wait_pid = nil if @wait_pid == 0 # may happen on jruby
+        end
+        @wait_pid.nil?
+      end
+
+      def running?
+        @wait_pid.nil?
+      end
+
+      def exitstatus
+        return nil if @wait_status.nil?
+        @wait_status.exitstatus || @wait_status.termsig
+      end
+
+      def write(input)
+        if !input.nil?
+          [*input].each{ |line| @stdin.puts line.to_s }
+          @stdin.close
+        end
+      end
+
+      def read(size)
+        ios, _, _ = IO.select([ @stdout, @stderr ], nil, nil, READ_CHECK_TIMEOUT)
+        if ios && block_given?
+          yield read_if_ready(ios, @stdout, size), read_if_ready(ios, @stderr, size)
+        end
+      end
+
+      def flush_stdout; @stdout.read; end
+      def flush_stderr; @stderr.read; end
+
+      def teardown
+        [@stdin, @stdout, @stderr].each{ |fd| fd.close if fd && !fd.closed? }
+      end
+
+      private
+
+      def read_if_ready(ready_ios, io, size)
+        ready_ios.include?(io) ? read_by_size(io, size) : ''
+      end
+
+      def read_by_size(io, size)
+        io.read_nonblock(size)
+      end
+
     end
 
   end

data/lib/scmd/version.rb

@@ -1,3 +1,3 @@
 module Scmd
-  VERSION = "2.1.1"
+  VERSION = "2.1.2"
 end

data/scmd.gemspec

@@ -11,12 +11,13 @@ Gem::Specification.new do |gem|
   gem.description = %q{Build and run system commands.}
   gem.summary     = %q{Build and run system commands.}
   gem.homepage    = "http://github.com/redding/scmd"
+  gem.license     = 'MIT'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert")
+  gem.add_development_dependency("assert", ["~> 2.3"])
   gem.add_dependency("posix-spawn")
 end

data/script/bench.rb

@@ -0,0 +1,47 @@
+# $ bundle exec ruby script/bench.rb
+
+require 'bench/runner'
+
+class ScmdBenchLogger
+
+  def initialize(file_path)
+    @file = File.open(file_path, 'w')
+    @ios = [@file, $stdout]
+    yield self
+    @file.close
+  end
+
+  def method_missing(meth, *args, &block)
+    @ios.each do |io|
+      io.respond_to?(meth.to_s) ? io.send(meth.to_s, *args, &block) : super
+    end
+  end
+
+  def respond_to?(*args)
+    @ios.first.respond_to?(args.first.to_s) ? true : super
+  end
+
+end
+
+def run_cmd(logger, *args)
+  GC.disable
+
+  ScmdBenchRunner.run(logger, *args)
+  logger.puts
+
+  GC.enable
+  GC.start
+end
+
+ScmdBenchLogger.new('bench/results.txt') do |logger|
+  run_cmd(logger, Scmd.new("echo hi"), 1)
+  run_cmd(logger, Scmd.new("echo hi"), 10)
+  run_cmd(logger, Scmd.new("echo hi"), 100)
+  run_cmd(logger, Scmd.new("echo hi"), 1000)
+
+  run_cmd(logger, Scmd.new("cat test/support/bigger-than-64k.txt"), 1)
+  run_cmd(logger, Scmd.new("cat test/support/bigger-than-64k.txt"), 10)
+  run_cmd(logger, Scmd.new("cat test/support/bigger-than-64k.txt"), 100)
+  run_cmd(logger, Scmd.new("cat test/support/bigger-than-64k.txt"), 1000)
+end
+