acidic_job 1.0.0.beta.10 → 1.0.0.pre1

data/lib/acidic_job/mixin.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-module AcidicJob
-  module Mixin
-    extend ActiveSupport::Concern
-
-    def self.wire_up(other)
-      # Ensure our `perform` method always runs first to gather parameters
-      # and run perform callbacks for Sidekiq workers
-      other.prepend PerformWrapper
-
-      # By default, we unique job runs by the `job_id`
-      other.instance_variable_set(:@acidic_identifier, :job_id)
-      # However, you can customize this behavior on a per job class level
-      other.define_singleton_method(:acidic_by_job_identifier) { @acidic_identifier = :job_id }
-      # You could unique job runs by the arguments passed to the job (e.g. memoization)
-      other.define_singleton_method(:acidic_by_job_arguments) { @acidic_identifier = :job_arguments }
-      # Or, you could unique jobs run by any logic you'd like using a block
-      other.define_singleton_method(:acidic_by) { |&block| @acidic_identifier = block }
-
-      # We add a callback to ensure that staged, non-workflow jobs are "finished" after they are "performed".
-      # This allows us to ensure that we can always inspect whether a run is finished and get correct data
-      other.set_callback :perform, :after, :finish_staged_job, if: -> { was_staged_job? && !was_workflow_job? }
-      # We also allow you to write any of your own callbacks keyed to the "finish" event.
-      # The "finish" event is notably different from the "perform" event for acidic jobs,
-      # as any acidic job can have one or more "perform" event (retries or a resume after awaiting jobs),
-      # but will only ever have one "finish" event (when the run successfully completes)
-      other.define_callbacks :finish
-    end
-
-    included do
-      Mixin.wire_up(self)
-    end
-
-    class_methods do
-      def inherited(subclass)
-        Mixin.wire_up(subclass)
-        super
-      end
-
-      # `perform_now` runs a job synchronously and immediately
-      # `perform_later` runs a job asynchronously and queues it immediately
-      # `perform_acidicly` run a job asynchronously and queues it after a successful database commit
-      def perform_acidicly(*args)
-        job = new(*args)
-
-        Run.stage!(job)
-      end
-
-      # Instantiate an instance of a job ready for serialization
-      def with(...)
-        # New delegation syntax (...) was introduced in Ruby 2.7.
-        # https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
-        job = new(...)
-        # force the job to resolve the `queue_name`, so that we don't try to serialize a Proc into ActiveRecord
-        job.queue_name
-        job
-      end
-    end
-
-    def idempotency_key
-      IdempotencyKey.new(self).value(acidic_by: acidic_identifier)
-    end
-
-    protected
-
-    # Short circuits execution by sending execution right to 'finished'.
-    # So, ends the job "successfully"
-    def safely_finish_acidic_job
-      FinishedPoint.new
-    end
-
-    def with_acidic_workflow(persisting: {}, &block)
-      raise UnknownJobAdapter unless (defined?(::AcidicJob::Base) && self.class < ::AcidicJob::Base) ||
-                                     (defined?(::AcidicJob::ActiveKiq) && self.class < ::AcidicJob::ActiveKiq)
-
-      raise RedefiningWorkflow if defined? @workflow_builder
-
-      @workflow_builder = WorkflowBuilder.new
-
-      raise MissingWorkflowBlock, "A block must be passed to `with_acidic_workflow`" unless block_given?
-      raise MissingBlockArgument, "An argument must be passed to the `with_acidic_workflow` block" if block.arity.zero?
-
-      block.call @workflow_builder
-
-      raise NoDefinedSteps if @workflow_builder.steps.empty?
-
-      # convert the array of steps into a hash of recovery_points and next steps
-      workflow = @workflow_builder.define_workflow
-
-      ensure_run_record_and_process(workflow, persisting)
-    rescue LocalJumpError
-      raise MissingWorkflowBlock, "A block must be passed to `with_acidic_workflow`"
-    end
-
-    # DEPRECATED
-    # second attempt at the DSL, but `providing` suggested you needed to serialize
-    # any data that would be used in step methods, but simply instance variables work.
-    def with_acidity(providing: {}, &block)
-      ::ActiveSupport::Deprecation.new("1.0", "AcidicJob").deprecation_warning(:with_acidity)
-
-      @workflow_builder = WorkflowBuilder.new
-      @workflow_builder.instance_exec(&block)
-
-      raise NoDefinedSteps if @workflow_builder.steps.empty?
-
-      # convert the array of steps into a hash of recovery_points and next steps
-      workflow = @workflow_builder.define_workflow
-
-      ensure_run_record_and_process(workflow, providing)
-    rescue LocalJumpError
-      raise MissingWorkflowBlock, "A block must be passed to `with_acidity`"
-    end
-
-    # DEPRECATED
-    # first attempt at the DSL, but `idempotently` and `with` are too distant from the gem name.
-    def idempotently(with: {}, &block)
-      ::ActiveSupport::Deprecation.new("1.0", "AcidicJob").deprecation_warning(:idempotently)
-
-      @workflow_builder = WorkflowBuilder.new
-      @workflow_builder.instance_exec(&block)
-
-      raise NoDefinedSteps if @workflow_builder.steps.empty?
-
-      # convert the array of steps into a hash of recovery_points and next steps
-      workflow = @workflow_builder.define_workflow
-
-      ensure_run_record_and_process(workflow, with)
-    rescue LocalJumpError
-      raise MissingWorkflowBlock, "A block must be passed to `idempotently`"
-    end
-
-    private
-
-    # You can always retrieve the unique identifier from within the job instance itself
-    def acidic_identifier
-      self.class.instance_variable_get(:@acidic_identifier)
-    end
-
-    def ensure_run_record_and_process(workflow, persisting)
-      ::AcidicJob.logger.log_run_event("Initializing run...", self, nil)
-      @acidic_job_run = ::ActiveRecord::Base.transaction(isolation: acidic_isolation_level) do
-        run = Run.find_by(idempotency_key: idempotency_key)
-        serialized_job = serialize
-
-        if run.present?
-          # Programs enqueuing multiple jobs with different parameters but the
-          # same idempotency key is a bug.
-          if run.serialized_job["arguments"] != serialized_job["arguments"]
-            raise MismatchedIdempotencyKeyAndJobArguments
-          end
-
-          # Only acquire a lock if the key is unlocked or its lock has expired
-          # because the original job was long enough ago.
-          raise LockedIdempotencyKey if run.lock_active?
-
-          run.update!(
-            last_run_at: Time.current,
-            locked_at: Time.current,
-            # staged workflow jobs won't have the `workflow` or `recovery_point` stored when staged,
-            # so we need to persist both here.
-            workflow: workflow,
-            recovery_point: run.recovery_point || workflow.keys.first
-          )
-        else
-          run = Run.create!(
-            staged: false,
-            idempotency_key: idempotency_key,
-            job_class: self.class.name,
-            locked_at: Time.current,
-            last_run_at: Time.current,
-            workflow: workflow,
-            recovery_point: workflow.keys.first,
-            serialized_job: serialize
-          )
-        end
-
-        # persist `persisting` values and set accessors for each
-        # first, get the current state of all accessors for both previously persisted and initialized values
-        current_accessors = persisting.stringify_keys.merge(run.attr_accessors)
-
-        # next, ensure that `Run#attr_accessors` is populated with initial values
-        # skip validations for this call to ensure a write
-        run.update_column(:attr_accessors, current_accessors) if current_accessors != run.attr_accessors
-
-        # finally, set reader and writer methods
-        current_accessors.each do |accessor, value|
-          # the reader method may already be defined
-          self.class.attr_reader accessor unless respond_to?(accessor)
-          # but we should always update the value to match the current value
-          instance_variable_set("@#{accessor}", value)
-          # and we overwrite the setter to ensure any updates to an accessor update the `Run` stored value
-          # Note: we must define the singleton method on the instance to avoid overwriting setters on other
-          # instances of the same class
-          define_singleton_method("#{accessor}=") do |updated_value|
-            instance_variable_set("@#{accessor}", updated_value)
-            run.attr_accessors[accessor] = updated_value
-            run.save!(validate: false)
-            updated_value
-          end
-        end
-
-        # ensure that we return the `run` record so that the result of this block is the record
-        run
-      end
-      ::AcidicJob.logger.log_run_event("Initialized run.", self, @acidic_job_run)
-
-      Processor.new(@acidic_job_run, self).process_run
-    end
-
-    def was_staged_job?
-      job_id.start_with? Run::STAGED_JOB_ID_PREFIX
-    end
-
-    def was_workflow_job?
-      return false unless defined? @acidic_job_run
-
-      @acidic_job_run.present?
-    end
-
-    def staged_job_run
-      return unless was_staged_job?
-      # memoize so we don't have to make unnecessary database calls
-      return @staged_job_run if defined? @staged_job_run
-
-      # "STG__#{idempotency_key}__#{encoded_global_id}"
-      _prefix, _idempotency_key, encoded_global_id = job_id.split("__")
-      staged_job_gid = "gid://#{::Base64.urlsafe_decode64(encoded_global_id)}"
-
-      @staged_job_run = ::GlobalID::Locator.locate(staged_job_gid)
-    end
-
-    def finish_staged_job
-      staged_job_run.finish!
-    end
-
-    def acidic_isolation_level
-      case ::ActiveRecord::Base.connection.adapter_name.downcase.to_sym
-      # SQLite doesn't support `serializable` transactions,
-      # so we use the strictest isolation_level is does support
-      when :sqlite
-        :read_uncommitted
-      else
-        :serializable
-      end
-    end
-  end
-end

data/lib/acidic_job/processor.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module AcidicJob
-  class Processor
-    def initialize(run, job)
-      @run = run
-      @job = job
-      @workflow = Workflow.new(run, job)
-    end
-
-    def process_run
-      # if the run record is already marked as finished, immediately return its result
-      return @run.succeeded? if @run.finished?
-
-      AcidicJob.logger.log_run_event("Processing #{@run.current_step_name}...", @job, @run)
-      loop do
-        break if @run.finished?
-
-        if !@run.known_recovery_point?
-          raise UnknownRecoveryPoint,
-                "Defined workflow does not reference this step: #{@run.current_step_name.inspect}"
-        elsif (awaited_jobs = jobs_from(@run.current_step_awaits)).any?
-          # We only execute the current step, without progressing to the next step.
-          # This ensures that any failures in parallel jobs will have this step retried in the main workflow
-          step_result = @workflow.execute_current_step
-          # We allow the `#step_done` method to manage progressing the recovery_point to the next step,
-          # and then calling `process_run` to restart the main workflow on the next step.
-          # We pass the `step_result` so that the async callback called after the step-parallel-jobs complete
-          # can move on to the appropriate next stage in the workflow.
-          enqueue_awaited_jobs(awaited_jobs, step_result)
-          # after processing the current step, break the processing loop
-          # and stop this method from blocking in the primary worker
-          # as it will continue once the background workers all succeed
-          # so we want to keep the primary worker queue free to process new work
-          # this CANNOT ever be `break` as that wouldn't exit the parent job,
-          # only this step in the workflow, blocking as it awaits the next step
-          return true
-        else
-          @workflow.execute_current_step
-          @workflow.progress_to_next_step
-        end
-      end
-      AcidicJob.logger.log_run_event("Processed #{@run.current_step_name}.", @job, @run)
-
-      @run.succeeded?
-    end
-
-    private
-
-    def enqueue_awaited_jobs(awaited_jobs, step_result)
-      AcidicJob.logger.log_run_event("Enqueuing #{awaited_jobs.count} awaited jobs...", @job, @run)
-      # All jobs created in the block are pushed atomically at the end of the block.
-      AcidicJob::Run.transaction do
-        awaited_jobs.each do |awaited_job|
-          worker_class, args = job_and_args(awaited_job)
-
-          job = worker_class.new(*args)
-
-          AcidicJob::Run.await!(job, by: @run, return_to: step_result)
-        end
-      end
-      AcidicJob.logger.log_run_event("Enqueued #{awaited_jobs.count} awaited jobs.", @job, @run)
-    end
-
-    def jobs_from(jobs_or_jobs_getter)
-      case jobs_or_jobs_getter
-      when Array
-        jobs_or_jobs_getter.compact
-      when Symbol, String
-        if @job.respond_to?(jobs_or_jobs_getter, _include_private = true)
-          jobs = @job.method(jobs_or_jobs_getter).call
-          Array(jobs).compact
-        else
-          raise UnknownAwaitedJob,
-                "Invalid `awaits`; unknown method `#{jobs_or_jobs_getter}` for this job"
-        end
-      else
-        raise UnknownAwaitedJob,
-              "Invalid `awaits`; must be either an jobs Array or method name, was: #{jobs_or_jobs_getter.class.name}"
-      end
-    end
-
-    def job_and_args(job)
-      case job
-      when Class
-        [job, []]
-      else
-        [
-          job.class,
-          job.arguments
-        ]
-      end
-    end
-  end
-end

data/lib/acidic_job/rails.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/railtie"
-
-module AcidicJob
-  class Rails < ::Rails::Railtie
-    initializer "acidic_job.action_mailer_extension" do
-      ::ActiveSupport.on_load(:action_mailer) do
-        # Add `deliver_acidicly` to ActionMailer
-        ::ActionMailer::Parameterized::MessageDelivery.include(Extensions::ActionMailer)
-        ::ActionMailer::MessageDelivery.include(Extensions::ActionMailer)
-      end
-    end
-
-    initializer "acidic_job.active_job_serializers" do
-      ::ActiveSupport.on_load(:active_job) do
-        ::ActiveJob::Serializers.add_serializers(
-          Serializers::ExceptionSerializer,
-          Serializers::FinishedPointSerializer,
-          Serializers::JobSerializer,
-          Serializers::RangeSerializer,
-          Serializers::RecoveryPointSerializer,
-          Serializers::WorkerSerializer
-        )
-      end
-    end
-
-    generators do
-      require "generators/acidic_job/install_generator"
-    end
-
-    # This hook happens after all initializers are run, just before returning
-    config.after_initialize do
-      if defined?(::Noticed)
-        # Add `deliver_acidicly` to Noticed
-        ::Noticed::Base.include(Extensions::Noticed)
-      end
-    end
-  end
-end

data/lib/acidic_job/serializer.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module AcidicJob
-  class Serializer
-    # Used for `serialize` method in ActiveRecord
-    class << self
-      def load(json)
-        return if json.nil? || json.empty?
-
-        data = JSON.parse(json)
-        Arguments.send :deserialize_argument, data
-      end
-
-      def dump(obj)
-        data = Arguments.send :serialize_argument, obj
-        data.to_json
-      rescue ActiveJob::SerializationError
-        raise UnserializableValue
-      end
-    end
-  end
-end

data/lib/acidic_job/serializers/exception_serializer.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/serializers/object_serializer"
-
-module AcidicJob
-  module Serializers
-    class ExceptionSerializer < ::ActiveJob::Serializers::ObjectSerializer
-      def serialize(exception)
-        hash = {
-          "class" => exception.class.name,
-          "message" => exception.message,
-          "cause" => exception.cause,
-          "backtrace" => {}
-        }
-
-        exception.backtrace.map do |trace|
-          path, _, location = trace.rpartition("/")
-
-          next if hash["backtrace"].key?(path)
-
-          hash["backtrace"][path] = location
-        end
-
-        super(hash)
-      end
-
-      def deserialize(hash)
-        exception_class = hash["class"].constantize
-        exception = exception_class.new(hash["message"])
-        exception.set_backtrace(hash["backtrace"].map do |path, location|
-          [path, location].join("/")
-        end)
-        exception
-      end
-
-      def serialize?(argument)
-        defined?(Exception) && argument.is_a?(Exception)
-      end
-    end
-  end
-end

data/lib/acidic_job/serializers/finished_point_serializer.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/serializers/object_serializer"
-
-module AcidicJob
-  module Serializers
-    class FinishedPointSerializer < ::ActiveJob::Serializers::ObjectSerializer
-      def serialize(finished_point)
-        super(
-          "class" => finished_point.class.name
-        )
-      end
-
-      def deserialize(hash)
-        finished_point_class = hash["class"].constantize
-        finished_point_class.new
-      end
-
-      def serialize?(argument)
-        defined?(::AcidicJob::FinishedPoint) && argument.is_a?(::AcidicJob::FinishedPoint)
-      end
-    end
-  end
-end

data/lib/acidic_job/serializers/job_serializer.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/serializers/object_serializer"
-
-module AcidicJob
-  module Serializers
-    class JobSerializer < ::ActiveJob::Serializers::ObjectSerializer
-      def serialize(job)
-        # don't serialize the `enqueued_at` value, as ActiveRecord will check if the Run record has changed
-        # by comparing the deserialized database value with a temporary in-memory generated value.
-        # That temporary in-memory generated value can sometimes have an `enqueued_at` value that is 1 second off
-        # from the original. In this case, ActiveRecord will think the record has unsaved changes and block the lock.
-        super(job.as_json.merge("job_class" => job.class.name))
-      end
-
-      def deserialize(hash)
-        job = ::ActiveJob::Base.deserialize(hash)
-        job.send(:deserialize_arguments_if_needed)
-        job
-      end
-
-      def serialize?(argument)
-        defined?(::ActiveJob::Base) && argument.class < ::ActiveJob::Base
-      end
-    end
-  end
-end

data/lib/acidic_job/serializers/range_serializer.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/serializers/object_serializer"
-
-# :nocov:
-module AcidicJob
-  module Serializers
-    class RangeSerializer < ::ActiveJob::Serializers::ObjectSerializer
-      KEYS = %w[begin end exclude_end].freeze
-
-      def serialize(range)
-        args = Arguments.serialize([range.begin, range.end, range.exclude_end?])
-        super(KEYS.zip(args).to_h)
-      end
-
-      def deserialize(hash)
-        klass.new(*Arguments.deserialize(hash.values_at(*KEYS)))
-      end
-
-      private
-
-      def klass
-        ::Range
-      end
-    end
-  end
-end
-# :nocov:

data/lib/acidic_job/serializers/recovery_point_serializer.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/serializers/object_serializer"
-
-module AcidicJob
-  module Serializers
-    class RecoveryPointSerializer < ::ActiveJob::Serializers::ObjectSerializer
-      def serialize(recovery_point)
-        super(
-          "class" => recovery_point.class.name,
-          "name" => recovery_point.name
-        )
-      end
-
-      def deserialize(hash)
-        recovery_point_class = hash["class"].constantize
-        recovery_point_class.new(hash["name"])
-      end
-
-      def serialize?(argument)
-        defined?(::AcidicJob::RecoveryPoint) && argument.is_a?(::AcidicJob::RecoveryPoint)
-      end
-    end
-  end
-end

data/lib/acidic_job/serializers/worker_serializer.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "active_job/serializers/object_serializer"
-
-# :nocov:
-module AcidicJob
-  module Serializers
-    class WorkerSerializer < ::ActiveJob::Serializers::ObjectSerializer
-      def serialize(worker)
-        super(
-          "job_class" => worker.class.name,
-          "arguments" => worker.arguments,
-        )
-      end
-
-      def deserialize(hash)
-        worker_class = hash["job_class"].constantize
-        worker_class.new(*hash["arguments"])
-      end
-
-      def serialize?(argument)
-        defined?(::Sidekiq) && argument.class.include?(::Sidekiq::Worker)
-      end
-    end
-  end
-end
-# :nocov:

data/lib/acidic_job/test_case.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./testing"
-
-module AcidicJob
-  class TestCase < ::ActiveJob::TestCase
-    include ::AcidicJob::Testing
-  end
-end

data/lib/acidic_job/testing.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "database_cleaner"
-
-module AcidicJob
-  module Testing
-    def self.included(mod)
-      mod.class_eval "self.use_transactional_tests = false if respond_to?(:use_transactional_tests)", __FILE__, __LINE__
-    end
-
-    def before_setup
-      @connection = ::ActiveRecord::Base.connection
-      @original_cleaners = ::DatabaseCleaner.cleaners
-      ::DatabaseCleaner.cleaners = transaction_free_cleaners_for(@original_cleaners)
-      super
-      ::DatabaseCleaner.start
-    end
-
-    def after_teardown
-      ::DatabaseCleaner.clean
-      super
-      ::DatabaseCleaner.cleaners = @original_cleaners
-    end
-
-    private
-
-    # Ensure that the system's original DatabaseCleaner configuration is maintained, options included,
-    # except that any `transaction` strategies for any ORMs are replaced with a `deletion` strategy.
-    def transaction_free_cleaners_for(original_cleaners)
-      non_transaction_cleaners = original_cleaners.dup.to_h do |(orm, opts), cleaner|
-        [[orm, opts], ensure_no_transaction_strategies_for(cleaner)]
-      end
-      ::DatabaseCleaner::Cleaners.new(non_transaction_cleaners)
-    end
-
-    def ensure_no_transaction_strategies_for(cleaner)
-      return cleaner unless strategy_name_for(cleaner) == "transaction"
-
-      cleaner.strategy = deletion_strategy_for(cleaner)
-      cleaner
-    end
-
-    def strategy_name_for(cleaner)
-      cleaner               # <DatabaseCleaner::Cleaner>
-        .strategy           # <DatabaseCleaner::ActiveRecord::Truncation>
-        .class              # DatabaseCleaner::ActiveRecord::Truncation
-        .name               # "DatabaseCleaner::ActiveRecord::Truncation"
-        .rpartition("::")   # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
-        .last               # "Truncation"
-        .downcase           # "truncation"
-    end
-
-    def deletion_strategy_for(cleaner)
-      strategy = cleaner.strategy
-      strategy_namespace = strategy                    # <DatabaseCleaner::ActiveRecord::Truncation>
-                           .class                      # DatabaseCleaner::ActiveRecord::Truncation
-                           .name                       # "DatabaseCleaner::ActiveRecord::Truncation"
-                           .rpartition("::")           # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
-                           .first                      # "DatabaseCleaner::ActiveRecord"
-      deletion_strategy_class_name = [strategy_namespace, "::", "Deletion"].join
-      deletion_strategy_class = deletion_strategy_class_name.constantize
-      instance_variable_hash = strategy.instance_variables.to_h do |var|
-        [
-          var.to_s.remove("@"),
-          strategy.instance_variable_get(var)
-        ]
-      end
-      options = instance_variable_hash.except("db", "connection_class")
-
-      deletion_strategy_class.new(**options)
-    end
-  end
-end