canvas_sync 0.22.0.beta7 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 460a37fe879ff078150579638df606c33dfd35870b69955c42dc7bee7afb4833
-  data.tar.gz: e02f9568f6d80f0f0bf4ab6ff21800ed8bcd36d5cd1803f03cf6a186b3fda690
+  metadata.gz: b659edf35a8c6f427f847142d4627920cc19effabfe7fb5ad2ccb960884cf47c
+  data.tar.gz: 3264f9b298a5fcbf251a6ccd927ce20133598ed1b9fdd8adf3a728ef90a4e080
 SHA512:
-  metadata.gz: 1a08031744764b9f14a8da562ffee5ca83a85e4efa9b5a5b9725605cce53853b90d3dfd9b01bb5ec5ac5aeb248bc6be88fe07b1de9b5b2e5b0b6c4d25d8cd942
-  data.tar.gz: a71f36915f50bbb74dc746ac2f9c7a8f3489995f8dc67648a58ceb20e85cd71c17072b7b967e415c1be4d3f349c378afcc7b1ed132e2682711cca1c98958d7bc
+  metadata.gz: a9c7add460f50301b9f404880e9f6ac2fc57996f1e4c8928f2c52b9bfa5f4973f6cc3c531729763a40de6cce127b86aed70b88ea11fc2119e9fe1856f81a4996
+  data.tar.gz: 7d5951ebd7f02917344ea94c23d4f7e5d467d7d803be2944ab1d073aa207acca55a065aa8e2b9145f129154c1ed10b9fb2d14b0692c1e1d8ec21a99f042dab8a

data/lib/canvas_sync/job_batches/compat/sidekiq.rb

@@ -45,7 +45,7 @@ module CanvasSync::JobBatches
 
         def call(_worker, msg, _queue, _redis_pool = nil)
           if (batch = Thread.current[CURRENT_BATCH_THREAD_KEY]) && should_handle_batch?(msg)
-            batch.increment_job_queue(msg['jid']) if (msg[:bid] = batch.bid)
+            batch.increment_job_queue(msg['jid']) if (msg['bid'] = batch.bid)
           end
           yield
         end

data/lib/canvas_sync/job_uniqueness/compat/active_job.rb

@@ -41,7 +41,7 @@ module CanvasSync::JobUniqueness
 
         def deserialize(data)
           super
-          @uniqueness_cache_data = data['uniqueness_cache_data'].symbolize_keys
+          @uniqueness_cache_data = data['uniqueness_cache_data']&.symbolize_keys
         end
 
         def uniqueness_lock_context

data/lib/canvas_sync/job_uniqueness/compat/sidekiq.rb

@@ -19,7 +19,7 @@ module CanvasSync::JobUniqueness
 
       class SidekiqLockContext < LockContext
         def job_scheduled_at
-          @job_instance["at"]
+          @job_instance&.[]("at")
         end
 
         def reenqueue(schedule_in:)
@@ -38,7 +38,7 @@ module CanvasSync::JobUniqueness
             queue: msg['queue'],
             args: msg['args'],
             # kwargs: msg['kwargs'],
-            **(msg['uniqueness_cache_data'] || {}),
+            **(msg['uniqueness_cache_data']&.symbolize_keys || {}),
           }, job_instance: msg)
         end
 
@@ -58,7 +58,7 @@ module CanvasSync::JobUniqueness
         def call(_worker, msg, _queue, _redis_pool = nil, &blk)
           ctx = lock_context(msg)
           return blk.call unless ctx
-          msg['uniqueness_cache_data'] = ctx.cache_data
+          msg['uniqueness_cache_data'] = ctx.cache_data.stringify_keys
           ctx.handle_lifecycle!(:enqueue, &blk)
         end
       end

data/lib/canvas_sync/job_uniqueness/lock_context.rb

@@ -6,18 +6,23 @@ module CanvasSync::JobUniqueness
       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.
-    # Honestly, base_key and job_clazz are probably the only needed values
     def serialize
       {
+        lid: lock_id,
         clazz: self.class.to_s,
         job_clazz: @context_data[:job_clazz].to_s,
         jid: @context_data[:jid],
@@ -29,6 +34,7 @@ module CanvasSync::JobUniqueness
     # 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?
@@ -38,6 +44,7 @@ module CanvasSync::JobUniqueness
 
     def debug_data
       {
+        lid: lock_id,
         context_class: self.class.to_s,
         job_class: job_class.to_s,
         queue: job_queue,
@@ -146,7 +153,6 @@ module CanvasSync::JobUniqueness
     # @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)
-      new_job_id = nil
       strategy = conflict_strategy_for(origin)
 
       strategy.call

data/lib/canvas_sync/job_uniqueness/locksmith.rb

@@ -14,7 +14,7 @@ module CanvasSync::JobUniqueness
 
     def initialize(key, lock_context, redis_pool = nil)
       @lock_context = lock_context
-      @job_id = lock_context.job_id
+      @job_id = lock_context.lock_id # Yes, .lock_id is intentional
       @item = lock_context
       @key = SidekiqUniqueJobs::Key.new(key)
 
@@ -28,7 +28,7 @@ module CanvasSync::JobUniqueness
         :"limit" => lcfg[:limit],
       })
 
-      @redis_pool  = redis_pool
+      @redis_pool = redis_pool
     end
 
     def locked_jids

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

@@ -4,12 +4,12 @@ module CanvasSync::JobUniqueness
       valid_for :perform
 
       def call
-        Thread.current[:unique_jobs_previous_jid] = lock_context.job_id
+        Thread.current[:unique_jobs_previous_context] = lock_context
         rescheduled = lock_context.reenqueue(
           schedule_in: schedule_in,
         )
       ensure
-        Thread.current[:unique_jobs_previous_jid] = nil
+        Thread.current[:unique_jobs_previous_context] = nil
       end
 
       def schedule_in

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

@@ -43,7 +43,7 @@ module CanvasSync::JobUniqueness
       end
 
       def wrap_in_batch(&blk)
-        if Thread.current[:unique_jobs_previous_jid] # Ensure we don't re-wrap in a batch when rescheduling
+        if Thread.current[:unique_jobs_previous_context] # Ensure we don't re-wrap in a batch when rescheduling
           return blk.call
         end
 
@@ -62,7 +62,7 @@ module CanvasSync::JobUniqueness
           })
         end
 
-        CanvasSync::JobUniqueness.logger.debug("Wrapped job in Locking Batch #{batch.bid} for #{key}")
+        CanvasSync::JobUniqueness.logger.debug("Wrapped job (#{lock_context.lock_id}) in Locking Batch #{batch.bid} for #{key}")
 
         batch.jobs do
           return blk.call
@@ -74,7 +74,7 @@ module CanvasSync::JobUniqueness
         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.job_id} #{lock_context.debug_data}")
+        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)
@@ -83,13 +83,9 @@ module CanvasSync::JobUniqueness
       def lock!(purpose, wait: nil)
         locked = nil
         if purpose == :enqueue
-          if Thread.current[:unique_jobs_previous_jid].present?
-            locked = locksmith.swap_locks(Thread.current[:unique_jobs_previous_jid])
-          else
-            locked = locksmith.lock()
-          end
+          locked = locksmith.lock()
         elsif purpose == :perform
-          locked = locksmith.execute { lock_context.job_id }
+          locked = locksmith.execute { lock_context.lock_id }
         end
 
         CanvasSync::JobUniqueness.logger.debug { "Requested lock of #{key} for #{purpose} - (#{locked || 'Not Obtained!'})" }
@@ -98,7 +94,7 @@ module CanvasSync::JobUniqueness
       end
 
       def unlock()
-        CanvasSync::JobUniqueness.logger.debug { "Trying to unlock #{key} for JID #{lock_context.job_id}" }
+        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

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.22.0.beta7".freeze
+  VERSION = "0.22.0".freeze
 end

data/spec/job_batching/compat/sidekiq_spec.rb

@@ -74,7 +74,7 @@ RSpec.describe CanvasSync::JobBatches::Compat::Sidekiq do
       it 'assigns bid to msg' do
         msg = { 'jid' => jid }
         subject.call(nil, msg, nil) {}
-        expect(msg[:bid]).to eq(bid)
+        expect(msg['bid']).to eq(bid)
       end
     end
   end

data/spec/job_uniqueness/on_conflict/reschedule_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe CanvasSync::JobUniqueness::OnConflict::Reschedule do
 
   it "calls reenqueue" do
     expect(lock_context).to receive(:reenqueue) do |*args, **kwargs|
-      expect(Thread.current[:unique_jobs_previous_jid]).to be_present
+      expect(Thread.current[:unique_jobs_previous_context]).to be_present
     end
     on_conflict.call
   end
@@ -21,4 +21,43 @@ RSpec.describe CanvasSync::JobUniqueness::OnConflict::Reschedule do
     lock_context2.handle_lifecycle!(:enqueue) {}
     lock_context2.handle_lifecycle!(:perform) {}
   end
+
+  it "maintains a consistent lock_id" do
+    TestWorker.clear
+    TestWorker.unique_job_options.merge!({ strategy: :while_executing, on_conflict: :reschedule })
+
+    lock_context.handle_lifecycle!(:enqueue) {}
+    lock_context.handle_lifecycle!(:perform) {}
+
+    TestWorker.perform_async
+    j1 = TestWorker.jobs[0]
+    TestWorker.perform_one
+    j2 = TestWorker.jobs[0]
+
+    expect(j1).not_to eq(j2)
+    expect(j1['uniqueness_cache_data']['lid']).to be_present
+    expect(j1['uniqueness_cache_data']['lid']).to eq(j2['uniqueness_cache_data']['lid'])
+  end
+
+  it "unlocks after rescheduling" do
+    TestWorker.clear
+    TestWorker.unique_job_options.merge!({ strategy: :while_executing, on_conflict: :reschedule })
+
+    lock_context.handle_lifecycle!(:enqueue) {}
+    lock_context.handle_lifecycle!(:perform) {}
+
+    TestWorker.perform_async
+    expect(TestWorker.jobs.size).to eq(1)
+    TestWorker.perform_one
+    expect(TestWorker.jobs.size).to eq(1)
+
+    lock_context.lock_strategy.send(:unlock)
+    Sidekiq::Worker.drain_all
+    expect(TestWorker.jobs.size).to eq(0)
+
+    # Run another worker to validate that the lock was released
+    TestWorker.perform_async
+    TestWorker.perform_one
+    expect(TestWorker.jobs.size).to eq(0)
+  end
 end

data/spec/job_uniqueness/spec_helper.rb

@@ -1,10 +1,13 @@
 require_relative "../spec_helper"
 require "canvas_sync/job_uniqueness/job_uniqueness"
 
+require 'redis'
+Redis.silence_deprecations = true
+
 Dir[File.join(File.dirname(__FILE__), "./support/**/*.rb")].sort.each { |f| require f }
 
 Sidekiq::Testing.server_middleware do |chain|
-  chain.insert_before CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware, CanvasSync::JobUniqueness::Compat::Sidekiq::ServerMiddleware
+  chain.insert_after CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware, CanvasSync::JobUniqueness::Compat::Sidekiq::ServerMiddleware
 end
 
 RSpec.configure do |config|

data/spec/job_uniqueness/strategy/base_spec.rb

@@ -9,11 +9,11 @@ RSpec.describe CanvasSync::JobUniqueness::Strategy::Base do
 
   describe '#wrap_in_batch' do
     it 'does not wrap if re-enqueuing' do
-      Thread.current[:unique_jobs_previous_jid] = "j100"
+      Thread.current[:unique_jobs_previous_context] = context
       expect(CanvasSync::JobBatches::Batch).not_to receive(:new)
       strategy.send(:wrap_in_batch, &->{ })
     ensure
-      Thread.current[:unique_jobs_previous_jid] = nil
+      Thread.current[:unique_jobs_previous_context] = nil
     end
 
     context 'when the job fails' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canvas_sync
 version: !ruby/object:Gem::Version
-  version: 0.22.0.beta7
+  version: 0.22.0
 platform: ruby
 authors:
 - Instructure CustomDev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-25 00:00:00.000000000 Z
+date: 2024-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -870,9 +870,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.6
 signing_key: