sidekiq-scheduler 2.0.8 → 2.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2ca5f12c843c8653e3a174431625f89622daee3
-  data.tar.gz: e479e32ea285d53200078971da9b1eb3e7dfd323
+  metadata.gz: 0f7d8c790cf456b0a62f67d543f1c7532f21e16b
+  data.tar.gz: ca1112b924897da7d6d06d72e071ea63a92ac8e8
 SHA512:
-  metadata.gz: 2ab648c207104060b36cfebb38fae68bb8af05b63ab2760485d6b958e1145312b7b1ceca631089eb297d8a84f6963969920e04f36e5fc9f641f45635b58d5c10
-  data.tar.gz: ef5e376ba307b8b0fc62c6fcb61b7be50c50cd37971715e501de8220dad7e8743dfb5856ba18c10aa963c990827d194b807df2fe45927a38c3027aa7310a247b
+  metadata.gz: 666ed752c0a891f3ad99af53402ff3274e881dc0540d79d0025c191cdcb6d80d73066d4e9c4021f85c0e04d4d65ecb6a63d41e2b4d6b0420f58070ab791b28b2
+  data.tar.gz: f8dec2ee3b6add1cd02bd6760dc58fc49fc65cef3b1ae1a01891fb77e5fd535c9052ab78c98f21c5a396bbe30e457466a92bcf17dbf104c6e5be631879aa2f63

data/README.md

@@ -81,8 +81,7 @@ if Rails.env == 'production' && (defined?(Rails::Server) || defined?(Unicorn))
   Sidekiq.configure_server do |config|
 
     config.on(:startup) do
-      Sidekiq.schedule = YAML
-        .load_file(File.expand_path('../../../config/scheduler.yml', __FILE__))
+      Sidekiq.schedule = YAML.load_file(File.expand_path('../../config/scheduler.yml', __FILE__))
       Sidekiq::Scheduler.reload_schedule!
     end
   end
@@ -157,7 +156,7 @@ require 'sidekiq/scheduler'
 
 Sidekiq.configure_server do |config|
   config.on(:startup) do
-    Sidekiq.schedule = YAML.load_file(File.expand_path("../../../config/scheduler.yml",__FILE__))
+    Sidekiq.schedule = YAML.load_file(File.expand_path("../../config/scheduler.yml", __FILE__))
     Sidekiq::Scheduler.reload_schedule!
   end
 end
@@ -167,11 +166,11 @@ If you are running a non Rails project you should add code to load the workers c
 
 ```ruby
 require 'sidekiq/scheduler'
-Dir[File.expand_path('../lib/workers/*.rb',__FILE__)].each do |file| load file; end
+Dir[File.expand_path('../lib/workers/*.rb', __FILE__)].each do |file| load file; end
 
 Sidekiq.configure_server do |config|
   config.on(:startup) do
-    Sidekiq.schedule = YAML.load_file(File.expand_path("../../../config/scheduler.yml",__FILE__))
+    Sidekiq.schedule = YAML.load_file(File.expand_path("../../config/scheduler.yml", __FILE__))
     Sidekiq::Scheduler.reload_schedule!
   end
 end
@@ -218,15 +217,11 @@ You can set that flag in the following ways.
 ```ruby
 Sidekiq.configure_server do |config|
   # ...
-
-  config.on(:startup) do
-    # ...
-    Sidekiq::Scheduler.dynamic = true
-  end
+  Sidekiq::Scheduler.dynamic = true
 end
 ```
 
-If `:dynamic` flag is set to false, you have to reload the schedule manually in sidekiq
+If `:dynamic` flag is set to `false`, you have to reload the schedule manually in sidekiq
 side:
 
 ```ruby

data/lib/sidekiq-scheduler/job_presenter.rb

@@ -0,0 +1,58 @@
+begin
+  require 'sidekiq/web/helpers'
+rescue LoadError
+  require 'sidekiq/web_helpers'
+end
+
+module SidekiqScheduler
+  class JobPresenter
+    attr_reader :name
+
+    include Sidekiq::WebHelpers
+
+    def initialize(name, attributes)
+      @name = name
+      @attributes = attributes
+    end
+
+    # Returns the next time execution for the job
+    #
+    # @return [String] with the job's next time
+    def next_time
+      execution_time = Sidekiq.redis { |r| r.hget(Sidekiq::Scheduler.next_times_key, name) }
+
+      relative_time(Time.parse(execution_time)) if execution_time
+    end
+
+    # Returns the interval for the job
+    #
+    # @return [String] with the job's interval
+    def interval
+      @attributes['cron'] || @attributes['interval'] || @attributes['every']
+    end
+
+    # Returns the queue of the job
+    #
+    # @return [String] with the job's queue
+    def queue
+      @attributes.fetch('queue', 'default')
+    end
+
+    # Delegates the :[] method to the attributes' hash
+    #
+    # @return [String] with the value for that key
+    def [](key)
+      @attributes[key]
+    end
+
+    # Builds the presenter instances for the schedule hash
+    #
+    # @param schedule_hash [Hash] with the redis schedule
+    # @return [Array<JobPresenter>] an array with the instances of presenters
+    def self.build_collection(schedule_hash)
+      Hash(schedule_hash).map do |name, job_spec|
+        new(name, job_spec)
+      end
+    end
+  end
+end

data/lib/sidekiq-scheduler/manager.rb

@@ -18,7 +18,7 @@ module SidekiqScheduler
       Sidekiq::Scheduler.enabled = options[:enabled]
       Sidekiq::Scheduler.dynamic = options[:dynamic]
       Sidekiq::Scheduler.listened_queues_only = options[:listened_queues_only]
-      Sidekiq.schedule = options[:schedule] if options[:schedule]
+      Sidekiq.schedule = options[:schedule] || {}
     end
 
     def stop

data/lib/sidekiq-scheduler/version.rb

@@ -1,5 +1,5 @@
 module SidekiqScheduler
 
-  VERSION = '2.0.8'
+  VERSION = '2.0.9'
 
 end

data/lib/sidekiq-scheduler/web.rb

@@ -1,3 +1,5 @@
+require_relative 'job_presenter'
+
 module SidekiqScheduler
   # Hook into *Sidekiq::Web* Sinatra app which adds a new '/recurring-jobs' page
 
@@ -6,7 +8,7 @@ module SidekiqScheduler
 
     def self.registered(app)
       app.get '/recurring-jobs' do
-        @schedule = (Sidekiq.schedule! || [])
+        @presented_jobs = JobPresenter.build_collection(Sidekiq.schedule!)
 
         erb File.read(File.join(VIEW_PATH, 'recurring_jobs.erb'))
       end
@@ -14,7 +16,7 @@ module SidekiqScheduler
       app.get '/recurring-jobs/:name/enqueue' do
         schedule = Sidekiq.get_schedule(params[:name])
         Sidekiq::Scheduler.enqueue_job(schedule)
-        redirect to('/recurring-jobs')
+        redirect '/recurring-jobs'
       end
     end
   end
@@ -23,4 +25,4 @@ end
 require 'sidekiq/web' unless defined?(Sidekiq::Web)
 Sidekiq::Web.register(SidekiqScheduler::Web)
 Sidekiq::Web.tabs['recurring_jobs'] = 'recurring-jobs'
-Sidekiq::Web.set :locales, Sidekiq::Web.locales << File.expand_path(File.dirname(__FILE__) + "/../../web/locales")
+Sidekiq::Web.locales << File.expand_path(File.dirname(__FILE__) + "/../../web/locales")

data/lib/sidekiq/scheduler.rb

@@ -8,6 +8,7 @@ module Sidekiq
     extend Sidekiq::Util
 
     REGISTERED_JOBS_THRESHOLD_IN_SECONDS = 24 * 60 * 60
+    RUFUS_METADATA_KEYS = %w(description at cron every in interval)
 
     # We expect rufus jobs to have #params
     Rufus::Scheduler::Job.module_eval do
@@ -26,299 +27,340 @@ module Sidekiq
 
       # Set to schedule jobs only when will be pushed to queues listened by sidekiq
       attr_accessor :listened_queues_only
-    end
 
-    # the Rufus::Scheduler jobs that are scheduled
-    def self.scheduled_jobs
-      @@scheduled_jobs
-    end
+      # the Rufus::Scheduler jobs that are scheduled
+      def scheduled_jobs
+        @@scheduled_jobs
+      end
 
-    def self.print_schedule
-      if self.rufus_scheduler
-        logger.info "Scheduling Info\tLast Run"
-        scheduler_jobs = self.rufus_scheduler.all_jobs
-        scheduler_jobs.each do |_, v|
-          logger.info "#{v.t}\t#{v.last}\t"
+      def print_schedule
+        if rufus_scheduler
+          logger.info "Scheduling Info\tLast Run"
+          scheduler_jobs = rufus_scheduler.all_jobs
+          scheduler_jobs.each do |_, v|
+            logger.info "#{v.t}\t#{v.last}\t"
+          end
         end
       end
-    end
 
-    # Pulls the schedule from Sidekiq.schedule and loads it into the
-    # rufus scheduler instance
-    def self.load_schedule!
-      if enabled
-        logger.info 'Loading Schedule'
-
-        # Load schedule from redis for the first time if dynamic
-        if dynamic
-          Sidekiq.reload_schedule!
-          self.rufus_scheduler.every('5s') do
-            self.update_schedule
+      # Pulls the schedule from Sidekiq.schedule and loads it into the
+      # rufus scheduler instance
+      def load_schedule!
+        if enabled
+          logger.info 'Loading Schedule'
+
+          # Load schedule from redis for the first time if dynamic
+          if dynamic
+            Sidekiq.reload_schedule!
+            rufus_scheduler.every('5s') do
+              update_schedule
+            end
           end
-        end
 
-        logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
+          logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
 
 
-        @@scheduled_jobs = {}
+          @@scheduled_jobs = {}
 
-        Sidekiq.schedule.each do |name, config|
-          if !listened_queues_only || enabled_queue?(config['queue'])
-            self.load_schedule_job(name, config)
-          else
-            logger.info { "Ignoring #{name}, job's queue is not enabled." }
+          Sidekiq.schedule.each do |name, config|
+            if !listened_queues_only || enabled_queue?(config['queue'])
+              load_schedule_job(name, config)
+            else
+              logger.info { "Ignoring #{name}, job's queue is not enabled." }
+            end
           end
-        end
 
-        Sidekiq.redis { |r| r.del(:schedules_changed) }
+          Sidekiq.redis { |r| r.del(:schedules_changed) }
 
-        logger.info 'Schedules Loaded'
-      else
-        logger.info 'SidekiqScheduler is disabled'
+          logger.info 'Schedules Loaded'
+        else
+          logger.info 'SidekiqScheduler is disabled'
+        end
       end
-    end
 
-    # modify interval type value to value with options if options available
-    def self.optionizate_interval_value(value)
-      args = value
-      if args.is_a?(::Array)
-        return args.first if args.size > 2 || !args.last.is_a?(::Hash)
-        # symbolize keys of hash for options
-        args[1] = args[1].inject({}) do |m, i|
-          key, value = i
-          m[(key.to_sym rescue key) || key] = value
-          m
+      # modify interval type value to value with options if options available
+      def optionizate_interval_value(value)
+        args = value
+        if args.is_a?(::Array)
+          return args.first if args.size > 2 || !args.last.is_a?(::Hash)
+          # symbolize keys of hash for options
+          args[1] = args[1].inject({}) do |m, i|
+            key, value = i
+            m[(key.to_sym rescue key) || key] = value
+            m
+          end
         end
+        args
       end
-      args
-    end
 
-    # Loads a job schedule into the Rufus::Scheduler and stores it in @@scheduled_jobs
-    def self.load_schedule_job(name, config)
-      # If rails_env is set in the config, enforce ENV['RAILS_ENV'] as
-      # required for the jobs to be scheduled.  If rails_env is missing, the
-      # job should be scheduled regardless of what ENV['RAILS_ENV'] is set
-      # to.
-      if config['rails_env'].nil? || self.rails_env_matches?(config)
-        logger.info "Scheduling #{name} #{config}"
-        interval_defined = false
-        interval_types = %w{cron every at in interval}
-        interval_types.each do |interval_type|
-          config_interval_type = config[interval_type]
+      # Loads a job schedule into the Rufus::Scheduler and stores it in @@scheduled_jobs
+      def load_schedule_job(name, config)
+        # If rails_env is set in the config, enforce ENV['RAILS_ENV'] as
+        # required for the jobs to be scheduled.  If rails_env is missing, the
+        # job should be scheduled regardless of what ENV['RAILS_ENV'] is set
+        # to.
+        if config['rails_env'].nil? || rails_env_matches?(config)
+          logger.info "Scheduling #{name} #{config}"
+          interval_defined = false
+          interval_types = %w{cron every at in interval}
+          interval_types.each do |interval_type|
+            config_interval_type = config[interval_type]
 
-          if !config_interval_type.nil? && config_interval_type.length > 0
+            if !config_interval_type.nil? && config_interval_type.length > 0
 
-            args = self.optionizate_interval_value(config_interval_type)
+              args = optionizate_interval_value(config_interval_type)
 
-            # We want rufus_scheduler to return a job object, not a job id
-            opts = { :job => true }
+              rufus_job = new_job(name, interval_type, config, args)
+              @@scheduled_jobs[name] = rufus_job
+              update_job_next_time(name, rufus_job.next_time)
 
-            @@scheduled_jobs[name] = self.rufus_scheduler.send(interval_type, *args, opts) do |job, time|
-              config.delete(interval_type)
+              interval_defined = true
 
-              idempotent_job_enqueue(name, time, config)
+              break
             end
+          end
 
-            interval_defined = true
-
-            break
+          unless interval_defined
+            logger.info "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
           end
         end
+      end
+
+      # Pushes the job into Sidekiq if not already pushed for the given time
+      #
+      # @param [String] job_name The job's name
+      # @param [Time] time The time when the job got cleared for triggering
+      # @param [Hash] config Job's config hash
+      def idempotent_job_enqueue(job_name, time, config)
+        registered = register_job_instance(job_name, time)
+
+        if registered
+          logger.info "queueing #{config['class']} (#{job_name})"
+
+          handle_errors { enqueue_job(config) }
+
+          remove_elder_job_instances(job_name)
+        else
+          logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
+        end
+      end
 
-        unless interval_defined
-          logger.info "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
+      # Pushes job's next time execution
+      #
+      # @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)
         end
       end
-    end
 
-    # Pushes the job into Sidekiq if not already pushed for the given time
-    #
-    # @param [String] job_name The job's name
-    # @param [Time] time The time when the job got cleared for triggering
-    # @param [Hash] config Job's config hash
-    def self.idempotent_job_enqueue(job_name, time, config)
-      registered = register_job_instance(job_name, time)
+      # Returns true if the given schedule config hash matches the current
+      # ENV['RAILS_ENV']
+      def rails_env_matches?(config)
+        config['rails_env'] && ENV['RAILS_ENV'] && config['rails_env'].gsub(/\s/, '').split(',').include?(ENV['RAILS_ENV'])
+      end
 
-      if registered
-        logger.info "queueing #{config['class']} (#{job_name})"
+      def handle_errors
+        begin
+          yield
+        rescue StandardError => e
+          logger.info "#{e.class.name}: #{e.message}"
+        end
+      end
 
-        self.handle_errors { self.enqueue_job(config) }
+      # Enqueue a job based on a config hash
+      def enqueue_job(job_config)
+        config = prepare_arguments(job_config.dup)
 
-        remove_elder_job_instances(job_name)
-      else
-        logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
+        if active_job_enqueue?(config['class'])
+          enque_with_active_job(config)
+        else
+          enque_with_sidekiq(config)
+        end
       end
-    end
 
-    # Returns true if the given schedule config hash matches the current
-    # ENV['RAILS_ENV']
-    def self.rails_env_matches?(config)
-      config['rails_env'] && ENV['RAILS_ENV'] && config['rails_env'].gsub(/\s/, '').split(',').include?(ENV['RAILS_ENV'])
-    end
+      def rufus_scheduler_options
+        @rufus_scheduler_options ||= {}
+      end
 
-    def self.handle_errors
-      begin
-        yield
-      rescue StandardError => e
-        logger.info "#{e.class.name}: #{e.message}"
+      def rufus_scheduler_options=(options)
+        @rufus_scheduler_options = options
       end
-    end
 
-    # Enqueue a job based on a config hash
-    def self.enqueue_job(job_config)
-      config = prepare_arguments(job_config.dup)
+      def rufus_scheduler
+        @rufus_scheduler ||= new_rufus_scheduler
+      end
 
-      if active_job_enqueue?(config['class'])
-        enque_with_active_job(config)
-      else
-        enque_with_sidekiq(config)
+      # Stops old rufus scheduler and creates a new one.  Returns the new
+      # rufus scheduler
+      def clear_schedule!
+        rufus_scheduler.stop
+        @rufus_scheduler = nil
+        @@scheduled_jobs = {}
+        rufus_scheduler
       end
-    end
 
-    def self.rufus_scheduler_options
-      @rufus_scheduler_options ||= {}
-    end
+      def reload_schedule!
+        if enabled
+          logger.info 'Reloading Schedule'
+          clear_schedule!
+          load_schedule!
+        else
+          logger.info 'SidekiqScheduler is disabled'
+        end
+      end
 
-    def self.rufus_scheduler_options=(options)
-      @rufus_scheduler_options = options
-    end
+      def update_schedule
+        if Sidekiq.redis { |r| r.scard(:schedules_changed) } > 0
+          logger.info 'Updating schedule'
+          Sidekiq.reload_schedule!
+          while schedule_name = Sidekiq.redis { |r| r.spop(:schedules_changed) }
+            if Sidekiq.schedule.keys.include?(schedule_name)
+              unschedule_job(schedule_name)
+              load_schedule_job(schedule_name, Sidekiq.schedule[schedule_name])
+            else
+              unschedule_job(schedule_name)
+            end
+          end
+          logger.info 'Schedules Loaded'
+        end
+      end
 
-    def self.rufus_scheduler
-      @rufus_scheduler ||= Rufus::Scheduler.new(rufus_scheduler_options)
-    end
+      def unschedule_job(name)
+        if scheduled_jobs[name]
+          logger.debug "Removing schedule #{name}"
+          scheduled_jobs[name].unschedule
+          scheduled_jobs.delete(name)
+        end
+      end
 
-    # Stops old rufus scheduler and creates a new one.  Returns the new
-    # rufus scheduler
-    def self.clear_schedule!
-      self.rufus_scheduler.stop
-      @rufus_scheduler = nil
-      @@scheduled_jobs = {}
-      self.rufus_scheduler
-    end
+      def enque_with_active_job(config)
+        initialize_active_job(config['class'], config['args']).enqueue(config)
+      end
 
-    def self.reload_schedule!
-      if enabled
-        logger.info 'Reloading Schedule'
-        self.clear_schedule!
-        self.load_schedule!
-      else
-        logger.info 'SidekiqScheduler is disabled'
+      def enque_with_sidekiq(config)
+        Sidekiq::Client.push(sanitize_job_config(config))
       end
-    end
 
-    def self.update_schedule
-      if Sidekiq.redis { |r| r.scard(:schedules_changed) } > 0
-        logger.info 'Updating schedule'
-        Sidekiq.reload_schedule!
-        while schedule_name = Sidekiq.redis { |r| r.spop(:schedules_changed) }
-          if Sidekiq.schedule.keys.include?(schedule_name)
-            self.unschedule_job(schedule_name)
-            self.load_schedule_job(schedule_name, Sidekiq.schedule[schedule_name])
-          else
-            self.unschedule_job(schedule_name)
-          end
+      def initialize_active_job(klass, args)
+        if args.is_a?(Array)
+          klass.new(*args)
+        else
+          klass.new(args)
         end
-        logger.info 'Schedules Loaded'
       end
-    end
 
-    def self.unschedule_job(name)
-      if self.scheduled_jobs[name]
-        logger.debug "Removing schedule #{name}"
-        self.scheduled_jobs[name].unschedule
-        self.scheduled_jobs.delete(name)
+      # Returns true if the enqueuing needs to be done for an ActiveJob
+      #  class false otherwise.
+      #
+      # @param [Class] klass the class to check is decendant from ActiveJob
+      #
+      # @return [Boolean]
+      def active_job_enqueue?(klass)
+        klass.is_a?(Class) && defined?(ActiveJob::Enqueuing) &&
+          klass.included_modules.include?(ActiveJob::Enqueuing)
       end
-    end
 
-    def self.enque_with_active_job(config)
-      initialize_active_job(config['class'], config['args']).enqueue(config)
-    end
+      # Convert the given arguments in the format expected to be enqueued.
+      #
+      # @param [Hash] config the options to be converted
+      # @option config [String] class the job class
+      # @option config [Hash/Array] args the arguments to be passed to the job
+      #   class
+      #
+      # @return [Hash]
+      def prepare_arguments(config)
+        config['class'] = try_to_constantize(config['class'])
+
+        if config['args'].is_a?(Hash)
+          config['args'].symbolize_keys! if config['args'].respond_to?(:symbolize_keys!)
+        else
+          config['args'] = Array(config['args'])
+        end
 
-    def self.enque_with_sidekiq(config)
-      Sidekiq::Client.push(config)
-    end
+        config
+      end
 
-    def self.initialize_active_job(klass, args)
-      if args.is_a?(Array)
-        klass.new(*args)
-      else
-        klass.new(args)
+      def try_to_constantize(klass)
+        klass.is_a?(String) ? klass.constantize : klass
+      rescue NameError
+        klass
       end
-    end
 
-    # Returns true if the enqueuing needs to be done for an ActiveJob
-    #  class false otherwise.
-    #
-    # @param [Class] klass the class to check is decendant from ActiveJob
-    #
-    # @return [Boolean]
-    def self.active_job_enqueue?(klass)
-      defined?(ActiveJob::Enqueuing) && klass.included_modules.include?(ActiveJob::Enqueuing)
-    end
+      # Returns true if a job's queue is being listened on by sidekiq
+      #
+      # @param [String] job_queue Job's queue name
+      #
+      # @return [Boolean]
+      def enabled_queue?(job_queue)
+        queues = Sidekiq.options[:queues]
 
-    # Convert the given arguments in the format expected to be enqueued.
-    #
-    # @param [Hash] config the options to be converted
-    # @option config [String] class the job class
-    # @option config [Hash/Array] args the arguments to be passed to the job
-    #   class
-    #
-    # @return [Hash]
-    def self.prepare_arguments(config)
-      config['class'] = config['class'].constantize if config['class'].is_a?(String)
-
-      if config['args'].is_a?(Hash)
-        config['args'].symbolize_keys! if config['args'].respond_to?(:symbolize_keys!)
-      else
-        config['args'] = Array(config['args'])
+        queues.empty? || queues.include?(job_queue)
       end
 
-      config
-    end
+      # Registers a queued job instance
+      #
+      # @param [String] job_name The job's name
+      # @param [Time] time Time at which the job was cleared by the scheduler
+      #
+      # @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
+      end
 
-    # Returns true if a job's queue is being listened on by sidekiq
-    #
-    # @param [String] job_queue Job's queue name
-    #
-    # @return [Boolean]
-    def self.enabled_queue?(job_queue)
-      queues = Sidekiq.options[:queues]
+      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
 
-      queues.empty? || queues.include?(job_queue)
-    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
 
-    # Registers a queued job instance
-    #
-    # @param [String] job_name The job's name
-    # @param [Time] time Time at which the job was cleared by the scheduler
-    #
-    # @return [Boolean] true if the job was registered, false when otherwise
-    def self.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)
+      # Returns the key of the Redis hash for job's execution times hash
+      #
+      def next_times_key
+        'sidekiq-scheduler:next_times'
+      end
+
+      private
+
+      def new_rufus_scheduler
+        Rufus::Scheduler.new(rufus_scheduler_options).tap do |scheduler|
+          scheduler.define_singleton_method(:on_post_trigger) do |job, triggered_time|
+            Sidekiq::Scheduler.update_job_next_time(job.tags[0], job.next_time)
+          end
         end
       end
 
-      registered
-    end
+      def new_job(name, interval_type, config, args)
+        opts = { :job => true, :tags => [name] }
 
-    def self.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)
+        rufus_scheduler.send(interval_type, *args, opts) do |job, time|
+          idempotent_job_enqueue(name, time, sanitize_job_config(config))
+        end
+      end
+
+      def sanitize_job_config(config)
+        config.reject { |k, _| RUFUS_METADATA_KEYS.include?(k) }
       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 self.pushed_job_key(job_name)
-      "sidekiq-scheduler:pushed:#{job_name}"
     end
   end
 end

data/web/locales/cs.yml

@@ -6,4 +6,6 @@ cs:
   class: Třída
   queue: Fronta
   arguments: Argumenty
-  enqueue_now: Zařadit nyní
+  enqueue_now: Zařadit nyní
+  next_time: Příště
+  no_next_time: no next execution for this job

data/web/locales/en.yml

@@ -6,4 +6,6 @@ en:
   class: Class
   queue: Queue
   arguments: Arguments
-  enqueue_now: Enqueue now
+  enqueue_now: Enqueue now
+  next_time: Next Time
+  no_next_time: no next execution for this job

data/web/locales/es.yml

@@ -6,4 +6,6 @@ es:
   class: Clase
   queue: Cola
   arguments: Argumentos
-  enqueue_now: Encolar ahora
+  enqueue_now: Encolar ahora
+  next_time: Próxima ejecución
+  no_next_time: esta tarea no se volverá a ejecutar

data/web/views/recurring_jobs.erb

@@ -10,23 +10,25 @@
         <th><%= t('class') %></th>
         <th><%= t('queue') %></th>
         <th><%= t('arguments') %></th>
+        <th><%= t('next_time') %></th>
         <th></th>
       </tr>
     </thead>
 
     <tbody>
-      <% @schedule.each do |name, job_spec| %>
+      <% @presented_jobs.each do |job| %>
         <tr>
-          <td><%= name %></td>
-          <td><%= job_spec['description'] %></td>
-          <td><%= job_spec.fetch 'cron', job_spec['every'] %></td>
-          <td><%= job_spec['class'] %></td>
+          <td><%= job.name %></td>
+          <td><%= job['description'] %></td>
+          <td><%= job.interval %></td>
+          <td><%= job['class'] %></td>
           <td>
-            <a href="<%= root_path %>queues/<%= job_spec.fetch('queue', 'default') %>"><%= job_spec.fetch('queue', 'default') %></a>
+            <a href="<%= root_path %>queues/<%= job.queue %>"><%= job.queue %></a>
           </td>
-          <td><%= job_spec['args'] %></td>
+          <td><%= job['args'] %></td>
+          <td><%= job.next_time || t('no_next_time') %></td>
           <td class="text-center">
-            <a class="btn btn-warn btn-xs" href="<%= root_path %>recurring-jobs/<%= URI.escape(name) %>/enqueue">
+            <a class="btn btn-warn btn-xs" href="<%= root_path %>recurring-jobs/<%= URI.escape(job.name) %>/enqueue">
               <%= t('enqueue_now') %>
             </a>
           </td>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-scheduler
 version: !ruby/object:Gem::Version
-  version: 2.0.8
+  version: 2.0.9
 platform: ruby
 authors:
 - Morton Jonuschat
@@ -9,216 +9,216 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-06 00:00:00.000000000 Z
+date: 2016-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: rufus-scheduler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 3.1.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 3.1.8
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mock_redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - <
       - !ruby/object:Gem::Version
         version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - <
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Light weight job scheduling extension for Sidekiq that adds support for
@@ -229,19 +229,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- MIT-LICENSE
-- README.md
-- Rakefile
 - lib/sidekiq-scheduler.rb
-- lib/sidekiq-scheduler/manager.rb
+- lib/sidekiq/scheduler.rb
 - lib/sidekiq-scheduler/schedule.rb
 - lib/sidekiq-scheduler/version.rb
+- lib/sidekiq-scheduler/job_presenter.rb
+- lib/sidekiq-scheduler/manager.rb
 - lib/sidekiq-scheduler/web.rb
-- lib/sidekiq/scheduler.rb
+- web/views/recurring_jobs.erb
 - web/locales/cs.yml
 - web/locales/en.yml
 - web/locales/es.yml
-- web/views/recurring_jobs.erb
+- MIT-LICENSE
+- Rakefile
+- README.md
 homepage: https://github.com/moove-it/sidekiq-scheduler
 licenses:
 - MIT
@@ -252,17 +253,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: Light weight job scheduling extension for Sidekiq