oflow 0.3.0

data/test/flow_nest_test.rb

@@ -0,0 +1,215 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+require 'collector'
+
+class Hop < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    task.info("#{op} #{box.contents}")
+    task.ship(op, box)
+  end
+
+end # Hop
+
+class FlowNestTest < ::Test::Unit::TestCase
+
+  def test_flow_nest
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow(:nest, :opt1 => 1) { |f|
+      # use collector as the log
+      f.task(:log, Collector) { |t|
+        collector = t.actor
+      }
+
+      # starts off the process
+      trigger = f.task(:trigger, Hop) { |t|
+        t.link(nil, :deep, nil)
+      }
+      # a nested flow
+      f.flow(:deep) { |f2|
+        f2.route(nil, :one, nil)
+        f2.task(:one, Hop) { |t|
+          t.link(nil, :two, nil)
+        }
+        f2.task(:two, Hop) { |t|
+          t.link(nil, :flow, :bye)
+        }
+        f2.link(:bye, :out, nil)
+      }
+      f.task(:out, Hop) { |t|
+          t.link(nil, :done, nil)
+      }
+      f.task(:done, ::OFlow::Actors::Ignore)
+    }
+
+    # see if the flow was constructed correctly
+    assert_equal(%|OFlow::Env {
+  nest (OFlow::Flow) {
+    log (Collector) {
+    }
+    trigger (Hop) {
+       => deep:
+    }
+    deep (OFlow::Flow) {
+      one (Hop) {
+         => two:
+      }
+      two (Hop) {
+         => flow:bye
+      }
+       * one:
+      bye => out:
+    }
+    out (Hop) {
+       => done:
+    }
+    done (OFlow::Actors::Ignore) {
+    }
+  }
+}|, ::OFlow::Env.describe())
+
+    # run it and check the output
+    trigger.receive(:go, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+    assert_equal([['go 7', ':nest:trigger'],
+                  [' 7', ':nest:deep:one'],
+                  [' 7', ':nest:deep:two'],
+                  [' 7', ':nest:out']
+                 ], collector.collection)
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_flow_nest_deep
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow(:nest_deep, :opt1 => 1) { |f|
+      # use collector as the log
+      f.task(:log, Collector) { |t|
+        collector = t.actor
+      }
+
+      # starts off the process
+      trigger = f.task(:trigger, Hop) { |t|
+        t.link(nil, :deep, nil)
+      }
+      # a nested flow
+      f.flow(:deep) { |f2|
+        f2.route(nil, :deeper, nil)
+        f2.flow(:deeper) { |f3|
+          f3.route(nil, :one, nil)
+          f3.task(:one, Hop) { |t|
+            t.link(nil, :two, nil)
+          }
+          f3.task(:two, Hop) { |t|
+            t.link(nil, :flow, :bye)
+          }
+          f3.link(:bye, :flow, :bye)
+        }
+        f2.link(:bye, :out, nil)
+      }
+      f.task(:out, Hop) { |t|
+        t.link(nil, :done, nil)
+      }
+      f.task(:done, ::OFlow::Actors::Ignore)
+    }
+
+    # see if the flow was constructed correctly
+    assert_equal(%|OFlow::Env {
+  nest_deep (OFlow::Flow) {
+    log (Collector) {
+    }
+    trigger (Hop) {
+       => deep:
+    }
+    deep (OFlow::Flow) {
+      deeper (OFlow::Flow) {
+        one (Hop) {
+           => two:
+        }
+        two (Hop) {
+           => flow:bye
+        }
+         * one:
+        bye => flow:bye
+      }
+       * deeper:
+      bye => out:
+    }
+    out (Hop) {
+       => done:
+    }
+    done (OFlow::Actors::Ignore) {
+    }
+  }
+}|, ::OFlow::Env.describe())
+
+    # run it and check the output
+    trigger.receive(:go, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+    assert_equal([['go 7', ':nest_deep:trigger'],
+                  [' 7', ':nest_deep:deep:deeper:one'],
+                  [' 7', ':nest_deep:deep:deeper:two'],
+                  [' 7', ':nest_deep:out']
+                 ], collector.collection)
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_flow_nest_label
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow(:nest) { |f|
+      # use collector as the log
+      f.task(:log, Collector) { |t|
+        collector = t.actor
+      }
+
+      # starts off the process
+      trigger = f.task(:trigger, Hop) { |t|
+        t.link(:go, :deep, :first)
+      }
+      # a nested flow
+      f.flow(:deep) { |f2|
+        f2.route(:first, :one, :hip)
+        f2.task(:one, Hop) { |t|
+          t.link(:hip, :two, :hop)
+        }
+        f2.task(:two, Hop) { |t|
+          t.link(:hop, :flow, :get_out)
+        }
+        f2.link(:get_out, :out, :finish)
+      }
+      f.task(:out, Hop) { |t|
+          t.link(:finish, :done, nil)
+      }
+      f.task(:done, ::OFlow::Actors::Ignore)
+    }
+
+    # run it and check the output
+    trigger.receive(:go, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+    assert_equal([['go 7', ':nest:trigger'],
+                  ['hip 7', ':nest:deep:one'],
+                  ['hop 7', ':nest:deep:two'],
+                  ['finish 7', ':nest:out']
+                 ], collector.collection)
+
+    ::OFlow::Env.clear()
+  end
+
+
+end # FlowNestTest

data/test/flow_rescue_test.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+require 'collector'
+
+class Crash < ::OFlow::Actor
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    nil.crash()
+  end
+
+end # Crash
+
+class FlowRescueTest < ::Test::Unit::TestCase
+
+  # Make sure the error handler works and forwards to the 'error' task if it
+  # exists.
+  def test_flow_rescue_task
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('rescue') { |f|
+      trigger = f.task('crash', Crash)
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+      f.task(:error, ::OFlow::Actors::Relay) { |t|
+        t.link(nil, 'collector', 'error')
+      }
+      f.task(:log, ::OFlow::Actors::Relay) { |t|
+        t.link(nil, 'collector', 'log')
+      }
+    }
+    trigger.receive(:knock, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    assert_equal(collector.collection.size, 1)
+    assert_equal(collector.collection[0][0].class, NoMethodError)
+    assert_equal(collector.collection[0][1], ':rescue:crash')
+
+    ::OFlow::Env.clear()
+  end
+
+  # Make sure the error handler on the flow is used to handle errors.
+  def test_flow_rescue_var
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('rescue') { |f|
+      trigger = f.task('crash', Crash)
+      f.error_handler = f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+      f.task(:log, ::OFlow::Actors::Relay) { |t|
+        t.link(nil, 'collector', 'log')
+      }
+    }
+    trigger.receive(:knock, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    assert_equal(collector.collection.size, 1)
+    assert_equal(collector.collection[0][0].class, NoMethodError)
+    assert_equal(collector.collection[0][1], ':rescue:crash')
+
+    ::OFlow::Env.clear()
+  end
+
+  # Make sure the error handler on the flow is used to handle errors.
+  def test_flow_rescue_env
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('rescue') { |f|
+      trigger = f.task('crash', Crash)
+      ::OFlow::Env.error_handler = f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+      f.task(:log, ::OFlow::Actors::Relay) { |t|
+        t.link(nil, 'collector', 'log')
+      }
+    }
+    trigger.receive(:knock, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    assert_equal(1, collector.collection.size)
+    assert_equal(NoMethodError, collector.collection[0][0].class)
+    assert_equal(':rescue:crash', collector.collection[0][1])
+
+    ::OFlow::Env.clear()
+  end
+
+  # Make sure the default error handler on the flow passes a message to the log.
+  def test_flow_rescue_env_log
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('rescue') { |f|
+      trigger = f.task('crash', Crash)
+      ::OFlow::Env.log = f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    trigger.receive(:knock, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    assert_equal(1, collector.collection.size)
+    assert_equal(["NoMethodError: undefined method `crash' for nil:NilClass",
+                  "/flow_rescue_test.rb:0:in `perform'",
+                  "/task.rb:0:in `block in initialize'"],
+                 simplify(collector.collection[0][0]))
+
+    assert_equal(':rescue:crash', collector.collection[0][1])
+
+    ::OFlow::Env.clear()
+  end
+
+  def simplify(bt)
+    bt.split("\n").map do |line|
+      i = line.index(/\/\w+\.rb\:\d+/)
+      unless i.nil?
+        line = line[i..-1]
+      end
+      line.gsub(/\d+/, '0')
+    end
+  end
+
+end # FlowRescueTest

data/test/flow_tracker_test.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+require 'collector'
+
+class Throw < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    task.ship(op, box)
+  end
+
+end # Throw
+
+class Catch < ::OFlow::Actor
+  attr_reader :ball
+
+  def initialize(task, options)
+    super
+    @ball = nil
+  end
+
+  def perform(op, box)
+    @ball = box
+  end
+
+end # Catch
+
+class FlowTrackerTest < ::Test::Unit::TestCase
+
+  def test_flow_tracker
+    trigger = nil
+    catcher = nil
+    ::OFlow::Env.flow(:nest, :opt1 => 1) { |f|
+
+      # starts off the process
+      trigger = f.task(:trigger, Throw) { |t|
+        t.link(nil, :deep, nil)
+      }
+      # a nested flow
+      f.flow(:deep) { |f2|
+        f2.route(nil, :one, nil)
+        f2.task(:one, Throw) { |t|
+          t.link(nil, :two, nil)
+        }
+        f2.task(:two, Throw) { |t|
+          t.link(nil, :flow, :bye)
+        }
+        f2.link(:bye, :out, nil)
+      }
+      f.task(:out, Throw) { |t|
+          t.link(nil, :done, nil)
+      }
+      catcher = f.task(:done, Catch)
+    }
+
+    # run it and check the output
+    trigger.receive(:go, ::OFlow::Box.new(7, ::OFlow::Tracker.create('test')))
+    ::OFlow::Env.flush()
+    assert_equal(["test-",
+                  ":nest:trigger-go",
+                  ":nest:deep-",
+                  ":nest:deep:one-",
+                  ":nest:deep:two-",
+                  ":nest:deep-bye",
+                  ":nest:out-",
+                  ":nest:done-"], catcher.actor.ball.tracker.track.map {|s| s.where })
+
+    ::OFlow::Env.clear()
+  end
+
+end # FlowTrackerTest

data/test/stutter.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'oflow'
+
+class Stutter < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    task.ship(:collector, ::OFlow::Box.new([task.full_name, op, box.contents]))
+    task.ship(op, box)
+  end
+
+end # Stutter

data/test/task_test.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+class Gather < ::OFlow::Actor
+  attr_accessor :requests
+
+  def initialize(task, options)
+    super
+    @requests = {}
+  end
+
+  def perform(op, box)
+    if @requests[op].nil?
+      @requests[op] = [box]
+    else
+      @requests[op] << box
+    end
+  end
+
+end # Gather
+
+
+class TaskTest < ::Test::Unit::TestCase
+
+  def test_task_queue_count
+    task = ::OFlow::Task.new(nil, 'test', Gather)
+    assert_equal(0, task.queue_count())
+    task.stop()
+    task.receive(:dance, ::OFlow::Box.new('two step'))
+    assert_equal(1, task.queue_count())
+    task.receive(:dance, ::OFlow::Box.new('twist'))
+    assert_equal(2, task.queue_count())
+    task.shutdown()
+  end
+
+  def test_task_perform
+    task = ::OFlow::Task.new(nil, 'test', Gather)
+    task.receive(:dance, ::OFlow::Box.new('two step'))
+    task.flush()
+
+    requests = task.actor.requests
+    assert_equal(1, requests.size)
+    boxes = requests[:dance]
+    assert_equal(1, boxes.size)
+    box = boxes[0]
+    assert_equal(false, box.nil?)
+    assert_equal('two step', box.contents)
+    task.shutdown()
+  end
+
+  def test_task_perform_shutdown
+    task = ::OFlow::Task.new(nil, 'test', Gather)
+    task.receive(:dance, ::OFlow::Box.new('two step'))
+    task.shutdown(true)
+
+    requests = task.actor.requests
+    assert_equal(1, requests.size)
+    boxes = requests[:dance]
+    assert_equal(1, boxes.size)
+    box = boxes[0]
+    assert_equal(false, box.nil?)
+    assert_equal('two step', box.contents)
+  end
+
+  def test_task_raise_after_close
+    task = ::OFlow::Task.new(nil, 'test', Gather)
+    task.shutdown()
+    assert_raise(ThreadError) { task.start() }
+  end
+
+  def test_task_max_queue_count
+    task = ::OFlow::Task.new(nil, 'test', Gather, :max_queue_count => 4, :req_timeout => 0.1)
+    task.stop()
+    6.times do |i|
+      begin
+        task.receive(:dance, ::OFlow::Box.new(i))
+      rescue ::OFlow::BusyError
+        # expected for all over first 4
+      end
+    end
+    task.start()
+    task.shutdown(true)
+
+    requests = task.actor.requests
+    boxes = requests[:dance]
+    assert_equal(4, boxes.size)
+    nums = boxes.map { |box| box.contents }
+    assert_equal([0, 1, 2, 3], nums)
+  end
+
+end # TaskTest

data/test/tracker_test.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+
+require 'test/unit'
+require 'oflow'
+
+class TrackerTest < ::Test::Unit::TestCase
+
+  def test_tracker_new
+    t = ::OFlow::Tracker.create('here')
+    t2 = ::OFlow::Tracker.create('here')
+
+    assert_not_equal(t.id, t2.id, 'id must be unique')
+    assert_equal('here', t.track[0].location)
+  end
+
+  def test_tracker_track
+    t = ::OFlow::Tracker.create('here')
+    t2 = t.receive('there', 'op1')
+
+    assert_equal('here', t.track[0].location)
+    assert_equal('here', t2.track[0].location)
+    assert_equal('there', t2.track[1].location)
+  end
+
+  def test_tracker_merge
+    t = ::OFlow::Tracker.create('here')
+    # 2 different paths
+    t2 = t.receive('there', 'op1')
+    t3 = t.receive('everywhere', 'op2')
+    # should not happen but should handle merging when not back to a common place
+    t4 = t2.merge(t3)
+    assert_equal('here', t4.track[0].location)
+    assert_equal(true, t4.track[1].is_a?(Array))
+    assert_equal(2, t4.track[1].size)
+    assert_equal('there', t4.track[1][0][0].location)
+    assert_equal('everywhere', t4.track[1][1][0].location)
+
+    # back to a common location
+    t2 = t2.receive('home', 'op1')
+    t3 = t3.receive('home', 'op1')
+    t4 = t2.merge(t3)
+    assert_equal('here', t4.track[0].location)
+    assert_equal(true, t4.track[1].is_a?(Array))
+    assert_equal(2, t4.track[1].size)
+    assert_equal('there', t4.track[1][0][0].location)
+    assert_equal('everywhere', t4.track[1][1][0].location)
+    assert_equal('home', t4.track[2].location)
+  end
+
+end # TrackerTest

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: oflow
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Peter Ohler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-04 00:00:00.000000000 Z
+dependencies: []
+description: Operations Workflow in Ruby. This implements a workflow/process flow
+  using multiple task nodes that each have their own queues and execution thread.
+email: peter@ohler.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/oflow.rb
+- lib/oflow/actor.rb
+- lib/oflow/actors.rb
+- lib/oflow/actors/errorhandler.rb
+- lib/oflow/actors/ignore.rb
+- lib/oflow/actors/log.rb
+- lib/oflow/actors/relay.rb
+- lib/oflow/actors/timer.rb
+- lib/oflow/box.rb
+- lib/oflow/env.rb
+- lib/oflow/errors.rb
+- lib/oflow/flow.rb
+- lib/oflow/haserrorhandler.rb
+- lib/oflow/haslinks.rb
+- lib/oflow/haslog.rb
+- lib/oflow/hasname.rb
+- lib/oflow/hastasks.rb
+- lib/oflow/inspector.rb
+- lib/oflow/link.rb
+- lib/oflow/pattern.rb
+- lib/oflow/stamp.rb
+- lib/oflow/task.rb
+- lib/oflow/test.rb
+- lib/oflow/test/action.rb
+- lib/oflow/test/actorwrap.rb
+- lib/oflow/tracker.rb
+- lib/oflow/version.rb
+- test/actors/log_test.rb
+- test/actors/timer_test.rb
+- test/actorwrap_test.rb
+- test/all_tests.rb
+- test/box_test.rb
+- test/collector.rb
+- test/flow_basic_test.rb
+- test/flow_cfg_error_test.rb
+- test/flow_log_test.rb
+- test/flow_nest_test.rb
+- test/flow_rescue_test.rb
+- test/flow_tracker_test.rb
+- test/stutter.rb
+- test/task_test.rb
+- test/tracker_test.rb
+homepage: http://www.ohler.com/oflow
+licenses:
+- MIT
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+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: oflow
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Operations Workflow in Ruby
+test_files: []
+has_rdoc: true