daemon_controller 1.2.0 → 2.0.0

data/spec/echo_server.rb

@@ -1,138 +1,162 @@
 #!/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
 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 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]
+    sleep(options[:wait1])
+    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,143 @@
-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_controller(options = {})
+    @start_command = String.new("./spec/run_echo_server -l spec/echo_server.log")
+    if options[:log_message1]
+      @start_command << " --log-message1 #{Shellwords.escape options[:log_message1]}"
+    end
+    if options[:log_message2]
+      @start_command << " --log-message2 #{Shellwords.escape options[:log_message2]}"
+    end
+    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[:crash_signal]
+      @start_command << " --crash-signal #{options[:crash_signal]}"
+    end
+    if options[:no_daemonize]
+      @start_command << " --no-daemonize"
+    end
+    if !options[: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
+    }.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 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 = Time.now + deadline_duration
+    while Time.now < deadline
+      if yield
+        return
+      else
+        sleep(check_interval)
+      end
+    end
+    raise "Time limit exceeded"
+  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,18 @@
 #!/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
+  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
+  begin
+    File.unlink("spec/echo_server.pid")
+  rescue
+    nil
+  end
+  raise
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: daemon_controller
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Hongli Lai
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-03 00:00:00.000000000 Z
+date: 2025-03-24 00:00:00.000000000 Z
 dependencies: []
 description: A library for robust daemon management.
 email: software-signing@phusion.nl
@@ -17,23 +16,14 @@ 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
@@ -43,24 +33,21 @@ 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: []

checksums.yaml.gz.asc

@@ -1,12 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Version: GnuPG/MacGPG2 v2.0.17 (Darwin)
-Comment: GPGTools - http://gpgtools.org
-
-iQEcBAABAgAGBQJTFNXmAAoJECrHRaUKISqMzVcH/3xePU605BycvtYvhZDEDmIk
-O27O70O3hDW6+ljjprz7aAniJMGkF3ewn34BJ35kb5xmhxi5gFdVzu/Su9un1KWw
-RKy0b/5rR6SJvuFxaWAOBUtTk/YO2FyG43dTvKb12OtAha9V2F5etoTPMzPyzllH
-GfIpaW0EuHqPfq/+6+rgtNGyrfXagx4udvh394RJlIsys/zrgH/gP37x/1XsHTAn
-Hbe6AeHuaCLPm8PMLTsETQleeioA/Dkgju1Ag9ihvG4qlVqRFM5EA2zJvR9yWb33
-7YfgSHUSU4TYdPER4FrKQfUTbGCuJiInrxF2M1awpHSgMKC3hgnOAG9Koh9hiz8=
-=wUWc
------END PGP SIGNATURE-----

data/debian.template/changelog

@@ -1,5 +0,0 @@
-daemon-controller-ruby (1.1.2-1) precise; urgency=low
-
-  * Initial packaging
-
- -- Hongli Lai <hongli@phusion.nl>  Wed, 01 May 2013 16:04:07 +0200

data/debian.template/compat

@@ -1 +0,0 @@
-7

data/debian.template/control.template

@@ -1,15 +0,0 @@
-Source: ruby-daemon-controller
-Section: ruby
-Priority: extra
-Maintainer: Hongli Lai <hongli@phusion.nl>
-Build-Depends: debhelper (>= 7.0.50~)
-Standards-Version: 3.9.3
-Homepage: https://github.com/FooBarWidget/daemon_controller
-Vcs-Git: git://github.com/FooBarWidget/daemon_controller.git
-Vcs-Browser: https://github.com/FooBarWidget/daemon_controller
-
-Package: ruby-daemon-controller
-Architecture: all
-Depends: ${shlibs:Depends}, ${misc:Depends}, ruby | ruby-interpreter
-Description: Library for robust daemon management
- Library which implements daemon management capabilities.