acidic_job 1.0.0.pre26 → 1.0.0.pre27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12ef46783f7518f53f6f92384087761abecfa81576e72c6c9f8facdec94182a3
-  data.tar.gz: c39ab11338a29020c6700d7cb9707b0ac9a28a7971f9125247cfbb35eee06b21
+  metadata.gz: 2b41d1bacc6dc699e4e70e38c535795039f7dbfd5ed4b7ea3671809d7658fc5d
+  data.tar.gz: 53641ee78275b54defdae3ab1c4ca0087d6e193009c0d3df758114019a5a3efb
 SHA512:
-  metadata.gz: 4560e80dbfcac6f59efee5cae6236e430cae66ef54928e0f8258180752fdbc78161b421e39d9df46cdc67a528b170589d08db78a609ad52d263cae3b63387c8d
-  data.tar.gz: 8c23139c2f27dda273bb504a13d45afcf60e5ffec1ad9351cbf984da0ffb2de399cc693f0f98d1edbb053f1b62e2d0a46ba9bac6baa3c43a9d8dd2458cb79eb5
+  metadata.gz: d383cde62b69a013979df927ff64d1c99ff591261a103b3694733f65f0fa0d44c1216bf3b7e8638b746a59754efbc32afd410c9039bda9f88a89926e552ee1d9
+  data.tar.gz: ced115b0b7607c60b48a51d2fd4e2db6442fd0daa44b2a9b648a1ced7598ca3e0f05dd8894359ed163c27287146769d37aebe9e464c989e46ebabfa6ba07d41d

data/.gitignore

@@ -12,3 +12,5 @@ slides.md
 /test/dummy
 /test/log
 /database.sqlite
+/test/combustion/log/test.log
+/test/combustion/database.sqlite

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (1.0.0.pre26)
+    acidic_job (1.0.0.pre27)
       activerecord
       activesupport
       database_cleaner

data/lib/acidic_job/extensions/sidekiq.rb

@@ -47,7 +47,7 @@ module AcidicJob
           arguments = args || @args
           arguments += [kwargs] unless kwargs.empty?
           normalized_args = ::Sidekiq.load_json(::Sidekiq.dump_json(arguments))
-          item = { "class" => self.class, "args" => normalized_args, "jid" => jid }
+          item = { "class" => self.class.name, "args" => normalized_args, "jid" => jid }
           sidekiq_options = sidekiq_options_hash || {}
 
           sidekiq_options.merge(item)

data/lib/acidic_job/run.rb

@@ -3,6 +3,7 @@
 require "active_record"
 require "global_id"
 require "active_support/core_ext/object/with_options"
+require_relative "./serializer"
 
 module AcidicJob
   class Run < ActiveRecord::Base
@@ -17,11 +18,11 @@ module AcidicJob
 
     after_create_commit :enqueue_staged_job, if: :staged?
 
-    serialize :error_object
-    serialize :serialized_job
-    serialize :workflow
-    serialize :returning_to
-    store :attr_accessors
+    serialize :serialized_job, JSON
+    serialize :error_object, Serializer
+    serialize :workflow, Serializer
+    serialize :returning_to, Serializer
+    store :attr_accessors, coder: Serializer
 
     validates :staged, inclusion: { in: [true, false] } # uses database default
     validates :serialized_job, presence: true

data/lib/acidic_job/serializer.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "active_job/serializers"
+require "active_job/arguments"
+require "json"
+
+class WorkerSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(worker)
+    # {"_aj_serialized"=>"WorkerSerializer", "class"=>"SuccessfulArgWorker", "args"=>[123], "kwargs"=>{}}]
+    super(
+      "class" => worker.class.name,
+      "args" => worker.instance_variable_get(:@__acidic_job_args),
+      "kwargs" => worker.instance_variable_get(:@__acidic_job_kwargs)
+    )
+  end
+
+  def deserialize(hash)
+    worker_class = hash["class"].constantize
+    worker_class.new(*hash["args"], **hash["kwargs"])
+  end
+
+  def serialize?(argument)
+    defined?(Sidekiq) && argument.class.include?(Sidekiq::Worker)
+  end
+end
+
+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
+
+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
+
+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
+
+ActiveJob::Serializers.add_serializers WorkerSerializer, ExceptionSerializer, FinishedPointSerializer,
+                                       RecoveryPointSerializer
+
+# ...
+module AcidicJob
+  module Arguments
+    include ActiveJob::Arguments
+    extend self # rubocop:disable Style/ModuleFunction
+
+    # `ActiveJob` will throw an error if it tries to deserialize a GlobalID record.
+    # However, this isn't the behavior that we want for our custom `ActiveRecord` serializer.
+    # Since `ActiveRecord` does _not_ reset instance record state to its pre-transactional state
+    # on a transaction ROLLBACK, we can have GlobalID entries in a serialized column that point to
+    # non-persisted records. This is ok. We should simply return `nil` for that portion of the
+    # serialized field.
+    def deserialize_global_id(hash)
+      GlobalID::Locator.locate hash[GLOBALID_KEY]
+    rescue ActiveRecord::RecordNotFound
+      nil
+    end
+  end
+
+  class Serializer
+    # Used for `serialize` method in ActiveRecord
+    class << self
+      def load(json)
+        return if json.nil? || json.empty?
+
+        data = JSON.parse(json)
+        Arguments.deserialize(data).first
+      end
+
+      def dump(obj)
+        data = Arguments.serialize [obj]
+        data.to_json
+      end
+    end
+  end
+end

data/lib/acidic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcidicJob
-  VERSION = "1.0.0.pre26"
+  VERSION = "1.0.0.pre27"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre26
+  version: 1.0.0.pre27
 platform: ruby
 authors:
 - fractaledmind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-20 00:00:00.000000000 Z
+date: 2022-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -300,6 +300,7 @@ files:
 - lib/acidic_job/recovery_point.rb
 - lib/acidic_job/rspec_configuration.rb
 - lib/acidic_job/run.rb
+- lib/acidic_job/serializer.rb
 - lib/acidic_job/staging.rb
 - lib/acidic_job/step.rb
 - lib/acidic_job/test_case.rb