ruote 0.9.20 → 2.1.1

data/test/README.rdoc

@@ -0,0 +1,15 @@
+
+= ruote testing
+
+running all the tests
+
+  $ ruby19 test/test.rb
+
+running a specific test
+
+  $ ruby19 test/functional/ft_1_process_status.rb
+
+running a test with file persistence :
+
+  $ ruby19 test/functional/eft_2_sequence.rb -- --fs
+

data/test/bm/ci.rb

@@ -0,0 +1,55 @@
+
+#
+# testing ruote
+#
+# Wed Sep 16 16:28:36 JST 2009
+#
+
+#require 'profile'
+
+require 'benchmark'
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../path_helper'
+require File.dirname(__FILE__) + '/../functional/engine_helper'
+require 'ruote/log/test_logger'
+
+ac = {
+  #:definition_in_launchitem_allowed => true
+}
+
+engine = determine_engine_class(ac).new(ac)
+
+#puts
+#p engine.class
+#puts
+
+#N = 10_000
+#N = 1_000
+N = 300
+
+engine.add_service(:s_logger, Ruote::TestLogger)
+#engine.context[:noisy] = true
+
+Benchmark.benchmark(' ' * 20 + Benchmark::Tms::CAPTION, 20) do |bench|
+
+  bench.report('run') do
+
+    wfid = engine.launch(
+      Ruote.process_definition(:name => 'ci') {
+        concurrent_iterator(:branches => N.to_s) {
+          noop
+        }
+      }
+    )
+
+    engine.logger.wait_for([ [ :processes, :terminated, { :wfid => wfid } ] ])
+
+  end
+
+end
+
+puts
+
+engine.stop
+

data/test/bm/ici.rb

@@ -0,0 +1,71 @@
+
+#
+# testing ruote
+#
+# Wed Sep 16 16:28:36 JST 2009
+#
+
+#require 'profile'
+
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../path_helper'
+require File.dirname(__FILE__) + '/../functional/engine_helper'
+require 'ruote/log/test_logger'
+
+ac = {
+  #:definition_in_launchitem_allowed => true
+}
+
+engine = determine_engine_class(ac).new(ac)
+
+#puts
+#p engine.class
+#puts
+
+#N = 10_000
+N = 1_000
+#N = 300
+
+engine.add_service(:s_logger, Ruote::TestLogger)
+#engine.context[:noisy] = true
+
+launched = nil
+reached = nil
+count = 0
+
+engine.register_participant :alpha do |workitem|
+  reached ||= Time.now
+  count += 1
+end
+
+launched = Time.now
+
+#wfid = engine.launch(
+#  Ruote.process_definition :name => 'ci' do
+#    concurrent_iterator :branches => N.to_s do
+#      alpha
+#    end
+#  end
+#)
+wfid = engine.launch(
+  Ruote.process_definition(:name => 'ci') do
+    concurrent_iterator :branches => 10 do
+      concurrent_iterator :branches => 10 do
+        concurrent_iterator :branches => 10 do
+          alpha
+        end
+      end
+    end
+  end
+)
+
+engine.logger.wait_for([ [ :processes, :terminated, { :wfid => wfid } ] ])
+
+puts "whole process took #{Time.now - launched} s"
+puts "workitem reached first participant after #{reached - launched} s"
+puts "seen #{count} workitems"
+puts "#{N} branches"
+
+engine.stop
+

data/test/bm/juuman.rb

@@ -0,0 +1,54 @@
+
+#
+# Testing Ruote (OpenWFEru)
+#
+# John Mettraux at openwfe.org
+#
+# Mon Aug  3 17:17:13 JST 2009
+#
+
+require 'benchmark'
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../path_helper'
+require File.dirname(__FILE__) + '/../functional/engine_helper'
+
+require 'ruote/log/test_logger'
+require 'ruote/part/hash_participant'
+
+N = 1000
+#N = 100
+
+ac = {
+  #:definition_in_launchitem_allowed => true
+}
+
+engine = determine_engine_class(ac).new(ac)
+
+pdef = Ruote.process_definition :name => 'test' do
+  alpha
+end
+
+engine.register_participant :alpha, Ruote::HashParticipant
+
+Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|
+
+  wfid = nil
+
+  b.report("launch #{N} processes") do
+    N.times { wfid = engine.launch(pdef) }
+  end
+
+  sleep 3
+
+  b.report("listing 1 process") do
+    engine.process(wfid)
+  end
+  b.report("listing #{N} processes") do
+    ps = engine.processes
+    p [ :wrong, ps.size ] if ps.size != N
+  end
+end
+
+#engine.shutdown
+

data/test/bm/load_26c.rb

@@ -14,9 +14,10 @@ require 'rubygems'
 
 require File.dirname(__FILE__) + '/../path_helper'
 require File.dirname(__FILE__) + '/../functional/engine_helper'
+require 'ruote/log/test_logger'
 
 ac = {
-  :definition_in_launchitem_allowed => true
+  #:definition_in_launchitem_allowed => true
 }
 
 engine = determine_engine_class(ac).new(ac)
@@ -26,7 +27,8 @@ engine = determine_engine_class(ac).new(ac)
 #puts
 
 #N = 10_000
-N = 100
+N = 1_000
+#N = 100
 
 $count = 0
 
@@ -35,18 +37,22 @@ engine.register_participant("count") do |workitem|
   #print '.'
 end
 
+engine.add_service(:s_logger, Ruote::TestLogger)
+
 Benchmark.benchmark(' ' * 20 + Benchmark::Tms::CAPTION, 20) do |bench|
 
   bench.report('run') do
-    engine.launch(
-      OpenWFE.process_definition(:name => 'bm26c') {
+    wfid = engine.launch(
+      Ruote.process_definition(:name => 'bm26c') {
         sequence do
           N.times do
-            count
+            #count
+            participant :ref => 'count'
           end
         end
-      },
-      :wait_for => true)
+      }#, :wait_for => true)
+    )
+    engine.logger.wait_for([ [ :processes, :terminated, { :wfid => wfid } ] ])
   end
 
 end
@@ -55,6 +61,8 @@ puts
 
 engine.stop
 
+# N = 100
+
 # Sat Jan 24 23:57:09 JST 2009
 # ruby 1.8.6 (2008-03-03 patchlevel 114) [universal-darwin9.0]
 #
@@ -77,3 +85,13 @@ engine.stop
 #     user     system      total       real
 #   3.160000   0.060000   3.220000 (  3.749696)
 
+# Mon May 18 13:50:49 JST 2009
+# ruby 1.9.1p129 (2009-05-12 revision 23412) [i386-darwin9.6.0]
+#
+#  using engine of class Ruote::Engine
+#
+#     user     system      total        real
+#   0.010000   0.000000   0.010000 (  0.010206)
+#
+# No participant/subprocess lookup...
+

data/test/bm/mega.rb

@@ -0,0 +1,64 @@
+
+$:.unshift('lib')
+
+require 'rubygems'
+require 'ruote/engine'
+require 'ruote/worker'
+require 'ruote/part/storage_participant'
+require 'ruote/storage/hash_storage'
+require 'ruote/storage/fs_storage'
+require 'ruote/log/test_logger'
+
+#opts = { 's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ] }
+opts = {}
+
+storage = if ARGV.include?('--fs')
+  #FileUtils.rm_rf('work_mega') if ARGV.include?('-e')
+  Ruote::FsStorage.new('work_mega', opts)
+else
+  Ruote::HashStorage.new(opts)
+end
+
+p storage.class
+
+if ARGV.include?('-e')
+  #
+  # engine and worker
+  #
+
+  puts "... engine + worker ..."
+
+  engine = Ruote::Engine.new(Ruote::Worker.new(storage))
+
+  engine.register_participant 'alpha', Ruote::StorageParticipant
+
+  start = Time.now
+
+  pdef = Ruote.process_definition :name => 'mega' do
+    #echo '/${f:index}/'
+    alpha :unless => '${f:index} == 2000'
+  end
+
+  wfid = nil
+
+  (1..2000).to_a.each_with_index do |i|
+    wfid = engine.launch(pdef, 'index' => i)
+  end
+
+  puts "took #{Time.now - start} seconds to launch"
+
+  #engine.context.worker.run_thread.join
+  engine.wait_for(wfid)
+
+else
+  #
+  # pure worker
+  #
+
+  puts "... standalone worker ..."
+
+  worker = Ruote::Worker.new(storage)
+  worker.run
+
+end
+

data/test/bm/seq_thousand.rb

@@ -0,0 +1,31 @@
+
+#
+# testing ruote
+#
+# Fri Dec 18 19:19:07 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), '..', 'functional', 'base')
+
+
+class BmSeqThousandTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_empty_sequence
+
+    n = 100
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        iterator :on => (1..n).to_a do
+          echo 'a'
+        end
+      end
+    end
+
+    noisy
+
+    assert_trace pdef, [ 'a' ] * n
+  end
+end
+

data/test/bm/t.rb

@@ -0,0 +1,35 @@
+
+$:.unshift('lib')
+
+require 'ruote/engine'
+
+pdef = Ruote.process_definition do
+  sequence do
+    #625.times do
+    #500.times do
+    5000.times do
+      echo 'a'
+    end
+  end
+end
+
+engine = Ruote::Engine.new
+t = Time.now
+fei = engine.launch(pdef)
+engine.wait_for(fei.wfid)
+puts "#{Time.now - t}s"
+
+#require 'eventmachine'
+#EM.run {
+#  engine = Ruote::Engine.new
+#  t = Time.now
+#  fei = engine.launch(pdef)
+#  #engine.wait_for(fei.wfid)
+#  #puts "#{Time.now - t}s"
+#  #EM.stop
+#  engine.wqueue.observe(:processes) do |eclass, emsg, args|
+#    puts "#{Time.now - t}s"
+#    EM.stop
+#  end
+#}
+

data/test/functional/base.rb

@@ -1,155 +1,148 @@
 
 #
-# Testing Ruote (OpenWFEru)
-#
-# John Mettraux at openwfe.org
+# testing ruote
 #
 # Sat Sep 20 23:40:10 JST 2008
 #
 
-require File.dirname(__FILE__) + '/../test_helper.rb'
-require File.dirname(__FILE__) + '/engine_helper.rb'
+require 'fileutils'
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+require File.join(File.dirname(__FILE__), 'storage_helper.rb')
 
-require 'openwfe/engine'
+require 'ruote/engine'
+require 'ruote/worker'
+require 'ruote/parser/ruby_dsl'
 
 
 module FunctionalBase
 
   def setup
 
-    @tracer = Tracer.new
-
-    ac = {}
+    #require 'ruote/util/look'
+    #Ruote::Look.dump_lsof
+    #Ruote::Look.dump_lsof_count
 
-    class << ac
-      alias :old_put :[]=
-      def []= (k, v)
-        raise("!!!!! #{k.class}\n#{k.inspect}") \
-          if k.class != String and k.class != Symbol
-        old_put(k, v)
-      end
-    end
-      #
-      # useful for tracking misuses of the application context
-
-    ac['__tracer'] = @tracer
-    ac[:ruby_eval_allowed] = true
-    ac[:definition_in_launchitem_allowed] = true
+    @engine =
+      Ruote::Engine.new(
+        Ruote::Worker.new(
+          determine_storage(
+            's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])))
 
-    @engine = determine_engine_class(ac).new(ac)
+    @tracer = Tracer.new
 
-    @terminated_processes = []
-    @engine.get_expression_pool.add_observer(:terminate) do |c, fe, wi|
-      @terminated_processes << fe.fei.wfid
-      #p [ :terminated, @terminated_processes ]
-    end
+    @engine.add_service('tracer', @tracer)
   end
 
   def teardown
 
-    $OWFE_LOG.level = Logger::INFO
-    @engine.stop
+    @engine.shutdown
+    @engine.context.storage.purge!
   end
 
-  #
-  # returns true when running on a Ruby 1.8.x like interpreter
-  #
-  def ruby18
+  def assert_log_count (count, &block)
+
+    c = @engine.context.logger.log.select(&block).size
+
+    #logger.to_stdout if ( ! @engine.context[:noisy]) && c != count
 
-    RUBY_VERSION.match(/^1\.8\./)
+    assert_equal count, c
   end
 
+  #   assert_trace(pdef, *expected_traces)
+  #   assert_trace(pdef, fields, *expected_traces)
   #
-  # launch_thing is a process definition or a launch item
-  #
-  def assert_trace (launch_thing, expected_trace, opts={})
+  def assert_trace (pdef, *expected_traces)
 
-    fei = @engine.launch(launch_thing, opts[:launch_opts] || {})
+    fields = expected_traces.first.is_a?(Hash) ? expected_traces.shift : {}
 
-    wait(fei, opts)
+    expected_traces = expected_traces.collect do |et|
+      et.is_a?(Array) ? et.join("\n") : et
+    end
 
-    yield(@engine) if block_given?
+    wfid = @engine.launch(pdef, fields)
 
-    assert_engine_clean(fei, opts)
+    wait_for(wfid)
 
-    assert_equal(expected_trace, @tracer.to_s) if expected_trace
+    #yield(@engine) if block_given?
 
-    purge_engine unless opts[:no_purge]
+    assert_engine_clean(wfid)
 
-    fei
-  end
+    if expected_traces.length > 0
+      ok, nok = expected_traces.partition { |et| @tracer.to_s == et }
+      assert_equal(nok.first, @tracer.to_s) if ok.empty?
+    end
 
-  protected
+    assert(true)
+      # so that the assertion count matches
+
+    wfid
+  end
 
-  def log_level_to_debug
+  def logger
 
-    $OWFE_LOG.level = Logger::DEBUG
+    @engine.context.logger
   end
 
-  def wait (fei, opts={})
+  protected
 
-    #opts[:wait] ?
-    #  @engine.wait_for(fei) :
-    #  sleep(opts[:after] || 0.350)
+  def noisy (on=true)
 
-    Thread.pass
-    return if @terminated_processes.include?(fei.wfid)
-    @engine.wait_for(fei)
+    puts "\nnoisy " + caller[0] if on
+    @engine.context.logger.noisy = true
   end
 
-  def assert_engine_clean (fei=nil, opts={})
+  def wait_for (*wfid_or_part)
 
-    assert_no_errors(fei, opts)
-    assert_no_remaining_expressions(fei, opts)
+    @engine.context.logger.wait_for(*wfid_or_part)
   end
 
-  def assert_no_errors (fei, opts)
+  def assert_engine_clean (wfid)
 
-    return if opts[:ignore_errors]
+    assert_no_errors(wfid)
+    assert_no_remaining_expressions(wfid)
+  end
 
-    ps = if fei
-      @engine.process_status(fei.wfid)
-    else
-      @engine.process_statuses.values.first
-    end
+  def assert_no_errors (wfid)
 
-    return unless ps
-    return if ps.errors.size == 0
+    errors = @engine.storage.get_many('errors', /#{wfid}$/)
 
-    # TODO : implement 'banner' function
+    return if errors.size == 0
 
+    puts
     puts '-' * 80
-    puts 'caught process error(s)'
+    puts 'remaining process error(s)'
     puts
-    ps.errors.values.each do |e|
-      puts "  ** error : #{e.error_class} \"#{e.stacktrace}\""
+    errors.each do |e|
+      puts "  ** #{e['message']}"
+      puts e['trace']
     end
     puts '-' * 80
 
     puts_trace_so_far
 
-    flunk 'caught process error(s)'
+    flunk 'remaining process error(s)'
   end
 
-  def assert_no_remaining_expressions (fei, opts)
-
-    return if opts[:ignore_errors]
+  def assert_no_remaining_expressions (wfid)
 
-    expcount = @engine.get_expression_storage.size
-    return if expcount == 1
+    expcount = @engine.storage.get_many('expressions').size
+    return if expcount == 0
 
-    50.times { Thread.pass }
-    expcount = @engine.get_expression_storage.size
-    return if expcount == 1
+    tf, _, tn = caller[2].split(':')
 
+    puts
     puts '-' * 80
     puts 'too many expressions left in storage'
     puts
-    puts "this test's wfid : #{fei.wfid}"
+    puts "this test : #{tf}"
+    puts "            #{tn}"
+    puts
+    puts "this test's wfid : #{wfid}"
     puts
     puts 'left :'
     puts
-    puts @engine.get_expression_storage.to_s
+    puts @engine.context.storage.dump('expressions')
     puts
     puts '-' * 80
 
@@ -158,14 +151,6 @@ module FunctionalBase
     flunk 'too many expressions left in storage'
   end
 
-  def purge_engine
-
-    @engine.application_context.values.each do |s|
-      s.purge if s.respond_to?(:purge)
-    end
-    FileUtils.rm_rf('work')
-  end
-
   def puts_trace_so_far
 
     #puts '. ' * 40
@@ -173,26 +158,30 @@ module FunctionalBase
     puts '---8<---'
     puts @tracer.to_s
     puts '--->8---'
-    puts '. ' * 40
+    puts
   end
 end
 
 class Tracer
+  attr_reader :s
   def initialize
     super
-    @trace = ''
+    @s = ''
   end
   def to_s
-    @trace.to_s.strip
+    @s.to_s.strip
+  end
+  def to_a
+    to_s.split("\n")
   end
   def << s
-    @trace << s
+    @s << s
   end
   def clear
-    @trace = ''
+    @s = ''
   end
-  def puts s
-    @trace << "#{s}\n"
+  def puts (s)
+    @s << "#{s}\n"
   end
 end