oflow 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bffd9fcf94e7e2e7bd1042d9eac1579debdbb15
-  data.tar.gz: 1606f17e500c5c533b7192dfb2308ffffb99a393
+  metadata.gz: a5ebeca0ca2d46e8134511f55eeb680352c49a0a
+  data.tar.gz: 7aacf1ca2bde1fd1413695f607a6d087bfbc8935
 SHA512:
-  metadata.gz: c9c6fac1a663adba34988a7caeaff5603054aaa7cf581186bcd199ff439650bc168e3ff65f9edf5a0cc2bf71e246aef5e032f97a11b70f7b2b92050170467053
-  data.tar.gz: a158841d007f3be5f1bddc54fb22686931ff42bdd033c5b097d2bcef6ceb351347e9c0709107926866de9ea0504c429d7bbe28ffeb1d9a2b2974075bb790de80
+  metadata.gz: 4d8a98f7a6362f81f1fe83d56017b5cf09ced84f59be798fa60edbd647031a83772e0045ac2559d720d79b2367559e18471e24aadc80a789305932cb529c7a7b
+  data.tar.gz: ab9864fcea8cb033cbe1c7926ef8edee98934a741d2eae89a7db1f8a7b9e3ac85de436a50931e7110652c38ec0158530f047b0c6e0591ffe696e76465a026e29

data/README.md

@@ -21,9 +21,19 @@ Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announceme
 
 ## Build Status
 
-[![Build Status](https://secure.travis-ci.org/ohler55/oflow.png?branch=master)](http://travis-ci.org/ohler55/oflow)
+[![Build Status](https://travis-ci.org/ohler55/oflow-ruby.png?branch=master)](https://travis-ci.org/ohler55/oflow-ruby)
 
-### Current Release 0.3
+## Release Notes
+
+### Release 0.4
+
+ - Added support for dynamic Timer options updates.
+
+ - Added Balancer Actor for load balancing of processing across multiple tasks.
+
+ - Added Merger Actor that merges two or more processing paths.
+
+### Release 0.3
 
  - Initial release with minimal features.
 

data/lib/oflow/actor.rb

@@ -25,7 +25,7 @@ module OFlow
     # Returns whether the Actor should have it's own thread or not. In almost
     # all cases the Actor should have it's own thread. The exception is when the
     # action is trivial such as a relay.
-    # @return [Boolean] indicator of whether a new thread should be created.
+    # @return [true|false] indicator of whether a new thread should be created.
     def with_own_thread()
       true
     end

data/lib/oflow/actors/balancer.rb

@@ -0,0 +1,38 @@
+
+module OFlow
+  module Actors
+
+    # Redirects operations to one Task out of all the linked tasks. It uses the
+    # Task.backed_up() method to determine which task is the least busy. It also
+    # attempts to distribute requests somewhat evenly if Tasks are equally as
+    # busy.
+    class Balancer < Actor
+
+      def initialize(task, options)
+        super
+        @cnt = 0
+        @called = {}
+      end
+
+      def perform(op, box)
+        best = nil
+        order = nil
+        bbu = nil
+        @task.links().each do |dest,lnk|
+          t = lnk.target
+          next if t.nil?
+          bu = t.backed_up()
+          if bbu.nil? || bu < bbu || (bbu == bu && @called.fetch(dest, 0) < order)
+            best = dest
+            bbu = bu
+            order = @called.fetch(dest, 0)
+          end
+        end
+        @cnt += 1
+        @called[best] = @cnt
+        task.ship(best, box)
+      end
+
+    end # Balancer
+  end # Actors
+end # OFlow

data/lib/oflow/actors/merger.rb

@@ -0,0 +1,85 @@
+
+module OFlow
+  module Actors
+
+    class Merger < Actor
+
+      def initialize(task, options)
+        super
+        @match_key = options.fetch(:match, :tracker)
+        @cnt = options.fetch(:count, 2)
+        # Hash of Arrays
+        @waiting = {}
+      end
+
+      def perform(op, box)
+        matches = match(box)
+        if matches.nil?
+          waiting_add(box)
+        else
+          matches.each { |b| waiting_remove(b) }
+          matches << box
+          box = merge(matches)
+          task.ship(nil, box)
+        end
+      end
+
+      def box_key(box)
+        key = nil
+        if :tracker == @match_key
+          key = box.tracker.id unless box.tracker.nil?
+        elsif !@match_key.nil?
+          key = box.get(@match_key)
+        end
+        key
+      end
+
+      def waiting_add(box)
+        key = box_key(box)
+        boxes = @waiting[key]
+        if boxes.nil?
+          @waiting[key] = [box]
+        else
+          boxes << box
+        end
+      end
+
+      def waiting_remove(box)
+        key = box_key(box)
+        boxes = @waiting[key]
+        # only remove the box, not a similar one or one that is ==
+        boxes.delete_if { |b| box.equal?(b) }
+      end
+
+      # Should look at all the waiting boxes and determine which of those if any
+      # are a match for the target. If all necessary matches are found then an
+      # array of the boxes are returned, otherwise nil is returned.
+      def match(target)
+        key = box_key(target)
+        boxes = @waiting[key]
+        return nil if boxes.nil? || (boxes.size + 1) < @cnt  
+        Array.new(boxes)
+      end
+
+      # Should merge the boxes and return a single box. The default is to take
+      # all the box contents and place them in an Array and then merge the
+      # Trackers if there are any.
+      def merge(boxes)
+        content = []
+        tracker = nil
+        boxes.each do |b|
+          content << b.contents
+          unless b.tracker.nil?
+            if tracker.nil?
+              tracker = b.tracker
+            else
+              tracker = tracker.merge(b.tracker)
+            end
+          end
+        end
+        Box.new(content, tracker)
+      end
+
+    end # Merger
+  end # Actors
+end # OFlow

data/lib/oflow/actors/timer.rb

@@ -30,8 +30,10 @@ module OFlow
       def initialize(task, options={})
         @count = 0
         @pending = nil
+        @stop = nil
+        @period = nil
+        @repeat = nil
         set_options(options)
-        @start = Time.now() if @start.nil?
         @pending = @start
         super
         task.receive(:init, nil)
@@ -46,17 +48,25 @@ module OFlow
         op = op.to_sym unless op.nil?
         case op
         when :stop
-          # TBD if no arg (or earlier than now) then stop now else set to new stop time
+          set_stop(box.nil? ? nil : box.contents)
         when :start
-          # TBD if stopped then start if no arg, if arg then set start time
+          old = @start
+          set_start(box.nil? ? nil : box.contents)
+          @pending = @start if @start < old
         when :period
-          # TBD
+          old = @period
+          set_period(box.nil? ? nil : box.contents)
+          if old.nil? || @pending.nil? || @pending.nil?
+            @pending = nil
+          else
+            @pending = @pending - old + @period
+          end
         when :repeat
-          # TBD
+          set_repeat(box.nil? ? nil : box.contents)
         when :label
-          # TBD
+          set_label(box.nil? ? nil : box.contents)
         when :with_tracker
-          # TBD
+          set_with_tracker(box.nil? ? nil : box.contents)
         end
         while true
           now = Time.now()
@@ -76,7 +86,7 @@ module OFlow
             unless Task::STOPPED == task.state
               @count += 1
               now = Time.now()
-              tracker = @with_tracker ? Tracker.new(@label) : nil
+              tracker = @with_tracker ? Tracker.create(@label) : nil
               box = Box.new([@label, @count, now.utc()], tracker)
               task.links.each_key do |key|
                 begin
@@ -112,13 +122,61 @@ module OFlow
       end
 
       def set_options(options)
-        @start = options[:start]
-        @stop = options[:stop]
-        @period = options[:period]
-        @repeat = options[:repeat]
-        @label = options[:label]
-        @with_tracker = options[:with_tracker]
-        # TBD check values for type and range
+        set_start(options[:start]) # if nil let start get set to now
+        set_stop( options[:stop]) if options.has_key?(:stop)
+        set_period(options[:period]) if options.has_key?(:period)
+        set_repeat(options[:repeat]) if options.has_key?(:repeat)
+        set_with_tracker(options[:with_tracker])
+        @label = options[:label].to_s
+      end
+
+      def set_start(v)
+        now = Time.now()
+        if v.is_a?(Numeric)
+          v = now + v
+        elsif v.nil?
+          v = Time.now()
+        elsif !v.kind_of?(Time) && !v.kind_of?(Date)
+          raise ConfigError.new("Expected start to be a Time or Numeric, not a #{v.class}.")
+        end
+        @start = v
+      end
+
+      def set_stop(v)
+        now = Time.now()
+        if v.is_a?(Numeric)
+          v = now + v
+        elsif !v.nil? && !v.kind_of?(Time) && !v.kind_of?(Date)
+          raise ConfigError.new("Expected stop to be a Time or Numeric, not a #{v.class}.")
+        end
+        @stop = v
+      end
+
+      def set_period(v)
+        unless v.nil? || v.kind_of?(Numeric)
+          raise ConfigError.new("Expected period to be a Numeric, not a #{v.class}.")
+        end
+        @period = v
+      end
+
+      def set_repeat(v)
+        unless v.nil? || v.kind_of?(Fixnum)
+          raise ConfigError.new("Expected repeat to be a Fixnum, not a #{v.class}.")
+        end
+        @repeat = v
+      end
+
+      def set_label(v)
+        v = v.to_s unless v.nil?
+        @label = v
+      end
+
+      def set_with_tracker(v)
+        v = false if v.nil?
+        unless true == v || false == v
+          raise ConfigError.new("Expected with_tracker to be a boolean, not a #{v.class}.")
+        end
+        @with_tracker = v
       end
 
     end # Timer

data/lib/oflow/actors.rb

@@ -8,4 +8,7 @@ require 'oflow/actors/ignore'
 require 'oflow/actors/relay'
 require 'oflow/actors/log'
 require 'oflow/actors/errorhandler'
+
+require 'oflow/actors/balancer'
+require 'oflow/actors/merger'
 require 'oflow/actors/timer'

data/lib/oflow/hastasks.rb

@@ -74,7 +74,7 @@ module OFlow
 
     # Performs a recursive walk over all Tasks and yields to the provided block
     # for each. Flows are followed recusively.
-    # @param tasks_only [Boolean] indicates on Tasks and not Flows are yielded to
+    # @param tasks_only [true|false] indicates on Tasks and not Flows are yielded to
     # @param blk [Proc] Proc to call on each iteration
     def walk_tasks(tasks_only=true, &blk)
       @tasks.each_value do |t|
@@ -185,7 +185,7 @@ module OFlow
     end
 
     # Shuts down all Tasks.
-    # @param flush_first [Boolean] flag indicating shutdown should occur after the system becomes idle
+    # @param flush_first [true|false] flag indicating shutdown should occur after the system becomes idle
     def shutdown(flush_first=false)
       # block all tasks first so threads can empty queues
       @tasks.each_value do |task|

data/lib/oflow/link.rb

@@ -18,7 +18,7 @@ module OFlow
     # Tasks and Flows.
     # @param target_name [Symbol] target Task base name
     # @param op [Symbol] operation to use on the target
-    # @param ingress [Boolean] indicates the Link is internal
+    # @param ingress [true|false] indicates the Link is internal
     # @return [Link] new Link
     def initialize(target_name, op, ingress=false)
       @target_name = target_name

data/lib/oflow/task.rb

@@ -90,7 +90,7 @@ module OFlow
               sleep(1.0)
             end
           rescue Exception => e
-                puts "*** #{full_name} #{e.class}: #{e.message}"
+            puts "*** #{full_name} #{e.class}: #{e.message}"
             @current_req = nil
             # TBD Env.rescue(e)
           end
@@ -159,7 +159,7 @@ module OFlow
     # selecting an Actor when stepping from the Inspector.
     # @return [Fixnum] a measure of how backed up a Task is
     def backed_up()
-      cnt = @queue.size()
+      cnt = @queue.size() + (@current_req.nil? ? 0 : 1)
       return 0 if 0 == cnt
       if @max_queue_count.nil? || 0 == @max_queue_count
         cnt = 80 if 80 < cnt
@@ -217,6 +217,7 @@ module OFlow
 
     # Wakes up the Task if it has been stopped or if Env.shutdown() has been called.
     def wakeup()
+      # don't wake if the task is currently processing
       @loop.wakeup() unless @loop.nil?
     end
 

data/lib/oflow/test/actorwrap.rb

@@ -11,8 +11,15 @@ module OFlow
 
       def initialize(name, actor_class, options={})
         @name = name
+        @before = []
+        @state = options.fetch(:state, Task::RUNNING)
+        @starting = true
         @actor = actor_class.new(self, options)
+        @starting = false
         @history = []
+        @before.each do |req|
+          receive(req[0], req[1])
+        end
       end
 
       def reset()
@@ -23,9 +30,27 @@ module OFlow
         ":test:#{@name}"
       end
 
+      def state()
+        @state
+      end
+
+      def links()
+        lnk = Link.new(@name, nil)
+        lnk.instance_variable_set(:@target, self)
+        { nil => lnk }
+      end
+
+      def queue_count()
+        0
+      end
+
       # Calls perform on the actor instance
       def receive(op, box)
-        @actor.perform(op, box)
+        if @starting
+          @before << [op, box]
+        else
+          @actor.perform(op, box)
+        end
       end
 
       # Task API that adds entry to history.

data/lib/oflow/version.rb

@@ -1,5 +1,5 @@
 
 module OFlow
   # Current version of the module. 
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/test/actors/balancer_test.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../../lib"),
+  File.join(File.dirname(__FILE__), "..")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+require 'oflow/test'
+
+require 'collector'
+
+class Busy < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+    @delay = options.fetch(:delay, 0)
+  end
+
+  def perform(op, box)
+    if 0.0 < @delay
+      done = Time.now() + @delay
+      while true
+        now = Time.now()
+        break if done <= now
+        sleep(done - now)
+      end
+    end
+    task.ship(nil, ::OFlow::Box.new([task.name, box.contents]))
+  end
+
+end # Busy
+
+class BalancerTest < ::Test::Unit::TestCase
+
+  def test_balancer_fair
+    balancer = nil
+    collector = nil
+    ::OFlow::Env.flow('fair') { |f|
+      f.task('balance', ::OFlow::Actors::Balancer) { |t|
+        balancer = t
+        t.link(:one, :one, nil)
+        t.link(:two, :two, nil)
+        t.link(:three, :three, nil)
+      }
+      f.task(:one, Busy) { |t|
+        t.link(nil, :collector, :one)
+      }
+      f.task(:two, Busy) { |t|
+        t.link(nil, :collector, :two)
+      }
+      f.task(:three, Busy) { |t|
+        t.link(nil, :collector, :three)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    9.times { |i| balancer.receive(nil, ::OFlow::Box.new(i)) }
+    ::OFlow::Env.flush()
+    counts = {}
+    collector.collection.each { |a| counts[a[0]] = counts.fetch(a[0], 0) + 1 }
+
+    assert_equal(counts[:one], counts[:two], 'all counts should be the same')
+    assert_equal(counts[:two], counts[:three], 'all counts should be the same')
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_balancer_less_busy
+    balancer = nil
+    collector = nil
+    ::OFlow::Env.flow('less-busy') { |f|
+      f.task('balance', ::OFlow::Actors::Balancer) { |t|
+        balancer = t
+        t.link(:one, :one, nil)
+        t.link(:two, :two, nil)
+        t.link(:three, :three, nil)
+      }
+      f.task(:one, Busy, delay: 0.01) { |t|
+        t.link(nil, :collector, :one)
+      }
+      f.task(:two, Busy, delay: 0.02) { |t|
+        t.link(nil, :collector, :two)
+      }
+      f.task(:three, Busy, delay: 0.04) { |t|
+        t.link(nil, :collector, :three)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    40.times { |i| balancer.receive(nil, ::OFlow::Box.new(i)); sleep(0.005) }
+    ::OFlow::Env.flush()
+    counts = {}
+    collector.collection.each { |a| counts[a[0]] = counts.fetch(a[0], 0) + 1 }
+    #puts "*** #{counts}"
+
+    assert(counts[:one] > counts[:two], 'one is faster and should have processed more than two')
+    assert(counts[:two] > counts[:three], 'two is faster and should have processed more than three')
+
+    ::OFlow::Env.clear()
+  end
+
+end # BalancerTest

data/test/actors/merger_test.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../../lib"),
+  File.join(File.dirname(__FILE__), "..")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+require 'oflow/test'
+
+require 'collector'
+
+class Splitter < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    task.ship(:left, box)
+    task.ship(:right, box)
+  end
+
+end # Splitter
+
+class Multiplier < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+    @factor = options.fetch(:factor, 1)
+  end
+
+  def perform(op, box)
+    box = box.set(nil, box.contents * @factor)
+    task.ship(nil, box)
+  end
+
+end # Multiplier
+
+class MergerTest < ::Test::Unit::TestCase
+
+  def test_merger_any
+    start = nil
+    collector = nil
+    ::OFlow::Env.flow('merge') { |f|
+      f.task(:split, Splitter) { |t|
+        start = t
+        t.link(:left, :one, nil)
+        t.link(:right, :two, nil)
+      }
+      f.task(:one, Multiplier, factor: 2) { |t|
+        t.link(nil, :merge, nil)
+      }
+      f.task(:two, Multiplier, factor: 3) { |t|
+        t.link(nil, :merge, nil)
+      }
+      f.task(:merge, ::OFlow::Actors::Merger) { |t|
+        t.link(nil, :collector, nil)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    start.receive(nil, ::OFlow::Box.new(1))
+    ::OFlow::Env.flush()
+
+    result = collector.collection[0]
+    assert_equal(2, result.size, 'should be 2 values in the box')
+    assert(result.include?(2), 'box should include 2')
+    assert(result.include?(3), 'box should include 3')
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_merger_tracker
+    start = nil
+    collector = nil
+    ::OFlow::Env.flow('merge') { |f|
+      f.task(:split, Splitter) { |t|
+        start = t
+        t.link(:left, :one, nil)
+        t.link(:right, :two, nil)
+      }
+      f.task(:one, Multiplier, factor: 2) { |t|
+        t.link(nil, :merge, nil)
+      }
+      f.task(:two, Multiplier, factor: 3) { |t|
+        t.link(nil, :merge, nil)
+      }
+      f.task(:merge, ::OFlow::Actors::Merger) { |t|
+        t.link(nil, :collector, nil)
+      }
+      f.task(:collector, Collector, contents_only: false) { |t|
+        collector = t.actor
+      }
+    }
+    tracker = ::OFlow::Tracker.create('start')
+    start.receive(nil, ::OFlow::Box.new(1, tracker))
+    tracker2 = ::OFlow::Tracker.create('start2')
+    start.receive(nil, ::OFlow::Box.new(10, tracker2))
+    ::OFlow::Env.flush()
+
+    box = collector.collection[0]
+    result = box.contents
+    assert_equal(2, result.size, 'should be 2 values in the box')
+    assert(result.include?(2), 'box should include 2')
+    assert(result.include?(3), 'box should include 3')
+    
+    t = box.tracker()
+    assert_not_nil(t, 'should have a tracker')
+    assert_equal(t.id, tracker.id, 'tracker id should be carried through')
+    track = t.track
+    
+    assert_equal('start', track[0].location)
+    assert_equal(':merge:split', track[1].location)
+    split = track[2].map { |a| a.map { |stamp| stamp.location } }
+
+    assert_equal(2, split.size, 'should be 2 values in the split')
+    assert(split.include?([':merge:one']), 'split should include [merge:one]')
+    assert(split.include?([':merge:two']), 'split should include [merge:two]')
+    assert_equal(':merge:merge', track[3].location)
+    assert_equal(':merge:collector', track[4].location)
+
+    box = collector.collection[1]
+    result = box.contents
+    assert_equal(2, result.size, 'should be 2 values in the box')
+    assert(result.include?(20), 'box should include 20')
+    assert(result.include?(30), 'box should include 30')
+
+    ::OFlow::Env.clear()
+  end
+
+end # MergerTest

data/test/actors/timer_test.rb

@@ -8,12 +8,13 @@
 
 require 'test/unit'
 require 'oflow'
+require 'oflow/test'
 
 require 'collector'
 
 class TimerTest < ::Test::Unit::TestCase
 
-  def test_timer_repeat
+  def test_timer_period_repeat
     period = 0.1
     timer = nil
     collector = nil
@@ -51,6 +52,232 @@ class TimerTest < ::Test::Unit::TestCase
     ::OFlow::Env.clear()
   end
 
-  # TBD more tests on start, stop, combinations of options, and error conditions
+  def test_timer_options_start
+    now = Time.now()
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, start: now, state: ::OFlow::Task::BLOCKED)
+    assert_equal(now, t.actor.start, 'is the start time now?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, start: nil, state: ::OFlow::Task::BLOCKED)
+    assert_equal(Time, t.actor.start.class, 'is the start time a Time?')
+    assert(0.1 > (Time.now() - t.actor.start), 'is the start time now?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, start: 2, state: ::OFlow::Task::BLOCKED)
+    assert_equal(Time, t.actor.start.class, 'is the start time a Time?')
+    assert(0.1 > (Time.now() + 2 - t.actor.start), 'is the start time now + 2?')
+
+    assert_raise(::OFlow::ConfigError) do
+      ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, start: 'now')
+    end
+  end
+
+  def test_timer_options_stop
+    now = Time.now()
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, stop: now, state: ::OFlow::Task::BLOCKED)
+    assert_equal(now, t.actor.stop, 'is the stop time now?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, stop: nil, state: ::OFlow::Task::BLOCKED)
+    assert_equal(nil, t.actor.stop, 'is the stop time nil?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, stop: 2, state: ::OFlow::Task::BLOCKED)
+    assert_equal(Time, t.actor.stop.class, 'is the stop time a Time?')
+    assert(0.1 > (Time.now() + 2 - t.actor.stop), 'is the stop time now + 2?')
+
+    assert_raise(::OFlow::ConfigError) do
+      ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, stop: 'now')
+    end
+  end
+
+  def test_timer_options_period
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: nil, state: ::OFlow::Task::BLOCKED)
+    assert_equal(nil, t.actor.period, 'is the period nil?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: 2, state: ::OFlow::Task::BLOCKED)
+    assert_equal(2, t.actor.period, 'is the period 2?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: 2.0, state: ::OFlow::Task::BLOCKED)
+    assert_equal(2.0, t.actor.period, 'is the period 2.0?')
+
+    assert_raise(::OFlow::ConfigError) do
+      ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, period: 'now')
+    end
+  end
+
+  def test_timer_options_repeat
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, repeat: nil, state: ::OFlow::Task::BLOCKED)
+    assert_equal(nil, t.actor.repeat, 'is the repeat nil?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, repeat: 2, state: ::OFlow::Task::BLOCKED)
+    assert_equal(2, t.actor.repeat, 'is the repeat 2?')
+
+    assert_raise(::OFlow::ConfigError) do
+      ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, repeat: 2.0)
+    end
+  end
+
+  def test_timer_options_with_tracker
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, with_tracker: nil, state: ::OFlow::Task::BLOCKED)
+    assert_equal(false, t.actor.with_tracker, 'is the with_tracker false?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, with_tracker: false, state: ::OFlow::Task::BLOCKED)
+    assert_equal(false, t.actor.with_tracker, 'is the with_tracker false?')
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, with_tracker: true, state: ::OFlow::Task::BLOCKED)
+    assert_equal(true, t.actor.with_tracker, 'is the with_tracker true?')
+
+    assert_raise(::OFlow::ConfigError) do
+      ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, with_tracker: 'now')
+    end
+
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, with_tracker: true, repeat: 2, label: 'fast')
+    assert_equal(2, t.history.size, 'are there 2 items in the history?')
+    assert_equal(false, t.history[0].box.tracker.nil?, 'is there a tracker on the box that shipped?')
+  end
+
+  def test_timer_repeat
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, repeat: 2, label: 'fast')
+    assert_equal(2, t.history.size, 'are there 2 items in the history?')
+  end
+
+  def test_timer_time
+    t = ::OFlow::Test::ActorWrap.new('test', ::OFlow::Actors::Timer, stop: 2, period: 0.5, label: 'time')
+    assert_equal(4, t.history.size, 'are there 4 items in the history?')
+  end
+
+  def test_timer_perform_period
+    period = 0.1
+    timer = nil
+    collector = nil
+    ::OFlow::Env.flow('one-time') { |f|
+      f.task('once', ::OFlow::Actors::Timer, repeat: 2, period: 2) { |t|
+        timer = t
+        t.link(:ping, :collector, :tick)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    timer.receive(:period, ::OFlow::Box.new(period))
+    ::OFlow::Env.flush()
+    prev = nil
+    ticks = collector.collection.map do |t|
+      tf = t[2].to_f
+      if prev.nil?
+        tick = [t[1], tf, 0.0]
+      else
+        tick = [t[1], tf, tf - prev]
+      end
+      prev = tf
+      tick
+    end
+    
+    ticks.size.times do |i|
+      tick = ticks[i]
+      assert_equal(i + 1, tick[0])
+      next if 0 == i
+      dif = tick[2] - period
+      limit = period / 10 # 10% accuracy
+      assert(-limit < dif && dif < limit, "Verify timer fires are within 10% of expected. (dif: #{dif}, limit: #{limit})")
+    end
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_timer_perform_repeat
+    repeat = 2
+    timer = nil
+    collector = nil
+    ::OFlow::Env.flow('one-time') { |f|
+      f.task('once', ::OFlow::Actors::Timer, repeat: 4, period: 0.1) { |t|
+        timer = t
+        t.link(:ping, :collector, :tick)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    timer.receive(:repeat, ::OFlow::Box.new(repeat))
+    ::OFlow::Env.flush()
+    assert_equal(2, collector.collection.size)
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_timer_perform_start
+    now = Time.now()
+    timer = nil
+    collector = nil
+    ::OFlow::Env.flow('one-time') { |f|
+      f.task('once', ::OFlow::Actors::Timer, repeat: 1, period: 0.1, start: 2) { |t|
+        timer = t
+        t.link(:ping, :collector, :tick)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    timer.receive(:start, ::OFlow::Box.new(nil))
+    ::OFlow::Env.flush()
+    first_fire = collector.collection[0][2] - now
+    assert(0.01 > first_fire, "first fire was at #{first_fire}, expected less than 0.01 msecs?")
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_timer_perform_stop
+    timer = nil
+    collector = nil
+    ::OFlow::Env.flow('one-time') { |f|
+      f.task('once', ::OFlow::Actors::Timer, repeat: 10, period: 0.1, stop: 2) { |t|
+        timer = t
+        t.link(:ping, :collector, :tick)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    timer.receive(:stop, ::OFlow::Box.new(0.25))
+    ::OFlow::Env.flush()
+    assert_equal(3, collector.collection.size)
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_timer_perform_label
+    timer = nil
+    collector = nil
+    ::OFlow::Env.flow('one-time') { |f|
+      f.task('once', ::OFlow::Actors::Timer, repeat: 2, period: 0.1, label: 'first') { |t|
+        timer = t
+        t.link(:ping, :collector, :tick)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    timer.receive(:label, ::OFlow::Box.new('second'))
+    ::OFlow::Env.flush()
+    assert_equal(['first', 'second'], collector.collection.map { |x| x[0] })
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_timer_perform_tracker
+    timer = nil
+    collector = nil
+    ::OFlow::Env.flow('one-time') { |f|
+      f.task('once', ::OFlow::Actors::Timer, repeat: 2, period: 0.1, with_tracker: false) { |t|
+        timer = t
+        t.link(:ping, :collector, :tick)
+      }
+      f.task(:collector, Collector, contents_only: false) { |t|
+        collector = t.actor
+      }
+    }
+    timer.receive(:with_tracker, ::OFlow::Box.new(true))
+    ::OFlow::Env.flush()
+    assert_equal([false, true], collector.collection.map { |x| !x.tracker.nil? })
+
+    ::OFlow::Env.clear()
+  end
 
 end # TimerTest

data/test/all_tests.rb

@@ -24,4 +24,6 @@ require 'flow_tracker_test'
 # Actor tests
 require 'actors/log_test'
 require 'actors/timer_test'
+require 'actors/balancer_test'
+require 'actors/merger_test'
 

data/test/collector.rb

@@ -13,10 +13,15 @@ class Collector < ::OFlow::Actor
   def initialize(task, options)
     super
     @collection = []
+    @contents_only = options.fetch(:contents_only, true)
   end
 
   def perform(op, box)
-    @collection << box.contents
+    if @contents_only
+      @collection << box.contents
+    else
+      @collection << box
+    end
   end
 
 end # Collector

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oflow
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-04 00:00:00.000000000 Z
+date: 2014-02-08 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.
@@ -23,9 +23,11 @@ files:
 - lib/oflow.rb
 - lib/oflow/actor.rb
 - lib/oflow/actors.rb
+- lib/oflow/actors/balancer.rb
 - lib/oflow/actors/errorhandler.rb
 - lib/oflow/actors/ignore.rb
 - lib/oflow/actors/log.rb
+- lib/oflow/actors/merger.rb
 - lib/oflow/actors/relay.rb
 - lib/oflow/actors/timer.rb
 - lib/oflow/box.rb
@@ -47,7 +49,9 @@ files:
 - lib/oflow/test/actorwrap.rb
 - lib/oflow/tracker.rb
 - lib/oflow/version.rb
+- test/actors/balancer_test.rb
 - test/actors/log_test.rb
+- test/actors/merger_test.rb
 - test/actors/timer_test.rb
 - test/actorwrap_test.rb
 - test/all_tests.rb