Replace "runner" terminology in Supervisor and Configuration with "process" and "fork"

Much clearer.

Author: rosa

lib/solid_queue/configuration.rb

@@ -19,7 +19,7 @@ def initialize(mode: :work, load_from: nil)
       @raw_config = config_from(load_from)
     end
 
-    def runners
+    def processes
       case mode
       when :dispatch then dispatcher
       when :work     then workers

lib/solid_queue/supervisor.rb

@@ -11,12 +11,12 @@ def start(mode: :work, load_configuration_from: nil)
         SolidQueue.supervisor = true
         configuration = Configuration.new(mode: mode, load_from: load_configuration_from)
 
-        new(*configuration.runners).start
+        new(*configuration.processes).start
       end
     end
 
-    def initialize(*runners)
-      @runners = Array(runners)
+    def initialize(*configured_processes)
+      @configured_processes = Array(configured_processes)
       @forks = {}
     end
 
@@ -33,7 +33,7 @@ def start
     end
 
     private
-      attr_reader :runners, :forks
+      attr_reader :configured_processes, :forks
 
       def boot
         sync_std_streams
@@ -42,13 +42,13 @@ def boot
       end
 
       def supervise
-        start_runners
+        start_forks
 
         loop do
           procline "supervising #{forks.keys.join(", ")}"
 
           process_signal_queue
-          reap_and_replace_terminated_runners
+          reap_and_replace_terminated_forks
           interruptible_sleep(1.second)
         end
       end
@@ -68,8 +68,8 @@ def launch_process_prune
         @prune_task.execute
       end
 
-      def start_runners
-        runners.each { |runner| start_runner(runner) }
+      def start_forks
+        configured_processes.each { |configured_process| start_fork(configured_process) }
       end
 
       def shutdown
@@ -80,25 +80,25 @@ def shutdown
 
       def graceful_termination
         procline "terminating gracefully"
-        term_runners
+        term_forks
 
-        wait_until(SolidQueue.shutdown_timeout, -> { all_runners_terminated? }) do
-          reap_terminated_runners
+        wait_until(SolidQueue.shutdown_timeout, -> { all_forks_terminated? }) do
+          reap_terminated_forks
         end
 
-        immediate_termination unless all_runners_terminated?
+        immediate_termination unless all_forks_terminated?
       end
 
       def immediate_termination
         procline "terminating immediately"
-        quit_runners
+        quit_forks
       end
 
-      def term_runners
+      def term_forks
         signal_processes(forks.keys, :TERM)
       end
 
-      def quit_runners
+      def quit_forks
         signal_processes(forks.keys, :QUIT)
       end
 
@@ -116,26 +116,26 @@ def prune_dead_processes
         end
       end
 
-      def start_runner(runner)
-        runner.supervised_by process
+      def start_fork(configured_process)
+        configured_process.supervised_by process
 
         pid = fork do
-          runner.start
+          configured_process.start
         end
 
-        forks[pid] = runner
+        forks[pid] = configured_process
       end
 
-      def reap_and_replace_terminated_runners
+      def reap_and_replace_terminated_forks
         loop do
           pid, status = ::Process.waitpid2(-1, ::Process::WNOHANG)
           break unless pid
 
-          replace_runner(pid, status)
+          replace_fork(pid, status)
         end
       end
 
-      def reap_terminated_runners
+      def reap_terminated_forks
         loop do
           pid, status = ::Process.waitpid2(-1, ::Process::WNOHANG)
           break unless pid
@@ -146,16 +146,16 @@ def reap_terminated_runners
         # All children already reaped
       end
 
-      def replace_runner(pid, status)
-        if runner = forks.delete(pid)
-          SolidQueue.logger.info "[SolidQueue] Restarting worker[#{status.pid}] (status: #{status.exitstatus})"
-          start_runner(runner)
+      def replace_fork(pid, status)
+        if supervised_fork = forks.delete(pid)
+          SolidQueue.logger.info "[SolidQueue] Restarting fork[#{status.pid}] (status: #{status.exitstatus})"
+          start_fork(supervised_fork)
         else
-          SolidQueue.logger.info "[SolidQueue] Tried to replace worker[#{pid}] (status: #{status.exitstatus}, runner[#{status.pid}]), but it had already died  (status: #{status.exitstatus})"
+          SolidQueue.logger.info "[SolidQueue] Tried to replace fork[#{pid}] (status: #{status.exitstatus}, fork[#{status.pid}]), but it had already died  (status: #{status.exitstatus})"
         end
       end
 
-      def all_runners_terminated?
+      def all_forks_terminated?
         forks.empty?
       end
 

test/unit/configuration_test.rb

@@ -3,7 +3,7 @@
 class ConfigurationTest < ActiveSupport::TestCase
   test "read configuration from default file" do
     configuration = SolidQueue::Configuration.new(mode: :all)
-    assert 3, configuration.runners.count
+    assert 3, configuration.processes.count
     assert_equal 2, configuration.workers.count
     assert configuration.dispatcher.present?
   end