openwferu 0.9.4 → 0.9.5

data/lib/openwfe/storage/yamlfilestorage.rb

@@ -42,6 +42,7 @@
 
 require 'find'
 require 'yaml'
+require 'monitor'
 require 'fileutils'
 
 require 'openwfe/utils'
@@ -58,19 +59,25 @@ require 'openwfe/expressions/raw_xml'
 
 module OpenWFE
     
-    
     #
     # Stores OpenWFEru related objects into yaml encoded files.
     # This storage is meant to look and feel like a Hash.
     #
     class YamlFileStorage  
-        include ServiceMixin
+        include MonitorMixin, ServiceMixin
         
         attr_accessor :basepath
         
         def initialize (service_name, application_context, path)
+
+            super()
+
             service_init(service_name, application_context)
+
             @basepath = path
+            #@basepath = OpenWFE::clean_path(@basepath) 
+            @basepath += "/" unless @basepath[-1, 1] == "/"
+
             FileUtils.makedirs @basepath 
         end
         
@@ -78,27 +85,31 @@ module OpenWFE
         # Stores an object with its FlowExpressionId instance as its key.
         #
         def []= (fei, object)
-            
-            fei_path = compute_file_path(fei)
-            fei_parent_path = File.dirname(fei_path)
-            
-            FileUtils.makedirs(fei_parent_path) \
-                if not File.exist?(fei_parent_path)
+            synchronize do
+                fei_path = compute_file_path(fei)
+
+                fei_parent_path = File.dirname(fei_path)
                 
-            fd = IO.sysopen(fei_path , "w+")
-            io = IO.open(fd , "w+")
-            
-            data = YAML.dump(object)
-            
-            io.write(data)
-            io.close
+                FileUtils.makedirs(fei_parent_path) \
+                    if not File.exist?(fei_parent_path)
+                    
+                fd = IO.sysopen(fei_path , "w+")
+                io = IO.open(fd , "w+")
+                
+                data = YAML.dump(object)
+                
+                io.write(data)
+                io.close
+            end
         end
             
         #
         # Deletes the whole storage directory... beware...
         #
         def purge
-            FileUtils.remove_dir @basepath
+            synchronize do
+                FileUtils.remove_dir @basepath
+            end
         end 
         
         #
@@ -114,13 +125,15 @@ module OpenWFE
         # instance.
         #
         def delete (fei)
+            synchronize do
             
-            fei_path = compute_file_path(fei)
-            
-            if File.exist?(fei_path)
+                fei_path = compute_file_path(fei)
+
+                #ldebug do 
+                #    "delete()\n   for #{fei.to_debug_s}\n   at #{fei_path}"
+                #end
+                
                 File.delete(fei_path)
-            else
-                raise "Object not found at #{fei_path}"
             end
         end
         
@@ -141,7 +154,8 @@ module OpenWFE
         # Returns the count of objects currently stored in this instance.
         #
         def length
-            return count_objects(0, @basepath)
+            #return count_objects(0, @basepath)
+            count_objects()
         end
 
         alias :size :length
@@ -159,38 +173,51 @@ module OpenWFE
                 return object
             end
             
-            def count_objects (count, item)
-
-                # TODO #8346 : use "find" to do that job
-                # measure perf before and after change !
-                
-                return count + 1 if OpenWFE::ends_with(item, ".yaml")
-                
-                if File.stat(item).directory?
-                    
-                    d = Dir.new(item)
-                    d.each do |i|
-                        next if i == "." or i == ".."
-                        i = item + "/" + i
-                        count = count_objects(count, i)
-                    end
-                    d.close()
+            def count_objects
+                count = 0
+                Find.find(@basepath) do |path|
+                    next if File.stat(path).directory?
+                    count += 1 if OpenWFE::ends_with(path, ".yaml")
                 end
-                
                 return count
             end
 
+            #
+            # Passes each object path to the given block
+            #
             def each_object_path (&block)
                 return unless block
-                Find.find(@basepath) do |path|
-                    block.call path \
-                        unless File.stat(path).directory?
+                synchronize do
+                    Find.find(@basepath) do |path|
+                        next if File.stat(path).directory?
+                        next unless OpenWFE::ends_with(path, ".yaml")
+                        ldebug { "each_object_path() considering #{path}" }
+                        block.call path
+                    end
                 end
             end
-            
-            def compute_file_path (fei)
-                raise NotImplementedError.new
+
+            #
+            # Passes each object to the given block
+            #
+            def each_object (&block)
+                return unless block
+                each_object_path do |path|
+                    block.call load_object(path)
+                end
             end
+
+            #
+            # each_value() is a method from Hash, by providing it here
+            # it's easier to disguise a YamlFileStorage as a hash.
+            #
+            alias :each_value :each_object
+
+            protected
+                
+                def compute_file_path (object)
+                    raise NotImplementedError.new
+                end
             
         end        
         

data/lib/openwfe/util/dollar.rb

@@ -173,10 +173,23 @@ module OpenWFE
 
             def call_ruby (ruby_code)
 
-                binding = nil
-                binding = @flow_expression.get_binding if @flow_expression
-
-                eval(ruby_code, binding).to_s
+                #binding = nil
+                #binding = @flow_expression.get_binding if @flow_expression
+                #eval(ruby_code, binding).to_s
+
+                wi = @workitem
+                workitem = @workitem
+                if @flow_expression
+                    fexp = @flow_expression
+                    flow_expression = @flow_expression
+                    fei = @flow_expression.fei
+                end
+                    #
+                    # some simple notations made available to ${ruby:...}
+                    # notations
+
+                #eval(ruby_code, binding).to_s
+                eval(ruby_code).to_s
             end
     end
 

data/lib/openwfe/util/lru.rb

@@ -0,0 +1,154 @@
+#
+#--
+# 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$
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+#require 'monitor'
+
+
+module OpenWFE
+
+    #
+    # A Hash that has a max size. After the maxsize has been reached, the
+    # least recently used entries (LRU hence), will be discared to make
+    # room for the new entries.
+    #
+    class LruHash
+        #include MonitorMixin
+            #
+            # seems not necessary for now, and it collides with expool's
+            # @monitors own sync
+
+        def initialize (maxsize)
+
+            super()
+
+            @maxsize = maxsize
+
+            @hash = {}
+            @lru_keys = []
+        end
+
+        def maxsize= (newsize)
+            remove_lru() while @hash.size > newsize
+            @maxsize = newsize
+        end
+
+        def maxsize
+            return @maxsize
+        end
+
+        def size
+            return @lru_keys.size
+        end
+        alias :length :size
+
+        def keys
+            return @hash.keys
+        end
+        def values
+            return @values
+        end
+
+        def clear
+            @hash.clear
+            @lru_keys.clear
+        end
+
+        def each (&block)
+            return unless block
+            @hash.each do |k, v|
+                block.call(k, v)
+            end
+        end
+
+        #
+        # Returns the keys with the lru in front.
+        #
+        def ordered_keys
+            return @lru_keys
+        end
+
+        def [] (key)
+            value = @hash[key]
+            return nil unless value
+            touch(key)
+            return value
+        end
+
+        def []= (key, value)
+            remove_lru() while @hash.size >= @maxsize
+            @hash[key] = value
+            touch(key)
+            return value
+        end
+
+        def delete (key)
+            value = @hash.delete(key)
+            @lru_keys.delete(key)
+            return value
+        end
+
+        def include? (key)
+            return @hash.include?(key)
+        end
+
+        protected
+
+            #
+            # Puts the key on top of the lru 'stack'.
+            # The bottom being the lru place.
+            #
+            def touch (key)
+                @lru_keys.delete(key)
+                @lru_keys << key
+            end
+
+            #
+            # Removes the lru value and returns it.
+            # Returns nil if the cache is currently empty.
+            #
+            def remove_lru ()
+                return nil if @lru_keys.size < 1
+                key = @lru_keys.delete_at(0)
+                return @hash.delete(key)
+            end
+    end
+end
+

data/lib/openwfe/util/otime.rb

@@ -184,13 +184,34 @@ module OpenWFE
         o = Rational(time.utc_offset, 3600 * 24)
 
         begin
+
             return DateTime.new(
-                time.year, time.month, time.day, time.hour, time.min, s, o)
+                time.year, 
+                time.month, 
+                time.day, 
+                time.hour, 
+                time.min, 
+                s, 
+                o)
+
         rescue Exception => e
-            puts \
-                "\n Date.new() problem. Params :"+
-                "\n....y:#{time.year} M:#{time.month} d:#{time.day} "+
-                "h:#{time.hour} m:#{time.min} s:#{s} o:#{o}"
+
+            #puts
+            #puts OpenWFE::exception_to_s(e)
+            #puts
+            #puts \
+            #    "\n Date.new() problem. Params :"+
+            #    "\n....y:#{time.year} M:#{time.month} d:#{time.day} "+
+            #    "h:#{time.hour} m:#{time.min} s:#{s} o:#{o}"
+
+            return DateTime.new(
+                time.year, 
+                time.month, 
+                time.day, 
+                time.hour, 
+                time.min, 
+                time.sec, 
+                time.utc_offset)
         end
     end
 

data/lib/openwfe/util/scheduler.rb

@@ -41,9 +41,7 @@
 
 require 'monitor'
 
-#require 'openwfe/utils'
 require 'openwfe/util/otime'
-require 'openwfe/util/stoppable'
 
 
 module OpenWFE
@@ -88,7 +86,7 @@ module OpenWFE
     #        # will regenerate the monthly report in four days
     #
     class Scheduler
-        include MonitorMixin, Stoppable
+        include MonitorMixin
 
         attr_accessor \
             :precision
@@ -107,35 +105,34 @@ module OpenWFE
                 # every 250ms, the scheduler wakes up
 
             @last_cron_minute = -1
+
+            @stopped = false
         end
 
         #
         # Starts this scheduler (or restart it if it was previously stopped)
         #
-        def start
-
-            #if @scheduler_thread
-            #    @scheduler_thread.wakeup
-            #    return
-            #end
+        def sstart
 
             @scheduler_thread = Thread.new do
                 while true
-                    break if self.is_stopped?
-                    #print "."
-                    #$stdout.flush
+                    break if @stopped
+                    #print "."; $stdout.flush
                     step
                     sleep(@precision)
                 end
             end
-
-            do_restart
         end
 
         #
-        # The scheduler is stoppable via stop() or do_stop()
+        # The scheduler is stoppable via sstop()
         #
-        alias :stop :do_stop
+        def sstop
+            @stopped = true
+        end
+
+        alias :start :sstart
+        alias :stop :sstop
 
         #
         # Joins on the scheduler thread
@@ -171,7 +168,7 @@ module OpenWFE
                     job.trigger()
                     return nil
                 end
-                
+
                 return push(job) \
                     if @pending_jobs.length < 1
 
@@ -262,8 +259,8 @@ module OpenWFE
         # Returns the job id attributed to this 'cron job', this id can
         # be used to unschedule the job.
         #
-        def schedule \
-            (cron_line, cron_id=nil, schedulable=nil, params=nil, &block)
+        def schedule (
+            cron_line, cron_id=nil, schedulable=nil, params=nil, &block)
 
             synchronize do
             
@@ -368,24 +365,17 @@ module OpenWFE
                     #
                     # cron entries
 
-                    begin
-                        if now.sec == 0 and minute > @last_cron_minute
-                            #
-                            # only consider cron entries at the second 0 of a 
-                            # minute
+                    if now.sec == 0 and minute > @last_cron_minute
+                        #
+                        # only consider cron entries at the second 0 of a 
+                        # minute
 
-                            @last_cron_minute = minute
+                        @last_cron_minute = minute
 
-                            @cron_entries.each do |cron_id, cron_entry|
-                                #puts "step() cron_id : #{cron_id}"
-                                cron_entry.trigger \
-                                    if cron_entry.matches? now
-                            end
+                        @cron_entries.each do |cron_id, cron_entry|
+                            #puts "step() cron_id : #{cron_id}"
+                            trigger(cron_entry) if cron_entry.matches? now
                         end
-                    rescue Exception => e
-                        #puts \
-                        #    "step() caught exception\n" + 
-                        #    OpenWFE::exception_to_s(e)
                     end
 
                     #
@@ -412,11 +402,29 @@ module OpenWFE
                             #
                             # obviously
 
-                        job.trigger()
+                        trigger(job)
+
                         @pending_jobs.delete_at(0)
                     end
                 end
-        end
+            end
+
+            def trigger (entry)
+                Thread.new do
+                    begin
+                        entry.trigger
+                    rescue Exception => e
+                        message =
+                            "trigger() caught exception\n" + 
+                            OpenWFE::exception_to_s(e)
+                        if self.respond_to? :lwarn
+                            lwarn { message }
+                        else
+                            puts message
+                        end
+                    end
+                end
+            end
     end
 
     #

data/lib/openwfe/util/schedulers.rb

@@ -60,12 +60,14 @@ module OpenWFE
 
             ldebug { "initialize() SchedulerService #{self.object_id}" }
 
-            start()
+            sstart()
         end
 
         def stop
+
             linfo { "stop() for scheduler #{self.object_id}" }
-            do_stop
+
+            sstop()
         end
     end
 

data/lib/openwfe/utils.rb

@@ -99,6 +99,7 @@ module OpenWFE
 
         return nil if object == nil
 
+        return object if object.kind_of? Float
         return object if object.kind_of? Fixnum
         return object if object.kind_of? TrueClass
         return object if object.kind_of? FalseClass
@@ -196,9 +197,43 @@ module OpenWFE
         return s
     end
 
+    #
+    # Some code for writing thinks like :
+    #
+    #     if async
+    #         OpenWFE::call_in_thread "launch()", self do
+    #             raw_expression.apply(wi)
+    #         end
+    #     else
+    #         raw_expression.apply(wi)
+    #     end
+    #
+    def OpenWFE.call_in_thread (caller_name, caller_object=nil, &block)
+        return unless block
+        Thread.new do
+            begin
+                block.call
+            rescue Exception => e
+                msg = "#{caller_name} caught an exception\n" + exception_to_s(e)
+                if caller_object and caller_object.respond_to? :lwarn
+                    caller_object.lwarn { msg }
+                else
+                    puts msg
+                end
+            end
+        end
+        # implicitely return the thread
+    end
+
     #
     # A small Timer class for debug purposes.
     #
+    #     t = Time.new
+    #
+    #     # ... do something
+    #
+    #     puts "that something took #{t.duration} ms"
+    #
     class Timer
 
         attr_reader :start
@@ -207,11 +242,38 @@ module OpenWFE
             @start = Time.now.to_f
         end
 
+        #
+        # Returns the number of milliseconds since this Timer was
+        # instantiated.
+        #
         def duration
             return (Time.now.to_f - @start) * 1000
         end
     end
 
+    #
+    # Returns a version of s that is usable as or within a filename
+    # (removes for examples things like '/' or '\'...)
+    #
+    def OpenWFE.ensure_for_filename (s)
+        s = s.gsub(" ", "_")
+        s = s.gsub("/", "_")
+        s = s.gsub(":", "_")
+        s = s.gsub(";", "_")
+        s = s.gsub("\*", "_")
+        s = s.gsub("\\", "_")
+        s = s.gsub("\+", "_")
+        s = s.gsub("\?", "_")
+        return s
+    end
+
+    #
+    # "my//path" -> "my/path"
+    #
+    def OpenWFE.clean_path (s)
+        s.gsub(/\/+/, "/")
+    end
+
     #
     # This method is used within the InFlowWorkItem and the CsvTable classes.
     #

data/lib/openwfe/version.rb

@@ -34,5 +34,5 @@
 #
 
 module OpenWFE
-    OPENWFERU_VERSION = '0.9.4'
+    OPENWFERU_VERSION = '0.9.5'
 end