sidekiq-scheduler 2.1.9 → 2.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 310c3a0ed3c3976eb6585432e0b2bd00ddb4ddb8
-  data.tar.gz: ee996ad32bfaacb0f3aa77a7f3073a3a8ad4d9f4
+  metadata.gz: a3f7cb5ee802d2e3b5c89b308fbcaff612911217
+  data.tar.gz: e6b488b10334b3af01c9d2521e31ec3c53f0ef20
 SHA512:
-  metadata.gz: 629bdc5d21f6907a7427356d3b78d1a253587aea9b7f3528ba92f2cc1f3f2b01116eeddb36830a1bed3341e7a9f6d192d94ba1ac3e9c66bf80663a4f5d31fc1c
-  data.tar.gz: b2a7113238972d104d65f19d465ead5846e157696dee0c77f51000ba4dc751ca6d597566e44824f6012e722d770a634fb9d655d47dd11fafdbb3eb5858010e7a
+  metadata.gz: b56413d0c141f2ae15bfacb255a8eed2550b6b0f899703f5fd08d67539794878e411d9a5a48086f4fd9d7f542f6b78fe9a016b7edf32a78819b93c7860ecf2a2
+  data.tar.gz: 6b8524661830f24e9233a95ec94a18ad31eac1f0880a63a3bc48f728e802f8f5ffe79437bfd5d17bdc3ec07a79d142b0d991b33a5a6363f79a4e6f1c387ee2c2

data/README.md

@@ -94,6 +94,7 @@ Available options are:
 
 ``` yaml
 :dynamic: <if true the schedule can be modified in runtime [false by default]>
+:dynamic_every: <if dynamic is true, the schedule is reloaded every interval [5s by default]>
 :enabled: <enables scheduler if true [true by default]>
 :scheduler:
   :listened_queues_only: <push jobs whose queue is being listened by sidekiq [false by default]>
@@ -244,7 +245,7 @@ Sidekiq.set_schedule('heartbeat', { 'every' => ['1m'], 'class' => 'HeartbeatWork
 
 If the schedule did not exist it will be created, if it existed it will be updated.
 
-When `:dynamic` flag is set to `true`, schedule changes are loaded every 5 seconds.
+When `:dynamic` flag is set to `true`, schedule changes are loaded every 5 seconds. Use the `:dynamic_every` flag for a different interval.
 
 ``` yaml
 # config/sidekiq.yml

data/lib/sidekiq-scheduler.rb

@@ -3,6 +3,7 @@ require 'tilt/erb'
 
 require_relative 'sidekiq-scheduler/version'
 require_relative 'sidekiq-scheduler/manager'
+require_relative 'sidekiq-scheduler/redis_manager'
 
 Sidekiq.configure_server do |config|
 
@@ -10,6 +11,9 @@ Sidekiq.configure_server do |config|
     dynamic = Sidekiq::Scheduler.dynamic
     dynamic = dynamic.nil? ? config.options.fetch(:dynamic, false) : dynamic
 
+    dynamic_every = Sidekiq::Scheduler.dynamic_every
+    dynamic_every = dynamic_every.nil? ? config.options.fetch(:dynamic_every, '5s') : dynamic_every
+
     enabled = Sidekiq::Scheduler.enabled
     enabled = enabled.nil? ? config.options.fetch(:enabled, true) : enabled
 
@@ -22,14 +26,15 @@ Sidekiq.configure_server do |config|
     schedule ||= config.options[:schedule] || {}
 
     scheduler_options = {
-      dynamic:   dynamic,
-      enabled:   enabled,
-      schedule:  schedule,
+      dynamic:       dynamic,
+      dynamic_every: dynamic_every,
+      enabled:       enabled,
+      schedule:      schedule,
       listened_queues_only: listened_queues_only
     }
 
     # schedules_changed's type was changed from SET to ZSET, so we remove old versions at startup
-    Sidekiq.redis { |r| r.del(:schedules_changed) unless r.type(:schedules_changed) == 'zset' }
+    SidekiqScheduler::RedisManager.clean_schedules_changed
 
     schedule_manager = SidekiqScheduler::Manager.new(scheduler_options)
     config.options[:schedule_manager] = schedule_manager

data/lib/sidekiq-scheduler/job_presenter.rb

@@ -3,6 +3,7 @@ begin
 rescue LoadError
   require 'sidekiq/web_helpers'
 end
+require 'sidekiq-scheduler/redis_manager'
 
 module SidekiqScheduler
   class JobPresenter
@@ -19,7 +20,7 @@ module SidekiqScheduler
     #
     # @return [String] with the job's next time
     def next_time
-      execution_time = Sidekiq.redis { |r| r.hget(Sidekiq::Scheduler.next_times_key, name) }
+      execution_time = SidekiqScheduler::RedisManager.get_job_next_time(name)
 
       relative_time(Time.parse(execution_time)) if execution_time
     end
@@ -28,7 +29,7 @@ module SidekiqScheduler
     #
     # @return [String] with the job's last time
     def last_time
-      execution_time = Sidekiq.redis { |r| r.hget(Sidekiq::Scheduler.last_times_key, name) }
+      execution_time = SidekiqScheduler::RedisManager.get_job_last_time(name)
 
       relative_time(Time.parse(execution_time)) if execution_time
     end

data/lib/sidekiq-scheduler/manager.rb

@@ -17,6 +17,7 @@ module SidekiqScheduler
     def initialize(options)
       Sidekiq::Scheduler.enabled = options[:enabled]
       Sidekiq::Scheduler.dynamic = options[:dynamic]
+      Sidekiq::Scheduler.dynamic_every = options[:dynamic_every]
       Sidekiq::Scheduler.listened_queues_only = options[:listened_queues_only]
       Sidekiq.schedule = options[:schedule] if Sidekiq::Scheduler.enabled
     end

data/lib/sidekiq-scheduler/redis_manager.rb

@@ -0,0 +1,212 @@
+module SidekiqScheduler
+  module RedisManager
+
+    REGISTERED_JOBS_THRESHOLD_IN_SECONDS = 24 * 60 * 60
+
+    # Returns the schedule of a given job
+    #
+    # @param [String] name The name of the job
+    #
+    # @return [String] schedule in JSON format
+    def self.get_job_schedule(name)
+      hget(:schedules, name)
+    end
+
+    # Returns the state of a given job
+    #
+    # @param [String] name The name of the job
+    #
+    # @return [String] state in JSON format
+    def self.get_job_state(name)
+      hget(schedules_state_key, name)
+    end
+
+    # Returns the next execution time for a given job
+    #
+    # @param [String] name The name of the job
+    #
+    # @return [String] next time the job has to be executed
+    def self.get_job_next_time(name)
+      hget(next_times_key, name)
+    end
+
+    # Returns the last execution time of a given job
+    #
+    # @param [String] name The name of the job
+    #
+    # @return [String] last time the job was executed
+    def self.get_job_last_time(name)
+      hget(last_times_key, name)
+    end
+
+    # Sets the schedule for a given job
+    #
+    # @param [String] name The name of the job
+    # @param [Hash] config The new schedule for the job
+    def self.set_job_schedule(name, config)
+      hset(:schedules, name, JSON.generate(config))
+    end
+
+    # Sets the state for a given job
+    #
+    # @param [String] name The name of the job
+    # @param [Hash] state The new state for the job
+    def self.set_job_state(name, state)
+      hset(schedules_state_key, name, JSON.generate(state))
+    end
+
+    # Sets the next execution time for a given job
+    #
+    # @param [String] name The name of the job
+    # @param [String] next_time The next time the job has to be executed
+    def self.set_job_next_time(name, next_time)
+      hset(next_times_key, name, next_time)
+    end
+
+    # Sets the last execution time for a given job
+    #
+    # @param [String] name The name of the job
+    # @param [String] last_time The last time the job was executed
+    def self.set_job_last_time(name, last_time)
+      hset(last_times_key, name, last_time)
+    end
+
+    # Removes the schedule for a given job
+    #
+    # @param [String] name The name of the job
+    def self.remove_job_schedule(name)
+      hdel(:schedules, name)
+    end
+
+    # Removes the next execution time for a given job
+    #
+    # @param [String] name The name of the job
+    def self.remove_job_next_time(name)
+      hdel(next_times_key, name)
+    end
+
+    # Returns the schedules of all the jobs
+    #
+    # @return [Hash] hash with all the job schedules
+    def self.get_all_schedules
+      Sidekiq.redis { |r| r.hgetall(:schedules) }
+    end
+
+    # Returns boolean value that indicates if the schedules value exists
+    #
+    # @return [Boolean] true if the schedules key is set, false otherwise
+    def self.schedule_exist?
+      Sidekiq.redis { |r| r.exists(:schedules) }
+    end
+
+    # Returns all the schedule changes for a given time range.
+    #
+    # @param [Float] from The minimum value in the range
+    # @param [Float] to The maximum value in the range
+    #
+    # @return [Array] array with all the changed job names
+    def self.get_schedule_changes(from, to)
+      Sidekiq.redis { |r| r.zrangebyscore(:schedules_changed, from, "(#{to}") }
+    end
+
+    # Register a schedule change for a given job
+    #
+    # @param [String] name The name of the job
+    def self.add_schedule_change(name)
+      Sidekiq.redis { |r| r.zadd(:schedules_changed, Time.now.to_f, name) }
+    end
+
+    # Remove all the schedule changes records
+    def self.clean_schedules_changed
+      Sidekiq.redis { |r| r.del(:schedules_changed) unless r.type(:schedules_changed) == 'zset' }
+    end
+
+    # Removes a queued job instance
+    #
+    # @param [String] job_name The name of the job
+    # @param [Time] time The time at which the job was cleared by the scheduler
+    #
+    # @return [Boolean] true if the job was registered, false otherwise
+    def self.register_job_instance(job_name, time)
+      job_key = pushed_job_key(job_name)
+      registered, _ = Sidekiq.redis do |r|
+        r.pipelined do
+          r.zadd(job_key, time.to_i, time.to_i)
+          r.expire(job_key, REGISTERED_JOBS_THRESHOLD_IN_SECONDS)
+        end
+      end
+
+      registered
+    end
+
+    # Removes instances of the job older than 24 hours
+    #
+    # @param [String] job_name The name of the job
+    def self.remove_elder_job_instances(job_name)
+      seconds_ago = Time.now.to_i - REGISTERED_JOBS_THRESHOLD_IN_SECONDS
+
+      Sidekiq.redis do |r|
+        r.zremrangebyscore(pushed_job_key(job_name), 0, seconds_ago)
+      end
+    end
+
+    # Returns the key of the Redis sorted set used to store job enqueues
+    #
+    # @param [String] job_name The name of the job
+    #
+    # @return [String] the pushed job key
+    def self.pushed_job_key(job_name)
+      "sidekiq-scheduler:pushed:#{job_name}"
+    end
+
+    # Returns the key of the Redis hash for job's execution times hash
+    #
+    # @return [String] with the key
+    def self.next_times_key
+      'sidekiq-scheduler:next_times'
+    end
+
+    # Returns the key of the Redis hash for job's last execution times hash
+    #
+    # @return [String] with the key
+    def self.last_times_key
+      'sidekiq-scheduler:last_times'
+    end
+
+    # Returns the Redis's key for saving schedule states.
+    #
+    # @return [String] with the key
+    def self.schedules_state_key
+      'sidekiq-scheduler:states'
+    end
+
+    private
+
+    # Returns the value of a Redis stored hash field
+    #
+    # @param [String] hash_key The key name of the hash
+    # @param [String] field_key The key name of the field
+    #
+    # @return [String]
+    def self.hget(hash_key, field_key)
+      Sidekiq.redis { |r| r.hget(hash_key, field_key) }
+    end
+
+    # Sets the value of a Redis stored hash field
+    #
+    # @param [String] hash_key The key name of the hash
+    # @param [String] field_key The key name of the field
+    # @param [String] value The new value name for the field
+    def self.hset(hash_key, field_key, value)
+      Sidekiq.redis { |r| r.hset(hash_key, field_key, value) }
+    end
+
+    # Removes the value of a Redis stored hash field
+    #
+    # @param [String] hash_key The key name of the hash
+    # @param [String] field_key The key name of the field
+    def self.hdel(hash_key, field_key)
+      Sidekiq.redis { |r| r.hdel(hash_key, field_key) }
+    end
+  end
+end

data/lib/sidekiq-scheduler/schedule.rb

@@ -1,6 +1,7 @@
 require 'json'
 
 require 'sidekiq-scheduler/utils'
+require_relative 'redis_manager'
 
 module SidekiqScheduler
   module Schedule
@@ -71,7 +72,7 @@ module SidekiqScheduler
       if name.nil?
         get_all_schedules
       else
-        encoded_schedule = Sidekiq.redis { |r| r.hget(:schedules, name) }
+        encoded_schedule = SidekiqScheduler::RedisManager.get_job_schedule(name)
         encoded_schedule.nil? ? nil : JSON.parse(encoded_schedule)
       end
     end
@@ -80,8 +81,8 @@ module SidekiqScheduler
     def get_all_schedules
       schedules = {}
 
-      if Sidekiq.redis { |r| r.exists(:schedules) }
-        Sidekiq.redis { |r| r.hgetall(:schedules) }.tap do |h|
+      if SidekiqScheduler::RedisManager.schedule_exist?
+        SidekiqScheduler::RedisManager.get_all_schedules.tap do |h|
           h.each do |name, config|
             schedules[name] = JSON.parse(config)
           end
@@ -103,16 +104,16 @@ module SidekiqScheduler
     def set_schedule(name, config)
       existing_config = get_schedule(name)
       unless existing_config && existing_config == config
-        Sidekiq.redis { |r| r.hset(:schedules, name, JSON.generate(config)) }
-        Sidekiq.redis { |r| r.zadd(:schedules_changed, Time.now.to_f, name) }
+        SidekiqScheduler::RedisManager.set_job_schedule(name, config)
+        SidekiqScheduler::RedisManager.add_schedule_change(name)
       end
       config
     end
 
     # remove a given schedule by name
     def remove_schedule(name)
-      Sidekiq.redis { |r| r.hdel(:schedules, name) }
-      Sidekiq.redis { |r| r.zadd(:schedules_changed, Time.now.to_f, name) }
+      SidekiqScheduler::RedisManager.remove_job_schedule(name)
+      SidekiqScheduler::RedisManager.add_schedule_change(name)
     end
 
     private

data/lib/sidekiq-scheduler/version.rb

@@ -1,5 +1,5 @@
 module SidekiqScheduler
 
-  VERSION = '2.1.9'
+  VERSION = '2.1.10'
 
 end

data/lib/sidekiq/scheduler.rb

@@ -3,13 +3,13 @@ require 'thwait'
 require 'sidekiq/util'
 require 'sidekiq-scheduler/manager'
 require 'sidekiq-scheduler/rufus_utils'
+require_relative '../sidekiq-scheduler/redis_manager'
 require 'json'
 
 module Sidekiq
   class Scheduler
     extend Sidekiq::Util
 
-    REGISTERED_JOBS_THRESHOLD_IN_SECONDS = 24 * 60 * 60
     RUFUS_METADATA_KEYS = %w(description at cron every in interval enabled)
 
     # We expect rufus jobs to have #params
@@ -27,6 +27,9 @@ module Sidekiq
       # Set to update the schedule in runtime in a given time period.
       attr_accessor :dynamic
 
+      # Set to update the schedule in runtime dynamically per this period.
+      attr_accessor :dynamic_every
+
       # Set to schedule jobs only when will be pushed to queues listened by sidekiq
       attr_accessor :listened_queues_only
 
@@ -55,7 +58,7 @@ module Sidekiq
           if dynamic
             Sidekiq.reload_schedule!
             @current_changed_score = Time.now.to_f
-            rufus_scheduler.every('5s') do
+            rufus_scheduler.every(dynamic_every) do
               update_schedule
             end
           end
@@ -137,8 +140,10 @@ module Sidekiq
       # @param [String] name The job's name
       # @param [Time] next_time The job's next time execution
       def update_job_next_time(name, next_time)
-        Sidekiq.redis do |r|
-          next_time ? r.hset(next_times_key, name, next_time) : r.hdel(next_times_key, name)
+        if next_time
+          SidekiqScheduler::RedisManager.set_job_next_time(name, next_time)
+        else
+          SidekiqScheduler::RedisManager.remove_job_next_time(name)
         end
       end
 
@@ -147,7 +152,7 @@ module Sidekiq
       # @param [String] name The job's name
       # @param [Time] last_time The job's last execution time
       def update_job_last_time(name, last_time)
-        Sidekiq.redis { |r| r.hset(last_times_key, name, last_time) } if last_time
+        SidekiqScheduler::RedisManager.set_job_last_time(name, last_time) if last_time
       end
 
       # Returns true if the given schedule config hash matches the current
@@ -215,9 +220,7 @@ module Sidekiq
 
       def update_schedule
         last_changed_score, @current_changed_score = @current_changed_score, Time.now.to_f
-        schedule_changes = Sidekiq.redis do |r|
-          r.zrangebyscore :schedules_changed, last_changed_score, "(#{@current_changed_score}"
-        end
+        schedule_changes = SidekiqScheduler::RedisManager.get_schedule_changes(last_changed_score, @current_changed_score)
 
         if schedule_changes.size > 0
           logger.info 'Updating schedule'
@@ -318,52 +321,11 @@ module Sidekiq
       #
       # @return [Boolean] true if the job was registered, false when otherwise
       def register_job_instance(job_name, time)
-        pushed_job_key = pushed_job_key(job_name)
-
-        registered, _ = Sidekiq.redis do |r|
-          r.pipelined do
-            r.zadd(pushed_job_key, time.to_i, time.to_i)
-            r.expire(pushed_job_key, REGISTERED_JOBS_THRESHOLD_IN_SECONDS)
-          end
-        end
-
-        registered
+        SidekiqScheduler::RedisManager.register_job_instance(job_name, time)
       end
 
       def remove_elder_job_instances(job_name)
-        Sidekiq.redis do |r|
-          r.zremrangebyscore(pushed_job_key(job_name), 0, Time.now.to_i - REGISTERED_JOBS_THRESHOLD_IN_SECONDS)
-        end
-      end
-
-      # Returns the key of the Redis sorted set used to store job enqueues
-      #
-      # @param [String] job_name The name of the job
-      #
-      # @return [String]
-      def pushed_job_key(job_name)
-        "sidekiq-scheduler:pushed:#{job_name}"
-      end
-
-      # Returns the key of the Redis hash for job's execution times hash
-      #
-      # @return [String] with the key
-      def next_times_key
-        'sidekiq-scheduler:next_times'
-      end
-
-      # Returns the key of the Redis hash for job's last execution times hash
-      #
-      # @return [String] with the key
-      def last_times_key
-        'sidekiq-scheduler:last_times'
-      end
-
-      # Returns the Redis's key for saving schedule states.
-      #
-      # @return [String] with the key
-      def schedules_state_key
-        'sidekiq-scheduler:states'
+        SidekiqScheduler::RedisManager.remove_elder_job_instances(job_name)
       end
 
       def job_enabled?(name)
@@ -405,7 +367,7 @@ module Sidekiq
       # @param name [String] with the schedule's name
       # @return [Hash] with the schedule's state
       def schedule_state(name)
-        state = Sidekiq.redis { |r| r.hget(schedules_state_key, name) }
+        state = SidekiqScheduler::RedisManager.get_job_state(name)
 
         state ? JSON.parse(state) : {}
       end
@@ -415,7 +377,7 @@ module Sidekiq
       # @param name [String] with the schedule's name
       # @param name [Hash] with the schedule's state
       def set_schedule_state(name, state)
-        Sidekiq.redis { |r| r.hset(schedules_state_key, name, JSON.generate(state)) }
+        SidekiqScheduler::RedisManager.set_job_state(name, state)
       end
 
       # Adds a Hash with schedule metadata as the last argument to call the worker.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-scheduler
 version: !ruby/object:Gem::Version
-  version: 2.1.9
+  version: 2.1.10
 platform: ruby
 authors:
 - Morton Jonuschat
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-31 00:00:00.000000000 Z
+date: 2017-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -29,16 +29,22 @@ dependencies:
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rufus-scheduler
   requirement: !ruby/object:Gem::Requirement
@@ -235,6 +241,7 @@ files:
 - lib/sidekiq-scheduler.rb
 - lib/sidekiq-scheduler/job_presenter.rb
 - lib/sidekiq-scheduler/manager.rb
+- lib/sidekiq-scheduler/redis_manager.rb
 - lib/sidekiq-scheduler/rufus_utils.rb
 - lib/sidekiq-scheduler/schedule.rb
 - lib/sidekiq-scheduler/utils.rb