class PhusionPassenger::AbstractServer

def before_fork
end

def client
	return @child_channel
end

def define_message_handler(message_name, handler)
	@message_handlers[message_name.to_s] = handler
end

def define_signal_handler(signal, handler)
	@signal_handlers[signal.to_s] = handler
end

def finalize_server
end

def initialize
	@done = false
	@message_handlers = {}
	@signal_handlers = {}
	@orig_signal_handlers = {}
	@last_activity_time = Time.now
end

def initialize_server
end

def main_loop
	channel = MessageChannel.new(@child_socket)
	while !@done
		begin
			name, *args = channel.read
			@last_activity_time = Time.now
			if name.nil?
				@done = true
			elsif @message_handlers.has_key?(name)
				__send__(@message_handlers[name], *args)
			else
				raise UnknownMessage, "Unknown message '#{name}' received."
			end
		rescue Interrupt
			@done = true
		rescue SignalException => signal
			if signal.message == SERVER_TERMINATION_SIGNAL
				@done = true
			else
				raise
			end
		end
	end
end

def quit_main
	@done = true
end

def reset_signal_handlers
	Signal.list_trappable.each_key do |signal|
		begin
			@orig_signal_handlers[signal] = trap(signal, 'DEFAULT')
		rescue ArgumentError
			# Signal cannot be trapped; ignore it.
		end
	end
	@signal_handlers.each_pair do |signal, handler|
		trap(signal) do
			__send__(handler)
		end
	end
	trap('HUP', 'IGNORE')
end

def revert_signal_handlers
	@orig_signal_handlers.each_pair do |signal, handler|
		trap(signal, handler)
	end
	@orig_signal_handlers.clear
end

def server
	if !started?
		raise ServerNotStarted, "Server hasn't been started yet. Please call start() first."
	end
	return @parent_channel
end

def server_pid
	return @pid
end

def start
	if started?
		raise ServerAlreadyStarted, "Server is already started"
	end

	@parent_socket, @child_socket = UNIXSocket.pair
	before_fork
	@pid = fork
	if @pid.nil?
		begin
			STDOUT.sync = true
			STDERR.sync = true
			@parent_socket.close
			
			# During Passenger's early days, we used to close file descriptors based
			# on a white list of file descriptors. That proved to be way too fragile:
			# too many file descriptors are being left open even though they shouldn't
			# be. So now we close file descriptors based on a black list.
			file_descriptors_to_leave_open = [0, 1, 2, @child_socket.fileno]
			NativeSupport.close_all_file_descriptors(file_descriptors_to_leave_open)
			# In addition to closing the file descriptors, one must also close
			# the associated IO objects. This is to prevent IO.close from
			# double-closing already closed file descriptors.
			close_all_io_objects_for_fds(file_descriptors_to_leave_open)
			
			# At this point, RubyGems might have open file handles for which
			# the associated file descriptors have just been closed. This can
			# result in mysterious 'EBADFD' errors. So we force RubyGems to
			# clear all open file handles.
			Gem.clear_paths
			
			start_synchronously(@child_socket)
		rescue Interrupt
			# Do nothing.
		rescue SignalException => signal
			if signal.message == SERVER_TERMINATION_SIGNAL
				# Do nothing.
			else
				print_exception(self.class.to_s, signal)
			end
		rescue Exception => e
			print_exception(self.class.to_s, e)
		ensure
			exit!
		end
	end
	@child_socket.close
	@parent_channel = MessageChannel.new(@parent_socket)
end

def start_synchronously(socket)
	@child_socket = socket
	@child_channel = MessageChannel.new(socket)
	begin
		reset_signal_handlers
		initialize_server
		begin
			main_loop
		ensure
			finalize_server
		end
	ensure
		revert_signal_handlers
	end
end

def started?
	return !@parent_channel.nil?
end

def stop
	if !started?
		raise ServerNotStarted, "Server is not started"
	end
	
	@parent_socket.close
	@parent_channel = nil
	
	# Wait at most 3 seconds for server to exit. If it doesn't do that,
	# we kill it. If that doesn't work either, we kill it forcefully with
	# SIGKILL.
	begin
		Timeout::timeout(3) do
			Process.waitpid(@pid) rescue nil
		end
	rescue Timeout::Error
		Process.kill(SERVER_TERMINATION_SIGNAL, @pid) rescue nil
		begin
			Timeout::timeout(3) do
				Process.waitpid(@pid) rescue nil
			end
		rescue Timeout::Error
			Process.kill('SIGKILL', @pid) rescue nil
			Process.waitpid(@pid, Process::WNOHANG) rescue nil
		end
	end
end