AO3-6895 Reduce the number of badly closed database connections

app/controllers/challenge_signups_controller.rb

@@ -3,6 +3,7 @@
 
 class ChallengeSignupsController < ApplicationController
   include ExportsHelper
+  Resque::Job.extend(ResqueExecutorWrap)
 
   before_action :users_only, except: [:summary, :display_summary, :requests_summary]
   before_action :load_collection, except: [:index]

app/controllers/troubleshooting_controller.rb

@@ -3,6 +3,7 @@
 # A controller used to let admins and tag wranglers perform some
 # troubleshooting on tags and works.
 class TroubleshootingController < ApplicationController
+  Resque::Job.extend(ResqueExecutorWrap)
   before_action :check_permission_to_wrangle
   before_action :load_item
   before_action :check_visibility

app/jobs/redis_set_job.rb

@@ -35,7 +35,7 @@
 
   def perform(*args, **kwargs)
     scan_and_remove(redis, key, batch_size: batch_size) do |batch|
-      perform_on_batch(batch, *args, **kwargs)
+      Rails.application.executor.wrap {perform_on_batch(batch, *args, **kwargs)}
     end
   end
 

app/models/bookmark.rb

@@ -131,6 +131,8 @@ def check_new_external_work
   after_create :update_work_stats
   after_destroy :update_work_stats, :update_pseud_index
 
+  Resque::Job.extend(ResqueExecutorWrap)
+
   def invalidate_bookmark_count
     work = Work.where(id: self.bookmarkable_id)
     if work.present? && self.bookmarkable_type == 'Work'

app/models/challenge_assignment.rb

@@ -80,6 +80,7 @@ def signups_match
   }
 
   scope :posted, -> { joins(WORKS_JOIN).where("challenge_assignments.creation_id IS NOT NULL AND works.posted = 1") }
+  Resque::Job.extend(ResqueExecutorWrap)
 
   # should be faster than unfulfilled scope because no giant left joins
   def self.unfulfilled_in_collection(collection)

app/models/challenge_signup_summary.rb

@@ -1,5 +1,5 @@
 class ChallengeSignupSummary
-
+  Resque::Job.extend(ResqueExecutorWrap)
   attr_reader :collection, :challenge
 
   def initialize(collection)

app/models/concerns/async_with_resque.rb

@@ -22,14 +22,16 @@ def async(method, *args)
 
     # Actually perform the delayed action.
     def perform(method, *args)
-      if method.is_a?(Integer)
-        # TODO: For backwards compatibility, if the "method" is an integer, we
-        # treat it like an ID and use perform_on_instance instead. But once all
-        # of the jobs in the queue have been processed (or deleted), we should
-        # be able to remove this check.
-        perform_on_instance(method, *args)
-      else
-        send(method, *args)
+      Rails.application.executor.wrap do
+        if method.is_a?(Integer)
+          # TODO: For backwards compatibility, if the "method" is an integer, we
+          # treat it like an ID and use perform_on_instance instead. But once all
+          # of the jobs in the queue have been processed (or deleted), we should
+          # be able to remove this check.
+          perform_on_instance(method, *args)
+        else
+          send(method, *args)
+        end
       end
     end
 

app/models/concerns/filterable.rb

@@ -3,6 +3,7 @@
 # A module for types that are supposed to have FilterTaggings, calculated based
 # on their tags. Includes Taggable.
 module Filterable
+  Resque::Job.extend(ResqueExecutorWrap)
   extend ActiveSupport::Concern
   include Taggable
 

app/models/indexing/index_queue.rb

@@ -1,4 +1,5 @@
 class IndexQueue
+  Resque::Job.extend(ResqueExecutorWrap)
 
   BATCH_SIZE = 1000
   REDIS = REDIS_GENERAL

app/models/potential_match.rb

@@ -1,4 +1,5 @@
 class PotentialMatch < ApplicationRecord
+  Resque::Job.extend(ResqueExecutorWrap)
   # We use "-1" to represent all the requested items matching
   ALL = -1
 

app/models/pseud.rb

@@ -2,6 +2,7 @@ class Pseud < ApplicationRecord
   include Searchable
   include WorksOwner
   include Justifiable
+  Resque::Job.extend(ResqueExecutorWrap)
 
   has_one_attached :icon do |attachable|
     attachable.variant(:standard, resize_to_limit: [100, 100])

app/models/redis_hit_counter.rb

@@ -3,6 +3,7 @@
 class RedisHitCounter
   class << self
     include RedisScanning
+    Resque::Job.extend(ResqueExecutorWrap)
 
     # Records a hit for the given IP address on the given work ID. If the IP
     # address hasn't visited the work within the current 24 hour block, we

app/models/search/async_indexer.rb

@@ -1,5 +1,5 @@
 class AsyncIndexer
-
+  Resque::Job.extend(ResqueExecutorWrap)
   REDIS = REDIS_GENERAL
 
   ####################

app/models/search/index_sweeper.rb

@@ -1,4 +1,5 @@
 class IndexSweeper
+  Resque::Job.extend(ResqueExecutorWrap)
 
   REDIS = AsyncIndexer::REDIS
 

app/models/search/indexer.rb

@@ -8,6 +8,7 @@ class Indexer
     Series: %w[BookmarkedSeriesIndexer],
     ExternalWork: %w[BookmarkedExternalWorkIndexer]
   }.freeze
+  Resque::Job.extend(ResqueExecutorWrap)
 
   delegate :klass, :klass_with_includes, :index_name, :document_type, to: :class
 

app/models/serial_work.rb

@@ -11,6 +11,7 @@ class SerialWork < ApplicationRecord
   after_destroy :update_series_index, :update_work_index
 
   scope :in_order, -> { order(:position) }
+  Resque::Job.extend(ResqueExecutorWrap)
 
   # If you add or remove a work from a series, make sure restricted? is still accurate
   def adjust_series_visibility

app/models/series.rb

@@ -22,6 +22,8 @@ class Series < ApplicationRecord
     maximum: ArchiveConfig.TITLE_MAX,
     too_long: ts("must be less than %{max} letters long.", max: ArchiveConfig.TITLE_MAX)
 
+  Resque::Job.extend(ResqueExecutorWrap)
+
   # return title.html_safe to overcome escaping done by sanitiser
   def title
     read_attribute(:title).try(:html_safe)

app/models/stat_counter.rb

@@ -3,6 +3,8 @@ class StatCounter < ApplicationRecord
 
   after_commit :enqueue_to_index, on: :update
 
+  Resque::Job.extend(ResqueExecutorWrap)
+
   def enqueue_to_index
     IndexQueue.enqueue(self, :stats)
   end

app/models/tag.rb

@@ -7,6 +7,8 @@ class Tag < ApplicationRecord
   include Wrangleable
   include Rails.application.routes.url_helpers
 
+  Resque::Job.extend(ResqueExecutorWrap)
+
   NAME = "Tag"
 
   # Note: the order of this array is important.

app/models/tagging.rb

@@ -12,6 +12,8 @@ class Tagging < ApplicationRecord
   after_create :update_filters
   after_destroy :update_filters
 
+  Resque::Job.extend(ResqueExecutorWrap)
+
   def update_filters
     return unless taggable.is_a?(Filterable)
 

app/models/user.rb

@@ -17,6 +17,8 @@ class User < ApplicationRecord
   # properly
   include BackwardsCompatiblePasswordDecryptor
 
+  Resque::Job.extend(ResqueExecutorWrap)
+
   # Allows other models to get the current user with User.current_user
   cattr_accessor :current_user
 

app/models/work.rb

@@ -8,6 +8,8 @@ class Work < ApplicationRecord
   include WorkChapterCountCaching
   include Creatable
 
+  Resque::Job.extend(ResqueExecutorWrap)
+
   ########################################################################
   # ASSOCIATIONS
   ########################################################################

lib/bookmarkable.rb

@@ -1,4 +1,5 @@
 module Bookmarkable
+  Resque::Job.extend(ResqueExecutorWrap)
 
   def self.included(bookmarkable)
     bookmarkable.class_eval do

lib/resque_executor_wrap.rb

@@ -0,0 +1,5 @@
+module ResqueExecutorWrap
+  def around_perform_wrap_executor(*args)
+    Rails.application.executor.wrap { yield }
+  end
+end

lib/searchable.rb

@@ -1,4 +1,5 @@
 module Searchable
+  Resque::Job.extend(ResqueExecutorWrap)
 
   def self.included(searchable)
     searchable.class_eval do