canvas_sync 0.10.5 → 0.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1cc1054e379b920c5acee75583700fdffaae885a4cea48df1d8de97ed70c02e
-  data.tar.gz: 83741af3ec47ee4b72db5e4a354a8713c002fc6930cfe352a80c5f57a36dba4a
+  metadata.gz: 85296cf62f289592ac9f7a9eae904ab8f4f95fa4e721c0746fb12b47e8f3679c
+  data.tar.gz: 4e766399a5b695d589584454e4a0697480131bde11599887b13371d10b03c09d
 SHA512:
-  metadata.gz: dc7ad8ad007bda5edb7cf980b767113075a4be84cf1c2a228cf8287f8aba2c587bb170574a0168216b0bcaa19c8c395224d37249954b23203a50df234e5d9599
-  data.tar.gz: be307cba8401af1b7697d4c843d260e290517aca0f3d3866a72db6f327f6d3726df894a5306f2b39f2e10eacbb22465a45b5b8398c810304d53145ef59a17ad7
+  metadata.gz: 543d433fcf85fcae47fa4937c796d7efe59954e39d38c9bdae63e03e4c0bfef1613483c4d2e2994fd3e481c9da1b7f5ea3e7ab8719f43103d74a4caa128baa41
+  data.tar.gz: bbab77a8e574656e3030e643460694e60147f740095d6d37630d5ae6770c2eb60d0502e2a83db7cfce253035804084662e2255dd5154ed4c595c6589310e13b2

data/README.md

@@ -398,6 +398,38 @@ Available config options (if you add more, please update this!):
 
 * `config.classes_to_only_log_errors_on` - use this if you are utilizing the `CanvasSync::JobLog` table, but want certain classes to only persist in the `job_logs` table if an error is encountered. This is useful if you've got a very frequently used job that's filling up your database, and only really care about tracking failures.
 
+## Handling Job errors
+
+If you need custom handling for when a CanvasSync Job fails, you can add an `:on_failure` option to you Job Chain's `:global_options`.
+The value should be a String in the following format: `ModuleOrClass::AnotherModuleOrClass.class_method`.
+The given method of the given class will be called when an error occurs.
+The handling method should accept 2 arguments: `[error, **options]`
+
+The current parameters provided in `**options` are:
+- `job_chain`
+- `job_log`
+
+Example:
+```ruby
+class CanvasSyncStarterWorker
+  def perform
+    job_chain = CanvasSync.default_provisioning_report_chain(
+      %w[desired models],
+      options: {
+        global: {
+          on_failure: 'CanvasSyncStarterWorker.handle_canvas_sync_error',
+        }
+      }
+    )
+    CanvasSync.invoke_next(job_chain)
+  end
+
+  def self.handle_canvas_sync_error(error, **options)
+    # Do Stuff
+  end
+end
+```
+
 ## Upgrading
 
 Re-running the generator when there's been a gem change will give you several choices if it detects conflicts between your local files and the updated generators. You can either view a diff or allow the generator to overwrite your local file. In most cases you may just want to add the code from the diff yourself so as not to break any of your customizations.

data/lib/canvas_sync.rb

@@ -101,12 +101,16 @@ module CanvasSync
       invoke_next(job_chain)
     end
 
+    def duplicate_chain(job_chain)
+      Marshal.load(Marshal.dump(job_chain))
+    end
+
     # Invokes the next job in a chain of jobs.
     #
     # This should typically be called automatically by the gem where necessary.
     #
     # @param job_chain [Hash] A chain of jobs to execute
-    def invoke_next(job_chain)
+    def invoke_next(job_chain, extra_options: {})
       return if job_chain[:jobs].empty?
 
       # Make sure all job classes are serialized as strings
@@ -116,7 +120,9 @@ module CanvasSync
       jobs = duped_job_chain[:jobs]
       next_job = jobs.shift
       next_job_class = next_job[:job].constantize
-      next_job_class.perform_later(duped_job_chain, next_job[:options])
+      next_options = next_job[:options] || {}
+      next_options.merge!(extra_options)
+      next_job_class.perform_later(duped_job_chain, next_options)
     end
 
     def fork(job_log, job_chain, keys: [])
@@ -125,9 +131,10 @@ module CanvasSync
       duped_job_chain[:global_options][:fork_keys] ||= []
       duped_job_chain[:global_options][:fork_path] << job_log.job_id
       duped_job_chain[:global_options][:fork_keys] << ['canvas_term_id']
+      duped_job_chain[:global_options][:on_failure] ||= 'CanvasSync::Jobs::ForkGather.handle_branch_error'
       sub_items = yield duped_job_chain
-      sub_count =  sub_items.respond_to?(:count) ? sub_items.count : sub_items
-      job_log.update!(fork_count: sub_count)
+      sub_count = sub_items.respond_to?(:count) ? sub_items.count : sub_items
+      job_log.fork_count = sub_count
       sub_items
     end
 
@@ -172,7 +179,7 @@ module CanvasSync
       return unless models.present?
       models.map! &:to_s
       term_scope = term_scope.to_s if term_scope
-      options = options.with_indifferent_access
+      options = options.deep_symbolize_keys!
 
       model_job_map = {
         terms: CanvasSync::Jobs::SyncTermsJob,
@@ -190,7 +197,7 @@ module CanvasSync
       jobs = []
       try_add_model_job = ->(model) {
         return unless models.include?(model)
-        jobs.push(job: model_job_map[model].to_s, options: options[model] || {})
+        jobs.push(job: model_job_map[model].to_s, options: options[model.to_sym] || {})
         models -= [model]
       }
 
@@ -223,14 +230,19 @@ module CanvasSync
       post_provisioning_jobs = jobs
 
       jobs = pre_provisioning_jobs
-      jobs += Array.wrap({
-        job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s,
-        options: { term_scope: term_scope, models: models },
-      }) if models.present?
+      if models.present?
+        provisioning_job = {
+          job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s,
+          options: { term_scope: term_scope, models: models },
+        }
+        provisioning_job[:options].merge!(options[:provisioning]) if options[:provisioning].present?
+        jobs += Array.wrap(provisioning_job)
+      end
       jobs += post_provisioning_jobs
 
       global_options = { legacy_support: legacy_support }
       global_options[:account_id] = account_id if account_id.present?
+      global_options.merge!(options[:global]) if options[:global].present?
 
       { jobs: jobs, global_options: global_options }
     end

data/lib/canvas_sync/job.rb

@@ -13,13 +13,26 @@ module CanvasSync
       @job_log.started_at = Time.now
       @job_log.save
 
+      @job_chain = job.arguments[0] if job.arguments[0].is_a?(Hash) && job.arguments[0].include?(:jobs)
+
       begin
         block.call
         @job_log.status = JobLog::SUCCESS_STATUS
       rescue => e # rubocop:disable Style/RescueStandardError
         @job_log.exception = "#{e.class}: #{e.message}"
-        @job_log.backtrace = e.backtrace
+        @job_log.backtrace = e.backtrace.join('\n')
         @job_log.status = JobLog::ERROR_STATUS
+        if @job_chain&.[](:global_options)&.[](:on_failure)&.present?
+          begin
+            class_name, method = @job_chain[:global_options][:on_failure].split('.')
+            klass = class_name.constantize
+            klass.send(method.to_sym, e, job_chain: @job_chain, job_log: @job_log)
+          rescue => e2
+            @job_log.backtrace += "\n\nError Occurred while handling an Error: #{e2.class}: #{e2.message}"
+            @job_log.backtrace += "\n" + e2.backtrace.join('\n')
+            Raven.captureException(e2) if defined? Raven
+          end
+        end
         raise e
       ensure
         if CanvasSync.config.classes_to_only_log_errors_on.include?(@job_log.job_class) && @job_log.status != JobLog::ERROR_STATUS

data/lib/canvas_sync/jobs/fork_gather.rb

@@ -2,10 +2,9 @@ module CanvasSync
   module Jobs
     class ForkGather < CanvasSync::Job
       def perform(job_chain, options)
-        fork_item = (job_chain[:global_options][:fork_path] || []).pop
+        forked_job = self.class.forked_at_job(job_chain)
 
-        if fork_item.present?
-          forked_job = CanvasSync::JobLog.find_by(job_id: fork_item)
+        if forked_job.present?
           forked_job.with_lock do
             forked_job.fork_count -= 1
             forked_job.save!
@@ -21,6 +20,40 @@ module CanvasSync
           CanvasSync.invoke_next(job_chain)
         end
       end
+
+      def self.handle_branch_error(e, job_chain:, skip_invoke: false, **kwargs)
+        return nil unless job_chain&.[](:global_options)&.[](:fork_path).present?
+
+        duped_chain = CanvasSync.duplicate_chain(job_chain)
+        job_list = duped_chain[:jobs]
+        while job_list.count > 0
+          job_class_name = job_list[0][:job]
+          job_class = job_class_name.constantize
+          break if job_class <= CanvasSync::Jobs::ForkGather
+          job_list.shift
+        end
+
+        return nil unless job_list.present?
+
+        if skip_invoke
+          duped_chain
+        else
+          CanvasSync.invoke_next(duped_chain)
+          true
+        end
+      end
+
+      protected
+
+      def self.forked_at_job(job_chain)
+        fork_item = (job_chain[:global_options][:fork_path] || []).pop
+
+        if fork_item.present?
+          CanvasSync::JobLog.find_by(job_id: fork_item)
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.10.5".freeze
+  VERSION = "0.10.6".freeze
 end

data/spec/canvas_sync/canvas_sync_spec.rb

@@ -24,6 +24,23 @@ RSpec.describe CanvasSync do
     end
 
     describe '.default_provisioning_report_chain' do
+      it 'splits an options: Hash into options for separate models' do
+        chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'], :active, options: {
+          terms: { a: 1 },
+          users: { b: 2 },
+          provisioning: { c: 3 },
+          global: { d: 4 },
+        })
+        expect(chain).to eq({
+          jobs: [
+            { job: CanvasSync::Jobs::SyncTermsJob.to_s, options: { a: 1 } },
+            { job: CanvasSync::Jobs::SyncUsersJob.to_s, options: { b: 2 } },
+            { job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: 'active', models: ['courses'], c: 3 } }
+          ],
+          global_options: { legacy_support: false, d: 4 }
+        })
+      end
+
       context 'we are syncing users with a term scope' do
         it 'syncs the users in a separate job that runs first' do
           chain = CanvasSync.default_provisioning_report_chain(['users', 'courses'], :active)

data/spec/canvas_sync/jobs/fork_gather_spec.rb

@@ -26,5 +26,48 @@ RSpec.describe CanvasSync::Jobs::ForkGather do
       expect(CanvasSync).to receive(:invoke_next)
       CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
     end
+
+    it 'pops the most-recent fork_path enrty' do
+      job_log.update!(fork_count: 1)
+      expect(CanvasSync).to receive(:invoke_next) do |*args|
+        expect(args[0][:global_options][:fork_path]).to eq []
+      end
+      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
+    end
+  end
+
+  describe 'handle_branch_error' do
+    let(:error) { StandardError.new }
+
+    let(:job_chain) {
+      {
+        jobs: [
+          { job: 'CanvasSync::Jobs::ReportChecker' },
+          { job: 'CanvasSync::Jobs::ReportChecker' },
+          { job: 'CanvasSync::Jobs::ForkGather' },
+          { job: 'CanvasSync::Jobs::ReportChecker' },
+        ],
+        global_options: {
+          fork_path: ['BLAH'],
+        }
+      }
+    }
+
+    it 'skips to and performs the next ForkGatherJob' do
+      expect(CanvasSync).to receive(:invoke_next) do |*args|
+        expect(args[0][:jobs][0][:job]).to eq 'CanvasSync::Jobs::ForkGather'
+      end
+      expect(CanvasSync::Jobs::ForkGather.handle_branch_error(error, job_chain: job_chain)).to be true
+    end
+
+    it 'does nothing if no ForkGather is in the chain' do
+      job_chain[:jobs].delete_at(2)
+      expect(CanvasSync::Jobs::ForkGather.handle_branch_error(error, job_chain: job_chain)).to be nil
+    end
+
+    it 'does nothing if no fork_path is present' do
+      job_chain[:global_options][:fork_path] = []
+      expect(CanvasSync::Jobs::ForkGather.handle_branch_error(error, job_chain: job_chain)).to be nil
+    end
   end
 end

data/spec/canvas_sync/jobs/job_spec.rb

@@ -1,40 +1,74 @@
 require 'spec_helper'
 
 class GoodJob < CanvasSync::Job
-  def perform(argument)
+  def perform(job_chain, argument)
   end
 end
 
 class EvilError < StandardError; end;
 
 class BadJob < CanvasSync::Job
-  def perform(argument)
+  def perform(job_chain, argument)
     raise EvilError
   end
+
+  def self.evil_catcher(e, *opts)
+    raise EvilError
+  end
+
+  def self.good_catcher(e, *opts)
+
+  end
 end
 
 RSpec.describe CanvasSync::Job do
   describe '#perform' do
     it 'creates a CanvasSync::JobLog and logs relevant data on it' do
       expect {
-        GoodJob.perform_now("argument")
+        GoodJob.perform_now({}, "argument")
       }.to change { CanvasSync::JobLog.count }.by(1)
 
       job_log = CanvasSync::JobLog.last
       expect(job_log.started_at).to_not be_nil
       expect(job_log.job_class).to eq(GoodJob.to_s)
-      expect(job_log.job_arguments).to eq(["argument"])
+      expect(job_log.job_arguments).to eq([{}, "argument"])
       expect(job_log.completed_at).to_not be_nil
     end
 
     it 'logs exceptions on the CanvasSync::JobLog and then re-raises' do
       expect {
-        BadJob.perform_now("argument")
+        BadJob.perform_now({}, "argument")
       }.to raise_exception(StandardError)
 
       job_log = CanvasSync::JobLog.last
       expect(job_log.exception).to eq("EvilError: EvilError")
       expect(job_log.backtrace).to_not be_nil
     end
+
+    it 'invokes an error handler' do
+      expect(BadJob).to receive(:good_catcher).once
+      expect {
+        BadJob.perform_now({
+          jobs: [],
+          global_options: {
+            on_failure: 'BadJob.good_catcher'
+          }
+        })
+      }.to raise_exception(StandardError)
+    end
+
+    it 'logs a failing error handler' do
+      expect(BadJob).to receive(:bad_catcher).once.and_call_original
+      expect {
+        BadJob.perform_now({
+          jobs: [],
+          global_options: {
+            on_failure: 'BadJob.bad_catcher'
+          }
+        })
+      }.to raise_exception(StandardError)
+      job_log = CanvasSync::JobLog.last
+      expect(job_log.backtrace).to include "Error Occurred while handling an Error"
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canvas_sync
 version: !ruby/object:Gem::Version
-  version: 0.10.5
+  version: 0.10.6
 platform: ruby
 authors:
 - Nate Collings
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-17 00:00:00.000000000 Z
+date: 2019-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler