canvas_sync 0.16.5 → 0.17.0.beta1

data/lib/canvas_sync/job_chain.rb

@@ -1,102 +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: {})
-      perform_next(extra_options)
-    end
-
-    def duplicate
-      self.class.new(Marshal.load(Marshal.dump(chain_data)))
-    end
-
-    def normalize!
-      @chain_data[:global_options] ||= {}
-    end
-
-    def serialize
-      normalize!
-      chain_data
-    end
-
-    def perform_next(extra_options = {})
-      return if jobs.empty?
-
-      # Make sure all job classes are serialized as strings
-      jobs.each { |job| job[:job] = job[:job].to_s }
-
-      duped_job_chain = duplicate
-
-      jobs = duped_job_chain[:jobs]
-      next_job = jobs.shift
-      next_job_class = next_job[:job].constantize
-      next_options = next_job[:options] || {}
-      next_options.merge!(extra_options)
-      next_job_class.perform_later(duped_job_chain.serialize, next_options)
-    end
-
-    def fork(job_log, keys: [])
-      duped_job_chain = duplicate
-      duped_job_chain[:fork_state] ||= {}
-      duped_job_chain[:fork_state][:forking_path] ||= []
-      duped_job_chain[:fork_state][:pre_fork_globals] ||= []
-
-      duped_job_chain[:fork_state][:forking_path] << job_log.job_id
-      duped_job_chain[:fork_state][:pre_fork_globals] << global_options
-      # 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_items
-    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,74 +0,0 @@
-module CanvasSync
-  module Jobs
-    class ForkGather < CanvasSync::Job
-      def perform(job_chain, options)
-        forked_job = self.class.forked_at_job(job_chain)
-
-        while true
-          if forked_job.present?
-            forked_job.with_lock do
-              forked_job.fork_count -= 1
-              forked_job.save!
-            end
-
-            if forked_job.fork_count <= 0
-              pfgs = job_chain[:fork_state][:pre_fork_globals].pop
-              job_chain[:global_options] = pfgs
-
-              if options[:gather_all]
-                # If we want to gather all, repeat for the next level fork
-                forked_job = self.class.forked_at_job(job_chain)
-              else
-                forked_job = nil
-              end
-            else
-              # If a fork was found and it isn't complete, break the loop before continuing the chain
-              break
-            end
-
-            # Repeat this logic for [if gather_all] the next fork up, or [if not gather_all] nil
-            next
-          end
-
-          # If there is no current fork (either not in a fork, or all forks were closed), continue the chain
-          CanvasSync.invoke_next(job_chain)
-          break
-        end
-      end
-
-      def self.handle_branch_error(e, job_chain:, skip_invoke: false, **kwargs)
-        return nil unless job_chain&.dig(:fork_state, :forking_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.dig(:fork_state, :forking_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: [], fork_state: { forking_path: ['BLAH'], pre_fork_globals: [{}] }} }
-
-    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 forking_path is specified' do
-      job_chain[:fork_state].delete(:forking_path)
-      expect(CanvasSync).to receive(:invoke_next)
-      CanvasSync::Jobs::ForkGather.perform_now(job_chain, {})
-    end
-
-    it 'pops the most-recent forking_path enrty' do
-      job_log.update!(fork_count: 1)
-      expect(CanvasSync).to receive(:invoke_next) do |*args|
-        expect(args[0][:fork_state][:forking_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' },
-        ],
-        fork_state: {
-          forking_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 forking_path is present' do
-      job_chain[:fork_state][:forking_path] = []
-      expect(CanvasSync::Jobs::ForkGather.handle_branch_error(error, job_chain: job_chain)).to be nil
-    end
-  end
-end