recurrent 0.1.0 → 0.2.0

data/README.markdown

@@ -35,7 +35,7 @@ Use the every method to create tasks.
     end
 
 ####Frequency
-  The first argument is the frequency, it can be an integer in seconds, including ActiveSupport style 2.hours, 3.weeks etc, or an [IceCube::Rule](http://seejohncode.com/ice_cube/)
+  The first argument is the frequency, it can be an integer in seconds, including ActiveSupport style 2.hours, 3.weeks etc, or an [IceCube::Schedule](http://seejohncode.com/ice_cube/)
 ####Name
   The second argument is the name of the task
 ####Options

data/bin/recurrent

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-$: << File.expand_path("#{File.dirname(__FILE__)}/../lib")
 require 'rubygems'
 require 'trollop'
 
@@ -16,5 +15,5 @@ begin
 rescue LoadError
   require 'recurrent'
 end
-
+$0 = "recurrent:worker:started-#{Time.now.to_s(:logging)}"
 Recurrent::Worker.new(opts).start

data/lib/recurrent/configuration.rb

@@ -19,7 +19,7 @@ module Recurrent
           ")
         end
       end
-      block_accessor :logger, :save_task_schedule, :load_task_schedule, :save_task_return_value, :process_locking, :handle_slow_task
+      block_accessor :logger, :save_task_schedule, :load_task_schedule, :save_task_return_value, :load_task_return_value, :process_locking, :handle_slow_task, :setup
 
     end
   end

data/lib/recurrent/ice_cube_extensions.rb

@@ -1,5 +1,12 @@
 module IceCube
   class Rule
+
+    def ==(another_rule)
+      ['@interval', '@validation_types', '@validations'].all? do |variable|
+        self.instance_variable_get(variable) == another_rule.instance_variable_get(variable)
+      end && self.class.name == another_rule.class.name
+    end
+
     def frequency_in_seconds
       rule_type = self.class
       if rule_type == IceCube::YearlyRule
@@ -19,4 +26,12 @@ module IceCube
       end
     end
   end
-end
+
+  class Schedule
+    attr_writer :start_date
+
+    def has_same_rules?(other_schedule)
+      self.rrules == other_schedule.rrules
+    end
+  end
+end

data/lib/recurrent/scheduler.rb

@@ -41,50 +41,26 @@ module Recurrent
     end
 
     def create_schedule(name, frequency, start_time=nil)
-      logger.info "| Creating schedule"
-      if frequency.is_a? IceCube::Rule
-        logger.info "| Frequency is an IceCube Rule: #{frequency.to_s}"
-        rule = frequency
-        frequency_in_seconds = rule.frequency_in_seconds
+      saved_schedule = Configuration.load_task_schedule.call(name) if Configuration.load_task_schedule
+      new_schedule = frequency.is_a?(IceCube::Schedule) ? frequency : create_schedule_from_frequency(frequency, start_time)
+      if saved_schedule
+        use_saved_schedule_if_rules_match(saved_schedule, new_schedule)
       else
-        logger.info "| Frequency is an integer: #{frequency}"
-        rule = create_rule_from_frequency(frequency)
-        logger.info "| IceCube Rule created: #{rule.to_s}"
-        frequency_in_seconds = frequency
+        new_schedule
       end
-      start_time ||= derive_start_time(name, frequency_in_seconds)
+    end
+
+    def create_schedule_from_frequency(frequency, start_time=nil)
+      logger.info "| Frequency is an integer: #{frequency}"
+      rule = create_rule_from_frequency(frequency)
+      logger.info "| IceCube Rule created: #{rule.to_s}"
+      frequency_in_seconds = frequency
+      start_time ||= derive_start_time_from_frequency(frequency_in_seconds)
       schedule = IceCube::Schedule.new(start_time)
       schedule.add_recurrence_rule rule
-      logger.info "| schedule created"
       schedule
     end
 
-    def derive_start_time(name, frequency)
-      logger.info "| No start time provided, deriving one."
-      if Configuration.load_task_schedule
-        logger.info "| Attempting to derive from saved schedule"
-        derive_start_time_from_saved_schedule(name, frequency)
-      else
-        derive_start_time_from_frequency(frequency)
-      end
-    end
-
-    def derive_start_time_from_saved_schedule(name, frequency)
-      saved_schedule = Configuration.load_task_schedule.call(name)
-      if saved_schedule
-        logger.info "| Saved schedule found"
-        if saved_schedule.rrules.first.frequency_in_seconds == frequency
-          logger.info "| Saved schedule frequency matches, setting start time to saved schedules next occurrence: #{saved_schedule.next_occurrence.to_s(:seconds)}"
-          saved_schedule.next_occurrence
-        else
-          logger.info "| Schedule frequency does not match saved schedule frequency"
-          derive_start_time_from_frequency(frequency)
-        end
-      else
-        derive_start_time_from_frequency(frequency)
-      end
-    end
-
     def derive_start_time_from_frequency(frequency)
       logger.info "| Deriving start time from frequency"
       current_time = Time.now
@@ -135,6 +111,16 @@ module Recurrent
       end
     end
 
+    def use_saved_schedule_if_rules_match(saved_schedule, new_schedule)
+      if new_schedule.has_same_rules? saved_schedule
+        logger.info "| Schedule matches a saved schedule, using saved schedule."
+        saved_schedule.start_date = saved_schedule.next_occurrence
+        saved_schedule
+      else
+        new_schedule
+      end
+    end
+
     def self.define_frequencies(*frequencies)
       frequencies.each do |frequency|
         method_name = frequency == :day ? :daily? : :"#{frequency}ly?"

data/lib/recurrent/task.rb

@@ -15,8 +15,18 @@ module Recurrent
       return handle_still_running(execution_time) if running?
       @thread = Thread.new do
         Thread.current["execution_time"] = execution_time
-        return_value = action.call
-        save_results(return_value) if save?
+        begin
+          if Configuration.load_task_return_value && action.arity == 1
+            previous_value = Configuration.load_task_return_value.call(name)
+            return_value = action.call(previous_value)
+          else
+            return_value = action.call
+          end
+          save_results(return_value) if save?
+        rescue => e
+          logger.warn("#{name} - #{e.message}")
+          logger.warn(e.backtrace)
+        end
       end
     end
 
@@ -28,8 +38,8 @@ module Recurrent
     end
 
     def next_occurrence
-      return @next_occurrence if @next_occurrence && @next_occurrence.future?
-      @next_occurrence = schedule.next_occurrence
+      occurrence = schedule.next_occurrence
+      schedule.start_date = occurrence
     end
 
     def save?

data/lib/recurrent/version.rb

@@ -1,3 +1,3 @@
 module Recurrent
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/recurrent/worker.rb

@@ -4,6 +4,7 @@ module Recurrent
     attr_accessor :scheduler, :logger
 
     def initialize(options={})
+      Configuration.setup.call if Configuration.setup
       file = options[:file]
       @scheduler = Scheduler.new(file)
       if options[:every]
@@ -61,7 +62,7 @@ module Recurrent
       lock_established = nil
       until lock_established
         break if $exit
-        lock_established = Configuration.process_locking.call do
+        lock_established = Configuration.process_locking.call(*scheduler.tasks.map(&:name)) do
           execute
         end
         break if $exit

data/spec/scheduler_spec.rb

@@ -55,17 +55,16 @@ module Recurrent
         end
       end
 
-      describe "create_schedule" do
-        context "when frequency is an IceCube Rule" do
-          subject do
+      describe "#create_schedule" do
+        context "when frequency is an IceCube::Schedule" do
+          before :each do
             rule = IceCube::Rule.daily(1)
-            @scheduler.create_schedule(:test, rule)
-          end
-          it "should be a schedule" do
-            subject.class.should == IceCube::Schedule
+            @schedule = IceCube::Schedule.new(Time.now)
+            @schedule.add_recurrence_rule rule
           end
-          it "should have the correct rule" do
-            subject.rrules.first.is_a? IceCube::DailyRule
+
+          it "returns the schedule" do
+            @scheduler.create_schedule(:test, @schedule).should == @schedule
           end
         end
 
@@ -83,7 +82,7 @@ module Recurrent
 
         context "when start time is not provided" do
           it "should derive its own start time" do
-            @scheduler.should_receive(:derive_start_time)
+            @scheduler.should_receive(:derive_start_time_from_frequency).with(1.day)
             @scheduler.create_schedule(:test, 1.day)
           end
         end
@@ -96,7 +95,7 @@ module Recurrent
         end
       end
 
-      describe "derive_start_time_from_frequency" do
+      describe "#derive_start_time_from_frequency" do
         context "when the current time is 11:35:12 am on July 26th, 2011" do
           before(:all) do
             Timecop.freeze(Time.local(2011, 7, 26, 11, 35, 12))
@@ -150,30 +149,26 @@ module Recurrent
         end
       end
 
-      describe "derive_start_time_from_saved_schedule" do
+      describe "A schedule has a saved schedule" do
         before(:all) do
           @scheduler = Scheduler.new
           Configuration.load_task_schedule do |name|
-            current_time = Time.new
-            current_time.change(:sec => 0, :usec => 0)
-            @scheduler.create_schedule(:test, 10.seconds, current_time) if name == :test
+            if name == :test
+              current_time = Time.new
+              current_time.change(:sec => 0, :usec => 0)
+              schedule = IceCube::Schedule.new(current_time)
+              schedule.add_recurrence_rule IceCube::SecondlyRule.new(10)
+              schedule
+            end
           end
         end
 
         describe "a schedule being created with a saved schedule with the same name and frequency" do
-          it "derives its start time from the saved schedule" do
-            @scheduler.should_not_receive(:derive_start_time_from_frequency)
-            @scheduler.create_schedule(:test, 10.seconds)
-          end
-
-          describe "the created schedule's start time" do
-            it "should be the next occurrence of the saved schedule" do
-              saved_schedule = Configuration.load_task_schedule.call(:test)
-              created_schedule = @scheduler.create_schedule(:test, 10.seconds)
-              created_schedule.start_date.to_s(:seconds).should == saved_schedule.next_occurrence.to_s(:seconds)
-            end
+          it "should return the saved schedule with its start time updated to be its next_occurrence" do
+            saved_schedule = Configuration.load_task_schedule.call(:test)
+            created_schedule = @scheduler.create_schedule(:test, 10.seconds)
+            created_schedule.start_date.to_s(:seconds).should == saved_schedule.next_occurrence.to_s(:seconds)
           end
-
         end
 
         describe "a schedule being created with a saved schedule with the same name and different frequency" do

data/spec/task_spec.rb

@@ -10,7 +10,7 @@ module Recurrent
       before :each do
         @executing_task_time = 5.minutes.ago
         @current_time = Time.now
-        @task = Task.new :name => 'execute test', :logger => Logger.new('some identifier')
+        @task = Task.new :name => 'execute test', :logger => Logger.new('some identifier'), :action => proc { 'blah' }
       end
 
       context "The task is still running a previous execution" do
@@ -40,30 +40,64 @@ module Recurrent
         @task.thread['execution_time'].should == @current_time
       end
 
-      it "calls the action" do
-        @task.action.should_receive(:call)
-        @task.execute(@current_time)
+      context "load_task_return_value is configured" do
+        before :each do
+          Configuration.load_task_return_value do
+            "testing"
+          end
+        end
+
+        context "the action doesn't take an argument" do
+          it "calls the action with a nil argument" do
+            @task.action.should_receive(:call)
+            @task.execute(@current_time)
+          end
+        end
+
+        context "the action takes an argument" do
+          before :each do
+            @task.action = proc { |previous_value| "derp" }
+          end
+
+          it "loads the task return value and calls the action with it as an argument" do
+            @task.action.should_receive(:call).with("testing")
+            @task.execute(@current_time)
+          end
+
+          after :each do
+            @task.action = proc { "derp" }
+          end
+        end
+        after :each do
+          Configuration.load_task_return_value = nil
+        end
+      end
+
+      context "load_task_return_value is not configured" do
+
       end
+
+
+
     end
 
     describe "#next_occurrence" do
       context "a task that occurs ever 10 seconds and has just occurred" do
-        subject do
-          current_time = Time.new
-          current_time.change(:sec => 0, :usec => 0)
-          Timecop.freeze(current_time)
-          Task.new(:name => :test, :schedule => Scheduler.new.create_schedule(:test, 10.seconds, current_time))
+        before :each do
+          @current_time = Time.new
+          @current_time.change(:sec => 0, :usec => 0)
+          Timecop.freeze(@current_time)
+          @task = Task.new(:name => :test, :schedule => Scheduler.new.create_schedule(:test, 10.seconds, @current_time))
         end
 
         it "should occur 10 seconds from now" do
-          subject.next_occurrence.should == 10.seconds.from_now
+          @task.next_occurrence.should == 10.seconds.from_now
         end
 
-        it "should cache its next occurrence while it's still valid" do
-          subject.schedule.should_receive(:next_occurrence).and_return(10.seconds.from_now)
-          subject.next_occurrence
-          subject.schedule.should_not_receive(:next_occurrence)
-          subject.next_occurrence
+        it "update the start time of the task to the time of this occurrence because IceCube::Schedule#next_occurrence gets progressively slower the farther back the start time is" do
+          @task.schedule.start_date.should == @current_time
+          @task.next_occurrence.should == 10.seconds.from_now
+          @task.schedule.start_date.should == 10.seconds.from_now
         end
 
         after(:each) do

data/spec/worker_spec.rb

@@ -41,5 +41,23 @@ module Recurrent
         Timecop.return
       end
     end
+
+    describe "setup" do
+      before :each do
+        Configuration.setup do
+          @setup = true
+        end
+      end
+
+      it "runs any configured setup when a worker is created" do
+        @setup.should == nil
+        Worker.new
+        @setup.should == true
+      end
+
+      after :each do
+        Configuration.setup = nil
+      end
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: recurrent
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Adam Kittelson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-09 00:00:00 Z
+date: 2011-08-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ice_cube