canvas_sync 0.23.4 → 0.24.0.beta1

data/lib/canvas_sync/job_uniqueness/lock_context.rb

@@ -1,199 +0,0 @@
-
-module CanvasSync::JobUniqueness
-  class LockContext
-    def self.from_serialized(data, **kwargs)
-      context_class = data[:clazz]&.constantize || self
-      context_class.new(data, **kwargs)
-    end
-
-    attr_reader :lock_id
-
-    # { job_clazz, jid, queue, args?, kwargs?, base_key? }
-    def initialize(data, job_instance: nil, config: nil)
-      @base_key = data[:base_key]
-      @context_data = data
-      @job_instance = job_instance
-      @config = config || @context_data[:config]
-
-      # TODO Consider (somewhere) updating the lock_id to the BID of the wrapping Batch (when applicable)
-      @lock_id ||= data[:lid] || Thread.current[:unique_jobs_previous_context]&.lock_id || job_id
-    end
-
-    # This is primarily for rehydrating in a Batch Callback, so it is unlikely that args and kwargs are needed.
-    def serialize
-      {
-        lid: lock_id,
-        clazz: self.class.to_s,
-        job_clazz: @context_data[:job_clazz].to_s,
-        jid: @context_data[:jid],
-        queue: @context_data[:queue],
-        **cache_data,
-      }
-    end
-
-    # Properties to cache on the serialized Job object to prevent issues arising from code changes between enqueue and perform
-    def cache_data
-      {
-        lid: lock_id,
-        base_key: base_key,
-        job_score: job_score,
-        # TODO Should config also be cached on the Job at time of enqueue?
-        # config: config,
-      }
-    end
-
-    def debug_data
-      {
-        lid: lock_id,
-        context_class: self.class.to_s,
-        job_class: job_class.to_s,
-        queue: job_queue,
-        limit: config[:limit],
-        timeout: config[:timeout],
-        ttl: config[:ttl],
-        strategy: config[:strategy],
-        time: Time.now.to_f,
-        at: job_scheduled_at,
-      }
-    end
-
-    def handle_lifecycle!(stage, *args, **kwargs, &blk)
-      lock_strategy.send(:"on_#{stage}", *args, **kwargs, &blk)
-    rescue CouldNotLockError => e
-      call_conflict_strategy(stage)
-    end
-
-    def lock_strategy
-      return @lock_strategy if defined?(@lock_strategy)
-
-      strat_name = config[:strategy]
-      @lock_strategy = Strategy.lookup(strat_name).new(self)
-    end
-
-    def config
-      @config ||= job_class.unique_job_options
-    end
-
-    def job_class
-      @job_class ||= begin
-        if (job_clazz = @context_data[:job_clazz]).is_a?(String)
-          job_clazz.constantize
-        else
-          job_clazz
-        end
-      end
-    end
-
-    def job_id
-      @context_data[:jid]
-    end
-
-    def job_queue
-      @context_data[:queue]
-    end
-
-    def job_scheduled_at
-      nil
-    end
-
-    def job_score
-      @context_data[:job_score] || job_scheduled_at.to_s
-    end
-
-    def base_key(any_hash: false)
-      @base_key ||= begin
-        queue = @context_data[:queue] || "default"
-
-        base_key = [
-          CanvasSync::JobUniqueness.config.lock_prefix.presence,
-        ].compact
-
-        scope = config[:scope]
-        if scope.is_a?(Proc)
-          base_key << scope.call(queue: queue)
-        elsif scope == :global
-          base_key << job_class.name
-        elsif scope == :per_queue
-          base_key << job_class.name
-          base_key << queue
-        else
-          base_key << scope
-        end
-
-        args = @context_data[:args] || []
-        kwargs = @context_data[:kwargs] || {}
-        hash = config[:hash]
-        if config[:hash].is_a?(Proc)
-          hash = config[:hash].call(*args, **kwargs)
-        elsif config[:hash].nil?
-          hash = [*args, kwargs]
-        end
-
-        hash = ":#{hash}" if hash.is_a?(Symbol)
-
-        if hash && !hash.is_a?(String)
-          hash = Array(hash)
-
-          # Normalize the hash to ensure that the order of any Hash keys don't matter
-          hash = normalize_hash_chunk(hash)
-
-          normalized = ActiveJob::Arguments.serialize(hash)
-          hash = OpenSSL::Digest::MD5.hexdigest(JSON.dump(normalized))
-        end
-
-        base_key << hash if hash
-
-        base_key.join(":")
-      end
-    end
-
-    def reenqueue
-      raise NotImplementedError, "needs to be implemented in child class"
-    end
-
-    protected
-
-    attr_reader :job_instance
-
-    #
-    # Call whatever strategy that has been configured
-    #
-    # @param [Symbol] origin the origin `:client` or `:server`
-    #
-    # @return [void] the return value is irrelevant
-    #
-    # @yieldparam [void] if a new job id was set and a block is given
-    # @yieldreturn [void] the yield is irrelevant, it only provides a mechanism in
-    #   one specific situation to yield back to the middleware.
-    def call_conflict_strategy(origin)
-      strategy = conflict_strategy_for(origin)
-
-      strategy.call
-    end
-
-    def conflict_strategy_for(origin)
-      raise ArgumentError, "#origin needs to be either `:enqueue` or `:perform`" unless %i[enqueue perform].include?(origin)
-
-      @conflict_strategies ||= {}
-      @conflict_strategies[origin] ||= begin
-        cfg = config[:on_conflict]
-        cfg = cfg[origin] if cfg.is_a?(Hash)
-
-        cstrat_cls = OnConflict.lookup(cfg || :null_strategy)
-        cstrat = cstrat_cls.new(self) # TODO Pass redis_pool?
-      end
-    end
-
-    private
-
-    def normalize_hash_chunk(chunk)
-      if chunk.is_a?(Hash)
-        chunk.map { |k, v| [k, normalize_hash_chunk(v)] }.sort.to_h
-      elsif chunk.is_a?(Array)
-        chunk.map { |c| normalize_hash_chunk(c) }
-      else
-        chunk
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/locksmith.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require "sidekiq_unique_jobs"
-
-module CanvasSync::JobUniqueness
-  # This class is intended to be the complete translation layer between CanvasSync::JobUniqueness and SidekiqUniqueJobs.
-  # In other words, you could consider it the "locking backend" and thus could potentially swap out SUJ for a more succinct solution.
-  #
-  # SUJ's implementation is somewhat complex, but is somewhat pre-tailored over (eg) https://github.com/leandromoreira/redlock-rb.
-  # Mainly SUJ tracks the JID so that if a process dies, another can pick up the job without having to figure out how to unlock it.
-  # SUJ also handles the integration into Sidekiq Web, which is a nice bonus.
-  class Locksmith < SidekiqUniqueJobs::Locksmith
-    attr_reader :lock_context
-
-    def initialize(key, lock_context, redis_pool = nil)
-      @lock_context = lock_context
-      @job_id = lock_context.lock_id # Yes, .lock_id is intentional
-      @item = lock_context
-      @key = SidekiqUniqueJobs::Key.new(key)
-
-      lcfg = lock_context.config
-      @config = OpenStruct.new({
-        :"type" => lcfg[:strategy],
-        :"pttl" => lcfg[:ttl] * 1000,
-        :"timeout" => lcfg[:timeout],
-        :"wait_for_lock?" => lcfg[:ttl]&.positive?,
-        :"lock_info" => false,
-        :"limit" => lcfg[:limit],
-      })
-
-      @redis_pool = redis_pool
-    end
-
-    def locked_jids
-      SidekiqUniqueJobs::Lock.new(@key).locked_jids
-    end
-
-    def swap_locks(old_jid)
-      olimit = lock_context.config[:limit]
-      new_jid = @job_id
-      return if old_jid == new_jid
-
-      # NB This is quite hacky, but should work
-      #
-      # Ideally the unlock(old) and lock(new) would be atomic, but that increases the amount of coupling with Sidekiq-Unique-Jobs - right now,
-      #   we're using fairly stable (though still internal) SUJ APIs; I fear that writing custom Lua will be significantly more brittle
-      #
-      # In the general case, we'd only bump limit by 1, but that leaves a potential race-condition when limit is configured > 1:
-      # (Assuming until_and_while_executing, reschedule, limit = 2):
-      #   (Workers are performing 2 Jobs, RUN lock count = 2)
-      #   Worker 1 pulls Job A
-      #   Worker 2 pulls Job B
-      #   W1 and W2 both fail to get the runtime lock
-      #   W1 and W2 call swap_locks
-      #   W1 calls lock(limit+1), lock is granted, lock count becomes limit+1
-      #   W2 calls lock(limit+1), lock is denied because count would be limit+2
-      #   W1 calls unlock(old_jid)
-
-      # Force creation of another lock, ignoring the limit
-      @config.limit = olimit + 100
-      result = lock
-
-      # Release the old lock, bringing us back within the limit
-      @job_id = old_jid
-      unlock
-
-      result
-    ensure
-      @config.limit = olimit
-      @job_id = new_jid
-    end
-
-    private
-
-    def lock_score
-      lock_context.job_score
-    end
-
-    def lock_info
-      @lock_info = JSON.dump(lock_context.debug_data)
-    end
-
-    # def taken?(conn)
-    #   v = conn.hexists(key.locked, job_id)
-    #   v.is_a?(Numeric) ? v != 0 : v
-    # end
-
-    def redis_version
-      @redis_version ||= CanvasSync::JobUniqueness.config.redis_version || SidekiqUniqueJobs.fetch_redis_version
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/on_conflict/base.rb

@@ -1,32 +0,0 @@
-module CanvasSync::JobUniqueness
-  module OnConflict
-    class Base
-      attr_reader :lock_context
-      attr_reader :redis_pool
-
-      class_attribute :_valid_for, instance_writer: false
-
-      def self.valid_for(*origins)
-        if origins.present?
-          orgins = Array(origins).map(&:to_sym)
-          self._valid_for = origins
-        else
-          self._valid_for || [:enqueue, :perform]
-        end
-      end
-
-      def initialize(lock_context, redis_pool = nil)
-        @lock_context = lock_context
-        @redis_pool = redis_pool
-      end
-
-      def call
-        raise NotImplementedError, "needs to be implemented in child class"
-      end
-
-      def replace?
-        is_a?(Replace)
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/on_conflict/log.rb

@@ -1,13 +0,0 @@
-module CanvasSync::JobUniqueness
-  module OnConflict
-    class Log < Base
-      valid_for :enqueue, :perform
-
-      def call
-        CanvasSync::JobUniqueness.logger.info(<<~MESSAGE.chomp)
-          Skipping job with id (#{lock_context.job_id}) because key: (#{lock_context.base_key}) is locked
-        MESSAGE
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/on_conflict/null_strategy.rb

@@ -1,9 +0,0 @@
-module CanvasSync::JobUniqueness
-  module OnConflict
-    class NullStrategy < Base
-      valid_for :enqueue, :perform
-
-      def call; end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/on_conflict/raise.rb

@@ -1,11 +0,0 @@
-module CanvasSync::JobUniqueness
-  module OnConflict
-    class Raise < Base
-      valid_for :enqueue, :perform
-
-      def call
-        raise Conflict, lock_context
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/on_conflict/reject.rb

@@ -1,21 +0,0 @@
-module CanvasSync::JobUniqueness
-  module OnConflict
-    class Reject < Base
-      valid_for :perform
-
-      def call
-        # TODO Allow this to work on Sidekiq-backed ActiveJob
-        unless lock_context.is_a?(CanvasSync::JobUniqueness::Compat::Sidekiq::SidekiqLockContext)
-          CanvasSync::JobUniqueness.logger.error(":reject conflict strategy is not supported for non-Sidekiq-backed jobs")
-          return
-        end
-
-        kwargs = {}
-        kwargs[:notify_failure] = false if Sidekiq::DeadSet.instance_method(:kill).arity > 1
-
-        sidekiq_message = lock_context.instance_variable_get(:@job_instance)
-        Sidekiq::DeadSet.new.kill(JSON.dump(sidekiq_message), **kwargs)
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/on_conflict/reschedule.rb

@@ -1,20 +0,0 @@
-module CanvasSync::JobUniqueness
-  module OnConflict
-    class Reschedule < OnConflict::Base
-      valid_for :perform
-
-      def call
-        Thread.current[:unique_jobs_previous_context] = lock_context
-        rescheduled = lock_context.reenqueue(
-          schedule_in: schedule_in,
-        )
-      ensure
-        Thread.current[:unique_jobs_previous_context] = nil
-      end
-
-      def schedule_in
-        lock_context.config[:reschedule_in] || 60
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/on_conflict.rb

@@ -1,62 +0,0 @@
-module CanvasSync::JobUniqueness
-  module OnConflict
-    extend ActiveSupport::Autoload
-
-    autoload :Base
-
-    autoload :Log
-    autoload :NullStrategy
-    autoload :Raise
-    autoload :Reject
-    autoload :Reschedule
-
-    # Replace is... hard. It involves hacking into some of the inner workings of Sidekiq and/or ActiveJob.
-    # The best solution would be to somehow mark the previously-scheduled job as dead and let it be picked up by workers but not invoke
-    #   its perform method (technically this would mess with success numbers, but does anybody really care about those?).
-    # Replace will also conflict with the UntilExecuted strategy as it wouldn't be able to replace a job that has begun executing.
-    #
-    # Replace is useful for two cases:
-    #   1. Moving the job to the back of the queue, eg for debouncing purposes
-    #   2. Replacing non-hashed params with updated values
-    # A solution to (2) would be to store the latest params outside of the Job params - eg in the DB or in Redis directly.
-    # (1) is solvebale in a similar out-of-band way, but other, better solutions may exist as well
-    #
-    # If the param in question is a (eg) a list that you want to append to, you could:
-    #   Push to the list in Redis
-    #   Queue the job
-    #   (Push another param to the list in Redis)
-    #   (Re-enqueue the job, but it won't enqueue because it is locked)
-    #   When the job begins, it pulls all values from the field in Redis an processes
-    #   Adding more params from this point would allow another job to enqueue
-    #
-    # We may implement some tooling for this at some point, but for now the recommendation is to handle this yourself,
-    # autoload :Replace
-
-    class << self
-      def lookup(strategy)
-        matching_strategy(strategy.to_s.camelize) ||
-          CanvasSync::JobUniqueness.config.conflict_strategies[strategy] ||
-          raise(StrategyNotFound, "on_conflict: #{strategy} is not found. Is it declared in the configuration?")
-      end
-
-      def validate!(on_conflict, lock_strategy)
-        on_conflict = { enqueue: on_conflict, perform: on_conflict } unless on_conflict.is_a?(Hash)
-
-        lock_strategy = Strategy.lookup(lock_strategy) if lock_strategy.is_a?(Symbol)
-        on_conflict.each do |origin, strategy|
-          strategy = OnConflict.lookup(strategy) if strategy.is_a?(Symbol)
-
-          if lock_strategy.locks_on.include?(origin) && !strategy.valid_for.include?(origin)
-            raise ArgumentError, "(#{origin.to_s.titleize}) conflict strategy #{strategy.name.underscore} is not valid for lock strategy #{lock_strategy.name.underscore}"
-          end
-        end
-      end
-
-      private
-
-      def matching_strategy(const)
-        const_get(const, false) if const_defined?(const, false)
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/strategy/base.rb

@@ -1,107 +0,0 @@
-module CanvasSync::JobUniqueness
-  module Strategy
-    class Base
-      attr_reader :lock_context
-
-      def initialize(lock_context)
-        @lock_context = lock_context
-        @conflict_strategies = {}
-      end
-
-      class_attribute :_locks_on, instance_writer: false
-
-      def self.locks_on(*origins)
-        if origins.present?
-          orgins = Array(origins).map(&:to_sym)
-          self._locks_on = origins
-        else
-          self._locks_on || [:enqueue, :perform]
-        end
-      end
-
-      def on_enqueue; end
-      def on_perform; end
-
-      def batch_callback(event, batch_status)
-        if event == :success
-          unlock
-        else
-          unlock_cond = lock_context.config[:unlock_on_failure]
-
-          if (event == :complete && unlock_cond == :any) || (event == :death && unlock_cond == :death) || (event == :stagnated && unlock_cond == :stagnant)
-            unlock
-          end
-        end
-      end
-
-      delegate :locked?, to: :locksmith
-
-      protected
-
-      def key
-        lock_context.base_key
-      end
-
-      def wrap_in_batch(&blk)
-        if Thread.current[:unique_jobs_previous_context] # Ensure we don't re-wrap in a batch when rescheduling
-          return blk.call
-        end
-
-        batch = CanvasSync::JobBatches::Batch.new
-        batch.context = {
-          uniqueness_lock_key: key,
-        }
-
-        CanvasSync::JobBatches::Batch::Callback::VALID_CALLBACKS.each do |callback|
-          callback = callback.to_sym
-          batch.on(callback, self.class.to_s + ".internal_batch_callback", {
-            event: callback,
-            lock_strategy: self.class.to_s,
-            lock_key: key,
-            lock_context: lock_context.serialize,
-          })
-        end
-
-        CanvasSync::JobUniqueness.logger.debug("Wrapped job (#{lock_context.lock_id}) in Locking Batch #{batch.bid} for #{key}")
-
-        batch.jobs do
-          return blk.call
-        end
-      end
-
-      def self.internal_batch_callback(batch_status, opts)
-        CanvasSync::JobUniqueness.logger.debug("Received Batch(#{batch_status.bid}) callback for #{opts[:lock_strategy]} #{opts[:lock_key]} - #{opts[:event]}")
-        CanvasSync::JobUniqueness.logger.debug("Context data: #{opts[:lock_context]}")
-        strategy_class = opts[:lock_strategy].constantize
-        lock_context = LockContext.from_serialized(opts[:lock_context])
-        CanvasSync::JobUniqueness.logger.debug("Rehydrated LockContext: #{lock_context.lock_id} #{lock_context.debug_data}")
-        strategy = strategy_class.new(lock_context)
-        # TODO Should this route through LockContext#handle_lifecycle!?
-        strategy.batch_callback(opts[:event].to_sym, batch_status)
-      end
-
-      def lock!(purpose, wait: nil)
-        locked = nil
-        if purpose == :enqueue
-          locked = locksmith.lock()
-        elsif purpose == :perform
-          locked = locksmith.execute { lock_context.lock_id }
-        end
-
-        CanvasSync::JobUniqueness.logger.debug { "Requested lock of #{key} for #{purpose} - (#{locked || 'Not Obtained!'})" }
-
-        raise CouldNotLockError.new(lock_context, source: purpose) if !locked
-      end
-
-      def unlock()
-        CanvasSync::JobUniqueness.logger.debug { "Trying to unlock #{key} for LID #{lock_context.lock_id}" }
-        result = locksmith.unlock
-        CanvasSync::JobUniqueness.logger.debug { "Unlocked #{key} - (#{result || 'Not Unlocked!'})" }
-      end
-
-      def locksmith
-        @locksmith ||= Locksmith.new(key, lock_context)
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/strategy/until_and_while_executing.rb

@@ -1,35 +0,0 @@
-module CanvasSync::JobUniqueness
-  module Strategy
-    # Implements two locks - one while enqueued and one while performing
-    class UntilAndWhileExecuting < Base
-      locks_on :enqueue, :perform
-
-      def on_enqueue
-        # Obtain lock
-        lock!(:enqueue)
-
-        # Proceed with enqueuing the job, wrapping it in a batch
-        runtime_lock.on_enqueue do
-          yield
-        end
-      end
-
-      def on_perform
-        # Obtain Runtime lock
-        runtime_lock.on_perform do
-          # Release Queue lock
-          unlock()
-
-          # Run the job
-          yield
-        end
-      end
-
-      private
-
-      def runtime_lock
-        @runtime_lock ||= Strategy::WhileExecuting.new(lock_context)
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/strategy/until_executed.rb

@@ -1,20 +0,0 @@
-module CanvasSync::JobUniqueness
-  module Strategy
-    class UntilExecuted < Base
-      locks_on :enqueue, :perform
-
-      def on_enqueue
-        lock!(:enqueue)
-
-        wrap_in_batch do
-          yield
-        end
-      end
-
-      def on_perform
-        lock!(:perform)
-        yield
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/strategy/until_executing.rb

@@ -1,20 +0,0 @@
-module CanvasSync::JobUniqueness
-  module Strategy
-    class UntilExecuting < Base
-      locks_on :enqueue
-
-      def on_enqueue
-        lock!(:enqueue)
-        yield
-      end
-
-      def on_perform
-        unlock
-        yield
-      end
-
-      # TODO Define behavior when an error occurs during perform().
-      # SUJ's behavior is to relock, but this has some edge-cases (like how do we handle if another job already took the lock?)
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/strategy/until_expired.rb

@@ -1,16 +0,0 @@
-module CanvasSync::JobUniqueness
-  module Strategy
-    class UntilExpired < UntilExecuted
-      locks_on :enqueue, :perform
-
-      def on_enqueue
-        lock!(:enqueue)
-        yield
-      end
-
-      def on_perform
-        lock!(:perform)
-      end
-    end
-  end
-end

data/lib/canvas_sync/job_uniqueness/strategy/while_executing.rb

@@ -1,26 +0,0 @@
-module CanvasSync::JobUniqueness
-  module Strategy
-    class WhileExecuting < Base
-      locks_on :perform
-
-      RUN_SUFFIX = ":RUN"
-
-      def on_enqueue
-        wrap_in_batch do
-          yield
-        end
-      end
-
-      def on_perform
-        lock!(:perform)
-        yield
-      end
-
-      protected
-
-      def key
-        super + RUN_SUFFIX
-      end
-    end
-  end
-end