ruote 0.9.18 → 0.9.19

data/lib/openwfe/expool/representation.rb

@@ -39,83 +39,83 @@
 
 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
+
     #
-    # 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.
+    # Computes and returns the up-to-date representation of
+    # the process definition (on the fly changes included)
     #
-    module RepresentationMixin
+    def representation
 
-        #
-        # Computes and returns the up-to-date representation of
-        # the process definition (on the fly changes included)
-        #
-        def representation
+      root_exp = find_root_expression
 
-            root_exp = find_root_expression
+      update_rep root_exp
+    end
 
-            update_rep root_exp
-        end
+    protected
 
-        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)
 
-            #
-            # 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
 
-                rep = flow_expression.raw_representation.dup
-                children = flow_expression.children
+        index = -1
 
-                index = -1
+        rep[2] = rep.last.inject([]) { |r, c|
 
-                rep[2] = rep.last.inject([]) { |r, c|
+          index += 1
 
-                    index += 1
+          r << if c.is_a?(Array)
 
-                    r << if c.is_a?(Array)
+            child_fei = flow_expression.children[index]
+            child_exp = find_expression child_fei
 
-                        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
 
-                        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
 
-                        c
-                    end
+        } if children and children.size > 0
 
-                } if children and children.size > 0
+        rep
+      end
 
-                rep
-            end
+      def find_root_expression
 
-            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
+        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)
+      def find_expression (fei)
 
-                self.find { |fexp| fexp.fei == fei }
-            end
-    end
+        self.find { |fexp| fexp.fei == fei }
+      end
+  end
 end

data/lib/openwfe/expool/threadedexpstorage.rb

@@ -2,31 +2,31 @@
 #--
 # Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
-# 
-# Redistribution and use in source and binary forms, with or without 
+#
+# 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 
+#   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 
+#
+# 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.
 #++
 #
@@ -42,147 +42,150 @@ 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
+
     #
-    # 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.
+    # Will take care of stopping the 'queue processing' thread.
     #
-    module ThreadedStorageMixin
-
-        #
-        # Will take care of stopping the 'queue processing' thread.
-        #
-        def stop
-
-            @stopped = true
-            @queue.push :stop
-        end
+    def stop
 
-        #
-        # 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
+      @stopped = true
+      @queue.push :stop
+    end
 
-        protected
+    #
+    # makes sure that the queue isn't actually preparing a batch
+    # before returning a result.
+    #
+    def find_expressions (options)
 
-            #
-            # starts the thread that does the actual persistence.
-            #
-            def start_queue
+      Thread.pass
 
-                @mutex = Mutex.new
-                @queue = Queue.new
+      @mutex.synchronize do
+        super
+      end
+    end
 
-                Thread.new do
+    protected
 
-                    loop do
+      #
+      # starts the thread that does the actual persistence.
+      #
+      def start_queue
 
-                        events = [ @queue.pop ]
+        @mutex = Mutex.new
+        @queue = Queue.new
 
-                        @mutex.synchronize do
+        Thread.new do
 
-                            14.times { Thread.pass } # gather some steam
+          loop do
 
-                            @queue.size.times do
-                                events << @queue.pop
-                            end
+            events = [ @queue.pop ]
 
-                            process_events events
-                        end
+            @mutex.synchronize do
 
-                        break if events.include?(:stop)
-                    end
-                end
-            end
+              14.times { Thread.pass }
+                #
+                # gather some steam :
+                # let job accumulate
 
-            #
-            # queues an event for later (well within a second) persistence
-            #
-            def queue (event, fei, fexp=nil)
+              @queue.size.times do
+                events << @queue.pop
+              end
 
-                if @stopped
-                    process_event event, fei, fexp
-                else
-                    @queue.push [ event, fei, fexp ]
-                end
+              process_events events
             end
 
-            def process_events (events)
+            break if events.include?(:stop)
+          end
+        end
+      end
 
-                ldebug { "process_events() #{events.size} events" }
+      #
+      # queues an event for later (well within a second) persistence
+      #
+      def queue (event, fei, fexp=nil)
 
-                # reducing the operation count
+        if @stopped
+          process_event event, fei, fexp
+        else
+          @queue.push [ event, fei, fexp ]
+        end
+      end
 
-                events = events.inject({}) do |r, event|
-                    r[event[1]] = event if event != :stop
-                    r
-                end
+      def process_events (events)
 
-                ldebug { "process_events() #{events.size} events remaining" }
+        ldebug { "process_events() #{events.size} events" }
 
-                # perform the remaining operations
+        # reducing the operation count
 
-                events.each_value do |event, fei, fexp|
+        events = events.inject({}) do |r, event|
+          r[event[1]] = event if event != :stop
+          r
+        end
 
-                    process_event event, fei, fexp
-                end
-            end
+        ldebug { "process_events() #{events.size} events remaining" }
 
-            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
+        # perform the remaining operations
 
-            #
-            # 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
+        events.each_value do |event, fei, fexp|
 
-            #
-            # 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
+          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