canvas_sync 0.17.23.beta8 → 0.17.27.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bed2b1c5be095c602aca19968b0155ff48026a1c5136cb65b5f31e5decbcb40
-  data.tar.gz: ae6112e2694f0118a43619cf3de053d7eee7ff1873e0dface27b0b3558727132
+  metadata.gz: 413b8669b85123f239a5917982347c9cb90bd56229c42e11a92ce8bc619171f5
+  data.tar.gz: b99de51cad35d7c894ed54ab8910cbe6d0b594cadab814683396350dbbc4b95a
 SHA512:
-  metadata.gz: 6261b328341a102a9ea6c5f91315444604a3556ccbc040fb38122d18db557bd2c5d2cbc7e5b3c74a52d0d48eb0315793232a3cdff0be21964af1c2617d4ae22d
-  data.tar.gz: 458a2c7b422c2a769ec961bd75bd8f43e5dde63c9231bbd4aab6e2a400ec79ee74d9dc12d93cdbd2cc26ef69bb3611972b84956f55cfc2e2a89a4fc22ec2eafb
+  metadata.gz: e78f116e14b49c88fb04d95b33623c99a31c6a09735491361b0c287a2d48fff2bf061710f5715854b8601b7eb0c1aa3de9bfd93d87d08f71c260eac830a08fce
+  data.tar.gz: 361de97175217d570b0e60f4b3737a38d685ea4404d568ad35df281f495f08288284d734a02e2f8c5809c2a81e3863bb3030a217ce5d5bab71ca60d889eff31c

data/lib/canvas_sync/importers/bulk_importer.rb

@@ -65,7 +65,7 @@ module CanvasSync
         }
 
         row_buffer = nil
-        if defined?(User) && klass == User && csv_column_names.include?(:user_id)
+        if defined?(User) && klass == User && csv_column_names.include?('user_id')
           row_buffer = UserRowBuffer.new(&row_buffer_out)
         else
           row_buffer = NullRowBuffer.new(&row_buffer_out)

data/lib/canvas_sync/job_batches/batch.rb

@@ -19,6 +19,8 @@ require_relative "./chain_builder"
 
 module CanvasSync
   module JobBatches
+    CURRENT_BATCH_THREAD_KEY = :job_batches_batch
+
     class Batch
       include RedisModel
 
@@ -89,7 +91,7 @@ module CanvasSync
         raise NoBlockGivenError unless block_given?
 
         if !@existing && !@initialized
-          parent_bid = Thread.current[:batch]&.bid
+          parent_bid = Thread.current[CURRENT_BATCH_THREAD_KEY]&.bid
 
           redis.multi do |r|
             r.hset(@bidkey, "parent_bid", parent_bid.to_s) if parent_bid
@@ -111,11 +113,11 @@ module CanvasSync
         end
 
         begin
-          parent = Thread.current[:batch]
-          Thread.current[:batch] = self
+          parent = Thread.current[CURRENT_BATCH_THREAD_KEY]
+          Thread.current[CURRENT_BATCH_THREAD_KEY] = self
           yield
         ensure
-          Thread.current[:batch] = parent
+          Thread.current[CURRENT_BATCH_THREAD_KEY] = parent
         end
 
         nil
@@ -179,11 +181,11 @@ module CanvasSync
 
       def self.with_batch(batch)
         batch = self.new(batch) if batch.is_a?(String)
-        parent = Thread.current[:batch]
-        Thread.current[:batch] = batch
+        parent = Thread.current[CURRENT_BATCH_THREAD_KEY]
+        Thread.current[CURRENT_BATCH_THREAD_KEY] = batch
         yield
       ensure
-        Thread.current[:batch] = parent
+        Thread.current[CURRENT_BATCH_THREAD_KEY] = parent
       end
 
       # Any Batches or Jobs created in the given block won't be assocaiated to the current batch
@@ -228,6 +230,14 @@ module CanvasSync
       end
 
       class << self
+        def current
+          Thread.current[CURRENT_BATCH_THREAD_KEY]
+        end
+
+        def current_context
+          current&.context || {}
+        end
+
         def process_failed_job(bid, jid)
           _, pending, failed, children, complete, parent_bid = redis do |r|
             return unless r.exists?("BID-#{bid}")

data/lib/canvas_sync/job_batches/batch_aware_job.rb

@@ -6,17 +6,17 @@ module CanvasSync
       included do
         around_perform do |job, block|
           if (@bid) # This _must_ be @bid - not just bid
-            prev_batch = Thread.current[:batch]
+            prev_batch = Thread.current[CURRENT_BATCH_THREAD_KEY]
             begin
-              Thread.current[:batch] = Batch.new(@bid)
+              Thread.current[CURRENT_BATCH_THREAD_KEY] = Batch.new(@bid)
               block.call
-              Thread.current[:batch].save_context_changes
+              Thread.current[CURRENT_BATCH_THREAD_KEY].save_context_changes
               Batch.process_successful_job(@bid, job_id)
             rescue
               Batch.process_failed_job(@bid, job_id)
               raise
             ensure
-              Thread.current[:batch] = prev_batch
+              Thread.current[CURRENT_BATCH_THREAD_KEY] = prev_batch
             end
           else
             block.call
@@ -24,7 +24,7 @@ module CanvasSync
         end
 
         around_enqueue do |job, block|
-          if (batch = Thread.current[:batch])
+          if (batch = Thread.current[CURRENT_BATCH_THREAD_KEY])
             @bid = batch.bid
             batch.increment_job_queue(job_id) if @bid
           end
@@ -33,11 +33,11 @@ module CanvasSync
       end
 
       def bid
-        @bid || Thread.current[:batch]&.bid
+        @bid || Thread.current[CURRENT_BATCH_THREAD_KEY]&.bid
       end
 
       def batch
-        Thread.current[:batch]
+        Thread.current[CURRENT_BATCH_THREAD_KEY]
       end
 
       def batch_context

data/lib/canvas_sync/job_batches/chain_builder.rb

@@ -37,16 +37,29 @@ module CanvasSync
         insert_at(-1, new_job)
       end
 
-      def insert_at(position, new_jobs)
+      def insert_at(position, new_jobs, *args, &blk)
         chain = self.class.get_chain_parameter(base_job)
+        if new_jobs.is_a?(Class) || new_jobs.is_a?(String)
+          new_jobs = build_job_hash(new_jobs, *args, &blk)
+        elsif args.length > 0
+          raise "Unexpected number of arguments"
+        end
         new_jobs = [new_jobs] unless new_jobs.is_a?(Array)
         chain.insert(position, *new_jobs)
       end
 
-      def insert(new_jobs, **kwargs)
-        invalid_params = kwargs.keys - VALID_PLACEMENT_PARAMETERS
-        raise "Invalid placement parameters: #{invalid_params.map(&:to_s).join(', ')}" if invalid_params.present?
-        raise "At most one placement parameter may be provided" if kwargs.values.compact.length > 1
+      def insert(new_jobs, *args, **kwargs, &blk)
+        if new_jobs.is_a?(Class) || new_jobs.is_a?(String)
+          job_kwargs = kwargs.except(*VALID_PLACEMENT_PARAMETERS)
+          args << job_kwargs if job_kwargs.present?
+          new_jobs = build_job_hash(new_jobs, *args, &blk)
+          kwargs = kwargs.slice(*VALID_PLACEMENT_PARAMETERS)
+        else
+          invalid_params = kwargs.keys - VALID_PLACEMENT_PARAMETERS
+          raise "Invalid placement parameters: #{invalid_params.map(&:to_s).join(', ')}" if invalid_params.present?
+          raise "At most one placement parameter may be provided" if kwargs.values.compact.length > 1
+          raise "Unexpected number of arguments" if args.length > 0
+        end
 
         new_jobs = [new_jobs] unless new_jobs.is_a?(Array)
 
@@ -90,7 +103,6 @@ module CanvasSync
         raise "Found multiple \"#{sub_type}\" jobs in the chain" if matching_jobs.count > 1
         return nil if matching_jobs.count == 0
 
-
         job = matching_jobs[0][0]
         job = self.class.new(job) unless job.is_a?(ChainBuilder)
         job
@@ -116,8 +128,22 @@ module CanvasSync
         end
       end
 
+      def apply_block(&blk)
+        return unless blk.present?
+        instance_exec(&blk)
+      end
+
       private
 
+      def build_job_hash(job, *params, &blk)
+        hsh = {
+          job: job,
+          parameters: params,
+        }
+        self.class.new(hsh).apply_block(&blk) if blk.present?
+        hsh
+      end
+
       def find_matching_jobs(search_job, parent_job = self.base_job)
         return to_enum(:find_matching_jobs, search_job, parent_job) unless block_given?
 
@@ -150,6 +176,13 @@ module CanvasSync
       end
 
       class << self
+        def build(job, *args, &blk)
+          new(job).tap do |ch|
+            ch[:parameters] = args
+            ch.apply_block(&blk)
+          end
+        end
+
         def _job_type_definitions
           @job_type_definitions ||= {}
         end

data/lib/canvas_sync/job_batches/context_hash.rb

@@ -95,6 +95,10 @@ module CanvasSync
         @flattened = flattened.with_indifferent_access
       end
 
+      def to_h
+        flatten
+      end
+
       private
 
       def get_parent_hash(bid)

data/lib/canvas_sync/job_batches/jobs/concurrent_batch_job.rb

@@ -3,16 +3,19 @@ require_relative './base_job'
 module CanvasSync
   module JobBatches
     class ConcurrentBatchJob < BaseJob
+      def self.make_batch(sub_jobs, context: nil, &blk)
+        ManagedBatchJob.make_batch(
+          sub_jobs,
+          ordered: false,
+          concurrency: true,
+          context: context,
+          desc_prefix: 'ConcurrentBatchJob',
+          &blk
+        )
+      end
+
       def perform(sub_jobs, context: nil)
-        Batch.new.tap do |b|
-          b.description = "Concurrent Batch Root"
-          b.context = context
-          b.jobs do
-            sub_jobs.each do |j|
-              ChainBuilder.enqueue_job(j)
-            end
-          end
-        end
+        self.class.make_batch(sub_jobs, context: context)
       end
     end
   end

data/lib/canvas_sync/job_batches/jobs/managed_batch_job.rb

@@ -3,8 +3,8 @@ require_relative './base_job'
 module CanvasSync
   module JobBatches
     class ManagedBatchJob < BaseJob
-      def perform(sub_jobs, context: nil, ordered: true, concurrency: nil)
-        man_batch_id = SecureRandom.urlsafe_base64(10)
+      def self.make_batch(sub_jobs, ordered: true, concurrency: nil, context: nil, desc_prefix: nil, &blk)
+        desc_prefix ||= ''
 
         if concurrency == 0 || concurrency == nil || concurrency == true
           concurrency = sub_jobs.count
@@ -14,38 +14,60 @@ module CanvasSync
 
         root_batch = Batch.new
 
-        Batch.redis do |r|
-          r.multi do
-            r.hset("MNGBID-#{man_batch_id}", "root_bid", root_batch.bid)
-            r.hset("MNGBID-#{man_batch_id}", "ordered", ordered)
-            r.hset("MNGBID-#{man_batch_id}", "concurrency", concurrency)
-            r.expire("MNGBID-#{man_batch_id}", Batch::BID_EXPIRE_TTL)
-
-            mapped_sub_jobs = sub_jobs.each_with_index.map do |j, i|
-              j['_mngbid_index_'] = i # This allows duplicate jobs when a Redis Set is used
-              j = ActiveJob::Arguments.serialize([j])
-              JSON.unparse(j)
-            end
-            if ordered
-              r.rpush("MNGBID-#{man_batch_id}-jobs", mapped_sub_jobs)
-            else
-              r.sadd("MNGBID-#{man_batch_id}-jobs", mapped_sub_jobs)
+        if concurrency < sub_jobs.count
+          man_batch_id = SecureRandom.urlsafe_base64(10)
+
+          Batch.redis do |r|
+            r.multi do
+              r.hset("MNGBID-#{man_batch_id}", "root_bid", root_batch.bid)
+              r.hset("MNGBID-#{man_batch_id}", "ordered", ordered)
+              r.hset("MNGBID-#{man_batch_id}", "concurrency", concurrency)
+              r.expire("MNGBID-#{man_batch_id}", Batch::BID_EXPIRE_TTL)
+
+              mapped_sub_jobs = sub_jobs.each_with_index.map do |j, i|
+                j['_mngbid_index_'] = i # This allows duplicate jobs when a Redis Set is used
+                j = ActiveJob::Arguments.serialize([j])
+                JSON.unparse(j)
+              end
+              if ordered
+                r.rpush("MNGBID-#{man_batch_id}-jobs", mapped_sub_jobs)
+              else
+                r.sadd("MNGBID-#{man_batch_id}-jobs", mapped_sub_jobs)
+              end
+              r.expire("MNGBID-#{man_batch_id}-jobs", Batch::BID_EXPIRE_TTL)
             end
-            r.expire("MNGBID-#{man_batch_id}-jobs", Batch::BID_EXPIRE_TTL)
           end
+
+          root_batch.allow_context_changes = (concurrency == 1)
+          root_batch.on(:success, "#{to_s}.cleanup_redis", managed_batch_id: man_batch_id)
+
+          desc_prefix = "MGD(#{man_batch_id}): #{desc_prefix}"
         end
 
-        root_batch.description = "Managed Batch Root (#{man_batch_id})"
-        root_batch.allow_context_changes = (concurrency == 1)
         root_batch.context = context
-        root_batch.on(:success, "#{self.class.to_s}.cleanup_redis", managed_batch_id: man_batch_id)
-        root_batch.jobs {}
 
-        concurrency.times do
-          self.class.perform_next_sequence_job(man_batch_id)
+        blk.call(ManagedBatchProxy.new(root_batch)) if blk.present?
+
+        root_batch.description = "#{desc_prefix}: #{root_batch.description || 'Root'}"
+
+        if concurrency < sub_jobs.count
+          root_batch.jobs {}
+          concurrency.times do
+            perform_next_sequence_job(man_batch_id)
+          end
+        else
+          root_batch.jobs do
+            sub_jobs.each do |j|
+              ChainBuilder.enqueue_job(j)
+            end
+          end
         end
       end
 
+      def perform(sub_jobs, context: nil, ordered: true, concurrency: nil)
+        self.class.make_batch(sub_jobs, ordered: ordered, concurrency: concurrency, context: context)
+      end
+
       def self.cleanup_redis(status, options)
         man_batch_id = options['managed_batch_id']
         Batch.redis do |r|
@@ -94,6 +116,21 @@ module CanvasSync
           end
         end
       end
+
+      class ManagedBatchProxy
+        def initialize(real_batch)
+          @real_batch = real_batch
+        end
+
+        delegate_missing_to :real_batch
+
+        def jobs
+          raise "Managed Batches do not support calling .jobs directly!"
+        end
+
+        private
+        attr_reader :real_batch
+      end
     end
   end
 end

data/lib/canvas_sync/job_batches/jobs/serial_batch_job.rb

@@ -3,14 +3,20 @@ require_relative './base_job'
 module CanvasSync
   module JobBatches
     class SerialBatchJob < BaseJob
-      def perform(sub_jobs, context: nil)
-        ManagedBatchJob.new.perform(
+      def self.make_batch(sub_jobs, context: nil, &blk)
+        ManagedBatchJob.make_batch(
           sub_jobs,
-          context: context,
           ordered: true,
           concurrency: false,
+          context: context,
+          desc_prefix: 'SerialBatchJob',
+          &blk
         )
       end
+
+      def perform(sub_jobs, context: nil)
+        self.class.make_batch(sub_jobs, context: context)
+      end
     end
   end
 end

data/lib/canvas_sync/job_batches/sidekiq/web/helpers.rb

@@ -12,7 +12,7 @@ module CanvasSync::JobBatches::Sidekiq
       end
 
       def drain_zset(key)
-        items, _ = Sidekiq.redis do |r|
+        items, _ = Batch.redis do |r|
           r.multi do
             r.zrange(key, 0, -1)
             r.zremrangebyrank(key, 0, -1)

data/lib/canvas_sync/job_batches/sidekiq.rb

@@ -8,11 +8,11 @@ module CanvasSync
     module Sidekiq
       module WorkerExtension
         def bid
-          Thread.current[:batch].bid
+          Thread.current[CURRENT_BATCH_THREAD_KEY].bid
         end
 
         def batch
-          Thread.current[:batch]
+          Thread.current[CURRENT_BATCH_THREAD_KEY]
         end
 
         def batch_context
@@ -42,7 +42,7 @@ module CanvasSync
 
       class ClientMiddleware
         def call(_worker, msg, _queue, _redis_pool = nil)
-          if (batch = Thread.current[:batch]) && should_handle_batch?(msg)
+          if (batch = Thread.current[CURRENT_BATCH_THREAD_KEY]) && should_handle_batch?(msg)
             batch.increment_job_queue(msg['jid']) if (msg[:bid] = batch.bid)
           end
           yield
@@ -57,17 +57,17 @@ module CanvasSync
       class ServerMiddleware
         def call(_worker, msg, _queue)
           if (bid = msg['bid'])
-            prev_batch = Thread.current[:batch]
+            prev_batch = Thread.current[CURRENT_BATCH_THREAD_KEY]
             begin
-              Thread.current[:batch] = Batch.new(bid)
+              Thread.current[CURRENT_BATCH_THREAD_KEY] = Batch.new(bid)
               yield
-              Thread.current[:batch].save_context_changes
+              Thread.current[CURRENT_BATCH_THREAD_KEY].save_context_changes
               Batch.process_successful_job(bid, msg['jid'])
             rescue
               Batch.process_failed_job(bid, msg['jid'])
               raise
             ensure
-              Thread.current[:batch] = prev_batch
+              Thread.current[CURRENT_BATCH_THREAD_KEY] = prev_batch
             end
           else
             yield

data/lib/canvas_sync/jobs/begin_sync_chain_job.rb

@@ -14,6 +14,12 @@ module CanvasSync
           globals[:updated_after] = last_batch&.started_at&.iso8601
         end
 
+        # Refuse to run syncs of the same genre if there is a running full sync
+        if last_full_sync_record&.status == 'processing' && last_full_sync > 12.hours.ago
+          Rails.logger.warn("Attempted to start a '#{genre}' sync while a full-sync is still processing.")
+          return
+        end
+
         if should_full_sync?(globals[:full_sync_every])
           globals[:updated_after] = nil
         end
@@ -25,6 +31,10 @@ module CanvasSync
           status: 'processing',
         )
 
+        globals[:batch_genre] = genre
+        globals[:batch_start_time] = sync_batch.started_at.iso8601
+        globals[:sync_batch_id] = sync_batch.id
+
         JobBatches::Batch.new.tap do |b|
           b.description = "CanvasSync Root Batch (SyncBatch##{sync_batch.id})"
           b.on(:complete, "#{self.class.to_s}.batch_completed", sync_batch_id: sync_batch.id)
@@ -62,7 +72,7 @@ module CanvasSync
       end
 
       def last_full_sync_record
-        @last_full_sync_record ||= SyncBatch.where(status: 'completed', full_sync: true, batch_genre: genre).last
+        @last_full_sync_record ||= SyncBatch.where(status: ['completed', 'processing'], full_sync: true, batch_genre: genre).last
       end
 
       def last_full_sync

data/lib/canvas_sync/jobs/sync_terms_job.rb

@@ -23,23 +23,7 @@ module CanvasSync
           end
         end
 
-        if (jobs = options[:sub_jobs]).present?
-          context = options[:context] || {}
-          if options[:term_scope]
-            Term.send(options[:term_scope]).find_each.map do |term|
-              local_context = context.merge(canvas_term_id: get_term_id(term))
-              JobBatches::ConcurrentBatchJob.perform_now(jobs, context: local_context)
-            end
-          else
-            JobBatches::ConcurrentBatchJob.perform_now(jobs, context: context)
-          end
-        end
-      end
-
-      protected
-
-      def get_term_id(term)
-        term.try(:canvas_id) || term.canvas_term_id
+        TermBatchesJob.perform_now(options)
       end
     end
   end

data/lib/canvas_sync/jobs/term_batches_job.rb

@@ -0,0 +1,50 @@
+module CanvasSync
+  module Jobs
+    class TermBatchesJob < CanvasSync::Job
+      def perform(options)
+        if (jobs = options[:sub_jobs]).present?
+          context = options[:context] || {}
+          if options[:term_scope]
+            Term.send(options[:term_scope]).find_each.map do |term|
+              term_id = get_term_id(term)
+              local_context = context.merge(canvas_term_id: term_id)
+
+              # Override the delta-syncing date if:
+              # 1. the Term hasn't been synced before or
+              # 2. the Term underwent a period of not syncing
+              term_last_sync = CanvasSync.redis.get(self.class.last_sync_key(term_id))
+              if batch_context[:updated_after]
+                if !term_last_sync.present? || batch_context[:updated_after] > term_last_sync
+                  local_context[:updated_after] = term_last_sync.presence
+                end
+              end
+
+              JobBatches::ManagedBatchJob.make_batch(jobs, ordered: false, concurrency: true) do |b|
+                b.description = "TermBatchJob(#{term.canvas_id}) Root"
+                b.context = local_context
+                b.on(:success, "#{self.class.to_s}.batch_finished") unless options[:mark_synced] == false
+              end
+            end
+          else
+            JobBatches::ConcurrentBatchJob.make_batch(jobs, context: context)
+          end
+        end
+      end
+
+      def self.batch_finished(status, opts)
+        ctx = JobBatches::Batch.current_context
+        term_id = ctx[:canvas_term_id]
+        CanvasSync.redis.set(last_sync_key(term_id), ctx[:batch_start_time])
+      end
+
+      def self.last_sync_key(term_id)
+        ctx = JobBatches::Batch.current_context
+        "#{CanvasSync.redis_prefix}:#{ctx[:batch_genre]}:#{term_id}:last_sync"
+      end
+
+      def get_term_id(term)
+        term.try(:canvas_id) || term.canvas_term_id
+      end
+    end
+  end
+end

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.17.23.beta8".freeze
+  VERSION = "0.17.27.beta1".freeze
 end

data/lib/canvas_sync.rb

@@ -80,6 +80,7 @@ module CanvasSync
   ].freeze
 
   JobBatches::ChainBuilder.register_chain_job(CanvasSync::Jobs::SyncTermsJob, :sub_jobs)
+  JobBatches::ChainBuilder.register_chain_job(CanvasSync::Jobs::TermBatchesJob, :sub_jobs)
   JobBatches::ChainBuilder.register_chain_job(CanvasSync::Jobs::BeginSyncChainJob, 0)
 
   class << self
@@ -130,12 +131,8 @@ module CanvasSync
       models,
       term_scope: nil,
       term_scoped_models: DEFAULT_TERM_SCOPE_MODELS,
-      legacy_support: false,
-      account_id: nil,
-      updated_after: nil,
-      full_sync_every: nil,
-      batch_genre: nil,
-      options: {}
+      options: {},
+      **kwargs
     ) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
       return unless models.present?
       models.map! &:to_s
@@ -155,7 +152,7 @@ module CanvasSync
         context_module_items: CanvasSync::Jobs::SyncContextModuleItemsJob,
       }.with_indifferent_access
 
-      root_chain = JobBatches::ChainBuilder.new(CanvasSync::Jobs::BeginSyncChainJob)
+      root_chain = base_canvas_sync_chain(**kwargs, globals: options[:global] || kwargs[:globals])
       concurrent_root_chain = JobBatches::ChainBuilder.new(JobBatches::ConcurrentBatchJob)
       root_chain << concurrent_root_chain
       current_chain = concurrent_root_chain
@@ -211,6 +208,20 @@ module CanvasSync
       # Wrap it all up
       ###############################
 
+      root_chain
+    end
+
+    def base_canvas_sync_chain(
+      legacy_support: false, # Import records 1 by 1 instead of with bulk upserts
+      account_id: nil, # legacy/non PandaPal apps
+      updated_after: nil,
+      full_sync_every: nil,
+      batch_genre: nil,
+      globals: {},
+      &blk
+    )
+      root_chain = JobBatches::ChainBuilder.new(CanvasSync::Jobs::BeginSyncChainJob)
+
       global_options = {
         legacy_support: legacy_support,
         updated_after: updated_after,
@@ -218,10 +229,12 @@ module CanvasSync
         batch_genre: batch_genre,
       }
       global_options[:account_id] = account_id if account_id.present?
-      global_options.merge!(options[:global]) if options[:global].present?
+      global_options.merge!(globals) if globals
 
       root_chain.params[1] = global_options
 
+      root_chain.apply_block(&blk)
+
       root_chain
     end
 
@@ -307,5 +320,15 @@ module CanvasSync
       return if invalid.empty?
       raise "Invalid live event(s) specified: #{invalid.join(', ')}. Only #{SUPPORTED_LIVE_EVENTS.join(', ')} are supported."
     end
+
+    def redis(*args, &blk)
+      JobBatches::Batch.redis(*args, &blk)
+    end
+
+    def redis_prefix
+      pfx = "cs"
+      pfx = "#{Apartment::Tenant.current}:#{pfx}" if defined?(Apartment)
+      pfx
+    end
   end
 end