async-background 1.0.2 → 1.1.1

data/lib/async/background/queue/schema.rb

@@ -29,11 +29,9 @@ module Async
 
           enable_incremental_vacuum!(db) unless jobs_table?(db)
 
-          with_migration_timeout(db) do
-            immediate_transaction(db) do
-              reject_future_version!(db)
-              upgrade!(db) unless current?(db)
-            end
+          synchronized_change(db) do
+            reject_future_version!(db)
+            upgrade!(db) unless current?(db)
           end
         end
 
@@ -41,20 +39,20 @@ module Async
           migrate!(db)
           return if dashboard_indexes_current?(db)
 
-          with_migration_timeout(db) do
-            immediate_transaction(db) do
-              create_dashboard_indexes!(db) unless dashboard_indexes_current?(db)
-            end
+          synchronized_change(db) do
+            create_dashboard_indexes!(db) unless dashboard_indexes_current?(db)
           end
         end
 
+        def synchronized_change(db, &change)
+          with_migration_timeout(db) { immediate_transaction(db, &change) }
+        end
+
         def current?(db)
           jobs_table?(db) && version(db) == VERSION && core_indexes_current?(db)
         end
 
-        def dashboard_indexes_current?(db)
-          (DASHBOARD_INDEXES - index_names(db)).empty?
-        end
+        def dashboard_indexes_current?(db) = indexes_present?(db, DASHBOARD_INDEXES)
 
         def version(db)
           db.get_first_value(SQL::USER_VERSION).to_i
@@ -101,8 +99,10 @@ module Async
           SQL::CREATE_DASHBOARD_INDEXES.each { |statement| db.execute(statement) }
         end
 
-        def core_indexes_current?(db)
-          (CORE_INDEXES - index_names(db)).empty?
+        def core_indexes_current?(db) = indexes_present?(db, CORE_INDEXES)
+
+        def indexes_present?(db, names)
+          (names - index_names(db)).empty?
         end
 
         def jobs_table?(db)
@@ -156,7 +156,11 @@ module Async
           db.execute(SQL::COMMIT)
           result
         rescue StandardError
-          db.execute(SQL::ROLLBACK) rescue nil
+          begin
+            db.execute(SQL::ROLLBACK)
+          rescue StandardError
+            nil
+          end
           raise
         end
       end

data/lib/async/background/queue/socket_notifier.rb

@@ -19,7 +19,7 @@ module Async
         ].freeze
 
         DEAD_WORKER_TTL = 5.0
-        WAKE_BYTE = "\x01".freeze
+        WAKE_BYTE = "\x01"
 
         def initialize(socket_dir:, total_workers:)
           @socket_dir = socket_dir
@@ -64,7 +64,11 @@ module Async
           begin
             socket.write_nonblock(WAKE_BYTE)
           ensure
-            socket.close rescue nil
+            begin
+              socket.close
+            rescue StandardError
+              nil
+            end
           end
           true
         rescue IO::WaitWritable
@@ -72,9 +76,15 @@ module Async
         rescue *UNAVAILABLE
           mark_dead(index, now)
           false
-        rescue => e
+        rescue StandardError => e
           mark_dead(index, now)
-          Console.logger.warn(self) { "SocketNotifier#notify_one(#{index + 1}) failed: #{e.class} #{e.message}" } rescue nil
+          begin
+            Console.logger.warn(self) do
+              "SocketNotifier#notify_one(#{index + 1}) failed: #{e.class} #{e.message}"
+            end
+          rescue StandardError
+            nil
+          end
           false
         end
 

data/lib/async/background/queue/socket_waker.rb

@@ -1,113 +1,196 @@
 # frozen_string_literal: true
 
 require 'socket'
-require 'async/notification'
 require 'fileutils'
+require_relative '../runtime'
 
 module Async
   module Background
     module Queue
       class SocketWaker
+        CLOSE_GRACE = 2
+
         attr_reader :path
 
         def initialize(path)
           @path = path
           @server = nil
-          @notification = ::Async::Notification.new
+          @notification = Runtime::Notification.new
           @running = false
           @accept_task = nil
+          @clients = Runtime::TaskGroup.new
+          @sockets = {}
         end
 
         def open!
-          cleanup_stale_socket
           ensure_directory
+          cleanup_stale_socket
           @server = UNIXServer.new(@path)
-          File.chmod(0600, @path)
           @running = true
+          self
         rescue Errno::EADDRINUSE
           raise "Socket #{@path} is already in use by another process"
         end
 
-        def start_accept_loop(parent_task)
-          @accept_task = parent_task.async do |task|
-            while @running
-              begin
-                client = @server.accept_nonblock
-                handle_client(task, client)
-              rescue IO::WaitReadable
-                @server.wait_readable
-              rescue Errno::EBADF, IOError
-                break
-              rescue => e
-                Console.logger.error(self) { "SocketWaker accept error: #{e.class} #{e.message}" }
-              end
-            end
-          rescue => e
-            Console.logger.error(self) { "SocketWaker loop crashed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}" }
-          ensure
-            @accept_task = nil
-          end
+        def start_accept_loop(_parent_task = nil)
+          @accept_task = Runtime.spawn(name: 'socket-waker-accept') { accept_loop }
         end
 
         def wait(timeout: nil)
-          if timeout
-            ::Async::Task.current.with_timeout(timeout) { @notification.wait }
-          else
-            @notification.wait
-          end
-        rescue ::Async::TimeoutError
-          # Timeout is normal - listener will fall back to polling
+          @notification.wait(timeout)
         end
 
         def signal
-          @notification.signal
+          @notification.signal_all
+          true
         end
 
         def close
+          return unless @running || @server
+
           @running = false
-          if @accept_task && !@accept_task.finished?
-            @accept_task.stop rescue nil
-          end
+          stop_accept_loop
+          @notification.signal_all
+          hang_up_clients
+          stop_clients
 
-          @server&.close rescue nil
+          begin
+            @server&.close
+          rescue StandardError
+            nil
+          end
           @server = nil
-          File.unlink(@path) rescue nil
+          @accept_task = nil
+          begin
+            File.unlink(@path)
+          rescue StandardError
+            nil
+          end
         end
 
         private
 
-        def handle_client(parent_task, client)
-          parent_task.async do
+        def accept_loop
+          while @running
+            begin
+              client = @server.accept_nonblock
+            rescue IO::WaitReadable
+              @server.wait_readable
+              next
+            rescue Errno::EBADF, IOError
+              break
+            rescue StandardError => e
+              Console.logger.error(self) { "SocketWaker accept error: #{e.class} #{e.message}" }
+              next
+            end
+
+            break unless @running
+
+            handle_client(client)
+          end
+        rescue StandardError => e
+          Console.logger.error(self) { "SocketWaker loop crashed: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}" }
+        end
+
+        def handle_client(client)
+          @sockets[client] = true
+
+          @clients.spawn(name: 'socket-waker-client') do
+            loop do
+              client.read_nonblock(256)
+              @notification.signal_all
+            rescue IO::WaitReadable
+              client.wait_readable
+              retry
+            rescue EOFError, Errno::ECONNRESET, Errno::EBADF, IOError
+              break
+            end
+          rescue StandardError => e
+            Console.logger.warn(self) { "SocketWaker client handler error: #{e.class} #{e.message}" }
+          ensure
+            @sockets.delete(client)
             begin
-              loop do
-                begin
-                  client.read_nonblock(256)
-                  @notification.signal
-                rescue IO::WaitReadable
-                  client.wait_readable
-                  retry
-                rescue EOFError, Errno::ECONNRESET
-                  break
-                end
-              end
-            rescue => e
-              Console.logger.warn(self) { "SocketWaker client handler error: #{e.class} #{e.message}" }
-            ensure
-              client.close rescue nil
-              @notification.signal
+              client.close
+            rescue StandardError
+              nil
             end
+            @notification.signal_all
           end
         end
 
+        def stop_accept_loop
+          task = @accept_task or return
+
+          wake_accept_loop
+          return if await(task, CLOSE_GRACE)
+
+          task.stop
+          await(task, CLOSE_GRACE)
+        end
+
+        def wake_accept_loop
+          return unless @server
+
+          UNIXSocket.open(@path) do |s|
+            s.write_nonblock("\x00")
+          rescue StandardError
+            nil
+          end
+        rescue StandardError
+          nil
+        end
+
+        def hang_up_clients
+          @sockets.each_key do |socket|
+            socket.close
+          rescue StandardError
+            nil
+          end
+        end
+
+        def stop_clients
+          return if @clients.empty?
+
+          return if await_group(@clients, CLOSE_GRACE)
+
+          @clients.stop_all(CLOSE_GRACE)
+        end
+
+        def await(task, grace)
+          return true unless Runtime.scheduler
+
+          task.wait(grace)
+          true
+        rescue Runtime::TimeoutError
+          false
+        rescue Exception # rubocop:disable Lint/RescueException
+          true
+        end
+
+        def await_group(group, grace)
+          return true unless Runtime.scheduler
+
+          group.wait(grace)
+          true
+        rescue Runtime::TimeoutError
+          false
+        rescue StandardError
+          true
+        end
+
         def cleanup_stale_socket
           return unless File.exist?(@path)
 
           begin
-            UNIXSocket.open(@path) { |s| s.close }
+            UNIXSocket.open(@path, &:close)
 
             raise "Socket #{@path} is already in use by another process (worker_index conflict?)"
           rescue Errno::ECONNREFUSED, Errno::ENOENT
-            File.unlink(@path) rescue nil
+            begin
+              File.unlink(@path)
+            rescue StandardError
+              nil
+            end
           end
         end
 

data/lib/async/background/queue/sql.rb

@@ -4,17 +4,17 @@ module Async
   module Background
     module Queue
       module SQL
-        USER_VERSION = 'PRAGMA user_version'.freeze
-        DATA_VERSION = 'PRAGMA data_version'.freeze
-        BUSY_TIMEOUT = 'PRAGMA busy_timeout'.freeze
-        TABLE_INFO = 'PRAGMA table_info(jobs)'.freeze
-        OPTIMIZE = 'PRAGMA optimize'.freeze
+        USER_VERSION = 'PRAGMA user_version'
+        DATA_VERSION = 'PRAGMA data_version'
+        BUSY_TIMEOUT = 'PRAGMA busy_timeout'
+        TABLE_INFO = 'PRAGMA table_info(jobs)'
+        OPTIMIZE = 'PRAGMA optimize'
         INCREMENTAL_VACUUM_PAGES = 64
         INCREMENTAL_VACUUM = "PRAGMA incremental_vacuum(#{INCREMENTAL_VACUUM_PAGES})".freeze
-        AUTO_VACUUM_INCREMENTAL = 'PRAGMA auto_vacuum = INCREMENTAL'.freeze
-        BEGIN_IMMEDIATE = 'BEGIN IMMEDIATE'.freeze
-        COMMIT = 'COMMIT'.freeze
-        ROLLBACK = 'ROLLBACK'.freeze
+        AUTO_VACUUM_INCREMENTAL = 'PRAGMA auto_vacuum = INCREMENTAL'
+        BEGIN_IMMEDIATE = 'BEGIN IMMEDIATE'
+        COMMIT = 'COMMIT'
+        ROLLBACK = 'ROLLBACK'
 
         def self.busy_timeout(milliseconds)
           "PRAGMA busy_timeout = #{Integer(milliseconds)}"
@@ -28,7 +28,7 @@ module Async
           "ALTER TABLE jobs ADD COLUMN #{name} #{sql_type}"
         end
 
-        CREATE_SCHEMA = <<~SQL.freeze
+        CREATE_SCHEMA = <<~SQL
           CREATE TABLE IF NOT EXISTS jobs (
             id                 INTEGER PRIMARY KEY,
             class_name         TEXT    NOT NULL,
@@ -50,12 +50,12 @@ module Async
             ON jobs(run_at) WHERE status = 'pending';
         SQL
 
-        INSERT_JOB = <<~SQL.freeze
+        INSERT_JOB = <<~SQL
           INSERT INTO jobs (class_name, args, options, created_at, run_at)
           VALUES (?, ?, ?, ?, ?)
         SQL
 
-        FETCH_NEXT_JOB = <<~SQL.freeze
+        FETCH_NEXT_JOB = <<~SQL
           UPDATE jobs
           SET    status      = 'running',
                  locked_by   = ?,
@@ -73,13 +73,13 @@ module Async
           RETURNING id, class_name, args, options
         SQL
 
-        MARK_STARTED = <<~SQL.freeze
+        MARK_STARTED = <<~SQL
           UPDATE jobs
           SET    started_at = ?
           WHERE  id = ? AND claim_token = ? AND status = 'running' AND started_at IS NULL
         SQL
 
-        COMPLETE_JOB = <<~SQL.freeze
+        COMPLETE_JOB = <<~SQL
           UPDATE jobs
           SET    status      = 'done',
                  locked_by   = NULL,
@@ -89,7 +89,7 @@ module Async
           WHERE  id = ? AND claim_token = ? AND status = 'running'
         SQL
 
-        FAIL_JOB = <<~SQL.freeze
+        FAIL_JOB = <<~SQL
           UPDATE jobs
           SET    status             = 'failed',
                  locked_by          = NULL,
@@ -101,19 +101,19 @@ module Async
           WHERE  id = ? AND claim_token = ? AND status = 'running'
         SQL
 
-        RETRY_STATE = <<~SQL.freeze
+        RETRY_STATE = <<~SQL
           SELECT options
           FROM jobs
           WHERE id = ? AND claim_token = ? AND status = 'running'
         SQL
 
-        LEASE_ALIVE = <<~SQL.freeze
+        LEASE_ALIVE = <<~SQL
           SELECT 1
           FROM jobs
           WHERE id = ? AND claim_token = ? AND status = 'running'
         SQL
 
-        RETRY_JOB = <<~SQL.freeze
+        RETRY_JOB = <<~SQL
           UPDATE jobs
           SET    status             = 'pending',
                  locked_by          = NULL,
@@ -129,7 +129,7 @@ module Async
           WHERE  id = ? AND claim_token = ? AND status = 'running'
         SQL
 
-        RECOVER_WORKER = <<~SQL.freeze
+        RECOVER_WORKER = <<~SQL
           UPDATE jobs
           SET    status      = 'pending',
                  locked_by   = NULL,
@@ -139,67 +139,67 @@ module Async
           WHERE  status = 'running' AND locked_by = ?
         SQL
 
-        BACKFILL_FINISHED_AT = <<~SQL.freeze
+        BACKFILL_FINISHED_AT = <<~SQL
           UPDATE jobs
           SET finished_at = created_at
           WHERE finished_at IS NULL AND status IN ('done', 'failed')
         SQL
 
-        CLEANUP_DONE = <<~SQL.freeze
+        CLEANUP_DONE = <<~SQL
           DELETE FROM jobs
           WHERE status = 'done' AND finished_at IS NOT NULL AND finished_at < ?
         SQL
 
-        CLEANUP_FAILED = <<~SQL.freeze
+        CLEANUP_FAILED = <<~SQL
           DELETE FROM jobs
           WHERE status = 'failed' AND finished_at IS NOT NULL AND finished_at < ?
         SQL
 
-        NEXT_PENDING_RUN_AT = <<~SQL.freeze
+        NEXT_PENDING_RUN_AT = <<~SQL
           SELECT MIN(run_at)
           FROM jobs
           WHERE status = 'pending'
         SQL
 
-        JOBS_TABLE_EXISTS = <<~SQL.freeze
+        JOBS_TABLE_EXISTS = <<~SQL
           SELECT 1
           FROM sqlite_master
           WHERE type = 'table' AND name = 'jobs'
           LIMIT 1
         SQL
 
-        JOB_INDEX_NAMES = <<~SQL.freeze
+        JOB_INDEX_NAMES = <<~SQL
           SELECT name
           FROM sqlite_master
           WHERE type = 'index' AND tbl_name = 'jobs'
         SQL
 
-        DROP_LEGACY_PENDING_INDEX = 'DROP INDEX IF EXISTS idx_jobs_status_run_at_id'.freeze
+        DROP_LEGACY_PENDING_INDEX = 'DROP INDEX IF EXISTS idx_jobs_status_run_at_id'
 
-        CREATE_PENDING_INDEX = <<~SQL.freeze
+        CREATE_PENDING_INDEX = <<~SQL
           CREATE INDEX IF NOT EXISTS idx_jobs_pending
           ON jobs(run_at) WHERE status = 'pending'
         SQL
 
-        CREATE_DONE_INDEX = <<~SQL.freeze
+        CREATE_DONE_INDEX = <<~SQL
           CREATE INDEX IF NOT EXISTS idx_jobs_done_finished_at
           ON jobs(finished_at DESC, id DESC)
           WHERE status = 'done'
         SQL
 
-        CREATE_FAILED_INDEX = <<~SQL.freeze
+        CREATE_FAILED_INDEX = <<~SQL
           CREATE INDEX IF NOT EXISTS idx_jobs_failed_finished_at
           ON jobs(finished_at DESC, id DESC)
           WHERE status = 'failed'
         SQL
 
-        CREATE_EXECUTING_INDEX = <<~SQL.freeze
+        CREATE_EXECUTING_INDEX = <<~SQL
           CREATE INDEX IF NOT EXISTS idx_jobs_executing_started_at
           ON jobs(started_at)
           WHERE status = 'running' AND started_at IS NOT NULL
         SQL
 
-        CREATE_CLAIMED_INDEX = <<~SQL.freeze
+        CREATE_CLAIMED_INDEX = <<~SQL
           CREATE INDEX IF NOT EXISTS idx_jobs_claimed_locked_at
           ON jobs(locked_at)
           WHERE status = 'running' AND started_at IS NULL

data/lib/async/background/queue/store.rb

@@ -24,7 +24,7 @@ module Async
         FAILED_RETENTION_AGE = 7 * 24 * 3600
         CLEANUP_VACUUM_THRESHOLD = 100
         ERROR_MESSAGE_MAX_LEN = 2_000
-        EMPTY_ARGS_JSON = '[]'.freeze
+        EMPTY_ARGS_JSON = '[]'
 
         attr_reader :path, :options
 
@@ -131,7 +131,8 @@ module Async
           @db.changes.positive?
         end
 
-        def fail(job_id, claim_token:, error_class: nil, error_message: nil, finished_at: realtime_now, duration_ms: nil)
+        def fail(job_id, claim_token:, error_class: nil, error_message: nil, finished_at: realtime_now,
+                 duration_ms: nil)
           ensure_connection
           bind_failure(@fail_stmt, finished_at, duration_ms, error_class, error_message, job_id, claim_token)
           @db.changes.positive?
@@ -153,8 +154,11 @@ module Async
             next unless lease_alive?(job_id, claim_token)
 
             policy = retry_policy(stored_options, fallback_options)
-            policy_retries?(policy) ? retry_job!(job_id, claim_token, policy, error_class, error_message) :
+            if policy_retries?(policy)
+              retry_job!(job_id, claim_token, policy, error_class, error_message)
+            else
               fail_job!(job_id, claim_token, error_class, error_message, finished_at, duration_ms)
+            end
           end
         end
 
@@ -178,7 +182,11 @@ module Async
           return unless connected?
 
           finalize_statements
-          @db.execute(SQL::OPTIMIZE) rescue nil
+          begin
+            @db.execute(SQL::OPTIMIZE)
+          rescue StandardError
+            nil
+          end
           @db.close
           @db = nil
           @schema_checked = false
@@ -211,7 +219,7 @@ module Async
           require 'sqlite3'
         rescue LoadError
           raise LoadError,
-                "sqlite3 gem is required for Async::Background::Queue. " \
+                'sqlite3 gem is required for Async::Background::Queue. ' \
                 "Add `gem 'sqlite3', '~> 2.0'` to your Gemfile."
         end
 
@@ -338,7 +346,11 @@ module Async
           yield statement if block_given?
           statement.step
         ensure
-          statement.reset! rescue nil
+          begin
+            statement.reset!
+          rescue StandardError
+            nil
+          end
         end
 
         def dump_args(args)
@@ -360,56 +372,43 @@ module Async
           Job::Options.new(**options)
         end
 
+        STATEMENTS = {
+          :@enqueue_stmt => SQL::INSERT_JOB,
+          :@fetch_stmt => SQL::FETCH_NEXT_JOB,
+          :@mark_started_stmt => SQL::MARK_STARTED,
+          :@complete_stmt => SQL::COMPLETE_JOB,
+          :@fail_stmt => SQL::FAIL_JOB,
+          :@retry_state_stmt => SQL::RETRY_STATE,
+          :@lease_check_stmt => SQL::LEASE_ALIVE,
+          :@retry_stmt => SQL::RETRY_JOB,
+          :@requeue_stmt => SQL::RECOVER_WORKER,
+          :@cleanup_done_stmt => SQL::CLEANUP_DONE,
+          :@cleanup_failed_stmt => SQL::CLEANUP_FAILED,
+          :@next_pending_stmt => SQL::NEXT_PENDING_RUN_AT,
+          :@begin_stmt => SQL::BEGIN_IMMEDIATE,
+          :@commit_stmt => SQL::COMMIT,
+          :@rollback_stmt => SQL::ROLLBACK
+        }.freeze
+
         def prepare_statements
-          @enqueue_stmt = @db.prepare(SQL::INSERT_JOB)
-          @fetch_stmt = @db.prepare(SQL::FETCH_NEXT_JOB)
-          @mark_started_stmt = @db.prepare(SQL::MARK_STARTED)
-          @complete_stmt = @db.prepare(SQL::COMPLETE_JOB)
-          @fail_stmt = @db.prepare(SQL::FAIL_JOB)
-          @retry_state_stmt = @db.prepare(SQL::RETRY_STATE)
-          @lease_check_stmt = @db.prepare(SQL::LEASE_ALIVE)
-          @retry_stmt = @db.prepare(SQL::RETRY_JOB)
-          @requeue_stmt = @db.prepare(SQL::RECOVER_WORKER)
-          @cleanup_done_stmt = @db.prepare(SQL::CLEANUP_DONE)
-          @cleanup_failed_stmt = @db.prepare(SQL::CLEANUP_FAILED)
-          @next_pending_stmt = @db.prepare(SQL::NEXT_PENDING_RUN_AT)
-          @begin_stmt = @db.prepare(SQL::BEGIN_IMMEDIATE)
-          @commit_stmt = @db.prepare(SQL::COMMIT)
-          @rollback_stmt = @db.prepare(SQL::ROLLBACK)
+          STATEMENTS.each { |name, sql| instance_variable_set(name, @db.prepare(sql)) }
         end
 
         def finalize_statements
-          statements.each { |statement| statement&.close rescue nil }
+          statements.each do |statement|
+            statement&.close
+          rescue StandardError
+            nil
+          end
           clear_statements
         end
 
         def statements
-          [
-            @enqueue_stmt,
-            @fetch_stmt,
-            @mark_started_stmt,
-            @complete_stmt,
-            @fail_stmt,
-            @retry_state_stmt,
-            @lease_check_stmt,
-            @retry_stmt,
-            @requeue_stmt,
-            @cleanup_done_stmt,
-            @cleanup_failed_stmt,
-            @next_pending_stmt,
-            @begin_stmt,
-            @commit_stmt,
-            @rollback_stmt
-          ]
+          STATEMENTS.keys.map { |name| instance_variable_get(name) }
         end
 
         def clear_statements
-          @enqueue_stmt = @fetch_stmt = @mark_started_stmt = nil
-          @complete_stmt = @fail_stmt = @retry_state_stmt = @lease_check_stmt = nil
-          @retry_stmt = @requeue_stmt = nil
-          @cleanup_done_stmt = @cleanup_failed_stmt = nil
-          @next_pending_stmt = nil
-          @begin_stmt = @commit_stmt = @rollback_stmt = nil
+          STATEMENTS.each_key { |name| instance_variable_set(name, nil) }
         end
 
         def maybe_cleanup