ruote 0.9.18

data/lib/openwfe/worklist/oldrest.rb

@@ -0,0 +1,244 @@
+#
+#--
+# 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 'rexml/element'
+require 'openwfe/orest/xmlcodec'
+require 'openwfe/orest/oldrestservlet'
+
+
+module OpenWFE
+
+    #
+    # This webrick servlet provides a REST interface for an old style
+    # OpenWFE worklist.
+    #
+    class OldRestWorklistServlet < OldRestServlet
+
+        def initialize (server, params)
+            super
+            @worklist = params[:Worklist]
+        end
+
+        #
+        # The realm for HTTP authentication.
+        #
+        def get_realm_name
+            "worklist"
+        end
+
+        #
+        # Lists the stores in the worklist
+        #
+        def do__getstorenames (req, res)
+
+            e = REXML::Element.new 'stores'
+
+            @worklist.each_store do |regex, store_name, store|
+
+                perms = @worklist.get_permissions(
+                    req.attributes['username'], store_name)
+
+                es = REXML::Element.new 'store'
+                es.add_attribute 'name', store_name
+                es.add_attribute 'workitem-count', store.size
+                es.add_attribute 'permissions', perms
+                e << es
+            end
+
+            reply_with_xml res, 200, e
+        end
+
+        alias :do__liststores :do__getstorenames
+
+        #
+        # This implementation simply encodes the workitem, no transformation
+        # into headers at all.
+        #
+        def do__getheaders (req, res)
+
+            limit = req.query['limit']
+            limit = limit.to_s.to_i if limit
+            limit = nil if limit and limit < 1
+
+            hs = @worklist.get_headers(
+                req.attributes['username'],
+                get_store_name(req),
+                limit)
+
+            # TODO raise "404 no store named '#{store_name}'" unless store
+            # TODO raise "403 forbidden"
+
+            e = REXML::Element.new 'headers'
+
+            hs.each do |h|
+
+                workitem, locked = h
+
+                e << OpenWFE::XmlCodec::encode_workitem_as_header(
+                    workitem, locked)
+            end
+
+            reply_with_xml res, 200, e
+        end
+
+        #
+        # Launches a new process instance.
+        #
+        def do__launchflow (req, res)
+
+            engine_name = req.query['engineid']
+            engine_name = "__nil__" unless engine_name
+
+            launch_item = OpenWFE::XmlCodec::decode req.body
+
+            r = @worklist.launch_flow engine_name, launch_item
+
+            e = REXML::Element.new 'ok'
+
+            e.add_attribute 'flow-id', r.to_s
+
+            reply_with_xml res, 200, e
+        end
+
+        #
+        # Retrieves a workitem from the worklist
+        #
+        def do__getworkitem (req, res)
+
+            execute_wi_get :get, req, res
+        end
+
+        #
+        # Retrieves a workitem from the worklist, locks it and returns it
+        #
+        def do__getandlockworkitem (req, res)
+
+            execute_wi_get :get_and_lock, req, res
+        end
+
+        #
+        # Returns the flow expression ids of the workitems with a given
+        # workflow instance id in a store.
+        #
+        def do__findflowinstance (req, res)
+
+            store_name = get_store_name req
+
+            wfid = req.query['id']
+            raise "404 'id' not specified" unless wfid
+
+            wis = @worklist.list_workitems(
+                req.attributes['username'], store_name, wfid)
+
+            e = REXML::Element.new 'stores'
+
+            wis.each do |wi|
+                e << OpenWFE::XmlCodec::encode(wi.fei)
+            end
+
+            reply_with_xml res, 200, e
+        end
+
+        #
+        # Releases a workitem (unlocks it).
+        #
+        def do__releaseworkitem (req, res)
+
+            execute_wi_post :release, req, res
+        end
+
+        #
+        # Simply saves the workitem and the modifications done to it.
+        #
+        def do__saveworkitem (req, res)
+
+            execute_wi_post :save, req, res
+        end
+
+        #
+        # Forwards the workitem (makes the worklist reply to the engine
+        # with the modified workitem)
+        #
+        def do__forwardworkitem (req, res)
+
+            execute_wi_post :forward, req, res
+        end
+
+        protected
+
+            def execute_wi_post (method, req, res)
+
+                store_name = get_store_name req
+
+                wi = OpenWFE::XmlCodec::decode req.body
+
+                @worklist.send(
+                    method,
+                    req.attributes['username'], 
+                    store_name, 
+                    wi)
+            end
+
+            def execute_wi_get (method, req, res)
+
+                store_name = get_store_name req
+                fei = OpenWFE::XmlCodec::decode req.body
+
+                wi = @worklist.send(
+                    method, req.attributes['username'], store_name, fei)
+
+                raise "404 no workitem found for #{fei.to_s}" unless wi
+
+                reply_with_wi res, wi
+            end
+
+            def reply_with_wi (res, wi)
+
+                reply_with_xml res, 200, OpenWFE::XmlCodec::encode(wi)
+            end
+
+            def get_store_name (req)
+
+                ss = req.path.split("/")
+                raise "404 'store' not specified" if ss.length != 3
+                ss[-1]
+            end
+    end
+end
+

data/lib/openwfe/worklist/storelocks.rb

@@ -0,0 +1,293 @@
+#
+#--
+# 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
+#
+
+require 'thread'
+require 'rufus/otime'
+require 'openwfe/contextual'
+
+
+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 = Rufus::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
+
+            @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
+