joblin 0.1.11 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fee4e742fd313bae02c2d077066985c147749f207dfd211ac5adb29426a80d84
-  data.tar.gz: d0d074e5a51d65ee15a63e23a549240014f2d09c882ce5632163ab4a9a444c7a
+  metadata.gz: e87b736e32f7b502592a72a08da939d0a2ef95302e96b491f8d258bcdafcfab1
+  data.tar.gz: 97df4d3166bb653f6362d11b600c91a805c4cdc368091690265ae2c686c136d2
 SHA512:
-  metadata.gz: 8f91c842abc953c54b356d4fb58e69bfda58e30684ede90b71a7e5503d54c198a0ae823e5e84ee81c94d5af92d8260bb331deb5f4270a09313c695d8d2afbd99
-  data.tar.gz: 8a3c1553aff7ac339d16e30931e5960aaee92047b4424b9a59e6b8d4f1ea6d38a5a8e3c8a3ad2aa999bc36dd694ff80ee579013c0047066de03d62baab24637a
+  metadata.gz: 352592cc3733c55879d51ac118c242184140d174f7873b632a6695a7536a641493a3515377a5b838bc1d27e22c9cb5092517b8d4096098b96cfc124561ea558e
+  data.tar.gz: a818e8053990c09106eb47a21ca8bd70aeea51a21a3d21f8a14de54bd6f03e7aa4931913d145b90db8a8c3907eb1bb78ae0dd4f25cc3e07450d120bead87cde8

data/app/models/joblin/background_task/api_access.rb

@@ -19,6 +19,7 @@ module Joblin
         def allow_api_access!(&blk)
           include Mixin unless self < Mixin
           @api_access_allowed = true
+          BackgroundTask.api_accessible_types[name] = self if name
           api_access_rules(&blk) if blk
         end
 
@@ -27,6 +28,15 @@ module Joblin
           @api_access_allowed
         end
 
+        # Registry (name => class) of task types that opted into API access.
+        # build_from_api resolves params[:type] against this instead of
+        # constantizing arbitrary user input, so an unknown/hostile type can't
+        # autoload arbitrary constants.
+        def api_accessible_types
+          BackgroundTask.instance_variable_get(:@api_accessible_types) ||
+            BackgroundTask.instance_variable_set(:@api_accessible_types, {})
+        end
+
         def find_for_api(id)
           task = find(id)
           raise ActiveRecord::RecordNotFound unless task.api_access_allowed?
@@ -41,7 +51,7 @@ module Joblin
             params ||= controller_or_params
           end
 
-          task_type = self == BackgroundTask ? params[:type].safe_constantize : self
+          task_type = self == BackgroundTask ? api_accessible_types[params[:type].to_s] : self
           raise ActiveRecord::RecordNotFound unless task_type && task_type <= BackgroundTask
 
           task = task_type.new
@@ -68,7 +78,10 @@ module Joblin
           raise ActiveRecord::RecordInvalid.new(task) unless task.api_access_allowed?
 
           val_errors = task.api_validate_options
-          raise ActiveRecord::ValidationError.new(val_errors) unless val_errors.empty?
+          unless val_errors.empty?
+            val_errors.each { |msg| task.errors.add(:base, msg) }
+            raise ActiveRecord::RecordInvalid.new(task)
+          end
 
           task
         end

data/app/models/joblin/background_task/attachments.rb

@@ -38,9 +38,9 @@ module Joblin
           save_as = save_as || send(key).filename.to_s || key.to_s
           save_as = File.join(working_dir, save_as) unless Pathname.new(save_as).absolute?
 
-          File.open(save_as, 'w') do |file|
+          File.open(save_as, 'wb') do |file|
             send(key).download do |chunk|
-              file.write(chunk.force_encoding("UTF-8"))
+              file.write(chunk)
             end
           end
           save_as

data/app/models/joblin/background_task/retention_policy.rb

@@ -16,12 +16,20 @@ module Joblin
       class BackgroundTaskCleaner < ActiveJob::Base
         def perform
           types = BackgroundTask.distinct.pluck(:type)
-          types.each do |type|
-            type = type.constantize
-            rp = type.record_retention
+          types.each do |type_name|
+            klass = type_name ? type_name.safe_constantize : BackgroundTask
+            # Skip rows whose class has been renamed/removed rather than aborting
+            # the whole cleanup run.
+            next unless klass && klass <= BackgroundTask
+
+            rp = klass.record_retention
             next unless rp
 
-            type.where("created_at < ?", rp.ago).destroy_all
+            # Scope by the exact type column so a parent policy doesn't reap
+            # subclass rows that declared their own (longer) retention.
+            BackgroundTask.where(type: type_name)
+                          .where("created_at < ?", rp.ago)
+                          .destroy_all
           end
         end
       end

data/app/models/joblin/background_task.rb

@@ -22,12 +22,19 @@ module Joblin
         joins("LEFT OUTER JOIN #{t} AS t2 ON #{t}.type = t2.type AND #{t}.created_at < t2.created_at")
           .group(:id).order(:type, created_at: :desc).having('count(*) < ?', history_length)
       else
+        # DISTINCT ON requires the distinct expression to lead the ORDER BY;
+        # created_at DESC then picks the most recent row per type.
         select("DISTINCT ON (#{t}.type) #{t}.*")
+          .order(Arel.sql("#{t}.type, #{t}.created_at DESC"))
       end
     }
 
     def enqueue!
-      self.workflow_state = 'scheduled' if self.workflow_state == 'unscheduled'
+      # Persist the transition here so it isn't lost when enter_batch reuses an
+      # existing batch_id (and doesn't otherwise write the record) — e.g. a
+      # re-enqueue after failure must not stay `failed`.
+      self.workflow_state = 'scheduled'
+      save! if changed?
 
       enter_batch do
         self.class::ExecutorJob.perform_later()

data/db/migrate/20260709120000_add_indexes_to_joblin_background_tasks.rb

@@ -0,0 +1,10 @@
+class AddIndexesToJoblinBackgroundTasks < Joblin::MiscHelper::MigrationClass
+  def change
+    # Retention cleanup filters on (type, created_at) and grouped_history orders
+    # by the same pair; a composite index keeps both off a sequential scan.
+    add_index :joblin_background_tasks, [:type, :created_at], if_not_exists: true
+
+    # Batch callbacks look tasks up by batch_id.
+    add_index :joblin_background_tasks, :batch_id, if_not_exists: true
+  end
+end

data/lib/joblin/batching/batch.rb

@@ -221,7 +221,7 @@ module Joblin::Batching
       unless defined?(@closed)
         @closed = redis.hget(@bidkey, 'complete') == 'true'
       end
-      raise "Cannot add jobs to Batch #{} bid - it has already entered the callback-stage" if @closed
+      raise "Cannot add jobs to Batch #{bid} - it has already entered the callback-stage" if @closed
     end
 
     def persist!
@@ -236,6 +236,7 @@ module Joblin::Batching
             r.hincrby("BID-#{parent_bid}", "children", 1)
             r.expire("BID-#{parent_bid}", BID_EXPIRE_TTL)
             r.zadd("BID-#{parent_bid}-bids", created_at, bid)
+            r.expire("BID-#{parent_bid}-bids", BID_EXPIRE_TTL)
           else
             r.zadd("BID-ROOT-bids", created_at, bid)
           end
@@ -275,38 +276,64 @@ module Joblin::Batching
 
         precount = 0
 
-        all_results = redis do |r|
-          return unless r.exists?("BID-#{bid}")
+        # WATCH the batch hash so this transaction (the caller's mutations *and*
+        # the state reads/expirations, some of which — e.g. hincrby "pending" —
+        # would otherwise recreate the hash) aborts if a concurrent cleanup_redis
+        # deletes the batch after we've checked it exists. An aborted EXEC applies
+        # nothing, so re-running the block on retry is safe (no double-apply).
+        # Concurrent mutations of the *same* bid can also abort us; we retry a
+        # bounded number of times and give up loudly rather than spin forever.
+        max_attempts = 50
+        all_results =
+          redis do |r|
+            attempts = 0
+            loop do
+              attempts += 1
+              result = r.watch("BID-#{bid}") do |rc|
+                if rc.exists?("BID-#{bid}")
+                  rc.multi do |r|
+                    blk.call(r)
+                    futures = r.instance_variable_get(:@futures) || r.instance_variable_get(:@pipeline)&.futures || r.instance_variable_get(:@client)&.futures
+                    precount = futures.size
+
+                    # Misc
+                    r.hget("BID-#{bid}", "parent_bid")
+                    r.hget("BID-#{bid}", "keep_open")
+                    r.scard("BID-#{bid}-holds")
+
+                    # Jobs
+                    r.hincrby("BID-#{bid}", "pending", 0)
+                    r.scard("BID-#{bid}-failed")
+                    r.scard("BID-#{bid}-dead")
+
+                    # Batches
+                    r.hincrby("BID-#{bid}", "children", 0)
+                    r.scard("BID-#{bid}-batches-complete")
+                    r.scard("BID-#{bid}-batches-success")
+                    r.scard("BID-#{bid}-batches-failed")
+                    r.scard("BID-#{bid}-batches-stagnated")
+
+                    # Touch Expirations
+                    r.expire("BID-#{bid}", BID_EXPIRE_TTL)
+                    r.expire("BID-#{bid}-batches-success", BID_EXPIRE_TTL)
+                  end
+                else
+                  # Batch was cleaned up; nothing to process.
+                  rc.unwatch
+                  :missing
+                end
+              end
 
-          r.multi do |r|
-            # The block probably doesn't _have_ to be part of the same transaction, but it was easier than
-            #   re-assessing possible race-conditions and is technically more performant
-            blk.call(r)
-            futures = r.instance_variable_get(:@futures) || r.instance_variable_get(:@pipeline)&.futures || r.instance_variable_get(:@client)&.futures
-            precount = futures.size
-
-            # Misc
-            r.hget("BID-#{bid}", "parent_bid")
-            r.hget("BID-#{bid}", "keep_open")
-            r.scard("BID-#{bid}-holds")
-
-            # Jobs
-            r.hincrby("BID-#{bid}", "pending", 0)
-            r.scard("BID-#{bid}-failed")
-            r.scard("BID-#{bid}-dead")
-
-            # Batches
-            r.hincrby("BID-#{bid}", "children", 0)
-            r.scard("BID-#{bid}-batches-complete")
-            r.scard("BID-#{bid}-batches-success")
-            r.scard("BID-#{bid}-batches-failed")
-            r.scard("BID-#{bid}-batches-stagnated")
-
-            # Touch Expirations
-            r.expire("BID-#{bid}", BID_EXPIRE_TTL)
-            r.expire("BID-#{bid}-batches-success", BID_EXPIRE_TTL)
+              # :missing => batch gone; Array => committed; nil => EXEC aborted (retry).
+              break result unless result.nil?
+
+              if attempts >= max_attempts
+                raise "with_callback_check: gave up after #{attempts} attempts due to contention on BID-#{bid}"
+              end
+            end
           end
-        end
+
+        return if all_results == :missing
 
         # Exclude return values from the passed block
         actual_results = all_results[precount..-1]
@@ -407,7 +434,7 @@ module Joblin::Batching
 
         # User-configured parameters/arguments to pass to the callback
         callback_args = callbacks.reduce([]) do |memo, jcb|
-          cb = JSON.load(jcb)
+          cb = JSON.parse(jcb)
           memo << [cb['callback'], event.to_s, cb['opts'], bid, parent_bid]
         end
 
@@ -487,7 +514,7 @@ module Joblin::Batching
       # Internal method to cleanup a Redis Hash and related keys
       def cleanup_redis_index_for(key, suffixes = [""])
         redis do |r|
-          if r.hget(k, "created_at").present?
+          if r.hget(key, "created_at").present?
             r.multi do |r|
               suffixes.each do |suffix|
                 r.expire(key + suffix, BID_EXPIRE_TTL)

data/lib/joblin/batching/callback.rb

@@ -26,7 +26,12 @@ module Joblin::Batching
           method ||= "on_#{event}"
           status = Batch::Status.new(bid)
 
-          if clazz && object = Object.const_get(clazz)
+          # safe_constantize returns nil (rather than raising NameError) for an
+          # unknown/typo'd class, so a bad callback name logs a warning instead
+          # of retrying forever and stranding the triggering batch.
+          object = clazz.is_a?(String) ? clazz.safe_constantize : clazz
+
+          if object
             target = target == :instance ? object.new : object
             if target.respond_to?(method, true)
               target.send(method, status, opts.with_indifferent_access)
@@ -87,6 +92,7 @@ module Joblin::Batching
             r.sadd("BID-#{parent_bid}-batches-success", bid)
             r.srem("BID-#{parent_bid}-batches-failed", bid)
             r.sadd("BID-#{parent_bid}-batches-complete", bid)
+            r.expire("BID-#{parent_bid}-batches-complete", BID_EXPIRE_TTL)
           end
         end
 
@@ -113,6 +119,8 @@ module Joblin::Batching
             Batch.with_callback_check(parent_bid, except: [:success]) do |r|
               r.sadd("BID-#{parent_bid}-batches-complete", bid)
               r.sadd("BID-#{parent_bid}-batches-failed", bid)
+              r.expire("BID-#{parent_bid}-batches-complete", BID_EXPIRE_TTL)
+              r.expire("BID-#{parent_bid}-batches-failed", BID_EXPIRE_TTL)
             end
           end
         end

data/lib/joblin/batching/chain_builder.rb

@@ -79,11 +79,12 @@ module Joblin::Batching
 
         chain = self.class.get_chain_parameter(parent_job)
 
-        if parent_job[:job] != needed_parent_type
+        # Compare by name: parent_job[:job] may be a Class or its String name.
+        if parent_job[:job].to_s != needed_parent_type.to_s
           old_job = chain[sub_index]
           parent_job = chain[sub_index] = {
             job: needed_parent_type,
-            parameters: [],
+            args: [],
           }
           sub_index = 0
           chain = self.class.get_chain_parameter(parent_job)

data/lib/joblin/batching/compat/sidekiq/web/views/_batches_table.erb

@@ -26,8 +26,8 @@
         <% status = Joblin::Batching::Batch::Status.new(batch) %>
         <tr>
             <td><%= safe_relative_time(batch.created_at.to_f) %></th>
-            <td><a href="<%= root_path %>batches/<%= batch.bid %>"><%= batch.bid %></a></td>
-            <td><%= batch.description %></th>
+            <td><a href="<%= root_path %>batches/<%= h(batch.bid) %>"><%= h(batch.bid) %></a></td>
+            <td><%= h(batch.description) %></th>
 
             <td><%= status.pending %></th>
             <td><%= status.failures %></th>

data/lib/joblin/batching/compat/sidekiq/web/views/_jobs_table.erb

@@ -9,11 +9,11 @@
 
     <% @jobs.each do |job_desc| %>
         <tr>
-            <td><%= job_desc[:jid] %></td>
-            <td><%= job_desc['job'] %></td>
+            <td><%= h(job_desc[:jid]) %></td>
+            <td><%= h(job_desc['job']) %></td>
             <td>
                 <code class="code-wrap">
-                    <div class="args-extended"><%= job_desc['parameters'].to_json  %></div>
+                    <div class="args-extended"><%= h(job_desc['parameters'].to_json) %></div>
                 </code>
             </td>
         </tr>

data/lib/joblin/batching/compat/sidekiq/web/views/batch.erb

@@ -8,13 +8,13 @@
         <tbody>
             <tr>
                 <th colspan="2" scope=row><%= t('Batch') %></td>
-                <td><%= @batch.bid %></td>
+                <td><%= h(@batch.bid) %></td>
             </tr>
             <tr>
                 <th colspan="2" scope=row><%= t('Parent') %></td>
                 <td>
                     <% if @batch.parent_bid.present? %>
-                        <a href="<%= root_path %>batches/<%= @batch.parent_bid %>"><%= @batch.parent_bid %></a>
+                        <a href="<%= root_path %>batches/<%= h(@batch.parent_bid) %>"><%= h(@batch.parent_bid) %></a>
                     <% else %>
                         ROOT
                     <% end %>
@@ -26,7 +26,7 @@
             </tr>
             <tr>
                 <th colspan="2" scope=row><%= t('Description') %></td>
-                <td><%= @batch.description %></td>
+                <td><%= h(@batch.description) %></td>
             </tr>
             <tr>
                 <th colspan="2" scope=row><%= t('Context') %></td>
@@ -63,7 +63,7 @@
     %>
     <% if @jobs.any? && @total_size > @count.to_i %>
         <div class="col-sm-4">
-            <%= erb get_template(:_pagination), locals: { url: "#{root_path}batches/#{@batch.bid}", page_key: :job_page } %>
+            <%= erb get_template(:_pagination), locals: { url: "#{root_path}batches/#{h(@batch.bid)}", page_key: :job_page } %>
         </div>
     <% end %>
 </header>
@@ -74,7 +74,7 @@
 </div>
 <% end %>
 
-<form class="form-horizontal" action="<%= root_path %>batches/<%= @batch.bid %>" method="post">
+<form class="form-horizontal" action="<%= root_path %>batches/<%= h(@batch.bid) %>" method="post">
     <%= csrf_tag %>
     <a class="btn btn-default" href="<%= root_path %>batches"><%= t('GoBack') %></a>
     <input class="btn btn-danger" type="submit" name="delete" value="<%= t('Delete') %>" data-confirm="<%= t('AreYouSure') %>" />

data/lib/joblin/batching/compat/sidekiq/web/views/pool.erb

@@ -13,11 +13,11 @@
             </tr>
             <tr>
                 <th scope=row><%= t('Description') %></td>
-                <td><%= @pool.description %></td>
+                <td><%= h(@pool.description) %></td>
             </tr>
             <tr>
                 <th scope=row><%= t('Type') %></td>
-                <td><%= @pool.order.to_s.upcase %></td>
+                <td><%= h(@pool.order.to_s.upcase) %></td>
             </tr>
             <tr>
                 <th scope=row><%= t('Concurrency') %></td>
@@ -61,13 +61,13 @@
 
         <% @active_tasks.each do |job_desc| %>
             <tr>
-                <td><a href="<%= root_path %>batches/<%= job_desc['pool_wrapper_batch'] %>"><%= job_desc['pool_wrapper_batch'] %></a></td>
-                <td><%= job_desc['job'] %></td>
+                <td><a href="<%= root_path %>batches/<%= h(job_desc['pool_wrapper_batch']) %>"><%= h(job_desc['pool_wrapper_batch']) %></a></td>
+                <td><%= h(job_desc['job']) %></td>
                 <td>
                     <code class="code-wrap">
                         <div class="args-extended">
-                            <%= job_desc['args']&.to_json %>
-                            <%= job_desc['kwargs']&.to_json %>
+                            <%= h(job_desc['args']&.to_json) %>
+                            <%= h(job_desc['kwargs']&.to_json) %>
                         </div>
                     </code>
                 </td>
@@ -90,7 +90,7 @@
     %>
     <% if @jobs.any? && @total_size > @count.to_i %>
         <div class="col-sm-4">
-            <%= erb get_template(:_pagination), locals: { url: "#{root_path}pools/#{@pool.pid}", page_key: :job_page } %>
+            <%= erb get_template(:_pagination), locals: { url: "#{root_path}pools/#{h(@pool.pid)}", page_key: :job_page } %>
         </div>
     <% end %>
 </header>
@@ -111,18 +111,18 @@
 
         <% @jobs.each do |job_desc| %>
             <tr>
-                <td><%= job_desc['job'] %></td>
+                <td><%= h(job_desc['job']) %></td>
                 <td>
                     <code class="code-wrap">
                         <div class="args-extended">
-                            <%= job_desc['args']&.to_json %>
-                            <%= job_desc['kwargs']&.to_json %>
+                            <%= h(job_desc['args']&.to_json) %>
+                            <%= h(job_desc['kwargs']&.to_json) %>
                         </div>
                     </code>
                 </td>
-                <td><a href="<%= root_path %>batches/<%= job_desc['pool_wrapper_batch'] %>"><%= job_desc['pool_wrapper_batch'] %></a></td>
+                <td><a href="<%= root_path %>batches/<%= h(job_desc['pool_wrapper_batch']) %>"><%= h(job_desc['pool_wrapper_batch']) %></a></td>
                 <% if @pool.order == 'priority' %>
-                    <td><%= job_desc['priority'] %></td>
+                    <td><%= h(job_desc['priority']) %></td>
                 <% end %>
             </tr>
         <% end %>
@@ -130,7 +130,7 @@
 </div>
 <% end %>
 
-<form class="form-horizontal" action="<%= root_path %>pools/<%= @pool.pid %>" method="post">
+<form class="form-horizontal" action="<%= root_path %>pools/<%= h(@pool.pid) %>" method="post">
     <%= csrf_tag %>
     <a class="btn btn-default" href="<%= root_path %>pools"><%= t('GoBack') %></a>
     <input class="btn btn-danger" type="submit" name="delete" value="<%= t('Delete') %>" data-confirm="<%= t('AreYouSure') %>" />

data/lib/joblin/batching/compat/sidekiq/web/views/pools.erb

@@ -29,9 +29,9 @@
         <% @pools.each do |pool| %>
         <tr>
             <td><%= safe_relative_time(pool.created_at.to_f) %></th>
-            <td><a href="<%= root_path %>pools/<%= pool.pid %>"><%= pool.pid %></a></td>
-            <td><%= pool.description %></th>
-            <td><%= pool.order.to_s.upcase %></th>
+            <td><a href="<%= root_path %>pools/<%= h(pool.pid) %>"><%= h(pool.pid) %></a></td>
+            <td><%= h(pool.description) %></th>
+            <td><%= h(pool.order.to_s.upcase) %></th>
             <td><%= pool.concurrency %></th>
             <td><%= pool.active_count %></th>
             <td><%= pool.pending_count %></th>

data/lib/joblin/batching/compat/sidekiq/web.rb

@@ -39,6 +39,18 @@ module Joblin::Batching::Compat::Sidekiq
         (env["rack.route_params"] || {})[key.to_sym]
       end
 
+      # Read a query-string parameter such as `count` or `page`.
+      #
+      # Sidekiq 7+ defines `url_params(key)` on the web action and returns the
+      # query value only. Sidekiq 6.x has no `url_params`; there the action's
+      # `params` is an indifferent hash that already merges the query string,
+      # so we read from it. On Sidekiq 7/8 the action's own `url_params`
+      # shadows this fallback (a class's instance method wins over one from an
+      # included module), so this definition only takes effect on Sidekiq 6.x.
+      def url_params(key)
+        params[key]
+      end
+
       def tree_data(root_bid, slice: nil)
         tree_bids = Joblin::Batching::Batch.bid_hierarchy(root_bid, slice: slice)
 
@@ -98,7 +110,11 @@ module Joblin::Batching::Compat::Sidekiq
         own_keys = batch.context.own.keys
         batch.context.flatten.each do |k,v|
           added = own_keys.include? k
-          bits << "  <span class=\"key #{added ? 'own' : 'inherited'}\">\"#{k}\": #{v.to_json},</span>"
+          # Both the key and the JSON-encoded value are app/user data; escape
+          # them so batch context can't inject markup into this page.
+          safe_key = Rack::Utils.escape_html(k.to_s)
+          safe_val = Rack::Utils.escape_html(v.to_json)
+          bits << "  <span class=\"key #{added ? 'own' : 'inherited'}\">\"#{safe_key}\": #{safe_val},</span>"
         end
         bits = [
           "{ // <span class=\"own\">Added</span> / <span class=\"inherited\">Inherited</span>",

data/lib/joblin/batching/context_hash.rb

@@ -144,7 +144,7 @@ module Joblin::Batching
         context_hash.each do |k, v|
           v.freeze
         end
-        context_hash.freeze unless editable
+        context_hash.freeze unless editable == true || editable == "true"
 
         @hash_map[bid] = context_hash
       else

data/lib/joblin/batching/jobs/managed_batch_job.rb

@@ -2,6 +2,12 @@ require_relative './base_job'
 
 module Joblin::Batching
   class ManagedBatchJob < BaseJob
+    # preflight_check: an optional "Class.method" (or bare "method" on Object)
+    # string, invoked with the deserialized next job just before it is enqueued.
+    # Its return value controls the sequence:
+    #   :abort  -> abort the whole managed batch (cleanup and stop)
+    #   falsy   -> skip this job and advance to the next one
+    #   truthy  -> enqueue and run this job (the default lambda returns true)
     def self.make_batch(sub_jobs, ordered: true, concurrency: nil, context: nil, preflight_check: nil, description: nil, desc_prefix: nil, &blk)
       desc_prefix ||= ''
 
@@ -127,13 +133,13 @@ module Joblin::Batching
         break unless next_job_json.present?
 
         next_job = JSON.parse(next_job_json)
-        next_job = ::ActiveJob::Arguments.deserialize(next_job)[0]
+        next_job = ::ActiveJob::Arguments.deserialize(next_job)[0]&.symbolize_keys
 
         preflight_result = preflight_check.call(next_job)
         if preflight_result == :abort
           cleanup_redis(nil, { "managed_batch_id" => man_batch_id })
           break
-        elsif !preflight_check
+        elsif !preflight_result
           next
         end
 

data/lib/joblin/batching/pool.rb

@@ -37,6 +37,13 @@ module Joblin::Batching
     end
 
     def add_jobs(job_descs, skip_refill: false)
+      # Adding to a pool that has already been cleaned up (e.g. it drained to
+      # empty and auto-removed) would strand the job forever. Long-lived
+      # producers that add over time must hold the pool open with `keep_open!`.
+      unless redis.exists?(redis_key)
+        raise "Cannot add jobs to Pool #{pid}: it no longer exists. Wrap long-lived producers in `keep_open!`."
+      end
+
       job_descs.each do |job_desc|
         wrapper = Batch.new
         wrapper.description = "Pool Job Wrapper (PID: #{pid})"
@@ -147,8 +154,10 @@ module Joblin::Batching
     # Administrative/console method to cleanup expired pools from the WebUI
     def self.cleanup_redis_index!
       suffixes = ["", "-active", "-jobs"]
-      r.zrangebyscore("pools", "0", Batch::BID_EXPIRE_TTL.seconds.ago.to_i).each do |pid|
-        r.zrem("pools", pid) if Batch.cleanup_redis_index_for("POOLID-#{pid}", suffixes)
+      redis do |r|
+        r.zrangebyscore("pools", "0", Batch::BID_EXPIRE_TTL.seconds.ago.to_i).each do |pid|
+          r.zrem("pools", pid) if Batch.cleanup_redis_index_for("POOLID-#{pid}", suffixes)
+        end
       end
     end
 
@@ -245,7 +254,7 @@ module Joblin::Batching
       self.created_at = Time.now.utc.to_f
       self.description = description
       self.order = order
-      self.concurrency = concurrency
+      self.concurrency = concurrency || 1
       self.clean_when_empty = clean_when_empty
       self.on_failed_job = on_failed_job
       flush_pending_attrs

data/lib/joblin/batching/pool_refill.lua

@@ -15,7 +15,8 @@ if checkin_item ~= "" then
 end
 
 local pool_type = redis.call('HGET', poolkey, "order")
-local allotment = tonumber(redis.call("HGET", poolkey, "concurrency"))
+-- Treat an unset/blank concurrency as 1 rather than erroring on tonumber("") -> nil
+local allotment = tonumber(redis.call("HGET", poolkey, "concurrency")) or 1
 local active = redis.call("HLEN", activekey) + (redis.call("HGET", poolkey, "_active_count") or 0)
 
 local pop_count = allotment - active

data/lib/joblin/batching/schedule_callback.lua

@@ -1,4 +1,10 @@
 
+-- If the batch hash is already gone (cleaned up), don't resurrect it with a
+-- fresh HSET. Report it as already-processed so no callback is (re-)scheduled.
+if redis.call('EXISTS', KEYS[1]) == 0 then
+    return 'true'
+end
+
 local previously_scheduled = redis.call('HGET', KEYS[1], ARGV[1])
 redis.call('HSET', KEYS[1], ARGV[1], 'true')