bluepill 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa9f8a199b7c2f30858345bc94b934e3a15be6776595ea4481c61722340812b8
-  data.tar.gz: b33c36a84b7bbe956866889eca7838211f4d40942e75b3e6fefd33b6c81b6958
+  metadata.gz: '0208aabbcc97f59a0e1186f9d01d58b96a3193b378a33341e38914f5817e2dde'
+  data.tar.gz: a985b9962e81fcce8a800e3154a971fcf8864cf43905f31abc91fed6cfdf0e2d
 SHA512:
-  metadata.gz: 42b736d7e86289628a9a0b057f01d9e0b379a42048b6903da13090429a4831255adcefd07db3cccc3ab19b816ad9281ad58d692779e171a3ea767cb24c0f96f6
-  data.tar.gz: e8dcc83be7c7a2df1f6f030f13dc11ef75bd98b087dce958cbce07f13812193693bdd7dfafd3ee2e8d9753b913b41341bb8b1db5d588882aa748f789d7ff9445
+  metadata.gz: e260492f6536962844cf956db8493aa730a28c53a08a18dbca4a1ac53d53e54f9c1b9e2e6edfad165205a0b4021844878099ccb25a486b8fa7a9fdd2d0125ef8
+  data.tar.gz: 848b4037e5cf18f6b4ad5db27fd5dbe22e443101619af3c6e4a8e944bff85189ebafcb6353615bb7df73c40a65dda1c6294ab5ca0849f23e5c19d2a3237f2126

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.2] - 2026-11-02
+
+### Removed
+
+- **Breaking:** support for Ruby 3.0 and 3.1, and for JRuby 9.4, which runs Ruby 3.1 code. Bluepill 0.3.2 needs Ruby 3.2 or newer, or JRuby 10.0 or newer, which needs Java 21. Bluepill 0.3.0 still runs on them.
+
+### Fixed
+
+- Bluepill runs on JRuby, in the foreground and as a daemon. It forked to start every process and command, which the JVM can't do, so on JRuby it started none. On JRuby it now spawns them, and starts a new bluepill to be the daemon. A process that bluepill starts there runs in a process group of its own, as a forked one's new session does, and stays bluepill's child, which collects its exit status. Spawned commands can't switch to another user, so on JRuby a config that sets `uid`, `gid` or `supplementary_groups` fails to load when bluepill runs as root. CRuby runs bluepill as before.
+
 ## [0.3.0] - 2026-11-02
 
 ### Upgrading from 0.2
@@ -992,7 +1002,8 @@ Initial release.
 - Added the `bluepill` CLI with the `load`, `status`, `start`, `stop`, `restart`, `unmonitor`, `quit` and `log` commands.
 - Added syslog logging.
 
-[unreleased]: https://github.com/bluepill-rb/bluepill/compare/v0.3.0...HEAD
+[unreleased]: https://github.com/bluepill-rb/bluepill/compare/v0.3.2...HEAD
+[0.3.2]: https://github.com/bluepill-rb/bluepill/compare/v0.3.0...v0.3.2
 [0.3.0]: https://github.com/bluepill-rb/bluepill/compare/v0.2.9...v0.3.0
 [0.2.9]: https://github.com/bluepill-rb/bluepill/compare/v0.2.7...v0.2.9
 [0.2.7]: https://github.com/bluepill-rb/bluepill/compare/v0.2.5...v0.2.7

data/README.md

@@ -198,6 +198,8 @@ end
 
 These only apply when bluepill runs as root. Every command a process runs, such as its `start_command`, `stop_command` and `pre_start_command`, runs as its user and groups, and so do the commands of its children with `monitor_children`.
 
+On JRuby, bluepill can't run commands as another user or group, since the JVM can't fork, so a config that sets `uid`, `gid` or `supplementary_groups` fails to load when bluepill runs as root. Run it on CRuby to use them.
+
 To track resources of child processes, use `:include_children`:
 ```ruby
 Bluepill.application("app_name") do |app|
@@ -497,9 +499,6 @@ end
 
 Note that You must define only one application per config when using foreground mode.
 
-
-JRuby allows you to run bluepill only in the foreground.
-
 ## Links
 
 * Code: [http://github.com/bluepill-rb/bluepill](http://github.com/bluepill-rb/bluepill)
@@ -512,10 +511,9 @@ JRuby allows you to run bluepill only in the foreground.
 This library aims to support and is [tested against][ci] the following Ruby
 implementations:
 
-* Ruby 3.0 through 3.4
+* Ruby 3.2 through 3.4
 * Ruby 4.0
-* JRuby 9.4 (only in the foreground)
-* JRuby 10.0 and 10.1 (only in the foreground)
+* JRuby 10.0 and 10.1, without `uid`, `gid` and `supplementary_groups`
 
 If something doesn't work on one of these interpreters, please open an issue.
 

data/bin/bluepill

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 require "optparse"
 require "rbconfig"
 require "bluepill"
@@ -7,7 +8,8 @@ require "bluepill"
 # Default options
 options = {
   log_file: "/var/log/bluepill.log",
-  base_dir: ENV["BLUEPILL_BASE_DIR"] || (::Process.euid.zero? ? "/var/run/bluepill" : File.join(ENV.fetch("HOME", nil), ".bluepill")),
+  base_dir: ENV["BLUEPILL_BASE_DIR"] ||
+    (::Process.euid.zero? ? "/var/run/bluepill" : File.join(ENV.fetch("HOME", nil), ".bluepill")),
   privileged: true,
   timeout: 10,
   attempts: 1
@@ -19,7 +21,8 @@ OptionParser.new do |opts|
     options[:log_file] = file
   end
 
-  opts.on("-c", "--base-dir DIR", "Directory to store bluepill socket and pid files, defaults to #{options[:base_dir]}") do |base_dir|
+  opts.on("-c", "--base-dir DIR",
+    "Directory to store bluepill socket and pid files, defaults to #{options[:base_dir]}") do |base_dir|
     options[:base_dir] = base_dir
   end
 
@@ -28,15 +31,18 @@ OptionParser.new do |opts|
     exit
   end
 
-  opts.on("--[no-]privileged", "Allow/disallow to run #{$PROGRAM_NAME} as non-privileged process. disallowed by default") do |v|
+  opts.on("--[no-]privileged",
+    "Allow/disallow to run #{$PROGRAM_NAME} as non-privileged process. disallowed by default") do |v|
     options[:privileged] = v
   end
 
-  opts.on("-t", "--timeout Seconds", Integer, "Timeout for commands sent to the daemon, in seconds. Defaults to 10.") do |timeout|
+  opts.on("-t", "--timeout Seconds", Integer,
+    "Timeout for commands sent to the daemon, in seconds. Defaults to 10.") do |timeout|
     options[:timeout] = timeout
   end
 
-  opts.on("--attempts Count", Integer, "Attempts for commands sent to the daemon, in seconds. Defaults to 1.") do |attempts|
+  opts.on("--attempts Count", Integer,
+    "Attempts for commands sent to the daemon, in seconds. Defaults to 1.") do |attempts|
     options[:attempts] = attempts
   end
 
@@ -91,7 +97,8 @@ elsif APPLICATION_COMMANDS.include?(ARGV.first)
     exit(1)
   else
     # There are none running AND they aren't trying to start one
-    $stderr.puts "Error: There are no running bluepill daemons.\nTo start a bluepill daemon, use: bluepill load <config file>"
+    $stderr.puts "Error: There are no running bluepill daemons.\n" \
+                 "To start a bluepill daemon, use: bluepill load <config file>"
     exit(2)
   end
 end

data/bluepill.gemspec

@@ -12,7 +12,12 @@ Gem::Specification.new do |spec|
   spec.email = ["entombedvirus@gmail.com"]
   spec.homepage = "https://github.com/bluepill-rb/bluepill"
   spec.summary = "A process monitor written in Ruby with stability and minimalism in mind."
-  spec.description = "Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave."
+  spec.description = <<~DESCRIPTION.tr("\n", " ").strip
+    Bluepill keeps your daemons up while taking up as little resources as possible.
+    After all you probably want the resources of your server to be used by whatever
+    daemons you are running rather than the thing that's supposed to make sure they
+    are brought back up, should they die or misbehave.
+  DESCRIPTION
   spec.license = "MIT"
 
   spec.metadata = {
@@ -22,7 +27,7 @@ Gem::Specification.new do |spec|
     "rubygems_mfa_required" => "true"
   }
 
-  spec.required_ruby_version = ">= 3.0"
+  spec.required_ruby_version = ">= 3.2"
 
   # sig has the RBS signatures, and the standard libraries they use in manifest.yaml
   spec.executables = %w[bluepill bpsv]

data/lib/bluepill/application/lifecycle.rb

@@ -13,8 +13,9 @@ module Bluepill
       # Start the daemon
       #
       # It creates the pids directory, stops a previous daemon for the
-      # application, clears journal locks it left behind, daemonizes unless
-      # it runs in the foreground, traps signals, opens the socket, and runs
+      # application, clears journal locks it left behind, daemonizes, or in
+      # the foreground leads a process group of its own, traps signals,
+      # opens the socket, and runs
       # until a signal stops it. Processes that are already running, from
       # their pid files, are monitored again, not restarted, so bluepill can
       # be upgraded without restarting them.
@@ -30,9 +31,10 @@ module Bluepill
         setup_pids_dir
         kill_previous_bluepill
         ProcessJournal.clear_all_atomic_fs_locks
-        become_process_group_leader
+        # Daemonizing starts a new session, which has a process group of its
+        # own, and a process that leads a process group already can't
+        foreground? ? become_process_group_leader : Daemonize.daemonize
         # Trapped after daemonizing, which ignores HUP
-        Daemonize.daemonize unless foreground?
         setup_signal_traps
         logger.reopen
 
@@ -130,7 +132,8 @@ module Bluepill
       #
       # @api private
       def setup_logger
-        self.logger = ProcessJournal.logger = Logger.new(log_file: log_file, log_level: @log_level, stdout: foreground?).prefix_with(name)
+        logger = Logger.new(log_file:, log_level: @log_level, stdout: foreground?).prefix_with(name)
+        self.logger = ProcessJournal.logger = logger
       rescue SystemCallError => e
         raise unwritable(e)
       end

data/lib/bluepill/application/listener.rb

@@ -91,10 +91,8 @@ module Bluepill
       #
       # @api private
       def daemon_command(command)
-        # The backtrace is caller's lines, with no locations, so Ruby 3.1's
-        # error_highlight doesn't add a snippet of this file to the message
         DAEMON_COMMANDS.detect { |known| known.name.eql?(command) } ||
-          raise(NoMethodError, "Unknown command `#{command}`", caller)
+          raise(NoMethodError, "Unknown command `#{command}`")
       end
 
       # Log an error that answering a client raised, with its backtrace

data/lib/bluepill/application.rb

@@ -148,7 +148,7 @@ module Bluepill
     # @return [Object] what the block returns
     #
     # @api private
-    def synchronize(&block) = @mutex.synchronize(&block)
+    def synchronize(&) = @mutex.synchronize(&)
 
     # Start the daemon and monitor the application's processes
     #
@@ -168,7 +168,8 @@ module Bluepill
       log_crash(e)
       raise if e.is_a?(Error)
 
-      raise StartupError, ["Failed to start bluepill:", format("%s `%s`", e.class.name, e.message), e.backtrace].join("\n")
+      raise StartupError,
+        ["Failed to start bluepill:", format("%s `%s`", e.class.name, e.message), e.backtrace].join("\n")
     end
 
     # @!method start(group_name = nil, process_name = nil)
@@ -271,7 +272,8 @@ module Bluepill
     #
     # @api private
     def log_crash(error)
-      [format("Bluepill stopped: %s `%s`", error.class, error.message), *error.backtrace].each { |line| logger.crit(line) }
+      lines = [format("Bluepill stopped: %s `%s`", error.class, error.message), *error.backtrace]
+      lines.each { |line| logger.crit(line) }
     end
 
     # Send a command to a process, a group, or every process

data/lib/bluepill/condition_watch.rb

@@ -75,7 +75,8 @@ module Bluepill
     # @raise [ConfigError] for an event a check can't fire
     #
     # @api private
-    def initialize(name, logger: nil, fires: :restart, every: nil, times: 1, include_children: false, **condition_options)
+    def initialize(name, logger: nil, fires: :restart, every: nil, times: 1, include_children: false,
+      **condition_options)
       @name = name
       @logger = logger
       @fires = events_to_fire(Array(fires))
@@ -105,7 +106,7 @@ module Bluepill
       return events if unknown.empty?
 
       raise ConfigError, "#{@name} can't fire #{unknown.collect(&:inspect).join(", ")}: " \
-        "a check fires #{known.collect(&:inspect).join(", ")}"
+                         "a check fires #{known.collect(&:inspect).join(", ")}"
     end
 
     # Create the check, with the options the watch doesn't take for itself

data/lib/bluepill/controller.rb

@@ -193,7 +193,8 @@ module Bluepill
     # @api private
     def send_process_command(application, command, *args)
       unless Application::PROCESS_COMMANDS.include?(command.to_sym)
-        raise UnknownCommandError, format("Unknown command `%s` (or application `%s` has not been loaded yet)", command, command)
+        raise UnknownCommandError,
+          format("Unknown command `%s` (or application `%s` has not been loaded yet)", command, command)
       end
 
       # these need to be sent to the daemon and the results printed out
@@ -235,7 +236,9 @@ module Bluepill
       version = Socket.client_command(base_dir, application, "version")
       return if Version.to_s.eql?(version)
 
-      raise VersionMismatchError, version.instance_of?(String) ? "#{OUT_OF_DATE}\nDaemon Version: #{version}, CLI Version: #{Version}" : OUT_OF_DATE
+      raise VersionMismatchError, OUT_OF_DATE unless version.instance_of?(String)
+
+      raise VersionMismatchError, "#{OUT_OF_DATE}\nDaemon Version: #{version}, CLI Version: #{Version}"
     rescue ArgumentError
       raise VersionMismatchError, OUT_OF_DATE
     end

data/lib/bluepill/daemonize.rb

@@ -27,6 +27,8 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 # OTHER DEALINGS IN THE SOFTWARE.
 
+require "rbconfig"
+
 module Bluepill
   # Turn the bluepill daemon, or a block, into a daemon process
   #
@@ -35,6 +37,9 @@ module Bluepill
   # it started in, closes the files it inherited, and points its standard
   # streams at /dev/null.
   #
+  # A Ruby that can't fork, such as JRuby, starts a new bluepill to be the
+  # daemon instead, which starts the new session itself.
+  #
   # @api private
   module Daemonize
     # Raised when a daemon can't detach from its controlling terminal
@@ -45,6 +50,20 @@ module Bluepill
     # The highest file descriptor that close_io closes
     MAX_FD = 8191
 
+    # Set in the environment of the bluepill that a bluepill that can't
+    # fork starts to be its daemon
+    DAEMON_ENV = "BLUEPILL_DAEMON"
+
+    # Return whether this Ruby can fork
+    #
+    # JRuby can't, since the JVM runs threads of its own that a fork would
+    # leave behind. Bluepill spawns its commands there instead.
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def self.can_fork? = ::Process.respond_to?(:fork)
+
     # Fork, retrying every 5 seconds while the system is out of processes
     #
     # @return [Integer, nil] the child's pid in the parent, nil in the child
@@ -132,6 +151,8 @@ module Bluepill
     #
     # @api private
     def self.daemonize
+      return daemonize_without_fork unless can_fork?
+
       exit if safefork
 
       session = detach
@@ -141,6 +162,37 @@ module Bluepill
       session
     end
 
+    # Turn the calling process into a daemon, in a Ruby that can't fork
+    #
+    # The first time, it starts a new bluepill that runs the same pill file
+    # with DAEMON_ENV set, and exits, so `bluepill load` returns. In that
+    # bluepill, which is new, so it inherited no files to close and its
+    # standard streams are /dev/null already, it starts a new session and
+    # leaves the directory it started in.
+    #
+    # @return [Integer] the daemon's session id
+    #
+    # @api private
+    def self.daemonize_without_fork
+      start_daemon_bluepill unless ENV.delete(DAEMON_ENV)
+
+      session = detach
+      Dir.chdir("/")
+      session
+    end
+
+    # Start a bluepill that runs the same pill file to be the daemon, and exit
+    #
+    # @return [void] it never returns, since it exits
+    #
+    # @api private
+    def self.start_daemon_bluepill
+      dir = __dir__ #: String
+      args = ["-I#{File.expand_path("..", dir)}", "-rbluepill", File.expand_path($PROGRAM_NAME), *ARGV]
+      ::Process.spawn({DAEMON_ENV => "1"}, RbConfig.ruby, *args, in: File::NULL, out: File::NULL, err: File::NULL)
+      exit
+    end
+
     # Start a new session, which leaves the controlling terminal
     #
     # @return [Integer] the new session's id

data/lib/bluepill/dsl/attributes.rb

@@ -89,8 +89,8 @@ module Bluepill
       # @raise [ConfigError] for a method the proxy doesn't have
       #
       # @api private
-      def evaluate(&block)
-        instance_eval(&block)
+      def evaluate(&)
+        instance_eval(&)
       rescue NameError => e
         raise unless e.receiver.equal?(self)
 

data/lib/bluepill/dsl/process_factory/child_factory.rb

@@ -49,7 +49,7 @@ module Bluepill
       # @api private
       def create_child_process(name, pid, logger)
         child = ProcessProxy.new(name, @attributes, @child_process_block, actual_pid: pid)
-        process = child.to_process(logger: logger)
+        process = child.to_process(logger:)
         process.determine_initial_state
         process
       end
@@ -71,8 +71,11 @@ module Bluepill
       # @api private
       def validate!(parent_name)
         child = ProcessProxy.new("<child of #{parent_name}>", @attributes, @child_process_block)
-        raise ConfigError, "Config Error: You must specify a stop_command for the children of '#{parent_name}'" unless child.stop_command
+        unless child.stop_command
+          raise ConfigError, "Config Error: You must specify a stop_command for the children of '#{parent_name}'"
+        end
 
+        child.validate_privileges!
         child.to_process
       end
     end

data/lib/bluepill/dsl/process_factory/registry.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module Bluepill
   class ProcessFactory
     # The process names and pid files that an application's config has used

data/lib/bluepill/dsl/process_factory.rb

@@ -109,6 +109,7 @@ module Bluepill
       validate_unique_pid_file!(process)
       validate_stop_signals!(process)
       validate_on_start_timeout!(process)
+      process.validate_privileges!
     end
 
     # Fail if another process in the group has the same name
@@ -208,7 +209,8 @@ module Bluepill
       event = process.on_start_timeout
       return if events.include?(event)
 
-      config_error!("Config Error: on_start_timeout for '#{process.name}' must be one of #{events.collect(&:inspect).join(", ")}, not #{event.inspect}")
+      config_error!("Config Error: on_start_timeout for '#{process.name}' must be one of " \
+                    "#{events.collect(&:inspect).join(", ")}, not #{event.inspect}")
     end
 
     # Warn when bluepill can't find the process's pid

data/lib/bluepill/dsl/process_proxy.rb

@@ -2,6 +2,7 @@
 
 require "bluepill/dsl/attributes"
 require "bluepill/process/attributes"
+require "bluepill/daemonize"
 
 module Bluepill
   # The self of a process block in a config file
@@ -25,6 +26,9 @@ module Bluepill
     # monitor_children sets the two attributes it leaves out
     attribute(*(Process::Attributes::CONFIGURABLE_ATTRIBUTES - %i[monitor_children child_process_factory]), :group)
 
+    # The attributes that switch the user or groups that commands run as
+    PRIVILEGE_ATTRIBUTES = %i[uid gid supplementary_groups].freeze
+
     # Return the process's name
     #
     # @return [String] the name
@@ -119,7 +123,9 @@ module Bluepill
     #
     # @api public
     def monitor_children(&child_process_block)
-      raise ConfigError, "monitor_children for process '#{@name}' needs a block that configures the children" unless child_process_block
+      unless child_process_block
+        raise ConfigError, "monitor_children for process '#{@name}' needs a block that configures the children"
+      end
 
       @child_process_block = child_process_block
     end
@@ -139,6 +145,27 @@ module Bluepill
       Process.new(@name, @checks, actual_pid: @actual_pid, **attributes.except(:group), **options)
     end
 
+    # Fail if the process sets a user or groups that bluepill can't switch to
+    #
+    # A Ruby that can't fork, such as JRuby, spawns commands, which can't
+    # switch users or groups. Bluepill only switches when it runs as root,
+    # so they fail the config only then.
+    #
+    # @return [void]
+    #
+    # @raise [ConfigError] if it sets uid, gid or supplementary_groups
+    #
+    # @api private
+    def validate_privileges!
+      return if Daemonize.can_fork? || !::Process::Sys.geteuid.zero?
+
+      set = PRIVILEGE_ATTRIBUTES.select { |name| attributes[name] }
+      return if set.empty?
+
+      raise ConfigError, "Config Error: #{attribute_owner} sets #{set.join(", ")}, but bluepill " \
+                         "can't run commands as another user or group on #{RUBY_ENGINE}, which can't fork"
+    end
+
     # Name the process, for an unknown attribute's error
     #
     # @return [String] the process's name

data/lib/bluepill/dsl.rb

@@ -30,11 +30,11 @@ module Bluepill
   # @return [void]
   #
   # @api public
-  def self.application(app_name, **options, &block)
+  def self.application(app_name, **options, &)
     app_proxy = AppProxy.new(app_name, **options)
     # evaluate also passes the proxy to a block that takes an argument, and
     # turns a misspelled attribute into a ConfigError
-    app_proxy.evaluate(&block)
+    app_proxy.evaluate(&)
     app_proxy.app.load
   rescue Error => e
     location = e.location if e.is_a?(ConfigError)

data/lib/bluepill/logger.rb

@@ -218,8 +218,16 @@ module Bluepill
       # The ::Logger method for each syslog priority
       #
       # @api private
-      LOGGER_EQUIVALENTS =
-        {debug: :debug, err: :error, warning: :warn, info: :info, emerg: :fatal, alert: :warn, crit: :fatal, notice: :info}.freeze
+      LOGGER_EQUIVALENTS = {
+        debug: :debug,
+        err: :error,
+        warning: :warn,
+        info: :info,
+        emerg: :fatal,
+        alert: :warn,
+        crit: :fatal,
+        notice: :info
+      }.freeze
 
       LOG_METHODS.each do |method|
         next if method == LOGGER_EQUIVALENTS[method]

data/lib/bluepill/process/children.rb

@@ -29,7 +29,8 @@ module Bluepill
         new_children_pids = System.get_children(actual_pid) - @children.collect(&:actual_pid)
         return if new_children_pids.empty?
 
-        logger.info "Existing children: #{@children.collect(&:actual_pid).join(",")}. Got new children: #{new_children_pids} for #{actual_pid}"
+        logger.info "Existing children: #{@children.collect(&:actual_pid).join(",")}. " \
+                    "Got new children: #{new_children_pids} for #{actual_pid}"
         add_children(new_children_pids)
       end
 

data/lib/bluepill/process/pid.rb

@@ -47,6 +47,8 @@ module Bluepill
         # could include bluepill itself, so only signal a real pid
         raise "invalid pid #{pid}" unless pid > 0
 
+        # A spawned daemon that exited is a zombie until it's collected
+        System.reap(pid)
         ::Process.kill(code, pid)
         true
       rescue => e

data/lib/bluepill/process/stop_signals.rb

@@ -111,9 +111,12 @@ module Bluepill
           expected, label = i.even? ? [Symbol, "a symbol (signal)"] : [Integer, "a number (delay)"]
           next if value.is_a?(expected)
 
-          raise(ConfigError, "Config Error: Invalid stop_signals!  Expected #{label} at position #{i} instead of '#{value}'.")
+          raise(ConfigError,
+            "Config Error: Invalid stop_signals!  Expected #{label} at position #{i} instead of '#{value}'.")
         end
-        raise(ConfigError, "Config Error: Invalid stop_signals!  Expected an odd number of elements.") unless signals.size.odd?
+        return if signals.size.odd?
+
+        raise(ConfigError, "Config Error: Invalid stop_signals!  Expected an odd number of elements.")
       end
     end
   end

data/lib/bluepill/process/triggers.rb

@@ -37,7 +37,7 @@ module Bluepill
       # @return [Triggers] the triggers
       #
       # @api private
-      def add(klass, process, **options) = self << klass.new(process, **options, logger: logger)
+      def add(klass, process, **options) = self << klass.new(process, **options, logger:)
 
       # Add a trigger
       #
@@ -58,7 +58,7 @@ module Bluepill
       # @return [Array<Trigger>] the triggers
       #
       # @api private
-      def each(&block) = @triggers.each(&block)
+      def each(&) = @triggers.each(&)
 
       # Tell every trigger about a transition, before it happens
       #

data/lib/bluepill/process/watches.rb

@@ -46,7 +46,7 @@ module Bluepill
       # @return [Watches] the watches
       #
       # @api private
-      def add(name, **options) = self << ConditionWatch.new(name, **options, logger: logger)
+      def add(name, **options) = self << ConditionWatch.new(name, **options, logger:)
 
       # Add a watch
       #
@@ -67,7 +67,7 @@ module Bluepill
       # @return [Array<ConditionWatch>] the watches
       #
       # @api private
-      def each(&block) = @watches.each(&block)
+      def each(&) = @watches.each(&)
 
       # Forget what the watches have read, as when the process changes state
       #

data/lib/bluepill/process.rb

@@ -228,8 +228,8 @@ module Bluepill
     # @api private
     def add_checks(checks, logger)
       @logger = logger
-      @watches = Watches.new(logger: logger)
-      @triggers = Triggers.new(logger: logger)
+      @watches = Watches.new(logger:)
+      @triggers = Triggers.new(logger:)
       checks.each { |name, options| add_check(name, options) }
     end
 

data/lib/bluepill/process_commands/execution.rb

@@ -34,8 +34,8 @@ module Bluepill
       # @api private
       def command_options
         System::CommandOptions.new(
-          uid: uid, gid: gid, supplementary_groups: supplementary_groups, working_dir: working_dir,
-          environment: environment, stdin: stdin, stdout: stdout, stderr: stderr
+          uid:, gid:, supplementary_groups:, working_dir:,
+          environment:, stdin:, stdout:, stderr:
         )
       end
 
@@ -51,8 +51,8 @@ module Bluepill
       #   transition happened
       #
       # @api private
-      def with_timeout(secs, next_state, &blk)
-        Timeout.timeout(secs, &blk)
+      def with_timeout(secs, next_state, &)
+        Timeout.timeout(secs, &)
       rescue Timeout::Error
         logger.err "Execution is taking longer than expected."
         logger.err "Did you forget to tell bluepill to daemonize this process?"

data/lib/bluepill/process_commands.rb

@@ -70,7 +70,7 @@ module Bluepill
     def daemonize_process(command)
       # ProcessFactory gives every process that bluepill daemonizes a pid file
       file = pid_file #: String
-      daemon_id = System.daemonize(command, command_options, pid_file: file, logger: logger)
+      daemon_id = System.daemonize(command, command_options, pid_file: file, logger:)
       return unless daemon_id
 
       journal.append(daemon_id)

data/lib/bluepill/process_conditions/file_time.rb

@@ -24,7 +24,7 @@ module Bluepill
       #
       # @api private
       def initialize(filename:, below:, **options)
-        super(below: below, **options)
+        super(below:, **options)
         @filename = filename
       end
 

data/lib/bluepill/process_conditions/http.rb

@@ -44,7 +44,8 @@ module Bluepill
       # @raise [NameError] for a kind that names no Net::HTTP response
       #
       # @api private
-      def initialize(url:, kind: nil, pattern: nil, timeout: 5, open_timeout: timeout, read_timeout: timeout, verify_ssl: true, **options)
+      def initialize(url:, kind: nil, pattern: nil, timeout: 5, open_timeout: timeout, read_timeout: timeout,
+        verify_ssl: true, **options)
         super(**options)
         @verify_ssl = verify_ssl
         @uri = URI.parse(url) #: URI::HTTP