Create always new Worker and Dispatcher instances before starting

We were reusing the instances of Worker and Dispatcher from the initial
configuration all the time, which could bring some problems with stopped
pools. Now that we need a name to be generated and be unique per process
instance, we really need to instantiate new processes every time they're
started.

Author: rosa

lib/solid_queue/configuration.rb

@@ -2,6 +2,12 @@
 
 module SolidQueue
   class Configuration
+    class Process < Struct.new(:kind, :attributes)
+      def instantiate
+        "SolidQueue::#{kind.to_s.titleize}".safe_constantize.new(**attributes)
+      end
+    end
+
     WORKER_DEFAULTS = {
       queues: "*",
       threads: 3,
@@ -22,28 +28,10 @@ def initialize(mode: :fork, load_from: nil)
       @raw_config = config_from(load_from)
     end
 
-    def processes
+    def configured_processes
       dispatchers + workers
     end
 
-    def workers
-      workers_options.flat_map do |worker_options|
-        processes = if mode.fork?
-          worker_options.fetch(:processes, WORKER_DEFAULTS[:processes])
-        else
-          WORKER_DEFAULTS[:processes]
-        end
-        processes.times.map { Worker.new(**worker_options.with_defaults(WORKER_DEFAULTS)) }
-      end
-    end
-
-    def dispatchers
-      dispatchers_options.map do |dispatcher_options|
-        recurring_tasks = parse_recurring_tasks dispatcher_options[:recurring_tasks]
-        Dispatcher.new **dispatcher_options.merge(recurring_tasks: recurring_tasks).with_defaults(DISPATCHER_DEFAULTS)
-      end
-    end
-
     def max_number_of_threads
       # At most "threads" in each worker + 1 thread for the worker + 1 thread for the heartbeat task
       workers_options.map { |options| options[:threads] }.max + 2
@@ -54,6 +42,24 @@ def max_number_of_threads
 
       DEFAULT_CONFIG_FILE_PATH = "config/solid_queue.yml"
 
+      def workers
+        workers_options.flat_map do |worker_options|
+          processes = if mode.fork?
+            worker_options.fetch(:processes, WORKER_DEFAULTS[:processes])
+          else
+            WORKER_DEFAULTS[:processes]
+          end
+          processes.times.map { Process.new(:worker, worker_options.with_defaults(WORKER_DEFAULTS)) }
+        end
+      end
+
+      def dispatchers
+        dispatchers_options.map do |dispatcher_options|
+          recurring_tasks = parse_recurring_tasks dispatcher_options[:recurring_tasks]
+          Process.new :dispatcher, dispatcher_options.merge(recurring_tasks: recurring_tasks).with_defaults(DISPATCHER_DEFAULTS)
+        end
+      end
+
       def config_from(file_or_hash, env: Rails.env)
         config = load_config_from(file_or_hash)
         config[env.to_sym] ? config[env.to_sym] : config

lib/solid_queue/processes/base.rb

@@ -6,6 +6,12 @@ class Base
       include Callbacks # Defines callbacks needed by other concerns
       include AppExecutor, Registrable, Interruptible, Procline
 
+      attr_reader :name
+
+      def initialize(*)
+        @name = generate_name
+      end
+
       def kind
         self.class.name.demodulize
       end
@@ -19,8 +25,13 @@ def pid
       end
 
       def metadata
-        {}
+        { name: name }
       end
+
+      private
+        def generate_name
+          [ kind.downcase, SecureRandom.hex(10) ].join("-")
+        end
     end
   end
 end

lib/solid_queue/processes/poller.rb

@@ -8,6 +8,8 @@ class Poller < Base
 
     def initialize(polling_interval:, **options)
       @polling_interval = polling_interval
+
+      super(**options)
     end
 
     def metadata

lib/solid_queue/processes/registrable.rb

@@ -21,6 +21,7 @@ def process_id
       def register
         @process = SolidQueue::Process.register \
           kind: kind,
+          name: name,
           pid: pid,
           hostname: hostname,
           supervisor: try(:supervisor),

lib/solid_queue/processes/runnable.rb

@@ -25,10 +25,6 @@ def stop
       @thread&.join
     end
 
-    def name
-      @name ||= [ kind.downcase, SecureRandom.hex(6) ].join("-")
-    end
-
     def alive?
       !running_async? || @thread.alive?
     end

lib/solid_queue/supervisor.rb

@@ -16,6 +16,7 @@ def start(mode: :fork, load_configuration_from: nil)
 
     def initialize(configuration)
       @configuration = configuration
+      super
     end
 
     def start
@@ -44,7 +45,7 @@ def boot
       end
 
       def start_processes
-        configuration.processes.each { |configured_process| start_process(configured_process) }
+        configuration.configured_processes.each { |configured_process| start_process(configured_process) }
       end
 
       def stopped?

lib/solid_queue/supervisor/async_supervisor.rb

@@ -23,10 +23,13 @@ def stop
       attr_reader :threads
 
       def start_process(configured_process)
-        configured_process.supervised_by process
-        configured_process.start
+        process_instance = configured_process.instantiate.tap do |instance|
+          instance.supervised_by process
+        end
+
+        process_instance.start
 
-        threads[configured_process.name] = configured_process
+        threads[process_instance.name] = process_instance
       end
 
       def stop_threads

lib/solid_queue/supervisor/fork_supervisor.rb

@@ -6,15 +6,17 @@ class Supervisor::ForkSupervisor < Supervisor
 
     def initialize(*)
       super
+
       @forks = {}
+      @configured_processes = {}
     end
 
     def kind
       "Supervisor(fork)"
     end
 
     private
-      attr_reader :forks
+      attr_reader :forks, :configured_processes
 
       def supervise
         loop do
@@ -33,14 +35,17 @@ def supervise
       end
 
       def start_process(configured_process)
-        configured_process.supervised_by process
-        configured_process.mode = :fork
+        process_instance = configured_process.instantiate.tap do |instance|
+          instance.supervised_by process
+          instance.mode = :fork
+        end
 
         pid = fork do
-          configured_process.start
+          process_instance.start
         end
 
-        forks[pid] = configured_process
+        configured_processes[pid] = configured_process
+        forks[pid] = process_instance
       end
 
       def terminate_gracefully
@@ -87,6 +92,7 @@ def reap_terminated_forks
           break unless pid
 
           forks.delete(pid)
+          configured_processes.delete(pid)
         end
       rescue SystemCallError
         # All children already reaped
@@ -96,7 +102,8 @@ def replace_fork(pid, status)
         SolidQueue.instrument(:replace_fork, supervisor_pid: ::Process.pid, pid: pid, status: status) do |payload|
           if supervised_fork = forks.delete(pid)
             payload[:fork] = supervised_fork
-            start_process(supervised_fork)
+
+            start_process(configured_processes.delete(pid))
           end
         end
       end

test/integration/instrumentation_test.rb

@@ -113,7 +113,7 @@ class InstrumentationTest < ActiveSupport::TestCase
 
   test "pruning processes emit prune_processes and deregister_process events" do
     time = Time.now
-    processes = 3.times.collect { |i| SolidQueue::Process.create!(kind: "Worker", supervisor_id: 42, pid: 10 + i, hostname: "localhost", last_heartbeat_at: time) }
+    processes = 3.times.collect { |i| SolidQueue::Process.create!(kind: "Worker", supervisor_id: 42, pid: 10 + i, hostname: "localhost", last_heartbeat_at: time, name: "worker-123#{i}") }
 
     # Heartbeats will expire
     travel_to 3.days.from_now

test/models/solid_queue/claimed_execution_test.rb

@@ -2,7 +2,7 @@
 
 class SolidQueue::ClaimedExecutionTest < ActiveSupport::TestCase
   setup do
-    @process = SolidQueue::Process.register(kind: "Worker", pid: 42, metadata: { queue: "background" })
+    @process = SolidQueue::Process.register(kind: "Worker", pid: 42, name: "worker-123", metadata: { queue: "background" })
   end
 
   test "perform job successfully" do