canvas_sync 0.16.2 → 0.17.0.beta3

data/lib/canvas_sync/job_chain.rb

@@ -1,57 +0,0 @@
-module CanvasSync
-  class JobChain
-    attr_reader :chain_data
-
-    delegate_missing_to :chain_data
-
-    VALID_PLACEMENT_PARAMETERS = %i[before after].freeze
-
-    def initialize(chain_data)
-      @chain_data = chain_data
-    end
-
-    def jobs
-      chain_data[:jobs]
-    end
-
-    def global_options
-      chain_data[:global_options]
-    end
-
-    def merge_options(job, options)
-      jobs.each do |j|
-        j[:options].deep_merge!(options) if job_matches_pattern(j, job)
-      end
-    end
-
-    def insert(new_job, **kwargs)
-      invalid_params = kwargs.keys - VALID_PLACEMENT_PARAMETERS
-      raise "Invalid placement parameters: #{invalid_params.map(&:to_s).join(', ')}" if invalid_params.present?
-      raise "Exactly one placement parameter may be provided" if kwargs.values.compact!.length > 1
-
-      if !kwargs.present?
-        jobs << new_job
-      else
-        placement = kwargs.keys[0]
-        relative_to = kwargs.values[0]
-
-        index = jobs.index { |job| job_matches_pattern(job, relative_to) }
-        raise "Could not find a \"#{relative_to}\" job in the chain" if index.nil?
-
-        index += 1 if placement == :after
-        new_job[:job] = new_job[:job].to_s
-        jobs.insert(index, new_job)
-      end
-    end
-
-    def process!(extra_options: {})
-      CanvasSync::invoke_next(self, extra_options: extra_options)
-    end
-
-    private
-
-    def job_matches_pattern(job_entry, pattern)
-      job_entry[:job].to_s == pattern.to_s
-    end
-  end
-end

data/lib/canvas_sync/jobs/fork_gather.rb

@@ -1,59 +0,0 @@
-module CanvasSync
-  module Jobs
-    class ForkGather < CanvasSync::Job
-      def perform(job_chain, options)
-        forked_job = self.class.forked_at_job(job_chain)
-
-        if forked_job.present?
-          forked_job.with_lock do
-            forked_job.fork_count -= 1
-            forked_job.save!
-          end
-
-          if forked_job.fork_count <= 0
-            (job_chain[:global_options][:fork_keys] || []).pop&.each do |k|
-              job_chain[:global_options].delete(k.to_sym)
-            end
-            CanvasSync.invoke_next(job_chain)
-          end
-        else
-          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/spec/canvas_sync/jobs/fork_gather_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe CanvasSync::Jobs::ForkGather do
-  describe '#perform' do
-    let!(:job_log) { CanvasSync::JobLog.create!(job_id: 'BLAH', fork_count: 3) }
-    let(:job_chain) { {jobs: [], global_options: { fork_path: ['BLAH'] }} }
-
-    it 'decrements fork_count' do
-      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
-      expect(job_log.reload.fork_count).to eq 2
-    end
-
-    it 'does not continue chain if fork_count > 0' do
-      expect(CanvasSync).not_to receive(:invoke_next)
-      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
-    end
-
-    it 'continues the chain if fork_count <= 0' do
-      job_log.update!(fork_count: 1)
-      expect(CanvasSync).to receive(:invoke_next)
-      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
-    end
-
-    it 'continues if no fork_path is specified' do
-      job_chain[:global_options].delete(:fork_path)
-      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