daemon_controller 1.0.0 → 1.1.0

data/daemon_controller.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = "daemon_controller"
   # Don't forget to update version.rb too.
-  s.version = "1.0.0"
-  s.date = "2012-02-04"
+  s.version = "1.1.0"
+  s.date = "2012-10-27"
   s.summary = "A library for implementing daemon management capabilities"
   s.email = "hongli@phusion.nl"
   s.homepage = "https://github.com/FooBarWidget/daemon_controller"

data/lib/daemon_controller.rb

@@ -22,15 +22,12 @@
 require 'tempfile'
 require 'fcntl'
 require 'timeout'
-
-libdir = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift(libdir)
-require 'daemon_controller/lock_file'
-
 if Process.respond_to?(:spawn)
 	require 'rbconfig'
 end
 
+require 'daemon_controller/lock_file'
+
 # Main daemon controller object. See the README for an introduction and tutorial.
 class DaemonController
 	ALLOWED_CONNECT_EXCEPTIONS = [Errno::ECONNREFUSED, Errno::ENETUNREACH,
@@ -123,6 +120,13 @@ class DaemonController
 	#  
 	#  The default value is +nil+.
 	#
+	# [:restart_command]
+	#  A command to restart the daemon with, e.g. "/etc/rc.d/nginx restart". If
+	#  no restart command is given (i.e. +nil+), then DaemonController will
+	#  restart the daemon by calling #stop and #start.
+	#
+	#  The default value is +nil+.
+	#
 	# [:before_start]
 	#  This may be a Proc. It will be called just before running the start command.
 	#  The before_start proc is not subject to the start timeout.
@@ -173,6 +177,10 @@ class DaemonController
 	#  descriptors except stdin, stdout and stderr. However if there are any file
 	#  descriptors you want to keep open, specify the IO objects here. This must be
 	#  an array of IO objects.
+	#
+	# [:env]
+	#  This must be a Hash.  The hash will contain the environment variables available
+	#  to be made available to the daemon. Hash keys must be strings, not symbols.
 	def initialize(options)
 		[:identifier, :start_command, :ping_command, :pid_file, :log_file].each do |option|
 			if !options.has_key?(option)
@@ -183,6 +191,7 @@ class DaemonController
 		@start_command = options[:start_command]
 		@stop_command = options[:stop_command]
 		@ping_command = options[:ping_command]
+		@restart_command = options[:restart_command]
 		@ping_interval = options[:ping_interval] || 0.1
 		@pid_file = options[:pid_file]
 		@log_file = options[:log_file]
@@ -193,6 +202,7 @@ class DaemonController
 		@daemonize_for_me = options[:daemonize_for_me]
 		@keep_ios = options[:keep_ios] || []
 		@lock_file = determine_lock_file(options, @identifier, @pid_file)
+		@env = options[:env] || {}
 	end
 	
 	# Start the daemon and wait until it can be pinged.
@@ -289,6 +299,17 @@ class DaemonController
 		end
 	end
 	
+	# Restarts the daemon. Uses the restart_command if provided, otherwise
+	# calls #stop and #start.
+	def restart
+		if @restart_command
+			run_command(@restart_command)
+		else
+			stop
+			start
+		end
+	end
+	
 	# Returns the daemon's PID, as reported by its PID file. Returns the PID
 	# as an integer, or nil there is no valid PID in the PID file.
 	#
@@ -315,6 +336,12 @@ class DaemonController
 		end
 	end
 
+	# Checks whether ping Unix domain sockets is supported. Currently
+	# this is supported on all Ruby implementations, except JRuby.
+	def self.can_ping_unix_sockets?
+		return RUBY_PLATFORM != "java"
+	end
+
 private
 	def start_without_locking
 		if daemon_is_running?
@@ -558,6 +585,11 @@ private
 	def self.fork_supported?
 		return RUBY_PLATFORM != "java" && RUBY_PLATFORM !~ /win32/
 	end
+
+	def self.spawn_supported?
+		# Process.spawn doesn't work very well in JRuby.
+		return Process.respond_to?(:spawn) && RUBY_PLATFORM != "java"
+	end
 	
 	def run_command(command)
 		# Create tempfile for storing the command's output.
@@ -566,7 +598,7 @@ private
 		File.chmod(0666, tempfile_path)
 		tempfile.close
 		
-		if self.class.fork_supported? || Process.respond_to?(:spawn)
+		if self.class.fork_supported? || self.class.spawn_supported?
 			if Process.respond_to?(:spawn)
 				options = {
 					:in  => "/dev/null",
@@ -578,14 +610,10 @@ private
 					options[io] = io
 				end
 				if @daemonize_for_me
-					ruby_interpreter = File.join(
-						Config::CONFIG['bindir'],
-						Config::CONFIG['RUBY_INSTALL_NAME']
-					) + Config::CONFIG['EXEEXT']
-					pid = Process.spawn(ruby_interpreter, SPAWNER_FILE,
+					pid = Process.spawn(@env, ruby_interpreter, SPAWNER_FILE,
 						command, options)
 				else
-					pid = Process.spawn(command, options)
+					pid = Process.spawn(@env, command, options)
 				end
 			else
 				pid = safe_fork(@daemonize_for_me) do
@@ -597,6 +625,7 @@ private
 					STDIN.reopen("/dev/null", "r")
 					STDOUT.reopen(tempfile_path, "w")
 					STDERR.reopen(tempfile_path, "w")
+					ENV.update(@env)
 					exec(command)
 				end
 			end
@@ -642,8 +671,14 @@ private
 				raise StartError, File.read(tempfile_path).strip
 			end
 		else
+			if @env && !@env.empty?
+				raise "Setting the :env option is not supported on this Ruby implementation."
+			elsif @daemonize_for_me
+				raise "Setting the :daemonize_for_me option is not supported on this Ruby implementation."
+			end
+
 			cmd = "#{command} >\"#{tempfile_path}\""
-			cmd += " 2>\"#{tempfile_path}\"" unless PLATFORM =~ /mswin/
+			cmd << " 2>\"#{tempfile_path}\"" unless PLATFORM =~ /mswin/
 			if !system(cmd)
 				raise StartError, File.read(tempfile_path).strip
 			end
@@ -665,19 +700,74 @@ private
 			end
 		elsif @ping_command.is_a?(Array)
 			type, *args = @ping_command
-			
-			case type
-			when :tcp
-				socket_domain = Socket::Constants::AF_INET
-				hostname, port = args
-				sockaddr = Socket.pack_sockaddr_in(port, hostname)
-			when :unix
-				socket_domain = Socket::Constants::AF_LOCAL
-				sockaddr = Socket.pack_sockaddr_un(args[0])
+			if self.class.can_ping_unix_sockets?
+				case type
+				when :tcp
+					socket_domain = Socket::Constants::AF_INET
+					hostname, port = args
+					sockaddr = Socket.pack_sockaddr_in(port, hostname)
+				when :unix
+					socket_domain = Socket::Constants::AF_LOCAL
+					sockaddr = Socket.pack_sockaddr_un(args[0])
+				else
+					raise ArgumentError, "Unknown ping command type #{type.inspect}"
+				end
+				return ping_socket(socket_domain, sockaddr)
 			else
-				raise ArgumentError, "Unknown ping command type #{type.inspect}"
+				case type
+				when :tcp
+					hostname, port = args
+					return ping_socket(hostname, port)
+				when :unix
+					raise "Pinging Unix domain sockets is not supported on this Ruby implementation"
+				else
+					raise ArgumentError, "Unknown ping command type #{type.inspect}"
+				end
 			end
+		else
+			return system(@ping_command)
+		end
+	end
 
+	if !can_ping_unix_sockets?
+		require 'java'
+		
+		def ping_socket(host_name, port)
+			channel = java.nio.channels.SocketChannel.open
+			begin
+				address = java.net.InetSocketAddress.new(host_name, port)
+				channel.configure_blocking(false)
+				if channel.connect(address)
+					return true
+				end
+
+				deadline = Time.now.to_f + 0.1
+				done = false
+				while true
+					begin
+						if channel.finish_connect
+							return true
+						end
+					rescue java.net.ConnectException => e
+						if e.message =~ /Connection refused/i
+							return false
+						else
+							throw e
+						end
+					end
+					
+					# Not done connecting and no error.
+					sleep 0.01
+					if Time.now.to_f >= deadline
+						return false
+					end
+				end
+			ensure
+				channel.close
+			end
+		end
+	else
+		def ping_socket(socket_domain, sockaddr)
 			begin
 				socket = Socket.new(socket_domain, Socket::Constants::SOCK_STREAM, 0)
 				begin
@@ -698,11 +788,16 @@ private
 			ensure
 				socket.close if socket
 			end
-		else
-			return system(@ping_command)
 		end
 	end
 
+	def ruby_interpreter
+		File.join(
+			Config::CONFIG['bindir'],
+			Config::CONFIG['RUBY_INSTALL_NAME']
+		) + Config::CONFIG['EXEEXT']
+	end
+
 	def safe_fork(double_fork)
 		pid = fork
 		if pid.nil?

data/lib/daemon_controller/lock_file.rb

@@ -78,7 +78,7 @@ class LockFile
 	# The lock file *must* be writable, otherwise an Errno::EACCESS
 	# exception will be raised.
 	def shared_lock
-		File.open(@filename, 'w') do |f|
+		File.open(@filename, 'w+') do |f|
 			if Fcntl.const_defined? :F_SETFD
 				f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 			end
@@ -93,7 +93,7 @@ class LockFile
 	#
 	# If a lock can be obtained, then the given block will be yielded.
 	def try_shared_lock
-		File.open(@filename, 'w') do |f|
+		File.open(@filename, 'w+') do |f|
 			if Fcntl.const_defined? :F_SETFD
 				f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 			end

data/lib/daemon_controller/spawn.rb

@@ -19,6 +19,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-# Used on Ruby 1.9 because forking may not be safe/supported on all platforms.
+# This helper script is used for daemonizing a command by executing it and
+# then exiting ourselves. Used on Ruby 1.9 and JRuby because forking may not
+# be safe/supported on all platforms.
 Process.setsid
 Process.spawn(ARGV[0])

data/lib/daemon_controller/version.rb

@@ -21,7 +21,7 @@
 
 class DaemonController
 	MAJOR = 1
-	MINOR = 0
+	MINOR = 1
 	TINY  = 0
 	VERSION_STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
 end # class DaemonController

data/spec/daemon_controller_spec.rb

@@ -128,7 +128,7 @@ describe DaemonController, "#start" do
 		end
 	end
 	
-	if DaemonController.send(:fork_supported?) || Process.respond_to?(:spawn)
+	if DaemonController.send(:fork_supported?) || DaemonController.send(:spawn_supported?)
 		it "kills the daemon if it doesn't start in time and hasn't forked " <<
 		   "yet, on platforms where Ruby supports fork() or Process.spawn" do
 			begin
@@ -209,7 +209,7 @@ describe DaemonController, "#start" do
 		log.should == ["before_start", "start_command"]
 	end
 	
-	if DaemonController.send(:fork_supported?) || Process.respond_to?(:spawn)
+	if DaemonController.send(:fork_supported?) || DaemonController.send(:spawn_supported?)
 		it "keeps the file descriptors in 'keep_ios' open" do
 			a, b = IO.pipe
 			begin
@@ -234,6 +234,14 @@ describe DaemonController, "#start" do
 			@controller.stop
 		end
 	end
+
+	it "receives environment variables" do
+		new_controller(:env => {'ENV_FILE' => 'spec/env_file.tmp'})
+		File.unlink('spec/env_file.tmp') if File.exist?('spec/env_file.tmp')
+		@controller.start
+		File.exist?('spec/env_file.tmp').should be_true
+		@controller.stop
+	end
 end
 
 describe DaemonController, "#stop" do
@@ -291,6 +299,36 @@ describe DaemonController, "#stop" do
 	end
 end
 
+describe DaemonController, "#restart" do
+	include TestHelper
+	
+	before :each do
+		new_controller
+	end
+	
+	it "raises no exception if the daemon is not running" do
+		@controller.restart
+	end
+	
+	describe 'with no restart command' do
+		it "restart the daemon using stop and start" do
+			@controller.should_receive(:stop)
+			@controller.should_receive(:start)
+			@controller.restart
+		end
+	end
+	
+	describe 'with a restart_command' do
+		it 'restarts the daemon using the restart_command' do
+			stop_cmd = "echo 'hello world'"
+			new_controller :restart_command => stop_cmd
+			
+			@controller.should_receive(:run_command).with(stop_cmd)
+			@controller.restart
+		end
+	end
+end
+
 describe DaemonController, "#connect" do
 	include TestHelper
 	
@@ -321,6 +359,11 @@ end
 
 describe DaemonController do
 	include TestHelper
+
+	after :each do
+		@server.close if @server && !@server.closed?
+		File.unlink('spec/foo.sock') rescue nil
+	end
 	
 	specify "if the ping command is a block that raises Errno::ECONNREFUSED, then that's " <<
 	        "an indication that the daemon cannot be connected to" do
@@ -332,57 +375,50 @@ describe DaemonController do
 	
 	specify "if the ping command is a block that returns an object that responds to #close, " <<
 	        "then the close method will be called on that object" do
-		server = TCPServer.new('localhost', 8278)
-		begin
-			socket = nil
-			new_controller(:ping_command => lambda do
-				socket = TCPSocket.new('localhost', 8278)
-			end)
-			@controller.send(:run_ping_command)
-			socket.should be_closed
-		ensure
-			server.close
-		end
+		@server = TCPServer.new('localhost', 8278)
+		socket = nil
+		new_controller(:ping_command => lambda do
+			socket = TCPSocket.new('localhost', 8278)
+		end)
+		@controller.send(:run_ping_command)
+		socket.should be_closed
 	end
 	
 	specify "if the ping command is a block that returns an object that responds to #close, " <<
 	        "and #close raises an exception, then that exception is ignored" do
-		server = TCPServer.new('localhost', 8278)
-		begin
-			o = Object.new
-			o.should_receive(:close).and_return do
-				raise StandardError, "foo"
-			end
-			new_controller(:ping_command => lambda do
-				o
-			end)
-			lambda { @controller.send(:run_ping_command) }.should_not raise_error(StandardError)
-		ensure
-			server.close
+		@server = TCPServer.new('localhost', 8278)
+		o = Object.new
+		o.should_receive(:close).and_return do
+			raise StandardError, "foo"
 		end
+		new_controller(:ping_command => lambda do
+			o
+		end)
+		lambda { @controller.send(:run_ping_command) }.should_not raise_error(StandardError)
 	end
 
 	specify "the ping command may be [:tcp, hostname, port]" do
-		new_controller(:ping_command => [:tcp, "localhost", 8278])
+		new_controller(:ping_command => [:tcp, "127.0.0.1", 8278])
 		@controller.send(:run_ping_command).should be_false
 
-		server = TCPServer.new('localhost', 8278)
-		begin
-			@controller.send(:run_ping_command).should be_true
-		ensure
-			server.close
-		end
+		@server = TCPServer.new('127.0.0.1', 8278)
+		@controller.send(:run_ping_command).should be_true
 	end
 
-	specify "the ping command may be [:unix, filename]" do
-		new_controller(:ping_command => [:unix, "spec/foo.sock"])
-		@controller.send(:run_ping_command).should be_false
+	if DaemonController.can_ping_unix_sockets?
+		specify "the ping command may be [:unix, filename]" do
+			new_controller(:ping_command => [:unix, "spec/foo.sock"])
+			@controller.send(:run_ping_command).should be_false
 
-		server = UNIXServer.new('spec/foo.sock')
-		begin
+			@server = UNIXServer.new('spec/foo.sock')
 			@controller.send(:run_ping_command).should be_true
-		ensure
-			server.close
+		end
+	else
+		specify "a ping command of type [:unix, filename] is not supported on this Ruby implementation" do
+			new_controller(:ping_command => [:unix, "spec/foo.sock"])
+			@server = UNIXServer.new('spec/foo.sock')
+			lambda { @controller.send(:run_ping_command) }.should raise_error(
+				"Pinging Unix domain sockets is not supported on this Ruby implementation")
 		end
 	end
 end

data/spec/echo_server.rb

@@ -1,5 +1,8 @@
-#!/usr/bin/env ruby
+#!/usr/bin/ruby
 # A simple echo server, used by the unit test.
+# The hashbang is explicitly set to /usr/bin/ruby because we need
+# a Ruby implementation that starts fast and supports forking. The
+# Ruby in $PATH may be JRuby which is neither.
 require 'socket'
 require 'optparse'
 
@@ -61,6 +64,10 @@ if options[:pid_file]
 	end
 end
 
+if ENV['ENV_FILE']
+	options[:env_file] = File.expand_path(ENV['ENV_FILE'])
+end
+
 def main(options)
 	STDIN.reopen("/dev/null", 'r')
 	STDOUT.reopen(options[:log_file], 'a')
@@ -69,6 +76,15 @@ def main(options)
 	STDERR.sync = true
 	Dir.chdir(options[:chdir])
 	File.umask(0)
+
+	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])
@@ -122,4 +138,4 @@ if options[:daemonize]
 	end
 else
 	main(options)
-end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: daemon_controller
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Hongli Lai
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-04 00:00:00 Z
+date: 2012-10-27 00:00:00 Z
 dependencies: []
 
 description: A library for robust daemon management.