openwferu 0.9.5 → 0.9.6

data/lib/openwfe/expool/expstorage.rb

@@ -58,6 +58,14 @@ module OpenWFE
     class CacheExpressionStorage
         include ServiceMixin, OwfeServiceLocator
 
+        #
+        # under 20 stored expressions, the unit tests for the 
+        # CachedFilePersistedEngine do fail because the persistent storage
+        # behind the cache hasn't the time to flush its work queue.
+        # a min size limit has been set to 77.
+        #
+        MIN_SIZE = 77
+
         DEFAULT_SIZE = 5000
 
         def initialize (service_name, application_context)
@@ -68,6 +76,7 @@ module OpenWFE
 
             size = @application_context[:expression_cache_size]
             size = DEFAULT_SIZE unless size
+            size = MIN_SIZE unless size > MIN_SIZE
 
             linfo { "new() size is #{size}" }
 
@@ -100,7 +109,10 @@ module OpenWFE
 
             fe = get_real_storage[fei]
 
-            return nil unless fe
+            unless fe
+                #ldebug { "[] (reload) miss for #{fei.to_debug_s}" }
+                return nil 
+            end
 
             @cache[fei] = fe
 
@@ -137,17 +149,35 @@ module OpenWFE
         end
 
         def each (&block)
-            @cache.each do |k, v|
-                block.call(k, v)
-            end
+            #@cache.each do |k, v|
+            #    block.call(k, v)
+            #end
+            @cache.each(&block)
+        end
+
+        #
+        # This each() just delegates to the real storage each() method.
+        #
+        def real_each (&block)
+            #@cache.each do |k, v|
+            #    block.call(k, v)
+            #end
+            get_real_storage.each(&block)
         end
 
+        #
+        # Displays a human-friendly view on this storage
+        #
         def to_s
             expstorage_to_s(self)
         end
 
         protected
 
+            #
+            # Returns the "real storage" i.e. the storage that does the real
+            # persistence behind this "cache storage".
+            #
             def get_real_storage
 
                 return @real_storage if @real_storage
@@ -197,6 +227,8 @@ module OpenWFE
         def to_s
             expstorage_to_s(self)
         end
+
+        alias :real_each :each
         
     end
 

data/lib/openwfe/expool/yamlexpstorage.rb

@@ -136,6 +136,14 @@ module OpenWFE
             end
         end
 
+        def each (&block)
+            each_object do |flow_expression|
+                block.call(flow_expression.fei, flow_expression)
+            end
+        end
+
+        alias :real_each :each
+
         def to_s
 
             s = "\n\n==== #{self.class} ===="
@@ -237,6 +245,16 @@ module OpenWFE
             super
         end
 
+        #
+        # calls process_queue() before the call the super class each()
+        # method
+        #
+        def each (&block)
+
+            process_queue()
+            super
+        end
+
         protected
 
             def start_processing_thread

data/lib/openwfe/expressions/environment.rb

@@ -125,7 +125,7 @@ module OpenWFE
 
             @variables.each do |key, value|
 
-                ldebug { "unbind() '#{key}' => #{value.class}" }
+                #ldebug { "unbind() '#{key}' => #{value.class}" }
 
                 if value.kind_of? FlowExpressionId
                     get_expression_pool().remove(value)

data/lib/openwfe/expressions/fe_misc.rb

@@ -39,6 +39,7 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/util/safe'
 require 'openwfe/expressions/flowexpression'
 require 'openwfe/expressions/fe_utils'
 
@@ -77,10 +78,18 @@ module OpenWFE
     # <reval/>
     #
     # Evals some Ruby code contained within the process definition 
-    # or within the workitem
+    # or within the workitem.
+    # 
+    # The code is evaluated at a SAFE level of 1.
     #
     class RevalExpression < FlowExpression
 
+        #
+        # See for an explanation on Ruby safety levels :
+        # http://www.rubycentral.com/book/taint.html
+        #
+        SAFETY_LEVEL = 3
+
         def apply (workitem)
 
             escape = lookup_boolean_attribute('escape', workitem, false)
@@ -90,7 +99,10 @@ module OpenWFE
             code = OpenWFE::fetch_text_content(self, workitem, escape) \
                 unless code
 
-            result = eval(code.to_s)
+            code = code.to_s
+
+            #result = eval(code)
+            result = OpenWFE::eval_safely(code, SAFETY_LEVEL, binding())
 
             OpenWFE::set_result(workitem, result) \
                 if result != nil  # 'false' is a valid result

data/lib/openwfe/expressions/fe_raw.rb

@@ -55,9 +55,6 @@ module OpenWFE
     #
     class RawExpression < FlowExpression
 
-        #attr_accessor \
-        #    :raw_representation
-
         def initialize \
             (fei, parent_id, env_id, application_context, raw_representation)
 
@@ -65,7 +62,9 @@ module OpenWFE
 
             @raw_representation = raw_representation
 
-            new_environment() if not @environment_id
+            #new_environment() if not @environment_id
+                #
+                # now done in the launch methods of the expression pool
         end
 
         def instantiate_real_expression \
@@ -139,6 +138,8 @@ module OpenWFE
             expression = instantiate_real_expression(
                 workitem, exp_class, attributes)
 
+            expression.apply_time = OpenWFE::now()
+
             expression.apply(workitem)
         end
 
@@ -172,20 +173,35 @@ module OpenWFE
                 #pp attributes
                 #pp lookup_attributes(workitem, attributes)
 
+                # TODO : do not use extract_children() !!!!!!!!
+                #self.children = extract_children()
+                #params = lookup_attributes(workitem)
+                #text = OpenWFE::fetch_text_content(self, workitem, false)
+                #params["0"] = text if text
+
+                params = lookup_attributes(workitem)
+
+                extract_text_children.each_with_index do |value, index|
+                    params[index.to_s] = value
+                end
+
                 get_expression_pool().launch_template(
                     self, 
                     0,
                     template, 
                     workitem, 
-                    lookup_attributes(workitem))
+                    params)
             end
 
-            #def extract_attributes ()
-            #    raise "abstract method : not implemented here"
-            #end
-            #def extract_children ()
-            #    raise "abstract method : not implemented here"
-            #end
+            def extract_attributes ()
+                raise NotImplementedError.new("'abstract method' sorry")
+            end
+            def extract_children ()
+                raise NotImplementedError.new("'abstract method' sorry")
+            end
+            def extract_text_children ()
+                raise NotImplementedError.new("'abstract method' sorry")
+            end
     end
 
 end

data/lib/openwfe/expressions/fe_subprocess.rb

@@ -39,6 +39,9 @@
 # John Mettraux at openwfe.org
 #
 
+#require 'uri'
+
+require 'openwfe/utils'
 require 'openwfe/expressions/fe_utils'
 
 
@@ -65,6 +68,19 @@ module OpenWFE
     #     
     #     </process-definition>
     #
+    # It's totally OK to have URLs as referenced processes :
+    #
+    #     require 'openwfe/def'
+    #
+    #     class AnotherDefinition0 < OpenWFE::ProcessDefinition
+    #         def make
+    #             sequence do
+    #                 participant ref => "toto"
+    #                 subprocess ref => "http://company.process.server/def0.rb"
+    #             end
+    #         end
+    #     end
+    #
     class SubProcessRefExpression < FlowExpression
 
         #
@@ -74,14 +90,20 @@ module OpenWFE
 
             ref = OpenWFE::lookup_ref(self, workitem)
 
-            raise "'subprocess' expression misses a 'ref', 'field-ref' or 'variable-ref' attribute" if not ref
+            raise "'subprocess' expression misses a 'ref', 'field-ref' or 'variable-ref' attribute" unless ref
+
+            template_uri = parse_uri(ref)
 
-            template_fei = lookup_variable(ref)
+            template = if template_uri
+                template_uri
+            else
+                lookup_variable(ref)
+            end
 
             #template_fei = lookup_participant(ref) if not template_fei
 
             raise "did not find any subprocess named '#{ref}'" \
-                if not template_fei
+                if not template
 
             forget = lookup_boolean_attribute(:forget, workitem)
 
@@ -90,22 +112,33 @@ module OpenWFE
 
             params = lookup_attributes(workitem)
 
-            #puts " ... params are #{params.to_s}"
+            text = OpenWFE::fetch_text_content(self, workitem, false)
+            params["0"] = text if text
+
+            #puts " ... params are #{params.keys.join(', ')}"
 
             get_expression_pool()\
-                .launch_template(requester, 0, template_fei, workitem, params)
+                .launch_template(requester, 0, template, workitem, params)
         end
 
         #def reply (workitem)
         #end
 
-        #protected
-        #    def lookup_participant (ref)
-        #        participant = get_participant_map.lookup_participant(ref)
-        #        return nil unless participant
-        #        #
-        #        # builds a participant expression on the fly
-        #    end
+        protected
+
+            def parse_uri (ref)
+
+                uri = OpenWFE::parse_uri(ref)
+
+                return nil unless uri
+
+                return uri if uri.scheme == "http"
+                return uri if uri.scheme == "https"
+                return uri if uri.scheme == "ftp"
+                    # what else ...
+
+                return nil
+            end
     end
 
 end

data/lib/openwfe/expressions/fe_utils.rb

@@ -65,7 +65,7 @@ module OpenWFE
         end
 
         text = dosub(text, expression, workitem) \
-            if not escape
+            unless escape
 
         return text
     end

data/lib/openwfe/expressions/flowexpression.rb

@@ -183,7 +183,11 @@ module OpenWFE
         #
         def owns_its_environment? ()
 
-            #ldebug { "owns_its_environment?()  #{@fei.to_debug_s}" }
+            #ldebug do 
+            #    "owns_its_environment?()\n" +
+            #    "    #{@fei.to_debug_s}\n" +
+            #    "    #{@environment_id.to_debug_s}"
+            #end
 
             return false if not @environment_id
 

data/lib/openwfe/expressions/raw_prog.rb

@@ -55,7 +55,9 @@ module OpenWFE
 
         attr_reader \
             :name, 
-            :attributes,
+            :attributes
+
+        attr_accessor \
             :children
 
         def initialize (name, attributes)
@@ -75,7 +77,7 @@ module OpenWFE
         #
         # Always return the ProgRawExpression class.
         #
-        def rawExpressionClass
+        def raw_expression_class
             return ProgRawExpression
         end
 
@@ -175,29 +177,14 @@ module OpenWFE
     #
     class ProcessDefinition
 
+        attr_reader :top_expressions
+
         #def initialize (exp_names=nil)
         def initialize ()
 
             super()
 
-            #if not exp_names
-            #    exp_names = $EXPRESSION_NAMES if $EXPRESSION_NAMES
-            #else
-            #    if exp_names.kind_of? ExpressionMap
-            #        exp_names = exp_names.expression_names
-            #    elsif exp_names.kind_of? Engine
-            #        exp_names = exp_names.get_expression_map.expression_names
-            #    elsif exp_names.kind_of? Hash
-            #        exp_names = exp_names[S_EXPRESSION_MAP].expression_names
-            #    elsif not exp_names.kind_of? Array
-            #        exp_names = $EXPRESSION_NAMES
-            #    end
-            #end
-            #if not exp_names
-            #    raise "no expression names found, please provide them"
-            #end
-            #@exp_names = exp_names
-
+            @top_expressions = []
             @previous_parent_expression = []
         end
 
@@ -207,16 +194,9 @@ module OpenWFE
 
             expname = OpenWFE.to_expression_name(methodname)
 
-            #if not @exp_names.include? expname
-            #    #raise "No expression named '#{methodname}' (#{expname}) found"
-            #    #raise "No expression named '#{expname}' found"
-            #    params = args[0]
-            #    params = {} if not params
-            #    params["ref"] = methodname
-            #    return make_expression("subprocess", params, &block)
-            #end
+            args = pack_args(args)
 
-            make_expression(expname, args[0], &block)
+            make_expression(expname, args, &block)
         end
 
         #
@@ -250,8 +230,11 @@ module OpenWFE
             exp.children << string_child \
                 if string_child
 
-            @parent_expression << exp \
-                if @parent_expression
+            if @parent_expression
+                @parent_expression << exp
+            else
+                @top_expressions << exp
+            end
 
             return exp if not block
 
@@ -280,8 +263,66 @@ module OpenWFE
         # segment raw representation
         #
         def ProcessDefinition.do_make ()
-            self.new().make
+
+            pdef = self.new
+            exp = pdef.make
+
+            if pdef.top_expressions.size == 1 and \
+                exp.name == "process-definition"
+
+                return exp 
+            end
+
+            name, revision = extract_name_and_revision(pdef.class.name)
+            attributes = {}
+            attributes["name"] = name
+            attributes["revision"] = revision
+
+            top_expression = ProgExpRepresentation.new(
+                "process-definition", attributes)
+
+            top_expression.children = pdef.top_expressions
+
+            top_expression
         end
+
+        protected
+
+            def pack_args (args)
+                return args[0] if args.length == 1
+                a = {}
+                args.each_with_index do |arg, index|
+                    if arg.is_a? Hash
+                        a = a.merge(arg)
+                        break
+                    end
+                    a[index.to_s] = arg
+                end
+                a
+            end
+
+            def ProcessDefinition.extract_name_and_revision (s)
+
+                #puts "s is >#{s}<"
+
+                m = Regexp.compile(".*::([^0-9_]*)_*([0-9][0-9_]*)$").match(s)
+                return [ as_name(m[1]), as_revision(m[2]) ] if m
+
+                m = Regexp.compile(".*::(.*$)").match(s)
+                return [ as_name(m[1]), '0' ] if m
+
+                return [ as_name(s), '0' ]
+            end
+
+            def ProcessDefinition.as_name (s)
+
+                return s[0..-11] if s.match(".*Definition$")
+                return s
+            end
+
+            def ProcessDefinition.as_revision (s)
+                s.gsub("_", ".")
+            end
     end
 
     #
@@ -337,6 +378,13 @@ module OpenWFE
                     end
                 end
             end
+
+            def extract_text_children ()
+                raw_representation.children.collect do |child|
+                    next if child.is_a? ProgExpRepresentation
+                    child.to_s
+                end
+            end
     end
 
     private