cronjobber 1.0.1 → 1.0.2

data/Rakefile

@@ -14,7 +14,7 @@ begin
     gem.summary = %Q{Cronjob for Rails}
     gem.description = %Q{Enables simple cronjobs for rails}
     gem.email = "giniedp@online.de"
-    gem.homepage = "http://github.com/giniedp/cronjob"
+    gem.homepage = "https://github.com/giniedp/cronjobber"
     gem.authors = ["Alexander Gräfenstein"]
     # gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/app/models/cronjobber/task.rb

@@ -11,10 +11,8 @@ class Cronjobber::Task < ActiveRecord::Base
     self.name.underscore
   end
 
-  def self.cronjob
-    @cronjob ||= self.find_by_name(self.cronjob_name)
-    @cronjob ||= self.create!(:name => self.cronjob_name)
-    @cronjob
+  def self.current_cronjob
+    self.find_by_name(self.cronjob_name) || self.create!(:name => self.cronjob_name)
   end
   
   def self.cronjob_enqueue(key=nil)
@@ -22,7 +20,10 @@ class Cronjobber::Task < ActiveRecord::Base
   end
   
   def self.cronjob_perform
-    unless cronjob.lock!
+    cronjob = self.current_cronjob
+    key = DateTime.now.to_i
+    
+    unless cronjob.lock!(key)
       cronjob.status = "locked"
       return cronjob
     end
@@ -34,10 +35,10 @@ class Cronjobber::Task < ActiveRecord::Base
     end
     
     if self.cronjob_delayed
-      self.cronjob_enqueue(cronjob.locking_key)
       cronjob.status = "enqueued"
       cronjob.last_error = nil
       cronjob.save!
+      self.cronjob_enqueue(key)
     else
       cronjob.send(self.cronjob_method)
       cronjob.status = "performed"
@@ -52,16 +53,20 @@ class Cronjobber::Task < ActiveRecord::Base
   end
   
   def self.cronjob_perform_delayed(key)
-    if cronjob.locked?(key)
+    cronjob = self.current_cronjob
+    
+    if cronjob.locked?(key.to_s)
       cronjob.status = "locked"
     else
       cronjob.send(self.cronjob_method)
       cronjob.status = "performed"
       cronjob.unlock!
     end
+    return cronjob
   rescue Exception => exception
     cronjob.status = "exception"
     cronjob.unlock!(exception)
+    return cronjob
   end
   
   def locked?(key=nil)
@@ -73,47 +78,49 @@ class Cronjobber::Task < ActiveRecord::Base
   end
   
   def lock!(key=nil)
-    return false if self.locked?
-    return self.update_attributes!(:locked_at => DateTime.now, :locking_key => Time.now.to_i)
+    !self.locked? && self.update_attributes!(:locked_at => DateTime.now, :locking_key => key) 
   end
   
   def unlock! exception=nil
-    return true unless self.locked?
-    if exception
-      self.last_error = [exception.message, exception.backtrace].flatten.join("\n")
-      self.total_failures = self.total_failures.to_i + 1
-    else
-      self.last_error = nil
+    self.class.transaction do
+      if exception
+        self.last_error = [exception.message, exception.backtrace].flatten.join("\n")
+        self.total_failures = self.total_failures.to_i + 1
+      else
+        self.last_error = nil
+      end
+      
+      if self.status == "performed"
+        self.total_runs = self.total_runs.to_i + 1
+        self.duration = (Time.now - self.locked_at.to_time) * 1000 if self.locked_at
+        self.run_at = Time.now
+      end
+
+      self.locked_at = nil
+      self.locking_key = nil
+      self.save!
     end
-    
-    self.update_attributes!({
-      :total_runs => self.total_runs.to_i + 1,
-      :locked_at => nil, 
-      :locking_key => nil,
-      :run_at => Time.now, 
-      :duration => (Time.now - self.locked_at.to_time) * 1000
-    })
   end
   
   def self.cronjob_timepoint t1, t2
     result = []
-    t1.to_date.upto(t2.to_date) do |date|
+    (t1 - 1.day).to_date.upto((t2 + 1.day).to_date) do |date|
       self.cronjob_timesteps.each do |time|
         result << Time.parse([date.year, date.month, date.day].join("-") + " " + time.to_s) 
       end
     end
-    result.sort.uniq.select { |time| (time > t1 && time < t2) }.first
+    result.sort.uniq.select { |time| (time > t1 && time <= t2) }.first
   end
   
-  def should_run?(run_at=nil)
-    run_at ||= Time.now
-    t1, t2 = (self.run_at || run_at), run_at
+  def should_run?(at_time=nil)
+    t1 = self.run_at || Time.now
+    t2 = at_time || Time.now
 
     if self.class.cronjob_frequency.to_i == 0
       if self.class.cronjob_timesteps.empty?
         true
       else
-        self.class.cronjob_timepoint(t1, t2 + 1.day).present?
+        self.class.cronjob_timepoint(t1, t2).present?
       end
     else
       if self.class.cronjob_timesteps.empty?

data/cronjobber.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "cronjobber"
-  s.version = "1.0.1"
+  s.version = "1.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alexander Gr\303\244fenstein"]
-  s.date = "2012-01-11"
+  s.date = "2012-01-16"
   s.description = "Enables simple cronjobs for rails"
   s.email = "giniedp@online.de"
   s.extra_rdoc_files = [
@@ -65,7 +65,7 @@ Gem::Specification.new do |s|
     "spec/dummy/script/rails",
     "spec/spec_helper.rb"
   ]
-  s.homepage = "http://github.com/giniedp/cronjob"
+  s.homepage = "https://github.com/giniedp/cronjobber"
   s.require_paths = ["lib"]
   s.rubygems_version = "1.8.15"
   s.summary = "Cronjob for Rails"

data/spec/cronjobber_spec.rb

@@ -68,7 +68,7 @@ describe Cronjobber::Task do
       
       class BackgroundJob < Cronjobber::Task
         run_task :in_background => true
-        def self.cronjob_enqueue
+        def self.cronjob_enqueue(key=nil)
           # mock with empty method for testing
         end
       end
@@ -100,13 +100,13 @@ describe Cronjobber::Task do
     end
 
     it "should be locked for invalid key" do
-      @job.lock!.should be true
-      @job.locked?("123456").should be true
+      @job.lock!("123456").should be true
+      @job.locked?("654321").should be true
     end
         
     it "should not be locked for valid key" do
-      @job.lock!.should be true
-      @job.locked?(@job.locking_key).should be false
+      @job.lock!("123456").should be true
+      @job.locked?("123456").should be false
     end
     
     it "should perform the job" do
@@ -136,7 +136,8 @@ describe Cronjobber::Task do
     it "should perform background job with valid key" do
       job = BackgroundJob.cronjob_perform
       job.locked?.should be true
-      BackgroundJob.cronjob_perform_delayed(job.locking_key)
+      job.locking_key.blank?.should be false
+      job = BackgroundJob.cronjob_perform_delayed(job.locking_key)
       job.locked?.should be false
       job.status.should == "performed"
       job.last_error.should be_nil
@@ -145,7 +146,7 @@ describe Cronjobber::Task do
     it "should not perform background job with invalidvalid key" do
       job = BackgroundJob.cronjob_perform
       job.locked?.should be true
-      BackgroundJob.cronjob_perform_delayed("some invalid key")
+      job = BackgroundJob.cronjob_perform_delayed("some invalid key")
       job.locked?.should be true
       job.status.should == "locked"
     end
@@ -156,20 +157,22 @@ describe Cronjobber::Task do
       class TestJob < Cronjobber::Task
         run_task :every => 0.minutes, :at => []
       end
-      @test_job = TestJob.new({ :run_at => Time.parse("2011-1-1 12:00") })
-      @test_job.save!
+      TestJob.destroy_all
+      TestJob.create!({ :name => TestJob.cronjob_name, :run_at => Time.parse("2011-1-1 12:00") })
     end
     
     it "should be runable before run_at time" do
-      @test_job.should_run?(Time.parse("2011-1-1 11:00")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2010-12-31 11:59")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 11:59")).should be true
     end
     
     it "should be runable on run_at time" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:00")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:00")).should be true
     end
     
     it "should be runable after run_at time" do
-      @test_job.should_run?(Time.parse("2011-1-1 13:00")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:01")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-2 12:01")).should be true
     end
   end
   
@@ -178,50 +181,55 @@ describe Cronjobber::Task do
       class TestJob < Cronjobber::Task
         run_task :every => 10.minutes, :at => []
       end
-      @test_job = TestJob.new({ :run_at => Time.parse("2011-1-1 12:00") })
-      @test_job.save!
+      TestJob.destroy_all
+      TestJob.create!({ :name => TestJob.cronjob_name, :run_at => Time.parse("2011-1-1 12:00") })
     end
     
     it "should not be runable before run_at time" do
-      @test_job.should_run?(Time.parse("2011-1-1 11:00")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 11:00")).should be false
     end
     
     it "should not be runable on run_at time" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:00")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:00")).should be false
     end
     
     it "should not be runable after run_at time before frequency elapses" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:09")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:09")).should be false
     end
     
     it "should be runable after run_at time after frequency elapsed" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:10")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:10")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:11")).should be true
     end
   end
   
   describe "without frequency and with time" do
     before :each do
       class TestJob < Cronjobber::Task
-        run_task :every => 0.minutes, :at => ["12:00"]
+        run_task :at => ["12:00"]
       end
-      @test_job = TestJob.new({ :run_at => Time.parse("2011-1-1 12:00") })
-      @test_job.save!
+      TestJob.destroy_all
+      TestJob.create!({ :name => TestJob.cronjob_name, :run_at => Time.parse("2011-1-1 12:00") })
     end
     
-    it "should not be runable before run_at time" do
-      @test_job.should_run?(Time.parse("2010-1-1 11:00")).should be false
-      @test_job.should_run?(Time.parse("2011-1-1 11:00")).should be false
-      @test_job.should_run?(Time.parse("2011-1-1 11:59")).should be false
+    it "should not be runable before next run at time" do
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 11:59")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:00")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:01")).should be false
+      
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-2 11:59")).should be false
     end
     
-    it "should not be runable on run_at time" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:00")).should be false
+    it "should not be runable on run_at time on same day" do
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:00")).should be false
     end
     
-    it "should be runable after run_at time" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:01")).should be true
-      @test_job.should_run?(Time.parse("2011-1-1 13:00")).should be true
-      @test_job.should_run?(Time.parse("2012-1-1 12:01")).should be true
+    it "should be runable on next run_at time" do
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-2 12:00")).should be true
+    end
+    
+    it "should be runable after next run_at time" do
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-2 12:01")).should be true
     end
   end
   
@@ -230,26 +238,26 @@ describe Cronjobber::Task do
       class TestJob < Cronjobber::Task
         run_task :every => 30.minutes, :at => ["12:00"]
       end
-      @test_job = TestJob.new({ :run_at => Time.parse("2011-1-1 12:00") })
-      @test_job.save!
+      TestJob.destroy_all
+      TestJob.create!({ :name => TestJob.cronjob_name, :run_at => Time.parse("2011-1-1 12:00") })
     end
     
     it "should not be runable before run_at time" do
-      @test_job.should_run?(Time.parse("2010-1-1 11:00")).should be false
-      @test_job.should_run?(Time.parse("2011-1-1 11:00")).should be false
-      @test_job.should_run?(Time.parse("2011-1-1 11:59")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2010-1-1 11:00")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 11:00")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 11:59")).should be false
     end
     
     it "should not be runable after run_at within frequency time" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:00")).should be false
-      @test_job.should_run?(Time.parse("2011-1-1 12:01")).should be false
-      @test_job.should_run?(Time.parse("2011-1-1 12:29")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:00")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:01")).should be false
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:29")).should be false
     end
     
     it "should be runable after run_at time after frequency time" do
-      @test_job.should_run?(Time.parse("2011-1-1 12:30")).should be true
-      @test_job.should_run?(Time.parse("2011-1-1 13:31")).should be true
-      @test_job.should_run?(Time.parse("2012-1-1 12:00")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 12:30")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2011-1-1 13:31")).should be true
+      TestJob.current_cronjob.should_run?(Time.parse("2012-1-1 12:00")).should be true
     end
   end
   

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cronjobber
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - "Alexander Gr\xC3\xA4fenstein"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-11 00:00:00 Z
+date: 2012-01-16 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   type: :development
@@ -104,7 +104,7 @@ files:
 - spec/dummy/public/stylesheets/.gitkeep
 - spec/dummy/script/rails
 - spec/spec_helper.rb
-homepage: http://github.com/giniedp/cronjob
+homepage: https://github.com/giniedp/cronjobber
 licenses: []
 
 post_install_message: