canvas_sync 0.17.2 → 0.17.5.beta1

data/lib/canvas_sync/job_batches/redis_model.rb

@@ -0,0 +1,69 @@
+module CanvasSync
+  module JobBatches
+    module RedisModel
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def redis_attr(key, type = :string, read_only: true)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{key}=(value)
+              raise "#{key} is read-only once the batch has been started" if #{read_only.to_s} && (@initialized || @existing)
+              @#{key} = value
+              if :#{type} == :json
+                value = JSON.unparse(value)
+              end
+              persist_bid_attr('#{key}', value)
+            end
+
+            def #{key}
+              return @#{key} if defined?(@#{key})
+              if (@initialized || @existing)
+                value = read_bid_attr('#{key}')
+                if :#{type} == :bool
+                  value = value == 'true'
+                elsif :#{type} == :int
+                  value = value.to_i
+                elsif :#{type} == :float
+                  value = value.to_f
+                elsif :#{type} == :json
+                  value = JSON.parse(value)
+                elsif :#{type} == :symbol
+                  value = value&.to_sym
+                end
+                @#{key} = value
+              end
+            end
+          RUBY
+        end
+      end
+
+      def persist_bid_attr(attribute, value)
+        if @initialized || @existing
+          redis do |r|
+            r.multi do
+              r.hset(redis_key, attribute, value)
+              r.expire(redis_key, Batch::BID_EXPIRE_TTL)
+            end
+          end
+        else
+          @pending_attrs ||= {}
+          @pending_attrs[attribute] = value
+        end
+      end
+
+      def read_bid_attr(attribute)
+        redis do |r|
+          r.hget(redis_key, attribute)
+        end
+      end
+
+      def flush_pending_attrs
+        redis do |r|
+          r.mapped_hmset(redis_key, @pending_attrs)
+        end
+        @initialized = true
+        @pending_attrs = {}
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_batches/redis_script.rb

@@ -0,0 +1,163 @@
+require 'pathname'
+require 'digest/sha1'
+require 'erb'
+
+# Modified from https://github.com/Shopify/wolverine/blob/master/lib/wolverine/script.rb
+
+module CanvasSync
+  module JobBatches
+    # {RedisScript} represents a lua script in the filesystem. It loads the script
+    # from disk and handles talking to redis to execute it. Error handling
+    # is handled by {LuaError}.
+    class RedisScript
+
+      # Loads the script file from disk and calculates its +SHA1+ sum.
+      #
+      # @param file [Pathname] the full path to the indicated file
+      def initialize(file)
+        @file = Pathname.new(file)
+      end
+
+      # Passes the script and supplied arguments to redis for evaulation.
+      # It first attempts to use a script redis has already cached by using
+      # the +EVALSHA+ command, but falls back to providing the full script
+      # text via +EVAL+ if redis has not seen this script before. Future
+      # invocations will then use +EVALSHA+ without erroring.
+      #
+      # @param redis [Redis] the redis connection to run against
+      # @param args [*Objects] the arguments to the script
+      # @return [Object] the value passed back by redis after script execution
+      # @raise [LuaError] if the script failed to compile of encountered a
+      #   runtime error
+      def call(redis, *args)
+        t = Time.now
+        begin
+          redis.evalsha(digest, *args)
+        rescue => e
+          e.message =~ /NOSCRIPT/ ? redis.eval(content, *args) : raise
+        end
+      rescue => e
+        if LuaError.intercepts?(e)
+          raise LuaError.new(e, @file, content)
+        else
+          raise
+        end
+      end
+
+      def content
+        @content ||= load_lua(@file)
+      end
+
+      def digest
+        @digest ||= Digest::SHA1.hexdigest content
+      end
+
+      private
+
+      def script_path
+        Rails.root + 'app/redis_lua'
+      end
+
+      def relative_path
+        @path ||= @file.relative_path_from(script_path)
+      end
+
+      def load_lua(file)
+        TemplateContext.new(script_path).template(script_path + file)
+      end
+
+      class TemplateContext
+        def initialize(script_path)
+          @script_path = script_path
+        end
+
+        def template(pathname)
+          @partial_templates ||= {}
+          ERB.new(File.read(pathname)).result binding
+        end
+
+        # helper method to include a lua partial within another lua script
+        #
+        # @param relative_path [String] the relative path to the script from
+        #     `script_path`
+        def include_partial(relative_path)
+          unless @partial_templates.has_key? relative_path
+            @partial_templates[relative_path] = nil
+            template( Pathname.new("#{@script_path}/#{relative_path}") )
+          end
+        end
+      end
+
+      # Reformats errors raised by redis representing failures while executing
+      # a lua script. The default errors have confusing messages and backtraces,
+      # and a type of +RuntimeError+. This class improves the message and
+      # modifies the backtrace to include the lua script itself in a reasonable
+      # way.
+      class LuaError < StandardError
+        PATTERN = /ERR Error (compiling|running) script \(.*?\): .*?:(\d+): (.*)/
+        WOLVERINE_LIB_PATH = File.expand_path('../../', __FILE__)
+        CONTEXT_LINE_NUMBER = 2
+
+        attr_reader :error, :file, :content
+
+        # Is this error one that should be reformatted?
+        #
+        # @param error [StandardError] the original error raised by redis
+        # @return [Boolean] is this an error that should be reformatted?
+        def self.intercepts? error
+          error.message =~ PATTERN
+        end
+
+        # Initialize a new {LuaError} from an existing redis error, adjusting
+        # the message and backtrace in the process.
+        #
+        # @param error [StandardError] the original error raised by redis
+        # @param file [Pathname] full path to the lua file the error ocurred in
+        # @param content [String] lua file content the error ocurred in
+        def initialize error, file, content
+          @error = error
+          @file = file
+          @content = content
+
+          @error.message =~ PATTERN
+          _stage, line_number, message = $1, $2, $3
+          error_context = generate_error_context(content, line_number.to_i)
+
+          super "#{message}\n\n#{error_context}\n\n"
+          set_backtrace generate_backtrace file, line_number
+        end
+
+        private
+
+        def generate_error_context(content, line_number)
+          lines = content.lines.to_a
+          beginning_line_number = [1, line_number - CONTEXT_LINE_NUMBER].max
+          ending_line_number = [lines.count, line_number + CONTEXT_LINE_NUMBER].min
+          line_number_width = ending_line_number.to_s.length
+
+          (beginning_line_number..ending_line_number).map do |number|
+            indicator = number == line_number ? '=>' : '  '
+            formatted_number = "%#{line_number_width}d" % number
+            " #{indicator} #{formatted_number}: #{lines[number - 1]}"
+          end.join.chomp
+        end
+
+        def generate_backtrace(file, line_number)
+          pre_wolverine = backtrace_before_entering_wolverine(@error.backtrace)
+          index_of_first_wolverine_line = (@error.backtrace.size - pre_wolverine.size - 1)
+          pre_wolverine.unshift(@error.backtrace[index_of_first_wolverine_line])
+          pre_wolverine.unshift("#{file}:#{line_number}")
+          pre_wolverine
+        end
+
+        def backtrace_before_entering_wolverine(backtrace)
+          backtrace.reverse.take_while { |line| ! line_from_wolverine(line) }.reverse
+        end
+
+        def line_from_wolverine(line)
+          line.split(':').first.include?(WOLVERINE_LIB_PATH)
+        end
+      end
+    end
+  end
+end

data/lib/canvas_sync/job_batches/sidekiq.rb

@@ -15,11 +15,31 @@ module CanvasSync
           Thread.current[:batch]
         end
 
+        def batch_context
+          batch&.context || {}
+        end
+
         def valid_within_batch?
           batch.valid?
         end
       end
 
+      class SidekiqCallbackWorker
+        include ::Sidekiq::Worker
+        include WorkerExtension
+        include Batch::Callback::CallbackWorkerCommon
+
+        def self.enqueue_all(args, queue)
+          return if args.empty?
+
+          ::Sidekiq::Client.push_bulk(
+            'class' => self,
+            'args' => args,
+            'queue' => queue
+          )
+        end
+      end
+
       class ClientMiddleware
         def call(_worker, msg, _queue, _redis_pool = nil)
           if (batch = Thread.current[:batch]) && should_handle_batch?(msg)
@@ -29,7 +49,7 @@ module CanvasSync
         end
 
         def should_handle_batch?(msg)
-          return false if msg['class'] == 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper' && msg['wrapped'].constantize.is_a?(BatchAwareJob)
+          return false if msg['class'] == 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper' && msg['wrapped'].constantize < BatchAwareJob
           true
         end
       end
@@ -37,16 +57,21 @@ module CanvasSync
       class ServerMiddleware
         def call(_worker, msg, _queue)
           if (bid = msg['bid'])
+            prev_batch = Thread.current[:batch]
             begin
               Thread.current[:batch] = Batch.new(bid)
               yield
-              Thread.current[:batch] = nil
+              Thread.current[:batch].save_context_changes
               Batch.process_successful_job(bid, msg['jid'])
+            rescue SuccessfulFailure => err
+              Thread.current[:batch].save_context_changes
+              Batch.process_successful_job(@bid, msg['jid'])
+              raise ::Sidekiq::JobRetry::Handled # This ensure that Sidekiq logs the error, but doesn't attempt to Retry it
             rescue
               Batch.process_failed_job(bid, msg['jid'])
               raise
             ensure
-              Thread.current[:batch] = nil
+              Thread.current[:batch] = prev_batch
             end
           else
             yield
@@ -92,7 +117,10 @@ module CanvasSync
         # This alias helps apartment-sidekiq set itself up correctly
         ::Sidekiq::Batch.const_set(:Server, CanvasSync::JobBatches::Sidekiq::ServerMiddleware)
         ::Sidekiq::Worker.send(:include, JobBatches::Sidekiq::WorkerExtension)
+        Batch::Callback.worker_class = SidekiqCallbackWorker
       end
     end
   end
 end
+
+require_relative 'sidekiq/web'

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

@@ -0,0 +1,114 @@
+
+begin
+  require "sidekiq/web"
+rescue LoadError
+  # client-only usage
+end
+
+require_relative "web/helpers"
+
+module CanvasSync::JobBatches::Sidekiq
+  module Web
+    def self.registered(app) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      app.helpers do
+        include Web::Helpers
+      end
+
+      app.get "/batches" do
+        @count = (params['count'] || 25).to_i
+        @current_page, @total_size, @batches = page('batches', params['page'], @count)
+        @batches = @batches.map {|b, score| CanvasSync::JobBatches::Batch.new(b) }
+
+        erb(get_template(:batches))
+      end
+
+      app.get "/batches/:bid" do
+        @bid = params[:bid]
+        @batch = CanvasSync::JobBatches::Batch.new(@bid)
+
+        @count = (params['count'] || 25).to_i
+        @current_batches_page, @total_batches_size, @sub_batches = page("BID-#{@batch.bid}-bids", params['batch_page'], @count)
+        @sub_batches = @sub_batches.map {|b, score| CanvasSync::JobBatches::Batch.new(b) }
+
+        @current_jobs_page, @total_jobs_size, @jobs = page("BID-#{@batch.bid}-jids", params['job_page'], @count)
+        @jobs = @jobs.map {|jid, score| jid }
+
+        erb(get_template(:batch))
+      end
+
+      app.post "/batches/all" do
+        if params['delete']
+          drain_zset('batches') do |batches|
+            batches.each do |bid|
+              CanvasSync::JobBatches::Batch.cleanup_redis(bid)
+            end
+          end
+        end
+
+        redirect "#{root_path}batches"
+      end
+
+      app.post "/batches/:bid" do
+        @bid = params[:bid]
+        @batch = CanvasSync::JobBatches::Batch.new(@bid)
+
+        if params['delete']
+          CanvasSync::JobBatches::Batch.delete_prematurely!(@bid)
+        end
+
+        redirect_with_query("#{root_path}batches")
+      end
+
+      # =============== POOLS =============== #
+
+      app.get "/pools" do
+        @count = (params['count'] || 25).to_i
+        @current_page, @total_size, @pools = page('pools', params['page'], @count)
+        @pools = @pools.map {|b, score| CanvasSync::JobBatches::Pool.new(b) }
+
+        erb(get_template(:pools))
+      end
+
+      app.get "/pools/:pid" do
+        @pid = params[:pid]
+        @pool = CanvasSync::JobBatches::Pool.new(@pid)
+
+        @count = (params['count'] || 25).to_i
+        @current_jobs_page, @total_jobs_size, @jobs = page("POOLID-#{@pool.pid}-jobs", params['job_page'], @count)
+        @jobs = @jobs.map {|desc, score=nil| JSON.parse(desc)[0] }
+
+        erb(get_template(:pool))
+      end
+
+      app.post "/pools/all" do
+        if params['delete']
+          drain_zset('pools') do |pools|
+            pools.each do |pid|
+              CanvasSync::JobBatches::Pool.from_pid(pid).cleanup_redis
+            end
+          end
+        end
+
+        redirect "#{root_path}pools"
+      end
+
+      app.post "/pools/:pid" do
+        @pid = params[:pid]
+        @pool = CanvasSync::JobBatches::Pool.from_pid(@pid)
+
+        if params['delete']
+          @pool.cleanup_redis
+        end
+
+        redirect_with_query("#{root_path}pools")
+      end
+    end
+  end
+end
+
+if defined?(::Sidekiq::Web)
+  ::Sidekiq::Web.register CanvasSync::JobBatches::Sidekiq::Web
+  ::Sidekiq::Web.tabs["Batches"] = "batches"
+  ::Sidekiq::Web.tabs["Pools"] = "pools"
+  ::Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), "locales")
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CanvasSync::JobBatches::Sidekiq
+  module Web
+    module Helpers
+      VIEW_PATH    = File.expand_path("../web/views", __dir__)
+
+      module_function
+
+      def get_template(name)
+        File.open(File.join(VIEW_PATH, "#{name}.erb")).read
+      end
+
+      def drain_zset(key)
+        items, _ = Sidekiq.redis do |r|
+          r.multi do
+            r.zrange(key, 0, -1)
+            r.zremrangebyrank(key, 0, -1)
+          end
+        end
+        yield items
+      end
+
+      def safe_relative_time(time)
+        time = parse_time(time)
+        relative_time(time)
+      end
+
+      def parse_time(time)
+        case time
+        when Time
+          time
+        when Integer, Float
+          Time.at(time)
+        else
+          Time.parse(time.to_s)
+        end
+      end
+    end
+  end
+end