sidekiq-cron 1.12.0 → 2.0.0.rc1

data/lib/sidekiq/cron/job.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'fugit'
+require 'cronex'
 require 'globalid'
 require 'sidekiq'
 require 'sidekiq/cron/support'
@@ -7,7 +10,7 @@ require 'sidekiq/options'
 module Sidekiq
   module Cron
     class Job
-      # How long we would like to store informations about previous enqueues.
+      # How long we would like to store information about previous enqueues.
       REMEMBER_THRESHOLD = 24 * 60 * 60
 
       # Time format for enqueued jobs.
@@ -19,11 +22,80 @@ 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
+
+      def initialize input_args = {}
+        args = Hash[input_args.map{ |k, v| [k.to_s, v] }]
+        @fetch_missing_args = args.delete('fetch_missing_args')
+        @fetch_missing_args = true if @fetch_missing_args.nil?
+
+        @name = args["name"]
+        @namespace = args["namespace"] || Sidekiq::Cron.configuration.default_namespace
+        @cron = args["cron"]
+        @description = args["description"] if args["description"]
+        @source = args["source"] == "schedule" ? "schedule" : "dynamic"
+
+        # Get class from klass or class.
+        @klass = args["klass"] || args["class"]
+
+        # Set status of job.
+        @status = args['status'] || status_from_redis
+
+        # Set last enqueue time - from args or from existing job.
+        if args['last_enqueue_time'] && !args['last_enqueue_time'].empty?
+          @last_enqueue_time = parse_enqueue_time(args['last_enqueue_time'])
+        else
+          @last_enqueue_time = last_enqueue_time_from_redis
+        end
+
+        # Get right arguments for job.
+        @symbolize_args = args["symbolize_args"] == true || ("#{args["symbolize_args"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
+        @args = parse_args(args["args"])
+
+        @date_as_argument = args["date_as_argument"] == true || ("#{args["date_as_argument"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
+
+        @active_job = args["active_job"] == true || ("#{args["active_job"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
+        @active_job_queue_name_prefix = args["queue_name_prefix"]
+        @active_job_queue_name_delimiter = args["queue_name_delimiter"]
+
+        # symbolize_args is only used when active_job is true
+        Sidekiq.logger.warn { "Cron Jobs - 'symbolize_args' is gonna be ignored, as it is only used when 'active_job' is true" } if @symbolize_args && !@active_job
+
+        if args["message"]
+          @message = args["message"]
+          message_data = Sidekiq.load_json(@message) || {}
+          @queue = message_data['queue'] || "default"
+        elsif @klass
+          message_data = {
+            "class" => @klass.to_s,
+            "args"  => @args,
+          }
+
+          # Get right data for message,
+          # only if message wasn't specified before.
+          klass_data = get_job_class_options(@klass)
+          message_data = klass_data.merge(message_data)
+
+          # Override queue if set in config,
+          # only if message is hash - can be string (dumped JSON).
+          if args['queue']
+            @queue = message_data['queue'] = args['queue']
+          else
+            @queue = message_data['queue'] || "default"
+          end
+
+          @message = message_data
+        end
+
+        @queue_name_with_prefix = queue_name_with_prefix
+      end
+
       # Crucial part of whole enqueuing job.
       def should_enque? time
         return false unless status == "enabled"
-        return false unless not_past_scheduled_time?(time)
-        return false unless not_enqueued_after?(time)
+        return false if past_scheduled_time?(time)
+        return false if enqueued_after?(time)
 
         enqueue = Sidekiq.redis do |conn|
           conn.zadd(job_enqueued_key, formatted_enqueue_time(time), formatted_last_time(time))
@@ -152,6 +224,7 @@ module Sidekiq
       # Input structure should look like:
       # {
       #   'name_of_job' => {
+      #     'namespace'   => 'MyNamespace',
       #     'class'       => 'MyClass',
       #     'cron'        => '1 * * * *',
       #     'args'        => '(OPTIONAL) [Array or Hash]',
@@ -182,6 +255,7 @@ module Sidekiq
       # Input structure should look like:
       # [
       #   {
+      #     'namespace'   => 'MyNamespace',
       #     'name'        => 'name_of_job',
       #     'class'       => 'MyClass',
       #     'cron'        => '1 * * * *',
@@ -207,19 +281,20 @@ module Sidekiq
       # Like #load_from_array.
       # If exists old jobs in Redis but removed from args, destroy old jobs.
       def self.load_from_array!(array, options = {})
-        job_names = array.map { |job| job["name"] }
+        job_names = array.map { |job| job["name"] || job[:name] }
         destroy_removed_jobs(job_names)
         load_from_array(array, options)
       end
 
       # Get all cron jobs.
-      def self.all
+      def self.all(namespace = Sidekiq::Cron.configuration.default_namespace)
         job_hashes = nil
         Sidekiq.redis do |conn|
-          set_members = conn.smembers(jobs_key)
+          job_keys = job_keys_from_namespace(namespace)
+
           job_hashes = conn.pipelined do |pipeline|
-            set_members.each do |key|
-              pipeline.hgetall(key)
+            job_keys.each do |job_key|
+              pipeline.hgetall(job_key)
             end
           end
         end
@@ -229,22 +304,26 @@ module Sidekiq
         end
       end
 
-      def self.count
-        out = 0
-        Sidekiq.redis do |conn|
-          out = conn.scard(jobs_key)
+      def self.count(namespace = Sidekiq::Cron.configuration.default_namespace)
+        if namespace == '*'
+          Namespace.all_with_count.reduce(0) do |memo, namespace_count|
+            memo + namespace_count[:count]
+          end
+        else
+          Sidekiq.redis { |conn| conn.scard(jobs_key(namespace)) }
         end
-        out
       end
 
-      def self.find name
+      def self.find(name, namespace = Sidekiq::Cron.configuration.default_namespace)
         # If name is hash try to get name from it.
         name = name[:name] || name['name'] if name.is_a?(Hash)
-        return unless exists? name
+        return unless exists? name, namespace
 
         output = nil
         Sidekiq.redis do |conn|
-          output = Job.new conn.hgetall( redis_key(name) )
+          if exists? name, namespace
+            output = Job.new conn.hgetall(redis_key(name, namespace))
+          end
         end
         output if output && output.valid?
       end
@@ -255,93 +334,17 @@ module Sidekiq
       end
 
       # Destroy job by name.
-      def self.destroy name
+      def self.destroy(name, namespace = Sidekiq::Cron.configuration.default_namespace)
         # If name is hash try to get name from it.
         name = name[:name] || name['name'] if name.is_a?(Hash)
 
-        if job = find(name)
+        if (job = find(name, namespace))
           job.destroy
         else
           false
         end
       end
 
-      attr_accessor :name, :cron, :description, :klass, :args, :message
-      attr_reader   :last_enqueue_time, :fetch_missing_args, :source
-
-      def initialize input_args = {}
-        args = Hash[input_args.map{ |k, v| [k.to_s, v] }]
-        @fetch_missing_args = args.delete('fetch_missing_args')
-        @fetch_missing_args = true if @fetch_missing_args.nil?
-
-        @name = args["name"]
-        @cron = args["cron"]
-        @description = args["description"] if args["description"]
-        @source = args["source"] == "schedule" ? "schedule" : "dynamic"
-
-        # Get class from klass or class.
-        @klass = args["klass"] || args["class"]
-
-        # Set status of job.
-        @status = args['status'] || status_from_redis
-
-        # Set last enqueue time - from args or from existing job.
-        if args['last_enqueue_time'] && !args['last_enqueue_time'].empty?
-          @last_enqueue_time = parse_enqueue_time(args['last_enqueue_time'])
-        else
-          @last_enqueue_time = last_enqueue_time_from_redis
-        end
-
-        # Get right arguments for job.
-        @symbolize_args = args["symbolize_args"] == true || ("#{args["symbolize_args"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
-        @args = parse_args(args["args"])
-
-        @date_as_argument = args["date_as_argument"] == true || ("#{args["date_as_argument"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
-
-        @active_job = args["active_job"] == true || ("#{args["active_job"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
-        @active_job_queue_name_prefix = args["queue_name_prefix"]
-        @active_job_queue_name_delimiter = args["queue_name_delimiter"]
-
-        if args["message"]
-          @message = args["message"]
-          message_data = Sidekiq.load_json(@message) || {}
-          @queue = message_data['queue'] || "default"
-        elsif @klass
-          message_data = {
-            "class" => @klass.to_s,
-            "args"  => @args,
-          }
-
-          # Get right data for message,
-          # only if message wasn't specified before.
-          klass_data = case @klass
-            when Class
-              @klass.get_sidekiq_options
-            when String
-              begin
-                Sidekiq::Cron::Support.constantize(@klass).get_sidekiq_options
-              rescue Exception => e
-                # Unknown class
-                {"queue"=>"default"}
-              end
-          end
-
-          message_data = klass_data.merge(message_data)
-
-          # Override queue if setted in config,
-          # only if message is hash - can be string (dumped JSON).
-          if args['queue']
-            @queue = message_data['queue'] = args['queue']
-          else
-            @queue = message_data['queue'] || "default"
-          end
-
-          @message = message_data
-        end
-
-        @queue_name_with_prefix = queue_name_with_prefix
-      end
-
       def status
         @status
       end
@@ -370,6 +373,12 @@ module Sidekiq
         message
       end
 
+      def human_cron
+        Cronex::ExpressionDescriptor.new(cron).description
+      rescue => e
+        cron
+      end
+
       def status_from_redis
         out = "enabled"
         if fetch_missing_args
@@ -406,6 +415,7 @@ module Sidekiq
       def to_hash
         hash = {
           name: @name,
+          namespace: @namespace,
           klass: @klass.to_s,
           cron: @cron,
           description: @description,
@@ -436,11 +446,13 @@ module Sidekiq
         @errors = []
 
         errors << "'name' must be set" if @name.nil? || @name.size == 0
+        errors << "'namespace' must be set" if @namespace.nil? || @namespace.size == 0
+
         if @cron.nil? || @cron.size == 0
           errors << "'cron' must be set"
         else
           begin
-            @parsed_cron = Fugit.do_parse_cronish(@cron)
+            @parsed_cron = do_parse_cron(@cron)
           rescue => e
             errors << "'cron' -> #{@cron.inspect} -> #{e.class}: #{e.message}"
           end
@@ -466,19 +478,18 @@ module Sidekiq
         return false unless valid?
 
         Sidekiq.redis do |conn|
-
           # Add to set of all jobs
-          conn.sadd self.class.jobs_key, [redis_key]
+          conn.sadd self.class.jobs_key(@namespace), [redis_key]
 
-          # Add informations for this job!
-          conn.hset redis_key, to_hash.transform_values! { |v| v || "" }
+          # Add information for this job!
+          conn.hset redis_key, to_hash.transform_values! { |v| v || '' }
 
           # Add information about last time! - don't enque right after scheduler poller starts!
           time = Time.now.utc
           exists = conn.public_send(REDIS_EXISTS_METHOD, job_enqueued_key)
           conn.zadd(job_enqueued_key, time.to_f.to_s, formatted_last_time(time).to_s) unless exists == true || exists == 1
         end
-        Sidekiq.logger.info { "Cron Jobs - added job with name: #{@name}" }
+        Sidekiq.logger.info { "Cron Jobs - added job with name #{@name} in the namespace #{@namespace}" }
       end
 
       def save_last_enqueue_time
@@ -506,9 +517,9 @@ module Sidekiq
       def destroy
         Sidekiq.redis do |conn|
           # Delete from set.
-          conn.srem self.class.jobs_key, [redis_key]
+          conn.srem self.class.jobs_key(@namespace), [redis_key]
 
-          # Delete runned timestamps.
+          # Delete ran timestamps.
           conn.del job_enqueued_key
 
           # Delete jid_history.
@@ -518,7 +529,7 @@ module Sidekiq
           conn.del redis_key
         end
 
-        Sidekiq.logger.info { "Cron Jobs - deleted job with name: #{@name}" }
+        Sidekiq.logger.info { "Cron Jobs - deleted job with name #{@name} from namespace #{@namespace}" }
       end
 
       # Remove all job from cron.
@@ -531,9 +542,17 @@ module Sidekiq
 
       # Remove "removed jobs" between current jobs and new jobs
       def self.destroy_removed_jobs new_job_names
-        current_job_names = Sidekiq::Cron::Job.all.filter_map { |j| j.name if j.source == "schedule" }
+        current_jobs = Sidekiq::Cron::Job.all("*").filter_map { |j| j if j.source == "schedule" }
+        current_job_names = current_jobs.map(&:name)
         removed_job_names = current_job_names - new_job_names
-        removed_job_names.each { |j| Sidekiq::Cron::Job.destroy(j) }
+        removed_job_names.each do |j|
+          job_to_destroy = current_jobs.detect { |job| job.name == j }
+
+          Sidekiq::Cron::Job.destroy(
+            job_to_destroy.name,
+            job_to_destroy.namespace
+          )
+        end
         removed_job_names
       end
 
@@ -551,15 +570,16 @@ module Sidekiq
         last_time(now).getutc.iso8601
       end
 
-      def self.exists? name
+      def self.exists?(name, namespace = Sidekiq::Cron.configuration.default_namespace)
         out = Sidekiq.redis do |conn|
-          conn.public_send(REDIS_EXISTS_METHOD, redis_key(name))
+          conn.public_send(REDIS_EXISTS_METHOD, redis_key(name, namespace))
         end
-        out == true || out == 1
+
+        [true, 1].include?(out)
       end
 
       def exists?
-        self.class.exists? @name
+        self.class.exists? @name, @namespace
       end
 
       def sort_name
@@ -573,11 +593,25 @@ module Sidekiq
       private
 
       def parsed_cron
-        @parsed_cron ||= Fugit.parse_cronish(@cron)
+        @parsed_cron ||= do_parse_cron(@cron)
+      end
+
+      def do_parse_cron(cron)
+        case Sidekiq::Cron.configuration.natural_cron_parsing_mode
+        when :single
+          Fugit.do_parse_cronish(cron)
+        when :strict
+          Fugit.parse_cron(cron) || # Ex. '11 1 * * 1'
+          Fugit.parse_nat(cron, :multi => :fail) || # Ex. 'every Monday at 01:11'
+          fail(ArgumentError.new("invalid cron string #{cron.inspect}"))
+        else
+          mode = Sidekiq::Cron.configuration.natural_cron_parsing_mode
+          raise ArgumentError, "Unknown natural cron parsing mode: #{mode.inspect}"
+        end
       end
 
-      def not_enqueued_after?(time)
-        @last_enqueue_time.nil? || @last_enqueue_time.to_i < last_time(time).to_i
+      def enqueued_after?(time)
+        @last_enqueue_time && @last_enqueue_time.to_i >= last_time(time).to_i
       end
 
       # Try parsing inbound args into an array.
@@ -631,48 +665,83 @@ module Sidekiq
         DateTime.parse(timestamp).to_time.utc
       end
 
-      def not_past_scheduled_time?(current_time)
+      def past_scheduled_time?(current_time)
         last_cron_time = parsed_cron.previous_time(current_time).utc
-        return false if (current_time.to_i - last_cron_time.to_i) > 60
-        true
+        period = Sidekiq::Cron.configuration.reschedule_grace_period
+
+        current_time.to_i - last_cron_time.to_i > period
+      end
+
+      def self.default_if_blank(namespace)
+        if namespace.nil? || namespace == ''
+          Sidekiq::Cron.configuration.default_namespace
+        else
+          namespace
+        end
       end
 
-      # Redis key for set of all cron jobs.
-      def self.jobs_key
-        "cron_jobs"
+      def self.job_keys_from_namespace(namespace = Sidekiq::Cron.configuration.default_namespace)
+        Sidekiq.redis do |conn|
+          if namespace == '*'
+            namespaces = conn.keys(jobs_key(namespace))
+            namespaces.flat_map { |name| conn.smembers(name) }
+          else
+            conn.smembers(jobs_key(namespace))
+          end
+        end
       end
 
-      # Redis key for storing one cron job.
-      def self.redis_key name
-        "cron_job:#{name}"
+      def self.migrate_old_jobs_if_needed!
+        Sidekiq.redis do |conn|
+          old_job_keys = conn.smembers('cron_jobs')
+          old_job_keys.each do |old_job|
+            old_job_hash = conn.hgetall(old_job)
+            old_job_hash[:namespace] = Sidekiq::Cron.configuration.default_namespace
+            create(old_job_hash)
+            conn.srem('cron_jobs', old_job)
+          end
+        end
       end
 
-      # Redis key for storing one cron job.
+      # Redis key for set of all cron jobs
+      def self.jobs_key(namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_jobs:#{default_if_blank(namespace)}"
+      end
+
+      # Redis key for storing one cron job
+      def self.redis_key(name, namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_job:#{default_if_blank(namespace)}:#{name}"
+      end
+
+      # Redis key for storing one cron job
       def redis_key
-        self.class.redis_key @name
+        self.class.redis_key @name, @namespace
       end
 
-      # Redis key for storing one cron job run times (when poller added job to queue)
-      def self.job_enqueued_key name
-        "cron_job:#{name}:enqueued"
+      # Redis key for storing one cron job run times
+      # (when poller added job to queue)
+      def self.job_enqueued_key(name, namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_job:#{default_if_blank(namespace)}:#{name}:enqueued"
       end
 
-      def self.jid_history_key name
-        "cron_job:#{name}:jid_history"
+      def self.jid_history_key(name, namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_job:#{default_if_blank(namespace)}:#{name}:jid_history"
       end
 
+      # Redis key for storing one cron job run times
+      # (when poller added job to queue)
       def job_enqueued_key
-        self.class.job_enqueued_key @name
+        self.class.job_enqueued_key @name, @namespace
       end
 
       def jid_history_key
-        self.class.jid_history_key @name
+        self.class.jid_history_key @name, @namespace
       end
 
       def serialized_last_enqueue_time
         @last_enqueue_time&.strftime(LAST_ENQUEUE_TIME_FORMAT)
       end
-      
+
       def convert_to_global_id_hash(argument)
         { GLOBALID_KEY => argument.to_global_id.to_s }
       rescue URI::GID::MissingModelIdError
@@ -719,6 +788,23 @@ module Sidekiq
           argument
         end
       end
+
+      def get_job_class_options(klass)
+        klass = klass.is_a?(Class) ? klass : begin
+          Sidekiq::Cron::Support.constantize(klass)
+        rescue NameError
+          # noop
+        end
+
+        if klass.nil?
+          # Unknown class
+          {"queue"=>"default"}
+        elsif is_active_job?(klass)
+          {"queue"=>klass.queue_name}
+        else
+          klass.get_sidekiq_options
+        end
+      end
     end
   end
 end

data/lib/sidekiq/cron/launcher.rb

@@ -1,7 +1,7 @@
 require 'sidekiq/cron/poller'
 
 # For Cron we need to add some methods to Launcher
-# so look at the code bellow.
+# so look at the code below.
 #
 # We are creating new cron poller instance and
 # adding start and stop commands to launcher.

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

@@ -0,0 +1,22 @@
+id:
+  Job: Job
+  Cron: Cron
+  CronJobs: Cron Job
+  EnqueueNow: Tambahkan ke Antrian Sekarang
+  EnableAll: Aktifkan Semua
+  DisableAll: Nonaktifkan Semua
+  EnqueueAll: Tambahkan Semua ke Antrian
+  DeleteAll: Hapus Semua
+  'Cron string': Cron string
+  AreYouSureEnqueueCronJobs: Apakah Anda yakin ingin menambahkan SEMUA cron job ke antrian?
+  AreYouSureEnqueueCronJob: Apakah Anda yakin ingin menambahkan cron job %{job} ke antrian?
+  AreYouSureDeleteCronJobs: Apakah Anda yakin ingin menghapus SEMUA cron job?
+  AreYouSureDeleteCronJob: Apakah Anda yakin ingin menghapus cron job %{job}?
+  NoCronJobsWereFound: Tidak ada cron job
+  Enable: Aktifkan
+  Disable: Nonaktifkan
+  'Last enqueued': Terakhir kali ditambahkan ke antrian
+  disabled: dinonaktifkan
+  enabled: diaktifkan
+  NoHistoryWereFound: Tidak ada riwayat
+  Description: Deskripsi

data/lib/sidekiq/cron/namespace.rb

@@ -0,0 +1,45 @@
+require 'sidekiq'
+
+module Sidekiq
+  module Cron
+    class Namespace
+      def self.all
+        namespaces = nil
+
+        Sidekiq.redis do |conn|
+          namespaces = conn.keys('cron_jobs:*').collect do |key|
+            key.split(':').last
+          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
+      end
+
+      def self.all_with_count
+        all.map do |namespace_name|
+          {
+            count: count(namespace_name),
+            name: namespace_name
+          }
+        end
+      end
+
+      def self.count(name = Sidekiq::Cron.configuration.default_namespace)
+        out = 0
+        Sidekiq.redis do |conn|
+          out = conn.scard("cron_jobs:#{name}")
+        end
+        out
+      end
+    end
+  end
+end

data/lib/sidekiq/cron/poller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sidekiq'
 require 'sidekiq/cron'
 require 'sidekiq/scheduled'
@@ -5,21 +7,26 @@ require 'sidekiq/options'
 
 module Sidekiq
   module Cron
-    # The Poller checks Redis every N seconds for sheduled cron jobs.
+    # The Poller checks Redis every N seconds for scheduled cron jobs.
     class Poller < Sidekiq::Scheduled::Poller
       def initialize(config = nil)
-        if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
-          super
-        else
+        if Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('6.5.0')
           # Old version of Sidekiq does not accept a config argument.
           @config = config
-          super()
         end
+
+        super
+      end
+
+      def start
+        Sidekiq::Cron::Job.migrate_old_jobs_if_needed!
+
+        super
       end
 
       def enqueue
         time = Time.now.utc
-        Sidekiq::Cron::Job.all.each do |job|
+        Sidekiq::Cron::Job.all('*').each do |job|
           enqueue_job(job, time)
         end
       rescue => ex

data/lib/sidekiq/cron/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module Cron
-    VERSION = "1.12.0"
+    VERSION = "2.0.0.rc1"
   end
 end