ruote 0.9.18

data/lib/openwfe/expool/parser.rb

@@ -0,0 +1,242 @@
+#
+#--
+# 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 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
+        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 = 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
+
+            tree.last.each do |child|
+                next unless child.is_a?(Array)
+                return child.last.first if child.first == 'description'
+            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
+
+        #
+        # Turns the expression tree into an XML process definition
+        #
+        def self.to_xml (tree)
+
+            elt = REXML::Element.new tree.first.to_s
+
+            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
+
+        #
+        # Returns an XML string
+        #
+        def self.to_s (tree, indent=-1)
+
+            d = REXML::Document.new
+            d << to_xml(tree)
+            s = ""
+            d.write s, indent
+            s
+        end
+    end
+end
+

data/lib/openwfe/expool/representation.rb

@@ -0,0 +1,121 @@
+#
+#--
+# 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
+#
+
+module OpenWFE
+
+    #
+    # This module gets included into the result of the expression pool (and
+    # engine) process_stack method (if the optional parameter 'unapplied' is
+    # set to true).
+    #
+    # It adds a representation() method that returns an up-to-date
+    # representation of the executing process instance.
+    # This representation is suitable for 'fluo' rendering.
+    #
+    module RepresentationMixin
+
+        #
+        # Computes and returns the up-to-date representation of
+        # the process definition (on the fly changes included)
+        #
+        def representation
+
+            root_exp = find_root_expression
+
+            update_rep root_exp
+        end
+
+        protected
+
+            #
+            # if a child expression is present (in the process stack)
+            # makes sure to take its current representation and include
+            # it in the parent representation.
+            #
+            def update_rep (flow_expression)
+
+                rep = flow_expression.raw_representation.dup
+                children = flow_expression.children
+
+                index = -1
+
+                rep[2] = rep.last.inject([]) { |r, c|
+
+                    index += 1
+
+                    r << if c.is_a?(Array)
+
+                        child_fei = flow_expression.children[index]
+                        child_exp = find_expression child_fei
+
+                        if child_exp
+                            update_rep(child_exp)
+                        else
+                            #c[1]['__gone__'] = true
+                                #
+                                # not a good idea
+                                # have to differentiate between 'replied'
+                                # expressions and removed expressions
+                            c
+                        end
+                    else
+
+                        c
+                    end
+
+                } if children and children.size > 0
+
+                rep
+            end
+
+            def find_root_expression
+
+                self.find do |fexp|
+                    fexp.fei.expid == "0" &&
+                    ( ! fexp.is_a?(OpenWFE::Environment)) &&
+                    fexp.fei.is_in_parent_process?
+                end
+            end
+
+            def find_expression (fei)
+
+                self.find { |fexp| fexp.fei == fei }
+            end
+    end
+end

data/lib/openwfe/expool/threadedexpstorage.rb

@@ -0,0 +1,188 @@
+#
+#--
+# Copyright (c) 2007-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 'thread'
+
+
+module OpenWFE
+
+    #
+    # This mixin gathers all the logic for a threaded expression storage,
+    # one that doesn't immediately stores workitems (removes overriding
+    # operations).
+    # Using this threaded storage brings a very important perf benefit.
+    #
+    module ThreadedStorageMixin
+
+        #
+        # Will take care of stopping the 'queue processing' thread.
+        #
+        def stop
+
+            @stopped = true
+            @queue.push :stop
+        end
+
+        #
+        # makes sure that the queue isn't actually preparing a batch
+        # before returning a result.
+        #
+        def find_expressions (options)
+
+            Thread.pass
+
+            @mutex.synchronize do
+                super
+            end
+        end
+
+        protected
+
+            #
+            # starts the thread that does the actual persistence.
+            #
+            def start_queue
+
+                @mutex = Mutex.new
+                @queue = Queue.new
+
+                Thread.new do
+
+                    loop do
+
+                        events = [ @queue.pop ]
+
+                        @mutex.synchronize do
+
+                            14.times { Thread.pass } # gather some steam
+
+                            @queue.size.times do
+                                events << @queue.pop
+                            end
+
+                            process_events events
+                        end
+
+                        break if events.include?(:stop)
+                    end
+                end
+            end
+
+            #
+            # queues an event for later (well within a second) persistence
+            #
+            def queue (event, fei, fexp=nil)
+
+                if @stopped
+                    process_event event, fei, fexp
+                else
+                    @queue.push [ event, fei, fexp ]
+                end
+            end
+
+            def process_events (events)
+
+                ldebug { "process_events() #{events.size} events" }
+
+                # reducing the operation count
+
+                events = events.inject({}) do |r, event|
+                    r[event[1]] = event if event != :stop
+                    r
+                end
+
+                ldebug { "process_events() #{events.size} events remaining" }
+
+                # perform the remaining operations
+
+                events.each_value do |event, fei, fexp|
+
+                    process_event event, fei, fexp
+                end
+            end
+
+            def process_event (event, fei, fexp)
+
+                begin
+                    if event == :update
+                        self[fei] = fexp
+                    else
+                        safe_delete fei
+                    end
+                rescue Exception => e
+                    lwarn do
+                        "process_event() ':#{event}' exception\n" + 
+                        OpenWFE::exception_to_s(e)
+                    end
+                end
+            end
+
+            #
+            # a call to delete that tolerates missing .yaml files
+            #
+            def safe_delete (fei)
+                begin
+                    self.delete fei
+                rescue Exception => e
+                #    lwarn do
+                #        "safe_delete() exception\n" + 
+                #        OpenWFE::exception_to_s(e)
+                #    end
+                end
+            end
+
+            #
+            # Adds the queue() method as an observer to the update and remove
+            # events of the expression pool.
+            # :update and :remove mean changes to expressions in the persistence
+            # that's why they are observed.
+            #
+            def observe_expool
+
+                get_expression_pool.add_observer(:update) do |event, fei, fe|
+                    ldebug { ":update  for #{fei.to_debug_s}" }
+                    queue event, fei, fe
+                end
+                get_expression_pool.add_observer(:remove) do |event, fei|
+                    ldebug { ":remove  for #{fei.to_debug_s}" }
+                    queue event, fei
+                end
+            end
+    end
+end