sidekiq-cron 1.5.1 → 1.12.0

data/lib/sidekiq/cron/job.rb

@@ -1,41 +1,46 @@
 require 'fugit'
+require 'globalid'
 require 'sidekiq'
 require 'sidekiq/cron/support'
+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 informations about previous enqueues.
       REMEMBER_THRESHOLD = 24 * 60 * 60
+
+      # Time format for enqueued jobs.
       LAST_ENQUEUE_TIME_FORMAT = '%Y-%m-%d %H:%M:%S %z'
 
-      # Use the exists? method if we're on a newer version of redis.
-      REDIS_EXISTS_METHOD = Gem.loaded_specs['redis'].version < Gem::Version.new('4.2') ? :exists : :exists?
+      # Use the exists? method if we're on a newer version of Redis.
+      REDIS_EXISTS_METHOD = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new("7.0.0") || Gem.loaded_specs['redis'].version < Gem::Version.new('4.2') ? :exists : :exists?
+
+      # Use serialize/deserialize key of GlobalID.
+      GLOBALID_KEY = "_sc_globalid"
 
-      #crucial part of whole enquing job
+      # Crucial part of whole enqueuing job.
       def should_enque? time
-        enqueue = false
+        return false unless status == "enabled"
+        return false unless not_past_scheduled_time?(time)
+        return false unless not_enqueued_after?(time)
+
         enqueue = Sidekiq.redis do |conn|
-          status == "enabled" &&
-            not_past_scheduled_time?(time) &&
-            not_enqueued_after?(time) &&
-            conn.zadd(job_enqueued_key, formated_enqueue_time(time), formated_last_time(time))
+          conn.zadd(job_enqueued_key, formatted_enqueue_time(time), formatted_last_time(time))
         end
-        enqueue
+        enqueue == true || enqueue == 1
       end
 
-      # remove previous informations about run times
-      # this will clear redis and make sure that redis will
-      # not overflow with memory
+      # Remove previous information about run times,
+      # this will clear Redis and make sure that Redis will not overflow with memory.
       def remove_previous_enques time
         Sidekiq.redis do |conn|
           conn.zremrangebyscore(job_enqueued_key, 0, "(#{(time.to_f - REMEMBER_THRESHOLD).to_s}")
         end
       end
 
-      #test if job should be enqued If yes add it to queue
+      # Test if job should be enqueued.
       def test_and_enque_for_time! time
-        #should this job be enqued?
         if should_enque?(time)
           enque!
 
@@ -43,9 +48,9 @@ module Sidekiq
         end
       end
 
-      #enque cron job to queue
+      # Enqueue cron job to queue.
       def enque! time = Time.now.utc
-        @last_enqueue_time = time.strftime(LAST_ENQUEUE_TIME_FORMAT)
+        @last_enqueue_time = time
 
         klass_const =
             begin
@@ -56,7 +61,7 @@ module Sidekiq
 
         jid =
           if klass_const
-            if defined?(ActiveJob::Base) && klass_const < ActiveJob::Base
+            if is_active_job?(klass_const)
               enqueue_active_job(klass_const).try :provider_job_id
             else
               enqueue_sidekiq_worker(klass_const)
@@ -74,23 +79,34 @@ module Sidekiq
         Sidekiq.logger.debug { "enqueued #{@name}: #{@message}" }
       end
 
-      def is_active_job?
-        @active_job || defined?(ActiveJob::Base) && Sidekiq::Cron::Support.constantize(@klass.to_s) < ActiveJob::Base
+      def is_active_job?(klass = nil)
+        @active_job || defined?(ActiveJob::Base) && (klass || Sidekiq::Cron::Support.constantize(@klass.to_s)) < ActiveJob::Base
       rescue NameError
         false
       end
 
+      def date_as_argument?
+        !!@date_as_argument
+      end
+
+      def enqueue_args
+        args = date_as_argument? ? @args + [Time.now.to_f] : @args
+        deserialize_argument(args)
+      end
+
       def enqueue_active_job(klass_const)
-        klass_const.set(queue: @queue).perform_later(*@args)
+        klass_const.set(queue: @queue).perform_later(*enqueue_args)
       end
 
       def enqueue_sidekiq_worker(klass_const)
-        klass_const.set(queue: queue_name_with_prefix).perform_async(*@args)
+        klass_const.set(queue: queue_name_with_prefix).perform_async(*enqueue_args)
       end
 
-      # siodekiq worker message
+      # Sidekiq worker message.
       def sidekiq_worker_message
-        @message.is_a?(String) ? Sidekiq.load_json(@message) : @message
+        message = @message.is_a?(String) ? Sidekiq.load_json(@message) : @message
+        message["args"] = enqueue_args
+        message
       end
 
       def queue_name_with_prefix
@@ -115,8 +131,8 @@ module Sidekiq
         queue_name
       end
 
-      # active job has different structure how it is loading data from sidekiq
-      # queue, it createaswrapper arround job
+      # Active Job has different structure how it is loading data from Sidekiq
+      # queue, it creates a wrapper around job.
       def active_job_message
         {
           'class'        => 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper',
@@ -127,13 +143,13 @@ module Sidekiq
             'job_class'  => @klass,
             'job_id'     => SecureRandom.uuid,
             'queue_name' => @queue_name_with_prefix,
-            'arguments'  => @args
+            'arguments'  => enqueue_args
           }]
         }
       end
 
-      # load cron jobs from Hash
-      # input structure should look like:
+      # Load cron jobs from Hash.
+      # Input structure should look like:
       # {
       #   'name_of_job' => {
       #     'class'       => 'MyClass',
@@ -147,23 +163,23 @@ module Sidekiq
       #   }
       # }
       #
-      def self.load_from_hash hash
-        array = hash.inject([]) do |out,(key, job)|
+      def self.load_from_hash(hash, options = {})
+        array = hash.map do |key, job|
           job['name'] = key
-          out << job
+          job
         end
-        load_from_array array
+        load_from_array(array, options)
       end
 
-      # like to {#load_from_hash}
-      # If exists old jobs in redis but removed from args, destroy old jobs
-      def self.load_from_hash! hash
+      # Like #load_from_hash.
+      # If exists old jobs in Redis but removed from args, destroy old jobs.
+      def self.load_from_hash!(hash, options = {})
         destroy_removed_jobs(hash.keys)
-        load_from_hash(hash)
+        load_from_hash(hash, options)
       end
 
-      # load cron jobs from Array
-      # input structure should look like:
+      # Load cron jobs from Array.
+      # Input structure should look like:
       # [
       #   {
       #     'name'        => 'name_of_job',
@@ -179,24 +195,24 @@ module Sidekiq
       #   }
       # ]
       #
-      def self.load_from_array array
+      def self.load_from_array(array, options = {})
         errors = {}
         array.each do |job_data|
-          job = new(job_data)
+          job = new(job_data.merge(options))
           errors[job.name] = job.errors unless job.save
         end
         errors
       end
 
-      # like to {#load_from_array}
-      # If exists old jobs in redis but removed from args, destroy old jobs
-      def self.load_from_array! array
+      # 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"] }
         destroy_removed_jobs(job_names)
-        load_from_array(array)
+        load_from_array(array, options)
       end
 
-      # get all cron jobs
+      # Get all cron jobs.
       def self.all
         job_hashes = nil
         Sidekiq.redis do |conn|
@@ -208,7 +224,7 @@ module Sidekiq
           end
         end
         job_hashes.compact.reject(&:empty?).collect do |h|
-          # no need to fetch missing args from redis since we just got this hash from there
+          # No need to fetch missing args from Redis since we just got this hash from there
           Sidekiq::Cron::Job.new(h.merge(fetch_missing_args: false))
         end
       end
@@ -222,26 +238,25 @@ module Sidekiq
       end
 
       def self.find name
-        #if name is hash try to get name from it
+        # If name is hash try to get name from it.
         name = name[:name] || name['name'] if name.is_a?(Hash)
+        return unless exists? name
 
         output = nil
         Sidekiq.redis do |conn|
-          if exists? name
-            output = Job.new conn.hgetall( redis_key(name) )
-          end
+          output = Job.new conn.hgetall( redis_key(name) )
         end
         output if output && output.valid?
       end
 
-      # create new instance of cron job
+      # Create new instance of cron job.
       def self.create hash
         new(hash).save
       end
 
-      #destroy job by name
+      # Destroy job by name.
       def self.destroy name
-        #if name is hash try to get name from it
+        # If name is hash try to get name from it.
         name = name[:name] || name['name'] if name.is_a?(Hash)
 
         if job = find(name)
@@ -252,7 +267,7 @@ module Sidekiq
       end
 
       attr_accessor :name, :cron, :description, :klass, :args, :message
-      attr_reader   :last_enqueue_time, :fetch_missing_args
+      attr_reader   :last_enqueue_time, :fetch_missing_args, :source
 
       def initialize input_args = {}
         args = Hash[input_args.map{ |k, v| [k.to_s, v] }]
@@ -262,24 +277,26 @@ module Sidekiq
         @name = args["name"]
         @cron = args["cron"]
         @description = args["description"] if args["description"]
+        @source = args["source"] == "schedule" ? "schedule" : "dynamic"
 
-        #get class from klass or class
+        # Get class from klass or class.
         @klass = args["klass"] || args["class"]
 
-        #set status of job
+        # Set status of job.
         @status = args['status'] || status_from_redis
 
-        #set last enqueue time - from args or from existing job
+        # 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
+        # Get right arguments for job.
         @symbolize_args = args["symbolize_args"] == true || ("#{args["symbolize_args"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
-        @args = args["args"].nil? ? [] : parse_args( args["args"] )
-        @args += [Time.now.to_f] if args["date_as_argument"]
+        @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"]
@@ -295,8 +312,8 @@ module Sidekiq
             "args"  => @args,
           }
 
-          #get right data for message
-          #only if message wasn't specified before
+          # Get right data for message,
+          # only if message wasn't specified before.
           klass_data = case @klass
             when Class
               @klass.get_sidekiq_options
@@ -304,21 +321,21 @@ module Sidekiq
               begin
                 Sidekiq::Cron::Support.constantize(@klass).get_sidekiq_options
               rescue Exception => e
-                #Unknown class
+                # 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)
+
+          # 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
 
-          #dump message as json
           @message = message_data
         end
 
@@ -380,28 +397,34 @@ module Sidekiq
             conn.lrange(jid_history_key, 0, -1) rescue nil
           end
 
-        # returns nil if out nil
         out && out.map do |jid_history_raw|
           Sidekiq.load_json jid_history_raw
         end
       end
 
-      #export job data to hash
+      # Export job data to hash.
       def to_hash
-        {
+        hash = {
           name: @name,
-          klass: @klass,
+          klass: @klass.to_s,
           cron: @cron,
           description: @description,
+          source: @source,
           args: @args.is_a?(String) ? @args : Sidekiq.dump_json(@args || []),
           message: @message.is_a?(String) ? @message : Sidekiq.dump_json(@message || {}),
           status: @status,
-          active_job: @active_job,
+          active_job: @active_job ? "1" : "0",
           queue_name_prefix: @active_job_queue_name_prefix,
           queue_name_delimiter: @active_job_queue_name_delimiter,
-          last_enqueue_time: @last_enqueue_time,
-          symbolize_args: @symbolize_args,
+          last_enqueue_time: serialized_last_enqueue_time,
+          symbolize_args: symbolize_args? ? "1" : "0",
         }
+
+        if date_as_argument?
+          hash.merge!(date_as_argument: "1")
+        end
+
+        hash
       end
 
       def errors
@@ -409,7 +432,7 @@ module Sidekiq
       end
 
       def valid?
-        #clear previous errors
+        # Clear previous errors.
         @errors = []
 
         errors << "'name' must be set" if @name.nil? || @name.size == 0
@@ -417,7 +440,7 @@ module Sidekiq
           errors << "'cron' must be set"
         else
           begin
-            @parsed_cron = Fugit.do_parse_cron(@cron)
+            @parsed_cron = Fugit.do_parse_cronish(@cron)
           rescue => e
             errors << "'cron' -> #{@cron.inspect} -> #{e.class}: #{e.message}"
           end
@@ -438,38 +461,30 @@ module Sidekiq
         end
       end
 
-      # add job to cron jobs
-      # input:
-      #   name: (string) - name of job
-      #   cron: (string: '* * * * *' - cron specification when to run job
-      #   class: (string|class) - which class to perform
-      # optional input:
-      #   queue: (string) - which queue to use for enquing (will override class queue)
-      #   args: (array|hash|nil) - arguments for permorm method
-
       def save
-        #if job is invalid return false
+        # If job is invalid, return false.
         return false unless valid?
 
         Sidekiq.redis do |conn|
 
-          #add to set of all jobs
-          conn.sadd self.class.jobs_key, redis_key
+          # Add to set of all jobs
+          conn.sadd self.class.jobs_key, [redis_key]
 
-          #add informations for this job!
-          conn.hmset redis_key, *hash_to_redis(to_hash)
+          # Add informations 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!
+          # Add information about last time! - don't enque right after scheduler poller starts!
           time = Time.now.utc
-          conn.zadd(job_enqueued_key, time.to_f.to_s, formated_last_time(time).to_s) unless conn.public_send(REDIS_EXISTS_METHOD, job_enqueued_key)
+          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}" }
       end
 
       def save_last_enqueue_time
         Sidekiq.redis do |conn|
-          # update last enqueue time
-          conn.hset redis_key, 'last_enqueue_time', @last_enqueue_time
+          # Update last enqueue time.
+          conn.hset redis_key, 'last_enqueue_time', serialized_last_enqueue_time
         end
       end
 
@@ -478,36 +493,35 @@ module Sidekiq
           jid: jid,
           enqueued: @last_enqueue_time
         }
-        @history_size ||= (Sidekiq.options[:cron_history_size] || 10).to_i - 1
+
+        @history_size ||= (Sidekiq::Options[:cron_history_size] || 10).to_i - 1
         Sidekiq.redis do |conn|
           conn.lpush jid_history_key,
                      Sidekiq.dump_json(jid_history)
-          # keep only last 10 entries in a fifo manner
+          # Keep only last 10 entries in a fifo manner.
           conn.ltrim jid_history_key, 0, @history_size
         end
       end
 
-      # remove job from cron jobs by name
-      # input:
-      #   first arg: name (string) - name of job (must be same - case sensitive)
       def destroy
         Sidekiq.redis do |conn|
-          #delete from set
-          conn.srem self.class.jobs_key, redis_key
+          # Delete from set.
+          conn.srem self.class.jobs_key, [redis_key]
 
-          #delete runned timestamps
+          # Delete runned timestamps.
           conn.del job_enqueued_key
 
-          # delete jid_history
+          # Delete jid_history.
           conn.del jid_history_key
 
-          #delete main job
+          # Delete main job.
           conn.del redis_key
         end
+
         Sidekiq.logger.info { "Cron Jobs - deleted job with name: #{@name}" }
       end
 
-      # remove all job from cron
+      # Remove all job from cron.
       def self.destroy_all!
         all.each do |job|
           job.destroy
@@ -515,9 +529,9 @@ module Sidekiq
         Sidekiq.logger.info { "Cron Jobs - deleted all jobs" }
       end
 
-      # remove "removed jobs" between current jobs and new jobs
+      # Remove "removed jobs" between current jobs and new jobs
       def self.destroy_removed_jobs new_job_names
-        current_job_names = Sidekiq::Cron::Job.all.map(&:name)
+        current_job_names = Sidekiq::Cron::Job.all.filter_map { |j| j.name if j.source == "schedule" }
         removed_job_names = current_job_names - new_job_names
         removed_job_names.each { |j| Sidekiq::Cron::Job.destroy(j) }
         removed_job_names
@@ -529,20 +543,19 @@ module Sidekiq
         parsed_cron.previous_time(now.utc).utc
       end
 
-      def formated_enqueue_time now = Time.now.utc
+      def formatted_enqueue_time now = Time.now.utc
         last_time(now).getutc.to_f.to_s
       end
 
-      def formated_last_time now = Time.now.utc
+      def formatted_last_time now = Time.now.utc
         last_time(now).getutc.iso8601
       end
 
       def self.exists? name
-        out = false
-        Sidekiq.redis do |conn|
-          out = conn.public_send(REDIS_EXISTS_METHOD, redis_key(name))
+        out = Sidekiq.redis do |conn|
+          conn.public_send(REDIS_EXISTS_METHOD, redis_key(name))
         end
-        out
+        out == true || out == 1
       end
 
       def exists?
@@ -553,10 +566,14 @@ module Sidekiq
         "#{status == "enabled" ? 0 : 1}_#{name}".downcase
       end
 
+      def args=(args)
+        @args = parse_args(args)
+      end
+
       private
 
       def parsed_cron
-        @parsed_cron ||= Fugit.parse_cron(@cron)
+        @parsed_cron ||= Fugit.parse_cronish(@cron)
       end
 
       def not_enqueued_after?(time)
@@ -564,24 +581,27 @@ module Sidekiq
       end
 
       # Try parsing inbound args into an array.
-      # args from Redis will be encoded JSON;
-      # try to load JSON, then failover
-      # to string array.
+      # Args from Redis will be encoded JSON,
+      # try to load JSON, then failover to string array.
       def parse_args(args)
         case args
+        when GlobalID::Identification
+          [convert_to_global_id_hash(args)]
         when String
           begin
             parsed_args = Sidekiq.load_json(args)
             symbolize_args? ? symbolize_args(parsed_args) : parsed_args
           rescue JSON::ParserError
-            [*args]   # cast to string array
+            [*args]
           end
         when Hash
+          args = serialize_argument(args)
           symbolize_args? ? [symbolize_args(args)] : [args]
         when Array
+          args = serialize_argument(args)
           symbolize_args? ? symbolize_args(args) : args
         else
-          [*args]     # cast to string array
+          [*args]
         end
       end
 
@@ -613,29 +633,26 @@ module Sidekiq
 
       def not_past_scheduled_time?(current_time)
         last_cron_time = parsed_cron.previous_time(current_time).utc
-          # or could it be?
-        #last_cron_time = last_time(current_time)
         return false if (current_time.to_i - last_cron_time.to_i) > 60
         true
       end
 
-      # Redis key for set of all cron jobs
+      # Redis key for set of all cron jobs.
       def self.jobs_key
         "cron_jobs"
       end
 
-      # Redis key for storing one cron job
+      # Redis key for storing one cron job.
       def self.redis_key name
         "cron_job:#{name}"
       end
 
-      # Redis key for storing one cron job
+      # Redis key for storing one cron job.
       def redis_key
         self.class.redis_key @name
       end
 
-      # Redis key for storing one cron job run times
-      # (when poller added job to queue)
+      # 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"
       end
@@ -644,8 +661,6 @@ module Sidekiq
         "cron_job:#{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
       end
@@ -654,12 +669,56 @@ module Sidekiq
         self.class.jid_history_key @name
       end
 
-      # Give Hash
-      # returns array for using it for redis.hmset
-      def hash_to_redis hash
-        hash.inject([]){ |arr,kv| arr + [kv[0], kv[1]] }
+      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
+        raise "Unable to serialize #{argument.class} " \
+          "without an id. (Maybe you forgot to call save?)"
+      end
+
+      def deserialize_argument(argument)
+        case argument
+        when String
+          argument
+        when Array
+          argument.map { |arg| deserialize_argument(arg) }
+        when Hash
+          if serialized_global_id?(argument)
+            deserialize_global_id argument
+          else
+            argument.transform_values { |v| deserialize_argument(v) }
+          end
+        else
+          argument
+        end
       end
 
+      def serialized_global_id?(hash)
+        hash.size == 1 && hash.include?(GLOBALID_KEY)
+      end
+
+      def deserialize_global_id(hash)
+        GlobalID::Locator.locate hash[GLOBALID_KEY]
+      end
+
+      def serialize_argument(argument)
+        case argument
+        when GlobalID::Identification
+          convert_to_global_id_hash(argument)
+        when Array
+          argument.map { |arg| serialize_argument(arg) }
+        when Hash
+          argument.each_with_object({}) do |(key, value), hash|
+            hash[key] = serialize_argument(value)
+          end
+        else
+          argument
+        end
+      end
     end
   end
 end