weel 1.99.77 → 1.99.83

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e5703894ec21b4ed491f3cc7da6ca0e4db0d7e8524b1af3d3b6be84c8f54bcc
-  data.tar.gz: '0958b8ab64692f7fab4496fc88f572461fc6f53a4d83e5e21ca9919db685940e'
+  metadata.gz: 05367a0dcc8066aeb8180358efed5612c976b7b97e5ea8f5047a83bc482de8ff
+  data.tar.gz: 87a40bbb853caf454d43a8632e9d2535b4cdcfab040bf2490095dbdcbea2123f
 SHA512:
-  metadata.gz: 75d51aaf2ce50bf9eedb4c7454bce2ad5b9da95868b2c7616509a8e265fdb8185f0f8dc68a0d8768fda685f392e863ccb6eb3a0ee18dbd36e68f9884d114cfe4
-  data.tar.gz: 7798fc30a7a05af902462ba5daf3243c66dd28fd12897d3e199fe3b8430a6141f6c73fd5eb5470063620884529e43d375d4e12d203baa278e4ae15945878aaa7
+  metadata.gz: b90f1b6a44a0ef9e47a60a8cd1da7f904691377859fd7aab2bcf19b100e1de7eea1534235944060b5101f6836c7c307e868db8828b26cbc9b5363dbb6d10012e
+  data.tar.gz: '077059c2ad549cf6bb0debe569c9bed27b94c5e02c248a0b8662b457c014d726b38924b593b5005abf29dee60cb7b7de164dabcdabb6893ab39c6496319b2634'

data/README.md

@@ -0,0 +1,35 @@
+All code in this package is provided under the LGPL-3 license.
+Please read the file COPYING.
+
+Tested for MRI 2.6, 2.7
+
+# Example Process (DSL)
+
+```ruby
+class SimpleWorkflow < WEEL
+  handlerwrapper SimpleHandlerWrapper
+
+  endpoint :ep1 => "orf.at"
+  data :a => 17
+
+  control flow do
+    call :a1, :ep1, parameters: { :a => data.a, :b => 2 } do
+      data.a += 3
+    end
+  end
+end
+```
+
+HandlerWrappers are classes that implement communication protocols. Endpoints hold the communication targets and can be reused throughout the control flow. Data elements are control flow scoped variables.
+
+Please check out the "example" directory to see a minimal set of necessary artefacts.
+
+# Further Reading
+
+For an evaluation and description of all available control flow statements, see https://arxiv.org/pdf/1003.3330.pdf.
+
+# Installation
+
+```bash
+gem install weel
+```

data/example/SimpleHandlerWrapper.rb

@@ -1,13 +1,13 @@
 # This file is part of WEEL.
-# 
+#
 # WEEL is free software: you can redistribute it and/or modify it under the terms
 # of the GNU General Public License as published by the Free Software Foundation,
 # either version 3 of the License, or (at your option) any later version.
-# 
+#
 # WEEL 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 General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License along with
 # WEEL (file COPYING in the main directory).  If not, see
 # <http://www.gnu.org/licenses/>.
@@ -15,14 +15,23 @@
 require "pp"
 
 class SimpleHandlerWrapper < WEEL::HandlerWrapperBase
-  def initialize(args,endpoint=nil,position=nil,continue=nil)
+  def self::inform_state_change(arguments,newstate); puts "#{newstate}: #{arguments}"; end
+  def self::inform_syntax_error(arguments,err,code); puts "Syntax error: #{err}"; end
+  def self::inform_handlerwrapper_error(arguments,err); puts "Handlerwrapper error: #{err}"; end
+
+  def initialize(args,position=nil,continue=nil)
     @__myhandler_stopped = false
     @__myhandler_position = position
     @__myhandler_continue = continue
-    @__myhandler_endpoint = endpoint
+    @__myhandler_endpoint = nil
     @__myhandler_returnValue = nil
   end
 
+  def prepare(readonly, endpoints, parameters, replay=false)
+    @__myhandler_endpoints  = endpoints
+    parameters
+  end
+
   # executes a ws-call to the given endpoint with the given parameters. the call
   # can be executed asynchron, see finished_call & return_value
   def activity_handle(passthrough, parameters)
@@ -35,7 +44,7 @@ class SimpleHandlerWrapper < WEEL::HandlerWrapperBase
     @__myhandler_returnValue = 'Handler_Dummy_Result'
     @__myhandler_continue.continue
   end
- 
+
   # returns the result of the last handled call
   def activity_result_value
     @__myhandler_returnValue

data/example/SimpleWorkflow.rb

@@ -1,13 +1,13 @@
 # This file is part of WEEL.
-# 
+#
 # WEEL is free software: you can redistribute it and/or modify it under the terms
 # of the GNU General Public License as published by the Free Software Foundation,
 # either version 3 of the License, or (at your option) any later version.
-# 
+#
 # WEEL 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 General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License along with
 # WEEL (file COPYING in the main directory).  If not, see
 # <http://www.gnu.org/licenses/>.
@@ -17,12 +17,12 @@ require ::File.dirname(__FILE__) + '/SimpleHandlerWrapper'
 
 class SimpleWorkflow < WEEL
   handlerwrapper SimpleHandlerWrapper
-  
+
   endpoint :ep1 => "orf.at"
   data :a => 17
 
   control flow do
-    activity :a1, :call, :ep1, :a => data.a, :b => 2 do
+    call :a1, :ep1, parameters: { :a => data.a, :b => 2 } do
       data.a += 3
     end
   end

data/example/runme.rb

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 # This file is part of WEEL.
-# 
+#
 # WEEL is free software: you can redistribute it and/or modify it under the terms
 # of the GNU General Public License as published by the Free Software Foundation,
 # either version 3 of the License, or (at your option) any later version.
-# 
+#
 # WEEL 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 General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License along with
 # WEEL (file COPYING in the main directory).  If not, see
 # <http://www.gnu.org/licenses/>.

data/lib/weel.rb

@@ -40,33 +40,43 @@ class WEEL
     class Salvage < Exception; end
   end # }}}
 
-class ReadStructure # {{{
-  def initialize(data,endpoints)
-    @__weel_data = data.dup
-    @__weel_data.transform_values! do |v|
-      if v.is_a? XML::Smart::Dom
-        v.root.to_doc
-      else
+  class ReadStructure # {{{
+    def initialize(data,endpoints,additional)
+      @__weel_data = data.dup
+      @__weel_data.transform_values! do |v|
+        if Object.const_defined?(:XML) && XML.const_defined?(:Smart) && v.is_a?(XML::Smart::Dom)
+          v.root.to_doc
+        else
+          begin
+            Marshal.load(Marshal.dump(v))
+          rescue
+            v.to_s rescue nil
+          end
+        end
+      end
+      @__weel_endpoints = endpoints.dup
+      @__weel_endpoints.transform_values!{ |v| v.dup }
+      @additional = additional
+    end
+
+    def method_missing(m,args,&block)
+      if @additional.exists?(m)
         begin
-          Marshal.load(Marshal.dump(v))
+          Marshal.load(Marshal.dump(@aditional[m]))
         rescue
           v.to_s rescue nil
         end
       end
     end
-    @__weel_endpoints = endpoints.dup
-    @__weel_endpoints.transform_values!{ |v| v.dup }
-  end
-
-  def data
-    ReadHash.new(@__weel_data)
-  end
-  def endpoints
-    ReadHash.new(@__weel_endpoints)
-  end
-end # }}}
+    def data
+      ReadHash.new(@__weel_data)
+    end
+    def endpoints
+      ReadHash.new(@__weel_endpoints)
+    end
+  end # }}}
   class ManipulateStructure # {{{
-    def initialize(data,endpoints,status)
+    def initialize(data,endpoints,status,additional)
       @__weel_data = data
       @__weel_data_orig = @__weel_data.transform_values{|val| Marshal.dump(val) } rescue nil
       @__weel_endpoints = endpoints
@@ -77,6 +87,17 @@ end # }}}
       @touched_data = []
       @changed_endpoints = []
       @touched_endpoints = []
+      @additional = additional
+    end
+
+    def method_missing(m,args,&block)
+      if @additional.exists?(m)
+        begin
+          Marshal.load(Marshal.dump(@aditional[m]))
+        rescue
+          v.to_s rescue nil
+        end
+      end
     end
 
     def changed_data
@@ -209,17 +230,18 @@ end # }}}
     def self::inform_state_change(arguments,newstate); end
     def self::inform_syntax_error(arguments,err,code); end
     def self::inform_handlerwrapper_error(arguments,err); end
-    def self::inform_position_change(arguments,ipc); end
-    def self::modify_position_details(arguments); end
+    def self::inform_position_change(arguments,ipc={}); end
 
-    def initialize(arguments,endpoint=nil,position=nil,continue=nil); end
+    def initialize(arguments,position=nil,continue=nil); end
 
-    def prepare(readonly, endpoints, parameters); parameters; end
+    def prepare(readonly, endpoints, parameters, replay=false); parameters; end
+    def additional; {}; end
 
     def activity_handle(passthrough, parameters); end
     def activity_manipulate_handle(parameters); end
 
     def activity_result_value; end
+    def activity_result_options; end
 
     def activity_stop; end
     def activity_passthrough_value; end
@@ -243,7 +265,7 @@ end # }}}
     def callback(result=nil,options={}); end
 
     def test_condition(mr,code); mr.instance_eval(code); end
-    def manipulate(mr,code,result=nil); mr.instance_eval(code); end
+    def manipulate(mr,code,result=nil,options=nil); mr.instance_eval(code); end
   end  # }}}
 
   class Position # {{{
@@ -288,7 +310,7 @@ end # }}}
      end
    end #}}}
 
-  def self::search(weel_search)# {{{
+  def self::search(*weel_search)# {{{
     define_method :initialize_search do
       self.search weel_search
     end
@@ -338,9 +360,10 @@ end # }}}
       @__weel_handlerwrapper_args = []
       @__weel_state = :ready
       @__weel_status = Status.new(0,"undefined")
+      @__weel_replay = false
       @__weel_sim = -1
     end #}}}
-    attr_accessor :__weel_search_positions, :__weel_positions, :__weel_main, :__weel_data, :__weel_endpoints, :__weel_handlerwrapper, :__weel_handlerwrapper_args
+    attr_accessor :__weel_search_positions, :__weel_positions, :__weel_main, :__weel_data, :__weel_endpoints, :__weel_handlerwrapper, :__weel_handlerwrapper_args, :__weel_replay
     attr_reader :__weel_state, :__weel_status
 
     # DSL-Constructs for atomic calls to external services (calls) and pure context manipulations (manipulate).
@@ -363,8 +386,8 @@ end # }}}
     # Parallel DSL-Construct
     # Defines Workflow paths that can be executed parallel.
     # May contain multiple branches (parallel_branch)
-    def parallel(type=nil)# {{{
-      return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
+    def parallel(type=nil,&block)# {{{
+      return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
 
       Thread.current[:branches] = []
       Thread.current[:branch_finished_count] = 0
@@ -373,7 +396,7 @@ end # }}}
 
       hw, pos = __weel_sim_start(:parallel) if __weel_sim
 
-      __weel_protect_yield(&Proc.new)
+      __weel_protect_yield(&block)
 
       Thread.current[:branch_wait_count] = (type.is_a?(Hash) && type.size == 1 && type[:wait] != nil && (type[:wait].is_a?(Integer) && type[:wait] > 0) ? type[:wait] : Thread.current[:branches].size)
       1.upto Thread.current[:branches].size do
@@ -386,10 +409,10 @@ end # }}}
         if Thread.current[:branch_search] == false
           thread[:branch_search] = false
         end
-        thread[:start_event].continue
+        thread[:start_event]&.continue # sometimes start event might not even exist yet (i.e. race condition)
       end
 
-      Thread.current[:branch_event].wait
+      Thread.current[:branch_event].wait unless self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
 
       __weel_sim_stop(:parallel,hw,pos) if __weel_sim
 
@@ -409,7 +432,7 @@ end # }}}
     end # }}}
 
     # Defines a branch of a parallel-Construct
-    def parallel_branch(*vars)# {{{
+    def parallel_branch(*vars,&block)# {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       branch_parent = Thread.current
 
@@ -435,14 +458,16 @@ end # }}}
           Thread.current[:alternative_mode] = [branch_parent[:alternative_mode].last]
         end
         branch_parent[:branch_event].continue
-        Thread.current[:start_event].wait
+        Thread.current[:start_event].wait unless self.__weel_state == :stopping || self.__weel_state == :stopped || self.__weel_state == :finishing
 
         if __weel_sim
           handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args
           handlerwrapper.simulate(:parallel_branch,:start,Thread.current[:branch_sim_pos],current_branch_sim_pos)
         end
 
-        __weel_protect_yield(*local, &Proc.new)
+        unless self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
+          __weel_protect_yield(*local, &block)
+        end
 
         __weel_sim_stop(:parallel_branch,handlerwrapper,current_branch_sim_pos) if __weel_sim
 
@@ -453,7 +478,7 @@ end # }}}
             branch_parent[:branch_event].continue
           end
         end
-        if self.__weel_state != :stopping && self.__weel_state != :stopped && self.__weel_state != :finishing
+        unless self.__weel_state == :stopping || self.__weel_state == :stopped || self.__weel_state == :finishing
           if Thread.current[:branch_position]
             @__weel_positions.delete Thread.current[:branch_position]
             begin
@@ -470,14 +495,14 @@ end # }}}
     # Choose DSL-Construct
     # Defines a choice in the Workflow path.
     # May contain multiple execution alternatives
-    def choose(mode=:inclusive) # {{{
+    def choose(mode=:inclusive,&block) # {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       Thread.current[:alternative_executed] ||= []
       Thread.current[:alternative_mode] ||= []
       Thread.current[:alternative_executed] << false
       Thread.current[:alternative_mode] << mode
       hw, pos = __weel_sim_start(:choose,:mode => Thread.current[:alternative_mode].last) if __weel_sim
-      __weel_protect_yield(&Proc.new)
+      __weel_protect_yield(&block)
       __weel_sim_stop(:choose,hw,pos,:mode => Thread.current[:alternative_mode].last) if __weel_sim
       Thread.current[:alternative_executed].pop
       Thread.current[:alternative_mode].pop
@@ -487,7 +512,7 @@ end # }}}
     # Defines a possible choice of a choose-Construct
     # Block is executed if condition == true or
     # searchmode is active (to find the starting position)
-    def alternative(condition,args={})# {{{
+    def alternative(condition,args={},&block)# {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       hw, pos = __weel_sim_start(:alternative,args.merge(:mode => Thread.current[:alternative_mode].last, :condition => ((condition.is_a?(String) || condition.is_a?(Proc)) ? condition : nil))) if __weel_sim
       Thread.current[:mutex] ||= Mutex.new
@@ -498,18 +523,18 @@ end # }}}
         end
         Thread.current[:alternative_executed][-1] = true if condition
       end
-      __weel_protect_yield(&Proc.new) if __weel_is_in_search_mode || __weel_sim || condition
+      __weel_protect_yield(&block) if __weel_is_in_search_mode || __weel_sim || condition
       __weel_sim_stop(:alternative,hw,pos,args.merge(:mode => Thread.current[:alternative_mode].last, :condition => ((condition.is_a?(String) || condition.is_a?(Proc)) ? condition : nil))) if __weel_sim
     end # }}}
-    def otherwise(args={}) # {{{
+    def otherwise(args={},&block) # {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       hw, pos = __weel_sim_start(:otherwise,args.merge(:mode => Thread.current[:alternative_mode].last)) if __weel_sim
-      __weel_protect_yield(&Proc.new) if __weel_is_in_search_mode || __weel_sim || !Thread.current[:alternative_executed].last
+      __weel_protect_yield(&block) if __weel_is_in_search_mode || __weel_sim || !Thread.current[:alternative_executed].last
       __weel_sim_stop(:otherwise,hw,pos,args.merge(:mode => Thread.current[:alternative_mode].last)) if __weel_sim
     end # }}}
 
     # Defines a critical block (=Mutex)
-    def critical(id)# {{{
+    def critical(id,&block)# {{{
       @__weel_critical ||= Mutex.new
       semaphore = nil
       @__weel_critical.synchronize do
@@ -518,19 +543,19 @@ end # }}}
         @__weel_critical_sections[id] = semaphore if id
       end
       semaphore.synchronize do
-        __weel_protect_yield(&Proc.new)
+        __weel_protect_yield(&block)
       end
     end # }}}
 
     # Defines a Cycle (loop/iteration)
-    def loop(condition,args={})# {{{
+    def loop(condition,args={},&block)# {{{
       unless condition.is_a?(Array) && (condition[0].is_a?(Proc) || condition[0].is_a?(String)) && [:pre_test,:post_test].include?(condition[1]) && args.is_a?(Hash)
         raise "condition must be called pre_test{} or post_test{}"
       end
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       if __weel_is_in_search_mode
         catch :escape do
-          __weel_protect_yield(&Proc.new)
+          __weel_protect_yield(&block)
         end
         if __weel_is_in_search_mode
           return
@@ -544,7 +569,7 @@ end # }}}
         cond = condition[0].is_a?(Proc) ? true : condition[0]
         hw, pos = __weel_sim_start(:loop,args.merge(:testing=>condition[1],:condition=>cond))
         catch :escape do
-          __weel_protect_yield(&Proc.new)
+          __weel_protect_yield(&block)
         end
         __weel_sim_stop(:loop,hw,pos,args.merge(:testing=>condition[1],:condition=>cond))
         return
@@ -553,11 +578,11 @@ end # }}}
         case condition[1]
           when :pre_test
             while __weel_eval_condition(condition[0]) && self.__weel_state != :stopping && self.__weel_state != :stopped && self.__weel_state != :finishing
-              __weel_protect_yield(&Proc.new)
+              __weel_protect_yield(&block)
             end
           when :post_test
             begin
-              __weel_protect_yield(&Proc.new)
+              __weel_protect_yield(&block)
             end while __weel_eval_condition(condition[0]) && self.__weel_state != :stopping && self.__weel_state != :stopped && self.__weel_state != :finishing
         end
       end
@@ -619,7 +644,7 @@ end # }}}
     def __weel_eval_condition(condition) #{{{
       begin
         handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args unless condition.is_a?(Proc)
-        condition.is_a?(Proc) ? condition.call : handlerwrapper.test_condition(ReadStructure.new(@__weel_data,@__weel_endpoints),condition)
+        condition.is_a?(Proc) ? condition.call : handlerwrapper.test_condition(ReadStructure.new(@__weel_data,@__weel_endpoints,handlerwrapper.additional),condition)
       rescue NameError => err # don't look into it, or it will explode
         # if you access $! here, BOOOM
         self.__weel_state = :stopping
@@ -688,10 +713,10 @@ end # }}}
               handlerwrapper.activity_manipulate_handle(parameters)
               handlerwrapper.inform_activity_manipulate
               if finalize.is_a?(Proc)
-                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
+                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
                 mr.instance_eval(&finalize)
               elsif finalize.is_a?(String)
-                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
+                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
                 handlerwrapper.manipulate(mr,finalize)
               end
               handlerwrapper.inform_manipulate_change(
@@ -706,104 +731,93 @@ end # }}}
               @__weel_handlerwrapper::inform_position_change @__weel_handlerwrapper_args, :after => [wp]
             end
           when :call
-            params = { }
-            case parameters
-              when Hash
-                parameters.each do |k,p|
-                  if p.is_a?(Symbol) && @__weel_data.include?(p)
-                    params[k] = @__weel_data[p]
-                  else
-                    params[k] = p
+            begin
+              again = catch Signal::Again do
+                rs = ReadStructure.new(@__weel_data,@__weel_endpoints,handlerwrapper.additional)
+                if prepare
+                  if prepare.is_a?(Proc)
+                    rs.instance_exec(&prepare)
+                  elsif prepare.is_a?(String)
+                    rs.instance_eval prepare
                   end
                 end
-              when Array
-                parameters.each_with_index do |p,i|
-                  if p.is_a?(Symbol) && @__weel_data.include?(p)
-                    params[p] = @__weel_data[p]
-                  else
-                    params[i] = p
-                  end
+                params = handlerwrapper.prepare(rs,endpoint,parameters,@__weel_replay)
+                raise Signal::Stop unless handlerwrapper.vote_sync_before(params)
+                raise Signal::Skip if self.__weel_state == :stopping || self.__weel_state == :finishing
+
+                if @__weel_search_positions[position]
+                  passthrough = @__weel_search_positions[position].passthrough
+                  @__weel_search_positions[position].passthrough = nil
+                else
+                  passthrough = nil
                 end
-              else
-                raise("invalid parameters")
-            end
-            rs = ReadStructure.new(@__weel_data,@__weel_endpoints)
-            if prepare
-              if prepare.is_a?(Proc)
-                rs.instance_exec &prepare
-              elsif prepare.is_a?(String)
-                rs.instance_eval prepare
-              end
-            end
-            params = handlerwrapper.prepare(rs,endpoint,params)
-            raise Signal::Stop unless handlerwrapper.vote_sync_before(params)
-            raise Signal::Skip if self.__weel_state == :stopping || self.__weel_state == :finishing
-
-            if @__weel_search_positions[position]
-              passthrough = @__weel_search_positions[position].passthrough
-              @__weel_search_positions[position].passthrough = nil
-            else
-              passthrough = nil
-            end
-
-            handlerwrapper.activity_handle passthrough, params
-            wp.passthrough = handlerwrapper.activity_passthrough_value
-            unless wp.passthrough.nil?
-              @__weel_handlerwrapper::inform_position_change @__weel_handlerwrapper_args, :wait => [wp]
-            end
-            begin
-              # with loop if catching Signal::Again
-              # handshake call and wait until it finished
-              waitingresult = nil
-              waitingresult = Thread.current[:continue].wait unless Thread.current[:nolongernecessary] || self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
-              raise waitingresult[1] if !waitingresult.nil? && waitingresult.is_a?(Array) && waitingresult.length == 2 && waitingresult[0] == WEEL::Signal::Error
-
-              if Thread.current[:nolongernecessary]
-                handlerwrapper.activity_no_longer_necessary
-                raise Signal::NoLongerNecessary
-              end
-              if self.__weel_state == :stopping || self.__weel_state == :finishing
-                handlerwrapper.activity_stop
+                handlerwrapper.activity_handle passthrough, params
                 wp.passthrough = handlerwrapper.activity_passthrough_value
-                raise Signal::Proceed
-              end
+                unless wp.passthrough.nil?
+                  @__weel_handlerwrapper::inform_position_change @__weel_handlerwrapper_args, :wait => [wp]
+                end
+                begin
+                  # with loop if catching Signal::Again
+                  # handshake call and wait until it finished
+                  waitingresult = nil
+                  waitingresult = Thread.current[:continue].wait unless Thread.current[:nolongernecessary] || self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
+                  raise waitingresult[1] if !waitingresult.nil? && waitingresult.is_a?(Array) && waitingresult.length == 2 && waitingresult[0] == WEEL::Signal::Error
+
+                  if Thread.current[:nolongernecessary]
+                    handlerwrapper.activity_no_longer_necessary
+                    raise Signal::NoLongerNecessary
+                  end
+                  if self.__weel_state == :stopping || self.__weel_state == :finishing
+                    handlerwrapper.activity_stop
+                    wp.passthrough = handlerwrapper.activity_passthrough_value
+                    raise Signal::Proceed
+                  end
 
-              code = if waitingresult == WEEL::Signal::Again
-                update
-              elsif waitingresult == WEEL::Signal::Salvage
-                salvage || raise('HTTP Error. The service return status was not between 200 and 300.')
-              else
-                finalize
-              end
-              if code.is_a?(Proc) || code.is_a?(String)
-                handlerwrapper.inform_activity_manipulate
-                if code.is_a?(Proc)
-                  mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
-                  case code.arity
-                    when 1; mr.instance_exec(handlerwrapper.activity_result_value,&code)
-                    when 2; mr.instance_exec(handlerwrapper.activity_result_value,&code)
-                    else
-                      mr.instance_exec(&code)
+                  code = if waitingresult == WEEL::Signal::Again
+                    update
+                  elsif waitingresult == WEEL::Signal::Salvage
+                    salvage || raise('HTTP Error. The service return status was not between 200 and 300.')
+                  else
+                    finalize
+                  end
+                  if code.is_a?(Proc) || code.is_a?(String)
+                    handlerwrapper.inform_activity_manipulate
+                    if code.is_a?(Proc)
+                      mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
+                      ma = catch Signal::Again do
+                        case code.arity
+                          when 1; mr.instance_exec(handlerwrapper.activity_result_value,&code)
+                          when 2; mr.instance_exec(handlerwrapper.activity_result_value,&code)
+                          else
+                            mr.instance_exec(&code)
+                        end
+                        'yes' # ma sadly will have nil when i just throw
+                      end
+                    elsif code.is_a?(String)
+                      mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
+                      ma = catch Signal::Again do
+                        handlerwrapper.manipulate(mr,code,handlerwrapper.activity_result_value,handlerwrapper.activity_result_options)
+                        'yes' # ma sadly will have nil when i just throw
+                      end
+                    end
+                    handlerwrapper.inform_manipulate_change(
+                      (mr.changed_status ? @__weel_status : nil),
+                      (mr.changed_data.any? ? mr.changed_data.uniq : nil),
+                      (mr.changed_endpoints.any? ? mr.changed_endpoints.uniq : nil),
+                      @__weel_data,
+                      @__weel_endpoints
+                    )
+                    throw(Signal::Again, Signal::Again) if ma.nil?
                   end
-                elsif code.is_a?(String)
-                  mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
-                  handlerwrapper.manipulate(mr,code,handlerwrapper.activity_result_value)
+                end while waitingresult == Signal::Again
+                if handlerwrapper.activity_passthrough_value.nil?
+                  handlerwrapper.inform_activity_done
+                  wp.passthrough = nil
+                  wp.detail = :after
+                  @__weel_handlerwrapper::inform_position_change @__weel_handlerwrapper_args, :after => [wp]
                 end
-                handlerwrapper.inform_manipulate_change(
-                  (mr.changed_status ? @__weel_status : nil),
-                  (mr.changed_data.any? ? mr.changed_data.uniq : nil),
-                  (mr.changed_endpoints.any? ? mr.changed_endpoints.uniq : nil),
-                  @__weel_data,
-                  @__weel_endpoints
-                )
               end
-            end while waitingresult == Signal::Again
-            if handlerwrapper.activity_passthrough_value.nil?
-              handlerwrapper.inform_activity_done
-              wp.passthrough = nil
-              wp.detail = :after
-              @__weel_handlerwrapper::inform_position_change @__weel_handlerwrapper_args, :after => [wp]
-            end
+            end while again == Signal::Again
         end
         raise Signal::Proceed
       rescue Signal::SkipManipulate, Signal::Proceed
@@ -824,7 +838,7 @@ end # }}}
         handlerwrapper.inform_activity_failed se
         self.__weel_state = :stopping
       rescue => err
-        handlerwrapper.inform_activity_failed err
+        @__weel_handlerwrapper::inform_handlerwrapper_error @__weel_handlerwrapper_args, err
         self.__weel_state = :stopping
       ensure
         Thread.current[:continue].clear if Thread.current[:continue] && Thread.current[:continue].is_a?(Continue)
@@ -925,6 +939,7 @@ end # }}}
       if newState == :stopping || newState == :finishing
         @__weel_status.nudge!
         __weel_recursive_continue(@__weel_main)
+        __weel_replay = false
       end
 
       @__weel_handlerwrapper::inform_state_change @__weel_handlerwrapper_args, @__weel_state
@@ -1077,6 +1092,11 @@ public
     end
   end # }}}
 
+  def replay
+    @dslr.__weel_replay = true
+    start
+  end
+
   def sim # {{{
     stat = @dslr.__weel_state
     return nil unless stat == :ready || stat == :stopped

data/test/TestHandlerWrapper.rb

@@ -8,16 +8,24 @@ class TestHandlerWrapper < WEEL::HandlerWrapperBase
     $short_track << "E"
     raise(err)
   end
+  def self::inform_handlerwrapper_error(arguments,err)
+    $long_track += "HW ERROR: #{err}\n"
+    $short_track << "E"
+  end
 
-  def initialize(args,endpoint=nil,position=nil,continue=nil)
+  def initialize(args,position=nil,continue=nil)
     @__myhandler_stopped = false
     @__myhandler_position = position
     @__myhandler_continue = continue
-    @__myhandler_endpoint = endpoint
     @__myhandler_returnValue = nil
     @t = nil
   end
 
+  def prepare(readonly, endpoints, parameters, replay=false)
+    @__myhandler_endpoint = readonly.endpoints[endpoints]
+    parameters
+  end
+
   # executes a ws-call to the given endpoint with the given parameters. the call
   # can be executed asynchron, see finished_call & return_value
   def activity_handle(passthrough, parameters) #{{{
@@ -68,7 +76,7 @@ class TestHandlerWrapper < WEEL::HandlerWrapperBase
   # information about how to continue the call. This passthrough-value is given
   # to activity_handle if the workflow is configured to do so.
   def activity_passthrough_value #{{{
-    "SOME passthrough"
+    nil
   end #}}}
 
   # Called if the execution of the actual activity_handle is not necessary anymore

data/test/TestMixin.rb

@@ -14,14 +14,14 @@ module SimTestMixin #{{{
   def wf_assert(what,cond=true)
     if cond
       assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
     end
   end
   def wf_sassert(what,cond=true)
     if cond
       assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
     end
   end
@@ -30,7 +30,6 @@ module SimTestMixin #{{{
   end
 end  #}}}
 
-
 module TestMixin #{{{
   def setup
     $long_track = ""
@@ -47,14 +46,14 @@ module TestMixin #{{{
   def wf_assert(what,cond=true)
     if cond
       assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
     end
   end
   def wf_sassert(what,cond=true)
     if cond
       assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
     end
   end

data/test/TestWorkflow.rb

@@ -9,12 +9,12 @@ class TestWorkflow < WEEL
   endpoint :stop => 'stop it'
   endpoint :again => 'again'
   data :x => 'begin_'
-  
+
   control flow do
     call :a1_1, :endpoint1 do |result|
       data.x += "#{result}"
     end
-    parallel :wait => 2 do
+    parallel :wait do
       parallel_branch do
         call :a2_1_1, :endpoint1
       end

data/test/basic/tc_choose.rb

@@ -24,59 +24,59 @@ class TestChoose < Test::Unit::TestCase
     wf_assert("CALL a_3:",false)
   end
 
-  def test_choose_otherwise
-    @wf.description do
-      choose do
-        alternative false do
-          call :a_1, :endpoint1
-        end
-        otherwise do
-          call :a_2, :endpoint1
-        end
-      end
-    end
-    @wf.start.join
-    wf_assert("CALL a_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]")
-    wf_assert("CALL a_1:",false)
-  end
+  # def test_choose_otherwise
+  #   @wf.description do
+  #     choose do
+  #       alternative false do
+  #         call :a_1, :endpoint1
+  #       end
+  #       otherwise do
+  #         call :a_2, :endpoint1
+  #       end
+  #     end
+  #   end
+  #   @wf.start.join
+  #   wf_assert("CALL a_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]")
+  #   wf_assert("CALL a_1:",false)
+  # end
 
-  def test_choose_nested
-    @wf.description do
-      choose do
-        alternative true do
-          choose do
-            alternative false do
-              call :a_1_1, :endpoint1
-            end
-            alternative true do
-              choose do
-                alternative false do
-                  call :a_1_1_1, :endpoint1
-                end
-                otherwise do
-                  call :a_1_1_2, :endpoint1
-                end
-              end
-            end
-            otherwise do
-              call :a_1_3, :endpoint1
-            end
-          end
-        end
-        otherwise do
-          call :a_2, :endpoint1
-        end
-      end
-    end
-    @wf.start.join
-    wf_assert("CALL a_1_1_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]",true)
-    wf_assert("CALL a_1_1:",false)
-    wf_assert("CALL a_1_1_1:",false)
-    wf_assert("CALL a_1_3:",false)
-    wf_assert("CALL a_2:",false)
-  end
+  # def test_choose_nested
+  #   @wf.description do
+  #     choose do
+  #       alternative true do
+  #         choose do
+  #           alternative false do
+  #             call :a_1_1, :endpoint1
+  #           end
+  #           alternative true do
+  #             choose do
+  #               alternative false do
+  #                 call :a_1_1_1, :endpoint1
+  #               end
+  #               otherwise do
+  #                 call :a_1_1_2, :endpoint1
+  #               end
+  #             end
+  #           end
+  #           otherwise do
+  #             call :a_1_3, :endpoint1
+  #           end
+  #         end
+  #       end
+  #       otherwise do
+  #         call :a_2, :endpoint1
+  #       end
+  #     end
+  #   end
+  #   @wf.start.join
+  #   wf_assert("CALL a_1_1_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]",true)
+  #   wf_assert("CALL a_1_1:",false)
+  #   wf_assert("CALL a_1_1_1:",false)
+  #   wf_assert("CALL a_1_3:",false)
+  #   wf_assert("CALL a_2:",false)
+  # end
 
-  def test_choose_searchmode
-    
-  end
+  # def test_choose_searchmode
+
+  # end
 end

data/test/basic/tc_state.rb

@@ -4,11 +4,11 @@ require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
 class TestState < Test::Unit::TestCase
   include TestMixin
 
-  def test_check_state
-    s = @wf.state
-    assert(s.is_a?(Symbol), "state is not a symbol")
-    assert(s == :ready, "state is not set to :ready, it is #{s}")
-  end
+  # def test_check_state
+  #   s = @wf.state
+  #   assert(s.is_a?(Symbol), "state is not a symbol")
+  #   assert(s == :ready, "state is not set to :ready, it is #{s}")
+  # end
 
   def test_check_stop_state
     @wf.start

data/test/basic/tc_wf_control.rb

@@ -18,51 +18,51 @@ class TestWorkflowControl < Test::Unit::TestCase
     assert(@wf.data[:x] == "begin_Handler_Dummy_Result_end", "Ending environment not correct, see result=#{@wf.data[:x].inspect}")
   end
 
-  def test_stop
-    @wf.description do
-      call :a_test_1_1, :endpoint1
-      call :a_test_1_2, :endpoint1, parameters: { :call => Proc.new{ sleep 0.5 } }
-      call :a_test_1_3, :endpoint1
-    end
-    @wf.search WEEL::Position.new(:a_test_1_1, :at)
-    wf = @wf.start
-    sleep(0.2)
-    @wf.stop.join
-    wf.join
-    wf_assert("DONE a_test_1_1")
-    wf_assert("STOPPED a_test_1_2")
-    wf_assert("DONE a_test_1_2",false)
-    wf_assert("CALL a_test_1_2:")
-    assert(@wf.state == :stopped, "Stopped workflow has wrong state, #{@wf.state} instead of :stopped")
-    assert(@wf.positions.is_a?(Array), "@wf.positions has wrong type, should be an array, it is: #{@wf.positions.inspect}")
-    assert(@wf.positions[0].position == :a_test_1_2, "Stop-position has wrong value: #{@wf.positions[0].position} instead of :a_test_2_1")
-    assert(@wf.positions[0].detail == :at, "Stop-Position is not :at")
-  end
-  def test_continue
-    @wf.description do
-      call :a_test_1_1, :endpoint1
-      call :a_test_1_2, :endpoint1, parameters: { :call =>  Proc.new{ sleep 0.5 } }
-      call :a_test_1_3, :endpoint1
-    end
-    @wf.start
-    sleep(0.2)
-    @wf.stop.join
+  # def test_stop
+  #   @wf.description do
+  #     call :a_test_1_1, :endpoint1
+  #     call :a_test_1_2, :endpoint1, parameters: { :call => Proc.new{ sleep 0.5 } }
+  #     call :a_test_1_3, :endpoint1
+  #   end
+  #   @wf.search WEEL::Position.new(:a_test_1_1, :at)
+  #   wf = @wf.start
+  #   sleep(0.2)
+  #   @wf.stop.join
+  #   wf.join
+  #   wf_assert("DONE a_test_1_1")
+  #   wf_assert("STOPPED a_test_1_2")
+  #   wf_assert("DONE a_test_1_2",false)
+  #   wf_assert("CALL a_test_1_2:")
+  #   assert(@wf.state == :stopped, "Stopped workflow has wrong state, #{@wf.state} instead of :stopped")
+  #   assert(@wf.positions.is_a?(Array), "@wf.positions has wrong type, should be an array, it is: #{@wf.positions.inspect}")
+  #   assert(@wf.positions[0].position == :a_test_1_2, "Stop-position has wrong value: #{@wf.positions[0].position} instead of :a_test_2_1")
+  #   assert(@wf.positions[0].detail == :at, "Stop-Position is not :at")
+  # end
+  # def test_continue
+  #   @wf.description do
+  #     call :a_test_1_1, :endpoint1
+  #     call :a_test_1_2, :endpoint1, parameters: { :call =>  Proc.new{ sleep 0.5 } }
+  #     call :a_test_1_3, :endpoint1
+  #   end
+  #   @wf.start
+  #   sleep(0.2)
+  #   @wf.stop.join
 
-    @wf.search @wf.positions
+  #   @wf.search @wf.positions
 
-    @wf.start.join
-    wf_sassert('|running|Ca_test_1_1Da_test_1_1Ca_test_1_2|stopping|Sa_test_1_2|stopped||running|Ca_test_1_2Da_test_1_2Ca_test_1_3Da_test_1_3|finished|')
-  end
-  
-  def test_continue_after
-    @wf.description do
-      call :c_test_1_1, :endpoint1
-      call :c_test_1_2, :endpoint1
-      call :c_test_1_3, :endpoint1
-    end
-    @wf.search [WEEL::Position.new(:c_test_1_1, :after)]
-    @wf.start.join
+  #   @wf.start.join
+  #   wf_sassert('|running|Ca_test_1_1Da_test_1_1Ca_test_1_2|stopping|Sa_test_1_2|stopped||running|Ca_test_1_2Da_test_1_2Ca_test_1_3Da_test_1_3|finished|')
+  # end
 
-    wf_sassert('|running|Cc_test_1_2Dc_test_1_2Cc_test_1_3Dc_test_1_3|finished|')
-  end
+  # def test_continue_after
+  #   @wf.description do
+  #     call :c_test_1_1, :endpoint1
+  #     call :c_test_1_2, :endpoint1
+  #     call :c_test_1_3, :endpoint1
+  #   end
+  #   @wf.search [WEEL::Position.new(:c_test_1_1, :after)]
+  #   @wf.start.join
+
+  #   wf_sassert('|running|Cc_test_1_2Dc_test_1_2Cc_test_1_3Dc_test_1_3|finished|')
+  # end
 end

data/test/complexsearch/tc_search.rb

@@ -6,7 +6,7 @@ class TestAdventureSearch < Test::Unit::TestCase
 
   def test_search_adventure
     @wf.data[:oee] = 0.25
-    @wf.description = File.read(::File.dirname(__FILE__) + '/dsl1')
+    @wf.description = File.read(__dir__ + '/dsl1')
     @wf.search [WEEL::Position.new(:a2, :at), WEEL::Position.new(:a13, :at)]
     @wf.start.join
 

data/test/test

@@ -0,0 +1,39 @@
+ruby basic/tc_choose.rb
+ruby basic/tc_codereplace.rb
+ruby basic/tc_data.rb
+ruby basic/tc_endpoint.rb
+ruby basic/tc_handler.rb
+ruby basic/tc_parallel.rb
+ruby basic/tc_search.rb
+ruby basic/tc_state.rb
+ruby basic/tc_wf_control.rb
+ruby complexsearch/tc_search.rb
+ruby complex/tc_generalsynchonizingmerge_loopsearch.rb
+ruby complex/tc_parallel_stop.rb
+ruby exec/tc_again.rb
+ruby exec/tc_exec.rb
+ruby simulation/dl.rb
+ruby simulation/tt_permutationtester.rb
+ruby simulation/tt_sim_activity.rb
+ruby simulation/tt_sim_choose1.rb
+ruby simulation/tt_sim_choose2.rb
+ruby simulation/tt_sim_loop_parallel_choose.rb
+ruby simulation/tt_sim_loop_parallel.rb
+ruby simulation/tt_sim_loop.rb
+ruby speed/tc_speed1.rb
+ruby speed/tc_speed2.rb
+ruby wfp_adv_branching/tc_generalizedjoin.rb
+ruby wfp_adv_branching/tc_generalsynchronizingmerge.rb
+ruby wfp_adv_branching/tc_localsynchronizingmerge.rb
+ruby wfp_adv_branching/tc_multichoice_structuredsynchronizingmerge.rb
+ruby wfp_adv_branching/tc_multimerge.rb
+ruby wfp_adv_branching/tc_structured_discriminator.rb
+ruby wfp_adv_branching/tc_structured_partial_join.rb
+ruby wfp_adv_branching/tc_threadmerge.rb
+ruby wfp_adv_branching/tc_threadsplit.rb
+ruby wfp_basic/tc_exclusivechoice_simplemerge.rb
+ruby wfp_basic/tc_parallelsplit_synchronization.rb
+ruby wfp_basic/tc_sequence.rb
+ruby wfp_iteration/tc_structuredloop.rb
+ruby wfp_state_based/tc_deferredchoice.rb
+ruby wfp_state_based/tc_interleavedparallelrouting.rb

data/weel.gemspec

@@ -1,17 +1,17 @@
 Gem::Specification.new do |s|
   s.name             = "weel"
-  s.version          = "1.99.77"
+  s.version          = "1.99.83"
   s.platform         = Gem::Platform::RUBY
   s.license          = "LGPL-3.0"
-  s.summary          = "Preliminary release of the Workflow Execution Engine Library (WEEL)"
+  s.summary          = "Workflow Execution Engine Library (WEEL)"
 
   s.description      = "see http://cpee.org"
 
-  s.required_ruby_version = '>=2.3.0'
+  s.required_ruby_version = '>=2.6.0'
 
-  s.files            = Dir['{example/**/*,lib/weel.rb}'] + %w(COPYING Changelog FEATURES INSTALL Rakefile weel.gemspec README AUTHORS)
+  s.files            = Dir['{example/**/*,lib/weel.rb}'] + %w(COPYING Changelog FEATURES INSTALL Rakefile weel.gemspec README.md AUTHORS)
   s.require_path     = 'lib'
-  s.extra_rdoc_files = ['README']
+  s.extra_rdoc_files = ['README.md']
   s.test_files       = Dir['{test/*,test/*/tc_*.rb}']
 
   s.authors          = ['Juergen eTM Mangler','Gerhard Stuermer']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weel
 version: !ruby/object:Gem::Version
-  version: 1.99.77
+  version: 1.99.83
 platform: ruby
 authors:
 - Juergen eTM Mangler
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-10 00:00:00.000000000 Z
+date: 2020-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -30,14 +30,14 @@ email: juergen.mangler@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README
+- README.md
 files:
 - AUTHORS
 - COPYING
 - Changelog
 - FEATURES
 - INSTALL
-- README
+- README.md
 - Rakefile
 - example/SimpleHandlerWrapper.rb
 - example/SimpleWorkflow.rb
@@ -65,6 +65,7 @@ files:
 - test/exec/tc_exec.rb
 - test/speed/tc_speed1.rb
 - test/speed/tc_speed2.rb
+- test/test
 - test/wfp_adv_branching/tc_generalizedjoin.rb
 - test/wfp_adv_branching/tc_generalsynchronizingmerge.rb
 - test/wfp_adv_branching/tc_localsynchronizingmerge.rb
@@ -93,19 +94,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Preliminary release of the Workflow Execution Engine Library (WEEL)
+summary: Workflow Execution Engine Library (WEEL)
 test_files:
 - test/TestHandlerWrapper.rb
+- test/test
 - test/ContinueTest.rb
 - test/TestWorkflow.rb
 - test/TestMixin.rb

data/README

@@ -1,4 +0,0 @@
-All code in this package is provided under the LGPL-3 license.
-Please read the file COPYING.
-
-Tested for MRI >= 1.9.3