openwferu 0.9.13 → 0.9.14

data/lib/openwfe/participants/participantmap.rb

@@ -51,7 +51,7 @@ module OpenWFE
     # A very simple directory of participants
     #
     class ParticipantMap < Service
-        include Observable
+        include OwfeObservable
 
         attr_accessor \
             :participants
@@ -64,6 +64,14 @@ module OpenWFE
             @observers = {}
         end
 
+        #
+        # Returns how many participants are currently registered here.
+        #
+        def size
+
+            @participants.size
+        end
+
         #
         # Adds a participant to this map.
         # This method is called by the engine's own register_participant()
@@ -121,7 +129,7 @@ module OpenWFE
 
             @participants << [ regex, participant ]
 
-            return participant
+            participant
         end
 
         #
@@ -137,6 +145,7 @@ module OpenWFE
             @participants.each do |tuple|
                 return tuple[1] if tuple[0].match(participant_name)
             end
+
             nil
         end
 
@@ -158,17 +167,20 @@ module OpenWFE
         end
 
         #
-        # Dispatches to the given participant.
+        # Dispatches to the given participant (participant name (string) or
         # The workitem will be fed to the consume() method of that participant.
         # If it's a cancelitem and the participant has a cancel() method,
         # it will get called instead.
         #
-        def dispatch (participant_name, workitem)
+        def dispatch (participant, participant_name, workitem)
+
+            unless participant
 
-            participant = lookup_participant(participant_name)
+                participant = lookup_participant participant_name
 
-            raise "Didn't find participant named '#{participant_name}'" \
-                if not participant
+                raise "there is no participant named '#{participant_name}'" \
+                    unless participant
+            end
 
             workitem.participant_name = participant_name
 
@@ -184,6 +196,8 @@ module OpenWFE
 
             onotify :dispatch, :before_consume, workitem
 
+            workitem.dispatch_time = Time.now
+
             participant.consume(workitem)
 
             onotify :dispatch, :after_consume, workitem

data/lib/openwfe/participants/participants.rb

@@ -177,6 +177,35 @@ module OpenWFE
         end
     end
 
+    #
+    # Simply aliasing a participant.
+    #
+    #     engine.register_participant "toto" do |workitem|
+    #         workitem.toto_message = "toto was here"
+    #     end
+    #     engine.register_participant "user_.*", AliasParticipant.new("toto")
+    #
+    # Workitems for participant whose name starts with 'user_' will be handled
+    # by participant 'toto'.
+    # Note that you can't use use a regex as the aliased name ("toto" in the 
+    # example).
+    #
+    class AliasParticipant
+        include LocalParticipant
+
+        attr_reader :aliased_name
+
+        def initialize (aliased_name)
+
+            @aliased_name = aliased_name
+        end
+
+        def consume (workitem)
+
+            get_participant_map.dispatch(nil, @aliased_name, workitem)
+        end
+    end
+
     #
     # The NullParticipant never replies, it simply discards the workitems
     # it receives.

data/lib/openwfe/rest/exception.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: exception.rb 3454 2006-10-08 16:51:00Z jmettraux $
-#
 
 #
 # "hecho en Costa Rica"

data/lib/openwfe/storage/yamlfilestorage.rb

@@ -140,8 +140,10 @@ module OpenWFE
             fei_path = compute_file_path(fei)
             
             if not File.exist?(fei_path)
+
                 ldebug { "[] didn't find file at #{fei_path}" }
                 #puts  "[] didn't find file at #{fei_path}"
+
                 return nil 
             end
 
@@ -184,7 +186,8 @@ module OpenWFE
 
                     count += 1 if OpenWFE::ends_with(path, ".yaml")
                 end
-                return count
+
+                count
             end
 
             #

data/lib/openwfe/util/dollar.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"

data/lib/openwfe/util/lru.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id$
-#
 
 #
 # "made in Japan"

data/lib/openwfe/util/observable.rb

@@ -45,7 +45,7 @@ module OpenWFE
     # available.
     # This mixin is chiefly used by the ExpressionPool class.
     #
-    module Observable
+    module OwfeObservable
 
         #
         # Observers will register themselves to the Observable via

data/lib/openwfe/util/scheduler.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -601,6 +599,8 @@ module OpenWFE
 
                         @last_cron_minute = minute
 
+                        #puts "step() @cron_entries.size #{@cron_entries.size}"
+
                         @cron_entries.each do |cron_id, cron_entry|
                             #puts "step() cron_id : #{cron_id}"
                             trigger(cron_entry) if cron_entry.matches? now
@@ -729,9 +729,9 @@ module OpenWFE
 
                 super(cron_id, &block)
 
-                if line.kind_of? String
+                if line.kind_of?(String)
                     @cron_line = CronLine.new(line)
-                elsif line.kind_of? CronLine
+                elsif line.kind_of?(CronLine)
                     @cron_line = line
                 else
                     raise \

data/lib/openwfe/util/schedulers.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"

data/lib/openwfe/util/workqueue.rb

@@ -43,133 +43,76 @@ require 'openwfe/utils'
 
 module OpenWFE
 
+    #
+    # This mixin provides a workqueue and a thread for executing tasks
+    # pushed onto it. It uses the thread.rb Queue class.
+    #
+    # It is currently only used by the ExpressionPool (maybe it'll get
+    # merged back into it later).
+    #
     module WorkqueueMixin
 
-        WQF_LOW = 0.500
-
         #
-        # Starts the workqueue with a given frequency (seconds)
+        # Creates and starts the workqueue.
         #
         def start_workqueue
 
-            @workqueue_mutex = Mutex.new
-            @workqueue = []
-            @workqueue_frequency = 0
+            @workqueue = Queue.new
+
+            @workstopped = false
 
             OpenWFE::call_in_thread "workqueue", self do
-                while true
-                    break if @workqueue_frequency == nil
-                    sleep @workqueue_frequency
-                    do_process_workqueue
+                loop do
+                    do_process_workelement @workqueue.pop
+                    break if @workstopped and @workqueue.empty?
                 end
             end
         end
 
         #
-        # Returns true if there is or there just was activity for the ]
+        # Returns true if there is or there just was activity for the
         # work queue.
         #
         def is_workqueue_busy?
-            (@workqueue.size > 0 or @workqueue_frequency < WQF_LOW)
+            
+            @workqueue.size > 0
         end
 
         #
         # Stops the workqueue.
         #
         def stop_workqueue
-            @workqueue_frequency = nil
-            do_process_workqueue
-                #
-                # maybe could process the work queue until it's really empty
+
+            @workstopped = true
         end
 
         #
         # the method called by the mixer to actually queue the work.
         #
         def queue_work (*args)
-            @workqueue_mutex.synchronize do
-
-                if @workqueue
-                    @workqueue.push args
-                        #
-                        # work will be done later (millisec order)
-                        # by the work thread
-                else
-                    do_process_workelement args
-                        #
-                        # degraded mode : as if there were no workqueue
-                end
-            end
-        end
-
-        #
-        # Returns the current workqueue size
-        #
-        def workqueue_size
-            return 0 unless @workqueue
-            @workqueue.size
-        end
-
-        #
-        # Called by the workqueue thread, copies the workqueue and clears
-        # it, and then processes the elt in the copied workqueue.
-        # (meanwhile, the empty workqueue gets filled by queue_work() 
-        # calls)
-        #
-        # This method calls the do_process_workelement() method of
-        # its 'mixer' with each work element queued.
-        #
-        def do_process_workqueue
-
-            q = nil
 
-            @workqueue_mutex.synchronize do
+            if @workqueue_stopped
 
-                if @workqueue.size < 1
-                    increment_workqueue_frequency
-                    return
-                end
-
-                q = Array.new(@workqueue)
-                @workqueue.clear
-
-                @workqueue_frequency = 0
+                do_process_workelement args
                     #
-                    # back to maximum reponsiveness
-            end
+                    # degraded mode : as if there were no workqueue
+            else
 
-            #ldebug { "do_process_workqueue() #{q.size} items to process" }
-
-            q.each do |elt|
-            
-                do_process_workelement elt
+                @workqueue.push args
                     #
-                    # exception management is now done in the 
-                    # do_process_workelement method
+                    # work will be done later (millisec order)
+                    # by the work thread
             end
-
-            # TODO : have a pool of workers handle that
-
-            #q.size
         end
 
-        protected
-
-            #
-            # No activity spotted, so decrease responsiveness
-            #
-            def increment_workqueue_frequency
-
-                return if @workqueue_frequency == nil
-
-                @workqueue_frequency *= 3
-
-                if @workqueue_frequency == 0
-                    @workqueue_frequency = 0.001
-                elsif @workqueue_frequency > WQF_LOW
-                    @workqueue_frequency = WQF_LOW
-                end
-            end
+        #--
+        # Returns the current workqueue size
+        #
+        #def workqueue_size
+        #    return 0 unless @workqueue
+        #    @workqueue.size
+        #end
+        #++
     end
 end
 

data/lib/openwfe/utils.rb

@@ -65,37 +65,20 @@ module OpenWFE
         exit 1
     end
 
-    #
-    # Attempts a deep cloning of the object
-    #
-    def OpenWFE.copy (object)
-
-        return nil if object == nil
-
-        if object.kind_of?(Array)
-            result = []
-            object.each do |i|
-                result << copy(i)
-            end
-            return result
-        end
-
-        if object.kind_of?(Hash)
-            result = {}
-            object.each do |k, v|
-                result[copy(k)] = copy(v)
-            end
-            return result
-        end
-
-        return object.dup
-    end
-
     #
     # see 
     # http://wiki.rubygarden.org/Ruby/page/show/Make_A_Deep_Copy_Of_An_Object
     #
+    # It's not perfect (that's why fulldup() uses it only in certain cases).
+    #
+    # For example :
+    #
+    #     TypeError: singleton can't be dumped
+    #         ./lib/openwfe/utils.rb:74:in `dump'
+    #         ./lib/openwfe/utils.rb:74:in `deep_clone'
+    #
     def OpenWFE.deep_clone (object)
+
         Marshal::load(Marshal.dump(object))
     end
 
@@ -125,7 +108,13 @@ module OpenWFE
             return d.root
         end
 
-        o = object.class.new
+        o = nil
+
+        begin
+            o = object.class.new
+        rescue ArgumentError
+            return deep_clone(object)
+        end
 
         #
         # some kind of collection ?
@@ -136,7 +125,7 @@ module OpenWFE
             end
         elsif object.kind_of?(Hash)
             object.each do |k, v|
-                o[copy(k)] = fulldup(v)
+                o[fulldup(k)] = fulldup(v)
             end
         end
 
@@ -194,6 +183,8 @@ module OpenWFE
     #
     def OpenWFE.parse_uri (string)
 
+        return nil if string.split("\n").size > 1
+
         begin
             return URI::parse(string)
         rescue Exception => e
@@ -459,6 +450,22 @@ module OpenWFE
         container[key[i+1..-1]] = value
     end
 
+    #
+    # Returns true if this host is currently online (has access to the web / 
+    # internet).
+    #
+    def online?
+
+        require 'open-uri'
+
+        begin
+            open("http://www.openwfe.org")
+            true
+        rescue SocketError => se
+            false
+        end
+    end
+
     protected
 
         def pop_key (key)

data/lib/openwfe/version.rb

@@ -32,5 +32,5 @@
 #
 
 module OpenWFE
-    OPENWFERU_VERSION = '0.9.13'
+    OPENWFERU_VERSION = '0.9.14'
 end

data/lib/openwfe/workitem.rb

@@ -202,7 +202,7 @@ module OpenWFE
         attr_accessor :flow_expression_id, :participant_name
 
         def last_expression_id
-            return @flow_expression_id
+            @flow_expression_id
         end
 
         def last_expression_id= (fei)

data/test/clone_test.rb

@@ -0,0 +1,51 @@
+
+#
+# Testing OpenWFEru
+#
+# John Mettraux at openwfe.org
+#
+
+require 'test/unit'
+
+require 'openwfe/utils'
+
+
+class FullDupTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    class MyClass
+
+        attr_reader :name
+
+        def initialize (name)
+            @name = name
+        end
+    end
+
+    def test_fulldup
+
+        o0 = MyClass.new("cow")
+
+        o1 = OpenWFE.fulldup(o0)
+
+        assert_not_equal o0.object_id, o1.object_id
+        assert_equal o0.name, o1.name
+    end
+
+    def test_yaml
+
+        require 'yaml'
+
+        o0 = MyClass.new("pig")
+        o1 = YAML.load(o0.to_yaml)
+
+        assert_not_equal o0.object_id, o1.object_id
+        assert_equal o0.name, o1.name
+    end
+
+end

data/test/concurrence_test.rb

@@ -0,0 +1,78 @@
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 15:41:44 JST 2006
+#
+# Kita Yokohama
+#
+
+require 'test/unit'
+
+#require 'openwfe/workitem'
+#require 'openwfe/flowexpressionid'
+require 'openwfe/engine/engine'
+require 'openwfe/expressions/raw_prog'
+require 'openwfe/worklist/storeparticipant'
+
+include OpenWFE
+
+
+class ConcurrenceAndParticipantTest < Test::Unit::TestCase
+
+    def setup
+        @engine = Engine.new()
+    end
+
+    #def teardown
+    #end
+
+    #
+    # concurrence test
+
+    class Hpc0 < ProcessDefinition
+        concurrence do
+            #participant :alice
+            #participant :bob
+            alice
+            bob
+        end
+    end
+
+    def test_hpc_0
+
+        @hpAlice = HashParticipant.new
+        @hpBob = HashParticipant.new
+
+        @engine.register_participant(:alice, @hpAlice)
+        @engine.register_participant(:bob, @hpBob)
+
+        @engine.launch(Hpc0)
+
+        sleep 0.100
+
+        assert_equal @hpAlice.size, 1
+        assert_equal @hpBob.size, 1
+    end
+
+    def test_1
+
+        @engine.register_participant :alice do |workitem|
+            puts "alice in"
+            sleep 0.100
+            puts "alice out"
+        end
+        @engine.register_participant :bob do |workitem|
+            puts "bob in"
+            sleep 0.100
+            puts "bob out"
+        end
+
+        @engine.launch Hpc0
+
+        sleep 2
+    end
+
+end
+

data/test/cron_test_2.rb

@@ -0,0 +1,50 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 16:18:25 JST 2006
+#
+
+require 'test/unit'
+
+require 'openwfe/util/otime'
+require 'openwfe/util/scheduler'
+
+
+#
+# testing otime and the scheduler (its cron aspect)
+#
+class CronTest2 < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def t_0
+
+        $var = 0
+
+        scheduler = OpenWFE::Scheduler.new
+        scheduler.start
+
+        scheduler.schedule '* * * * *' do
+            $var += 1
+        end
+
+        sleep 1
+        scheduler.stop
+
+        puts Time.now
+        puts "XXX #{$var}" if $var != 0
+    end
+
+    def test_0
+        300.times do 
+            t_0
+        end
+    end
+end