bluepill 0.3.0 → 0.3.2

data/lib/bluepill/socket.rb

@@ -27,7 +27,7 @@ module Bluepill
     # @return [Object] what the block returns
     #
     # @api private
-    def self.client(base_dir, name, &block) = UNIXSocket.open(socket_path(base_dir, name), &block)
+    def self.client(base_dir, name, &) = UNIXSocket.open(socket_path(base_dir, name), &)
 
     # Send a command to an application's daemon, and return its answer
     #

data/lib/bluepill/system/command_options.rb

@@ -92,7 +92,8 @@ module Bluepill
       # @return [void]
       #
       # @api private
-      def initialize(uid: nil, gid: nil, supplementary_groups: nil, working_dir: nil, environment: nil, stdin: nil, stdout: nil, stderr: nil, timeout: nil)
+      def initialize(uid: nil, gid: nil, supplementary_groups: nil, working_dir: nil, environment: nil, stdin: nil,
+        stdout: nil, stderr: nil, timeout: nil)
         @uid = uid
         @gid = gid
         @supplementary_groups = supplementary_groups
@@ -116,7 +117,7 @@ module Bluepill
       #
       # @api private
       def for_hook(env, timeout)
-        self.class.new(**to_h, environment: environment.merge(env), timeout: timeout)
+        self.class.new(**to_h, environment: environment.merge(env), timeout:)
       end
 
       # Return the options as a Hash
@@ -126,8 +127,8 @@ module Bluepill
       # @api private
       def to_h
         {
-          uid: uid, gid: gid, supplementary_groups: supplementary_groups, working_dir: working_dir,
-          environment: environment, stdin: stdin, stdout: stdout, stderr: stderr, timeout: timeout
+          uid:, gid:, supplementary_groups:, working_dir:,
+          environment:, stdin:, stdout:, stderr:, timeout:
         }
       end
     end

data/lib/bluepill/system/command_result.rb

@@ -67,7 +67,7 @@ module Bluepill
       # @return [Hash{Symbol => Object}] the :exit_code, :stdout and :stderr
       #
       # @api private
-      def to_h = {exit_code: exit_code, stdout: stdout, stderr: stderr}
+      def to_h = {exit_code:, stdout:, stderr:}
     end
   end
 end

data/lib/bluepill/system/command_spawn.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "bluepill/system/command_result"
+
+module Bluepill
+  module System
+    # Start commands without forking bluepill, in a Ruby that can't fork,
+    # such as JRuby
+    #
+    # The command gets the working directory and environment that a forked
+    # one sets up. It can't switch to another user or groups, which a
+    # config that sets them fails to load for.
+    #
+    # Commands and Daemon include it, and System extends them, so these are
+    # System's module functions.
+    #
+    # @api private
+    module CommandSpawn
+      # The seconds between checks of whether a spawned command has exited
+      EXIT_POLL_INTERVAL = 0.05
+
+      # Start a command, without waiting for it to finish
+      #
+      # @param [String] cmd the command, split into words without a shell
+      # @param [CommandOptions] options its working_dir and environment
+      # @param [String, nil] chdir the directory to run in without a
+      #   working_dir, or nil for bluepill's
+      # @param [Hash{Symbol => Object}] redirects more of Process.spawn's
+      #   options, such as where its standard streams go
+      #
+      # @return [Integer] the command's pid
+      #
+      # @raise [SystemCallError] if it can't be run, say because it doesn't
+      #   exist
+      #
+      # @api private
+      def spawn_command(cmd, options, chdir: nil, **redirects)
+        dir = options.working_dir&.to_s || chdir
+        redirects[:chdir] = dir if dir
+        program, *args = Shellwords.shellwords(cmd)
+        ::Process.spawn(spawn_environment(options), program.to_s, *args, **redirects)
+      end
+
+      # Run a command until it finishes, and return what it printed
+      #
+      # It's execute_blocking, for a Ruby that can't fork. Two threads read
+      # what the command prints, so neither pipe fills up and stops it.
+      #
+      # @param [String] cmd the command, split into words without a shell
+      # @param [CommandOptions] options its working_dir, environment and
+      #   timeout
+      #
+      # @return [CommandResult] what it printed, and its exit code, which is
+      #   1 if it couldn't be run
+      #
+      # @raise [Timeout::Error] if it ran longer than the timeout
+      #
+      # @api private
+      def spawn_blocking(cmd, options)
+        out_read, out_write = IO.pipe
+        err_read, err_write = IO.pipe
+        run_spawned(cmd, options, [out_read, err_read], [out_write, err_write])
+      end
+
+      # Spawn a command with its output on pipes, and wait for it to finish
+      #
+      # @param [String] cmd the command
+      # @param [CommandOptions] options as for spawn_blocking
+      # @param [Array(IO, IO)] readers the pipes' readers, for its standard
+      #   output and standard error, which are closed after
+      # @param [Array(IO, IO)] writers the pipes' writers
+      #
+      # @return [CommandResult] what it printed, and its exit code, which is
+      #   1 if it couldn't be run
+      #
+      # @raise [Timeout::Error] if it ran longer than the timeout
+      #
+      # @api private
+      def run_spawned(cmd, options, readers, writers)
+        out, err = writers
+        pid = spawn_blocking_command(cmd, options, out, err)
+        wait_for_spawned(cmd, options.timeout, pid, readers)
+      rescue SystemCallError => e
+        CommandResult.new(exit_code: 1, stderr: "Could not run #{cmd}: #{e.message}\n")
+      ensure
+        readers.each(&:close)
+      end
+
+      # Spawn a command that runs until it finishes, with its output on pipes
+      #
+      # With a timeout, it runs in a process group of its own, which is
+      # killed if it runs too long. The pipes' writers are closed here, so
+      # they end when the command closes its ends.
+      #
+      # @param [String] cmd the command
+      # @param [CommandOptions] options as for spawn_blocking
+      # @param [IO] out the pipe for its standard output
+      # @param [IO] err the pipe for its standard error
+      #
+      # @return [Integer] its pid
+      #
+      # @raise [SystemCallError] if it can't be run
+      #
+      # @api private
+      def spawn_blocking_command(cmd, options, out, err)
+        # pgroup: nil leaves it in bluepill's process group
+        spawn_command(cmd, options, in: File::NULL, out:, err:, pgroup: (true if options.timeout))
+      ensure
+        out.close
+        err.close
+      end
+
+      # Wait for a spawned command to finish, and collect what it printed
+      #
+      # @param [String] cmd the command, for the error on a timeout
+      # @param [Numeric, ActiveSupport::Duration, nil] timeout the seconds to
+      #   wait for it, or nil to wait until it finishes
+      # @param [Integer] pid its pid
+      # @param [Array(IO, IO)] pipes where to read its standard output and
+      #   standard error
+      #
+      # @return [CommandResult] what it printed, and its exit code (nil if a
+      #   signal ended it)
+      #
+      # @raise [Timeout::Error] if it ran longer than the timeout
+      #
+      # @api private
+      def wait_for_spawned(cmd, timeout, pid, pipes)
+        readers = pipes.collect { |pipe| read_in_background(pipe) }
+        status = wait_for_exit(pid, timeout) || kill_spawned_after(pid, timeout, cmd)
+        stdout, stderr = readers.collect(&:value)
+        CommandResult.new(exit_code: status.exitstatus, stdout:, stderr:)
+      end
+
+      # Wait for a spawned command to exit, for up to a timeout
+      #
+      # It polls, since a thread blocked waiting for a process would keep
+      # JRuby from exiting until the process does.
+      #
+      # @param [Integer] pid the command's pid
+      # @param [Numeric, ActiveSupport::Duration, nil] timeout the seconds to
+      #   wait, or nil to wait until it exits
+      #
+      # @return [Process::Status, nil] how it exited, or nil if it's still
+      #   running at the timeout
+      #
+      # @api private
+      def wait_for_exit(pid, timeout)
+        deadline = monotonic_now + timeout.to_f if timeout
+        loop do
+          _, status = ::Process.wait2(pid, ::Process::WNOHANG)
+          return status if status
+          return if deadline && monotonic_now >= deadline
+
+          Kernel.sleep(EXIT_POLL_INTERVAL)
+        end
+      end
+
+      # Kill a spawned command's process group after its timeout, and reap it
+      #
+      # @param [Integer] pid the command's pid, which leads the group
+      # @param [Numeric, ActiveSupport::Duration] timeout the seconds it was given
+      # @param [String] cmd the command, for the error
+      #
+      # @return [void] it never returns
+      #
+      # @raise [Timeout::Error] always
+      #
+      # @api private
+      def kill_spawned_after(pid, timeout, cmd)
+        kill_group_after(pid, timeout, cmd)
+      ensure
+        begin
+          ::Process.wait(pid)
+        rescue Errno::ECHILD
+          # It was collected already
+        end
+      end
+
+      # Kill a command's process group, once it has run past its timeout
+      #
+      # Forked commands are killed this way too.
+      #
+      # @param [Integer] child the pid of the group's leader, which runs the
+      #   command
+      # @param [Numeric, ActiveSupport::Duration] timeout the seconds it was given
+      # @param [String] cmd the command, for the error
+      #
+      # @return [void] it never returns
+      #
+      # @raise [Timeout::Error] always
+      #
+      # @api private
+      def kill_group_after(child, timeout, cmd)
+        begin
+          ::Process.kill("KILL", -child)
+        rescue Errno::ESRCH
+          nil # it finished just now
+        end
+        raise Timeout::Error, "#{cmd} took longer than #{timeout} seconds"
+      end
+
+      # Return the seconds on the monotonic clock, as a Float
+      #
+      # @return [Float]
+      #
+      # @api private
+      def monotonic_now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+      # Read a pipe to its end in a thread
+      #
+      # @param [IO] reader the pipe
+      #
+      # @return [Thread] a thread whose value is what it read, or "" if the
+      #   pipe was closed first, after a timeout
+      #
+      # @api private
+      def read_in_background(reader)
+        Thread.new do
+          reader.read
+        rescue IOError
+          ""
+        end
+      end
+
+      # Return the environment variables a command gets, as Strings
+      #
+      # PWD is the working directory, as a shell sets it, unless the
+      # environment sets it too.
+      #
+      # @param [CommandOptions] options its working_dir and environment
+      #
+      # @return [Hash{String => String}]
+      #
+      # @api private
+      def spawn_environment(options)
+        working_dir = options.working_dir
+        env = options.environment.to_h { |key, value| [key.to_s, value.to_s] }
+        working_dir ? {"PWD" => working_dir.to_s}.merge(env) : env
+      end
+    end
+  end
+end

data/lib/bluepill/system/commands.rb

@@ -6,6 +6,7 @@ require "bluepill/daemonize"
 require "bluepill/system/command_options"
 require "bluepill/system/command_result"
 require "bluepill/system/command_setup"
+require "bluepill/system/command_spawn"
 require "bluepill/system/daemon"
 
 module Bluepill
@@ -18,12 +19,14 @@ module Bluepill
     # @api private
     module Commands
       include CommandSetup
+      include CommandSpawn
 
       # Run a command until it finishes, and return what it printed
       #
       # With a timeout, the command runs in a process group of its own, and
       # if it hasn't finished in time, that whole group is killed, so a hung
-      # command and anything it started don't keep running.
+      # command and anything it started don't keep running. A Ruby that
+      # can't fork spawns the command instead.
       #
       # @param [String] cmd the command, split into words without a shell
       # @param [CommandOptions] options its uid, gid, supplementary_groups,
@@ -35,6 +38,8 @@ module Bluepill
       #
       # @api private
       def execute_blocking(cmd, options = CommandOptions.new)
+        return spawn_blocking(cmd, options) unless Daemonize.can_fork?
+
         rd, wr = IO.pipe
 
         child = Daemonize.safefork
@@ -95,27 +100,6 @@ module Bluepill
         reader.close
       end
 
-      # Kill a command's process group, once it has run past its timeout
-      #
-      # @param [Integer] child the pid of the group's leader, which runs the
-      #   command
-      # @param [Numeric, ActiveSupport::Duration] timeout the seconds it was given
-      # @param [String] cmd the command, for the error
-      #
-      # @return [void] it never returns
-      #
-      # @raise [Timeout::Error] always
-      #
-      # @api private
-      def kill_group_after(child, timeout, cmd)
-        begin
-          ::Process.kill("KILL", -child)
-        rescue Errno::ESRCH
-          nil # it finished just now
-        end
-        raise Timeout::Error, "#{cmd} took longer than #{timeout} seconds"
-      end
-
       # Run a command in a grandchild, report its result, and exit
       #
       # Sends the grandchild's output and exit code to the parent over

data/lib/bluepill/system/daemon.rb

@@ -4,6 +4,7 @@ require "shellwords"
 require "bluepill/daemonize"
 require "bluepill/system/command_options"
 require "bluepill/system/command_setup"
+require "bluepill/system/command_spawn"
 
 module Bluepill
   module System
@@ -19,12 +20,14 @@ module Bluepill
     # @api private
     module Daemon
       include CommandSetup
+      include CommandSpawn
 
       # Start a command as a daemon, and write its pid file
       #
       # It forks a child that drops privileges, sets up the environment and
       # standard streams, and daemonizes the command. The child tells the
-      # parent the daemon's pid over a pipe.
+      # parent the daemon's pid over a pipe. A Ruby that can't fork spawns
+      # the command instead.
       #
       # @param [String] cmd the command, split into words without a shell
       # @param [CommandOptions] options its uid, gid, supplementary_groups,
@@ -36,6 +39,19 @@ module Bluepill
       #
       # @api private
       def daemonize(cmd, options = CommandOptions.new, pid_file:, logger:)
+        return fork_daemon(cmd, options, pid_file:, logger:) if Daemonize.can_fork?
+
+        spawn_daemon(cmd, options, pid_file:, logger:)
+      end
+
+      # Start a command as a daemon by forking, and write its pid file
+      #
+      # @param (see #daemonize)
+      #
+      # @return [Integer, nil] the daemon's pid, or nil if it didn't start
+      #
+      # @api private
+      def fork_daemon(cmd, options, pid_file:, logger:)
         rd, wr = IO.pipe
 
         child = Daemonize.safefork
@@ -49,10 +65,71 @@ module Bluepill
           rd.close
 
           drop_privileges(options.uid, options.gid, options.supplementary_groups)
-          start_daemon(cmd, options, wr, pid_file: pid_file, logger: logger)
+          start_daemon(cmd, options, wr, pid_file:, logger:)
         end
       end
 
+      # Start a command as a daemon without forking, and write its pid file
+      #
+      # The command runs in a process group of its own, as a forked daemon's
+      # new session does, so killing what's left in it never kills bluepill.
+      # It stays bluepill's child, and pid_alive? collects its exit status.
+      #
+      # @param [String] cmd the command, split into words without a shell
+      # @param [CommandOptions] options its working_dir, environment, stdin,
+      #   stdout and stderr
+      # @param [String] pid_file where to write the daemon's pid
+      # @param [Logger] logger where to log why it didn't start
+      #
+      # @return [Integer, nil] the daemon's pid, or nil if it didn't start
+      #
+      # @api private
+      def spawn_daemon(cmd, options, pid_file:, logger:)
+        return unless can_write_pid_file(pid_file, logger)
+
+        pid = spawn_command(cmd, options, chdir: "/", pgroup: true, **daemon_streams(options))
+        File.write(pid_file, pid.to_s)
+        pid
+      rescue SystemCallError => e
+        logger.warning(format("%s - %s", e.class, e))
+        nil
+      end
+
+      # Return where a spawned daemon's standard streams go
+      #
+      # They're /dev/null unless the options name files. Output and error
+      # share one file when they name the same one, and are appended to.
+      #
+      # @param [CommandOptions] options its stdin, stdout and stderr
+      #
+      # @return [Hash{Symbol => Object}] Process.spawn's in, out and err
+      #
+      # @api private
+      def daemon_streams(options)
+        out = options.stdout
+        {
+          in: options.stdin || File::NULL,
+          out: out ? [out, APPEND_MODE] : File::NULL,
+          err: daemon_stderr(out, options.stderr)
+        }
+      end
+
+      # Return where a spawned daemon's standard error goes
+      #
+      # @param [String, nil] out the file for standard output
+      # @param [String, nil] err the file for standard error
+      #
+      # @return [Object] Process.spawn's err: standard output when they're
+      #   the same file, the file, or /dev/null
+      #
+      # @api private
+      def daemon_stderr(out, err)
+        return File::NULL unless err
+        return [:child, :out] if err.eql?(out)
+
+        [err, APPEND_MODE]
+      end
+
       # Read the daemon's pid from the child that started it, in the parent
       #
       # @param [IO] reader the end of the pipe that the child writes the pid to

data/lib/bluepill/system/usage.rb

@@ -18,6 +18,7 @@ module Bluepill
       #
       # @api private
       def pid_alive?(pid)
+        reap(pid)
         ::Process.kill(0, pid)
         true
       rescue Errno::EPERM # no permission, but it is definitely alive
@@ -26,6 +27,25 @@ module Bluepill
         false # no such process (ESRCH), or no pid
       end
 
+      # Collect the exit status of a daemon that bluepill spawned, if it exited
+      #
+      # A spawned daemon stays bluepill's child, and one that exited is a
+      # zombie, which kill(0) still finds, until bluepill collects its exit
+      # status. A thread that waits for it instead would keep JRuby from
+      # exiting while the daemon runs. A Ruby that forks has no daemons to
+      # collect, since init adopts them.
+      #
+      # @param [Integer, nil] pid the daemon's pid
+      #
+      # @return [void]
+      #
+      # @api private
+      def reap(pid)
+        ::Process.wait(pid, ::Process::WNOHANG) if pid && !Daemonize.can_fork?
+      rescue Errno::ECHILD
+        # It isn't bluepill's child, or was collected already
+      end
+
       # Return when a process started, in seconds since the epoch
       #
       # It's read from ps's elapsed time for the process, so it's accurate to

data/lib/bluepill/version.rb

@@ -4,7 +4,7 @@ module Bluepill
   # The version of bluepill
   #
   # @example
-  #   Bluepill::Version.to_s # => "0.3.0"
+  #   Bluepill::Version.to_s # => "0.3.2"
   #
   # @api public
   module Version
@@ -31,12 +31,12 @@ module Bluepill
     # Return the patch version
     #
     # @example
-    #   Bluepill::Version.patch # => 0
+    #   Bluepill::Version.patch # => 2
     #
     # @return [Integer] the patch version
     #
     # @api public
-    def self.patch = 0
+    def self.patch = 2
 
     # Return the pre-release version
     #
@@ -52,7 +52,7 @@ module Bluepill
     # Return the version's parts by name
     #
     # @example
-    #   Bluepill::Version.to_h # => {major: 0, minor: 3, patch: 0, pre: nil}
+    #   Bluepill::Version.to_h # => {major: 0, minor: 3, patch: 2, pre: nil}
     #
     # @return [Hash{Symbol => Integer, nil}] the major, minor, patch and
     #   pre-release versions
@@ -60,17 +60,17 @@ module Bluepill
     # @api public
     def self.to_h
       {
-        major: major,
-        minor: minor,
-        patch: patch,
-        pre: pre
+        major:,
+        minor:,
+        patch:,
+        pre:
       }
     end
 
     # Return the version's parts, without a missing pre-release version
     #
     # @example
-    #   Bluepill::Version.to_a # => [0, 3, 0]
+    #   Bluepill::Version.to_a # => [0, 3, 2]
     #
     # @return [Array<Integer>] the parts of the version
     #
@@ -80,9 +80,9 @@ module Bluepill
     # Return the version as a string
     #
     # @example
-    #   Bluepill::Version.to_s # => "0.3.0"
+    #   Bluepill::Version.to_s # => "0.3.2"
     #
-    # @return [String] the version, such as "0.3.0"
+    # @return [String] the version, such as "0.3.2"
     #
     # @api public
     def self.to_s = to_a.join(".")

data/sig/bluepill/dsl.rbs

@@ -142,6 +142,10 @@ module Bluepill
     include DSL::Attributes
     extend DSL::Attributes::ClassMethods
 
+    PRIVILEGE_ATTRIBUTES: Array[Symbol]
+
+    def validate_privileges!: () -> void
+
     attr_reader name: String
     attr_reader child_process_block: process_block?
     attr_reader actual_pid: Integer?