openwferu 0.9.9 → 0.9.10

data/lib/openwfe/participants/participantmap.rb

@@ -41,6 +41,7 @@
 
 require 'openwfe/workitem'
 require 'openwfe/service'
+require 'openwfe/util/observable'
 require 'openwfe/participants/participants'
 
 include OpenWFE
@@ -52,6 +53,7 @@ module OpenWFE
     # A very simple directory of participants
     #
     class ParticipantMap < Service
+        include Observable
 
         attr_accessor \
             :participants
@@ -60,6 +62,8 @@ module OpenWFE
             super(service_name, application_context)
 
             @participants = []
+
+            @observers = {}
         end
 
         #
@@ -167,12 +171,21 @@ module OpenWFE
 
             workitem.participant_name = participant_name
 
-            if workitem.kind_of? CancelItem and participant.respond_to? :cancel
+            if (workitem.kind_of?(CancelItem) and 
+                participant.respond_to?(:cancel))
+
                 participant.cancel(workitem)
+
+                onotify :dispatch, :cancel, workitem
+
                 return
             end
 
+            onotify :dispatch, :before_consume, workitem
+
             participant.consume(workitem)
+
+            onotify :dispatch, :after_consume, workitem
         end
     end
 

data/lib/openwfe/rest/definitions.rb

@@ -67,7 +67,8 @@ module OpenWFE
     E_LONG = 'long'
     E_DOUBLE = 'double'
 
-    E_XML = 'raw-xml'
+    E_RAW_XML = 'raw-xml'
+    E_XML_DOCUMENT = 'xml-document'
     E_BASE64 = 'base64'
 
     E_LIST = 'list'

data/lib/openwfe/rest/xmlcodec.rb

@@ -37,6 +37,7 @@
 # "hecho en Costa Rica"
 #
 
+require 'base64'
 require 'rexml/document'
 
 require 'openwfe/utils'
@@ -62,7 +63,11 @@ module OpenWFE
 
             if xmlElt.kind_of? String
 
-                xmlElt = REXML::Document.new(xmlElt)
+                xmlElt = REXML::Document.new(
+                    xmlElt, 
+                    :compress_whitespace => :all,
+                    :ignore_whitespace_nodes => :all)
+
                 xmlElt = xmlElt.root
             end
 
@@ -145,7 +150,7 @@ module OpenWFE
                 launchable.url = xmlElt.attributes[URL]
                 launchable.engine_id = xmlElt.attributes[ENGINE_ID]
 
-                return launchable
+                launchable
             end
 
 
@@ -210,7 +215,7 @@ module OpenWFE
                 #puts " ... fei.expressionName is >#{fei.expressionName}<"
                 #puts " ... fei.wfid is >#{fei.workflowInstanceId}<"
 
-                return fei
+                fei
             end
 
 
@@ -221,20 +226,30 @@ module OpenWFE
                 #
                 # atomic types
 
-                return xmlElt.text if xmlElt.name == E_STRING
-                return Integer(xmlElt.text) if xmlElt.name == E_INTEGER
-                return Integer(xmlElt.text) if xmlElt.name == E_LONG
-                return Float(xmlElt.text) if xmlElt.name == E_DOUBLE
-                return parse_boolean(xmlElt.text) if xmlElt.name == E_BOOLEAN
-
-                return xmlElt if xmlElt.name == E_XML
-
-                return Base64Attribute.new(xmlElt.txt) if xmlElt.name == E_BASE64
+                return xmlElt.text \
+                    if xmlElt.name == E_STRING
+                return Integer(xmlElt.text) \
+                    if xmlElt.name == E_INTEGER
+                return Integer(xmlElt.text) \
+                    if xmlElt.name == E_LONG
+                return Float(xmlElt.text) \
+                    if xmlElt.name == E_DOUBLE
+                return parse_boolean(xmlElt.text) \
+                    if xmlElt.name == E_BOOLEAN
+
+                return decode_xmldocument(xmlElt) \
+                    if xmlElt.name == E_XML_DOCUMENT
+                return xmlElt.children[0] \
+                    if xmlElt.name == E_RAW_XML
+
+                return Base64Attribute.new(xmlElt.text) \
+                    if xmlElt.name == E_BASE64
 
                 #
                 # composite types
 
-                return decode_list(xmlElt) if xmlElt.name == E_LIST
+                return decode_list(xmlElt) \
+                    if xmlElt.name == E_LIST
 
                 if xmlElt.name == E_SMAP or xmlElt.name == E_MAP
 
@@ -258,6 +273,12 @@ module OpenWFE
                     OpenWFE.xmldoc_to_string(xmlElt.document())
             end
 
+            def decode_xmldocument (xmlElt)
+
+                s = Base64::decode64 xmlElt.text.strip
+                REXML::Document.new s
+            end
+
             def decode_entry (xmlElt, map)
 
                 key = xmlElt.elements[1]
@@ -452,25 +473,27 @@ module OpenWFE
                 #puts "encodeAttribute() att.class is #{att.class}"
 
                 return encode_atomicattribute(E_STRING, att) \
-                    if att.kind_of? String
+                    if att.kind_of?(String)
                 return encode_atomicattribute(E_INTEGER, att) \
-                    if att.kind_of? Fixnum
+                    if att.kind_of?(Fixnum)
                 return encode_atomicattribute(E_DOUBLE, att) \
-                    if att.kind_of? Float
+                    if att.kind_of?(Float)
 
+                return encode_xmldocument(att) \
+                    if att.kind_of?(REXML::Document)
                 return encode_xmlattribute(att) \
-                    if att.kind_of? REXML::Element
+                    if att.kind_of?(REXML::Element)
 
                 return encode_atomicattribute(E_BOOLEAN, true) \
-                    if att.kind_of? TrueClass
+                    if att.kind_of?(TrueClass)
                 return encode_atomicattribute(E_BOOLEAN, false) \
-                    if att.kind_of? FalseClass
+                    if att.kind_of?(FalseClass)
 
                 return encode_base64attribute(att) \
-                    if att.kind_of? Base64Attribute
+                    if att.kind_of?(Base64Attribute)
 
-                return encode_mapattribute(att) if att.kind_of? Hash
-                return encode_listattribute(att) if att.kind_of? Array
+                return encode_mapattribute(att) if att.kind_of?(Hash)
+                return encode_listattribute(att) if att.kind_of?(Array)
 
                 #
                 # default
@@ -482,18 +505,24 @@ module OpenWFE
                 #    "Cannot encode attribute of class '#{att.class}'"
             end
 
+            def encode_xmldocument (elt)
+
+                e = REXML::Element.new(E_XML_DOCUMENT)
+                e.text = Base64::encode64(elt.to_s)
+                e
+            end
 
             def encode_xmlattribute (elt)
 
-                return elt if elt.name == E_XML
+                return elt if elt.name == E_RAW_XML
 
                 #
                 # else, wrap within <raw-xml>...</raw-xml>
 
-                e = REXML::Element.new(E_XML)
+                e = REXML::Element.new(E_RAW_XML)
                 e << elt
 
-                return e
+                e
             end
 
 
@@ -502,7 +531,7 @@ module OpenWFE
                 e = REXML::Element.new(E_BASE64)
                 e.text = att.content
 
-                return e
+                e
             end
 
 
@@ -512,7 +541,7 @@ module OpenWFE
                 #elt << REXML::Text.new(value.to_s())
                 elt.add_text(value.to_s())
 
-                return elt
+                elt
             end
 
 

data/lib/openwfe/util/kotoba.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux OpenWFE.org
+# Copyright (c) 2007, John Mettraux OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -53,7 +53,7 @@
 #
 # Kotoba is meant to be used for generating human readable (or more
 # easily rememberable) identifiers. Its first usage is within the 
-# OpenWFEru Ruby workflow and bpm engine for generating 'kawai' 
+# OpenWFEru Ruby workflow and bpm engine for generating 'kawaii' 
 # business process intance ids.
 #
 # == Kotoba from the command line

data/lib/openwfe/util/workqueue.rb

@@ -0,0 +1,177 @@
+#
+#--
+# 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$
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'thread'
+require 'openwfe/utils'
+
+
+module OpenWFE
+
+    module WorkqueueMixin
+
+        WQF_LOW = 0.500
+
+        #
+        # Starts the workqueue with a given frequency (seconds)
+        #
+        def start_workqueue
+
+            @workqueue_mutex = Mutex.new
+            @workqueue = []
+            @workqueue_frequency = 0
+
+            OpenWFE::call_in_thread "expression_pool", self do
+                while true
+                    sleep @workqueue_frequency
+                    break if @workqueue_frequency == nil
+                    do_process_workqueue
+                end
+            end
+        end
+
+        #
+        # Returns true if there is or there just was activity for the ]
+        # work queue.
+        #
+        def is_workqueue_busy?
+            (@workqueue.size > 0 or @workqueue_frequency < WQF_LOW)
+        end
+
+        #
+        # Stops the workqueue.
+        #
+        def stop_workqueue
+            @workqueue_frequency = nil
+            do_process_workqueue
+        end
+
+        #
+        # the method called by the mixer to actually queue the work.
+        #
+        def queue_work (*args)
+            @workqueue_mutex.synchronize do
+
+                if @workqueue
+                    @workqueue.push args
+                        #
+                        # work will be done later (millisec order)
+                        # by the work thread
+                else
+                    do_process_workelement args
+                        #
+                        # degraded mode : as if there were no workqueue
+                end
+            end
+        end
+
+        #
+        # Returns the current workqueue size
+        #
+        def workqueue_size
+            return 0 unless @workqueue
+            @workqueue.size
+        end
+
+        #
+        # Called by the workqueue thread, copies the workqueue and clears
+        # it, and then processes the elt in the copied workqueue.
+        # (meanwhile, the empty workqueue gets filled by queue_work() 
+        # calls)
+        #
+        # This method calls the do_process_workelement() method of
+        # its 'mixer' with each work element queued.
+        #
+        def do_process_workqueue
+
+            q = nil
+
+            @workqueue_mutex.synchronize do
+
+                if @workqueue.size < 1
+                    increment_workqueue_frequency
+                    return
+                end
+
+                q = Array.new(@workqueue)
+                @workqueue.clear
+
+                @workqueue_frequency = 0
+                    #
+                    # back to maximum reponsiveness
+            end
+
+            #ldebug { "do_process_workqueue() #{q.size} items to process" }
+
+            q.each do |elt|
+                begin
+
+                    do_process_workelement elt
+
+                rescue Exception => e
+
+                    lwarn do
+                        "#{self.service_name} caught an exception\n" + 
+                        OpenWFE::exception_to_s(e)
+                    end
+                end
+            end
+        end
+
+        protected
+
+            #
+            # No activity spotted, so decrease responsiveness
+            #
+            def increment_workqueue_frequency
+
+                return if @workqueue_frequency == nil
+
+                @workqueue_frequency *= 3
+
+                if @workqueue_frequency == 0
+                    @workqueue_frequency = 0.001
+                elsif @workqueue_frequency > WQF_LOW
+                    @workqueue_frequency = WQF_LOW
+                end
+            end
+    end
+end
+

data/lib/openwfe/utils.rb

@@ -112,27 +112,34 @@ module OpenWFE
 
         return nil if object == nil
 
-        return object if object.kind_of? Float
-        return object if object.kind_of? Fixnum
-        return object if object.kind_of? TrueClass
-        return object if object.kind_of? FalseClass
+        return object if object.kind_of?(Float)
+        return object if object.kind_of?(Fixnum)
+        return object if object.kind_of?(TrueClass)
+        return object if object.kind_of?(FalseClass)
 
-        return object.dup if object.kind_of? String
+        return object.dup if object.kind_of?(String)
 
         #return deep_clone(object) if object.kind_of? REXML::Document
-        return REXML::Document.new(object.to_s) \
-            if object.kind_of? REXML::Document
+        
+        #return REXML::Document.new(object.to_s) \
+        #    if object.kind_of? REXML::Document
+
+        if object.kind_of?(REXML::Element)
+            d = REXML::Document.new object.to_s
+            return d if object.kind_of?(REXML::Document)
+            return d.root
+        end
 
         o = object.class.new
 
         #
         # some kind of collection ?
 
-        if object.kind_of? Array
+        if object.kind_of?(Array)
             object.each do |i|
                 o << fulldup(i)
             end
-        elsif object.kind_of? Hash
+        elsif object.kind_of?(Hash)
             object.each do |k, v|
                 o[copy(k)] = fulldup(v)
             end
@@ -158,7 +165,7 @@ module OpenWFE
             end
         end
 
-        return o
+        o
     end
 
     def OpenWFE.to_underscore (string)
@@ -195,7 +202,7 @@ module OpenWFE
             return URI::parse(string)
         rescue Exception => e
         end
-        return nil
+        nil
     end
 
     #
@@ -209,7 +216,7 @@ module OpenWFE
         #
         return false unless string
         return false if string.length < start.length
-        return string[0, start.length] == start
+        string[0, start.length] == start
     end
 
     #
@@ -218,7 +225,7 @@ module OpenWFE
     def OpenWFE.ends_with (string, _end)
         return false unless string
         return false if string.length < _end.length
-        return string[-_end.length..-1] == _end
+        string[-_end.length..-1] == _end
     end
 
     #
@@ -254,6 +261,8 @@ module OpenWFE
     #         raw_expression.apply(wi)
     #     end
     #
+    # Returns the new thread instance.
+    #
     def OpenWFE.call_in_thread (caller_name, caller_object=nil, &block)
 
         return unless block
@@ -262,10 +271,12 @@ module OpenWFE
             begin
                 #$SAFE = safe_level
                     #
+                    # (note)
                     # doesn't work : the block inherits the safety level
                     # of its surroundings, it's a closure, ne ?
 
                 block.call
+
             rescue Exception => e
                 msg = "#{caller_name} caught an exception\n" + exception_to_s(e)
                 if caller_object and caller_object.respond_to? :lwarn
@@ -370,6 +381,34 @@ module OpenWFE
         return has_attribute?(rest, key)
     end
 
+    #
+    # Returns a list of lines matching the pattern in the given file.
+    #
+    # This is also possible :
+    #
+    #     OpenWFE::grep "^..) ", "path/to/file.txt" do |line|
+    #         puts " - '#{line.downcase}'"
+    #     end
+    #
+    def OpenWFE.grep (pattern, filepath, &block)
+
+        result = []
+        r = Regexp.new pattern
+
+        File.open filepath do |file|
+            file.readlines.each do |l|
+                if r.match l
+                    if block
+                        block.call l
+                    else
+                        result << l
+                    end
+                end
+            end
+        end
+        result unless block
+    end
+
     #
     # This method is used within the InFlowWorkItem and the CsvTable classes.
     #

data/lib/openwfe/version.rb

@@ -34,5 +34,5 @@
 #
 
 module OpenWFE
-    OPENWFERU_VERSION = '0.9.9'
+    OPENWFERU_VERSION = '0.9.10'
 end

data/lib/openwfe/worklist/storeparticipant.rb

@@ -39,6 +39,7 @@
 #
 
 require 'openwfe/utils'
+require 'openwfe/omixins'
 require 'openwfe/rudefinitions'
 require 'openwfe/storage/yamlfilestorage'
 require 'openwfe/participants/participant'
@@ -65,6 +66,7 @@ module OpenWFE
     #
     module StoreParticipantMixin
         include LocalParticipant
+        include FeiMixin
 
         #def initialize ()
         #end
@@ -132,9 +134,10 @@ module OpenWFE
         # identifier.
         #
         def delete (wi_or_fei)
-            fei = wi_or_fei
-            fei = fei.fei if fei.is_a? InFlowWorkItem
-            super fei
+            #fei = wi_or_fei
+            #fei = fei.fei if fei.is_a? InFlowWorkItem
+            #super fei
+            super extract_fei(wi_or_fei)
         end
 
         #
@@ -159,7 +162,7 @@ module OpenWFE
                     if (not workflow_instance_id) or workitem.fei.parent_wfid == workflow_instance_id
             end
 
-            return result
+            result
         end
 
         #

data/test/fei_test.rb

@@ -9,9 +9,10 @@
 
 require 'test/unit'
 require 'rutest_utils'
+#require 'openwfe/owfe'
 require 'openwfe/workitem'
 require 'openwfe/flowexpressionid'
-#require 'openwfe/rudefinitions'
+require 'openwfe/rudefinitions'
 
 
 class FeiTest < Test::Unit::TestCase
@@ -131,6 +132,16 @@ class FeiTest < Test::Unit::TestCase
             "failure 1"
     end
 
+    #def test_to_fei
+    #    fei = new_fei
+    #    wi = OpenWFE::InFlowItem.new
+    #    wi.last_expression_id = fei
+    #    assert_nil OpenWFE::to_fei(nil)
+    #    assert_equal fei, OpenWFE::to_fei(fei)
+    #    assert_equal fei, OpenWFE::to_fei(wi)
+    #    assert_equal fei, OpenWFE::to_fei(fei.to_s)
+    #end
+
     protected
 
         def puts_hash (h)