sidekiq-cron 2.1.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d5f570d2d2d72cdb4fc1a2458dc6cae7abfa5a0da1f27915310b5d5dc835e89
-  data.tar.gz: 514d74f88c65af3db1956190ca9092d4f1a95d6bce4b0a9191463e2bb0f9181a
+  metadata.gz: 24a9263df38117d217eaff38d09f5cc69029d2998a3cc07fd5f21878b340305c
+  data.tar.gz: 9cf118cc907fd84abdc0c0123fb23d6745b9fee021557560e35c55f9ff99fd35
 SHA512:
-  metadata.gz: 61f4af041526789dcf51264baa88a5e1855fa124a0fe9f2c5ed04eec36bd4b617aae1152890ab281d5938914725ba9cce812f70bc258a6e4b8d82b642882212a
-  data.tar.gz: 9e82488bd6459b3ce373e52c94fc3607631b5fc67fa58e578d190368a09f4edc3b4502318646d5285e9fb9d139a080d90d560b28ad31a56e9d01d81d1dc0a2f8
+  metadata.gz: 238cd9ccbf1f621090eca667e9e1b4c198589897869c7e8d89746886297bac0456dcd0452aa91f0e5e07af5e4e686d93f140089a44cd676cdf1711c45ced4e40
+  data.tar.gz: 404d91026a551fefd3e2a4c37bae8220e522b9a38a377cbbdc2f692331926495835feb2a4decf8dfe4a059e84ff6c45fc99e6c96c0f6156d53130586bf70b1bb

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to this project will be documented in this file.
 
+## 2.4.0
+
+- Fix reflected XSS on Sidekiq-UI (https://github.com/sidekiq-cron/sidekiq-cron/pull/568)
+- Add `cron_process_count_override` config option (https://github.com/sidekiq-cron/sidekiq-cron/pull/572)
+- Fix Spanish translation for enabled/disabled states (https://github.com/sidekiq-cron/sidekiq-cron/pull/575)
+- Allow to conditionally disable Sidekiq-Cron (https://github.com/sidekiq-cron/sidekiq-cron/pull/574)
+
+## 2.3.1
+
+- Fix manually launch enqueue job not working from web UI (https://github.com/sidekiq-cron/sidekiq-cron/pull/564)
+
+## 2.3.0
+
+- **WARNING** The default value for `available_namespaces` has changed from `nil` to `[default_namespace]`. Please refer to the [migration guide](https://github.com/sidekiq-cron/sidekiq-cron/blob/master/README.md#migrating-to-23) for further details (https://github.com/sidekiq-cron/sidekiq-cron/pull/552)
+- Fix deprecation warning for using raw params in WEB extension (https://github.com/sidekiq-cron/sidekiq-cron/pull/547)
+- Allow for sidekiq embedded configuration (https://github.com/sidekiq-cron/sidekiq-cron/pull/549)
+- Load schedule file within sidekiq callback (https://github.com/sidekiq-cron/sidekiq-cron/pull/550)
+- Fix missing default namespace if namespaces are explicitly provided (https://github.com/sidekiq-cron/sidekiq-cron/pull/551)
+
+## 2.2.0
+
+- Add support for Sidekiq v8 (https://github.com/sidekiq-cron/sidekiq-cron/pull/531, https://github.com/sidekiq-cron/sidekiq-cron/pull/538)
+- Always show parsed cron expression in web UI (https://github.com/sidekiq-cron/sidekiq-cron/pull/535)
+- Add fallback to .yaml extension (https://github.com/sidekiq-cron/sidekiq-cron/pull/534)
+- Refactor constantize helper to use Object.const_get (https://github.com/sidekiq-cron/sidekiq-cron/pull/541)
+- Allow testing of schedule by library consumers (https://github.com/sidekiq-cron/sidekiq-cron/pull/543)
+
 ## 2.1.0
 
 - Add `available_namespaces` configuration option (https://github.com/sidekiq-cron/sidekiq-cron/pull/524)

data/Gemfile

@@ -5,5 +5,5 @@ gemspec
 # To test different Sidekiq versions
 gem "sidekiq", ENV.fetch("SIDEKIQ_VERSION", ">= 6")
 
-# To test different Active Job versions
-gem "activejob", ENV.fetch("ACTIVE_JOB_VERSION", "~> 7")
+# To test different Rails versions
+gem "rails", ENV.fetch("RAILS_VERSION", "~> 7")

data/README.md

@@ -56,7 +56,7 @@ gem "sidekiq-cron"
   'active_job' => true,  # enqueue job through Active Job interface
   'queue_name_prefix' => 'prefix', # Active Job queue with prefix
   'queue_name_delimiter' => '.', # Active Job queue with custom delimiter (default: '_')
-  'description' => 'A sentence describing what work this job performs'
+  'description' => 'A sentence describing what work this job performs',
   'status' => 'disabled' # default: enabled
 }
 ```
@@ -69,13 +69,14 @@ All configuration options:
 
 ```ruby
 Sidekiq::Cron.configure do |config|
+  config.enabled = false # Default is true
   config.cron_poll_interval = 10 # Default is 30
   config.cron_schedule_file = 'config/my_schedule.yml' # Default is 'config/schedule.yml'
   config.cron_history_size = 20 # Default is 10
   config.default_namespace = 'statistics' # Default is 'default'
+  config.available_namespaces = %w[statistics maintenance billing] # Default is `[config.default_namespace]`
   config.natural_cron_parsing_mode = :strict # Default is :single
   config.reschedule_grace_period = 300 # Default is 60
-  config.available_namespaces = %w[maintenance billing] # Default is `nil`
 end
 ```
 
@@ -163,7 +164,7 @@ In the case you'd like to change this value, you can change it via the following
 
 ```ruby
 Sidekiq::Cron.configure do |config|
-  config.default_namespace = 'statics'
+  config.default_namespace = 'statistics'
 end
 ```
 
@@ -179,11 +180,21 @@ Sidekiq::Cron::Job.all('YOUR_OLD_NAMESPACE_NAME').each { |job| job.destroy }
 
 #### Available namespaces
 
-By default, Sidekiq Cron retrieves all existing jobs from Redis to determine the namespaces your application uses. However, this approach may not be suitable for large Redis installations. To address this, you can explicitly specify the list of available namespaces using the `available_namespaces` configuration option.
+By default, Sidekiq Cron uses the available_namespaces configuration option to determine which namespaces your application utilizes. The default namespace (`"default"`, by default) is always included in the list of available namespaces.
 
-If `available_namespaces` is set and a job is created with an unexpected namespace, a warning will be printed, and the job will be assigned to the default namespace.
+If you want Sidekiq Cron to automatically detect existing namespaces from the Redis database, you can set `available_namespaces` to the special option `:auto`.
 
-For more details and discussion, see [this issue](https://github.com/sidekiq-cron/sidekiq-cron/issues/516).
+If available_namespaces is explicitly set and a job is created with an unexpected namespace, a warning will be printed, and the job will be assigned to the default namespace.
+
+#### Migrating to 2.3
+
+As discussed in [this issue](https://github.com/sidekiq-cron/sidekiq-cron/issues/516), the approach introduced in Sidekiq Cron 2.0 for determining available namespaces using the `KEYS` command is not acceptable. Therefore, starting from version 2.3, namespacing has been reworked:
+
+- If you were not using the namespacing feature, no action is required. You can even remove `available_namespaces = %w[default]`, as it is now the default.
+
+- If you were using the namespacing feature and explicitly specified available namespaces as a list, no changes are needed.
+
+- If you were using the namespacing feature and relied on automatic namespace inference, you should either specify all used namespaces explicitly or set `available_namespaces` to `:auto` to maintain automatic detection. However, note that this approach does not scale well (see the referenced issue for details).
 
 #### Usage
 
@@ -511,6 +522,61 @@ Sidekiq::Cron.configure do |config|
 end
 ```
 
+You can also disable the entire engine by setting `enabled` to `false`. When disabled, Sidekiq-Cron will skip loading the schedule file on startup, which is useful for environments or specific Sidekiq processes where you don't need cron job scheduling at all:
+
+```ruby
+Sidekiq::Cron.configure do |config|
+  config.enabled = false
+end
+```
+
+Sidekiq will internally determine the process count by checking Redis but if polling has been disabled from some Sidekiq processes by setting the cron poll interval to zero, as explained above, that count might be incorrect. In that case, it is possible to override the default process count for Sidekiq Cron. This affects the way the random poll interval is calculated internally.
+
+```ruby
+Sidekiq::Cron.configure do |config|
+  config.cron_poll_process_count = 2
+end
+```
+
+## Testing your configuration
+
+You can test your application's configuration by loading the schedule in your test suite. Below is an example using RSpec in a Rails project:
+
+```ruby
+# spec/cron_schedule_spec.rb
+require "rails_helper"
+
+RSpec.describe "Cron Schedule" do
+  let(:schedule_loader) { Sidekiq::Cron::ScheduleLoader.new }
+  let(:all_jobs) { Sidekiq::Cron::Job.all }
+
+  # Confirms that `config.cron_schedule_file` points to a real file.
+  it "has a schedule file" do
+    expect(schedule_loader).to have_schedule_file
+  end
+
+  # Confirms that no jobs in the schedule have an invalid cron string.
+  it "does not return any errors" do
+    expect(schedule_loader.load_schedule).to be_empty
+  end
+
+  # May be subject to churn, but adds confidence.
+  it "adds the expected number of jobs" do
+    schedule_loader.load_schedule
+    expect(all_jobs.size).to eq 5
+  end
+
+  # Confirms that all job classes exist.
+  it "has a valid class for each added job" do
+    schedule_loader.load_schedule
+    # Shows that all classes exist (as we can constantize the names without raising).
+    job_classes = all_jobs.map { |job| job.klass.constantize }
+    # Naive check that classes are sidekiq jobs (as they all have `.perfrom_async`).
+    expect(job_classes).to all(respond_to(:perform_async))
+  end
+end
+```
+
 ## Contributing
 
 **Thanks to all [contributors](https://github.com/sidekiq-cron/sidekiq-cron/graphs/contributors), you’re awesome and this wouldn’t be possible without you!**

data/lib/sidekiq/cron/job.rb

@@ -17,8 +17,8 @@ module Sidekiq
       # Use serialize/deserialize key of GlobalID.
       GLOBALID_KEY = "_sc_globalid"
 
-      attr_accessor :name, :namespace, :cron, :description, :klass, :args, :message
-      attr_reader   :last_enqueue_time, :fetch_missing_args, :source
+      attr_accessor :name, :namespace, :cron, :description, :klass, :message
+      attr_reader   :last_enqueue_time, :fetch_missing_args, :source, :args
 
       def initialize input_args = {}
         args = Hash[input_args.map{ |k, v| [k.to_s, v] }]
@@ -32,7 +32,7 @@ module Sidekiq
 
         default_namespace = Sidekiq::Cron.configuration.default_namespace
         @namespace = args["namespace"] || default_namespace
-        if Sidekiq::Cron::Namespace.available_namespaces_provided? && !Sidekiq::Cron::Namespace.all.include?(@namespace) && @namespace != default_namespace
+        if Sidekiq::Cron::Namespace.available_namespaces_provided? && !Sidekiq::Cron::Namespace.all.include?(@namespace)
           Sidekiq.logger.warn { "Cron Jobs - unexpected namespace #{@namespace} encountered. Assigning to default namespace." }
           @namespace = default_namespace
         end
@@ -132,12 +132,7 @@ module Sidekiq
       def enqueue! time = Time.now.utc
         @last_enqueue_time = time
 
-        klass_const =
-            begin
-              Sidekiq::Cron::Support.constantize(@klass.to_s)
-            rescue NameError
-              nil
-            end
+        klass_const = Sidekiq::Cron::Support.safe_constantize(@klass.to_s)
 
         jid =
           if klass_const
@@ -160,9 +155,10 @@ module Sidekiq
       end
 
       def is_active_job?(klass = nil)
-        @active_job || defined?(::ActiveJob::Base) && (klass || Sidekiq::Cron::Support.constantize(@klass.to_s)) < ::ActiveJob::Base
-      rescue NameError
-        false
+        @active_job || defined?(::ActiveJob::Base) && begin
+                                                        klass ||= Sidekiq::Cron::Support.safe_constantize(@klass.to_s)
+                                                        klass ? klass < ::ActiveJob::Base : false
+                                                      end
       end
 
       def date_as_argument?
@@ -383,7 +379,7 @@ module Sidekiq
 
       def human_cron
         Cronex::ExpressionDescriptor.new(cron).description
-      rescue => e
+      rescue
         cron
       end
 
@@ -600,6 +596,10 @@ module Sidekiq
         @args = parse_args(args)
       end
 
+      def cron_expression_string
+        parsed_cron.to_cron_s
+      end
+
       private
 
       def parsed_cron
@@ -693,7 +693,7 @@ module Sidekiq
       def self.job_keys_from_namespace(namespace = Sidekiq::Cron.configuration.default_namespace)
         Sidekiq.redis do |conn|
           if namespace == '*'
-            namespaces = Sidekiq::Cron.configuration.available_namespaces&.map { jobs_key(_1) } || conn.keys(jobs_key(namespace))
+            namespaces = Sidekiq::Cron::Namespace.all.map { jobs_key(_1) }
             namespaces.flat_map { |name| conn.smembers(name) }
           else
             conn.smembers(jobs_key(namespace))
@@ -800,11 +800,7 @@ module Sidekiq
       end
 
       def get_job_options(klass, args)
-        klass = klass.is_a?(Class) ? klass : begin
-          Sidekiq::Cron::Support.constantize(klass)
-        rescue NameError
-          # noop
-        end
+        klass = klass.is_a?(Class) ? klass : Sidekiq::Cron::Support.safe_constantize(klass)
 
         if klass.nil?
           # Unknown class

data/lib/sidekiq/cron/launcher.rb

@@ -13,6 +13,7 @@ module Sidekiq
       # Add cron poller and execute normal initialize of Sidekiq launcher.
       def initialize(config, **kwargs)
         config[:cron_poll_interval] = Sidekiq::Cron.configuration.cron_poll_interval.to_i
+        config[:cron_poll_process_count] = Sidekiq::Cron.configuration.cron_poll_process_count
 
         @cron_poller = Sidekiq::Cron::Poller.new(config) if config[:cron_poll_interval] > 0
         super

data/lib/sidekiq/cron/locales/es.yml

@@ -18,5 +18,5 @@ es:
   LastEnqueued: Último trabajo en cola
   NoCronJobsWereFound: No se encontraron trabajos
   NoHistoryWereFound: No se encontró histórico de trabajos
-  disabled: activo
-  enabled: inactivo
+  disabled: inactivo
+  enabled: activo

data/lib/sidekiq/cron/namespace.rb

@@ -2,25 +2,20 @@ module Sidekiq
   module Cron
     class Namespace
       def self.all
-        namespaces = Sidekiq::Cron.configuration.available_namespaces
-        return namespaces if namespaces
-
-        Sidekiq.redis do |conn|
-          namespaces = conn.keys('cron_jobs:*').collect do |key|
-            key.split(':').last
+        namespaces = case (available_namespaces = Sidekiq::Cron.configuration.available_namespaces)
+          when NilClass then []
+          when Array then available_namespaces
+          when :auto
+            Sidekiq.redis do |conn|
+              conn.keys('cron_jobs:*').collect do |key|
+                key.split(':').last
+              end
+            end
+          else
+            raise ArgumentError, "Unexpected value provided for `available_namespaces`: #{available_namespaces.inspect}"
           end
-        end
-
-        # Adds the default namespace if not present
-        has_default = namespaces.detect do |name|
-          name == Sidekiq::Cron.configuration.default_namespace
-        end
-
-        unless has_default
-          namespaces << Sidekiq::Cron.configuration.default_namespace
-        end
 
-        namespaces
+        namespaces | [Sidekiq::Cron.configuration.default_namespace]
       end
 
       def self.all_with_count
@@ -33,15 +28,15 @@ module Sidekiq
       end
 
       def self.count(name = Sidekiq::Cron.configuration.default_namespace)
-        out = 0
         Sidekiq.redis do |conn|
-          out = conn.scard("cron_jobs:#{name}")
+          conn.scard("cron_jobs:#{name}")
         end
-        out
       end
 
       def self.available_namespaces_provided?
-        !!Sidekiq::Cron.configuration.available_namespaces
+        available_namespaces = Sidekiq::Cron.configuration.available_namespaces
+
+        available_namespaces != nil && available_namespaces != :auto
       end
     end
   end

data/lib/sidekiq/cron/poller.rb

@@ -43,6 +43,10 @@ module Sidekiq
       def poll_interval_average(process_count = 1)
         @config[:cron_poll_interval]
       end
+
+      def process_count
+        @config[:cron_poll_process_count] || super
+      end
     end
   end
 end

data/lib/sidekiq/cron/schedule_loader.rb

@@ -1,16 +1,62 @@
-Sidekiq.configure_server do |config|
-  schedule_file = Sidekiq::Cron.configuration.cron_schedule_file
-
-  if File.exist?(schedule_file)
-    config.on(:startup) do
-      schedule = Sidekiq::Cron::Support.load_yaml(ERB.new(IO.read(schedule_file)).result)
-      if schedule.kind_of?(Hash)
-        Sidekiq::Cron::Job.load_from_hash!(schedule, source: "schedule")
-      elsif schedule.kind_of?(Array)
-        Sidekiq::Cron::Job.load_from_array!(schedule, source: "schedule")
-      else
-        raise "Not supported schedule format. Confirm your #{schedule_file}"
+module Sidekiq
+  module Cron
+    class ScheduleLoader
+      def load_schedule
+        if schedule.is_a?(Hash)
+          Sidekiq::Cron::Job.load_from_hash!(schedule, source: "schedule")
+        elsif schedule.is_a?(Array)
+          Sidekiq::Cron::Job.load_from_array!(schedule, source: "schedule")
+        else
+          raise "Not supported schedule format. Confirm your #{schedule_file_name}"
+        end
+      end
+
+      def has_schedule_file?
+        File.exist?(schedule_file_name)
+      end
+
+      private
+
+      def schedule
+        @schedule ||= Sidekiq::Cron::Support.load_yaml(rendered_schedule_template)
+      end
+
+      def rendered_schedule_template
+        ERB.new(schedule_file_content).result
+      end
+
+      def schedule_file_content
+        IO.read(schedule_file_name)
+      end
+
+      def schedule_file_name
+        @schedule_file_name ||= yml_to_yaml_unless_file_exists(schedule_file_name_from_config)
+      end
+
+      def schedule_file_name_from_config
+        Sidekiq::Cron.configuration.cron_schedule_file
+      end
+
+      def yml_to_yaml_unless_file_exists(file_name)
+        if File.exist?(file_name)
+          file_name
+        else
+          file_name.sub(/\.yml$/, ".yaml")
+        end
       end
     end
   end
 end
+
+Sidekiq.configure_server do |config|
+  config.on(:startup) do
+    unless Sidekiq::Cron.configuration.enabled
+      Sidekiq.logger.info { "Cron Jobs - skipping schedule loading, Sidekiq-Cron is disabled" }
+      next
+    end
+
+    schedule_loader = Sidekiq::Cron::ScheduleLoader.new
+    next unless schedule_loader.has_schedule_file?
+    schedule_loader.load_schedule
+  end
+end

data/lib/sidekiq/cron/support.rb

@@ -1,35 +1,10 @@
 module Sidekiq
   module Cron
     module Support
-      # Inspired by Active Support Inflector
-      def self.constantize(camel_cased_word)
-        names = camel_cased_word.split("::".freeze)
-
-        # Trigger a built-in NameError exception including the ill-formed constant in the message.
-        Object.const_get(camel_cased_word) if names.empty?
-
-        # Remove the first blank element in case of '::ClassName' notation.
-        names.shift if names.size > 1 && names.first.empty?
-
-        names.inject(Object) do |constant, name|
-          if constant == Object
-            constant.const_get(name)
-          else
-            candidate = constant.const_get(name)
-            next candidate if constant.const_defined?(name, false)
-            next candidate unless Object.const_defined?(name)
-
-            # Go down the ancestors to check if it is owned directly. The check
-            # stops when we reach Object or the end of ancestors tree.
-            constant = constant.ancestors.inject(constant) do |const, ancestor|
-              break const    if ancestor == Object
-              break ancestor if ancestor.const_defined?(name, false)
-              const
-            end
-
-            constant.const_get(name, false)
-          end
-        end
+      def self.safe_constantize(klass_name)
+        Object.const_get(klass_name)
+      rescue NameError
+        nil
       end
 
       def self.load_yaml(src)

data/lib/sidekiq/cron/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module Cron
-    VERSION = "2.1.0"
+    VERSION = "2.4.0"
   end
 end