rbpm 0.0.2 → 0.0.3

data/lib/rbpm/workflow_managment.rb

@@ -0,0 +1,57 @@
+#---------------------------------------------------------------------------------------------------------------------------------
+#
+# rbpm lightweight workflows, copyright (c) 2005 Christian Tschenett <furthermore@nospam@tschenett.ch>
+#
+# This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License 
+# as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the 
+# Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#---------------------------------------------------------------------------------------------------------------------------------
+
+module Rbpm
+  
+  #the version manager can deal with multiple versions of a workflow
+  #if you put you workflow in a module and if you follow well defined 
+  #naming patterns for workflow class names and workflow module names.
+  #naming sample for a workflow named "foo" having version 1 and 2:
+  #module name of version 1: FooWorkflowVersion1.
+  #module name of version 2: FooWorkflowVersion2.
+  #class name of version 1 and 2: FooWorkflow.
+  #node: all workflow ruby files have to be "required" before
+  #relying on this version manager. maybe you introduce some sort
+  #of hot deploy directory or put workflow versions (ruby files)
+  #in a RDBMS table and automatically load them (or whatever :-)
+  class WorkflowVersionManager
+    
+    #finds version numbers of a given workflow (or number prefixes
+    #of loaded workflow modules, to be precise)
+    def self.find_workflow_versions(workflow_name)
+      versions = []
+      ObjectSpace.each_object(Module) do |m|
+        module_name = m.to_s
+        if module_name =~ /#{workflow_name}Version([0-9]+)$/
+          versions << $1.to_i
+        end
+      end
+      versions
+    end
+  
+    #returns a new workflow instance. version can be a number or :latest.
+    def self.create_workflow_instance(workflow_name, version = :latest, super_workflow_ref = -1)
+      workflow_name = workflow_name.to_s if workflow_name.is_a? Symbol
+      if :latest == version
+        versions = find_workflow_versions(workflow_name)  
+        if versions.empty?
+          #fallback to non-versionned wf
+          return eval("#{workflow_name}.new(#{super_workflow_ref})")
+        else
+          version = versions.max
+        end  
+      end
+      return eval("#{workflow_name}Version#{version}::#{workflow_name}.new(#{super_workflow_ref})")
+    end
+  end
+end

data/test/rbpm_action_tests.rb

@@ -1,9 +1,14 @@
 require 'test/unit'
 
 begin
-  require 'rbpm'
+  require 'rubygems'
+  require_gem 'rbpm'
 rescue LoadError
-  require '../lib/rbpm'
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
 end
 
 $mylog = {}

data/test/rbpm_call_tests.rb

@@ -1,9 +1,14 @@
 require 'test/unit'
 
 begin
-  require 'rbpm'
+  require 'rubygems'
+  require_gem 'rbpm'
 rescue LoadError
-  require '../lib/rbpm'
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
 end
 
 class DemoWorkflow6b < Rbpm::Workflow

data/test/rbpm_concurrency_fine_grained_graph_programming_sync_tests.rb

@@ -0,0 +1,153 @@
+require 'monitor'
+require 'test/unit'
+
+begin
+  require 'rubygems'
+  require_gem 'rbpm'
+rescue LoadError
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
+end
+
+#FIXME synchronized access to (parent)token and workflow instance variables which are target of concurrent access
+
+module Rbpm::Concurrent
+  class Token < Rbpm::Token
+    attr_reader :token_count, :token_count_cond, :first_token
+    attr_writer :token_count, :token_count_cond, :first_token
+    
+    def initialize(workflow, parent = nil, ctx_vars = {}, ref = -1)
+      super workflow, parent, ctx_vars, ref
+      @lock = Monitor.new
+      @first_token = false
+      @token_count = nil
+      @token_count_cond = nil
+    end
+    
+    def synchronize
+      @lock.synchronize do
+        yield
+      end
+    end
+  end
+  
+  class Workflow < Rbpm::Workflow
+    def create_token_instance(parent = nil, ctx_vars = {})
+      Token.new(self, parent, ctx_vars, generate_token_id)
+    end
+    
+    def take_transitions(transition_tokens)
+      first_transition,first_token = transition_tokens.shift
+      if (transition_tokens.length > 0)
+        
+        #parallel execution (one thread per token)
+        
+        token_count = [transition_tokens.length]
+        token_count.extend(MonitorMixin)
+        token_count_cond = token_count.new_cond
+        
+        transition_tokens.each do |transition_token|
+          transition,token = transition_token
+          token.token_count = token_count
+          token.token_count_cond = token_count_cond
+          Thread.new(transition,token) do |transition,token|
+            #puts "(thread)"
+            token.transit(transition)
+            #puts "(/thread)"
+          end
+        end
+        
+        #puts "(main)"
+        first_token.first_token = true
+        first_token.token.token_count = token_count
+        first_token.token.token_count_cond = token_count_cond
+        first_token.transit(first_transition) #first token will be executed within main thread
+        #puts "(/main)"
+        
+      else
+        first_token.transit(first_transition) #first token will be executed within main thread
+      end
+    end
+    
+    def self.create_join_node_instance
+      JoinNode.new
+    end
+    
+    class JoinNode
+      def action(token, caller)
+        parent_token = token.parent
+        token.done
+        
+        if token.first_token
+          
+          #puts "(1st done)"
+          token.token_count.synchronize do
+            token.token_count_cond.wait_while { token.token_count[0] > 0 }
+          end
+          #puts "(/1st done)"
+          
+          [[:default, parent_token]]
+        else
+          
+          #puts "(1+ done)"
+          token.token_count.synchronize do
+            token.token_count[0] = token.token_count[0] - 1
+            token.token_count_cond.signal
+          end
+          #puts "(/1+ done)"
+          
+          nil 
+        end
+      end
+    end
+  end
+end
+
+
+#should rbpm support concurrent fine grained graph oriented programming like this?
+class ConcurrentFineGrainedDemoWorkflow < Rbpm::Concurrent::Workflow
+  start_node :start, 
+             :trans => :create_working_threads,
+             :on_enter => lambda { |token,caller| token[:sum] = 0 }
+  fork_node  :create_working_threads, 
+             :trans => :loop_start, 
+             :children_ctx => :thread_contexts,
+             :on_enter => lambda { |token,caller| token[:thread_contexts] = [{},{}] }
+  node       :loop_start,
+             :trans => :loop_end_decision,
+             :on_enter => lambda { |token,caller| token[:counter] = 0 }
+  node       :loop_end_decision,
+             :increment_trans => :loop_inc,
+             :increment_trans_cond => "token[:counter] < 10",
+             :done_trans => :loop_end,
+             :done_trans_cond => "token[:counter] >= 10"
+  node       :loop_inc,
+             :trans => :loop_end_decision,
+             :on_enter => lambda { |token,caller| token[:counter] = token[:counter] + 1 }
+  join_node  :loop_end,
+             :trans => :end
+  end_node   :end,
+             :on_enter => lambda { |token,caller| token[:result] << token[:sum] }
+  
+  leave(:loop_inc) do |token,caller|
+    token.parent.synchronize do #ensure parent.sum++ is an atomic operation
+      #puts "#{token.ref}=#{token[:counter]}"
+      token.parent[:sum] = token.parent[:sum] + token[:counter]
+    end
+  end
+end
+
+class ConcurrentFineGrainedDemoWorkflowTest < Test::Unit::TestCase
+
+  def test_fine_grained_concurrent_workflow
+    wf = ConcurrentFineGrainedDemoWorkflow.new
+    result = []
+    #puts "(start)"
+    wf.start :result => result
+    #puts "(/start)"
+    assert_equal ((1..10).inject(0) {|sum,n| sum + 2 * n}), result[0]
+  end
+end

data/test/rbpm_condition_tests.rb

@@ -1,9 +1,14 @@
 require 'test/unit'
 
 begin
-  require 'rbpm'
+  require 'rubygems'
+  require_gem 'rbpm'
 rescue LoadError
-  require '../lib/rbpm'
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
 end
 
 class DemoWorkflow5 < Rbpm::Workflow

data/test/rbpm_ctxvars_tests.rb

@@ -1,9 +1,14 @@
 require 'test/unit'
 
 begin
-  require 'rbpm'
+  require 'rubygems'
+  require_gem 'rbpm'
 rescue LoadError
-  require '../lib/rbpm'
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
 end
 
 class DemoWorkflow3 < Rbpm::Workflow

data/test/rbpm_exceptions_tests.rb

@@ -1,9 +1,14 @@
 require 'test/unit'
 
 begin
-  require 'rbpm'
+  require 'rubygems'
+  require_gem 'rbpm'
 rescue LoadError
-  require '../lib/rbpm'
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
 end
 
 class ExceptionWf1 < Rbpm::Workflow

data/test/rbpm_fork_join_tests.rb

@@ -1,9 +1,14 @@
 require 'test/unit'
 
 begin
-  require 'rbpm'
+  require 'rubygems'
+  require_gem 'rbpm'
 rescue LoadError
-  require '../lib/rbpm'
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
 end
 
 class DemoWorkflow4 < Rbpm::Workflow

data/test/rbpm_fs2_persistence_tests.rb

@@ -0,0 +1,144 @@
+require 'test/unit'
+
+begin
+  require 'rubygems'
+  require_gem 'rbpm'
+rescue LoadError
+  begin
+    require '../lib/rbpm'
+  rescue LoadError
+    require 'lib/rbpm'
+  end
+end
+
+class Inbox
+  class InboxMessage
+    attr_reader :token_ref, :body
+    
+    def initialize(token_ref, body)
+      @token_ref = token_ref
+      @body = body
+    end
+  end
+  
+  def initialize
+    @messages = []
+  end
+  
+  def post(token_ref, body)
+    @messages << InboxMessage.new(token_ref, body)
+  end  
+  
+  def shift
+    @messages.shift
+  end
+end
+
+$my_inbox = Inbox.new
+
+class PersTestParentWorkflow < Rbpm::Workflow
+  start_node :start, :trans => :call
+  call_node :call, 
+      :workflow => :PersTestWorkflow, 
+      :call_in => {:in => :in},  
+      :call_out => {}, 
+      :trans => :end
+  end_node :end
+  
+  enter(:end) do |token, caller|
+    $my_inbox.post token.ref, "parent end notification"
+  end
+end
+
+class PersTestWorkflow < Rbpm::Workflow
+  start_node :start, :trans => :state, :trans_action => lambda { |token,caller| token[:tmp] = token[:in] }
+  state_node :state, :trans => :end, :trans_action => lambda { |token,caller| token[:out] = token[:tmp] + token[:in] }
+  end_node :end
+  
+  enter(:state) do |token,caller|
+    $my_inbox.post token.ref, "i need you input"
+  end
+  
+  enter(:end) do |token, caller|
+    $my_inbox.post token.ref, token[:out]
+  end
+end
+
+class RbpmFs2PersistenceTests < Test::Unit::TestCase
+
+  def test_fs_flock_persistence
+    mgr = Rbpm::FlockFileSystem::WorkflowPersistenceManager.new "ptokens.ind"
+        
+    mgr.create_and_start "PersTestParentWorkflow", :in => "Hello "
+    
+    #days later...
+    
+    msg = $my_inbox.shift
+    
+    assert_not_nil msg
+    assert_equal "i need you input", msg.body
+    
+    mgr.signal msg.token_ref, :in => "World"
+    
+    #hours later...
+    
+    msg = $my_inbox.shift
+    
+    assert_not_nil msg
+    assert_equal "Hello World", msg.body
+    
+    msg = $my_inbox.shift
+    
+    assert_not_nil msg
+    assert_equal "parent end notification", msg.body
+  end
+
+  def test_workflow_token_index
+    wf_t_ind = Rbpm::FlockFileSystem::WorkflowTokenIndex.new('test.ind')
+    
+    `rm test.ind` if File.exists?('test.ind')
+    
+    assert_nil wf_t_ind.lookup_super_workflow(123)
+    assert_nil wf_t_ind.lookup_super_workflow(20)
+    
+    `echo "10\n100\n100\n10\n20\n200\n21\n200" > test.ind`
+    
+    assert_nil wf_t_ind.lookup_super_workflow(123)
+    assert_nil wf_t_ind.lookup_super_workflow(200)
+    assert_equal 200, wf_t_ind.lookup_super_workflow(20)
+    assert_equal 200, wf_t_ind.lookup_super_workflow(21)
+    assert_equal 100, wf_t_ind.lookup_super_workflow(10)
+    assert_equal 10, wf_t_ind.lookup_super_workflow(100)
+    
+    wf_t_ind.update_workflow_tokens 1000, [1,2,3]
+    wf_t_ind.update_workflow_tokens 200, [20,22,23]
+    wf_t_ind.update_workflow_tokens 100, []
+    
+    assert_equal 14, `grep -c . test.ind`.to_i
+    
+    assert_equal 1000, wf_t_ind.lookup_super_workflow(1)
+    assert_equal 1000, wf_t_ind.lookup_super_workflow(2)
+    assert_equal 1000, wf_t_ind.lookup_super_workflow(3)
+    
+    assert_equal 200, wf_t_ind.lookup_super_workflow(20)
+    assert_nil wf_t_ind.lookup_super_workflow(21)
+    assert_equal 200, wf_t_ind.lookup_super_workflow(22)
+    assert_equal 200, wf_t_ind.lookup_super_workflow(23)
+    
+    assert_equal 101, wf_t_ind.generate_token_id(1000)
+    assert_equal 102, wf_t_ind.generate_token_id(10)
+    
+    assert_equal 1001, wf_t_ind.create_new_super_workflow_id
+        
+    wf_t_ind.update_workflow_tokens 1000, []
+    wf_t_ind.update_workflow_tokens 200, []
+    wf_t_ind.update_workflow_tokens 100, []
+    
+    assert_equal 6, `grep -c . test.ind`.to_i
+    
+    wf_t_ind.update_workflow_tokens 10, []
+    wf_t_ind.update_workflow_tokens 1001, []
+    
+    assert_equal false, File.exists?('test.ind')
+  end
+end