ruote 0.9.20 → 2.1.1

data/lib/ruote/part/local_participant.rb

@@ -0,0 +1,52 @@
+#--
+# 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
+
+  #
+  # Provides methods for 'local' participants.
+  #
+  # Assumes the class that includes this module has a #context method
+  # that points to the worker or engine ruote context.
+  #
+  module LocalParticipant
+
+    attr_accessor :context
+
+    # Sends back the workitem to the ruote engine.
+    #
+    def reply_to_engine (workitem)
+
+      # the local participant knows how to deal with the storage directly
+
+      @context.storage.put_msg(
+        'receive',
+        'fei' => workitem.h.fei,
+        'workitem' => workitem.h,
+        'participant_name' => workitem.participant_name)
+    end
+  end
+end
+

data/lib/{openwfe/engine/tc_engine.rb → ruote/part/no_op_participant.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+# 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
@@ -23,32 +23,37 @@
 #++
 
 
-require 'openwfe/engine/engine'
-require 'openwfe/expool/tc_expstorage'
-require 'openwfe/expool/yaml_errorjournal'
+require 'ruote/part/local_participant'
 
 
-module OpenWFE
+module Ruote
 
   #
-  # An engine persisted to a Tokyo Cabinet table.
+  # A participant that simply replies immediately to the engine.
   #
-  class TcPersistedEngine < Engine
+  # For testing purposes, but could be useful when used in conjunction with
+  # 'listen'.
+  #
+  class NoOpParticipant
+
+    include LocalParticipant
 
-    protected
+    def initialize (opts=nil)
+
+      @items = {}
+    end
 
     #
-    # Overrides the method already found in Engine with a persisted
-    # expression storage
+    # No operation : simply replies immediately to the engine.
     #
-    def build_expression_storage
+    def consume (workitem)
 
-      init_storage(TcExpressionStorage)
+      reply_to_engine(workitem)
     end
 
-    def build_error_journal
+    def cancel (fei, flavour)
 
-      init_service(:s_error_journal, YamlErrorJournal)
+      # nothing to do
     end
   end
 end

data/lib/{openwfe/engine/tt_engine.rb → ruote/part/null_participant.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+# 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
@@ -22,33 +22,32 @@
 # Made in Japan.
 #++
 
+require 'ruote/part/local_participant'
 
-require 'openwfe/engine/engine'
-require 'openwfe/expool/tt_expstorage'
-require 'openwfe/expool/yaml_errorjournal'
 
-
-module OpenWFE
+module Ruote
 
   #
-  # An engine persisted to a Tokyo Tyrant table.
+  # A /dev/null participant, simply discards the workitems it receives,
+  # without doing anything.
   #
-  class TtPersistedEngine < Engine
-
-    protected
+  # For testing purposes only.
+  #
+  class NullParticipant
 
-    #
-    # Overrides the method already found in Engine with a persisted
-    # expression storage
-    #
-    def build_expression_storage
+    include LocalParticipant
 
-      init_storage(TtExpressionStorage)
+    def initialize (opts=nil)
     end
 
-    def build_error_journal
+    # Does nothing, discards the workitem it receives.
+    #
+    def consume (workitem)
+    end
 
-      init_service(:s_error_journal, YamlErrorJournal)
+    # Does nothing.
+    #
+    def cancel (fei, flavour)
     end
   end
 end

data/lib/ruote/part/participant_list.rb

@@ -0,0 +1,201 @@
+#--
+# 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.
+#++
+
+
+require 'ruote/part/block_participant'
+
+
+module Ruote
+
+  #
+  # Tracking participants to [business] processes.
+  #
+  class ParticipantList
+
+    attr_reader :instantiated_participants
+
+    def initialize (context)
+
+      @context = context
+      @instantiated_participants = {}
+    end
+
+    # Registers the participant.
+    #
+    # Called by the register_participant method of the engine.
+    #
+    def register (name, participant, options, block, list=nil)
+
+      list ||= get_list
+
+      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)
+        [ participant.to_s, options ]
+      else
+        "inpa_#{name.inspect}"
+          # INstantiated PArticipant
+      end
+
+      key = (name.is_a?(Regexp) ? name : Regexp.new("^#{name}$")).source
+
+      entry = [ key, entry ]
+
+      list['list'].delete_if { |e| e.first == key }
+
+      position = options['position'] || 'last'
+      case position
+        when 'last' then list['list'] << entry
+        when 'first' then list['list'].unshift(entry)
+        when Fixnum then list['list'].insert(position, entry)
+        else raise "cannot insert participant at position '#{position}'"
+      end
+
+      if r = @context.storage.put(list)
+        #
+        # if put returns something it means the put failed, have to redo the
+        # work...
+        #
+        return register(name, participant, options, block, r)
+      end
+
+      if entry.last.is_a?(String)
+
+        participant = BlockParticipant.new(block, options) if block
+
+        participant.context = @context if participant.respond_to?(:context=)
+        @instantiated_participants[entry.last] = participant
+        #participant
+
+      else
+
+        nil
+      end
+    end
+
+    # Removes a participant, given via its name or directly from this
+    # participant list.
+    #
+    def unregister (name_or_participant, list=nil)
+
+      list ||= get_list
+
+      code = nil
+      entry = nil
+
+      name_or_participant = name_or_participant.to_s \
+        if name_or_participant.is_a?(Symbol)
+
+      if name_or_participant.is_a?(String)
+
+        entry = list['list'].find { |re, pa| name_or_participant.match(re) }
+
+        return nil unless entry
+
+        code = entry.last if entry.last.is_a?(String)
+
+      else # we've been given a participant instance
+
+        code = @instantiated_participants.find { |k, v|
+          v == name_or_participant
+        }
+
+        return nil unless code
+
+        code = code.first
+
+        entry = list['list'].find { |re, pa| pa == code }
+
+      end
+
+      list['list'].delete(entry)
+
+      if r = @context.storage.put(list)
+        #
+        # put failed, have to redo it
+        #
+        return unregister(name_or_participant, r)
+      end
+
+      @instantiated_participants.delete(code) if code
+
+      entry.first
+    end
+
+    def lookup_info (participant_name)
+
+      re, pa = get_list['list'].find { |rr, pp| participant_name.match(rr) }
+
+      case pa
+        when nil then nil
+        when String then @instantiated_participants[pa]
+        else pa
+      end
+    end
+
+    def lookup (participant_name)
+
+      pi = lookup_info(participant_name)
+
+      return nil unless pi
+      return pi unless pi.is_a?(Array)
+
+      class_name, options = pi
+
+      if rp = options['require_path']
+        require(rp)
+      end
+
+      pa = Ruote.constantize(class_name).new(options)
+
+      pa.context = @context if pa.respond_to?(:context=)
+
+      pa
+    end
+
+    # Shuts down the 'instantiated participants' (engine worker participants)
+    # if they respond to #shutdown.
+    #
+    def shutdown
+
+      @instantiated_participants.each { |re, pa|
+        pa.shutdown if pa.respond_to?(:shutdown)
+      }
+    end
+
+    protected
+
+    def get_list
+
+      @context.storage.get_configuration('participant_list') ||
+        { 'type' => 'configurations',
+          '_id' => 'participant_list',
+          'list' => [] }
+    end
+  end
+end
+

data/lib/ruote/part/smtp_participant.rb

@@ -0,0 +1,135 @@
+#--
+# Copyright (c) 2005-2010, Alain Hoang and John Mettraux.
+#
+# 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.
+#++
+
+require 'net/smtp'
+
+require 'ruote/participant'
+require 'ruote/part/template'
+
+
+module Ruote
+
+  #
+  # A very stupid SMTP participant, doesn't even care about formatting its
+  # messages. This class is meant as a base for more complex email participants.
+  #
+  # == options
+  #
+  # * :server - the IP address or hostname of the SMTP server/gateway (defaults to '127.0.0.1')
+  # * :port - the port of the SMTP server/gateway (defaults to 25)
+  # * :from - the from mail address (mandatory)
+  # * :to - the to mail address[es]
+  # * :template - a String template for the mail message
+  # * :notification - when set to true, the flow will resume immediately after having sent the email
+  #
+  # == :template
+  #
+  #   @engine.register_participant(
+  #     :no_good_notification
+  #     Ruote::SmtpParticipant,
+  #     :server => 'smtp.example.com'
+  #     :port => 25,
+  #     :to => 'toto@example.com',
+  #     :from => 'john@example.com',
+  #     :notification => true,
+  #     :template => "Subject: ${f:email_subject}\n\nno good.")
+  #
+  # Process variable / workitem field substitution works the same as in
+  # process definitions (in this example, the workitem field email_subject will
+  # be used as the subject of the email...)
+  #
+  # == block template
+  #
+  # Whereas the :template option accepts a String, the block template may
+  # be useful when more complex templates are to be computed.
+  #
+  #   @engine.register_participant(
+  #     :no_good_notification
+  #     Ruote::SmtpParticipant,
+  #     :server => 'smtp.example.com'
+  #     :port => 25,
+  #     :to => 'toto@example.com',
+  #     :from => 'john@example.com',
+  #     :notification => true
+  #   ) do
+  #
+  #     s = []
+  #     s << "From: the boss"
+  #     s << "Date: ${r:Time.now.rfc2822}"
+  #     s << "Subject: ${f:email_subject}\n"
+  #     s << ""
+  #     3.times { s << "this is no good." }
+  #
+  #     s.join("\n")
+  #   end
+  #
+  #
+  # == mail listener
+  #
+  # This participant cannot read POP/IMAP accounts for you. You have to
+  # use a mail listener or get a web reply by placing a link in the message...
+  #
+  class SmtpParticipant
+
+    include LocalParticipant
+    include TemplateMixin
+
+    def initialize (opts={}, &block)
+
+      @server = opts[:server] || '127.0.0.1'
+      @port = opts[:port] || 25
+
+      @from = opts[:from]
+      @to = opts[:to]
+
+      @template = opts[:template]
+      @block_template = block
+
+      @notification = opts[:notification]
+    end
+
+    def consume (workitem)
+
+      to = workitem.fields['email_target'] || @to
+      to = Array(to)
+
+      text = render_template(
+        Ruote::Exp::FlowExpression.fetch(@context, workitem.fei.to_h), workitem)
+
+      Net::SMTP.start(@server, @port) do |smtp|
+        smtp.send_message(text, @from, *to)
+      end
+
+      reply_to_engine(workitem) if @notification
+    end
+
+    def cancel (fei, flavour)
+
+      # does nothing
+      #
+      # one variant could send a "cancellation email"
+    end
+  end
+end
+