daemon_controller 1.2.0 → 3.0.0

data/spec/echo_server.rb

@@ -1,138 +1,170 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 # A simple echo server, used by the unit test.
-require 'socket'
-require 'optparse'
+require "socket"
+require "optparse"
 
 options = {
-	:port => 3230,
-	:chdir => "/",
-	:log_file => "/dev/null",
-	:wait1 => 0,
-	:wait2 => 0,
-	:stop_time => 0,
-	:daemonize => true
+  port: 3230,
+  chdir: "/",
+  log_file: "/dev/null",
+  wait1: 0,
+  wait2: 0,
+  stop_time: 0,
+  daemonize: true
 }
 parser = OptionParser.new do |opts|
-	opts.banner = "Usage: echo_server.rb [options]"
-	opts.separator ""
-	
-	opts.separator "Options:"
-	opts.on("-p", "--port PORT", Integer, "Port to use. Default: 3230") do |value|
-		options[:port] = value
-	end
-	opts.on("-C", "--change-dir DIR", String, "Change working directory. Default: /") do |value|
-		options[:chdir] = value
-	end
-	opts.on("-l", "--log-file FILENAME", String, "Log file to use. Default: /dev/null") do |value|
-		options[:log_file] = value
-	end
-	opts.on("-P", "--pid-file FILENAME", String, "Pid file to use.") do |value|
-		options[:pid_file] = File.expand_path(value)
-	end
-	opts.on("--wait1 SECONDS", Float, "Wait a few seconds before writing pid file.") do |value|
-		options[:wait1] = value
-	end
-	opts.on("--wait2 SECONDS", Float, "Wait a few seconds before binding server socket.") do |value|
-		options[:wait2] = value
-	end
-	opts.on("--stop-time SECONDS", Float, "Wait a few seconds before exiting.") do |value|
-		options[:stop_time] = value
-	end
-	opts.on("--crash-before-bind", "Whether the daemon should crash before binding the server socket.") do
-		options[:crash_before_bind] = true
-	end
-	opts.on("--no-daemonize", "Don't daemonize.") do
-		options[:daemonize] = false
-	end
+  opts.banner = "Usage: echo_server.rb [options]"
+  opts.separator ""
+
+  opts.separator "Options:"
+  opts.on("-p", "--port PORT", Integer, "Port to use. Default: 3230") do |value|
+    options[:port] = value
+  end
+  opts.on("-C", "--change-dir DIR", String, "Change working directory. Default: /") do |value|
+    options[:chdir] = value
+  end
+  opts.on("-l", "--log-file FILENAME", String, "Log file to use. Default: /dev/null") do |value|
+    options[:log_file] = value
+  end
+  opts.on("-P", "--pid-file FILENAME", String, "Pid file to use.") do |value|
+    options[:pid_file] = File.absolute_path(value)
+  end
+  opts.on("--log-message1 MESSAGE", String, "Log message before opening log file.") do |value|
+    options[:log_message1] = value
+  end
+  opts.on("--log-message2 MESSAGE", String, "Log message after opening log file.") do |value|
+    options[:log_message2] = value
+  end
+  opts.on("--wait1 SECONDS", Float, "Wait a few seconds before writing pid file.") do |value|
+    options[:wait1] = value
+  end
+  opts.on("--wait2 SECONDS", Float, "Wait a few seconds before binding server socket.") do |value|
+    options[:wait2] = value
+  end
+  opts.on("--stop-time SECONDS", Float, "Wait a few seconds before exiting.") do |value|
+    options[:stop_time] = value
+  end
+  opts.on("--crash-before-bind", "Whether the daemon should crash before binding the server socket.") do
+    options[:crash_before_bind] = true
+  end
+  opts.on("--crash-signal SIGNAL", "Signal to send to the daemon when crashing.") do |value|
+    options[:crash_signal] = value
+  end
+  opts.on("--no-daemonize", "Don't daemonize.") do
+    options[:daemonize] = false
+  end
+  opts.on("--ignore-sigterm", "Ignore SIGTERM.") do
+    options[:ignore_sigterm] = true
+  end
 end
 begin
-	parser.parse!
+  parser.parse!
 rescue OptionParser::ParseError => e
-	puts e
-	puts
-	puts "Please see '--help' for valid options."
-	exit 1
+  puts e
+  puts
+  puts "Please see '--help' for valid options."
+  exit 1
 end
 
 if options[:pid_file]
-	if File.exist?(options[:pid_file])
-		STDERR.puts "*** ERROR: pid file #{options[:pid_file]} exists."
-		exit 1
-	end
+  if File.exist?(options[:pid_file])
+    warn "*** ERROR: pid file #{options[:pid_file]} exists."
+    exit 1
+  end
+end
+
+if options[:log_message1]
+  puts options[:log_message1]
+  $stdout.flush
 end
 
-if ENV['ENV_FILE']
-	options[:env_file] = File.expand_path(ENV['ENV_FILE'])
+if options[:ignore_sigterm]
+  Signal.trap("SIGTERM", "IGNORE")
+end
+
+sleep(options[:wait1])
+
+if ENV["ENV_FILE"]
+  options[:env_file] = File.absolute_path(ENV["ENV_FILE"])
 end
 
 def main(options)
-	STDIN.reopen("/dev/null", 'r')
-	STDOUT.reopen(options[:log_file], 'a')
-	STDERR.reopen(options[:log_file], 'a')
-	STDOUT.sync = true
-	STDERR.sync = true
-	Dir.chdir(options[:chdir])
-	File.umask(0)
+  $stdin.reopen("/dev/null", "r")
+  $stdout.reopen(options[:log_file], "a")
+  $stderr.reopen(options[:log_file], "a")
+  $stdout.sync = true
+  $stderr.sync = true
+  Dir.chdir(options[:chdir])
+  File.umask(0)
+
+  if options[:log_message2]
+    puts options[:log_message2]
+  end
+
+  if options[:env_file]
+    File.write(options[:env_file], "\0")
+    at_exit do
+      File.unlink(options[:env_file])
+    rescue
+      nil
+    end
+  end
+
+  if options[:pid_file]
+    File.open(options[:pid_file], "w") do |f|
+      f.puts(Process.pid)
+    end
+  end
+
+  sleep(options[:wait2])
+  if options[:crash_before_bind]
+    puts "#{Time.now}: crashing, as instructed."
+    if options[:crash_signal]
+      Process.kill(options[:crash_signal], Process.pid)
+    end
+    exit 2
+  end
 
-	if options[:env_file]
-		File.open(options[:env_file], 'w') do |f|
-			f.write("\0")
-		end
-		at_exit do
-			File.unlink(options[:env_file]) rescue nil
-		end
-	end
-	
-	if options[:pid_file]
-		sleep(options[:wait1])
-		File.open(options[:pid_file], 'w') do |f|
-			f.puts(Process.pid)
-		end
-		at_exit do
-			File.unlink(options[:pid_file]) rescue nil
-		end
-	end
-	
-	sleep(options[:wait2])
-	if options[:crash_before_bind]
-		puts "#{Time.now}: crashing, as instructed."
-		exit 2
-	end
-	
-	server = TCPServer.new('127.0.0.1', options[:port])
-	begin
-		puts "*** #{Time.now}: echo server started"
-		while (client = server.accept)
-			puts "#{Time.now}: new client"
-			begin
-				while (line = client.readline)
-					puts "#{Time.now}: client sent: #{line.strip}"
-					client.puts(line)
-				end
-			rescue EOFError
-			ensure
-				puts "#{Time.now}: connection closed"
-				client.close rescue nil
-			end
-		end
-	rescue SignalException
-		exit 2
-	rescue => e
-		puts e.to_s
-		puts "    " << e.backtrace.join("\n    ")
-		exit 3
-	ensure
-		puts "*** #{Time.now}: echo server exiting..."
-		sleep(options[:stop_time])
-		puts "*** #{Time.now}: echo server exited"
-	end
+  server = TCPServer.new("127.0.0.1", options[:port])
+  begin
+    puts "*** #{Time.now}: echo server started"
+    while (client = server.accept)
+      puts "#{Time.now}: new client"
+      begin
+        while (line = client.readline)
+          puts "#{Time.now}: client sent: #{line.strip}"
+          client.puts(line)
+        end
+      rescue EOFError
+      ensure
+        puts "#{Time.now}: connection closed"
+        begin
+          client.close
+        rescue
+          nil
+        end
+      end
+    end
+  rescue SignalException
+    exit 2
+  rescue => e
+    puts e
+    puts "    " + e.backtrace.join("\n    ")
+    exit 3
+  ensure
+    puts "*** #{Time.now}: echo server exiting..."
+    sleep(options[:stop_time])
+    puts "*** #{Time.now}: echo server exited"
+  end
 end
 
 if options[:daemonize]
-	fork do
-		Process.setsid
-		main(options)
-	end
+  fork do
+    Process.setsid
+    main(options)
+  end
 else
-	main(options)
+  main(options)
 end

data/spec/test_helper.rb

@@ -1,116 +1,189 @@
-root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-$LOAD_PATH.unshift(File.join(root, "lib"))
+# frozen_string_literal: true
+
+require "shellwords"
+
+root = File.absolute_path(File.join(File.dirname(__FILE__), ".."))
 Dir.chdir(root)
 
-if !ENV['MRI_RUBY']
-	if RUBY_PLATFORM =~ /java/
-		# We need a Ruby implementation that starts fast and supports forking.
-		# JRuby is neither.
-		abort "In order to run these tests in JRuby, you must set " +
-			"the environment variable $MRI_RUBY to an MRI Ruby interpeter."
-	else
-		require 'rbconfig'
-		rb_config = defined?(RbConfig) ? RbConfig::CONFIG : Config::CONFIG
-		ENV['MRI_RUBY'] = rb_config['bindir'] + '/' + rb_config['RUBY_INSTALL_NAME'] +
-			rb_config['EXEEXT']
-		puts ENV['MRI_RUBY']
-	end
+# Ensure subprocesses (with could be a different Ruby) are
+# started without Bundler environment variables.
+ENV.replace(Bundler.with_unbundled_env { ENV.to_h.dup })
+
+if !ENV["MRI_RUBY"]
+  if RUBY_PLATFORM.match?(/java/)
+    # We need a Ruby implementation that starts fast and supports forking.
+    # JRuby is neither.
+    abort "In order to run these tests in JRuby, you must set " \
+      "the environment variable $MRI_RUBY to an MRI Ruby interpeter."
+  else
+    require "rbconfig"
+    rb_config = defined?(RbConfig) ? RbConfig::CONFIG : Config::CONFIG
+    ENV["MRI_RUBY"] = rb_config["bindir"] + "/" + rb_config["RUBY_INSTALL_NAME"] +
+      rb_config["EXEEXT"]
+    puts ENV["MRI_RUBY"]
+  end
+end
+
+trap("SIGQUIT") do
+  if Thread.respond_to?(:list)
+    output = String.new("----- #{Time.now} -----\n")
+    Thread.list.each do |thread|
+      output << "##### #{thread}\n"
+      output << thread.backtrace.join("\n")
+      output << "\n\n"
+    end
+    output << "--------------------"
+    warn(output)
+    $stderr.flush
+  end
 end
 
 module TestHelper
-	def new_controller(options = {})
-		@start_command = './spec/run_echo_server -l spec/echo_server.log -P spec/echo_server.pid'
-		if options[:wait1]
-			@start_command << " --wait1 #{options[:wait1]}"
-		end
-		if options[:wait2]
-			@start_command << " --wait2 #{options[:wait2]}"
-		end
-		if options[:stop_time]
-			@start_command << " --stop-time #{options[:stop_time]}"
-		end
-		if options[:crash_before_bind]
-			@start_command << " --crash-before-bind"
-		end
-		if options[:no_daemonize]
-			@start_command << " --no-daemonize"
-		end
-		new_options = {
-			:identifier    => 'My Test Daemon',
-			:start_command => @start_command,
-			:ping_command  => method(:ping_echo_server),
-			:pid_file      => 'spec/echo_server.pid',
-			:log_file      => 'spec/echo_server.log',
-			:start_timeout => 3,
-			:stop_timeout  => 3
-		}.merge(options)
-		@controller = DaemonController.new(new_options)
-	end
-	
-	def ping_echo_server
-		begin
-			TCPSocket.new('127.0.0.1', 3230)
-			true
-		rescue SystemCallError
-			false
-		end
-	end
-	
-	def write_file(filename, contents)
-		File.open(filename, 'w') do |f|
-			f.write(contents)
-		end
-	end
-	
-	def exec_is_slow?
-		return RUBY_PLATFORM == "java"
-	end
-	
-	def process_is_alive?(pid)
-		begin
-			Process.kill(0, pid)
-			return true
-		rescue Errno::ESRCH
-			return false
-		rescue SystemCallError => e
-			return true
-		end
-	end
-	
-	def eventually(deadline_duration = 1, check_interval = 0.05)
-		deadline = Time.now + deadline_duration
-		while Time.now < deadline
-			if yield
-				return
-			else
-				sleep(check_interval)
-			end
-		end
-		raise "Time limit exceeded"
-	end
+  def new_logger
+    @logger ||= begin
+      @log_stream = StringIO.new
+      logger = Logger.new(@log_stream)
+      logger.level = Logger::DEBUG
+      logger
+    end
+  end
+
+  def print_logs(example)
+    warn "----- LOGS FOR: #{example.full_description} ----"
+    warn @log_stream.string
+    warn "----- END LOGS -----"
+  end
+
+  def new_controller(options = {})
+    @start_command = String.new("./spec/run_in_mri_ruby echo_server.rb -l spec/echo_server.log")
+    if (log_message1 = options.delete(:log_message1))
+      @start_command << " --log-message1 #{Shellwords.escape log_message1}"
+    end
+    if (log_message2 = options.delete(:log_message2))
+      @start_command << " --log-message2 #{Shellwords.escape log_message2}"
+    end
+    if (wait1 = options.delete(:wait1))
+      @start_command << " --wait1 #{wait1}"
+    end
+    if (wait2 = options.delete(:wait2))
+      @start_command << " --wait2 #{wait2}"
+    end
+    if (stop_time = options.delete(:stop_time))
+      @start_command << " --stop-time #{stop_time}"
+    end
+    if options.delete(:crash_before_bind)
+      @start_command << " --crash-before-bind"
+    end
+    if (crash_signal = options.delete(:crash_signal))
+      @start_command << " --crash-signal #{crash_signal}"
+    end
+    if options.delete(:no_daemonize)
+      @start_command << " --no-daemonize"
+    end
+    if options.delete(:ignore_sigterm)
+      @start_command << " --ignore-sigterm"
+    end
+    if !options.delete(:no_write_pid_file)
+      @start_command << " -P spec/echo_server.pid"
+    end
+    new_options = {
+      identifier: "My Test Daemon",
+      start_command: @start_command,
+      ping_command: method(:ping_echo_server),
+      pid_file: "spec/echo_server.pid",
+      log_file: "spec/echo_server.log",
+      start_timeout: 30,
+      stop_timeout: 30,
+      logger: new_logger
+    }.merge(options)
+    @controller = DaemonController.new(**new_options)
+  end
+
+  def ping_echo_server
+    TCPSocket.new("127.0.0.1", 3230)
+    true
+  rescue SystemCallError
+    false
+  end
+
+  def monotonic_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def write_file(filename, contents)
+    File.write(filename, contents)
+  end
+
+  def exec_is_slow?
+    RUBY_PLATFORM == "java"
+  end
+
+  def process_is_alive?(pid)
+    Process.kill(0, pid)
+    true
+  rescue Errno::ESRCH
+    false
+  rescue SystemCallError
+    true
+  end
+
+  def eventually(deadline_duration = 1, check_interval = 0.05)
+    deadline = monotonic_time + deadline_duration
+    while monotonic_time < deadline
+      if yield
+        return
+      else
+        sleep(check_interval)
+      end
+    end
+    raise "Time limit exceeded"
+  end
+
+  def wait_until_pid_file_available
+    eventually(30) do
+      @controller.send(:pid_file_available?)
+    end
+  end
+
+  def find_echo_server_pid
+    process_line = `ps aux`.lines.grep(/echo_server\.rb/).first
+    process_line.split[1].to_i if process_line
+  end
+
+  def kill_and_wait_echo_server
+    pid = find_echo_server_pid
+    if pid
+      Process.kill("SIGTERM", pid)
+      Timeout.timeout(5) do
+        while find_echo_server_pid
+          sleep(0.1)
+        end
+      end
+    end
+  end
 end
 
 # A thread which doesn't execute its block until the
 # 'go!' method has been called.
 class WaitingThread < Thread
-	def initialize
-		@mutex = Mutex.new
-		@cond = ConditionVariable.new
-		@go = false
-		super do
-			@mutex.synchronize do
-				while !@go
-					@cond.wait(@mutex)
-				end
-			end
-			yield
-		end
-	end
-	
-	def go!
-		@mutex.synchronize do
-			@go = true
-			@cond.broadcast
-		end
-	end
+  def initialize
+    @mutex = Mutex.new
+    @cond = ConditionVariable.new
+    @go = false
+    super do
+      @mutex.synchronize do
+        until @go
+          @cond.wait(@mutex)
+        end
+      end
+      yield
+    end
+  end
+
+  def go!
+    @mutex.synchronize do
+      @go = true
+      @cond.broadcast
+    end
+  end
 end

data/spec/unresponsive_daemon.rb

@@ -1,12 +1,12 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 dir = File.dirname(__FILE__)
 Dir.chdir(File.dirname(dir))
-begin
-	File.open("spec/echo_server.pid", "w") do |f|
-		f.puts(Process.pid)
-	end
-	sleep 30
-rescue SignalException
-	File.unlink("spec/echo_server.pid") rescue nil
-	raise
-end
+
+Signal.trap("SIGTERM", "IGNORE") if ARGV.include?("--ignore-sigterm")
+
+File.open("spec/echo_server.pid", "w") do |f|
+  f.puts(Process.pid)
+end
+sleep 60

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: daemon_controller
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Hongli Lai
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-03 00:00:00.000000000 Z
+date: 2025-04-08 00:00:00.000000000 Z
 dependencies: []
 description: A library for robust daemon management.
 email: software-signing@phusion.nl
@@ -17,50 +16,37 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
-- README.markdown
+- README.md
 - Rakefile
 - daemon_controller.gemspec
-- debian.template/changelog
-- debian.template/compat
-- debian.template/control.template
-- debian.template/copyright
-- debian.template/ruby-daemon-controller.install
-- debian.template/rules
-- debian.template/source/format
 - lib/daemon_controller.rb
 - lib/daemon_controller/lock_file.rb
 - lib/daemon_controller/packaging.rb
 - lib/daemon_controller/spawn.rb
 - lib/daemon_controller/version.rb
-- rpm/get_distro_id.py
-- rpm/rubygem-daemon_controller.spec.template
 - spec/daemon_controller_spec.rb
 - spec/echo_server.rb
-- spec/run_echo_server
 - spec/test_helper.rb
 - spec/unresponsive_daemon.rb
 homepage: https://github.com/FooBarWidget/daemon_controller
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.0
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A library for implementing daemon management capabilities
 test_files: []