openwferu-scheduler 0.9.9 → 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
 
             #

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: openwferu-scheduler
 version: !ruby/object:Gem::Version 
-  version: 0.9.9
-date: 2007-04-16 00:00:00 +09:00
+  version: 0.9.11
+date: 2007-06-06 00:00:00 +09:00
 summary: OpenWFEru scheduler for Ruby (at, cron and every)
 require_paths: 
 - lib