ruote 2.1.10 → 2.1.11

data/lib/ruote/{part → svc}/participant_list.rb

@@ -31,6 +31,10 @@ module Ruote
   #
   # Tracking participants to [business] processes.
   #
+  # The methods here are mostly called via the engine (registering /
+  # unregistering participants) and via the dispatch_pool (when handing
+  # workitems to participants).
+  #
   class ParticipantList
 
     attr_reader :instantiated_participants
@@ -41,20 +45,16 @@ module Ruote
       @instantiated_participants = {}
     end
 
-    # Registers the participant.
-    #
-    # Called by the register_participant method of the engine.
+    # Registers a participant. Called by Engine#register_participant.
     #
-    def register (name, participant, options, block, list=nil)
-
-      list ||= get_list
+    def register (name, participant, options, block)
 
       options = options.inject({}) { |h, (k, v)|
         h[k.to_s] = v.is_a?(Symbol) ? v.to_s : v
         h
       }
 
-      entry = if participant.is_a?(Class)
+      entry = if participant.is_a?(Class) || participant.is_a?(String)
         [ participant.to_s, options ]
       else
         "inpa_#{name.inspect}"
@@ -65,6 +65,8 @@ module Ruote
 
       entry = [ key, entry ]
 
+      list = get_list
+
       list['list'].delete_if { |e| e.first == key }
 
       position = options['position'] || 'last'
@@ -104,12 +106,13 @@ module Ruote
     # Removes a participant, given via its name or directly from this
     # participant list.
     #
-    def unregister (name_or_participant, list=nil)
-
-      list ||= get_list
+    # Called usually by Engine#unregister_participant.
+    #
+    def unregister (name_or_participant)
 
       code = nil
       entry = nil
+      list = get_list
 
       if name_or_participant.is_a?(Symbol)
         name_or_participant = name_or_participant.to_s
@@ -151,35 +154,75 @@ module Ruote
       entry.first
     end
 
-    def lookup_info (participant_name)
+    # Returns a participant instance, or nil if there is no participant
+    # for the given participant name.
+    #
+    # Mostly a combination of #lookup_info and #instantiate.
+    #
+    def lookup (participant_name, workitem, opts={})
 
-      re, pa = get_list['list'].find { |rr, pp| participant_name.match(rr) }
+      pinfo = participant_name
 
-      case pa
-        when nil then nil
-        when String then @instantiated_participants[pa]
-        else pa
+      if participant_name.is_a?(String) && participant_name[0, 5] != 'inpa_'
+        pinfo = lookup_info(participant_name, workitem)
       end
+
+      pinfo ? instantiate(pinfo, opts) : nil
     end
 
-    def lookup (participant_name, opts={})
+    # Given a participant name, returns
+    #
+    # Returns nil if there is no participant registered that covers the given
+    # participant name.
+    #
+    def lookup_info (pname, workitem)
+
+      get_list['list'].each do |regex, pinfo|
 
-      pi = lookup_info(participant_name)
+        next unless pname.match(regex)
 
-      return nil unless pi
-      return opts[:on_reply] ? nil : pi unless pi.is_a?(Array)
+        pa = instantiate(pinfo, :if_respond_to? => :accept?)
 
-      class_name, options = pi
+        return pinfo unless pa
+
+        return pinfo if pa.accept?(
+          Ruote::Workitem.new(workitem.merge('participant_name' => pname))
+        )
+      end
+
+      nil
+    end
+
+    # Returns an instance of a participant
+    #
+    def instantiate (pinfo, opts={})
+
+      irt = opts[:if_respond_to?]
+
+      pinfo = @instantiated_participants[pinfo] if pinfo.is_a?(String)
+
+      if pinfo.respond_to?(:consume)
+        return (pinfo.respond_to?(irt) ? pinfo : nil) if irt
+        return pinfo
+      end
+
+      return nil unless pinfo
+
+      pa_class_name, options = pinfo
 
       if rp = options['require_path']
         require(rp)
       end
+      if lp = options['load_path']
+        load(lp)
+      end
 
-      pa_class = Ruote.constantize(class_name)
+      pa_class = Ruote.constantize(pa_class_name)
       pa_m = pa_class.instance_methods
 
-      return nil if opts[:on_reply] && ! (
-        pa_m.include?(:on_reply) || pa_m.include?('on_reply'))
+      if irt && ! (pa_m.include?(irt.to_s) || pa_m.include?(irt.to_sym))
+        return nil
+      end
 
       pa = if pa_class.instance_method(:initialize).arity > 0
         pa_class.new(options)
@@ -195,7 +238,7 @@ module Ruote
     #
     def names
 
-      get_list['list'].map { |re, pa| re }
+      get_list['list'].collect { |re, pa| re }
     end
 
     # Shuts down the 'instantiated participants' (engine worker participants)
@@ -208,8 +251,40 @@ module Ruote
       }
     end
 
+    # Used by Engine#participant_list
+    #
+    # Returns a representation of this participant list as an array of
+    # ParticipantEntry instances.
+    #
+    def list
+
+      get_list['list'].collect { |e| ParticipantEntry.new(e) }
+    end
+
+    # Used by Engine#participant_list=
+    #
+    # Takes as input an array of ParticipantEntry instances and updates
+    # this participant list with it.
+    #
+    # See ParticipantList#list
+    #
+    def list= (pl)
+
+      list = get_list
+      list['list'] = pl.collect { |e| ParticipantEntry.read(e) }
+
+      if r = @context.storage.put(list)
+        #
+        # put failed, have to redo it
+        #
+        list= (pl)
+      end
+    end
+
     protected
 
+    # Fetches and returns the participant list in the storage.
+    #
     def get_list
 
       @context.storage.get_configuration('participant_list') ||
@@ -217,6 +292,71 @@ module Ruote
           '_id' => 'participant_list',
           'list' => [] }
     end
+
+    #--
+    # Returns an array of all the classes in the ObjectSpace that include the
+    # Ruote::LocalParticipant module.
+    #
+    #def local_participant_classes
+    #  ObjectSpace.each_object(Class).inject([]) { |a, c|
+    #    a << c if c.include?(Ruote::LocalParticipant)
+    #    a
+    #  }
+    #end
+    #++
+  end
+
+  #
+  # A helper class, for ParticipantList#list, which returns a list (order
+  # matters) of ParticipantEntry instances.
+  #
+  # See Engine#participant_list
+  #
+  class ParticipantEntry
+
+    attr_accessor :regex, :classname, :options
+
+    def initialize (a)
+      @regex = a.first
+      if a.last.is_a?(Array)
+        @classname = a.last.first
+        @options = a.last.last
+      else
+        @classname = a.last
+        @options = nil
+      end
+    end
+
+    def to_a
+      @classname[0, 5] == 'inpa_' ?
+        [ @regex, @classname ] :
+        [ @regex, [ @classname, @options ] ]
+    end
+
+    def to_s
+      "/#{@regex}/ ==> #{@classname} #{@options.inspect}"
+    end
+
+    def self.read (elt)
+
+      if elt.is_a?(ParticipantEntry)
+        return elt.to_a
+      end
+
+      if elt.is_a?(Hash)
+        return elt['classname'][0, 5] == 'inpa_' ?
+          [ elt['regex'], elt['classname'] ] :
+          [ elt['regex'], [ elt['classname'], elt['options'] ] ]
+      end
+
+      # else elt is a Array
+
+      if elt.size == 3
+        return [ elt[0], [ elt[1], elt[2] ] ]
+      end
+
+      elt
+    end
   end
 end
 

data/lib/ruote/util/look.rb

@@ -37,8 +37,11 @@ module Ruote
 
     def self.dump_lsof
 
+      result = lsof
+
       puts '= lsof =' + '=' * 71
-      puts lsof
+      puts result
+      puts result.split("\n").size
       puts '=' * 80
     end
 

data/lib/ruote/util/ometa.rb

@@ -29,9 +29,9 @@
 
 module Ruote
 
+  # meta a la lucky stiff
+  #
   module WithMeta
-    #
-    # meta a la lucky stiff
 
     def self.included(target)
 
@@ -40,16 +40,32 @@ module Ruote
           self
         end
       end
-      def target.meta_eval (&block)
+      def target.meta_eval(&block)
         metaclass.instance_eval(&block)
       end
-      def target.meta_def (method_name, &block)
+      def target.meta_def(method_name, &block)
         meta_eval { define_method method_name, &block }
       end
-      def class_def (method_name, &block)
+      def class_def(method_name, &block)
         class_eval { define_method name, &block }
       end
     end
   end
+
+  # A blank slate of a class
+  #
+  class BlankSlate
+
+    instance_methods.each do |m|
+
+      next if %w[
+        method_missing respond_to? instance_eval object_id
+      ].include?(m.to_s)
+
+      next if m.to_s.match(/^__/)
+
+      undef_method(m)
+    end
+  end
 end
 

data/lib/ruote/version.rb

@@ -23,6 +23,6 @@
 #++
 
 module Ruote
-  VERSION = '2.1.10'
+  VERSION = '2.1.11'
 end
 

data/lib/ruote/worker.rb

@@ -39,6 +39,7 @@ module Ruote
       # 'receive' is a ParticipantExpression alias for 'reply'
 
     PROC_ACTIONS = %w[ cancel_process kill_process ]
+    DISP_ACTIONS = %w[ dispatch dispatch_cancel ]
 
     attr_reader :storage
     attr_reader :context
@@ -64,13 +65,16 @@ module Ruote
       @sleep_time = 0.000
     end
 
+    # Runs the worker in the current thread. See #run_in_thread for running
+    # in a dedicated thread.
+    #
     def run
 
-      while(@running) do
-        step
-      end
+      step while @running
     end
 
+    # Triggers the run method of the worker in a dedicated thread.
+    #
     def run_in_thread
 
       Thread.abort_on_exception = true
@@ -81,6 +85,14 @@ module Ruote
       @run_thread = Thread.new { run }
     end
 
+    # Joins the run thread of this worker (if there is no such thread, this
+    # method will return immediately, without any effect).
+    #
+    def join
+
+      @run_thread.join if @run_thread
+    end
+
     def subscribe (actions, subscriber)
 
       @subscribers << [ actions, subscriber ]
@@ -101,10 +113,9 @@ module Ruote
     # Returns true if the engine system is inactive, ie if all the process
     # instances are terminated or are stuck in an error.
     #
-    # NOTE : for now, if a branch of a process is in errors while another is
-    # still running, this methods will still consider the process instance
-    # as inactive (and it will return true if all the processes are considered
-    # inactive).
+    # NOTE : for now, if a branch of a process is in error while another is
+    # still running, this method will consider the process instance inactive
+    # (and it will return true if all the processes are considered inactive).
     #
     def inactive?
 
@@ -116,11 +127,11 @@ module Ruote
 
       wfids = @context.storage.get_many('expressions').collect { |exp|
         exp['fei']['wfid']
-      }.sort.uniq
+      }
 
       error_wfids = @context.storage.get_many('errors').collect { |err|
         err['fei']['wfid']
-      }.sort.uniq
+      }
 
       (wfids - error_wfids == [])
     end
@@ -213,7 +224,7 @@ module Ruote
 
           Ruote::Exp::FlowExpression.do_action(@context, msg)
 
-        elsif action.match(/^dispatch/)
+        elsif DISP_ACTIONS.include?(action)
 
           @context.dispatch_pool.handle(msg)
 
@@ -283,78 +294,27 @@ module Ruote
 
       if not exp_class
 
-        exp_class, tree = lookup_subprocess_or_participant(exp_hash)
+        exp_class = Ruote::Exp::RefExpression
+
+      #elsif msg['action'] == 'launch' && exp_class == Ruote::Exp::DefineExpression
+      elsif is_launch?(msg, exp_class)
 
-      elsif msg['action'] == 'launch' && exp_class == Ruote::Exp::DefineExpression
         def_name, tree = Ruote::Exp::DefineExpression.reorganize(tree)
         variables[def_name] = [ '0', tree ] if def_name
         exp_class = Ruote::Exp::SequenceExpression
       end
 
-      if exp_class == Ruote::Exp::SubprocessExpression && tree[1]['engine']
-        #
-        # the subprocess has to be transformed into an EngineParticipant...
-
-        exp_class = Ruote::Exp::ParticipantExpression
-
-        atts = tree[1]
-
-        if ref = atts.find { |k, v| v.nil? }
-          ref = ref.first
-          atts.delete(ref)
-        end
-
-        atts['pdef'] = atts['ref'] || ref
-        atts['ref'] = atts.delete('engine')
-      end
-
-      raise_unknown_expression_error(exp_hash) unless exp_class
-
       exp = exp_class.new(@context, exp_hash.merge!('original_tree' => tree))
 
       exp.initial_persist
       exp.do_apply
     end
 
-    def raise_unknown_expression_error (exp_hash)
-
-      exp_hash['state'] = 'failed'
-      #exp_hash['has_error'] = true
-
-      Ruote::Exp::RawExpression.new(@context, exp_hash).persist_or_raise
-        # undigested expression is stored
-
-      raise "unknown expression '#{exp_hash['original_tree'].first}'"
-    end
-
-    def lookup_subprocess_or_participant (exp_hash)
-
-      tree = exp_hash['original_tree']
-
-      key, value = Ruote::Exp::FlowExpression.new(
-        @context, exp_hash.merge('name' => 'temporary')
-      ).iterative_var_lookup(tree[0])
-
-      sub = value
-      part = @context.plist.lookup_info(key)
+    def is_launch? (msg, exp_class)
 
-      sub = key if (not sub) && (not part) && Ruote.is_uri?(key)
-        # for when a variable points to the URI of a[n external] subprocess
-
-      if sub or part
-
-        tree[1]['ref'] = key
-        tree[1]['original_ref'] = tree[0] if key != tree[0]
-
-        if sub
-          [ Ruote::Exp::SubprocessExpression, [ 'subprocess', *tree[1..2] ] ]
-        else
-          [ Ruote::Exp::ParticipantExpression, [ 'participant', *tree[1..2] ] ]
-        end
-      else
-
-        [ nil, tree ]
-      end
+      return false if exp_class != Ruote::Exp::DefineExpression
+      return true if msg['action'] == 'launch'
+      (msg['trigger'] == 'on_re_apply')
     end
 
     def cancel_process (msg)

data/lib/ruote/workitem.rb

@@ -144,7 +144,7 @@ module Ruote
 
     # When was this workitem dispatched ?
     #
-    def dispatch_at
+    def dispatched_at
 
       fields['dispatched_at']
     end
@@ -234,6 +234,33 @@ module Ruote
 
       @h['fields']['params']
     end
+
+    # (advanced)
+    #
+    # Shortcut for wi.fields['__command__']
+    #
+    # __command__ is read by the 'cursor' and the 'iterator' expressions
+    # when a workitem reaches it (apply and reply).
+    #
+    def commmand
+
+      @h['fields']['__command__']
+    end
+
+    # (advanced)
+    #
+    # Shortcut for wi.fields['__command__'] = x
+    #
+    # __command__ is read by the 'cursor' and the 'iterator' expressions
+    # when a workitem reaches it (apply and reply).
+    #
+    def command= (com)
+
+      com = com.is_a?(Array) ? com : com.split(' ')
+      com[1] = com[1].to_i if com[1]
+
+      @h['fields']['__command__'] = com
+    end
   end
 end