sidekiq-scheduler 2.1.10 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3f7cb5ee802d2e3b5c89b308fbcaff612911217
-  data.tar.gz: e6b488b10334b3af01c9d2521e31ec3c53f0ef20
+  metadata.gz: ac3ac2c861cfb11bbe7e875ad7ed7cff7822c99b
+  data.tar.gz: 542352c4b0ed726ac98c4fe80a80c3f1e5280d88
 SHA512:
-  metadata.gz: b56413d0c141f2ae15bfacb255a8eed2550b6b0f899703f5fd08d67539794878e411d9a5a48086f4fd9d7f542f6b78fe9a016b7edf32a78819b93c7860ecf2a2
-  data.tar.gz: 6b8524661830f24e9233a95ec94a18ad31eac1f0880a63a3bc48f728e802f8f5ffe79437bfd5d17bdc3ec07a79d142b0d991b33a5a6363f79a4e6f1c387ee2c2
+  metadata.gz: 62ae98b53be7b7d25562d9ed8c0e16579cdcaa1fcdee4c75def8ba2f5c68496ac853487030577eb52feb6bdc6f883ab127f9f651eafb769589ad6612a0383722
+  data.tar.gz: bf5ef6b12451881a3be4ea14a6ced7fb1e384a870e1f608e6130a0fd51e7821e9d799f7db324ba07c9b6cf687e61c9f8b4bf9d8dd1d9572316c6092290430387

data/README.md

@@ -287,9 +287,13 @@ ActiveSupport::TimeZone.find_tzinfo(Rails.configuration.time_zone).name
 
 ## Notes about running on Multiple Hosts
 
-`cron` and `at` jobs are pushed once regardless of the number of `sidekiq-scheduler` running instances,
+Under normal conditions, `cron` and `at` jobs are pushed once regardless of the number of `sidekiq-scheduler` running instances,
 assumming that time deltas between hosts is less than 24 hours.
 
+Non-normal conditions that could push a specific job multiple times are:
+ - high cpu load + a high number of jobs scheduled at the same time, like 100 jobs
+ - network / redis latency + 28 (see `MAX_WORK_THREADS` https://github.com/jmettraux/rufus-scheduler/blob/master/lib/rufus/scheduler.rb#L41) or more jobs scheduled within the same network latency window
+
 `every`, `interval` and `in` jobs will be pushed once per host.
 
 ## Sidekiq Web Integration

data/lib/sidekiq-scheduler.rb

@@ -1,9 +1,11 @@
 require 'sidekiq'
 require 'tilt/erb'
 
+require_relative 'sidekiq/scheduler'
 require_relative 'sidekiq-scheduler/version'
 require_relative 'sidekiq-scheduler/manager'
 require_relative 'sidekiq-scheduler/redis_manager'
+require_relative 'sidekiq-scheduler/extensions/schedule'
 
 Sidekiq.configure_server do |config|
 

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

@@ -0,0 +1,4 @@
+require 'sidekiq'
+require_relative '../schedule'
+
+Sidekiq.extend SidekiqScheduler::Schedule

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

@@ -0,0 +1,5 @@
+require 'sidekiq/web' unless defined?(Sidekiq::Web)
+
+Sidekiq::Web.register(SidekiqScheduler::Web)
+Sidekiq::Web.tabs['recurring_jobs'] = 'recurring-jobs'
+Sidekiq::Web.locales << File.expand_path(File.dirname(__FILE__) + '/../../../web/locales')

data/lib/sidekiq-scheduler/job_presenter.rb

@@ -56,7 +56,7 @@ module SidekiqScheduler
     end
 
     def enabled?
-      Sidekiq::Scheduler.job_enabled?(@name)
+      SidekiqScheduler::Scheduler.job_enabled?(@name)
     end
 
     # Builds the presenter instances for the schedule hash

data/lib/sidekiq-scheduler/manager.rb

@@ -2,8 +2,8 @@ require 'redis'
 
 require 'sidekiq/util'
 
-require 'sidekiq/scheduler'
 require 'sidekiq-scheduler/schedule'
+require 'sidekiq-scheduler/scheduler'
 
 module SidekiqScheduler
 
@@ -15,19 +15,19 @@ module SidekiqScheduler
     include Sidekiq::Util
 
     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
+      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
     end
 
     def stop
-      Sidekiq::Scheduler.clear_schedule!
+      SidekiqScheduler::Scheduler.clear_schedule!
     end
 
     def start
-      Sidekiq::Scheduler.load_schedule!
+      SidekiqScheduler::Scheduler.load_schedule!
     end
 
     def reset

data/lib/sidekiq-scheduler/schedule.rb

@@ -152,5 +152,3 @@ module SidekiqScheduler
     end
   end
 end
-
-Sidekiq.extend SidekiqScheduler::Schedule

data/lib/sidekiq-scheduler/scheduler.rb

@@ -0,0 +1,407 @@
+require 'rufus/scheduler'
+require 'thwait'
+require 'sidekiq/util'
+require 'json'
+require 'sidekiq-scheduler/manager'
+require 'sidekiq-scheduler/rufus_utils'
+require 'sidekiq-scheduler/redis_manager'
+
+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 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
+
+      # the Rufus::Scheduler jobs that are scheduled
+      def scheduled_jobs
+        @@scheduled_jobs
+      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
+      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?
+
+
+          @@scheduled_jobs = {}
+          queues = sidekiq_queues
+
+          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
+
+          logger.info 'Schedules Loaded'
+        else
+          logger.info 'SidekiqScheduler is disabled'
+        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)
+
+              rufus_job = new_job(name, interval_type, config, schedule, options)
+              @@scheduled_jobs[name] = rufus_job
+              update_job_next_time(name, rufus_job.next_time)
+
+              interval_defined = true
+
+              break
+            end
+          end
+
+          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, time) }
+
+          remove_elder_job_instances(job_name)
+        else
+          logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
+        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 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 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
+
+      def handle_errors
+        begin
+          yield
+        rescue StandardError => e
+          logger.info "#{e.class.name}: #{e.message}"
+        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)
+
+        if config.delete('include_metadata')
+          config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
+        end
+
+        if active_job_enqueue?(config['class'])
+          enqueue_with_active_job(config)
+        else
+          enqueue_with_sidekiq(config)
+        end
+      end
+
+      def rufus_scheduler_options
+        @rufus_scheduler_options ||= {}
+      end
+
+      def rufus_scheduler_options=(options)
+        @rufus_scheduler_options = options
+      end
+
+      def rufus_scheduler
+        @rufus_scheduler ||= new_rufus_scheduler
+      end
+
+      # 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
+
+      def reload_schedule!
+        if enabled
+          logger.info 'Reloading Schedule'
+          clear_schedule!
+          load_schedule!
+        else
+          logger.info 'SidekiqScheduler is disabled'
+        end
+      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)
+
+        if schedule_changes.size > 0
+          logger.info 'Updating schedule'
+          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
+      end
+
+      def unschedule_job(name)
+        if scheduled_jobs[name]
+          logger.debug "Removing schedule #{name}"
+          scheduled_jobs[name].unschedule
+          scheduled_jobs.delete(name)
+        end
+      end
+
+      def enqueue_with_active_job(config)
+        options = {
+          queue: config['queue']
+        }.keep_if { |_, v| !v.nil? }
+
+        initialize_active_job(config['class'], config['args']).enqueue(options)
+      end
+
+      def enqueue_with_sidekiq(config)
+        Sidekiq::Client.push(sanitize_job_config(config))
+      end
+
+      def initialize_active_job(klass, args)
+        if args.is_a?(Array)
+          klass.new(*args)
+        else
+          klass.new(args)
+        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 active_job_enqueue?(klass)
+        klass.is_a?(Class) && defined?(ActiveJob::Enqueuing) &&
+          klass.included_modules.include?(ActiveJob::Enqueuing)
+      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
+
+        config
+      end
+
+      def try_to_constantize(klass)
+        klass.is_a?(String) ? klass.constantize : klass
+      rescue NameError
+        klass
+      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
+
+      # 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)
+      end
+
+      def remove_elder_job_instances(job_name)
+        SidekiqScheduler::RedisManager.remove_elder_job_instances(job_name)
+      end
+
+      def job_enabled?(name)
+        job = Sidekiq.schedule[name]
+        schedule_state(name).fetch('enabled', job.fetch('enabled', true)) if job
+      end
+
+      def toggle_job_enabled(name)
+        state = schedule_state(name)
+        state['enabled'] = !job_enabled?(name)
+        set_schedule_state(name, state)
+      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|
+            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
+      end
+
+      def new_job(name, interval_type, config, schedule, options)
+        options = options.merge({ :job => true, :tags => [name] })
+
+        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
+
+      def sanitize_job_config(config)
+        config.reject { |k, _| RUFUS_METADATA_KEYS.include?(k) }
+      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)
+
+        state ? JSON.parse(state) : {}
+      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
+
+      # 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 sidekiq_queues
+        Sidekiq.options[:queues].map(&:to_s)
+      end
+    end
+  end
+end

data/lib/sidekiq-scheduler/version.rb

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

data/lib/sidekiq-scheduler/web.rb

@@ -17,21 +17,18 @@ module SidekiqScheduler
 
       app.get '/recurring-jobs/:name/enqueue' do
         schedule = Sidekiq.get_schedule(params[:name])
-        Sidekiq::Scheduler.enqueue_job(schedule)
+        SidekiqScheduler::Scheduler.enqueue_job(schedule)
         redirect "#{root_path}recurring-jobs"
       end
 
       app.get '/recurring-jobs/:name/toggle' do
         Sidekiq.reload_schedule!
 
-        Sidekiq::Scheduler.toggle_job_enabled(params[:name])
+        SidekiqScheduler::Scheduler.toggle_job_enabled(params[:name])
         redirect "#{root_path}recurring-jobs"
       end
     end
   end
 end
 
-require 'sidekiq/web' unless defined?(Sidekiq::Web)
-Sidekiq::Web.register(SidekiqScheduler::Web)
-Sidekiq::Web.tabs['recurring_jobs'] = 'recurring-jobs'
-Sidekiq::Web.locales << File.expand_path(File.dirname(__FILE__) + "/../../web/locales")
+require_relative 'extensions/web'

data/lib/sidekiq/scheduler.rb

@@ -1,407 +1,3 @@
-require 'rufus/scheduler'
-require 'thwait'
-require 'sidekiq/util'
-require 'sidekiq-scheduler/manager'
-require 'sidekiq-scheduler/rufus_utils'
-require_relative '../sidekiq-scheduler/redis_manager'
-require 'json'
+require 'sidekiq-scheduler/scheduler'
 
-module Sidekiq
-  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 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
-
-      # the Rufus::Scheduler jobs that are scheduled
-      def scheduled_jobs
-        @@scheduled_jobs
-      end
-
-      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
-
-      # 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?
-
-
-          @@scheduled_jobs = {}
-          queues = sidekiq_queues
-
-          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
-
-          logger.info 'Schedules Loaded'
-        else
-          logger.info 'SidekiqScheduler is disabled'
-        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)
-
-              rufus_job = new_job(name, interval_type, config, schedule, options)
-              @@scheduled_jobs[name] = rufus_job
-              update_job_next_time(name, rufus_job.next_time)
-
-              interval_defined = true
-
-              break
-            end
-          end
-
-          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, time) }
-
-          remove_elder_job_instances(job_name)
-        else
-          logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
-        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 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 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
-
-      def handle_errors
-        begin
-          yield
-        rescue StandardError => e
-          logger.info "#{e.class.name}: #{e.message}"
-        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)
-
-        if config.delete('include_metadata')
-          config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
-        end
-
-        if active_job_enqueue?(config['class'])
-          enqueue_with_active_job(config)
-        else
-          enqueue_with_sidekiq(config)
-        end
-      end
-
-      def rufus_scheduler_options
-        @rufus_scheduler_options ||= {}
-      end
-
-      def rufus_scheduler_options=(options)
-        @rufus_scheduler_options = options
-      end
-
-      def rufus_scheduler
-        @rufus_scheduler ||= new_rufus_scheduler
-      end
-
-      # 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
-
-      def reload_schedule!
-        if enabled
-          logger.info 'Reloading Schedule'
-          clear_schedule!
-          load_schedule!
-        else
-          logger.info 'SidekiqScheduler is disabled'
-        end
-      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)
-
-        if schedule_changes.size > 0
-          logger.info 'Updating schedule'
-          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
-      end
-
-      def unschedule_job(name)
-        if scheduled_jobs[name]
-          logger.debug "Removing schedule #{name}"
-          scheduled_jobs[name].unschedule
-          scheduled_jobs.delete(name)
-        end
-      end
-
-      def enqueue_with_active_job(config)
-        options = {
-          queue: config['queue']
-        }.keep_if { |_, v| !v.nil? }
-
-        initialize_active_job(config['class'], config['args']).enqueue(options)
-      end
-
-      def enqueue_with_sidekiq(config)
-        Sidekiq::Client.push(sanitize_job_config(config))
-      end
-
-      def initialize_active_job(klass, args)
-        if args.is_a?(Array)
-          klass.new(*args)
-        else
-          klass.new(args)
-        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 active_job_enqueue?(klass)
-        klass.is_a?(Class) && defined?(ActiveJob::Enqueuing) &&
-          klass.included_modules.include?(ActiveJob::Enqueuing)
-      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
-
-        config
-      end
-
-      def try_to_constantize(klass)
-        klass.is_a?(String) ? klass.constantize : klass
-      rescue NameError
-        klass
-      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
-
-      # 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)
-      end
-
-      def remove_elder_job_instances(job_name)
-        SidekiqScheduler::RedisManager.remove_elder_job_instances(job_name)
-      end
-
-      def job_enabled?(name)
-        job = Sidekiq.schedule[name]
-        schedule_state(name).fetch('enabled', job.fetch('enabled', true)) if job
-      end
-
-      def toggle_job_enabled(name)
-        state = schedule_state(name)
-        state['enabled'] = !job_enabled?(name)
-        set_schedule_state(name, state)
-      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_last_time(job.tags[0], triggered_time)
-            Sidekiq::Scheduler.update_job_next_time(job.tags[0], job.next_time)
-          end
-        end
-      end
-
-      def new_job(name, interval_type, config, schedule, options)
-        options = options.merge({ :job => true, :tags => [name] })
-
-        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
-
-      def sanitize_job_config(config)
-        config.reject { |k, _| RUFUS_METADATA_KEYS.include?(k) }
-      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)
-
-        state ? JSON.parse(state) : {}
-      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
-
-      # 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 sidekiq_queues
-        Sidekiq.options[:queues].map(&:to_s)
-      end
-    end
-  end
-end
+Sidekiq::Scheduler = SidekiqScheduler::Scheduler

data/web/locales/nl.yml

@@ -0,0 +1,14 @@
+nl:
+  recurring_jobs: Herhalende taken
+  name: Naam
+  description: Beschrijving
+  interval: Interval
+  class: Klasse
+  queue: Wachtrij
+  arguments: Argumenten
+  enqueue_now: Nu toevoegen
+  last_time: Laatste keer
+  next_time: Volgende keer
+  no_next_time: Geen volgende keer voor deze taak
+  disable: Uitzetten
+  enable: Aanzetten

data/web/locales/ru.yml

@@ -0,0 +1,14 @@
+ru:
+  recurring_jobs: Расписание задач
+  name: Название
+  description: Описание
+  interval: Интервал
+  class: Класс
+  queue: Очередь
+  arguments: Аргументы
+  enqueue_now: Поставить в очередь
+  last_time: Время последнего выполнения
+  next_time: Время следующего выполнения
+  no_next_time: выполнение задачи не запланировано
+  disable: Выключить
+  enable: Включить

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-scheduler
 version: !ruby/object:Gem::Version
-  version: 2.1.10
+  version: 2.2.1
 platform: ruby
 authors:
 - Morton Jonuschat
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-06 00:00:00.000000000 Z
+date: 2018-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -228,7 +228,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Light weight job scheduling extension for Sidekiq that adds support for
-  queueinga jobs in a recurring way.
+  queueing jobs in a recurring way.
 email:
 - sidekiq-scheduler@moove-it.com
 executables: []
@@ -239,11 +239,14 @@ files:
 - README.md
 - Rakefile
 - lib/sidekiq-scheduler.rb
+- lib/sidekiq-scheduler/extensions/schedule.rb
+- lib/sidekiq-scheduler/extensions/web.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/scheduler.rb
 - lib/sidekiq-scheduler/utils.rb
 - lib/sidekiq-scheduler/version.rb
 - lib/sidekiq-scheduler/web.rb
@@ -254,6 +257,8 @@ files:
 - web/locales/es.yml
 - web/locales/fr.yml
 - web/locales/it.yml
+- web/locales/nl.yml
+- web/locales/ru.yml
 - web/locales/sv.yml
 - web/locales/zh-cn.yml
 - web/views/recurring_jobs.erb