openwferu 0.9.16 → 0.9.17

data/lib/openwfe/expool/expstorage.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, Nicolas Modryzk and John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, Nicolas Modryzk and John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -40,9 +40,11 @@
 
 require 'fileutils'
 
+#require 'rufus/lru'
+
 require 'openwfe/service'
-require 'openwfe/util/lru'
 require 'openwfe/flowexpressionid'
+require 'openwfe/rudefinitions'
 
 
 module OpenWFE
@@ -63,29 +65,107 @@ module OpenWFE
             end
             get_expression_pool.add_observer(:remove) do |channel, fei|
                 ldebug { ":delete  for #{fei}" }
-                self.delete(fei)
+                self.delete fei
             end
         end
 
+        #
+        # a human readable representation of the content of the expression
+        # storage.
+        #
+        # Warning : this will display the content of the real storage,
+        # (especially when called against a cache).
+        #
         def to_s
 
             s = "\n\n==== #{self.class} ===="
 
-            self.each do |k, v|
+            find_expressions.each do |fexp|
+
                 s << "\n"
-                if v.kind_of?(RawExpression)
+                if fexp.kind_of?(RawExpression)
                     s << "*raw" 
                 else
                     s << "  "
                 end
-                #s << v.to_s
-                s << v.fei.to_s
-                s << "    key/value mismatch !" if k != v.fei
+                s << fexp.fei.to_s
             end
             s << "\n==== . ====\n"
 
             s
         end
+
+        #
+        # This method is used by the various implementations of 
+        # find_expressions()
+        #
+        def does_match? (options, fexp_or_fei)
+
+            wfid = options[:wfid]
+            wfid_prefix = options[:wfid_prefix]
+            parent_wfid = options[:parent_wfid]
+
+            wfname = options[:wfname]
+            wfrevision = options[:wfrevision]
+
+            ic = options[:include_classes]
+            ec = options[:exclude_classes]
+            ic = Array(ic) if ic
+            ec = Array(ec) if ec
+
+            cs = options[:consider_subprocesses]
+
+            ap = options[:applied]
+
+            fexp, fei = if fexp_or_fei.is_a?(FlowExpressionId)
+                [ nil, fexp_or_fei ]
+            else
+                [ fexp_or_fei, fexp_or_fei.fei ]
+            end
+
+            #
+            # let's make it verbose...
+
+            if fexp
+                return false if (ap == true and not fexp.apply_time)
+                return false if (ap == false and fexp.apply_time)
+                return false unless class_accepted?(fexp, ic, ec)
+            end
+
+            return false \
+                if wfname and fei.wfname != wfname
+            return false \
+                if wfrevision and fei.wfrevision != wfrevision
+
+            return false \
+                if cs and fei.sub_instance_id != ""
+            return false \
+                if wfid and fei.wfid != wfid
+            return false \
+                if wfid_prefix and not fei.wfid.match("^#{wfid_prefix}")
+            return false \
+                if parent_wfid and not fei.parent_wfid == parent_wfid
+
+            true
+        end
+
+        #
+        # Returns true if the given expression is in the list of included
+        # classes or false if it's in the list of excluded classes...
+        #
+        # include_classes has precedence of exclude_classes.
+        #
+        def class_accepted? (fexp, include_classes, exclude_classes)
+
+            return false if include_classes and (not include_classes.find do |klazz|
+                fexp.is_a?(klazz)
+            end)
+            return false if exclude_classes and exclude_classes.find do |klazz|
+                fexp.is_a?(klazz)
+            end
+
+            true
+        end
     end
 
     #
@@ -115,8 +195,7 @@ module OpenWFE
 
             service_init(service_name, application_context)
 
-            size = @application_context[:expression_cache_size]
-            size = DEFAULT_SIZE unless size
+            size = @application_context[:expression_cache_size] || DEFAULT_SIZE
             size = MIN_SIZE unless size > MIN_SIZE
 
             linfo { "new() size is #{size}" }
@@ -152,59 +231,55 @@ module OpenWFE
 
         def []= (fei, fe)
 
-            #linfo { "[]= caching #{fei}" }
+            ldebug { "[]= caching #{fei}" }
 
             @cache[fei.hash] = fe
         end
 
         def delete (fei)
+
             @cache.delete fei.hash
         end
 
         def length
+
             @cache.length
         end
 
         alias :size :length
 
         def clear
+
             @cache.clear
         end
 
         alias :purge :clear
 
         #
-        # Simply redirects the call to the each_of_kind() method of 
-        # the 'real storage'.
+        # This implementations of find_expressions() immediately passes
+        # the call to the underlying real storage.
         #
-        def each_of_kind (kind, &block)
+        def find_expressions (options={})
 
-            get_real_storage.each_of_kind(kind, &block)
+            get_real_storage.find_expressions options
         end
 
         #
-        # Passes a block to the expressions currently in the cache.
+        # Attempts at fetching the root expression of a given process
+        # instance.
         #
-        def each (wfid_prefix=nil, &block)
+        def fetch_root (wfid)
 
-            #@cache.each(&block)
+            #
+            # at first, look in the cache
 
-            if wfid_prefix
-                @cache.each do |fei, fexp|
-                    next unless fei.wfid.match "^#{wfid_prefix}"
-                    block.call fei, fexp
-                end
-            else
-                @cache.each(&block)
-            end
-        end
+            @cache.each do |hashed_fei, fexp|
 
-        #
-        # This each() just delegates to the real storage each() method.
-        #
-        def real_each (wfid_prefix=nil, &block)
+                return fexp \
+                    if fexp.fei.wfid == wfid and fexp.is_a?(DefineExpression)
+            end
 
-            get_real_storage.each(wfid_prefix, &block)
+            get_real_storage.fetch_root wfid
         end
 
         protected
@@ -215,12 +290,12 @@ module OpenWFE
             #
             def get_real_storage
 
-                return @real_storage if @real_storage
-
-                @real_storage = 
-                    @application_context[S_EXPRESSION_STORAGE + ".1"]
+                #return @real_storage if @real_storage
+                #@real_storage = 
+                #    @application_context[S_EXPRESSION_STORAGE + ".1"]
+                #@real_storage
 
-                @real_storage
+                @application_context["expressionStorage.1"]
             end
     end
         
@@ -235,39 +310,94 @@ module OpenWFE
         
         def initialize (service_name, application_context)
 
-            service_init(service_name, application_context)
+            service_init service_name, application_context
 
             observe_expool
         end
 
         alias :purge :clear
 
-        #
+        #--
         # Allows to pass a block to each expressions of a given kind (type).
         #
-        def each_of_kind (kind, &block)
+        #def each_of_kind (kind, &block)
+        #    self.each_value do |fexp|
+        #        block.call(fexp.fei, fexp) if fexp.kind_of?(kind)
+        #    end
+        #end
+        #
+        # An iterator on the expression stored in here.
+        #
+        #def each (wfid_prefix=nil, &block)
+        #    if wfid_prefix
+        #        super() do |fei, fexp|
+        #            next unless fei.wfid.match "^#{wfid_prefix}"
+        #            block.call fei, fexp
+        #        end
+        #    else
+        #        super(&block)
+        #    end
+        #end
+        #alias :real_each :each
+        #++
 
-            self.each_value do |fexp|
-                block.call(fexp.fei, fexp) if fexp.kind_of?(kind)
+        #
+        # Finds expressions matching the given criteria (returns a list
+        # of expressions).
+        #
+        # This methods is called by the expression pool, it's thus not
+        # very "public" (not used directly by integrators, who should
+        # just focus on the methods provided by the Engine).
+        #
+        # :wfid ::
+        #     will list only one process, 
+        #     <tt>:wfid => '20071208-gipijiwozo'</tt>
+        # :parent_wfid ::
+        #     will list only one process, and its subprocesses,
+        #     <tt>:parent_wfid => '20071208-gipijiwozo'</tt>
+        # :consider_subprocesses :: 
+        #     if true, "process-definition" expressions
+        #     of subprocesses will be returned as well.
+        # :wfid_prefix :: 
+        #     allows your to query for specific workflow instance
+        #     id prefixes. for example : 
+        #     <tt>:wfid_prefix => "200712"</tt>
+        #     for the processes started in December.
+        # :include_classes ::
+        #     excepts a class or an array of classes, only instances of these
+        #     classes will be returned. Parent classes or mixins can be
+        #     given.
+        #     <tt>:includes_classes => OpenWFE::SequenceExpression</tt>
+        # :exclude_classes ::
+        #     works as expected.
+        # :wfname ::
+        #     will return only the expressions who belongs to the given
+        #     workflow [name].
+        # :wfrevision ::
+        #     usued in conjuction with :wfname, returns only the expressions
+        #     with a given workflow revision.
+        # :applied ::
+        #     if this option is set to true, will only return the expressions
+        #     that have been applied (exp.apply_time != nil).
+        #
+        def find_expressions (options={})
+
+            values.find_all do |fexp|
+                does_match? options, fexp
             end
         end
 
-        def each (wfid_prefix=nil, &block)
-
-            if wfid_prefix
-
-                super() do |fei, fexp|
-                    next unless fei.wfid.match "^#{wfid_prefix}"
-                    block.call fei, fexp
-                end
-            else
+        #
+        # Attempts at fetching the root expression of a given process
+        # instance.
+        #
+        def fetch_root (wfid)
 
-                super(&block)
-            end
+            find_expressions(
+                :wfid => wfid, 
+                :include_classes => DefineExpression)[0]
         end
 
-        alias :real_each :each
-
     end
 
 end

data/lib/openwfe/expool/journal.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -44,7 +44,6 @@ require 'openwfe/service'
 require 'openwfe/omixins'
 require 'openwfe/rudefinitions'
 require 'openwfe/flowexpressionid'
-require 'openwfe/util/otime'
 require 'openwfe/storage/yamlcustom'
 require 'openwfe/expool/journal_replay'
 

data/lib/openwfe/expool/parser.rb

@@ -0,0 +1,233 @@
+#
+#--
+# Copyright (c) 2008, 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'rexml/document'
+require 'openwfe/expressions/rprocdef'
+
+
+module OpenWFE
+    
+    #
+    # A process definition parser.
+    #
+    # Currently supports XML, Ruby process pdefinitions, YAML and JSON.
+    #
+    module DefParser
+
+        #
+        # in : a process pdefinition
+        # out : a tree [ name, attributes, children ]
+        #
+        def self.parse (pdef)
+
+            return pdef \
+                if pdef.is_a?(Array)
+
+            return parse_string(pdef) \
+                if pdef.is_a?(String)
+
+            return pdef.do_make \
+                if pdef.is_a?(ProcessDefinition) or pdef.is_a?(Class)
+
+            return pdef.to_a \
+                if pdef.is_a?(SimpleExpRepresentation)
+                    # for legacy stuff
+
+            raise "cannot handle pdefinition of class #{pdef.class.name}"
+        end
+
+        def self.parse_string (pdef)
+
+            pdef = pdef.strip
+
+            #return SimpleExpRepresentation.from_xml(param) \
+            return parse_xml(pdef) \
+                if pdef[0, 1] == "<"
+
+            return YAML.load(s) \
+                if pdef.match /^--- ./
+
+            #
+            # else it's some ruby code to eval
+
+            ProcessDefinition.eval_ruby_process_definition pdef, 2
+        end
+
+        #
+        # The process definition is expressed as XML, turn that into
+        # an expression tree.
+        #
+        def self.parse_xml (xml)
+
+            xml = REXML::Document.new(xml) \
+                if xml.is_a?(String)
+
+            xml = xml.root \
+                if xml.is_a?(REXML::Document)
+
+            if xml.is_a?(REXML::Text)
+
+                s = xml.to_s.strip
+
+                return s if s.length > 0
+
+                return nil
+            end
+
+            return nil if xml.is_a?(REXML::Comment)
+
+            # xml element thus...
+
+            name = xml.name
+
+            attributes = xml.attributes.inject({}) do |r, (k, v)|
+                r[k] = v
+                r
+            end
+
+            rep = [ name, attributes, [] ]
+
+            xml.children.each do |c|
+
+                #r = if c.is_a?(REXML::Element) and c.prefix != xml.prefix
+                #    c
+                #else
+                #    parse_xml c
+                #end
+                r = parse_xml c
+
+                rep.last << r if r
+            end
+
+            rep
+        end
+    end
+
+    #
+    # A set of methods for manipulating / querying a process expression tree
+    #
+    module ExpressionTree
+
+        #
+        # Extracts the description out of a process definition tree.
+        #
+        # TODO #14964 : add language support here
+        #
+        def self.get_description (tree)
+
+            return tree.last.first.to_s if tree.first == 'description'
+
+            tree.last.each do |child|
+                d = get_description(child)
+                return d if d
+            end
+
+            nil
+        end
+
+        #
+        # Returns a string containing the ruby code that generated this
+        # raw representation tree.
+        #
+        def self.to_code_s (tree, indentation = 0)
+
+            s = ""
+            tab = "    "
+            ind = tab * indentation
+
+            s << ind
+            s << OpenWFE::make_safe(tree.first)
+
+            sa = ""
+            tree[1].each do |k, v|
+                sa << ", :#{OpenWFE::to_underscore(k)} => '#{v}'"
+            end
+            s << sa[1..-1] if sa.length > 0
+
+            if tree.last.length > 0
+                s << " do\n"
+                tree.last.each do |child|
+                    #if child.respond_to?(:to_code_s)
+                    if child.is_a?(Array) and child.size == 3 # and ...
+                        s << to_code_s(child, indentation + 1)
+                    else
+                        s << ind
+                        s << tab
+                        s << "'#{child.to_s}'"
+                    end
+                    s << "\n"
+                end
+                s << ind
+                s << "end"
+            end
+
+            s
+        end
+
+        def self.to_xml (tree)
+
+            elt = REXML::Element.new tree.first
+
+            tree[1].each do |k, v|
+
+                elt.attributes[k] = v
+            end
+
+            tree.last.each do |child|
+
+                #if child.kind_of?(SimpleExpRepresentation)
+                if child.is_a?(Array) and child.size == 3
+
+                    elt << to_xml(child)
+                else
+
+                    elt << REXML::Text.new(child.to_s)
+                end
+            end
+
+            elt
+        end
+
+        def self.to_s (tree)
+
+            to_xml(tree).to_s
+        end
+    end
+end
+