openwferu 0.9.2 → 0.9.3

data/lib/openwfe/expressions/timeout.rb

@@ -0,0 +1,94 @@
+#
+#--
+# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . Redistributions in binary form must reproduce the above copyright notice, 
+#   this list of conditions and the following disclaimer in the documentation 
+#   and/or other materials provided with the distribution.
+# 
+# . Neither the name of the "OpenWFE" nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/util/otime'
+require 'openwfe/util/scheduler'
+
+
+#
+# Managing timeout for expressions like 'participant' and 'when'
+#
+
+module OpenWFE
+
+
+    #
+    # The timeout behaviour is implemented here, making it easy
+    # to mix it in into ParticipantExpression and WhenExpression.
+    #
+    module TimeoutMixin
+        include Schedulable
+
+        attr_accessor \
+            :timeout_at,
+            :scheduler_job_id
+        
+        def determine_timeout
+
+            timeout = lookup_attribute(:timeout, @applied_workitem)
+            return unless timeout
+
+            timeout = OpenWFE::parse_time_string(timeout)
+            @timeout_at = Time.new.to_f + timeout
+
+            reschedule(get_scheduler)
+        end
+
+        def reschedule (scheduler)
+
+            return unless @timeout_at
+
+            @scheduler_job_id = 
+                scheduler.schedule_at(@timeout_at, self, nil)
+
+            ldebug do 
+                "reschedule() will timeout at "+
+                "#{OpenWFE::to_iso8601_date(@timeout_at)}"
+            end
+
+            #store_itself()
+                #
+                # done in the including expression
+        end
+    end
+
+end
+

data/lib/openwfe/flowexpressionid.rb

@@ -49,16 +49,22 @@ module OpenWFE
     class FlowExpressionId
 
         attr_accessor \
-            :owfe_version, \
-            :engine_id, \
-            :initial_engine_id, \
-            :workflow_definition_url, \
-            :workflow_definition_name, \
-            :workflow_definition_revision, \
-            :workflow_instance_id, \
-            :expression_name, \
+            :owfe_version,
+            :engine_id,
+            :initial_engine_id,
+            :workflow_definition_url, 
+            :workflow_definition_name,
+            :workflow_definition_revision,
+            :workflow_instance_id,
+            :expression_name,
             :expression_id
 
+        #
+        # A shortcut for fei.workflow_instance_id.
+        # There's also fei.parent_wfid.
+        #
+        alias :wfid :workflow_instance_id
+
         #
         # overrides the classical to_s()
         #
@@ -85,17 +91,7 @@ module OpenWFE
         end
 
         def dup
-            n = FlowExpressionId.new
-            n.owfe_version = @owfe_version.dup
-            n.engine_id = @engine_id.dup
-            n.initial_engine_id = @initial_engine_id.dup
-            n.workflow_definition_url = @workflow_definition_url.dup
-            n.workflow_definition_name = @workflow_definition_name.dup
-            n.workflow_definition_revision = @workflow_definition_revision.dup
-            n.workflow_instance_id = @workflow_instance_id.dup
-            n.expression_name = @expression_name.dup
-            n.expression_id = @expression_id.dup
-            return n
+            OpenWFE::fulldup(self)
         end
 
         alias eql? ==
@@ -117,6 +113,8 @@ module OpenWFE
             return workflow_instance_id[0..i-1]
         end
 
+        alias :parent_wfid :parent_workflow_instance_id
+
         #
         # This class method parses a string into a FlowExpressionId instance
         #

data/lib/openwfe/logging.rb

@@ -50,34 +50,53 @@ module OpenWFE
     #
     module Logging
 
-        def init_default_logging (filename)
-            log = Logger.new(filename)
-            @application_context[S_LOGGER] = log
+        def ldebug (message=nil, &block)
+            do_log(:debug, message, &block)
         end
 
-        def ldebug (&block)
-            log = get_logger
-            log.debug(who(), &block) if log
+        def linfo (message=nil, &block)
+            do_log(:info, message, &block)
         end
 
-        def linfo (&block)
-            log = get_logger
-            log.info(who(), &block) if log
+        def lwarn (message=nil, &block)
+            do_log(:warn, message, &block)
         end
 
-        def lwarn (&block)
-            log = get_logger
-            log.warn(who(), &block) if log
+        def lerror (message=nil, &block)
+            do_log(:error, message, &block)
+        end
+
+        def lfatal (message=nil, &block)
+            do_log(:fatal, message, &block)
+        end
+
+        def lunknown (message=nil, &block)
+            do_log(:unknown, message, &block)
         end
 
         private
 
-            def get_logger
-                return @application_context[S_LOGGER] if @application_context
-                return Logger.new(STDOUT)
+            def do_log (level, message, &block)
+
+                return unless $OWFE_LOG
+
+                logblock = lambda do
+                    if block
+                        "#{log_prepare(message)} - #{block.call}"
+                    else
+                        "#{log_prepare(message)}"
+                    end
+                end
+
+                $OWFE_LOG.send level, &logblock
+            end
+
+            def log_prepare (message)
+                return log_author() if not message
+                return "#{log_author} - #{message}"
             end
 
-            def who
+            def log_author
                 if respond_to? :service_name
                     "#{self.class} '#{self.service_name}'"
                 else

data/lib/openwfe/participants/atomparticipants.rb

@@ -52,7 +52,7 @@ require 'monitor'
 require 'rubygems'
 require 'atom/collection'
 
-require 'openwfe/participants/participants'
+require 'openwfe/participants/participant'
 
 
 module OpenWFE
@@ -61,18 +61,42 @@ module OpenWFE
     # Stores the incoming workitem into an 'atom feed'
     #
     # An example :
-    # <tt>
+    #
     #     feed0 = AtomParticipant.new(
-    #         20,
+    #         20,                          # no more than 20 entries are kept
     #         """
     #         <p>
     #             <h1>${f:colour}</h1>
     #         </p>
-    #         """)
-    # </tt>
+    #         """)                         # the template for each entry
+    #
+    # The template can be passed as the second parameter (after the max entry
+    # count) or as a block :
+    #
+    #     feed1 = AtomParticipant.new(20) do |flow_expression, atom_participant, workitem|
+    #         #
+    #         # usually only the workitem parameter is used
+    #         # but the other two allow for advanced tricks...
+    #
+    #         atom_participant.content_type = "xml"
+    #             # by default, it's "xhtml"
+    #
+    #         s = "<task>"
+    #         s << "<name>#{workitem.task_name}</name>"
+    #         s << "<assignee>#{workitem.task_assignee}</assignee>"
+    #         s << "<duedate>#{workitem.task_duedate}</duedate>"
+    #         s << "</task>"
+    #
+    #         # the block is supposed to 'return' a string which is the
+    #         # effective template
+    #     end
+    #
+    # This participant uses 
+    # "atom-tools" from http://code.necronomicorp.com/trac/atom-tools
+    #
     #
-    class AtomParticipant < LocalParticipant
-        include MonitorMixin
+    class AtomParticipant
+        include LocalParticipant, MonitorMixin
 
         attr_accessor \
             :content_type       # blocks may manipulate them

data/lib/openwfe/participants/enoparticipant.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, Alain Hoang, OpenWFE.org
+# Copyright (c) 2007, Alain Hoang and John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -36,19 +36,59 @@
 # "made in Japan"
 #
 # Alain Hoang at openwfe.org
+# John Mettraux at openwfe.org
 #
 
 require 'net/smtp'
 
-module OpenWFE
+require 'openwfe/participants/participant'
+
 
+module OpenWFE
 
     #
     # This participant is used to send an email notification
-    class EmailNotificationParticipant < LocalParticipant
+    #
+    #     @engine.register_participant(
+    #         'eno', 
+    #         EmailNotificationParticipant.new(
+    #             "googlemail.l.google.com",
+    #             25,
+    #             "eno@outoftheblue.co.jp",
+    #             """Subject: test 0
+    #
+    #     0 : ${r:Time.new}
+    #     1 : ${f:customer_name}
+    #             """))
+    #
+    # And then, from the process definition :
+    #
+    #     class TestDefinition0 < OpenWFE::ProcessDefinition
+    #         def make
+    #             process_definition :name => "test0", :revision => "0" do
+    #                 sequence do
+    #                     set :field => 'email_target' do
+    #                         "whatever56x56@gmail.com"
+    #                     end
+    #                     set :field => 'customer_name' do
+    #                         "Monsieur Toto"
+    #                     end
+    #                     participant :ref => 'eno'
+    #                     print "ok"
+    #                 end
+    #             end
+    #         end
+    #     end
+    #
+    # TODO #8426 : use a block to define template
+    #
+    class EmailNotificationParticipant 
+        include LocalParticipant
 
+        #
         # Create a new email notification participant.  Requires
         # a mail server, port, a from address, and a mail message template
+        #
         def initialize (smtp_server, smtp_port, from_address, template)
             @smtp_server = smtp_server
             @smtp_port = smtp_port

data/lib/openwfe/participants/participant.rb

@@ -50,7 +50,6 @@ module OpenWFE
     # other pieces of code may easily 'mix it in'.
     #
     module Participant
-        include Contextual
 
         #
         # A participant will be receiving workitems via this method.
@@ -59,6 +58,10 @@ module OpenWFE
         # items will be fed to this cancel() and not to consume().
         #
         def consume (workitem)
+
+            raise NotImplementedError.new(
+                "implementation for method consume() "+
+                "is missing in class '#{self.class}'")
         end
 
         #
@@ -66,6 +69,14 @@ module OpenWFE
         #
         #def cancel (cancelitem)
         #end
+    end
+
+    #
+    # Local participants provide handy methods like reply_to_engine() to
+    # further implementations of the Participant concept.
+    #
+    module LocalParticipant
+        include Participant, Contextual, Logging, OwfeServiceLocator
 
         #
         # Returns the FlowExpression instance that triggered this
@@ -79,6 +90,15 @@ module OpenWFE
             @application_context[S_EXPRESSION_POOL]\
                 .fetch_expression(workitem.flow_expression_id)
         end
+
+        #
+        # Participants use this method to reply to their engine when
+        # their job is done.
+        #
+        def reply_to_engine (workitem)
+
+            get_engine.reply(workitem)
+        end
     end
 
 end

data/lib/openwfe/participants/participantmap.rb

@@ -41,6 +41,7 @@
 
 require 'openwfe/workitem'
 require 'openwfe/service'
+require 'openwfe/participants/participants'
 
 include OpenWFE
 
@@ -76,9 +77,10 @@ module OpenWFE
                 participant = BlockParticipant.new(block)
             end
 
-            regex = Regexp.new(regex) if not regex.kind_of? Regexp
+            regex = Regexp.new(regex.to_s) unless regex.kind_of? Regexp
 
-            participant.application_context = @application_context
+            participant.application_context = @application_context \
+                if participant.respond_to? :application_context=
 
             @participants << [ regex, participant ]
         end

data/lib/openwfe/participants/participants.rb

@@ -39,7 +39,6 @@
 # John Mettraux at openwfe.org
 #
 
-require 'openwfe/rudefinitions'
 require 'openwfe/participants/participant'
 
 
@@ -48,16 +47,13 @@ require 'openwfe/participants/participant'
 #
 module OpenWFE
 
-    class LocalParticipant
-        include Participant, OwfeServiceLocator
-
-        def reply_to_engine (workitem)
-
-            get_expression_pool.reply(workitem.last_expression_id, workitem)
-        end
-    end
-
-    class PrintParticipant < LocalParticipant
+    #
+    # The PrintParticipant will just emit its name to the
+    # test tracer if any or to stdout else.
+    # Used by some unit tests.
+    #
+    class PrintParticipant 
+        include LocalParticipant
 
         def consume (workitem)
 
@@ -77,16 +73,15 @@ module OpenWFE
     # This participant is used by the register_participant() method of
     # Engine class.
     #
-    # <tt>
-    # engine.register_participant("the_boss") do |workitem|
-    #     puts "the boss received a workitem"
-    # end
-    # </tt>
+    #     engine.register_participant("the_boss") do |workitem|
+    #         puts "the boss received a workitem"
+    #     end
     #
     # After the block executes, the BlockParticipant immediately replies
     # to the engine.
     #
-    class BlockParticipant < LocalParticipant
+    class BlockParticipant 
+        include LocalParticipant
 
         def initialize (block)
             @block = block