ppool 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 440a4893e77aede60e337fa03a33a04efd842adf
+  data.tar.gz: fdc7ddf70a85f7634e3ae92c2c932071b4fab269
+SHA512:
+  metadata.gz: fac3e95edd1a6199030f6847805936c88e5a2c395489de0bb68d58ff23e888cff3057c84e137991174b549058e5eee1b57f9413807785e90f48b5baaf18351bd
+  data.tar.gz: cd1182ccd48acd747d4c225bd9cd8ad2b9036c9df5cd7ad11d7e3a3257de1963894a7f1da84bf1d534773876e97043c7b6a1f9b4c29145f96cccf1a15ba2733d

data/bin/ppool

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ppool'
+require 'optparse'
+
+
+options = {
+    :logdir => "./logs",
+    :size => 1,
+    :basic => false,
+}
+
+$USAGE = "Usage: ppool [options] COMMAND ARGS..."
+
+
+OptionParser.new do |opts|
+  opts.banner = $USAGE
+
+  opts.on('-l', '--logs DIR',  'Log directory') { |v| options[:logdir] = v }
+  opts.on('-s', '--size SIZE', 'Initial pool size') { |v| options[:size] = v }
+  opts.on('-b', '--basic', 'Basic (non curses) verion') { |v| options[:basic] = true}
+
+  opts.on("-h", "--help", "Show this message") {
+        puts opts
+        exit
+  }
+
+end.parse!
+
+command = ARGV.join(' ')
+if command == ''
+  puts $USAGE
+  exit(1)
+end
+
+logdir = options[:logdir]
+if ! Dir.exist?(logdir) 
+  Dir.mkdir(logdir)
+end
+
+size = options[:size].to_i
+
+if options[:basic]
+  controller = TerminalProcessController.new(size, command, logdir)
+else 
+  controller = CursesProcessController.new(size, command, logdir)
+end
+
+ProcessPool.new(controller).run
+

data/lib/basic_process_controller.rb

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

data/lib/curses_process_controller.rb

@@ -0,0 +1,157 @@
+
+require 'curses'
+
+class CursesProcessController < ShellProcessController
+
+  def initialize(size, script, logdir)
+    super(script, logdir)
+    @finishing = false
+    @finished = false
+    @size = size
+    @msg = ""
+    @last_stats = {}
+    init_window
+  end
+
+  def running?
+    return !@finished
+  end
+
+  def num_processes
+    return @size
+  end
+
+
+  def process_started(pid, num_processes) 
+  end
+
+  def process_ended(pid, status)
+    #draw_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
+      info "finishing #{stats[:active_processes]}"
+      if stats[:active_processes] == 0
+        @finished = true
+      end
+    end
+    @win.refresh
+
+  end
+
+  def delay
+    return 0.1
+  end
+
+
+  def init_window
+     
+     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) 
+
+     #Curses.noecho
+     #Curses.cbreak
+     #Curses.nonl 
+     #Curses.curs_set(0)
+
+     lines = Curses.lines
+     cols = Curses.cols
+
+     height = 12
+     width = 70
+
+     @win = Curses::Window.new(height, width, 2, 2)
+     #@win.keypad = true
+     #@win.nodelay = true
+
+     draw_window end
+
+  def draw_window
+     @win.clear
+     @win.attron(Curses.color_pair(1)|Curses::A_NORMAL) {
+       @win.box('|', '-')
+     }
+     
+  end
+
+  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
+
+
+  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
+      end
+    when 'q', 'Q'
+      @size = 0
+      @finishing = true
+    when 'x', 'X'
+      finished
+    end
+  end 
+
+
+end
+

data/lib/ppool.rb

@@ -0,0 +1,6 @@
+
+require "process_pool.rb"
+require "basic_process_controller.rb"
+require "shell_process_controller.rb"
+require "terminal_process_controller.rb"
+require "curses_process_controller.rb"

data/lib/process_pool.rb

@@ -0,0 +1,77 @@
+
+class ProcessPool
+
+  def initialize(controller)
+    @controller = controller
+    @active_processes = 0
+    @started_count = 0
+    @ended_count = 0
+    @errors = 0
+  end
+
+
+  def run
+
+    progress
+
+    while @controller.running?
+
+      num_processes = @controller.num_processes
+
+      # Create processes
+      while @active_processes < num_processes
+
+        @controller.info "num_proceses #{num_processes}, active_processes #{@active_processes}; forking"
+
+	pid = Process.fork do
+          @controller.run_process
+	end
+
+
+	@active_processes = @active_processes + 1
+	@controller.process_started(pid, @active_processes)
+	@started_count = @started_count + 1
+	
+	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
+	 #@controller.info "Exception #{e}"
+       end
+     end
+
+     progress
+
+     sleep @controller.delay
+
+    end
+    @controller.finished
+
+  end
+
+  def progress
+
+     @controller.progress({
+	:active_processes => @active_processes, 
+	:processes_started => @started_count, 
+	:processes_ended => @ended_count, 
+	:errors => @errors
+     })
+  end
+
+end

data/lib/shell_process_controller.rb

@@ -0,0 +1,30 @@
+class ShellProcessController < BasicProcessController
+
+  def initialize(script, logdir)
+    super()
+    @script = script
+    @logdir = logdir
+    @log = File.open("#{logdir}/ppool.log", 'w')
+
+  end
+
+  def run_process
+
+    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"
+
+    info "running #{@script} output to #{stdout}"
+    exec("#{@script} > #{stdout} 2> #{stderr} < #{stdin}")
+
+  end
+
+  def info(m)
+    @log.write("#{m}\n")
+    @log.flush
+  end
+
+end

data/lib/terminal_process_controller.rb

@@ -0,0 +1,116 @@
+
+require 'io/console'
+require 'io/wait'
+
+class TerminalProcessController < ShellProcessController
+
+  def initialize(size, script, logdir)
+    super(script, logdir)
+    @finishing = false
+    @finished = false
+    @size = size
+    @msg = ""
+    @last_stats = {}
+    @count = 0
+
+    Signal.trap('INT') do 
+      finished
+    end
+
+  end
+
+  def running?
+    return !@finished
+  end
+
+  def num_processes
+    return @size
+  end
+
+  def process_started(pid, num_processes) 
+  end
+
+  def process_ended(pid, status)
+  end
+
+  def progress(stats)
+
+     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
+
+     process_keys
+
+    if @finishing
+      info "finishing #{stats[:active_processes]}"
+      if stats[:active_processes] == 0
+        @finished = true
+      end
+    end
+
+
+  end
+
+  def delay
+    return 0.1
+  end
+
+
+  def process_keys
+   
+    case read_ch
+    when '+'
+      @size = @size + 1
+      @last_stats = {}
+      puts ""
+    when '-'
+      @size = @size - 1
+      if @size < 0
+        @size = 0
+      end
+      @last_stats = {}
+      puts ""
+    when 'q', 'Q'
+      @size = 0
+      @finishing = true
+      @last_stats = {}
+      puts ""
+    when 'x', 'X'
+      finished
+    end
+
+  end
+
+  def read_ch
+    begin
+      system("stty raw") 
+      if $stdin.ready?
+        c = $stdin.getc
+        return c.chr
+      end
+    ensure
+      system("stty -raw")
+    end
+    return nil
+  end
+
+
+  def finished
+    system("stty -raw")
+    puts ""
+    exit(0)
+  end
+
+
+
+end
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: ppool
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Paul Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Run a pool of processes
+email: pftylr@gmail.com
+executables:
+- ppool
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ppool
+- lib/basic_process_controller.rb
+- lib/curses_process_controller.rb
+- lib/ppool.rb
+- lib/process_pool.rb
+- lib/shell_process_controller.rb
+- lib/terminal_process_controller.rb
+homepage: http://rubygems.org/gems/ppool
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Process pool
+test_files: []