dante 0.2.0 → 0.3.0

data/test/test_helper.rb

@@ -1,24 +1,144 @@
 require 'rubygems'
+require 'fileutils'
 require 'tempfile'
+require 'tmpdir'
 require 'minitest/autorun'
-require 'mocha'
-$:.unshift File.expand_path("../../lib")
+$:.unshift File.expand_path("../../lib", __FILE__)
 require 'dante'
 
+module DanteTestHarness
+  TEST_PID = Process.pid
+
+  # The signal handlers in place before any test ran; Runner#start replaces them in
+  # the test process itself whenever a test runs a runner in the foreground.
+  ORIGINAL_TRAPS = %w(INT TERM).each_with_object({}) do |sig, traps|
+    traps[sig] = trap(sig, 'DEFAULT')
+    trap(sig, traps[sig])
+  end
+
+  # Daemons are forked from inside a test, so every forked process inherits the at_exit
+  # handlers of the test process (minitest's among them). Make forked processes leave
+  # without running them. It is registered during the run, after minitest's own handler,
+  # so it runs first.
+  def self.install_fork_guard
+    return if @fork_guard_installed
+    @fork_guard_installed = true
+    at_exit do
+      next if Process.pid == TEST_PID
+      exit!($!.is_a?(SystemExit) ? $!.status : ($! ? 1 : 0))
+    end
+  end
+
+  def before_setup
+    super
+    DanteTestHarness.install_fork_guard
+    @tmpdir = Dir.mktmpdir('dante-test-')
+    @original_argv = ARGV.dup
+    ARGV.clear
+  end
+
+  def after_teardown
+    stop_daemons
+  ensure
+    ARGV.replace(@original_argv)
+    ORIGINAL_TRAPS.each { |sig, handler| trap(sig, handler) }
+    FileUtils.rm_rf(@tmpdir)
+    super
+  end
+
+  # A path inside this test's own temporary directory.
+  def tmp_path(name)
+    File.join(@tmpdir, name)
+  end
+
+  # Polls until the block returns a truthy value and returns it, or returns nil once
+  # timeout seconds have passed.
+  def wait_until(timeout = 10, interval = 0.05)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+    loop do
+      result = yield
+      return result if result
+      return nil if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+      sleep interval
+    end
+  end
+
+  # The pid of the daemon recorded in pid_path.
+  def daemon_pid(pid_path)
+    pid = wait_until { File.exist?(pid_path) && (n = File.read(pid_path).to_i) > 0 && n }
+    assert pid, "no pid written to #{pid_path}"
+    (@daemon_pids ||= []) << pid # stopped in teardown even if the pid file is gone by then
+    pid
+  end
+
+  # Waits until a daemon has reached its startup block, shown by it creating path (and
+  # writing pattern to it). Runner#daemonize returns once the pid file exists, before the
+  # daemon has run its startup block.
+  def wait_for_output(path, pattern = //)
+    assert wait_until { File.exist?(path) && File.read(path) =~ pattern }, "#{path} never matched #{pattern.inspect}"
+  end
+
+  # Waits for a daemon to exit (it is not our child: init reaps it).
+  def wait_for_exit(pid, timeout = 10)
+    assert wait_until(timeout) { !process_alive?(pid) }, "process #{pid} still running after #{timeout}s"
+  end
+
+  # Whether pid is a live process. A zombie counts as gone: it has exited and only waits
+  # for its parent (init, for a daemon) to reap it.
+  # ceiling: zombies are recognised through /proc (Linux) only; elsewhere a zombie counts
+  # as alive until init reaps it, which only makes the waits longer.
+  def process_alive?(pid)
+    Process.kill(0, pid)
+    stat = "/proc/#{pid}/stat"
+    !(File.exist?(stat) && (line = File.read(stat))[line.rindex(')') + 2] == 'Z')
+  rescue Errno::ESRCH, Errno::EPERM, Errno::ENOENT, RangeError # ENOENT: reaped between the two checks; RangeError: no pid_t
+    false
+  end
+
+  # Stops every daemon whose pid file is in this test's directory, or whose pid the test
+  # read with daemon_pid, even when the test failed: SIGTERM first, then SIGKILL for
+  # daemons that trap SIGTERM.
+  # ceiling: a pid file or recorded pid of a daemon that already exited is trusted while
+  # its pid is alive, so a pid reused within the test's lifetime would be signalled;
+  # checking the process start time in /proc would rule that out.
+  def stop_daemons
+    pid_files = Dir[File.join(@tmpdir, '**', '*.pid')]
+    pids = pid_files.map { |f| [File.read(f).to_i, f] } + Array(@daemon_pids).map { |p| [p, 'daemon_pid'] }
+    pids.uniq { |pid, _| pid }.each do |pid, pid_file|
+      begin
+        next unless pid > 0 && process_alive?(pid)
+        %w(TERM KILL).each do |sig|
+          Process.kill(sig, pid)
+          break if wait_until(5) { !process_alive?(pid) }
+        end
+      rescue Errno::ESRCH
+        next
+      end
+      raise "daemon #{pid} from #{pid_file} survived SIGKILL" if process_alive?(pid)
+    end
+  end
+end
+
+Minitest::Test.send(:include, DanteTestHarness)
+
 ## Kernel Extensions
-require 'stringio'
 
 module Kernel
-  # Redirect standard out, standard error and the buffered logger for sprinkle to StringIO
+  # Redirect standard out and standard error to a file and return what was written
   # capture_stdout { any_commands; you_want } => "all output from the commands"
+  #
+  # The file is a real IO rather than a StringIO so that a daemon forked inside the block
+  # reopens $stdout onto its log file, as it does outside the tests.
   def capture_stdout
     return yield if ENV['DEBUG'] # Skip if debug mode
 
-    out = StringIO.new
-    $stdout = out
-    $stderr = out
-    yield
-    return out.string
+    Tempfile.create('stdout', @tmpdir || Dir.tmpdir) do |out|
+      out.sync = true
+      $stdout = out
+      $stderr = out
+      yield
+      File.read(out.path)
+    end
   ensure
     $stdout = STDOUT
     $stderr = STDERR
@@ -29,8 +149,8 @@ end
 class TestingProcess
   attr_reader :tmp_path
 
-  def initialize(name)
-    @tmp_path = "/tmp/dante-#{name}.log"
+  def initialize(name, dir)
+    @tmp_path = File.join(dir, "dante-#{name}.log")
   end # initialize
 
   def run_a!(data=nil)
@@ -64,4 +184,14 @@ class TestingProcess
   ensure
     puts "Closing!!"
   end
-end # TestingProcess
+
+  # Survives SIGTERM (and SIGINT): only SIGKILL stops it
+  def run_d!(data=nil)
+    p ['The rescuer']
+    sleep 100
+  rescue SystemExit, SignalException
+    p ['Saved']
+    retry
+  end
+
+end # TestingProcess

data/test/user_switch_test.rb

@@ -0,0 +1,194 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'etc'
+
+# Switching user and group needs root. CI runs this file a second time under sudo.
+describe "dante runner switching user and group" do
+  before do
+    skip "switching user and group needs root (CI runs this file under sudo)" unless Process.euid == 0
+    skip "reads credentials from /proc" unless File.exist?("/proc/self/status")
+    @nobody = begin
+      Etc.getpwnam('nobody')
+    rescue ArgumentError
+      skip "no 'nobody' user"
+    end
+    @nobody_group = Etc.getgrgid(@nobody.gid).name
+
+    # The switched process must be able to write its pid and log files.
+    File.chmod(0755, @tmpdir)
+    @dir = tmp_path('shared')
+    Dir.mkdir(@dir)
+    File.chmod(0777, @dir)
+    @pid_path = File.join(@dir, 'dante.pid')
+    @log_path = File.join(@dir, 'dante.log')
+    @status_path = File.join(@dir, 'status')
+  end
+
+  # Runs the block in a forked child that starts with the given supplementary groups,
+  # as a process started by root might have. Fails the test if the block raises. The
+  # error goes through a file rather than a pipe, which a daemon started by the block
+  # would hold open.
+  def run_in_child(groups = [0, 4, 27])
+    error_path = tmp_path('child-error')
+    pid = fork do
+      error = File.open(error_path, 'w') # opened before the block switches user
+      error.sync = true # exit! below doesn't flush
+      begin
+        $stdout = $stderr = File.open(tmp_path('child.out'), 'w')
+        Process.groups = groups
+        yield
+      rescue Exception => e
+        error.write("#{e.class}: #{e.message}")
+        exit!(1)
+      end
+      exit!(0)
+    end
+    Process.wait(pid)
+    assert_equal [0, ""], [$?.exitstatus, File.read(error_path)]
+  end
+
+  # The real, effective, saved and filesystem uids and gids and the supplementary
+  # groups, from the text of /proc/<pid>/status.
+  def credentials(status)
+    fields = status.lines.map { |line| line.chomp.split(/:\s*/, 2) }.to_h
+    { :uid => fields['Uid'].split.map(&:to_i), :gid => fields['Gid'].split.map(&:to_i),
+      :groups => fields['Groups'].to_s.split.map(&:to_i).sort }
+  end
+
+  # The supplementary groups the group database gives user, with primary group gid.
+  def groups_of(user, gid)
+    gids = [gid]
+    Etc.group { |group| gids << group.gid if group.mem.include?(user) }
+    gids.uniq.sort
+  end
+
+  # A uid with no passwd entry.
+  def unused_uid
+    (4242..60000).find do |uid|
+      begin
+        Etc.getpwuid(uid)
+        false
+      rescue ArgumentError
+        true
+      end
+    end
+  end
+
+  # The startup block of a foreground runner: records the process's credentials.
+  def record_status
+    status_path = @status_path
+    lambda { |_opts| File.write(status_path, File.read('/proc/self/status')) }
+  end
+
+  it "gives a daemon started with -u the user's uid, primary group and groups" do
+    run_in_child do
+      ARGV.replace(['-d', '-P', @pid_path, '-l', @log_path, '-u', 'nobody'])
+      Dante::Runner.new('test-process').execute { sleep 100 }
+    end
+    creds = credentials(File.read("/proc/#{daemon_pid(@pid_path)}/status"))
+
+    assert_equal [@nobody.uid] * 4, creds[:uid]
+    assert_equal [@nobody.gid] * 4, creds[:gid]
+    assert_equal groups_of('nobody', @nobody.gid), creds[:groups]
+    assert_empty creds[:groups] & [0, 4, 27]
+  end
+
+  it "gives a daemon started with -u and -G that group and the user's groups" do
+    group = begin
+      Etc.getgrgid(1)
+    rescue ArgumentError
+      skip "no group with gid 1"
+    end
+    run_in_child do
+      ARGV.replace(['-d', '-P', @pid_path, '-l', @log_path, '-u', 'nobody', '-G', group.name])
+      Dante::Runner.new('test-process').execute { sleep 100 }
+    end
+    creds = credentials(File.read("/proc/#{daemon_pid(@pid_path)}/status"))
+
+    assert_equal [@nobody.uid] * 4, creds[:uid]
+    assert_equal [group.gid] * 4, creds[:gid]
+    assert_equal groups_of('nobody', group.gid), creds[:groups]
+    assert_empty creds[:groups] & [0, 4, 27]
+  end
+
+  it "keeps root's uid and leaves only the new group with -G alone" do
+    run_in_child do
+      ARGV.replace(['-G', @nobody_group])
+      Dante::Runner.new('test-process').execute(&record_status)
+    end
+    creds = credentials(File.read(@status_path))
+
+    assert_equal [0] * 4, creds[:uid]
+    assert_equal [@nobody.gid] * 4, creds[:gid]
+    assert_equal [@nobody.gid], creds[:groups]
+  end
+
+  it "accepts a uid, and gives it the user's primary group and groups" do
+    run_in_child do
+      Dante::Runner.new('test-process').execute(:user => @nobody.uid, &record_status)
+    end
+    creds = credentials(File.read(@status_path))
+
+    assert_equal [@nobody.uid] * 4, creds[:uid]
+    assert_equal [@nobody.gid] * 4, creds[:gid]
+    assert_equal groups_of('nobody', @nobody.gid), creds[:groups]
+  end
+
+  it "keeps the group of a uid with no passwd entry and leaves only that group" do
+    uid = unused_uid
+    run_in_child do
+      Dante::Runner.new('test-process').execute(:user => uid, &record_status)
+    end
+    creds = credentials(File.read(@status_path))
+
+    assert_equal [uid] * 4, creds[:uid]
+    assert_equal [0] * 4, creds[:gid]
+    assert_equal [0], creds[:groups]
+  end
+
+  it "gives a uid with no passwd entry the group named by :group" do
+    uid = unused_uid
+    run_in_child do
+      Dante::Runner.new('test-process').execute(:user => uid, :group => @nobody.gid, &record_status)
+    end
+    creds = credentials(File.read(@status_path))
+
+    assert_equal [uid] * 4, creds[:uid]
+    assert_equal [@nobody.gid] * 4, creds[:gid]
+    assert_equal [@nobody.gid], creds[:groups]
+  end
+
+  it "keeps the current group when not root and given only the current user" do
+    group = begin
+      Etc.getgrgid(1)
+    rescue ArgumentError
+      skip "no group with gid 1"
+    end
+    run_in_child do
+      Dante::Runner.new('test-process').execute(:user => 'nobody', :group => group.gid) {}
+      # now nobody, with a group other than nobody's primary group
+      Dante::Runner.new('test-process').execute(:user => 'nobody', &record_status)
+    end
+    creds = credentials(File.read(@status_path))
+
+    assert_equal [@nobody.uid] * 4, creds[:uid]
+    assert_equal [group.gid] * 4, creds[:gid]
+  end
+
+  it "gives a user its supplementary groups from the group database" do
+    member = nil
+    Etc.group do |group|
+      member ||= group.mem.find { |name| name != 'root' && (Etc.getpwnam(name) rescue nil) }
+    end
+    skip "no user is a member of a group in the group database" unless member
+    passwd = Etc.getpwnam(member)
+    run_in_child([0]) do
+      Dante::Runner.new('test-process').execute(:user => member, &record_status)
+    end
+    creds = credentials(File.read(@status_path))
+
+    assert_equal [passwd.uid] * 4, creds[:uid]
+    assert_equal [passwd.gid] * 4, creds[:gid]
+    assert_equal groups_of(member, passwd.gid), creds[:groups]
+    assert_operator creds[:groups].size, :>, 1
+  end
+end

metadata

@@ -1,57 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: dante
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Nathan Esquenazi
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-12-04 00:00:00.000000000 Z
+date: 2026-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 description: Turn any process into a demon.
 email:
 - nesquena@gmail.com
@@ -59,7 +45,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".github/workflows/ci.yml"
+- ".github/workflows/release.yml"
+- ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -71,30 +60,28 @@ files:
 - test/dante_test.rb
 - test/runner_test.rb
 - test/test_helper.rb
-homepage: https://github.com/bazaarlabs/dante
-licenses: []
+- test/user_switch_test.rb
+homepage: https://github.com/nesquena/dante
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: dante
-rubygems_version: 2.0.7
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Turn any process into a demon
-test_files:
-- test/dante_test.rb
-- test/runner_test.rb
-- test/test_helper.rb
+test_files: []