ruote 0.9.18

data/lib/openwfe/worklist/storeparticipant.rb

@@ -0,0 +1,44 @@
+#
+#--
+# 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
+#
+
+#
+# this "openwfe/worklist/storeparticipant" has been deprecated for
+#
+require 'openwfe/participants/storeparticipants'
+

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/README.txt

@@ -0,0 +1,27 @@
+= OpenWFEru - about the unit tests
+
+There are three tests triggerable by Rake :
+
+   rake test
+   rake qtest
+   rake ptest
+
+These 3 tests correspond to the following unit test files *
+
+   test/rake_test.rb
+   test/rake_qtest.rb
+   test/rake_ptest.rb
+
+== test/rake_test.rb
+
+Triggers 'quicktests' and time based tests. Running "rake test" takes 10 seconds more than "rake qtest". These are the 10 seconds necessary to test some time and scheduling aspects of OpenWFEru.
+
+== test/rake_qtest.rb
+
+Runs only 'quick' tests.
+
+== test/rake_ptest.rb
+
+Runs the quicktest but with persistence on. Persistence stores its work file under the work/ directory.
+This set of tests takes care of wiping fresh the work/ directory before beginning the tests.
+

data/test/back_0916_test.rb

@@ -0,0 +1,111 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Feb 19 10:58:43 JST 2008
+#
+
+require 'rubygems'
+
+require 'test/unit'
+require 'fileutils'
+require 'openwfe/def'
+require 'openwfe/engine/file_persisted_engine'
+
+
+class Back0916Test < Test::Unit::TestCase
+
+    WORK = 'work_back'
+
+    def setup
+
+        FileUtils.rm_rf WORK
+        FileUtils.mkdir WORK
+
+        `cd work_back && tar xzvf ../test/expool_20031219_0916.tgz`
+
+        ac = { :work_directory => WORK }
+
+        @engine = OpenWFE::FilePersistedEngine.new ac
+    end
+
+    def teardown
+
+        $OWFE_LOG.level = Logger::INFO
+        FileUtils.rm_rf WORK
+    end
+
+    def test_0
+
+        $OWFE_LOG.level = Logger::DEBUG
+
+        trace = []
+
+        @engine.register_participant :alpha do
+            trace << :alpha
+        end
+
+        @engine.reload
+
+        ps = @engine.process_status "20080212-moshijuzuke" # an XML process
+        #p ps.expressions.collect { |e| e.fei.to_s }
+        exp = ps.expressions.first
+        wi = exp.applied_workitem
+        wi.message = "back from obsolesence"
+
+        @engine.reply wi
+
+        sleep 0.350
+
+        assert_equal [ :alpha ], trace
+
+        ps = @engine.process_status "20080212-moshijuzuke"
+        #puts ps.size
+        #puts ps.collect { |e| e.fei.to_s }.join("\n")
+
+        assert_nil ps
+
+        @engine.stop
+
+        sleep 0.300
+    end
+
+    def test_1
+
+        $OWFE_LOG.level = Logger::DEBUG
+
+        trace = []
+
+        #@engine.register_participant :employee do
+        #    trace << :assistant
+        #end
+        #@engine.register_participant :employee do
+        #    trace << :employee
+        #end
+        [ :user_bob, :user_alice ].each do |p|
+            @engine.register_participant p do
+                trace << p
+            end
+        end
+
+        @engine.reload
+
+        ps = @engine.process_status "20080213-depejetzube" # an ruby procdef
+        exp = ps.expressions.first
+        wi = exp.applied_workitem
+
+        @engine.reply wi
+
+        sleep 0.400
+
+        assert_equal [ :user_bob, :user_bob ], trace
+
+        assert_nil @engine.process_status("20080213-depejetzube")
+
+        @engine.stop
+
+        sleep 0.300
+    end
+end