ruote 2.1.4 → 2.1.5

data/lib/ruote/exp/ro_persist.rb

@@ -69,13 +69,10 @@ module Ruote::Exp
 
       return r if r
 
-      if h.has_error
-
-        err = @context.storage.get(
-          'errors', "err_#{Ruote.to_storage_id(h.fei)}")
-
-        @context.storage.delete(err) if err
-      end
+      #if h.has_error
+      err = @context.storage.get('errors', "err_#{Ruote.to_storage_id(h.fei)}")
+      @context.storage.delete(err) if err
+      #end
 
       nil
     end

data/lib/ruote/exp/ro_variables.rb

@@ -64,11 +64,15 @@ module Ruote::Exp
 
       if h.variables
 
-        val = h.variables[var]
+        #val = h.variables[var]
+        val = Ruote.lookup(h.variables, var)
+
         return val if val != nil
       end
 
-      if h.parent_id
+      if h.parent_id && h.parent_id['engine_id'] == @context.engine_id
+        #
+        # do not lookup variables in a remote engine ...
 
         return parent.lookup_variable(var, prefix)
       end

data/lib/ruote/fei.rb

@@ -75,6 +75,15 @@ module Ruote
       "#{hfei['expid']}!#{hfei['sub_wfid']}!#{hfei['wfid']}"
     end
 
+    def self.from_id (s, engine_id='engine')
+
+      ss = s.split('!')
+
+      FlowExpressionId.new(
+        'engine_id' => engine_id,
+        'expid' => ss[0], 'sub_wfid' => ss[1], 'wfid' => ss[2])
+    end
+
     # Returns the last number in the expid. For instance, if the expid is
     # '0_5_7', the child_id will be '7'.
     #

data/lib/ruote/log/wait_logger.rb

@@ -43,6 +43,7 @@ module Ruote
       @context.worker.subscribe(:all, self) if @context.worker
 
       @noisy = false
+      @count = -1
     end
 
     def notify (msg)

data/lib/ruote/part/engine_participant.rb

@@ -0,0 +1,185 @@
+#--
+# Copyright (c) 2005-2010, 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 Singapore.
+#++
+
+require 'ruote/subprocess'
+require 'ruote/part/local_participant'
+
+
+module Ruote
+
+  #
+  # A participant for pushing the execution of [segments of] processes to
+  # other engines.
+  #
+  # It works by giving the participant the connection information to the storage
+  # of the other engine.
+  #
+  # For instance :
+  #
+  #  engine0 =
+  #    Ruote::Engine.new(
+  #      Ruote::Worker.new(
+  #        Ruote::FsStorage.new('work0', 'engine_id' => 'engine0')))
+  #  engine1 =
+  #    Ruote::Engine.new(
+  #      Ruote::Worker.new(
+  #        Ruote::FsStorage.new('work1', 'engine_id' => 'engine1')))
+  #
+  #  engine0.register_participant('engine1',
+  #    Ruote::EngineParticipant,
+  #    'storage_class' => Ruote::FsStorage,
+  #    'storage_path' => 'ruote/storage/fs_storage',
+  #    'storage_args' => 'work1')
+  #  engine1.register_participant('engine0',
+  #    Ruote::EngineParticipant,
+  #    'storage_class' => Ruote::FsStorage,
+  #    'storage_path' => 'ruote/storage/fs_storage',
+  #    'storage_args' => 'work0')
+  #
+  # In this example, two engines are created (note that their 'engine_id' is
+  # explicitely set (else it would default to 'engine')). Each engine is then
+  # registered as participant in the other engine. The registration parameters
+  # detail the class and the arguments to the storage of the target engine.
+  #
+  # This example is a bit dry / flat. A real world example would perhaps detail
+  # a 'master' engine connected to 'departemental' engines, something more
+  # hierarchical.
+  #
+  # The example also binds reciprocally engines. If the delegated processes
+  # are always 'forgotten', one could imagine not binding the source engine
+  # as a participant in the target engine (not need to answer back).
+  #
+  # There are then two variants for calling a subprocess
+  #
+  #   subprocess :ref => 'subprocess_name', :engine => 'engine1'
+  #     # or
+  #   participant :ref => 'engine1', :pdef => 'subprocess_name'
+  #
+  # It's OK to go for the shorter versions :
+  #
+  #   subprocess_name :engine => 'engine1'
+  #     # or
+  #   participant 'engine1', :pdef => 'subprocess_name'
+  #   engine1 :pdef => 'subprocess_name'
+  #
+  # The subprocess is defined in the current process, or it's given via its
+  # URL. The third variant is a subprocess bound as an engine variable.
+  #
+  #   engine.variables['variant_3'] = Ruote.process_definition do
+  #     participant 'hello_world_3'
+  #   end
+  #
+  #   pdef = Ruote.process_definition do
+  #     sequence do
+  #       engine1 :pdef => 'variant_1'
+  #       engine1 :pdef => 'http://pdefs.example.com/variant_2.rb'
+  #       engine1 :pdef => 'variant_3'
+  #     end
+  #     define 'variant_1' do
+  #       participant 'hello_world_1'
+  #     end
+  #   end
+  #
+  class EngineParticipant
+
+    include LocalParticipant
+
+    def initialize (opts=nil)
+
+      if pa = opts['storage_path']
+        require pa
+      end
+
+      kl = opts['storage_class']
+
+      raise(ArgumentError.new("missing 'storage_class' parameter")) unless kl
+
+      @storage = Ruote.constantize(kl).new(opts['storage_args'])
+    end
+
+    def consume (workitem)
+
+      wi = workitem.to_h
+      fexp = Ruote::Exp::FlowExpression.fetch(@context, wi['fei'])
+      params = wi['fields'].delete('params')
+
+      forget = (fexp.attribute(:forget).to_s == 'true')
+
+      @storage.put_msg(
+        'launch',
+        'wfid' => wi['fei']['wfid'],
+        'sub_wfid' => fexp.get_next_sub_wfid,
+        'parent_id' => forget ? nil : wi['fei'],
+        'tree' => determine_tree(fexp, params),
+        'workitem' => wi,
+        'variables' => fexp.compile_variables)
+
+      fexp.unpersist if forget
+        #
+        # special behaviour here in case of :forget => true :
+        # parent_id of remote expression is set to nil and local expression
+        # is unpersisted immediately
+    end
+
+    def cancel (fei, flavour)
+
+      exps = @storage.get_many('expressions', /^0![^!]+!#{fei.wfid}$/)
+
+      return true if exps.size < 1
+        # participant expression will reply to its parent
+
+      @storage.put_msg(
+        'cancel',
+        'fei' => exps.first['fei'],
+        'flavour' => flavour)
+
+      false
+        # participant expression will NOT reply to its parent
+    end
+
+    def reply (fei, workitem)
+
+      @storage.put_msg(
+        'reply',
+        'fei' => fei,
+        'workitem' => workitem)
+    end
+
+    protected
+
+    def determine_tree (fexp, params)
+
+      pdef = params['def'] || params['pdef'] || params['tree']
+
+      tree = Ruote.lookup_subprocess(fexp, pdef)
+
+      raise(
+        "couldn't find process definition behind '#{pdef}'"
+      ) unless tree
+
+      tree.last
+    end
+  end
+end
+

data/lib/ruote/part/storage_participant.rb

@@ -27,6 +27,12 @@ require 'ruote/part/local_participant'
 
 module Ruote
 
+  #
+  # A participant that stores the workitem in the same storage used by the
+  # engine and the worker(s).
+  #
+  # Does not thread by default.
+  #
   class StorageParticipant
 
     include LocalParticipant
@@ -34,7 +40,15 @@ module Ruote
 
     attr_accessor :context
 
-    def initialize (options={})
+    def initialize (engine_or_options={}, options=nil)
+
+      if engine_or_options.respond_to?(:context)
+        @context = engine_or_options.context
+      else
+        options = engine_or_options
+      end
+
+      options ||= {}
 
       @store_name = options['store_name']
     end
@@ -47,6 +61,8 @@ module Ruote
 
       doc = workitem.to_h
 
+      doc.delete('_rev')
+
       doc.merge!(
         'type' => 'workitems',
         '_id' => to_id(doc['fei']),
@@ -59,13 +75,13 @@ module Ruote
     end
     alias :update :consume
 
-    # Makes sure to remove the workitem from the in-memory hash.
+    # Removes the document/workitem from the storage
     #
     def cancel (fei, flavour)
 
-      doc = fetch(fei)
+      doc = fetch(fei.to_h)
 
-      r = @storage.delete(doc)
+      r = @context.storage.delete(doc)
 
       cancel(fei, flavour) if r != nil
     end
@@ -74,11 +90,13 @@ module Ruote
 
       doc = fetch(fei)
 
-      doc ? Ruote::WorkItem.new(doc) : nil
+      doc ? Ruote::Workitem.new(doc) : nil
     end
 
     def fetch (fei)
 
+      fei = fei.to_h if fei.respond_to?(:to_h)
+
       @context.storage.get('workitems', to_id(fei))
     end
 
@@ -133,14 +151,50 @@ module Ruote
       @context.storage.get_many('workitems', /!#{wfid}$/).map { |hwi| Ruote::Workitem.new(hwi) }
     end
 
-    # Return all workitems for the specified participant
+    # Returns all workitems for the specified participant name
+    #
+    def by_participant (participant_name)
+
+
+      hwis = if @context.storage.respond_to?(:by_participant)
+
+        @context.storage.by_participant('workitems', participant_name)
+
+      else
+
+        fetch_all.select { |wi| wi['participant_name'] == participant_name }
+      end
+
+      hwis.collect { |hwi| Ruote::Workitem.new(hwi) }
+    end
+
+    # field : returns all the workitems with the given field name present.
+    #
+    # field and value : returns all the workitems with the given field name
+    # and the given value for that field.
+    #
+    # Warning : only some storages are optimized for such queries (like
+    # CouchStorage), the others will load all the workitems and then filter
+    # them.
     #
-    def by_participant( part )
+    def by_field (field, value=nil)
 
-      all.select { |wi| wi.participant_name == part }
+      hwis = if @context.storage.respond_to?(:by_field)
+
+        @context.storage.by_field('workitems', field, value)
+
+      else
+
+        fetch_all.select { |hwi|
+          hwi['fields'].keys.include?(field) &&
+          (value.nil? || hwi['fields'][field] == value)
+        }
+      end
+
+      hwis.collect { |hwi| Ruote::Workitem.new(hwi) }
     end
 
-    # Clean this participant out completely
+    # Cleans this participant out completely
     #
     def purge!
 
@@ -151,18 +205,20 @@ module Ruote
 
     def fetch_all
 
-      key = @store_name ? /^wi\_#{@store_name}::/ : nil
+      key = @store_name ? /^wi!#{@store_name}::/ : nil
 
       @context.storage.get_many('workitems', key)
     end
 
     def to_id (fei)
 
-      sid = Ruote.to_storage_id(fei)
+      a = [ Ruote.to_storage_id(fei) ]
+
+      a.unshift(@store_name) if @store_name
 
-      sid = @store_name ? "#{store_name}::#{sid}" : sid
+      a.unshift('wi')
 
-      "wi_#{sid}"
+      a.join('!')
     end
   end
 end

data/lib/ruote/participant.rb

@@ -3,4 +3,5 @@ require 'ruote/part/hash_participant'
 require 'ruote/part/storage_participant'
 require 'ruote/part/no_op_participant'
 require 'ruote/part/null_participant'
+require 'ruote/part/engine_participant'
 

data/lib/ruote/storage/base.rb

@@ -96,7 +96,7 @@ module Ruote
 
     def find_root_expression (wfid)
 
-      get_many('expressions', /#{wfid}$/).sort { |a, b|
+      get_many('expressions', /!#{wfid}$/).sort { |a, b|
         a['fei']['expid'] <=> b['fei']['expid']
       }.select { |e|
         e['parent_id'].nil?

data/lib/ruote/subprocess.rb

@@ -0,0 +1,68 @@
+#--
+# Copyright (c) 2005-2010, 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
+
+  #--
+  # a few helper methods about subprocesses
+  #++
+
+  # This method is used by the 'subprocess' expression and by the
+  # EngineParticipant.
+  #
+  def self.lookup_subprocess (fexp, ref)
+
+    val = fexp.lookup_variable(ref)
+
+    # a classical subprocess stored in a variable ?
+
+    return [ '0', val ] if is_tree?(val)
+    return val if is_pos_tree?(val)
+
+    # maybe subprocess :ref => 'uri'
+
+    subtree = fexp.context.parser.parse(ref) rescue nil
+
+    _, subtree = Ruote::Exp::DefineExpression.reorganize(subtree) \
+      if subtree && Ruote::Exp::DefineExpression.is_definition?(subtree)
+
+    return [ '0', subtree ] if is_tree?(subtree)
+
+    # no luck ...
+
+    raise "no subprocess named '#{ref}' found"
+  end
+
+  def self.is_tree? (a)
+
+    a.is_a?(Array) && a[1].is_a?(Hash) && a.size == 3
+  end
+
+  def self.is_pos_tree? (a)
+
+    a.is_a?(Array) && a.size == 2 && a[0].is_a?(String) && is_tree?(a[1])
+  end
+end
+