vete 0.2.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d1ef6e5614f544a633cfe36109f37ef7a37676b7ba276be48abcc40d6e9cf54
-  data.tar.gz: a0036c27a47eddba9385673345f4456fbae869fa816c8c2c0d46ce92a0866d82
+  metadata.gz: 9e19484c6c02cd403365def0a14367e2c31f302edd7b56842e863162d0178730
+  data.tar.gz: 303793b8c478fe08733f2da221a325d66e68b2d3ab54c89105482ef612866953
 SHA512:
-  metadata.gz: a0f287195bba7b81a368560aa3f0694b60e7afe8292957b9d947ca820291b603bdfc3d231bd9432c175a4f3df88714eba91b7a41db5dea744154e063000d2e42
-  data.tar.gz: 0aeb6cfa54c5a55d6b822ce29e5045f78176b428bd2948fd039ea5dce5096d42a0d7dd6e8b04ce2c2631fb28bd02480f79e5c75fdb8a489e729f614ae191c428
+  metadata.gz: 59e65ecb548ffa4ccc95f4928f83cb036cefaae98e447801c03616627557614f871f24442b331fd1f6d1211beaf8559f7b98870ea3e31a316ab22af6041d438f
+  data.tar.gz: 03aef3e49b3ee52dbd6867adee656d67fb6124f3eabc027732d35be04e46b0db0139a59abfc00d64079d2f4ce95b6d2cb24cb7e1f752283168196f965e028adb

data/lib/vete.rb

@@ -13,16 +13,20 @@ require "fileutils"
 require "optparse"
 require "thread"
 
-trap("INT" ) { print clear + go; abort "\n" }
+@pid = Process.pid
+
+trap("INT"  ) { print clear + go; abort "\n" }
+trap("WINCH") { print clear or draw if @pid == Process.pid }
 
 OptionParser.new.instance_eval do
-  @version = "0.2.0"
+  @version = "0.6.0"
   @banner  = "usage: #{program_name} [options]"
 
   on "-b", "--bar <width>"            , "Progress bar width, in characters", Integer
   on "-c", "--char <character>"       , "Character to use for progress bar", String
-  on "-r", "--reset"                  , "Remove directory used for job processing and quit"
+  on "-d", "--delay <mode>"           , "Delay mode (rand, task, numeric)"
   on "-h", "--help"                   , "Show help and command usage" do Kernel.abort to_s; end
+  on "-r", "--reset"                  , "Remove directory used for job processing and quit"
   on "-v", "--version"                , "Show version number" do Kernel.abort "#{program_name} #{@version}"; end
   on "-w", "--workers <count>"        , "Set the number of workers (default is 1)", Integer
 
@@ -31,17 +35,27 @@ end.parse!(into: opts={}) rescue abort($!.message)
 
 # populate CLI options
 @char = opts[:char   ] || "•"; @char = @char[0]
+@wait = opts[:delay  ]
 @nuke = opts[:reset  ]
 @wide = opts[:bar    ] || 20
 @work = opts[:workers] || 1
 
+# handle wait mode
+case @wait
+when "rand", "task", nil
+when /\A(?:0|[1-9]\d*|(?:0?\.|[1-9]\d*\.)\d*)\z/
+  @wait = @wait.to_f
+  @wait > 0 or abort "invalid delay time (#{@wait.to_f} secs)"
+else
+  abort "invalid delay mode '#{@wait}'"
+end
+
 # define job directories
 @vete = File.expand_path(".vete")
 @todo = File.join(@vete, "todo")
 @live = File.join(@vete, "live")
 @done = File.join(@vete, "done")
-@bomb = File.join(@vete, "bomb")
-
+@died = File.join(@vete, "died")
 
 def move(path, dest)
   dest = File.join(dest, File.basename(path))
@@ -59,27 +73,27 @@ end
 
 def vete_init
   nuke
-  list = [@todo, @live, @done, @bomb]
-  list.each {|path| File.mkdir_p(path, force: true, secure: true) }
+  list = [@todo, @live, @done, @died]
+  list.each {|path| FileUtils.mkdir_p(path) }
 end
 
 def vete_retry
-  list = Dir.glob(File.join(@bomb, "*")).sort.each {|path| FileUtils.touch(path) }
+  list = Dir.glob(File.join(@died, "*")).sort.each {|path| FileUtils.touch(path) }
   move(list, @todo)
 end
 
 def vete_todo(path)
-  FileUtils.touch(path, force: true, secure: true)
+  FileUtils.touch(File.join(@todo, path.to_s))
 end
 
 # ==[ Drawing ]===============================================================
 
 # https://www.cse.psu.edu/~kxc104/class/cmpen472/16f/hw/hw8/vt100ansi.htm
 
-def clear      ; "\e[2J"                        ; end
-def cursor(on) ; print on ? "\e[?25h": "\e[?25l"; end
-def go(r=1,c=1); "\e[#{r};#{c}H"                ; end
-def go!(...)   ; print go(...)                  ; end
+def clear(line=nil); line ? "\e[K" : "\e[2J"        ; end
+def cursor(on)     ; print on ? "\e[?25h": "\e[?25l"; end
+def go(r=1,c=1)    ; "\e[#{r};#{c}H"                ; end
+def go!(...)       ; print go(...)                  ; end
 
 def fg(rgb=nil); rgb ? "\e[38;2;#{hx(rgb)}m" : "\e[39m"; end
 def bg(rgb=nil); rgb ? "\e[48;2;#{hx(rgb)}m" : "\e[49m"; end
@@ -88,56 +102,49 @@ def hx(str=nil); str =~ /\A#?(?:(\h\h)(\h\h)(\h\h)|(\h)(\h)(\h))\z/ or return
   [r.hex, g.hex, b.hex] * ";"
 end
 
-def draw(rows, done=0, live=0, bomb=0, jobs=0, info=nil)
+def draw(live=0, done=0, died=0, jobs=0, info=nil)
 
   # outer box
   unless info
     print [
       clear,
-      go(2 + rows, @len + 3) + "└" + "─" * (@wide + 2) + "┘\n",
-      go(1       , @len + 3) + "┌" + "─" * (@wide + 2) + "┐\n",
+      go(2 + @work, @len + 3) + "└" + "─" * (@wide + 2) + "┘\n",
+      go(1        , @len + 3) + "┌" + "─" * (@wide + 2) + "┐\n",
     ].join
-    rows.times {|i| print " %*d │ %*s │\n" % [@len, i + 1, @wide, ""] }
+    @work.times {|i| print " %*d │ %*s │\n" % [@len, i + 1, @wide, ""] }
     return
   end
 
   # worker bars
-  dpct = done.to_f / jobs
-  lpct = live.to_f / jobs
+  ppct = (done + died).to_f / jobs
   most = info.values.max
   info.each do |slot, this|
     tpct = this.to_f / most
-    cols = dpct * tpct * @wide
+    cols = ppct * tpct * @wide
     print go(slot + 1, @len + 5) + bg("5383ec") + @char * cols
   end
 
   # summary bar
+  dpct = done.to_f / jobs
+  lpct = live.to_f / jobs
   gcol = dpct * @wide
   ycol = lpct * @wide
   print [
-    go(rows + 3, @len + 5),
+    go(@work + 3, @len + 5),
     fg("fff"),
     bg("58a65c") + @char * (       gcol       )     , #  green (done)
-    bg("f1bf42") + @char * (              ycol)     , # yellow (live) <= Add live
-    bg("d85140") + " "  * (@wide - gcol - ycol).ceil, #    red (left)
-    go(rows + 3, @len + 5 + @wide + 3) + " %.1f%% done " % [dpct * 100],
-    bomb == 0 ? nil : (bg + " " + bg("f1bf42") + " #{bomb} bombed "),
+    bg("f1bf42") + @char * (              ycol)     , # yellow (live)
+    bg("d85140") + " "  * (@wide - gcol - ycol).ceil, #    red (rest)
+    go(@work + 3, @len + 5 + @wide + 3)             , # scoot over...
+    bg("5383ec") + " %.1f%% " % [ppct * 100],         #   blue (done + died)
+    done > 0 ? (bg + " " + bg("58a65c") + " #{done} done ") : nil,
+    died > 0 ? (bg + " " + bg("d85140") + " #{died} died ") : nil,
   ].join
 
   # clear colors
   print fg + bg
 end
 
-# ==[ Simulate job creation, add helpers so vete makes this easy ]============
-
-FileUtils.rm_rf   @vete
-FileUtils.mkdir_p @todo
-FileUtils.mkdir_p @live
-FileUtils.mkdir_p @done
-FileUtils.mkdir_p @bomb
-
-1.upto(100) {|i| FileUtils.touch(File.join(@todo, i.to_s)) }
-
 # ==[ Configure workers ]=====================================================
 
 @len = @work.to_s.size
@@ -145,47 +152,55 @@ FileUtils.mkdir_p @bomb
 @que = Thread::Queue.new; @work.times {|slot| @que << (slot + 1) }
 
 begin
+  setup if defined?(setup)
+
   list = Dir[File.join(@todo, "*")]
+
+  live = 0
+  done = 0
+  died = 0
   jobs = list.size
   info = Hash.new(0)
 
-  setup
-
   cursor(false)
-  draw(@work)
+  draw
 
   time = Time.now
-  done = 0
-  live = 0
-  bomb = 0
   Thread.new do
-    list.each do |path|
+    list.each_with_index do |path, task|
       slot = @que.pop
       @mtx.synchronize {
         live += 1
       }
       show = "Working on task " + File.basename(path)
-      print go(slot + 1, @len + 5 + @wide + 3) + show
+      print go(slot + 1, @len + 5 + @wide + 3) + show + clear(true)
       if chld = fork # parent
         Thread.new do
           okay = Process.waitpid2(chld)[1] == 0
-          move(path, okay ? @done : @bomb)
+          move(path, okay ? @done : @died)
           @que.push(slot)
           @mtx.synchronize {
-            done += 1
             live -= 1
-            bomb += 1 unless okay
+            okay ? (done += 1) : (died += 1)
             info[slot] += 1
           }
         end
-        draw(@work, done, live, bomb, jobs, info.dup)
+        draw(live, done, died, jobs, info.dup)
       else
-        perform(slot, path)
+        case @wait
+        when "rand"  then sleep rand(@work)
+        when "task"  then sleep task
+        when Numeric then sleep task * @wait
+        end if task < @work
+        perform(path)
         exit
       end
     end
+    while @que.size != @work
+      sleep 1
+      draw(live, done, died, jobs, info.dup)
+    end
   end.join
-  draw(@work, done, live, bomb, jobs, info)
   secs = Time.now.to_f - time.to_f
 
   # summary

data/test/example.rb

@@ -1,13 +1,15 @@
 #!/usr/bin/env ruby
 
 def setup
+  vete_init
+  100.times {|i| vete_todo(i + 1) }
   @time = Time.now
 end
 
-def perform(slot, task)
+def perform(task)
   sleep rand
   secs = Time.now - @time
-  exit 4 if rand < 0.02
+  exit 1 if rand < 0.03
 end
 
 require_relative "../lib/vete"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vete
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Steve Shreeve
@@ -42,7 +42,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.9
 signing_key:
 specification_version: 4
 summary: Ruby CLI to spawn processes to get work done