sidekiq-scheduler 2.2.2 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2747b49a61187194593a74c6cdba9979d26fa99a
-  data.tar.gz: 3cda4ae1544bff66d97b7a94503a75aca57a237f
+SHA256:
+  metadata.gz: aff61224563645891063110d5f9ae5d16e6ccb0fee92df6a5f26976d0169c01b
+  data.tar.gz: d8a6ac2c6e17426bc095904ac3721a9433a21cfd1be433e5f280b9af5469954a
 SHA512:
-  metadata.gz: fc793b476d9a19bbc541dedef091e52ffabf08d88800c4a423121e9181d6042b39bd06498bec1c98dc3763b7ee4bf6b0f13e43896bf7d58d672d3570f5039776
-  data.tar.gz: 97da3f5c4e75468877f59e713407554364befe57b8891371dab4b17387b2f18cbba633695b28cbb99e53f6f63ac090ee3ae3bd64abf2875062f49db71cf45d84
+  metadata.gz: b01ea69bb3bafd959681e3f7cb3a5699385bdf73bf8abeb8e75a6e2765ec1476862f1d499046ae00233539ec266d313c55c03558961fab8f02b048e4164778bd
+  data.tar.gz: 7662c439f79b05f2954cfc0e1da2d0a84236334f75101431ed187ae8c69df47baa52cbee901e90a84e81b7ed5b7f81198938ca09cf3710f5885866b334cfcb43

data/README.md

@@ -30,6 +30,8 @@
 `sidekiq-scheduler` is an extension to [Sidekiq](http://github.com/mperham/sidekiq) that
 pushes jobs in a scheduled way, mimicking cron utility.
 
+__Note:__ If you are looking for version 2.2.*, go to [2.2-stable branch](https://github.com/moove-it/sidekiq-scheduler/tree/2.2-stable).
+
 ## Installation
 
 ``` shell
@@ -177,9 +179,19 @@ Cron, every, and interval types push jobs into sidekiq in a recurrent manner.
     every: '45m'    # Runs every 45 minutes
 ```
 
+The value is parsed by [`Fugit::Duration.parse`](https://github.com/floraison/fugit#fugitduration). It understands quite a number of formats, including human-readable ones:
+
+``` yaml
+    every: 45 minutes
+    every: 2 hours and 30 minutes
+    every: 1.5 hours
+```
+
 `interval` is similar to `every`, the difference between them is that `interval` type schedules the
 next execution after the interval has elapsed counting from its last job enqueue.
 
+Note that `every` and `interval` count from when the Sidekiq process (re)starts. So `every: '48h'` will never run if the Sidekiq process is restarted daily, for example. You can do `every: ['48h', first_in: '0s']` to make the job run immediately after a restart, and then have the worker check when it was last run.
+
 At, and in types push jobs only once. `at` schedules in a point in time:
 ``` yaml
     at: '3001/01/01'
@@ -228,7 +240,7 @@ require 'sidekiq-scheduler'
 Sidekiq.configure_server do |config|
   config.on(:startup) do
     Sidekiq.schedule = YAML.load_file(File.expand_path('../../sidekiq_scheduler.yml', __FILE__))
-    Sidekiq::Scheduler.reload_schedule!
+    SidekiqScheduler::Scheduler.instance.reload_schedule!
   end
 end
 ```
@@ -256,7 +268,7 @@ If `:dynamic` flag is set to `false`, you'll have to reload the schedule manuall
 side:
 
 ``` ruby
-Sidekiq::Scheduler.reload_schedule!
+SidekiqScheduler::Scheduler.instance.reload_schedule!
 ```
 
 Invoke `Sidekiq.get_schedule` to obtain the current schedule:
@@ -268,8 +280,9 @@ Sidekiq.get_schedule
 
 ## Time zones
 
-Note that if you use the cron syntax, this will be interpreted as in the server time zone
-rather than the `config.time_zone` specified in Rails.
+Note that if you use the cron syntax and are not running a Rails app, this will be interpreted in the server time zone.
+
+In a Rails app, [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) (>= 3.3.3) will use the `config.time_zone` specified in Rails.
 
 You can explicitly specify the time zone that rufus-scheduler will use:
 
@@ -294,7 +307,7 @@ That's a minimum of `concurrency` + 5 (per the [Sidekiq wiki](https://github.com
 You can also override the thread pool size in Rufus Scheduler by setting e.g.:
 
 ```
-Sidekiq::Scheduler.rufus_scheduler_options = { max_work_threads: 5 }
+SidekiqScheduler::Scheduler.instance.rufus_scheduler_options = { max_work_threads: 5 }
 ```
 
 ## Notes about running on Multiple Hosts
@@ -308,6 +321,19 @@ Non-normal conditions that could push a specific job multiple times are:
 
 `every`, `interval` and `in` jobs will be pushed once per host.
 
+## Notes on when sidekiq worker is down
+
+For a `cron`/`at` (and all other) job to be successfully enqueued, you need at least one sidekiq worker with scheduler to be up at that moment. Handling this is up to you and depends on your application.
+
+Possible solutions include:
+- Simply ignoring this fact, if you only run frequent periodic jobs, that can tolerate some increased interval
+- Abstaining from deploys/restarts during time when critical jobs are usually scheduled
+- Making your infrequent jobs idempotent (so that they can be enqueued multiple times but still produce result as if was run once) and scheduling them multiple times to reduce likelihood of not being run
+- Zero downtime deploy for sidekiq workers: keep at least one worker up during whole deploy and only restart/shut it down after when new one has started
+- Running scheduler inside your unicorn/rails processes (if you already have zero downtime deploy set up for these)
+
+Each option has it's own pros and cons. 
+
 ## Sidekiq Web Integration
 
 sidekiq-scheduler provides an extension to the Sidekiq web interface that adds a `Recurring Jobs` page.
@@ -367,12 +393,12 @@ if Rails.env == 'production' && (defined?(Rails::Server) || defined?(Unicorn))
 
     config.on(:startup) do
       Sidekiq.schedule = YAML.load_file(File.expand_path('../../scheduler.yml', __FILE__))
-      Sidekiq::Scheduler.reload_schedule!
+      SidekiqScheduler::Scheduler.instance.reload_schedule!
     end
   end
 else
-  Sidekiq::Scheduler.enabled = false
-  puts "Sidekiq::Scheduler.enabled is #{Sidekiq::Scheduler.enabled.inspect}"
+  SidekiqScheduler::Scheduler.instance.enabled = false
+  puts "SidekiqScheduler::Scheduler.instance.enabled is #{SidekiqScheduler::Scheduler.instance.enabled.inspect}"
 end
 ```
 
@@ -382,6 +408,6 @@ MIT License
 
 ## Copyright
 
-Copyright 2013 - 2017 Moove-IT.
+Copyright 2013 - 2018 Moove-IT.
 Copyright 2012 Morton Jonuschat.
 Some parts copyright 2010 Ben VandenBos.

data/lib/sidekiq-scheduler/extensions/web.rb

@@ -1,5 +1,11 @@
 require 'sidekiq/web' unless defined?(Sidekiq::Web)
 
+ASSETS_PATH = File.expand_path('../../../web/assets', __dir__)
+
 Sidekiq::Web.register(SidekiqScheduler::Web)
 Sidekiq::Web.tabs['recurring_jobs'] = 'recurring-jobs'
-Sidekiq::Web.locales << File.expand_path(File.dirname(__FILE__) + '/../../../web/locales')
+Sidekiq::Web.locales << File.expand_path("#{File.dirname(__FILE__)}/../../../web/locales")
+Sidekiq::Web.use Rack::Static, urls: ['/stylesheets'],
+                               root: ASSETS_PATH,
+                               cascade: true,
+                               header_rules: [[:all, { 'Cache-Control' => 'public, max-age=86400' }]]

data/lib/sidekiq-scheduler/job_presenter.rb

@@ -66,7 +66,7 @@ module SidekiqScheduler
     def self.build_collection(schedule_hash)
       schedule_hash ||= {}
 
-      schedule_hash.map do |name, job_spec|
+      schedule_hash.sort.map do |name, job_spec|
         new(name, job_spec)
       end
     end

data/lib/sidekiq-scheduler/manager.rb

@@ -14,26 +14,44 @@ module SidekiqScheduler
   class Manager
     include Sidekiq::Util
 
+    DEFAULT_SCHEDULER_OPTIONS = {
+      enabled: true,
+      dynamic: false,
+      dynamic_every: '5s',
+      schedule: {}
+    }
+
     def initialize(options)
-      SidekiqScheduler::Scheduler.enabled = options[:enabled]
-      SidekiqScheduler::Scheduler.dynamic = options[:dynamic]
-      SidekiqScheduler::Scheduler.dynamic_every = options[:dynamic_every]
-      SidekiqScheduler::Scheduler.listened_queues_only = options[:listened_queues_only]
-      Sidekiq.schedule = options[:schedule] if SidekiqScheduler::Scheduler.enabled
+      scheduler_options = load_scheduler_options(options)
+
+      @scheduler_instance = SidekiqScheduler::Scheduler.new(scheduler_options)
+      SidekiqScheduler::Scheduler.instance = @scheduler_instance
+      Sidekiq.schedule = scheduler_options[:schedule] if @scheduler_instance.enabled
     end
 
     def stop
-      SidekiqScheduler::Scheduler.clear_schedule!
+      @scheduler_instance.clear_schedule!
     end
 
     def start
-      SidekiqScheduler::Scheduler.load_schedule!
+      @scheduler_instance.load_schedule!
     end
 
-    def reset
-      clear_scheduled_work
-    end
+    private
 
-  end
+    def load_scheduler_options(options)
+      options[:listened_queues_only] = options.fetch(:scheduler, {})[:listened_queues_only]
+      scheduler_options = DEFAULT_SCHEDULER_OPTIONS.merge(options)
 
+      current_options = {
+        enabled: SidekiqScheduler::Scheduler.enabled,
+        dynamic: SidekiqScheduler::Scheduler.dynamic,
+        dynamic_every: SidekiqScheduler::Scheduler.dynamic_every,
+        schedule: Sidekiq.schedule,
+        listened_queues_only: SidekiqScheduler::Scheduler.listened_queues_only
+      }.delete_if { |_, value| value.nil? }
+
+      scheduler_options.merge(current_options)
+    end
+  end
 end

data/lib/sidekiq-scheduler/redis_manager.rb

@@ -96,7 +96,14 @@ module SidekiqScheduler
     #
     # @return [Boolean] true if the schedules key is set, false otherwise
     def self.schedule_exist?
-      Sidekiq.redis { |r| r.exists(:schedules) }
+      Sidekiq.redis do |r|
+        case r.exists(:schedules)
+        when true, 1
+          true
+        else
+          false
+        end
+      end
     end
 
     # Returns all the schedule changes for a given time range.

data/lib/sidekiq-scheduler/scheduler.rb

@@ -2,7 +2,6 @@ require 'rufus/scheduler'
 require 'thwait'
 require 'sidekiq/util'
 require 'json'
-require 'sidekiq-scheduler/manager'
 require 'sidekiq-scheduler/rufus_utils'
 require 'sidekiq-scheduler/redis_manager'
 
@@ -10,400 +9,348 @@ module SidekiqScheduler
   class Scheduler
     extend Sidekiq::Util
 
-    RUFUS_METADATA_KEYS = %w(description at cron every in interval enabled)
-
     # We expect rufus jobs to have #params
     Rufus::Scheduler::Job.module_eval do
-
       alias_method :params, :opts
-
     end
 
-    class << self
+    # Set to enable or disable the scheduler.
+    attr_accessor :enabled
 
-      # Set to enable or disable the scheduler.
-      attr_accessor :enabled
+    # Set to update the schedule in runtime in a given time period.
+    attr_accessor :dynamic
 
-      # 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 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
 
-      # Set to schedule jobs only when will be pushed to queues listened by sidekiq
-      attr_accessor :listened_queues_only
+    class << self
 
-      # the Rufus::Scheduler jobs that are scheduled
-      def scheduled_jobs
-        @@scheduled_jobs
+      def instance
+        @instance = new unless @instance
+        @instance
       end
 
-      def print_schedule
-        if rufus_scheduler
-          logger.info "Scheduling Info\tLast Run"
-          scheduler_jobs = rufus_scheduler.all_jobs
-          scheduler_jobs.each_value do |v|
-            logger.info "#{v.t}\t#{v.last}\t"
-          end
-        end
+      def instance=(value)
+        @instance = value
       end
 
-      # 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!
-            @current_changed_score = Time.now.to_f
-            rufus_scheduler.every(dynamic_every) do
-              update_schedule
-            end
-          end
-
-          logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
-
+      def method_missing(method, *arguments, &block)
+        instance_methods.include?(method) ? instance.public_send(method, *arguments) : super
+      end
+    end
 
-          @@scheduled_jobs = {}
-          queues = sidekiq_queues
+    def initialize(options = {})
+      self.enabled = options[:enabled]
+      self.dynamic = options[:dynamic]
+      self.dynamic_every = options[:dynamic_every]
+      self.listened_queues_only = options[:listened_queues_only]
+    end
 
-          Sidekiq.schedule.each do |name, config|
-            if !listened_queues_only || enabled_queue?(config['queue'].to_s, queues)
-              load_schedule_job(name, config)
-            else
-              logger.info { "Ignoring #{name}, job's queue is not enabled." }
-            end
-          end
+    # the Rufus::Scheduler jobs that are scheduled
+    def scheduled_jobs
+      @scheduled_jobs
+    end
 
-          logger.info 'Schedules Loaded'
-        else
-          logger.info 'SidekiqScheduler is disabled'
+    def print_schedule
+      if rufus_scheduler
+        Sidekiq.logger.info "Scheduling Info\tLast Run"
+        scheduler_jobs = rufus_scheduler.all_jobs
+        scheduler_jobs.each_value do |v|
+          Sidekiq.logger.info "#{v.t}\t#{v.last}\t"
         end
       end
+    end
 
-      # 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
-
-              schedule, options = SidekiqScheduler::RufusUtils.normalize_schedule_options(config_interval_type)
+    # Pulls the schedule from Sidekiq.schedule and loads it into the
+    # rufus scheduler instance
+    def load_schedule!
+      if enabled
+        Sidekiq.logger.info 'Loading Schedule'
 
-              rufus_job = new_job(name, interval_type, config, schedule, options)
-              @@scheduled_jobs[name] = rufus_job
-              update_job_next_time(name, rufus_job.next_time)
+        # Load schedule from redis for the first time if dynamic
+        if dynamic
+          Sidekiq.reload_schedule!
+          @current_changed_score = Time.now.to_f
+          rufus_scheduler.every(dynamic_every) do
+            update_schedule
+          end
+        end
 
-              interval_defined = true
+        Sidekiq.logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
 
-              break
-            end
-          end
+        @scheduled_jobs = {}
+        queues = sidekiq_queues
 
-          unless interval_defined
-            logger.info "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
+        Sidekiq.schedule.each do |name, config|
+          if !listened_queues_only || enabled_queue?(config['queue'].to_s, queues)
+            load_schedule_job(name, config)
+          else
+            Sidekiq.logger.info { "Ignoring #{name}, job's queue is not enabled." }
           end
         end
+
+        Sidekiq.logger.info 'Schedules Loaded'
+      else
+        Sidekiq.logger.info 'SidekiqScheduler is disabled'
       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)
+    # 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)
+        Sidekiq.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 registered
-          logger.info "queueing #{config['class']} (#{job_name})"
+          if !config_interval_type.nil? && config_interval_type.length > 0
 
-          handle_errors { enqueue_job(config, time) }
+            schedule, options = SidekiqScheduler::RufusUtils.normalize_schedule_options(config_interval_type)
 
-          remove_elder_job_instances(job_name)
-        else
-          logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
-        end
-      end
+            rufus_job = new_job(name, interval_type, config, schedule, options)
+            @scheduled_jobs[name] = rufus_job
+            SidekiqScheduler::Utils.update_job_next_time(name, rufus_job.next_time)
 
-      # 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)
-        if next_time
-          SidekiqScheduler::RedisManager.set_job_next_time(name, next_time)
-        else
-          SidekiqScheduler::RedisManager.remove_job_next_time(name)
-        end
-      end
+            interval_defined = true
 
-      # Pushes job's last execution time
-      #
-      # @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)
-        SidekiqScheduler::RedisManager.set_job_last_time(name, last_time) if last_time
-      end
-
-      # 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
+            break
+          end
+        end
 
-      def handle_errors
-        begin
-          yield
-        rescue StandardError => e
-          logger.info "#{e.class.name}: #{e.message}"
+        unless interval_defined
+          Sidekiq.logger.info "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
         end
       end
+    end
 
-      # Enqueue a job based on a config hash
-      #
-      # @param job_config [Hash] the job configuration
-      # @param time [Time] time the job is enqueued
-      def enqueue_job(job_config, time=Time.now)
-        config = prepare_arguments(job_config.dup)
+    # 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 = SidekiqScheduler::RedisManager.register_job_instance(job_name, time)
 
-        if config.delete('include_metadata')
-          config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
-        end
+      if registered
+        Sidekiq.logger.info "queueing #{config['class']} (#{job_name})"
 
-        if active_job_enqueue?(config['class'])
-          enqueue_with_active_job(config)
-        else
-          enqueue_with_sidekiq(config)
-        end
-      end
+        handle_errors { enqueue_job(config, time) }
 
-      def rufus_scheduler_options
-        @rufus_scheduler_options ||= {}
+        SidekiqScheduler::RedisManager.remove_elder_job_instances(job_name)
+      else
+        Sidekiq.logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
       end
+    end
 
-      def rufus_scheduler_options=(options)
-        @rufus_scheduler_options = options
-      end
+    # Enqueue a job based on a config hash
+    #
+    # @param job_config [Hash] the job configuration
+    # @param time [Time] time the job is enqueued
+    def enqueue_job(job_config, time = Time.now)
+      config = prepare_arguments(job_config.dup)
 
-      def rufus_scheduler
-        @rufus_scheduler ||= new_rufus_scheduler
+      if config.delete('include_metadata')
+        config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
       end
 
-      # Stops old rufus scheduler and creates a new one.  Returns the new
-      # rufus scheduler
-      #
-      # @param [Symbol] stop_option The option to be passed to Rufus::Scheduler#stop
-      def clear_schedule!(stop_option = :wait)
-        rufus_scheduler.stop(stop_option)
-        @rufus_scheduler = nil
-        @@scheduled_jobs = {}
-        rufus_scheduler
+      if active_job_enqueue?(config['class'])
+        SidekiqScheduler::Utils.enqueue_with_active_job(config)
+      else
+        SidekiqScheduler::Utils.enqueue_with_sidekiq(config)
       end
+    end
 
-      def reload_schedule!
-        if enabled
-          logger.info 'Reloading Schedule'
-          clear_schedule!
-          load_schedule!
-        else
-          logger.info 'SidekiqScheduler is disabled'
-        end
-      end
+    def rufus_scheduler_options
+      @rufus_scheduler_options ||= {}
+    end
 
-      def update_schedule
-        last_changed_score, @current_changed_score = @current_changed_score, Time.now.to_f
-        schedule_changes = SidekiqScheduler::RedisManager.get_schedule_changes(last_changed_score, @current_changed_score)
+    def rufus_scheduler_options=(options)
+      @rufus_scheduler_options = options
+    end
 
-        if schedule_changes.size > 0
-          logger.info 'Updating schedule'
+    def rufus_scheduler
+      @rufus_scheduler ||= SidekiqScheduler::Utils.new_rufus_scheduler(rufus_scheduler_options)
+    end
 
-          Sidekiq.reload_schedule!
-          schedule_changes.each do |schedule_name|
-            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 'Schedule updated'
-        end
+    # Stops old rufus scheduler and creates a new one.  Returns the new
+    # rufus scheduler
+    #
+    # @param [Symbol] stop_option The option to be passed to Rufus::Scheduler#stop
+    def clear_schedule!(stop_option = :wait)
+      if @rufus_scheduler
+        @rufus_scheduler.stop(stop_option)
+        @rufus_scheduler = nil
       end
 
-      def unschedule_job(name)
-        if scheduled_jobs[name]
-          logger.debug "Removing schedule #{name}"
-          scheduled_jobs[name].unschedule
-          scheduled_jobs.delete(name)
-        end
-      end
+      @@scheduled_jobs = {}
 
-      def enqueue_with_active_job(config)
-        options = {
-          queue: config['queue']
-        }.keep_if { |_, v| !v.nil? }
+      rufus_scheduler
+    end
 
-        initialize_active_job(config['class'], config['args']).enqueue(options)
+    def reload_schedule!
+      if enabled
+        Sidekiq.logger.info 'Reloading Schedule'
+        clear_schedule!
+        load_schedule!
+      else
+        Sidekiq.logger.info 'SidekiqScheduler is disabled'
       end
+    end
 
-      def enqueue_with_sidekiq(config)
-        Sidekiq::Client.push(sanitize_job_config(config))
-      end
+    def update_schedule
+      last_changed_score, @current_changed_score = @current_changed_score, Time.now.to_f
+      schedule_changes = SidekiqScheduler::RedisManager.get_schedule_changes(last_changed_score, @current_changed_score)
 
-      def initialize_active_job(klass, args)
-        if args.is_a?(Array)
-          klass.new(*args)
-        else
-          klass.new(args)
-        end
-      end
+      if schedule_changes.size > 0
+        Sidekiq.logger.info 'Updating schedule'
 
-      # 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)
+        Sidekiq.reload_schedule!
+        schedule_changes.each do |schedule_name|
+          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
+        Sidekiq.logger.info 'Schedule updated'
       end
+    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 job_enabled?(name)
+      job = Sidekiq.schedule[name]
+      schedule_state(name).fetch('enabled', job.fetch('enabled', true)) if job
+    end
 
-        config
-      end
+    def toggle_job_enabled(name)
+      state = schedule_state(name)
+      state['enabled'] = !job_enabled?(name)
+      set_schedule_state(name, state)
+    end
 
-      def try_to_constantize(klass)
-        klass.is_a?(String) ? klass.constantize : klass
-      rescue NameError
-        klass
-      end
+    private
 
-      # Returns true if a job's queue is included in the array of queues
-      #
-      # If queues are empty, returns true.
-      #
-      # @param [String] job_queue Job's queue name
-      # @param [Array<String>] queues
-      #
-      # @return [Boolean]
-      def enabled_queue?(job_queue, queues)
-        queues.empty? || queues.include?(job_queue)
-      end
+    def new_job(name, interval_type, config, schedule, options)
+      options = options.merge({ :job => true, :tags => [name] })
 
-      # 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)
-        SidekiqScheduler::RedisManager.register_job_instance(job_name, time)
+      rufus_scheduler.send(interval_type, schedule, options) do |job, time|
+        idempotent_job_enqueue(name, time, SidekiqScheduler::Utils.sanitize_job_config(config)) if job_enabled?(name)
       end
+    end
 
-      def remove_elder_job_instances(job_name)
-        SidekiqScheduler::RedisManager.remove_elder_job_instances(job_name)
+    def unschedule_job(name)
+      if scheduled_jobs[name]
+        Sidekiq.logger.debug "Removing schedule #{name}"
+        scheduled_jobs[name].unschedule
+        scheduled_jobs.delete(name)
       end
+    end
 
-      def job_enabled?(name)
-        job = Sidekiq.schedule[name]
-        schedule_state(name).fetch('enabled', job.fetch('enabled', true)) if job
-      end
+    # Retrieves a schedule state
+    #
+    # @param name [String] with the schedule's name
+    # @return [Hash] with the schedule's state
+    def schedule_state(name)
+      state = SidekiqScheduler::RedisManager.get_job_state(name)
 
-      def toggle_job_enabled(name)
-        state = schedule_state(name)
-        state['enabled'] = !job_enabled?(name)
-        set_schedule_state(name, state)
-      end
+      state ? JSON.parse(state) : {}
+    end
 
-      private
+    # Saves a schedule state
+    #
+    # @param name [String] with the schedule's name
+    # @param name [Hash] with the schedule's state
+    def set_schedule_state(name, state)
+      SidekiqScheduler::RedisManager.set_job_state(name, state)
+    end
 
-      def new_rufus_scheduler
-        Rufus::Scheduler.new(rufus_scheduler_options).tap do |scheduler|
-          scheduler.define_singleton_method(:on_post_trigger) do |job, triggered_time|
-            SidekiqScheduler::Scheduler.update_job_last_time(job.tags[0], triggered_time)
-            SidekiqScheduler::Scheduler.update_job_next_time(job.tags[0], job.next_time)
-          end
-        end
+    # Adds a Hash with schedule metadata as the last argument to call the worker.
+    # It currently returns the schedule time as a Float number representing the milisencods
+    # since epoch.
+    #
+    # @example with hash argument
+    #   arguments_with_metadata({value: 1}, scheduled_at: Time.now)
+    #   #=> [{value: 1}, {scheduled_at: <miliseconds since epoch>}]
+    #
+    # @param args [Array|Hash]
+    # @param metadata [Hash]
+    # @return [Array] arguments with added metadata
+    def arguments_with_metadata(args, metadata)
+      if args.is_a? Array
+        [*args, metadata]
+      else
+        [args, metadata]
       end
+    end
 
-      def new_job(name, interval_type, config, schedule, options)
-        options = options.merge({ :job => true, :tags => [name] })
+    def sidekiq_queues
+      Sidekiq.options[:queues].map(&:to_s)
+    end
 
-        rufus_scheduler.send(interval_type, schedule, options) do |job, time|
-          idempotent_job_enqueue(name, time, sanitize_job_config(config)) if job_enabled?(name)
-        end
-      end
+    # Returns true if a job's queue is included in the array of queues
+    #
+    # If queues are empty, returns true.
+    #
+    # @param [String] job_queue Job's queue name
+    # @param [Array<String>] queues
+    #
+    # @return [Boolean]
+    def enabled_queue?(job_queue, queues)
+      queues.empty? || queues.include?(job_queue)
+    end
 
-      def sanitize_job_config(config)
-        config.reject { |k, _| RUFUS_METADATA_KEYS.include?(k) }
-      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 active_job_enqueue?(klass)
+      klass.is_a?(Class) && defined?(ActiveJob::Enqueuing) &&
+        klass.included_modules.include?(ActiveJob::Enqueuing)
+    end
 
-      # Retrieves a schedule state
-      #
-      # @param name [String] with the schedule's name
-      # @return [Hash] with the schedule's state
-      def schedule_state(name)
-        state = SidekiqScheduler::RedisManager.get_job_state(name)
+    # 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'] = SidekiqScheduler::Utils.try_to_constantize(config['class'])
 
-        state ? JSON.parse(state) : {}
+      if config['args'].is_a?(Hash)
+        config['args'].symbolize_keys! if config['args'].respond_to?(:symbolize_keys!)
+      else
+        config['args'] = Array(config['args'])
       end
 
-      # Saves a schedule state
-      #
-      # @param name [String] with the schedule's name
-      # @param name [Hash] with the schedule's state
-      def set_schedule_state(name, state)
-        SidekiqScheduler::RedisManager.set_job_state(name, state)
-      end
+      config
+    end
 
-      # Adds a Hash with schedule metadata as the last argument to call the worker.
-      # It currently returns the schedule time as a Float number representing the milisencods
-      # since epoch.
-      #
-      # @example with hash argument
-      #   arguments_with_metadata({value: 1}, scheduled_at: Time.now)
-      #   #=> [{value: 1}, {scheduled_at: <miliseconds since epoch>}]
-      #
-      # @param args [Array|Hash]
-      # @param metadata [Hash]
-      # @return [Array] arguments with added metadata
-      def arguments_with_metadata(args, metadata)
-        if args.is_a? Array
-          [*args, metadata]
-        else
-          [args, metadata]
-        end
-      end
+    # Returns true if the given schedule config hash matches the current ENV['RAILS_ENV']
+    # @param [Hash] config The schedule job configuration
+    #
+    # @return [Boolean] true if the schedule config 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
 
-      def sidekiq_queues
-        Sidekiq.options[:queues].map(&:to_s)
+    def handle_errors
+      begin
+        yield
+      rescue StandardError => e
+        Sidekiq.logger.info "#{e.class.name}: #{e.message}"
       end
     end
   end

data/lib/sidekiq-scheduler/utils.rb

@@ -3,6 +3,8 @@ require 'set'
 module SidekiqScheduler
   module Utils
 
+    RUFUS_METADATA_KEYS = %w(description at cron every in interval enabled)
+
     # Stringify keys belonging to a hash.
     #
     # Also stringifies nested keys and keys of hashes inside arrays, and sets
@@ -40,5 +42,89 @@ module SidekiqScheduler
         object
       end
     end
+
+    # Constantize a given string.
+    #
+    # @param [String] klass The string to constantize
+    #
+    # @return [Class] the class corresponding to the klass param
+    def self.try_to_constantize(klass)
+      klass.is_a?(String) ? klass.constantize : klass
+    rescue NameError
+      klass
+    end
+
+    # Initializes active_job using the passed parameters.
+    #
+    # @param [Class] klass The class to initialize
+    # @param [Array/Hash] the parameters passed to the klass initializer
+    #
+    # @return [Object] instance of the class klass
+    def self.initialize_active_job(klass, args)
+      if args.is_a?(Array)
+        klass.new(*args)
+      else
+        klass.new(args)
+      end
+    end
+
+    # Enqueues the job using the Sidekiq client.
+    #
+    # @param [Hash] config The job configuration
+    def self.enqueue_with_sidekiq(config)
+      Sidekiq::Client.push(sanitize_job_config(config))
+    end
+
+    # Enqueues the job using the ActiveJob.
+    #
+    # @param [Hash] config The job configuration
+    def self.enqueue_with_active_job(config)
+      options = {
+        queue: config['queue']
+      }.keep_if { |_, v| !v.nil? }
+
+      initialize_active_job(config['class'], config['args']).enqueue(options)
+    end
+
+    # Removes the hash values associated to the rufus metadata keys.
+    #
+    # @param [Hash] config The job configuration
+    #
+    # @return [Hash] the sanitized job config
+    def self.sanitize_job_config(config)
+      config.reject { |k, _| RUFUS_METADATA_KEYS.include?(k) }
+    end
+
+    # Creates a new instance of rufus scheduler.
+    #
+    # @return [Rufus::Scheduler] the scheduler instance
+    def self.new_rufus_scheduler(options = {})
+      Rufus::Scheduler.new(options).tap do |scheduler|
+        scheduler.define_singleton_method(:on_post_trigger) do |job, triggered_time|
+          SidekiqScheduler::Utils.update_job_last_time(job.tags[0], triggered_time)
+          SidekiqScheduler::Utils.update_job_next_time(job.tags[0], job.next_time)
+        end
+      end
+    end
+
+    # Pushes job's next time execution
+    #
+    # @param [String] name The job's name
+    # @param [Time] next_time The job's next time execution
+    def self.update_job_next_time(name, next_time)
+      if next_time
+        SidekiqScheduler::RedisManager.set_job_next_time(name, next_time)
+      else
+        SidekiqScheduler::RedisManager.remove_job_next_time(name)
+      end
+    end
+
+    # Pushes job's last execution time
+    #
+    # @param [String] name The job's name
+    # @param [Time] last_time The job's last execution time
+    def self.update_job_last_time(name, last_time)
+      SidekiqScheduler::RedisManager.set_job_last_time(name, last_time) if last_time
+    end
   end
 end

data/lib/sidekiq-scheduler/version.rb

@@ -1,5 +1,5 @@
 module SidekiqScheduler
 
-  VERSION = '2.2.2'
+  VERSION = '3.1.1'
 
 end

data/lib/sidekiq-scheduler/web.rb

@@ -15,16 +15,16 @@ module SidekiqScheduler
         erb File.read(File.join(VIEW_PATH, 'recurring_jobs.erb'))
       end
 
-      app.get '/recurring-jobs/:name/enqueue' do
+      app.post '/recurring-jobs/:name/enqueue' do
         schedule = Sidekiq.get_schedule(params[:name])
-        SidekiqScheduler::Scheduler.enqueue_job(schedule)
+        SidekiqScheduler::Scheduler.instance.enqueue_job(schedule)
         redirect "#{root_path}recurring-jobs"
       end
 
-      app.get '/recurring-jobs/:name/toggle' do
+      app.post '/recurring-jobs/:name/toggle' do
         Sidekiq.reload_schedule!
 
-        SidekiqScheduler::Scheduler.toggle_job_enabled(params[:name])
+        SidekiqScheduler::Scheduler.instance.toggle_job_enabled(params[:name])
         redirect "#{root_path}recurring-jobs"
       end
     end

data/lib/sidekiq-scheduler.rb

@@ -10,40 +10,15 @@ require_relative 'sidekiq-scheduler/extensions/schedule'
 Sidekiq.configure_server do |config|
 
   config.on(:startup) do
-    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
-
-    scheduler = config.options.fetch(:scheduler, {})
-
-    listened_queues_only = Sidekiq::Scheduler.listened_queues_only
-    listened_queues_only = listened_queues_only.nil? ? scheduler[:listened_queues_only] : listened_queues_only
-
-    schedule = Sidekiq.schedule
-    schedule ||= config.options[:schedule] || {}
-
-    scheduler_options = {
-      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
     SidekiqScheduler::RedisManager.clean_schedules_changed
 
-    schedule_manager = SidekiqScheduler::Manager.new(scheduler_options)
+    schedule_manager = SidekiqScheduler::Manager.new(config.options)
     config.options[:schedule_manager] = schedule_manager
     config.options[:schedule_manager].start
   end
 
-  config.on(:shutdown) do
+  config.on(:quiet) do
     config.options[:schedule_manager].stop
   end
 

data/web/assets/stylesheets/recurring_jobs.css

@@ -0,0 +1,23 @@
+.recurring-jobs { border-top-left-radius: 4px; border-top-right-radius: 4px; }
+.recurring-jobs .title { margin-bottom: 5px; }
+.recurring-jobs .title .name { font-weight: bold;}
+.recurring-jobs .info,
+.recurring-jobs .description { margin-bottom: 5px; }
+.recurring-jobs .actions { margin-bottom: 5px; }
+.recurring-jobs .status,
+.recurring-jobs .description { font-size: 12px; }
+.recurring-jobs .enqueue { margin-bottom: 0.5rem }
+
+.list-group-item {
+  background-color: #f3f3f3;
+  color: #585454;
+  border: 1px solid rgba(0, 0, 0, 0.1);
+}
+
+@media (prefers-color-scheme: dark) {
+  .list-group-item {
+    background-color: #222;
+    color: white;
+    border: 1px solid #555;
+  }
+}

data/web/locales/ja.yml

@@ -0,0 +1,14 @@
+ja:
+  recurring_jobs: 定期ジョブ
+  name: 名前
+  description: 説明
+  interval: インターバル
+  class: クラス
+  queue: キュー
+  arguments: 引数
+  enqueue_now: すぐにエンキュー
+  last_time: 前回
+  next_time: 次回
+  no_next_time: このジョブの次の実行はありません
+  disable: 無効
+  enable: 有効

data/web/views/recurring_jobs.erb

@@ -1,48 +1,50 @@
-<h3><%= t('recurring_jobs') %></h3>
+<link href="<%= root_path %>stylesheets/recurring_jobs.css" media="screen" rel="stylesheet" type="text/css" />
 
-<div class="table_container">
-  <table class="table table-hover table-bordered table-striped table-white">
-    <thead>
-      <tr>
-        <th><%= t('name') %></th>
-        <th><%= t('description') %></th>
-        <th><%= t('interval') %></th>
-        <th><%= t('class') %></th>
-        <th><%= t('queue') %></th>
-        <th><%= t('arguments') %></th>
-        <th><%= t('last_time') %></th>
-        <th><%= t('next_time') %></th>
-        <th></th>
-      </tr>
-    </thead>
+<h3><%= t('recurring_jobs') %></h3>
 
-    <tbody>
-      <% @presented_jobs.each do |job| %>
-        <tr>
-          <td><%= job.name %></td>
-          <td><%= job['description'] %></td>
-          <td><%= job.interval %></td>
-          <td><%= job['class'] %></td>
-          <td>
-            <a href="<%= root_path %>queues/<%= job.queue %>"><%= job.queue %></a>
-          </td>
-          <td><%= job['args'] %></td>
-          <td><%= job.last_time %></td>
-          <td>
-            <span style="<%= 'text-decoration:line-through' unless job.enabled? %>">
-              <%= job.next_time || t('no_next_time') %>
+<div class="recurring-jobs">
+  <ul class="list-group">
+    <% @presented_jobs.each do |job| %>
+      <li class="list-group-item">
+        <div class="title">
+          <div class="row">
+            <div class="col-xs-6">
+              <span class="name"><%= job.name %></span>
+            </div>
+            <div class="col-xs-6 text-right">
+              <a href="<%= root_path %>queues/<%= job.queue %>"><%= job.queue %></a>
+            </div>
+          </div>
+        </div>
+        <div class="description"><%= job['description'] %></div>
+        <div class="info">
+          <div class="row">
+            <div class="col-md-4 class"><%= job['class'] %></div>
+            <div class="col-md-4 interval text-left"><%= t('interval') %>: <%= job.interval %></div>
+            <div class="col-md-4 args"><%= t('arguments') %>: <%= job['args'] %></div>
+          </div>
+        </div>
+        <div class="status row">
+          <div class="col-md-4 actions">
+            <form action="<%= root_path %>recurring-jobs/<%= ERB::Util.url_encode(job.name) %>/enqueue" method="post" class="enqueue">
+              <%= csrf_tag %>
+              <input type="submit" class="btn btn-warn btn-xs" value="<%= t('enqueue_now') %>" />
+            </form>
+            <form action="<%= root_path %>recurring-jobs/<%= ERB::Util.url_encode(job.name) %>/toggle" method="post">
+              <%= csrf_tag %>
+              <input type="submit" class="btn <%= job.enabled? ? "btn-primary" : "btn-warn"%> btn-xs" value="<%= job.enabled? ? t('disable') : t('enable') %>" />
+            </form>
+          </div>
+          <div class="col-md-4">
+            <span class="last_time"><%= t('last_time') %>: <%= job.last_time %></span>
+          </div>
+          <div class="col-md-4">
+            <span class="next_time text-right" style="<%= 'text-decoration:line-through' unless job.enabled? %>">
+              <%= t('next_time') %>: <%= job.next_time || t('no_next_time') %>
             </span>
-          </td>
-          <td class="text-center">
-            <a class="btn btn-warn btn-xs" href="<%= root_path %>recurring-jobs/<%= URI.escape(job.name) %>/enqueue">
-              <%= t('enqueue_now') %>
-            </a>
-            <a class="btn <%= job.enabled? ? "btn-primary" : "btn-warn"%> btn-xs" href="<%= root_path %>recurring-jobs/<%= URI.escape(job.name) %>/toggle">
-              <%= job.enabled? ? t('disable') : t('enable') %>
-            </a>
-          </td>
-        </tr>
-      <% end %>
-    </tbody>
-  </table>
+          </div>
+        </div>
+      </li>
+    <% end %>
+  </ul>
 </div>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-scheduler
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 3.1.1
 platform: ruby
 authors:
 - Morton Jonuschat
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-15 00:00:00.000000000 Z
+date: 2022-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -73,6 +73,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: thwait
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: e2mmap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -135,14 +163,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.19.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.19.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -251,12 +279,14 @@ files:
 - lib/sidekiq-scheduler/version.rb
 - lib/sidekiq-scheduler/web.rb
 - lib/sidekiq/scheduler.rb
+- web/assets/stylesheets/recurring_jobs.css
 - web/locales/cs.yml
 - web/locales/de.yml
 - web/locales/en.yml
 - web/locales/es.yml
 - web/locales/fr.yml
 - web/locales/it.yml
+- web/locales/ja.yml
 - web/locales/nl.yml
 - web/locales/pl.yml
 - web/locales/pt-BR.yml
@@ -283,8 +313,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.2.19
 signing_key: 
 specification_version: 4
 summary: Light weight job scheduling extension for Sidekiq