openwferu 0.9.6 → 0.9.7

data/lib/openwfe/listeners/socketlisteners.rb

@@ -141,9 +141,10 @@ module OpenWFE
         def reply_to_socket (socket, result)
 
             socket.puts result.to_s
+            socket.puts
             socket.close_write
 
-            ldebug { "reply_to_socket() result is >>>#{result}<<<" }
+            #ldebug { "reply_to_socket() result is >#{result}<" }
         end
 
         #
@@ -165,9 +166,20 @@ module OpenWFE
 
                 linfo { "listen() listening on #{@server.addr.join('  ')}" }
 
-                while socket = @server.accept
+                while true
+
+                    socket = nil
+
+                    begin
+                        socket = @server.accept
+                    rescue Exception => e
+                        linfo { "listen() shut down '#{e}'" }
+                    end
+
+                    return unless socket
+
                     OpenWFE.call_in_thread(@service_name, self) do
-                        handle_socket(socket) if is_allowed? socket 
+                        handle_socket(socket) if socket and is_allowed? socket 
                     end
                 end
             end
@@ -221,7 +233,21 @@ module OpenWFE
                     end
                 end
 
-                result = get_engine.reply(wi)
+                result = nil
+
+                begin
+
+                    result = get_engine.reply(wi)
+
+                    ldebug { "handle_socket() result is >>#{result}<<" }
+
+                rescue Exception => e
+
+                    result = "ERROR\n\n"
+                    result << OpenWFE::exception_to_s(e)
+
+                    ldebug { "handle_socket() error reply :\n" + result }
+                end
 
                 reply_to_socket(socket, result)
 

data/lib/openwfe/logging.rb

@@ -40,7 +40,8 @@
 #
 
 require 'logger'
-require 'openwfe/rudefinitions'
+require 'openwfe/utils'
+#require 'openwfe/rudefinitions'
 
 
 module OpenWFE
@@ -74,6 +75,13 @@ module OpenWFE
             do_log(:unknown, message, &block)
         end
 
+        #
+        # A simplification of caller_to_s for direct usage when debugging
+        #
+        def ldebug_callstack (msg, max_lines=nil)
+            ldebug { "#{msg}\n" + OpenWFE::caller_to_s(9, max_lines) }
+        end
+
         private
 
             def do_log (level, message, &block)

data/lib/openwfe/participants/participants.rb

@@ -68,15 +68,15 @@ module OpenWFE
         #
         def initialize (context_or_dir=nil)
 
-            if context_or_dir.kind_of? Hash
-                @application_context = context_or_dir
-                @workdir = @application_context[:work_directory]
-            else
-                @workdir = context_or_dir
-            end
-
-            @workdir = OpenWFE::DEFAULT_WORK_DIRECTORY unless @workdir
-            @workdir = "#{@workdir}/out/"
+            #if context_or_dir.kind_of? Hash
+            #    @application_context = context_or_dir
+            #    @workdir = @application_context[:work_directory]
+            #else
+            #    @workdir = context_or_dir
+            #end
+            #@workdir = OpenWFE::DEFAULT_WORK_DIRECTORY unless @workdir
+            #@workdir = "#{@workdir}/out/"
+            @workdir = OpenWFE::get_work_directory(context_or_dir) + "/out/"
 
             @reply_anyway = false
         end

data/lib/openwfe/participants/socketparticipants.rb

@@ -41,8 +41,8 @@
 
 require 'yaml'
 require 'socket'
+require 'timeout'
 
-#require 'openwfe/utils'
 require 'openwfe/rest/xmlcodec'
 require 'openwfe/participants/participant'
 
@@ -80,19 +80,22 @@ module OpenWFE
 
         #
         # The method called by the engine for each incoming workitem.
+        # Will dispatch the workitem over a TCP connection.
         #
         def consume (workitem)
 
+            dispatch(workitem)
+        end
+
+        def dispatch (workitem)
+
             socket = TCPSocket.new(@host, @port)
             socket.puts encode_workitem(workitem)
+            socket.puts
             socket.close_write
 
-            reply = ""
-            while true
-                r = socket.gets
-                break unless r
-                reply << r
-            end
+            reply = fetch_reply(socket)
+
             socket.close
 
             decode_reply(reply)
@@ -108,7 +111,7 @@ module OpenWFE
         #
         def SocketParticipant.dispatch (host, port, workitem)
 
-            SocketParticipant.new(host, port).consume(workitem)
+            SocketParticipant.new(host, port).dispatch(workitem)
         end
 
         protected
@@ -127,6 +130,32 @@ module OpenWFE
             def decode_reply (r)
                 r
             end
+
+            #
+            # The code that waits for the reply from the server, nicely
+            # wrapped inside a timeout and a rescue block.
+            #
+            def fetch_reply (socket)
+
+                reply = ""
+
+                begin
+
+                    timeout(7) do
+                        while true
+                            r = socket.gets
+                            break unless r
+                            reply << r
+                        end
+                    end
+
+                rescue Exception => e
+                    puts e
+                    raise "timeout while waiting for reply"
+                end
+
+                reply
+            end
     end
 
     #
@@ -155,6 +184,10 @@ module OpenWFE
 
         protected
 
+            #
+            # This implementation encodes the workitem as an XML document.
+            # This is compatible with OpenWFEja.
+            #
             def encode_workitem (wi)
 
                 sxml = OpenWFE::xml_encode(wi)

data/lib/openwfe/rudefinitions.rb

@@ -37,6 +37,8 @@
 # "made in Japan"
 #
 
+require 'fileutils'
+
 require 'openwfe/utils'
 require 'openwfe/version'
 
@@ -50,6 +52,7 @@ module OpenWFE
 
     S_ENGINE = 'engine'
     S_EXPRESSION_MAP = 'expressionMap'
+    S_WFID_GENERATOR = 'wfidGenerator'
     S_EXPRESSION_POOL = 'expressionPool'
     S_EXPRESSION_STORAGE = 'expressionStorage'
     S_PARTICIPANT_MAP = 'participantMap'
@@ -70,6 +73,21 @@ module OpenWFE
 
     DEFAULT_WORK_DIRECTORY = './work'
 
+    #
+    # Returns the work directory for the OpenWFE[ru] application context
+    # (if any).
+    #
+    def OpenWFE.get_work_directory (dir=nil)
+
+        dir = DEFAULT_WORK_DIRECTORY unless @application_context
+        dir = @application_context[:work_directory] unless dir
+        dir = DEFAULT_WORK_DIRECTORY unless dir
+
+        FileUtils.makedirs(dir) unless File.exist?(dir)
+
+        dir
+    end
+
     #
     # A mixin for easy OpenWFE service lookup
     # (assumes the presence of an application context instance var)
@@ -85,6 +103,9 @@ module OpenWFE
         def get_expression_map
             return @application_context[S_EXPRESSION_MAP]
         end
+        def get_wfid_generator
+            return @application_context[S_WFID_GENERATOR]
+        end
         def get_expression_pool
             return @application_context[S_EXPRESSION_POOL]
         end

data/lib/openwfe/storage/yamlextras.rb

@@ -0,0 +1,115 @@
+#
+#--
+# 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 'yaml'
+
+
+module OpenWFE
+    
+    #
+    # reopening some classes in order to facilitate their
+    # yaml serialization
+    #
+    
+    #
+    # opening for tuning yaml persistence
+    #
+    class FlowExpression
+
+        def to_yaml_properties
+
+            l = super()
+
+            l.delete("@application_context")
+
+            l.delete("@timeout_job_id")
+            #l.delete("@scheduler_job_id")
+                # scheduler ids should not get persisted
+
+            return l
+        end
+    end
+
+    #
+    # making sure that the FlowExpressionId is serialized as a unique String
+    #
+    class FlowExpressionId
+
+        yaml_as "tag:ruby.yaml.org,2002:#{self}"
+
+        #def to_yaml (opts={})
+        #    @s = to_s
+        #    super
+        #end
+        #def to_yaml_properties
+        #    [ "@s" ]
+        #end
+
+        def to_yaml (opts={})
+            YAML::quick_emit(self.object_id, opts) do |out|
+                out.map(taguri) do |map|
+                    map.add("s", to_s)
+                end
+            end
+        end
+
+        def FlowExpressionId.yaml_new (klass, tag, val)
+            s = val["s"]
+            begin
+                FlowExpressionId.to_fei(s)
+            rescue Exception => e
+                raise "failed to decode FlowExpressionId out of '#{s}'"
+            end
+        end
+    end
+    
+    #
+    # opening for tuning yaml persistence
+    #
+    class XmlRawExpression
+        def to_yaml_properties
+            l = super()
+            l.delete("@raw_representation")
+            return l
+        end
+    end
+end    
+

data/lib/openwfe/storage/yamlfilestorage.rb

@@ -142,7 +142,10 @@ module OpenWFE
 
             fei_path = compute_file_path(fei)
             
-            return nil if not File.exist?(fei_path)
+            if not File.exist?(fei_path)
+                ldebug { "[] didn't find file at #{fei_path}" }
+                return nil 
+            end
 
             load_object(fei_path)
         end
@@ -151,7 +154,7 @@ module OpenWFE
         # Returns the count of objects currently stored in this instance.
         #
         def length
-            #return count_objects(0, @basepath)
+
             count_objects()
         end
 
@@ -161,8 +164,6 @@ module OpenWFE
 
             def load_object (path)
 
-                #data = IO.read(path)
-                #object = YAML.load(data)
                 object = YAML.load_file(path)
                 
                 object.application_context = @application_context \
@@ -171,10 +172,18 @@ module OpenWFE
                 object
             end
             
+            #
+            # Returns the number of 'objects' currently in this storage.
+            #
             def count_objects
+
                 count = 0
+
                 Find.find(@basepath) do |path|
+
+                    next unless File.exist? path
                     next if File.stat(path).directory?
+
                     count += 1 if OpenWFE::ends_with(path, ".yaml")
                 end
                 return count
@@ -184,11 +193,16 @@ module OpenWFE
             # Passes each object path to the given block
             #
             def each_object_path (&block)
+
                 return unless block
+
                 synchronize do
                     Find.find(@basepath) do |path|
+
+                        next unless File.exist? path
                         next if File.stat(path).directory?
                         next unless OpenWFE::ends_with(path, ".yaml")
+
                         ldebug { "each_object_path() considering #{path}" }
                         block.call path
                     end
@@ -212,6 +226,11 @@ module OpenWFE
 
             protected
                 
+                #
+                # Each object is meant to have a unique file path,
+                # this method wraps the determination of that path. It has to
+                # be provided by extending classes.
+                #
                 def compute_file_path (object)
                     raise NotImplementedError.new
                 end

data/lib/openwfe/util/csvtable.rb

@@ -107,6 +107,27 @@ module OpenWFE
     #         # will yield "Henry" who takes care of all the politics stuff,
     #         # except for Asia and America
     #
+    # '>', '>=', '<' and '<=' can be put in front of individual cell values :
+    #
+    #     table = CsvTable.new("""
+    #         ,
+    #         in:fx, out:fy
+    #         ,
+    #         >100,a
+    #         >=10,b
+    #         ,c
+    #     """)
+    #
+    #     h = { 'fx' => '10' }
+    #     table.transform(h)
+    #
+    #     require 'pp'; pp h
+    #         # will yield { 'fx' => '10', 'fy' => 'b' }
+    #
+    # Such comparisons are done after the elements are transformed to float
+    # numbers. By default, non-numeric arguments will get compared as Strings.
+    #
+    #
     # Disclaimer : the decision / CSV table system is no replacement for
     # full rule engines with forward and backward chaining, RETE implementation
     # and the like...
@@ -229,13 +250,15 @@ module OpenWFE
 
                     cell = OpenWFE::dosub(cell, fexp, wi)
 
-                    modifiers = 0
-                    modifiers += Regexp::IGNORECASE if @ignore_case
-
                     #puts "__does '#{value}' match '#{cell}' ?"
 
-                    rcell = Regexp.new(cell, modifiers)
-                    return false unless rcell.match(value)
+                    b = if cell[0, 1] == '<' or cell[0, 1] == '>'
+                        numeric_compare(value, cell)
+                    else
+                        regex_compare(value, cell)
+                    end
+
+                    return false unless b
                 end
 
                 #puts "__row matches"
@@ -243,6 +266,52 @@ module OpenWFE
                 return true
             end
 
+            def regex_compare (value, cell)
+
+                modifiers = 0
+                modifiers += Regexp::IGNORECASE if @ignore_case
+
+                rcell = Regexp.new(cell, modifiers)
+
+                rcell.match(value)
+            end
+
+            def numeric_compare (value, cell)
+
+                comparator = cell[0, 1]
+                comparator += "=" if cell[1, 1] == "="
+                cell = cell[comparator.length..-1]
+
+                nvalue = narrow(value)
+                ncell = narrow(cell)
+
+                if nvalue.is_a? String or ncell.is_a? String
+                    value = '"' + value + '"'
+                    cell = '"' + cell + '"'
+                else
+                    value = nvalue
+                    cell = ncell
+                end
+
+                s = "#{value} #{comparator} #{cell}"
+
+                #puts "...>>>#{s}<<<"
+
+                begin
+                    return OpenWFE::eval_safely(s, 4)
+                rescue Exception => e
+                    return false
+                end
+            end
+
+            def narrow (s)
+                begin
+                    return Float(s)
+                rescue Exception => e
+                    return s
+                end
+            end
+
             def resolve_in_header (in_header)
 
                 in_header = "f:#{in_header}" \
@@ -279,7 +348,8 @@ module OpenWFE
                     elsif type == "f"
                         wi.set_attribute(target, value)
                     elsif type == "r"
-                        instance_eval(value)
+                        #instance_eval(value)
+                        OpenWFE::instance_eval_safely(self, value, 3)
                     end
                 end
             end

data/lib/openwfe/util/dollar.rb

@@ -188,6 +188,11 @@ module OpenWFE
 
             def call_ruby (ruby_code)
 
+                if @flow_expression
+                    return "" \
+                        if @flow_expression.ac[:ruby_eval_allowed] != true
+                end
+
                 #binding = nil
                 #binding = @flow_expression.get_binding if @flow_expression
                 #eval(ruby_code, binding).to_s