sidekiq_schedulable 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 558a8b58ecf33d2edc81636f2f5ba511100a6378
-  data.tar.gz: 8a4596c211c0f8c14a4dfbe2afe14f1a26c312c9
+  metadata.gz: 1064f6cde72a8cf64dc6d6b8ca33772fd07e82b2
+  data.tar.gz: 353880a557b65213b9638853962aa5cca164f59a
 SHA512:
-  metadata.gz: 8b0da8f414f5fc013f18dd7f4d1c321662f883c3e5e94ccd780f7b280430b86ae76c9f34793508b3e951a7bc3dc2b943e4abeeabe141a7066edda7c31f72c18d
-  data.tar.gz: 2a7ffab36ba92166caffe4e197b86784e4d327a2b484e3d30ee00325ff4bb24e873f7ce868490e36911e1b9d36378bd88995e154bb7a62823ee657a425657b5e
+  metadata.gz: 9cef8200ad866b2e733ca179af8055ae3d3813c29c54c3d62431af7eccd6da041bdc1bc5a9069f0029dafd230c74b9eae98c21e2c3b67ff1a5ef78a78433a401
+  data.tar.gz: e7c691de4d29031ffa8c210fb6d05b4a61716c3832b32bbfbb9b1f1c0f76729270de2ab266e5619fcc2dd85632f673ff4e27e60ee1e756ff46d07ee2d81f4d51

data/lib/sidekiq/schedulable.rb

@@ -5,10 +5,11 @@ module Sidekiq
     end
 
     module ClassMethods
-      def sidekiq_schedule(schedule)
+      def sidekiq_schedule(schedule, options = {})
         SidekiqSchedulable.schedules[self.to_s] = {
           worker: self,
-          at: schedule
+          at: schedule,
+          options: options
         }
       end
     end

data/lib/sidekiq_schedulable.rb

@@ -12,7 +12,7 @@ module SidekiqSchedulable
   def self.boot!
     Sidekiq.configure_server do |config|
       config.server_middleware do |chain|
-        chain.add Middleware::Server
+        chain.add Middleware::Server, schedules
       end
 
       config.client_middleware do |chain|

data/lib/sidekiq_schedulable/middleware/client.rb

@@ -7,7 +7,7 @@ module SidekiqSchedulable
 
       def call(worker_class, item, queue, redis_pool)
         if schedule = @schedules[worker_class]
-          item['schedule'] = schedule[:at]
+          item['scheduled'] = true
         end
         yield
       end

data/lib/sidekiq_schedulable/middleware/server.rb

@@ -3,18 +3,24 @@ require 'sidekiq_schedulable/schedule'
 module SidekiqSchedulable
   module Middleware
     class Server
+      def initialize(schedules = {})
+        @schedules = schedules
+      end
+
       def call(worker, item, queue)
+        start_time = Time.now
         yield
       ensure
-        schedule_next_job(worker, item) if item['schedule']
+        schedule_next_job(item, start_time) if item['scheduled']
       end
 
       private
 
-      def schedule_next_job(worker, item)
-        schedule = item['schedule']
-        time = Schedule.next_time(schedule)
-        worker.class.perform_at(time)
+      def schedule_next_job(item, start_time)
+        class_name = item['class']
+        if schedule = @schedules[class_name]
+          Schedule.enqueue(schedule, start_time)
+        end
       end
     end
   end

data/lib/sidekiq_schedulable/schedule.rb

@@ -2,8 +2,23 @@ require 'parse-cron'
 
 module SidekiqSchedulable
   module Schedule
+    def self.enqueue(schedule, last_run = nil)
+      worker = schedule[:worker]
+      time = next_time(schedule[:at])
+      if schedule[:options][:last_run]
+        last_time = last_run || last_time(schedule[:at])
+        worker.perform_at(time, last_time.to_f)
+      else
+        worker.perform_at(time)
+      end
+    end
+
     def self.next_time(schedule)
       CronParser.new(schedule).next(Time.now)
     end
+
+    def self.last_time(schedule)
+      CronParser.new(schedule).last(Time.now)
+    end
   end
 end

data/lib/sidekiq_schedulable/startup.rb

@@ -12,11 +12,9 @@ module SidekiqSchedulable
     end
 
     def schedule!
-      schedules.each do |worker_class, schedule|
-        unless already_scheduled?(worker_class)
-          time = Schedule.next_time(schedule[:at])
-          worker = schedule[:worker]
-          worker.perform_at(time)
+      schedules.each do |klass_name, schedule|
+        unless already_scheduled?(klass_name)
+          Schedule.enqueue(schedule)
         end
       end
     end
@@ -25,15 +23,15 @@ module SidekiqSchedulable
 
     attr_reader :schedules, :current_jobs
 
-    def already_scheduled?(worker_class)
+    def already_scheduled?(klass_name)
       scheduled_jobs.any? do |job|
-        job.item['class'] == worker_class
+        job.item['class'] == klass_name
       end
     end
 
     def scheduled_jobs
       @scheduled_jobs ||= current_jobs.select do |job|
-        job.item['schedule']
+        job.item['scheduled']
       end
     end
   end

data/lib/sidekiq_schedulable/version.rb

@@ -1,3 +1,3 @@
 module SidekiqSchedulable
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/sidekiq_schedulable_spec.rb

@@ -12,34 +12,65 @@ describe SidekiqSchedulable do
     include Sidekiq::Schedulable
 
     sidekiq_schedule '*/10 * * * * *'
+
+    def perform
+      :done
+    end
+  end
+
+  class AnotherWorker
+    include Sidekiq::Worker
+    include Sidekiq::Schedulable
+
+    sidekiq_schedule '0 12 * * * *', last_run: true
+
+    def perform(last_run)
+      Time.now - Time.at(last_run)
+    end
   end
 
   let(:midnight) { Time.new(2015, 10, 1, 0, 0, 0) }
   let(:next_ten_minutes) { midnight + 10 * 60 }
 
+  let(:schedules) {
+    {
+      'TestWorker' => {
+        worker: TestWorker,
+        at: '*/10 * * * * *',
+        options: {}
+      },
+      'AnotherWorker' => {
+        worker: AnotherWorker,
+        at: '0 12 * * * *',
+        options: { last_run: true }
+      }
+    }
+  }
+
   before do
     Timecop.freeze(midnight)
   end
 
   after do
-    TestWorker.jobs.clear
+    Sidekiq::Worker.clear_all
   end
 
   it "adds the schedule to the schedules" do
-    schedule = SidekiqSchedulable.schedules["TestWorker"]
+    schedule = SidekiqSchedulable.schedules['TestWorker']
 
     expect(schedule[:at]).to eq('*/10 * * * * *')
     expect(schedule[:worker]).to eq(TestWorker)
+    expect(schedule[:options]).to eq({})
   end
 
   describe SidekiqSchedulable::Middleware::Server do
     let(:worker) { TestWorker.new }
-    let(:middleware) { SidekiqSchedulable::Middleware::Server.new }
+    let(:middleware) { SidekiqSchedulable::Middleware::Server.new(schedules) }
 
     it "ensures the job is re-enqueued for next time" do
       expect {
-        middleware.call(worker, { 'schedule' => '*/10 * * * * *' }, 'a queue') do
-          raise "Error"
+        middleware.call(worker, { 'scheduled' => true, 'class' => 'TestWorker' }, 'a_queue') do
+          raise 'Error'
         end
       }.to raise_error RuntimeError, "Error"
 
@@ -50,17 +81,23 @@ describe SidekiqSchedulable do
     end
 
     it "does not re-schedule if the job has no schedule" do
-      middleware.call(worker, {}, 'a queue') do
+      middleware.call(worker, {}, 'a_queue') do
         true
       end
 
       expect(TestWorker.jobs.size).to eq(0)
     end
-  end
 
-  let(:schedules) {
-    { "TestWorker" => { worker: TestWorker, at: '*/10 * * * * *' } }
-  }
+    it "adds the last_run argument based on the last job start time" do
+      middleware.call(worker, { 'scheduled' => true, 'class' => 'AnotherWorker' }, 'a_queue') do
+        true
+      end
+
+      expect(AnotherWorker.jobs.size).to eq(1)
+      expect(AnotherWorker.jobs.first['args']).to eq([Time.now.to_f])
+      expect { AnotherWorker.drain }.to_not raise_error
+    end
+  end
 
   describe SidekiqSchedulable::Middleware::Client do
     let(:middleware) { SidekiqSchedulable::Middleware::Client.new(schedules) }
@@ -68,17 +105,17 @@ describe SidekiqSchedulable do
     it "adds the schedule to the job item" do
       item = {}
 
-      middleware.call("TestWorker", item, "a queue", nil) do
+      middleware.call('TestWorker', item, 'a queue', nil) do
         true
       end
 
-      expect(item['schedule']).to eq('*/10 * * * * *')
+      expect(item['scheduled']).to eq(true)
     end
 
     it "does not add the schedule if the worker has no schedule" do
       item = {}
 
-      middleware.call("Array", item, "a queue", nil) do
+      middleware.call('Array', item, 'a_queue', nil) do
         true
       end
 
@@ -100,6 +137,16 @@ describe SidekiqSchedulable do
       expect(TestWorker.jobs.first['at']).to eq(next_ten_minutes.to_f)
     end
 
+    it "adds the last_run argument based on the schedule" do
+      last_run = midnight - 60 * 60 * 12
+
+      SidekiqSchedulable::Startup.schedule!(schedules, current_jobs)
+
+      expect(AnotherWorker.jobs.size).to eq(1)
+      expect(AnotherWorker.jobs.first['args']).to eq([last_run.to_f])
+      expect { AnotherWorker.drain }.to_not raise_error
+    end
+
     it "does not enqueue a duplicate job for the given worker" do
       SidekiqSchedulable::Startup.schedule!(schedules, current_jobs)
       SidekiqSchedulable::Startup.schedule!(schedules, current_jobs)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq_schedulable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kevin Buchanan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-12 00:00:00.000000000 Z
+date: 2015-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq