ppool 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c44a544f926a9563eb3d498c8a194676863919d5
-  data.tar.gz: f8977e5444cc2df43c0df2ff5712edfed61c8bcc
+  metadata.gz: 7a26e4d31307303960169d895e99c920b2973274
+  data.tar.gz: ff136111314394c13522c6af72074f935d50cb4b
 SHA512:
-  metadata.gz: ea14c6efa27b98e2a9ae5f83565d71950b13b5587ef430e345b4c83631af2f44f1133b4f6443b1a5893321fb4d0d44c9f180a2886f9c76d21812982874e191b7
-  data.tar.gz: 15ab0325e16cf79ce093f604f55fc6515b4e8d5b7776c27916ed413ab61bd560794dc3f02abfa8efc9801fc2509f93547f1c6cad07a3044d33cef2556fd8290a
+  metadata.gz: 731c02140ced9acf4124d9322d3eeee11df2ae7a3b3d9b0cbd39b4760f09c2a1b9784e854a6cb795fb273484d394828fa50da9fdc656433a8a3eeff8647b6356
+  data.tar.gz: 22ef5674086659c33e6738b9c384b258e9fd29edd9632d9b078f79b52a6ff1c2c045de4f4b72980786d900afd6d9091c9ee0b6df5107ab846b1964648dc721d0

data/bin/ppool

@@ -27,13 +27,13 @@ require 'rubygems'
 require 'ppool'
 require 'optparse'
 
-
 options = {
     :size => 1,
     :delay => 100,
     :basic => false,
     :logdir => "./ppool-logs",
-    :rmlogs => false
+    :rmlogs => false,
+    :timespec => nil
 }
 
 $USAGE = "Usage: ppool [options] COMMAND ARGS..."
@@ -44,6 +44,7 @@ OptionParser.new do |opts|
 
   opts.on('-s', '--size SIZE', 'Initial pool size') { |v| options[:size] = v }
   opts.on('-d', '--delay MSECS', 'The delay between checking the state of the process pool (default 100ms)') { |v| options[:delay] = v }
+  opts.on('-t', '--time TIME',  'Time limit') { |v| options[:timespec] = v }
   opts.on('-b', '--basic', 'Basic (non curses) verion') { |v| options[:basic] = true}
   opts.on('-r', '--rmlogs', 'Remove logs for processes that exited successfully') { |v| options[:rmlogs] = true}
   opts.on('-l', '--logdir DIR',  'Log directory') { |v| options[:logdir] = v }
@@ -69,11 +70,19 @@ end
 size = options[:size].to_i
 delay = options[:delay].to_i
 
+begin
+  time = options[:timespec] == nil ? nil : PPool.convert_time_to_secs(options[:timespec])
+rescue ArgumentError => e
+  puts $USAGE
+  puts "error: #{e.message}"
+  exit(1)
+end
+
 if options[:basic]
-  controller = TerminalProcessController.new(size, delay, command, logdir, options[:rmlogs])
+  controller = PPool::TerminalProcessController.new(size, delay, command, time, logdir, options[:rmlogs])
 else 
-  controller = CursesProcessController.new(size, delay, command, logdir, options[:rmlogs])
+  controller = PPool::CursesProcessController.new(size, delay, command, time, logdir, options[:rmlogs])
 end
 
-ProcessPool.new(controller).run
+PPool::ProcessPool.new(controller).run
 

data/lib/basic_process_controller.rb

@@ -22,54 +22,60 @@
 # SOFTWARE.
 #
 
-class BasicProcessController 
+module PPool
 
-  def initialize
-    @time_started = Time.new.to_i
-  end
+  class BasicProcessController 
 
-  def running?
-    return true
-  end
+    def initialize
+      @time_started = Time.now.to_i
+    end
 
-  def num_processes
-    return 1
-  end
+    def running?
+      return true
+    end
 
-  def process_started(pid, num_processes) 
-    puts "> process started #{pid}; num_processes #{num_processes}"
-  end
+    def num_processes
+      return 1
+    end
 
-  def run_process 
-    info "#{Process.pid} running"
-    exit 0
-  end
+    def process_started(pid, num_processes) 
+      puts "> process started #{pid}; num_processes #{num_processes}"
+    end
 
-  def process_ended(pid, status)
-    puts "> process ended - pid #{pid}, status #{status}"
-  end
+    def run_process 
+      info "#{Process.pid} running"
+      exit 0
+    end
 
-  def progress(stats)
-    puts "> active #{stats[:active_processes]} started #{stats[:processes_started]} ended #{stats[:processes_ended]} errors #{stats[:errors]}"
-  end
+    def process_ended(pid, status)
+      puts "> process ended - pid #{pid}, status #{status}"
+    end
 
-  def delay
-    return 0.1
-  end
+    def progress(stats)
+      puts "> active #{stats[:active_processes]} started #{stats[:processes_started]} ended #{stats[:processes_ended]} errors #{stats[:errors]}"
+    end
 
-  def info(m)
-    puts "+ #{m}"
-  end
+    def delay
+      return 0.1
+    end
 
-  def time_running
-    secs = Time.new.to_i - @time_started
-    hours = (secs / (60 * 60)) % 24
-    mins = (secs / 60) % 60
-    secs = secs % 60
+    def info(m)
+      puts "+ #{m}"
+    end
 
-    return "%.2d:%.2d:%.2d" % [hours, mins,secs]
-  end
+    def time_running
+      secs = time_running_secs
+      hours = (secs / (60 * 60)) % 24
+      mins = (secs / 60) % 60
+      secs = secs % 60
 
+      return "%.2d:%.2d:%.2d" % [hours, mins,secs]
+    end
 
-end
+    def time_running_secs
+      Time.now.to_i - @time_started
+    end
 
+  end
+
+end

data/lib/curses_process_controller.rb

@@ -24,154 +24,125 @@
 
 require 'curses'
 
-class CursesProcessController < ShellProcessController
-
-  def initialize(size, delay, script, logdir, rmlogs)
-    super(script, logdir, rmlogs)
-    @finishing = false
-    @finished = false
-    @size = size
-    @delay = delay
-    @msg = ""
-    @last_stats = {}
-    init_window
-  end
-
-  def running?
-    return !@finished
-  end
-
-  def num_processes
-    return @size
-  end
+module PPool
 
+  class CursesProcessController < TimedProcessController
 
-  def process_started(pid, num_processes) 
-  end
-
+    def initialize(size, delay, script, time, logdir, rmlogs)
+      super(size, delay, script, time, logdir, rmlogs)
+      @msg = ""
+      @last_stats = {}
+      init_window
+    end
 
-  def progress(stats)
-
-    @last_stats = stats
-
-    draw_window
-
-    @win.attron(Curses.color_pair(3)|Curses::A_BOLD) {
-      @win.setpos(2 , 5)
-      @win.addstr("Time      #{time_running}")
-      @win.setpos(3 , 5)
-      @win.addstr("Size      #{@size}")
-      @win.setpos(4 , 5)
-      @win.addstr("Running   #{stats[:active_processes]}")
-      @win.setpos(5 , 5)
-      @win.addstr("Started   #{stats[:processes_started]}")
-      @win.setpos(6 , 5)
-      @win.addstr("Ended     #{stats[:processes_ended]}")
-      @win.setpos(7 , 5)
-      @win.addstr("Errors    #{stats[:errors]}")
-      @win.setpos(8 , 5)
-      @win.addstr("Logs      #{@logdir}")
-      @win.setpos(9 , 5)
-      @win.addstr("          #{@msg}")
-    }
-
-    process_keys
-
-    if @finishing
-      if stats[:active_processes] == 0
-        @finished = true
+    def progress(stats)
+
+      @last_stats = stats
+
+      draw_window
+
+      @win.attron(Curses.color_pair(3)|Curses::A_BOLD) {
+	@win.setpos(2 , 5)
+	@win.addstr("Time      #{time_running}")
+	@win.setpos(3 , 5)
+	@win.addstr("Size      #{@size}")
+	@win.setpos(4 , 5)
+	@win.addstr("Running   #{stats[:active_processes]}")
+	@win.setpos(5 , 5)
+	@win.addstr("Started   #{stats[:processes_started]}")
+	@win.setpos(6 , 5)
+	@win.addstr("Ended     #{stats[:processes_ended]}")
+	@win.setpos(7 , 5)
+	@win.addstr("Errors    #{stats[:errors]}")
+	@win.setpos(8 , 5)
+	@win.addstr("Logs      #{@logdir}")
+	@win.setpos(9 , 5)
+	@win.addstr("          #{@msg}")
+      }
+
+      process_keys
+
+      if finishing?
+	if stats[:active_processes] == 0
+	  finished
+	end
       end
+      @win.refresh
+
     end
-    @win.refresh
 
-  end
+    def init_window
 
-  def delay
-    return @delay / 1000
-  end
+       info "init_window"
 
+       Curses.init_screen
+       Curses.start_color
+       Curses.init_pair(1, Curses::COLOR_BLUE, Curses::COLOR_BLACK) 
+       Curses.init_pair(2, Curses::COLOR_RED, Curses::COLOR_BLACK) 
+       Curses.init_pair(3, Curses::COLOR_WHITE, Curses::COLOR_BLACK) 
 
-  def init_window
-     
-     info "init_window"
+       lines = Curses.lines
+       cols = Curses.cols
 
-     Curses.init_screen
-     Curses.start_color
-     Curses.init_pair(1, Curses::COLOR_BLUE, Curses::COLOR_BLACK) 
-     Curses.init_pair(2, Curses::COLOR_RED, Curses::COLOR_BLACK) 
-     Curses.init_pair(3, Curses::COLOR_WHITE, Curses::COLOR_BLACK) 
+       height = 12
+       width = 70
 
-     #Curses.noecho
-     #Curses.cbreak
-     #Curses.nonl 
-     #Curses.curs_set(0)
+       @win = Curses::Window.new(height, width, 2, 2)
 
-     lines = Curses.lines
-     cols = Curses.cols
+       draw_window 
+    end
 
-     height = 12
-     width = 70
+    def draw_window
+       @win.clear
+       @win.attron(Curses.color_pair(1)|Curses::A_NORMAL) {
+	 @win.box('|', '-')
+       }
 
-     @win = Curses::Window.new(height, width, 2, 2)
-     #@win.keypad = true
-     #@win.nodelay = true
+    end
 
-     draw_window end
+    def terminate
 
-  def draw_window
-     @win.clear
-     @win.attron(Curses.color_pair(1)|Curses::A_NORMAL) {
-       @win.box('|', '-')
-     }
-     
-  end
+      info "terminate"
+      Curses.close_screen 
 
-  def finished
-    info "finished"
-    Curses.close_screen 
-
-    puts ""
-    puts "Time     #{time_running}"
-    puts "Size     #{@size}"
-    puts "Running  #{@last_stats[:active_processes]}"
-    puts "Started  #{@last_stats[:processes_started]}"
-    puts "Ended    #{@last_stats[:processes_ended]}"
-    puts "Errors   #{@last_stats[:errors]}"
-    puts "Logs     #{@logdir}"
-    puts "         #{@msg}"
-    puts ""
-
-    exit(0)
-  end
+      puts ""
+      puts "Time     #{time_running}"
+      puts "Size     #{@size}"
+      puts "Running  #{@last_stats[:active_processes]}"
+      puts "Started  #{@last_stats[:processes_started]}"
+      puts "Ended    #{@last_stats[:processes_ended]}"
+      puts "Errors   #{@last_stats[:errors]}"
+      puts "Logs     #{@logdir}"
+      puts "         #{@msg}"
+      puts ""
+
+      exit(0)
+    end
 
 
-  def process_keys 
-
-     # Need to reset keyboard handling after a process
-     # has been forked.
-     Curses.noecho
-     Curses.cbreak
-     Curses.nonl 
-     Curses.curs_set(0)
-     @win.keypad = true
-     @win.nodelay = true
-
-    case @win.getch
-    when '+', Curses::KEY_UP
-      @size = @size + 1
-    when '-', Curses::KEY_DOWN
-      @size = @size - 1
-      if @size < 0
-        @size = 0
+    def process_keys 
+
+       # Need to reset keyboard handling after a process
+       # has been forked.
+       Curses.noecho
+       Curses.cbreak
+       Curses.nonl 
+       Curses.curs_set(0)
+       @win.keypad = true
+       @win.nodelay = true
+
+      case @win.getch
+      when '+', Curses::KEY_UP
+        inc_size
+      when '-', Curses::KEY_DOWN
+        dec_size
+      when 'q', 'Q'
+        finishing
+      when 'x', 'X'
+	terminate
       end
-    when 'q', 'Q'
-      @size = 0
-      @finishing = true
-    when 'x', 'X'
-      finished
-    end
-  end 
+    end 
 
+  end
 
 end
-

data/lib/ppool.rb

@@ -22,8 +22,12 @@
 # SOFTWARE.
 #
 
+
+require "process_pool_util.rb"
 require "process_pool.rb"
 require "basic_process_controller.rb"
 require "shell_process_controller.rb"
+require "timed_process_controller.rb"
 require "terminal_process_controller.rb"
 require "curses_process_controller.rb"
+

data/lib/process_pool.rb

@@ -22,79 +22,82 @@
 # SOFTWARE.
 #
 
-class ProcessPool
-
-  def initialize(controller)
-    @controller = controller
-    @active_processes = 0
-    @started_count = 0
-    @ended_count = 0
-    @errors = 0
-  end
+module PPool
 
+  class ProcessPool
 
-  def run
+    def initialize(controller)
+      @controller = controller
+      @active_processes = 0
+      @started_count = 0
+      @ended_count = 0
+      @errors = 0
+    end
 
-    progress
 
-    while @controller.running?
+    def run
 
-      num_processes = @controller.num_processes
+      progress
 
-      # Create processes
-      while @active_processes < num_processes
+      while @controller.running?
 
-        @controller.info "num_proceses #{num_processes}, active_processes #{@active_processes}; forking"
+	num_processes = @controller.num_processes
 
-	pid = Process.fork do
-          @controller.run_process
-	end
+	# Create processes
+	while @active_processes < num_processes
 
+	  @controller.info "num_proceses #{num_processes}, active_processes #{@active_processes}; forking"
 
-	@active_processes = @active_processes + 1
-	@controller.process_started(pid, @active_processes)
-	@started_count = @started_count + 1
-	
-	progress
-      end
+	  pid = Process.fork do
+	    @controller.run_process
+	  end
+
+
+	  @active_processes = @active_processes + 1
+	  @controller.process_started(pid, @active_processes)
+	  @started_count = @started_count + 1
 
-      doneWaiting = false
-      while ! doneWaiting 
-       begin
-	 pidStatus = Process.wait2(-1, Process::WNOHANG)
-	 if pidStatus != nil
-           @controller.process_ended(pidStatus[0], pidStatus[1].exitstatus)
-	   @active_processes = @active_processes - 1 
-	   @ended_count = @ended_count + 1
-           if pidStatus[1].exitstatus != 0 
-             @errors = @errors + 1
-           end
-	 else 
+	  progress
+	end
+
+	doneWaiting = false
+	while ! doneWaiting 
+	 begin
+	   pidStatus = Process.wait2(-1, Process::WNOHANG)
+	   if pidStatus != nil
+	     @controller.process_ended(pidStatus[0], pidStatus[1].exitstatus)
+	     @active_processes = @active_processes - 1 
+	     @ended_count = @ended_count + 1
+	     if pidStatus[1].exitstatus != 0 
+	       @errors = @errors + 1
+	     end
+	   else 
+	     doneWaiting = true
+	   end
+	 rescue => e
 	   doneWaiting = true
 	 end
-       rescue => e
-	 doneWaiting = true
-	 #@controller.info "Exception #{e}"
        end
-     end
 
-     progress
+       progress
+
+       Kernel.sleep @controller.delay
 
-     sleep @controller.delay
+      end
+      @controller.terminate
 
     end
-    @controller.finished
 
-  end
+    def progress
 
-  def progress
+       @controller.progress({
+	  :active_processes => @active_processes, 
+	  :processes_started => @started_count, 
+	  :processes_ended => @ended_count, 
+	  :errors => @errors
+       })
+    end
 
-     @controller.progress({
-	:active_processes => @active_processes, 
-	:processes_started => @started_count, 
-	:processes_ended => @ended_count, 
-	:errors => @errors
-     })
   end
 
-end
+end

data/lib/shell_process_controller.rb

@@ -22,58 +22,60 @@
 # SOFTWARE.
 #
 
-class ShellProcessController < BasicProcessController
+module PPool
 
-  def initialize(script, logdir, rmlogs)
-    super()
-    @script = script
-    @logdir = logdir
-    @rmlogs = rmlogs
-    @log = File.open("#{logdir}/ppool.log", 'w')
-    @stdout_log = {}
-    @stderr_log = {}
+  class ShellProcessController < BasicProcessController
 
-  end
+    def initialize(script, logdir, rmlogs)
+      super()
+      @script = script
+      @logdir = logdir
+      @rmlogs = rmlogs
+      @log = File.open("#{logdir}/ppool.log", 'w')
+      @stdout_log = {}
+      @stderr_log = {}
 
-  def run_process
+    end
 
-    timestamp = Time.now.strftime('%Y%m%d%H%M%S')
-    pid = Process.pid
- 
-    stdout = "#{@logdir}/process_#{pid}_#{timestamp}.stdout"
-    stderr = "#{@logdir}/process_#{pid}_#{timestamp}.stderr"
-    stdin = "/dev/null"
+    def run_process
 
-    info "running #{@script} output to #{stdout}"
-    exec("#{@script} > #{stdout} 2> #{stderr} < #{stdin}")
+      timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+      pid = Process.pid
 
-  end
+      stdout = "#{@logdir}/process_#{pid}_#{timestamp}.stdout"
+      stderr = "#{@logdir}/process_#{pid}_#{timestamp}.stderr"
+      stdin = "/dev/null"
 
-  def process_ended(pid, status)
+      info "running #{@script} output to #{stdout}"
+      Kernel.exec("#{@script} > #{stdout} 2> #{stderr} < #{stdin}")
 
-    if @rmlogs && status == 0    
-      delete_log_file(pid, 'stderr')
-      delete_log_file(pid, 'stdout')
     end
-     
-  end
 
-  def info(m)
-    @log.write("#{m}\n")
-    @log.flush
-  end
+    def process_ended(pid, status)
+      if @rmlogs && status == 0    
+	      delete_log_file(pid, 'stdout')
+	      delete_log_file(pid, 'stderr')
+      end
+    end
+
+    def info(m)
+      @log.write("#{m}\n")
+      @log.flush
+    end
 
 
-  def delete_log_file(pid, suffix)
-    begin 
-      Dir.glob("#{@logdir}/process_#{pid}_*.#{suffix}") { |file| 
-       info "deleting log file #{file} for process #{pid}"
-       File.delete(file)
-      }
-   rescue => e
-     info "error deleting log file for process #{pid}: #{e}"
-   end
+    def delete_log_file(pid, suffix)
+      begin
+        Dir.glob("#{@logdir}/process_#{pid}_*.#{suffix}") { |file|
+	  info "deleting log file #{file} for process #{pid}"
+	  File.delete(file)
+	}
+      rescue => e
+        info "error deleting log file for process #{pid}: #{e}"
+      end
+
+    end
 
   end
 
-end
+end

data/lib/terminal_process_controller.rb

@@ -25,112 +25,88 @@
 require 'io/console'
 require 'io/wait'
 
-class TerminalProcessController < ShellProcessController
-
-  def initialize(size, delay, script, logdir, rmlogs)
-    super(script, logdir, rmlogs)
-    @finishing = false
-    @finished = false
-    @size = size
-    @delay = delay
-    @msg = ""
-    @last_stats = {}
-    @count = 0
-
-    Signal.trap('INT') do 
-      finished
-    end
+module PPool
 
-  end
+  class TerminalProcessController < TimedProcessController
 
-  def running?
-    return !@finished
-  end
+    def initialize(size, delay, script, time, logdir, rmlogs)
+      super(size, delay, script, time, logdir, rmlogs)
+      @msg = ""
+      @last_stats = {}
+      @count = 0
 
-  def num_processes
-    return @size
-  end
+      Signal.trap('INT') do 
+	terminate
+      end
 
-  def process_started(pid, num_processes) 
-  end
+    end
 
-  def progress(stats)
 
-     if stats != @last_stats
-       if @count % 20 == 0
+    def progress(stats)
 
-          puts "----------------------------------------------"
-          puts " Time     | Size  Active  Started Ended Errors"
-          puts "=============================================="
+       if stats != @last_stats
+	 if @count % 20 == 0
 
+	    puts "----------------------------------------------"
+	    puts " Time     | Size  Active  Started Ended Errors"
+	    puts "=============================================="
+
+	 end
+	 puts(" %s | %4d   %4d   %4d   %4d   %4d\n" % [time_running, @size, stats[:active_processes], stats[:processes_started], stats[:processes_ended], stats[:errors]])
+	 @last_stats = stats
+	 @count = @count + 1
        end
-       puts(" %s | %4d   %4d   %4d   %4d   %4d\n" % [time_running, @size, stats[:active_processes], stats[:processes_started], stats[:processes_ended], stats[:errors]])
-       @last_stats = stats
-       @count = @count + 1
-     end
 
-     process_keys
+       process_keys
 
-    if @finishing
-      if stats[:active_processes] == 0
-        @finished = true
+      if finishing?
+	if stats[:active_processes] == 0
+	  finished
+	end
       end
     end
 
+    def process_keys
+
+      case read_ch
+      when '+'
+        inc_size
+	@last_stats = {}
+	puts ""
+      when '-'
+        dec_size
+	@last_stats = {}
+	puts ""
+      when 'q', 'Q'
+        finishing
+	@last_stats = {}
+	puts ""
+      when 'x', 'X'
+	terminate
+      end
 
-  end
-
-  def delay
-    return @delay / 1000
-  end
-
+    end
 
-  def process_keys
-   
-    case read_ch
-    when '+'
-      @size = @size + 1
-      @last_stats = {}
-      puts ""
-    when '-'
-      @size = @size - 1
-      if @size < 0
-        @size = 0
+    def read_ch
+      begin
+	system("stty raw") 
+	if $stdin.ready?
+	  c = $stdin.getc
+	  return c.chr
+	end
+      ensure
+	system("stty -raw")
       end
-      @last_stats = {}
-      puts ""
-    when 'q', 'Q'
-      @size = 0
-      @finishing = true
-      @last_stats = {}
-      puts ""
-    when 'x', 'X'
-      finished
+      return nil
     end
 
-  end
 
-  def read_ch
-    begin
-      system("stty raw") 
-      if $stdin.ready?
-        c = $stdin.getc
-        return c.chr
-      end
-    ensure
+    def terminate
       system("stty -raw")
+      puts ""
+      exit(0)
     end
-    return nil
-  end
-
 
-  def finished
-    system("stty -raw")
-    puts ""
-    exit(0)
   end
 
-
-
 end
-

data/lib/timed_process_controller.rb

@@ -0,0 +1,94 @@
+#
+# MIT License
+#
+# Copyright (c) 2016 Paul Taylor
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+require 'io/console'
+require 'io/wait'
+
+module PPool
+
+  class TimedProcessController < ShellProcessController
+
+    def initialize(size, delay, script, time, logdir, rmlogs)
+      super(script, logdir, rmlogs)
+
+      @size = size
+      @time = time
+      @finishing = false
+      @finished = false
+      @size = size
+      @delay = delay
+      @msg = ""
+
+      Signal.trap('INT') do 
+	finished
+      end
+
+    end
+
+    def running?
+      if @time != nil && time_running_secs > @time
+        @size = 0
+        @finishing = true
+      end
+      return !@finished
+    end
+
+    def num_processes
+      return @size
+    end
+
+    def process_started(pid, num_processes) 
+    end
+
+    def delay
+      return @delay / 1000.0
+    end
+
+    def inc_size
+      @size = @size + 1
+    end
+
+    def dec_size
+      @size = @size - 1
+      if @size < 0
+        @size = 0
+      end
+    end
+
+    def finishing
+      @size = 0
+      @finishing = true
+    end
+
+    def finishing?
+      return @finishing
+    end
+
+    def finished
+      @finished = true
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ppool
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Paul Taylor
@@ -24,6 +24,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Start of pool of processes running a single command and control the pool
   size via the keyboard.
 email: pftylr@gmail.com
@@ -39,6 +81,7 @@ files:
 - lib/process_pool.rb
 - lib/shell_process_controller.rb
 - lib/terminal_process_controller.rb
+- lib/timed_process_controller.rb
 homepage: http://rubygems.org/gems/ppool
 licenses:
 - MIT