openwferu 0.9.10.653 → 0.9.11

data/lib/openwfe/util/scheduler.rb

@@ -81,9 +81,15 @@ module OpenWFE
     #
     #    regenerator = Regenerator.new
     #
-    #    scheduler.schedule_in("4d", regenerator, :monthly)
+    #    scheduler.schedule_in("4d", regenerator)
     #        # 
-    #        # will regenerate the monthly report in four days
+    #        # will regenerate the report in four days
+    #
+    #    scheduler.schedule_in(
+    #        "5d", 
+    #        { :schedulable => regenerator, :scope => :month })
+    #            #
+    #            # will regenerate the monthly report in 5 days
     #
     # There is also schedule_every() :
     #
@@ -178,9 +184,11 @@ module OpenWFE
         # Schedules a job by specifying at which time it should trigger.
         # Returns the a job_id that can be used to unschedule the job.
         #
-        def schedule_at (at, schedulable=nil, params=nil, &block)
+        def schedule_at (at, params={}, &block)
+
+            params = prepare_params(params)
 
-            sschedule_at(false, at, nil, schedulable, params, &block)
+            sschedule_at(at, params, &block)
         end
 
 
@@ -188,12 +196,12 @@ module OpenWFE
         # Schedules a job by stating in how much time it should trigger.
         # Returns the a job_id that can be used to unschedule the job.
         #
-        def schedule_in (duration, schedulable=nil, params=nil, &block)
+        def schedule_in (duration, params={}, &block)
 
             duration = duration_to_f(duration)
+            params = prepare_params(params)
 
-            return schedule_at(
-                Time.new.to_f + duration, schedulable, params, &block)
+            schedule_at(Time.new.to_f + duration, params, &block)
         end
 
         #
@@ -210,9 +218,29 @@ module OpenWFE
         #         end
         #     end
         #
-        def schedule_every (freq, schedulable=nil, params=nil, &block)
+        def schedule_every (freq, params={}, &block)
+
+            f = duration_to_f freq
+
+            params = prepare_params params
+            schedulable = params[:schedulable]
+            params[:every] = true
 
-            sschedule_every(freq, nil, schedulable, params, &block)
+            sschedule_at Time.new.to_f + f, params do |job_id, at|
+
+                params[:job_id] = job_id
+
+                if schedulable
+                    schedulable.trigger(params)
+                else
+                    block.call job_id, at
+                end
+                
+                schedule_every(f, params, &block) \
+                    unless @dont_reschedule_every
+
+                job_id
+            end
         end
 
         #
@@ -224,14 +252,12 @@ module OpenWFE
 
                 for i in 0...@pending_jobs.length
                     if @pending_jobs[i].eid == job_id
-                        @pending_jobs.delete_at(i)
+                        @pending_jobs.delete_at i
                         return true
                     end
                 end
 
-                return true if unschedule_cron_job(job_id)
-
-                return false
+                unschedule_cron_job job_id
             end
         end
 
@@ -241,10 +267,10 @@ module OpenWFE
         def unschedule_cron_job (job_id)
             synchronize do
                 if @cron_entries.has_key?(job_id)
-                    @cron_entries.delete(job_id)
+                    @cron_entries.delete job_id
                     return true
                 end
-                return false
+                false
             end
         end
 
@@ -255,11 +281,11 @@ module OpenWFE
         #
         # For example :
         #
-        #    scheduler.schedule("5 0 * * *", nil, s, p)
-        #        # will trigger the schedulable s with params p every day
+        #    scheduler.schedule("5 0 * * *", s)
+        #        # will trigger the schedulable s every day
         #        # five minutes after midnight
         #
-        #    scheduler.schedule("15 14 1 * *", nil, s, p)
+        #    scheduler.schedule("15 14 1 * *", s)
         #        # will trigger s at 14:15 on the first of every month
         #
         #    scheduler.schedule("0 22 * * 1-5") do
@@ -270,29 +296,28 @@ 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, params={}, &block)
 
             synchronize do
+
+                params = prepare_params(params)
             
                 #
                 # is a job with the same id already scheduled ?
 
-                if cron_id and unschedule(cron_id)
-                    ldebug do 
-                        "schedule() unscheduled previous job "+
-                        "under same name '#{cron_id}'"
-                    end
-                end
+                cron_id = params[:cron_id]
+                cron_id = params[:job_id] unless cron_id
+
+                unschedule(cron_id) if cron_id
 
                 #
                 # schedule
 
-                b = to_block(schedulable, params, &block)
+                b = to_block(params, &block)
                 entry = CronEntry.new(cron_id, cron_line, &b)
                 @cron_entries[entry.eid] = entry
 
-                return entry.eid
+                entry.eid
             end
         end
 
@@ -305,11 +330,9 @@ module OpenWFE
             entry = @cron_entries[job_id]
             return entry if entry
 
-            @pending_jobs.each do |entry|
-                return entry if entry.eid == job_id
+            @pending_jobs.find do |entry|
+                entry.eid == job_id
             end
-
-            return nil
         end
 
         #
@@ -323,7 +346,8 @@ module OpenWFE
             j = get_job(job_id)
 
             return j.schedulable if j.respond_to? :schedulable
-            return nil
+
+            nil
         end
 
         #
@@ -359,34 +383,49 @@ module OpenWFE
         # Returns true if the given string seems to be a cron string.
         #
         def Scheduler.is_cron_string (s)
-            return s.match(".+ .+ .+ .+ .+")
+            s.match(".+ .+ .+ .+ .+")
         end
 
         protected
 
-            def sschedule_at (
-                is_every, at, at_id, schedulable=nil, params=nil, &block)
+            #
+            # Making sure that params is a Hash.
+            #
+            def prepare_params (params)
+                params = { :schedulable => params } \
+                    if params.is_a?(Schedulable)
+                params
+            end
+
+            def sschedule_at (at, params={}, &block)
 
                 synchronize do
 
                     #puts "0 at is '#{at.to_s}' (#{at.class})"
 
                     at = OpenWFE::to_ruby_time(at) \
-                        if at.kind_of? String
+                        if at.kind_of?(String)
 
                     at = OpenWFE::to_gm_time(at) \
-                        if at.kind_of? DateTime
+                        if at.kind_of?(DateTime)
 
                     at = at.to_f \
-                        if at.kind_of? Time
+                        if at.kind_of?(Time)
 
                     #puts "1 at is '#{at.to_s}' (#{at.class})"}"
 
-                    jobClass = AtEntry
-                    jobClass = EveryEntry if is_every
+                    jobClass = if params[:every]
+                        EveryEntry
+                    else
+                        AtEntry
+                    end
+
+                    job_id = params[:job_id]
+
+                    b = to_block(params, &block)
+                    job = jobClass.new(at, job_id, &b)
 
-                    b = to_block(schedulable, params, &block)
-                    job = jobClass.new(at, at_id, &b)
+                    unschedule(job_id) if job_id 
 
                     if at < (Time.new.to_f + @precision)
                         job.trigger()
@@ -408,30 +447,10 @@ module OpenWFE
                         end
                     end
 
-                    return push(job)
+                    push(job)
                 end
             end
 
-            def sschedule_every (freq, at_id, schedulable, params, &block)
-
-                f = duration_to_f(freq)
-
-                job_id = sschedule_at(
-                    true, Time.new.to_f + f, at_id) do |eid, at|
-
-                    if schedulable
-                        schedulable.trigger(params)
-                    else
-                        block.call eid, at
-                    end
-                    
-                    sschedule_every(f, eid, schedulable, params, &block) \
-                        unless @dont_reschedule_every
-                end
-
-                job_id
-            end
-
             #
             # Ensures that a duration is a expressed as a Float instance.
             #
@@ -442,22 +461,33 @@ module OpenWFE
             def duration_to_f (s)
                 return s if s.kind_of? Float
                 return OpenWFE::parse_time_string(s) if s.kind_of? String
-                return Float(s.to_s)
+                Float(s.to_s)
             end
 
-            def to_block (schedulable, params, &block)
-                if schedulable
-                    l = lambda do
-                        schedulable.trigger(params)
-                    end
-                    class << l
-                        attr_accessor :schedulable
-                    end
-                    l.schedulable = schedulable
-                    l
-                else
-                    block
+            #
+            # Returns a block. If a block is passed, will return it, else, 
+            # if a :schedulable is set in the params, will return a block 
+            # wrapping a call to it.
+            #
+            def to_block (params, &block)
+
+                return block if block
+
+                schedulable = params[:schedulable]
+
+                return nil unless schedulable
+
+                params.delete :schedulable
+
+                l = lambda do
+                    schedulable.trigger(params)
+                end
+                class << l
+                    attr_accessor :schedulable
                 end
+                l.schedulable = schedulable
+
+                l
             end
 
             #

data/lib/openwfe/util/workqueue.rb

@@ -60,8 +60,8 @@ module OpenWFE
 
             OpenWFE::call_in_thread "expression_pool", self do
                 while true
-                    sleep @workqueue_frequency
                     break if @workqueue_frequency == nil
+                    sleep @workqueue_frequency
                     do_process_workqueue
                 end
             end
@@ -141,17 +141,11 @@ module OpenWFE
             #ldebug { "do_process_workqueue() #{q.size} items to process" }
 
             q.each do |elt|
-                begin
-
-                    do_process_workelement elt
 
-                rescue Exception => e
-
-                    lwarn do
-                        "#{self.service_name} caught an exception\n" + 
-                        OpenWFE::exception_to_s(e)
-                    end
-                end
+                do_process_workelement elt
+                    #
+                    # exception management is now done in the 
+                    # do_process_workelement method
             end
         end
 

data/lib/openwfe/utils.rb

@@ -232,10 +232,10 @@ module OpenWFE
     # Attempts at displaying a nice stack trace
     #
     def OpenWFE.exception_to_s (exception)
-        s = ""
+        s = "exception : "
         s << "#{exception}\n"
         s << exception.backtrace.join("\n")
-        return s
+        s
     end
 
     #
@@ -247,7 +247,7 @@ module OpenWFE
             break if max_lines and index >= max_lines
             s << "   #{line}\n"
         end
-        return s
+        s
     end
 
     #

data/lib/openwfe/version.rb

@@ -34,6 +34,5 @@
 #
 
 module OpenWFE
-    #OPENWFERU_VERSION = '0.9.10'
-    OPENWFERU_VERSION = '0.9.10.653'
+    OPENWFERU_VERSION = '0.9.11'
 end

data/lib/openwfe/workitem.rb

@@ -472,12 +472,11 @@ module OpenWFE
 
     #
     # A header is a summary of a workitem, returned by the getHeader
-    # worklist method
+    # worklist method.
     #
-    class Header
+    class Header < InFlowWorkItem
 
-        attr_accessor \
-            :last_modified, :locked, :flow_expression_id, :attributes
+        attr_accessor :locked
     end
 
 

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/rest/xmlcodec'
+require 'openwfe/rest/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
+