ruote-maestrodev 2.2.1

data/lib/ruote/exp/fe_read.rb

@@ -0,0 +1,69 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # Reads the content of a local file or a file reachable over http and places
+  # the content in a [process] variable or a [workitem] field.
+  #
+  # Always attempts to parse the content as JSON. If the parsing fails, simply
+  # considers as plain text.
+  #
+  #   Ruote.process_definition do
+  #     read 'http://defs.example.org/filters/filter1.json', :to => 'x'
+  #     read 'http://defs.example.org/filters/filter1.json', :to => 'f:x'
+  #     read 'http://defs.example.org/filters/filter2.json', :to => 'v:y'
+  #     read 'filters/filter3.json', :to => 'f:y'
+  #     read 'texts/greetings${f:greeting_index}.txt', :to => 'f:greetings'
+  #     # ...
+  #   end
+  #
+  class ReadExpression < FlowExpression
+
+    names :read
+
+    def apply
+
+      to = attribute('to')
+      from = attribute('from') || attribute_text
+
+      content = open(from).read rescue nil
+        # should this happen in the worker loop ? thread out ?
+
+      content = Rufus::Json.decode(content) rescue content
+
+      set_vf(to, content)
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply(workitem)
+
+      # empty, never called
+    end
+  end
+end
+

data/lib/ruote/exp/fe_redo.rb

@@ -0,0 +1,82 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # Undoes and the redoes (re-applies) an expression identified by a tag.
+  #
+  #   pdef = Ruote.process_definition do
+  #     sequence :tag => 'kilroy' do
+  #       alpha
+  #       _redo :ref => 'kilroy', :unless => '${f:ok} == true'
+  #     end
+  #   end
+  #
+  # will redo at tag 'kilroy' if the field 'ok' is not set to true.
+  #
+  # (redo is escaped as _redo not to conflict with the "redo" Ruby keyword)
+  #
+  # Maybe this case is better served by a cursor/rewind combination
+  #
+  #   pdef = Ruote.process_definition do
+  #     cursor do
+  #       alpha
+  #       rewind :unless => '${f:ok} == true'
+  #     end
+  #   end
+  #
+  # (There is a big difference though, a redo will restart with the workitem
+  # as it was when the workitem entered the tagged region, while the rewind
+  # keeps the workitem as is)
+  #
+  class RedoExpression < FlowExpression
+
+    names :redo
+
+    def apply
+
+      ref = attribute(:ref) || attribute_text
+      tag = ref ? lookup_variable(ref) : nil
+
+      if tag && Ruote.is_a_fei?(tag)
+
+        @context.storage.put_msg('cancel', 'fei' => tag, 're_apply' => true)
+
+        reply_to_parent(h.applied_workitem) unless ancestor?(tag)
+
+      else
+
+        reply_to_parent(h.applied_workitem)
+      end
+    end
+
+    def reply(workitem)
+
+      # never called
+    end
+  end
+end
+

data/lib/ruote/exp/fe_ref.rb

@@ -0,0 +1,152 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # Sometimes you don't know at 'design time', if you want to trigger a
+  # participant or subprocess.
+  #
+  #   Ruote.process_definition do
+  #     sequence do
+  #       participant 'alice'
+  #       ref '${solver}'
+  #       participant 'charlie'
+  #     end
+  #   end
+  #
+  # In this process, solver's name could be a participant name or a subprocess
+  # name.
+  #
+  # Subprocesses have the priority over participants.
+  #
+  # Note : this expression is used by the worker when substituting unknown
+  # expression names with participant or subprocess refs.
+  #
+  class RefExpression < FlowExpression
+
+    names :ref
+
+    def apply
+
+      key = (attribute(:ref) || attribute_text).to_s
+
+      if name != 'ref'
+        key = name
+        tree[1]['ref'] = key
+      end
+
+      key = @context.dollar_sub.s(key, self, h.applied_workitem)
+        # see test/functional/ft_62_
+
+      key2, value = iterative_var_lookup(key)
+
+      tree[1]['ref'] = key2 if key2
+      tree[1]['original_ref'] = key if key2 != key
+
+      unless value
+        #
+        # seems like it's a participant
+
+        @h['participant'] =
+          @context.plist.lookup_info(tree[1]['ref'], h.applied_workitem)
+
+        value = key2 if ( ! @h['participant']) && (key2 != key)
+      end
+
+      new_exp_name, new_exp_class = nil
+
+      if value.is_a?(String)
+
+        if value.index("def consume(") && (Rufus::TreeChecker.parse(value) rescue false)
+          #
+          # participant code passed
+
+          @h['participant'] = [ 'Ruote::CodeParticipant', { 'code' => value } ]
+          tree[1]['ref'] = key
+
+        elsif klass = @context.expmap.expression_class(tree[1]['ref'])
+          #
+          # aliased expression
+
+          new_exp_name = value
+          new_exp_class = klass
+        end
+
+      elsif value.is_a?(Hash) && value['on_workitem']
+        #
+        # participant 'defined' in var
+
+        @h['participant'] = [ 'Ruote::BlockParticipant', value ]
+
+      elsif value.is_a?(Array) && value.size == 2 && value.last.is_a?(Hash)
+        #
+        # participant 'registered' in var
+
+        @h['participant'] = value
+      end
+
+      if value == nil and @h['participant'] == nil
+        #
+        # unknown participant or subprocess
+
+        @h['state'] = 'failed'
+        persist_or_raise
+
+        raise("unknown participant or subprocess '#{tree[1]['ref']}'")
+      end
+
+      new_exp_name, new_exp_class = if new_exp_name
+        [ new_exp_name, new_exp_class ]
+      elsif @h['participant']
+        [ 'participant', Ruote::Exp::ParticipantExpression ]
+      else
+        [ 'subprocess', Ruote::Exp::SubprocessExpression ]
+      end
+
+      tree[0] = new_exp_name
+      @h['name'] = new_exp_name
+
+      new_exp = new_exp_class.new(@context, @h)
+
+      do_schedule_timeout(attribute(:timeout)) if new_exp_name == 'subprocess'
+        #
+        # since ref neutralizes consider_timeout because participant expressions
+        # handle timeout by themselves, we have to force timeout consideration
+        # for subprocess expressions
+
+      #new_exp.initial_persist
+        # not necessary
+
+      new_exp.apply
+    end
+
+    def consider_timeout
+
+      # neutralized
+    end
+  end
+end
+

data/lib/ruote/exp/fe_registerp.rb

@@ -0,0 +1,110 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # This expressions lets one register participants directly from a process
+  # definition.
+  #
+  #   pdef = Ruote.define do
+  #
+  #     registerp 'alpha', :class => 'MyParticipant', :target => 'mail'
+  #       # register participant named 'alpha' with the given class
+  #       # and some attributes
+  #
+  #     registerp /^user_.+/, :class => 'MyParticipant'
+  #     registerp :regex => '^user_.+', :class => 'MyParticipant'
+  #       # register participant with a given regular expression
+  #
+  #     registerp 'admin', :class => 'MyParticipant', :position => -2
+  #       # register participant 'admin' as second to last in participant list
+  #   end
+  #
+  # Participant info can be given as attributes to the expression (see code
+  # above) or via the workitem.
+  #
+  #   pdef = Ruote.define do
+  #
+  #     registerp :participant => 'participant'
+  #       # participant info is found in the field 'participant'
+  #
+  #     registerp :participants => 'participants'
+  #       # an array of participant info is found in the field 'participants'
+  #   end
+  #
+  # The expression 'unregisterp' can be used to remove participants from the
+  # participant list.
+  #
+  class RegisterpExpression < FlowExpression
+
+    names :registerp
+
+    def apply
+
+      registerp_allowed?
+
+      if pa = attribute('participant')
+
+        register_participant(h.applied_workitem['fields'][pa])
+
+      elsif pas = attribute('participants')
+
+        h.applied_workitem['fields'][pas].each do |part|
+          register_participant(part)
+        end
+
+      else
+
+        register_participant(attributes)
+      end
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply(workitem)
+
+      # never called
+    end
+
+    protected
+
+    def registerp_allowed?
+
+      raise ArgumentError.new(
+        "'registerp_allowed' is set to false, cannot [un]register " +
+        "participants from process definitions"
+      ) if context['registerp_allowed'] != true
+    end
+
+    def register_participant(info)
+
+      name, (klass, opts) = Ruote::ParticipantEntry.read(info)
+
+      context.engine.register_participant(name, klass, opts)
+    end
+  end
+end
+

data/lib/ruote/exp/fe_reserve.rb

@@ -0,0 +1,126 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # Prevents two process branches from executing at the same time.
+  #
+  #   pdef = Ruote.process_definition :name => 'test' do
+  #     concurrence do
+  #       reserve :mutex => 'a' do
+  #         alpha
+  #       end
+  #       reserve 'a' do
+  #         alpha
+  #       end
+  #     end
+  #   end
+  #
+  # (Nice and tiny example, turns a concurrence into a sequence...)
+  #
+  class ReserveExpression < FlowExpression
+
+    names :reserve
+
+    def apply
+
+      return reply_to_parent(h.applied_workitem) if tree_children.empty?
+
+      h.mutex_name = attribute(:mutex) || attribute_text
+      h.mutex_name = 'reserve' if h.mutex_name.strip == ''
+
+      raise(
+        ArgumentError.new("can't bind reserve mutex at engine level")
+      ) if h.mutex_name.match(/^\/\//)
+
+      set_mutex
+    end
+
+    def reply(workitem)
+
+      release_mutex
+
+      reply_to_parent(workitem)
+    end
+
+    def cancel(flavour)
+
+      super
+
+      release_mutex
+    end
+
+    def enter
+
+      apply_child(0, h.applied_workitem)
+    end
+
+    protected
+
+    def set_mutex
+
+      target, var = locate_var(h.mutex_name)
+
+      val = target.variables[var]
+
+      # [ 'mutex', name, [ fei0, fei1, ... ] ]
+
+      mutex = val ? val : [ 'mutex', var, [] ]
+
+      mutex.last << h.fei
+
+      target.variables[var] = mutex
+
+      r = target.try_persist
+
+      return set_mutex if r != nil
+
+      if mutex.last.first == h.fei
+        enter
+      else
+        persist_or_raise
+      end
+    end
+
+    def release_mutex
+
+      target, var = locate_var(h.mutex_name)
+
+      mutex = target.variables[var]
+
+      mutex.last.shift
+
+      r = target.try_persist
+
+      return release_mutex if r != nil
+
+      next_fei = mutex.last.first
+
+      Ruote::Exp::FlowExpression.fetch(@context, next_fei).enter if next_fei
+    end
+  end
+end
+