openwferu 0.9.10.653 → 0.9.11

data/lib/openwfe/worklist/storelocks.rb

@@ -0,0 +1,288 @@
+#
+#--
+# 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.
+#++
+#
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'thread'
+require 'openwfe/contextual'
+require 'openwfe/util/otime'
+
+
+module OpenWFE
+
+    #
+    # TODO #11162 : turn this class into a mixin
+    #
+
+
+    #
+    # A wrapper for a Store[Participant] that includes a lock system.
+    #
+    class StoreWithLocks
+        include Contextual
+
+        DEFAULT_LOCK_MAX_AGE = "1h"
+
+        attr_accessor :lock_max_age
+        attr_reader :store
+
+        #
+        # Builds a new store with a lock system wrapping a 'real_store'.
+        # 
+        # This parameter 'real_store' may be a Class, like in
+        #
+        #     store = StoreWithLocks.new(HashParticipant)
+        #
+        # You can retrieve the 'real store' with 
+        #
+        #     real_store = store.store
+        #
+        # By default, a lock is kept for one hour. You can change that
+        # value with, for example :
+        #
+        #     store = StoreWithLocks.new(HashParticipant, :lock_max_age => "30m10s"
+        #
+        # (setting the lock maximum age to thirty minutes and 10 seconds).
+        #
+        def initialize (real_store, application_context=nil, params={})
+
+            @store = real_store
+            @store = @store.new if @store.kind_of?(Class)
+
+            self.application_context = application_context
+
+            @lock_max_age = params[:lock_max_age] || DEFAULT_LOCK_MAX_AGE
+            @lock_max_age = OpenWFE::parse_time_string @lock_max_age
+
+            @locks = {}
+            @lock_mutex = Mutex.new
+        end
+
+        #
+        # Sets the application context of this store lock and of the 
+        # real store behind.
+        #
+        def application_context= (ac)
+
+            @application_context = ac
+
+            if @store.respond_to?(:application_context=) and \
+                not store.application_context
+
+                @store.application_context = @application_context
+            end
+        end
+
+        #
+        # Get a workitem, lock it and then return it. Ensures that no other
+        # 'locker' can lock it meanwhile.
+        #
+        def get_and_lock (locker, key)
+
+            @lock_mutex.synchronize do
+
+                object = @store[key]
+
+                return nil unless object
+
+                not_locked?(key)
+
+                @locks[key] = [ locker, Time.now.to_i ]
+                object
+            end
+        end
+
+        alias :lock :get_and_lock
+
+        #
+        # Gets a workitem without locking it.
+        #
+        def get (key)
+            @store[key]
+        end
+
+        #
+        # Removes a lock set on an item.
+        # If the item was locked by some other locker, will raise an exception.
+        # If the item was not locked, will simply exit silently.
+        #
+        def release (locker, key)
+
+            @lock_mutex.synchronize do
+                holding_lock? locker, key
+                @locks.delete key
+            end
+        end
+
+        #
+        # Returns the locker currently holding a given object 
+        # (known by its key).
+        # Will return nil if the object is not locked (or doesn't exist).
+        #
+        def get_locker (key)
+
+            lock = get_lock key
+            return nil unless lock
+            lock[0]
+        end
+
+        #
+        # Saves the workitem and releases the lock on it.
+        #
+        def save (locker, workitem)
+
+            save_or_forward :save, locker, workitem
+        end
+
+        #
+        # Forwards the workitem (to the engine) and releases the lock on
+        # it (of course, it's not in the store anymore).
+        #
+        def forward (locker, workitem)
+
+            save_or_forward :forward, locker, workitem
+        end
+
+        alias :proceed :forward
+
+        #
+        # Directly forwards the list_workitems() call to the wrapped store.
+        #
+        def list_workitems (workflow_instance_id=nil)
+            @store.list_workitems(workflow_instance_id)
+        end
+
+        #
+        # Returns the count of workitems in the store.
+        #
+        def size
+            @store.size
+        end
+
+        #
+        # Just calls the consume method of the underlying store.
+        #
+        def consume (workitem)
+            @store.consume workitem
+        end
+
+        #
+        # Iterates over the workitems in the store.
+        #
+        # Doesn't care about any order for now.
+        #
+        def each (&block) # :yields: workitem, locked
+            return unless block
+            @store.each do |fei, workitem|
+                block.call workitem, locked?(fei)
+            end
+        end
+
+        protected
+
+            def save_or_forward (method, locker, workitem)
+
+                @lock_mutex.synchronize do
+                    holding_lock? locker, workitem.fei
+                    @locks.delete workitem.fei
+                    @store.send method, workitem
+                end
+            end
+
+            #
+            # Returns the lock info (else nil) for the given key.
+            #
+            def get_lock (key)
+
+                lock = @locks[key] 
+
+                return nil unless lock
+
+                l, lt = lock
+
+                if (Time.now.to_i - lt) > @lock_max_age
+                    @locks.delete key
+                    return nil
+                end
+
+                [ l, lt ]
+            end
+
+            #
+            # Returns true if the object is locked
+            #
+            def locked? (key)
+                @locks[key] != nil
+            end
+
+            #
+            # Will raise an exception if the object (designated via its key)
+            # is already locked.
+            #
+            def not_locked? (key)
+
+                raise "already locked" if get_lock key
+            end
+
+            #
+            # Will raise an exception if the locker is not holding a lock
+            # for the given key.
+            #
+            def holding_lock? (locker, key)
+
+                lock = get_lock key
+                raise "not locked" unless lock
+                l, lt = lock
+                raise "locked by someone else" if (l != locker)
+                # else, simply end
+            end
+
+            #--
+            # Sets the lock on a given key to 'now'.
+            #
+            #def touch_lock (key)
+            #    lock = @locks[key]
+            #    return false unless lock
+            #    locker, lock_time = lock
+            #    @locks[key] = [ locker, Time.now.to_i ]
+            #    true
+            #end
+            #++
+    end
+end
+

data/lib/openwfe/worklist/storeparticipant.rb

@@ -68,8 +68,10 @@ module OpenWFE
         include LocalParticipant
         include FeiMixin
 
-        #def initialize ()
-        #end
+        #
+        # optional field (only used by the old rest interface for now)
+        #
+        attr_accessor :store_name
 
         #
         # Called by the engine (the participant expression) when handing

data/lib/openwfe/worklist/worklist.rb

@@ -0,0 +1,297 @@
+#
+#--
+# 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/engine/engine'
+require 'openwfe/participants/participant'
+
+
+module OpenWFE
+
+    #
+    # An OpenWFEja-style worklist.
+    #
+    class Worklist
+        include LocalParticipant
+
+        attr_reader :stores
+
+        #
+        # Builds a new worklist.
+        #
+        # Parameters are :
+        #
+        # - :auth_system : something with an authenticate(user, pass) and an
+        #   optional authorised?(user, store, action) methods.
+        # - :launchables : an array of URLs : launchables, in this basic 
+        #   implementation, all users share the same list
+        #
+        def initialize (application_context, params)
+
+            @application_context = application_context
+
+            as = params[:auth_system]
+
+            @auth_system = if as == nil
+                DefaultAuthSystem.new
+            elsif as.kind_of?(Hash)
+                DefaultAuthSystem.new(as)
+            else
+                as
+            end
+
+            @stores = []
+        end
+
+        def consume (workitem)
+
+            pname = workitem.participant_name
+
+            each_store do |regex, store_name, store|
+
+                next unless pname.match regex
+
+                store.consume workitem
+                break
+            end
+        end
+
+        #
+        # A simple call to the authentify method of the @auth_system
+        # passed a initialization time.
+        #
+        def authenticate (user, pass)
+            @auth_system.authenticate(user, pass)
+        end
+
+        #
+        # Returns a string like "rwd" or "rw" or even "".
+        #
+        # Read / Write / Delegate
+        #
+        def get_permissions (user, store_name)
+            s = ""
+            [ :read, :write, :delegate ].each do |action|
+                s << action.to_s[0, 1] \
+                    if @auth_system.authorized?(user, store_name, action)
+            end
+            s
+        end
+
+        #
+        # For now, just a shortcut for 
+        #
+        #     @stores << [ regex, store_name, store]
+        #
+        def add_store (regex, store_name, store)
+
+            @stores << [ regex, store_name, store]
+
+            store.application_context = @application_context \
+                if store.respond_to?(:application_context=)
+        end
+
+        #
+        # Well, this implementation just returns workitems
+        #
+        def get_headers (user, store_name, limit)
+
+            authorized?(user, store_name, :read)
+
+            l = []
+
+            get_store(store_name).each do |workitem, locked|
+                break if limit and l.size >= limit
+                l << [ workitem, locked ]
+            end
+
+            l
+        end
+
+        def get (user, store_name, fei)
+            authorized?(user, store_name, :read)
+            get_store(store_name).get(fei)
+        end
+        def get_and_lock (user, store_name, fei)
+            authorized?(user, store_name, :write)
+            get_store(store_name).get_and_lock(user, fei)
+        end
+
+        def release (user, store_name, wi_or_fei)
+
+            authorized?(user, store_name, :write)
+
+            fei = wi_or_fei
+            fei = fei.fei if fei.respond_to?(:fei)
+
+            get_store(store_name).release(user, fei)
+        end
+
+        def save (user, store_name, workitem)
+            authorized?(user, store_name, :write)
+            get_store(store_name).save(user, workitem)
+        end
+        def forward (user, store_name, workitem)
+            authorized?(user, store_name, :write)
+            get_store(store_name).forward(user, workitem)
+        end
+        def list_workitems (user, store_name, workflow_instance_id=nil)
+            authorized?(user, store_name, :read)
+            get_store(store_name).list_workitems(workflow_instance_id)
+        end
+
+        def delegate (user, from_store_name, to_store_name)
+            authorized?(user, from_store_name, :write)
+            authorized?(user, to_store_name, :write)
+            # TODO : continue me
+        end
+
+        #
+        # Iterates over each of the stores in this worklist.
+        #
+        def each_store (&block) # :yields: regex, store_name, store
+
+            return unless block
+
+            @stores.each do |v|
+                regex, store_name, store = v
+                block.call regex, store_name, store
+            end
+        end
+
+        #
+        # Returns the first store whose regex matches the given
+        # store_name.
+        #
+        def lookup_store (store_name)
+            each_store do |regex, name, store|
+                return store if regex.match store_name
+            end
+            nil
+        end
+
+        #
+        # Returns the store instance with the given name.
+        #
+        def get_store (store_name)
+            each_store do |regex, s_name, store|
+                return store if s_name == store_name
+            end
+            nil
+        end
+
+        #
+        # Not really the job of a worklist, but it was in OpenWFEja, so
+        # here it is...
+        #
+        def launch_flow (engine_name, launch_item)
+
+            e = lookup_engine engine_name
+
+            raise "couldn't find engine named '#{engine_name}'" unless e
+
+            if e.is_a? OpenWFE::Engine
+
+                e.launch launch_item
+
+            elsif e.is_a? OpenWFE::Participant
+
+                e.consume launch_item
+
+            else
+                raise \
+                    "cannot launch a flow via something of "+
+                    "class #{e.class.name}"
+            end
+        end
+
+        protected
+
+            #
+            # This method is called when a launch_flow request is coming,
+            # it will lookup in the participant map to find the way (the
+            # Participant implementation) to deliver the launch_item to the
+            # engine.
+            #
+            # If there is no engine with that name, the default (local) engine
+            # is returned (and will thus be used to launch the flow).
+            #
+            def lookup_engine (engine_name)
+                e = get_participant_map.lookup_participant engine_name
+                return e if e
+                get_engine
+            end
+
+            def authorized? (user, store_name, action)
+
+                return true unless @auth_system.respond_to?(:authorized?)
+
+                unless @auth_system.authorized?(user, store_name, action)
+                    raise \
+                        "'#{user}' is not authorized " + 
+                        "to '#{action}' on store '#{store_name}'"
+                end
+
+                true
+            end
+    end
+
+    class DefaultAuthSystem
+
+        def initialize (hash=nil)
+            @hash = hash
+        end
+
+        def authenticate (user, pass)
+            return true unless @hash
+            pass == @hash[user]
+        end
+
+        def authorized? (user, store_name, action)
+            return true unless @hash
+            @hash[user] != nil
+        end
+    end
+
+    #--
+    # persistence...
+    # is handled by the StoreParticipant implementations themselves
+    #++
+
+end
+

data/test/cron_test.rb

@@ -25,25 +25,24 @@ class CronTest < Test::Unit::TestCase
     #end
 
     def test_cron_0
+
         $var = 0
 
-        scheduler = OpenWFE::Scheduler.new()
+        scheduler = OpenWFE::Scheduler.new
         scheduler.start
 
-        sid = scheduler.schedule('* * * * *', nil, CounterSchedulable.new, nil)
+        sid = scheduler.schedule(
+            '* * * * *',
+            :schedulable => CounterSchedulable.new)
 
-        assert \
-            sid,
-            "scheduler did not return a job id"
+        assert sid, "scheduler did not return a job id"
 
-        sleep(120)
+        sleep 120
         scheduler.stop
 
         #puts ">#{$var}<"
 
-        assert \
-            ($var == 2),
-            "cron_0 failed, $var is #{$var}"
+        assert_equal $var, 2, "$var should be at 2, it's at #{$var}"
     end
 
     protected

data/test/eno_test.rb

@@ -30,11 +30,7 @@ class EnoTest < Test::Unit::TestCase
     #
 
     class TestDefinition0 < ProcessDefinition
-        def make
-            process_definition :name => "eno", :revision => "0" do
-                email_notification_participant
-            end
-        end
+        email_notification_participant
     end
 
     def test_eno
@@ -43,18 +39,17 @@ class EnoTest < Test::Unit::TestCase
 
         engine = Engine.new
 
-        eno = EmailNotificationParticipant.new(
-            "mail.google.com",
-            25, 
-            "eno@outoftheblue.co.jp") do | fexp, part, wi |
+        eno = MailParticipant.new(
+            :smtp_server => "mail.google.com"
+            :from_address => "eno@outoftheblue.co.jp"
+        ) do
 
             s = ""
-
             s << "Subject: test 0\n\n"
 
-            s << "konnichiwa.\n\n"
+            s << "konnichiwa. #{Time.now.to_s}\n\n"
 
-            return s
+            s
         end
 
         engine.register_participant("email_notification_participant", eno)
@@ -63,7 +58,9 @@ class EnoTest < Test::Unit::TestCase
 
         li.email_target = ENV["TARGET"]
 
-        engine.launch(li)
+        fei = engine.launch(li)
+
+        engine.wait_for fei
     end
 end