joblin 0.1.12 → 0.2.0

data/lib/joblin/lazy_access.rb

@@ -1,12 +1,31 @@
 module Joblin
+  # Serialization coder (used by `serialize ..., coder: Joblin::LazyAccess`) that
+  # lazily rehydrates ActiveRecord references stored as GlobalIDs.
+  #
+  # Records are NOT auto-located from any string that happens to start with
+  # "gid://". Instead, `dump` records which keys held records in a reserved
+  # `_joblin_` envelope, and `load` only resolves those keys — and only when the
+  # key is actually read. This closes the object-injection/data-loss hole where
+  # an attacker-supplied "gid://..." string was located into an arbitrary record.
+  #
+  # Envelope shapes:
+  #   Hash with record values -> { ...values (records as gid strings)...,
+  #                                "_joblin_" => { "gid_keys" => [<key>, ...] } }
+  #   A standalone record (e.g. an Array element) -> { "_joblin_" => { "gid" => "gid://..." } }
   module LazyAccess
     extend ActiveSupport::Concern
 
+    MARKER = "_joblin_".freeze
+
     def initialize(...)
       super
       @access_cache = {}
     end
 
+    # For a loaded LazyAccessHash: the set of keys whose values are GlobalIDs.
+    # Tracked out-of-band so the reserved marker isn't exposed via enumeration.
+    attr_accessor :lazy_gid_keys
+
     def self.raw
       current = Thread.current[:lazy_access_read_raw]
       Thread.current[:lazy_access_read_raw] = true
@@ -15,44 +34,104 @@ module Joblin
       Thread.current[:lazy_access_read_raw] = current
     end
 
+    # ---- Serialization coder interface ----
+
     def self.load(val)
       case val
-      when String
-        if val.start_with?("gid://")
-          val = GlobalID::Locator.locate(val)
-        end
       when Hash
-        val = LazyAccessHash.new(val)
+        marker = marker_of(val)
+
+        # A per-object envelope resolves to its single record reference.
+        return locate(marker["gid"]) if marker && marker.key?("gid")
+
+        gid_keys = marker ? Array(marker["gid_keys"]).map(&:to_s) : []
+        data = val.reject { |k, _| k.to_s == MARKER }
+        LazyAccessHash.new(data).tap { |h| h.lazy_gid_keys = gid_keys }
       when Array
-        val = LazyAccessArray.new(val)
+        LazyAccessArray.new(val)
+      else
+        val
       end
-      val
     end
 
     def self.dump(val)
       case val
       when Array
-        val.to_a.map {|x| dump(x) }
+        val.to_a.map { |x| dump(x) }
       when Hash
-        val.to_h.transform_values{|x| dump(x) }
+        dump_hash(val)
       when ActiveRecord::Base
-        val.to_gid
+        # A record outside a hash-key context (Array element / standalone):
+        # wrap it so load can resolve it back.
+        { MARKER => { "gid" => val.to_gid.to_s } }
       else
         val
       end
     end
 
-    def [](key)
-      if Thread.current[:lazy_access_read_raw]
-        super
-      else
-        key = key.to_s if key.is_a?(Symbol)
-        unless @access_cache.key?(key)
-          val = super
-          @access_cache[key] = LazyAccess.load(val)
+    def self.dump_hash(hash)
+      # Keys known to hold GlobalIDs even when their value is still a raw gid
+      # string (loaded but never accessed): a LazyAccessHash carries them on an
+      # ivar; a raw storage hash carries them in its embedded marker.
+      carried =
+        if hash.respond_to?(:lazy_gid_keys) && hash.lazy_gid_keys
+          Array(hash.lazy_gid_keys).map(&:to_s)
+        elsif (m = marker_of(hash))
+          Array(m["gid_keys"]).map(&:to_s)
+        else
+          []
+        end
+
+      gid_keys = []
+      out = {}
+      hash.to_h.each do |k, v|
+        ks = k.to_s
+        next if ks == MARKER
+
+        if v.is_a?(ActiveRecord::Base)
+          out[ks] = v.to_gid.to_s
+          gid_keys << ks
+        elsif carried.include?(ks) && v.is_a?(String)
+          out[ks] = v
+          gid_keys << ks
+        else
+          out[ks] = dump(v)
         end
-        @access_cache[key]
       end
+      out[MARKER] = { "gid_keys" => gid_keys } unless gid_keys.empty?
+      out
+    end
+
+    def self.locate(gid_string)
+      return gid_string unless gid_string.is_a?(String)
+      GlobalID::Locator.locate(gid_string)
+    end
+
+    # Read the reserved marker hash regardless of string/symbol keying.
+    def self.marker_of(hash)
+      m = hash[MARKER]
+      m = hash[MARKER.to_sym] if m.nil?
+      m.is_a?(Hash) ? m.with_indifferent_access : nil
+    end
+
+    # ---- Lazy element access ----
+
+    def [](*args)
+      # Only the single-key form is lazily resolved/cached. Multi-arg or Range
+      # access (e.g. Array#[start, length] / arr[1..3]) delegates to super.
+      if Thread.current[:lazy_access_read_raw] || args.length != 1 || args.first.is_a?(Range)
+        return super
+      end
+
+      key = args.first
+      key = key.to_s if key.is_a?(Symbol)
+      return nil if key == MARKER
+
+      unless @access_cache.key?(key)
+        val = super
+        @access_cache[key] = _resolve_lazy_value(key, val)
+      end
+      @access_cache[key]
     end
 
     def []=(key, value)
@@ -60,6 +139,16 @@ module Joblin
       @access_cache[key] = value
       super
     end
+
+    private
+
+    def _resolve_lazy_value(key, val)
+      if lazy_gid_keys && lazy_gid_keys.include?(key.to_s)
+        LazyAccess.locate(val)
+      else
+        LazyAccess.load(val)
+      end
+    end
   end
 
   class LazyAccessHash < HashWithIndifferentAccess

data/lib/joblin/uniqueness/compat/active_job.rb

@@ -12,7 +12,7 @@ module Joblin::Uniqueness
           job_class.set(
             queue: job_queue.to_sym,
             wait: schedule_in,
-            priortity: job_instance.priority,
+            priority: job_instance.priority,
           ).perform_later(*job_instance.arguments)
         end
       end

data/lib/joblin/uniqueness/job_uniqueness.rb

@@ -33,6 +33,8 @@ module Joblin::Uniqueness
     end
   end
 
+  class StrategyNotFound < StandardError; end
+
   class << self
     def configure
       yield config

data/lib/joblin/uniqueness/lock_context.rb

@@ -61,6 +61,10 @@ module Joblin::Uniqueness
       lock_strategy.send(:"on_#{stage}", *args, **kwargs, &blk)
     rescue CouldNotLockError => e
       call_conflict_strategy(stage)
+      # A conflict means the original job must NOT be enqueued/run. Sidekiq's
+      # client treats a truthy middleware return as the payload to push, so we
+      # must return nil here regardless of what the conflict strategy returned.
+      nil
     end
 
     def lock_strategy

data/lib/joblin/uniqueness/on_conflict/log.rb

@@ -7,6 +7,7 @@ module Joblin::Uniqueness
         Joblin::Uniqueness.logger.info(<<~MESSAGE.chomp)
           Skipping job with id (#{lock_context.job_id}) because key: (#{lock_context.base_key}) is locked
         MESSAGE
+        nil
       end
     end
   end

data/lib/joblin/uniqueness/on_conflict/reject.rb

@@ -10,8 +10,15 @@ module Joblin::Uniqueness
           return
         end
 
+        # Sidekiq::DeadSet lives in sidekiq/api, which isn't loaded server-side
+        # by default; require it so we don't blow up with NameError here.
+        require "sidekiq/api"
+
         kwargs = {}
-        kwargs[:notify_failure] = false if Sidekiq::DeadSet.instance_method(:kill).arity > 1
+        # Sidekiq's DeadSet#kill is `kill(message, opts = {})` (arity -2) on 7/8
+        # and `kill(message)` (arity 1) on very old versions. Pass notify_failure
+        # only when the method actually accepts options.
+        kwargs[:notify_failure] = false if Sidekiq::DeadSet.instance_method(:kill).arity != 1
 
         sidekiq_message = lock_context.instance_variable_get(:@job_instance)
         Sidekiq::DeadSet.new.kill(JSON.dump(sidekiq_message), **kwargs)

data/lib/joblin/uniqueness/strategy/until_expired.rb

@@ -10,6 +10,7 @@ module Joblin::Uniqueness
 
       def on_perform
         lock!(:perform)
+        yield
       end
     end
   end

data/lib/joblin/uniqueness/unique_job_common.rb

@@ -11,8 +11,8 @@ module Joblin::Uniqueness
       # ensure_uniqueness(
       #   strategy: :until_executed, # :until_executed, :until_executing, :until_expired, :until_and_while_executing, :while_executing
       #   on_conflict: :raise, # :raise, :log, :reject, :reschedule, { enqueue: ..., perform: ... }, proc
-      #   lock_ttl: 7.days, # seconds
-      #   lock_timeout: 0, # seconds
+      #   ttl: 7.days, # seconds
+      #   timeout: 0, # seconds
 
       #   scope: :per_queue, # :global, :per_queue, string ("<class>-<queue>"), proc
       #   hash: ->{ { ... } },
@@ -41,6 +41,7 @@ module Joblin::Uniqueness
         kwargs[:ttl] ||= 30.days.to_i
         kwargs[:timeout] ||= 0
         kwargs[:limit] ||= 1
+        kwargs[:unlock_on_failure] ||= :stagnant
 
         self.unique_job_options = kwargs
 
@@ -53,18 +54,25 @@ module Joblin::Uniqueness
 
       class_methods do
         def unlock!(jid = nil, args: nil, kwargs: nil, queue: nil)
-          queue = self.try(:default_queue_name) || try(:queue)
+          # Only fall back to the class default when the caller didn't pass a queue.
+          queue ||= self.try(:default_queue_name) || try(:queue)
           raise ArgumentError, "Must specify queue:" unless queue.is_a?(String) || queue.is_a?(Symbol)
 
           temp_context = LockContext.new({ job_clazz: self, jid: jid, queue: queue, args: args, kwargs: kwargs })
           strategy = temp_context.lock_strategy
-          locksmith = strategy.send(:locksmith)
+
+          # until_and_while_executing keeps a second (":RUN") lock via its runtime
+          # strategy; clear both so those locks aren't stranded.
+          locksmiths = [strategy.send(:locksmith)]
+          if strategy.respond_to?(:runtime_lock, true)
+            locksmiths << strategy.send(:runtime_lock).send(:locksmith)
+          end
 
           if jid
-            locksmith.unlock!()
+            locksmiths.each(&:unlock!)
           else
-            locksmith.locked_jids.each do |jid|
-              unlock!(jid, args: args, kwargs: kwargs, queue: queue)
+            locksmiths.flat_map(&:locked_jids).uniq.each do |locked_jid|
+              unlock!(locked_jid, args: args, kwargs: kwargs, queue: queue)
             end
           end
         end

data/lib/joblin/version.rb

@@ -1,3 +1,3 @@
 module Joblin
-  VERSION = "0.1.12".freeze
+  VERSION = "0.2.0".freeze
 end