tserver 0.2.0

data/CHANGELOG

@@ -0,0 +1,21 @@
+= SVN
+
+= 0.2.0
+
+* Server.process do not have argument now
+* TServer.connection, TServer.connection_addr and TServer.terminate_listener? is available.
+* Reload method (terminate all exists listerners and spawn new without interupt service and established connection)
+* TServer.connections work when a listener don't have active connection
+* Testing server Logger output in './test.log'
+* Plurialize methods: Tserver.listeners, TServer.waiting_listeners
+* Add 'server' task to Rakefile: run 'test/exemple_server.rb'
+* Add multiple callback to log event, can be overrited
+* Use Logger for logging implementation
+
+= 0.1.1
+
+* Tests pass with 'win32' platform
+
+= 0.1.0
+
+* First release

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2007 Yann Lugrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,51 @@
+= TServer
+
+Author::        Yann Lugrin (mailto:yann.lugrin@sans-savoir.net)
+Copyright:: 		Copyright (c) 2007 Yann Lugrin
+Licence::       MIT[link://files/LICENSE.html]
+Version::				0.2.0
+
+This librarie implements a persistant multithread TCP server, it is alternative
+to 'gserver'[http://ruby-doc.org/stdlib/libdoc/gserver/rdoc/index.html] standard
+librarie. TServer is designed to be inherited by your custom server class. The
+server can accepts multiple simultaneous connections from clients, can be
+configured to have a maximum connection and a minimum permanent listener thread.
+Can be imediatly stopped, gracefull shutdown (dont accept new connection but
+wait established connection is closed before realy stop) or reloaded (terminate
+listener after established connection is closed and respawn new).
+
+== Example
+
+This example can receive simple string from telnet connection
+
+  require 'tserver'
+
+  # A server can return
+  class ExampleServer < TServer
+    def process
+      connection.each do |line|
+        break if line =~ /(quit|exit|close)/
+
+        log '> ' + line.chomp
+        conn.puts Time.now.to_s + '> ' + line.chomp
+      end
+    end
+  end
+
+  # Create the server with logging enabled (server activity is displayed
+  # in console with received data)
+  server = ExampleServer.new
+  server.verbose = true
+
+  # Shutdown the server when script is interupted
+  Signal.trap('SIGINT') do
+    server.shutdown
+  end
+
+  # Start the server (joined is set to true and the line wait on server
+  # thread before continue, the default values of this parameter is set to
+  # false, you can also use 'server.join' after server.start)
+  server.start(true)
+
+  # Now you can open a telnet connection to 127.0.0.1:10001 (telnet 127.0.0.1 10001)
+  # and send text (use exit to close the connection)

data/lib/tserver.rb

@@ -0,0 +1,373 @@
+#--
+# The MIT License
+#
+# Copyright (c) 2007 Yann Lugrin
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#++
+
+require 'socket'
+require 'thread'
+require 'thwait'
+require 'monitor'
+require 'logger'
+
+# Show README[link://files/README.html] for implementation example.
+class TServer
+
+	# Server port (default: 10001).
+	attr_reader :port
+
+	# Server host (default: 127.0.0.1).
+	attr_reader :host
+
+	# Maximum simultaneous connection can be established with server (default: 4, minimum: 1).
+	attr_reader :max_connection
+
+	# Minimum listener permanently spawned (default: 1, minimum: 0).
+	attr_reader :min_listener
+
+	# Server logger instance (default level: Logger:WARN, default output: stderr).
+	attr_reader :logger
+
+	DEFAULT_OPTIONS = {
+		:port => 10001,
+		:host => '127.0.0.1',
+		:max_connection => 4,
+		:min_listener => 1,
+		:log_level => Logger::WARN,
+		:stdlog => $stderr }
+
+	# Initialize a new server (use start to run the server).
+	#
+	# Options are:
+	# * <tt>:port</tt>  - Port which the server listen on (default: 10001).
+	# * <tt>:host</tt>  - IP which the server listen on (default: 127.0.0.1).
+	# * <tt>:max_connection</tt>  - Maximum number of simultaneous connection to server (default: 4, minimum: 1).
+	# * <tt>:min_listener</tt>  - Minimum number of listener thread (default: 1, minimum: 0).
+	# * <tt>:log_level</tt>  - Use Logger constants DEBUG, INFO, WARN, ERROR or FATAL to set log level (default: Logger:WARN).
+	# * <tt>:stdlog</tt>  - IO or filepath for log output (default: $stderr).
+	def initialize(options = {})
+		options = DEFAULT_OPTIONS.merge(options)
+
+		@port = options[:port]
+		@host = options[:host]
+
+		@max_connection = options[:max_connection] < 1 ? 1 : options[:max_connection]
+		@min_listener = options[:min_listener] < 0 ? 0 : (options[:min_listener] > @max_connection ? @max_connection : options[:min_listener])
+
+		@logger = Logger.new(options[:stdlog])
+		@logger.level = options[:log_level]
+
+		@tcp_server = nil
+		@tcp_server_thread = nil
+		@connections = Queue.new
+
+		@listener_threads = []
+		@listener_threads.extend(MonitorMixin)
+		@listener_cond = @listener_threads.new_cond
+
+		@shutdown = false
+	end
+
+	# Start the server, if joined is set at true this method return only when
+	# the server is stopped (you can also use join method after start)
+	def start(joined = false)
+		@shutdown = false
+		@tcp_server = TCPServer.new(@host, @port)
+
+		@min_listener.times { spawn_listener }
+		Thread.pass while @connections.num_waiting < @min_listener
+
+		@tcp_server_thread = Thread.new do
+			begin
+				server_started
+
+				loop do
+					@listener_threads.synchronize do
+						if @connections.num_waiting == 0 && @listener_threads.size >= @max_connection
+							server_waiting_listener
+							@listener_cond.wait
+						end
+					end
+
+					server_waiting_connection
+					@connections << @tcp_server.accept rescue Thread.exit
+					spawn_listener if !@connections.empty? && @connections.num_waiting == 0
+				end
+			ensure
+				@tcp_server = nil
+				@tcp_server_thread = nil
+
+				server_stopped
+			end
+		end
+
+		join if joined
+		true
+	end
+
+	# Join the main thread of the server and return only when the server is stopped.
+	def join
+		@tcp_server_thread.join if @tcp_server_thread
+	end
+
+	# Stop imediatly the server (all established connection is interrupted).
+	def stop
+		@tcp_server.close rescue nil
+		@listener_threads.synchronize { @listener_threads.each {|l| l.exit} }
+		@tcp_server_thread.exit rescue nil
+
+		true
+	end
+
+	# Gracefull shutdown, the server can't accept new connection but wait current
+	# connection before exit.
+	def shutdown
+		return if stopped?
+		server_shutdown
+
+		@tcp_server.close rescue nil
+		Thread.pass until @connections.empty?
+
+		@listener_threads.synchronize  do
+			@listener_threads.each do |listener|
+				listener[:terminate] = true
+				@connections << false
+			end
+		end
+
+		ThreadsWait.all_waits(*@listener_threads)
+		@tcp_server_thread.exit rescue nil
+		@tcp_server_thread = nil
+
+		true
+	end
+
+	# Reload the server
+	# * Spawn new listeners.
+	# * Terminate existing listeners when current connection is closed.
+	def reload
+		return if stopped?
+
+		listeners_to_exit = nil
+		@listener_threads.synchronize do
+			listeners_to_exit = @listener_threads.dup
+			@listener_threads.clear
+		end
+
+		listeners_to_exit.each do |listener|
+			listener[:connection].nil? ? listener.terminate : listener[:terminate] = true
+		end
+
+		@listener_threads.synchronize do
+			spawn_listener while @listener_threads.size < @min_listener
+		end
+
+		true
+	end
+
+	# Return the number of spawned listener.
+	def listeners
+		@listener_threads.synchronize { @listener_threads.size }
+	end
+
+	# Return the number of spawned listener waiting on new connection.
+	def waiting_listeners
+		@connections.num_waiting
+	end
+
+	# Returns an array of arrays, where each subarray contains:
+	# * address family: A string like "AF_INET" or "AF_INET6" if it is one of the commonly used families, the string "unknown:#" (where '#' is the address family number) if it is not one of the common ones. The strings map to the Socket::AF_* constants.
+	# * port: The port number.
+	# * name: Either the canonical name from looking the address up in the DNS, or the address in presentation format.
+	# * address: The address in presentation format (a dotted decimal string for IPv4, a hex string for IPv6).
+	def connections
+		@listener_threads.synchronize { @listener_threads.collect{|l| l[:connection].nil? ? nil : l[:connection].peeraddr } }.compact
+	end
+
+	# Return true if server running.
+	def started?
+		@listener_threads.synchronize { !@tcp_server_thread.nil? || @listener_threads.size > 0 }
+	end
+
+	# Return true if server dont running.
+	def stopped?
+		!started?
+	end
+
+	protected
+
+		# Override this method to implement a server, conn is a TCPSocket instance and
+		# is closed when this method return. Attribute 'connection' is available.
+		#
+		# Example (send 'Hello world!' string to client):
+		#	def process
+		#		connection.puts 'Hello world!'
+		#	end
+		#
+		# For persistant connection, use loop and Timeout.timeout or Tserver.terminate_listener?
+		# to break (and terminate listener) when server shutdown or reload. If server stop,
+		# listener is killed but begin/ensure can be used to terminate current process.
+		def process
+		end
+
+		# Callback (call when server is started)
+		def server_started
+			@logger.info do
+				"server:#{Thread.current} [#{@host}:#{@port}] is started"
+			end
+		end
+
+		# Callback (call when server is stopped)
+		def server_stopped
+			@logger.info do
+				"server:#{Thread.current} [#{@host}:#{@port}] is stopped"
+			end
+		end
+
+		# Callback (call when server shutdown, before is stopped)
+		def server_shutdown
+			@logger.info do
+				"server:#{Thread.current} [#{@host}:#{@port}] shutdown"
+			end
+		end
+
+		# Callback (call when server wait new connection)
+		def server_waiting_connection
+			@logger.info do
+				"server:#{Thread.current} [#{@host}:#{@port}] wait on connection"
+			end
+		end
+
+		# Callback (call when server wait free listener, don't accept new connection)
+		def server_waiting_listener
+			@logger.info do
+				"server:#{Thread.current} [#{@host}:#{@port}] wait on listener"
+			end
+		end
+
+		# Callback (call when listener is spawned)
+		def listener_spawned
+			@logger.info do
+				"listener:#{Thread.current} is spawned by server:#{Thread.current} [#{@host}:#{@port}]"
+			end
+		end
+
+		# Callback (call when listener exit)
+		def listener_terminated
+			@logger.info do
+				"listener:#{Thread.current} is terminated"
+			end
+		end
+
+		# Callback (call when listener wait connection - free listener)
+		def listener_waiting_connection
+			@logger.info do
+				"listener:#{Thread.current} wait on connection from server:#{Thread.current} [#{@host}:#{@port}]"
+			end
+		end
+
+		# Callback (call when a connection is established with listener)
+		def connection_established
+			@logger.info do
+				"client:#{connection_addr[1]} #{connection_addr[2]}<#{connection_addr[3]}> is connected to listener:#{Thread.current}"
+			 end
+		end
+
+		# Callback (call when the connection with listener close normally)
+		def connection_normally_closed
+			@logger.info do
+				"client:#{connection_addr[1]} #{connection_addr[2]}<#{connection_addr[3]}> is disconnected from listener:#{Thread.current}"
+			 end
+		end
+
+		# Callback (call when the connection with listener do not close normally,
+		# reveive 'error' instance from rescue)
+		def connection_not_normally_closed(error)
+			@logger.warn do
+				"client:#{connection_addr[1]} #{connection_addr[2]}<#{connection_addr[3]}> make an error and is disconnected from listener:#{Thread.current}"
+			end
+
+			@logger.debug do
+				"#{error.class.to_s}: #{error.to_s}\n" +
+				error.backtrace.join("\n")
+			end
+		end
+
+	private
+
+		def spawn_listener #:nodoc:
+			listener_thread = Thread.new do
+				begin
+					listener_spawned
+					loop do
+						begin
+							listener_waiting_connection
+							self.connection = (@connections.empty? && (terminate_listener? || @connections.num_waiting >= @min_listener)) ? Thread.exit : @connections.pop
+
+							if connection.is_a?(TCPSocket)
+								connection_established
+								process
+								connection_normally_closed
+							else
+								Thread.exit
+							end
+						rescue => e
+							connection_not_normally_closed(e)
+						ensure
+							connection.close rescue nil
+							self.connection = nil
+						end
+
+						@listener_threads.synchronize { @listener_cond.signal }
+					end
+				ensure
+					@listener_threads.synchronize { @listener_threads.delete(Thread.current) }
+					listener_terminated
+				end
+			end
+
+			@listener_threads.synchronize { @listener_threads << listener_thread }
+		end
+
+		# Set connection for current Thread
+		def connection=(conn) #:nodoc:
+			Thread.current[:connection] = conn
+		end
+
+		# Return connection of current listener thread (or nil)
+		def connection
+			Thread.current[:connection]
+		end
+
+		# Return array with information for current thread connection:
+		# * address family: A string like "AF_INET" or "AF_INET6" if it is one of the commonly used families, the string "unknown:#" (where '#' is the address family number) if it is not one of the common ones. The strings map to the Socket::AF_* constants.
+		# * port: The port number.
+		# * name: Either the canonical name from looking the address up in the DNS, or the address in presentation format.
+		# * address: The address in presentation format (a dotted decimal string for IPv4, a hex string for IPv6).
+		def connection_addr
+			Thread.current[:connection_addr] ||= (Thread.current[:connection].nil? ? [nil] * 4 : Thread.current[:connection].peeraddr)
+		end
+
+		# Return true if server ask listener to exit (when shutdown or reload)
+		def terminate_listener?
+			Thread.current[:terminate] == true
+		end
+end

data/test/example_server.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/tserver')
+
+# Example server, lauch this script and open a telnet to communicate
+# with the server. The server print logging information and received data
+# in console. The client receive a copy of sending data.
+#
+# Syntax example :
+# ruby example_server.rb
+# ruby example_server.rb 127.0.0.1 10001
+# ruby example_server.rb 127.0.0.1
+# ruby example_server.rb 10001
+# ruby example_server.rb 10001 127.0.0.1
+#
+# Default values :
+host = '127.0.0.1'
+port = 10001
+
+ARGV.each do |argv|
+	if argv =~ /^\d+$/
+		port = argv.to_i
+	elsif argv =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/
+		host = argv
+	end
+end
+
+# ExampleServer return string received from client.
+# Send quit, exit or close to close connection or
+# stop to kill server.
+class ExampleServer < TServer
+	def process
+		connection.each do |line|
+			stop if line =~ /stop/
+			break if line =~ /(quit|exit|close)/
+
+			puts '> ' + line.chomp
+			connection.puts Time.now.to_s + ' > ' + line.chomp
+		end
+	end
+end
+
+# Start server
+server = ExampleServer.new(:port => port, :host => host)
+server.logger.level = Logger::DEBUG
+
+Signal.trap('SIGINT') do
+	server.shutdown
+end
+
+server.start
+
+sleep 0.5 while server.started?

data/test/tserver_test.rb

@@ -0,0 +1,412 @@
+require 'test/unit'
+require 'timeout'
+require 'thread'
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/tserver')
+
+TEST_LOG = 'test.log'
+SERVER_READER = Queue.new
+
+# The test server can send received data to an IO
+class TestServer < TServer
+	def initialize(options= {})
+		super(options)
+	end
+
+	protected
+
+		# Send received data on IO and return the data to client
+		def process
+			loop do
+				SERVER_READER << string = connection.readline.chomp
+				connection.puts string
+			end
+		end
+end
+
+# The test client can send and receive data to a server
+class TestClient
+	def initialize(host, port)
+		@host = host
+		@port = port
+
+		@socket = nil
+	end
+
+	def connect
+		@socket = TCPSocket.new(@host, @port)
+		Thread.pass
+	end
+
+	def close
+		@socket.close if @socket
+		Thread.pass
+	end
+
+	def send(string)
+		@socket.puts string
+		Thread.pass
+	end
+
+	def receive
+		@socket.readline.chomp
+	end
+end
+
+class TServerTest < Test::Unit::TestCase
+	def setup
+		SERVER_READER.clear
+
+		@server = TestServer.new(:log_level => Logger::DEBUG, :stdlog => TEST_LOG)
+		@client = TestClient.new(@server.host, @server.port)
+	end
+
+	def teardown
+		@client.close rescue nil
+
+		@server.stop rescue nil
+		@server.join rescue nil # join the server to ensure is stopped before start the next test
+	end
+
+	def test_should_can_create_with_default_values
+		server = TServer.new
+
+		assert_equal 10001, server.port
+		assert_equal '127.0.0.1', server.host
+
+		assert_equal 4, server.max_connection
+		assert_equal 1, server.min_listener
+
+		assert_kind_of Logger, server.logger
+		assert_equal Logger::WARN, server.logger.level
+	end
+
+	def test_should_can_create_with_custom_values
+		# Set all options
+		server = TServer.new(:port => 10002, :host => '192.168.1.1', :max_connection => 10, :min_listener => 2, :log_level => Logger::DEBUG)
+
+		assert_equal 10002, server.port
+		assert_equal '192.168.1.1', server.host
+
+		assert_equal 10, server.max_connection
+		assert_equal 2, server.min_listener
+
+		assert_kind_of Logger, server.logger
+		assert_equal Logger::DEBUG, server.logger.level
+	end
+
+	def test_should_dont_have_more_min_listener_that_of_max_connection
+		server = TServer.new(:max_connection => 5, :min_listener => 6)
+
+		assert_equal 5, server.max_connection
+		assert_equal 5, server.min_listener
+	end
+
+	def test_should_dont_have_minimum_max_connection_and_min_listener
+		server = TServer.new(:max_connection => 0, :min_listener => -1)
+
+		assert_equal 1, server.max_connection
+		assert_equal 0, server.min_listener
+	end
+
+	def test_should_be_started
+		# Start a server
+		assert_not_timeout('Server do not start') { @server.start }
+		assert @server.started?
+		assert !@server.stopped?
+
+		# Listener is spawned
+		assert_equal @server.min_listener, @server.listeners
+		assert_equal @server.min_listener, @server.waiting_listeners
+	end
+
+	def test_should_be_stopped
+		# Stop a non started server
+		assert_not_timeout('Server do not stop') { @server.stop }
+
+		# Start the server
+		assert_not_timeout('Server do not start') { @server.start }
+
+		# Stop the server
+		assert_not_timeout('Server do not stop'){ @server.stop }
+
+		# The server is stopped and dont accept connection
+		assert !@server.started?
+		assert @server.stopped?
+		assert_raise(RUBY_PLATFORM =~ /win32/ ? Errno::EBADF : Errno::ECONNREFUSED) do
+			@client.connect
+		end
+	end
+
+	def test_should_be_stopped_with_established_connection
+		# Start the server and a client
+		assert_not_timeout('Server do not start') { @server.start }
+		assert_not_timeout('Client do not connect') { @client.connect }
+
+		# Shutdown the server
+		assert_not_timeout('Server do not stop') { @server.stop }
+
+		# The server is stopped and dont accept connection
+		assert !@server.started?
+		assert @server.stopped?
+		assert_raise(RUBY_PLATFORM =~ /win32/ ? Errno::EBADF : Errno::ECONNREFUSED) do
+			@client.connect
+		end
+	end
+
+	def test_should_be_shutdown
+		# Shutdown a non started server
+		assert_not_timeout('Server do not shutdown') { @server.shutdown }
+
+		# Start the server
+		assert_not_timeout('Server do not start') { @server.start }
+
+		# Shutdown the server
+		assert_not_timeout('Server do not shutdown') { @server.shutdown }
+
+		# The server is stopped and dont accept connection
+		assert !@server.started?
+		assert @server.stopped?
+		assert_raise(RUBY_PLATFORM =~ /win32/ ? Errno::EBADF : Errno::ECONNREFUSED) do
+			@client.connect
+		end
+
+		# Shutdown a shutdowned server
+		assert_not_timeout('Server do not shutdown') { @server.shutdown }
+	end
+
+	def test_should_be_shutdown_with_established_connection
+		# Start server and client
+		assert_not_timeout('Server do not start') { @server.start }
+		assert_not_timeout('Client do not connect') { @client.connect }
+
+		# Shutdown the server
+		shutdown_thread = nil
+		shutdown_thread = Thread.new do
+			assert_not_timeout('Server do not shutdown') { @server.shutdown }
+		end
+
+		# The server isn't stopped because a connection is established
+		assert @server.started?
+		assert !@server.stopped?
+
+		# The client can communicate with server
+		assert_not_timeout 'Client do not communicate with server' do
+			@client.send 'test string'
+			assert_equal 'test string', SERVER_READER.pop.chomp
+			assert_equal 'test string', @client.receive
+		end
+
+		# Close client
+		assert_not_timeout('Client do not close connection') { @client.close }
+		wait_listeners
+
+		# Wait server shutdown
+		assert_not_timeout('Server do not shutdown') { shutdown_thread.join }
+
+		# The server is stopped and dont accept connection
+		assert !@server.started?
+		assert @server.stopped?
+		assert_raise(RUBY_PLATFORM =~ /win32/ ? Errno::EBADF : Errno::ECONNREFUSED) do
+			@client.connect
+		end
+	end
+
+	def test_should_be_reload
+		# Reload a non started server
+		assert_not_timeout('Server do not reload') { @server.reload }
+
+		# Do not spawn listeners!
+		assert_equal 0, @server.instance_variable_get(:@listener_threads).size
+
+		# Start the server
+		assert_not_timeout('Server do not start') { @server.start }
+
+		# The server is started and accept connection
+		assert_not_timeout('Client do not connect') { @client.connect }
+
+		# Copy list of current listeners
+  	listeners_to_exit = @server.instance_variable_get(:@listener_threads).dup
+
+		# Reload the server
+		assert_not_timeout('Server do not reload') { @server.reload }
+
+		# Old listener is not terminated (connection with a client is established)
+		wait_listeners 2
+		assert_not_equal listeners_to_exit.first, @server.instance_variable_get(:@listener_threads).first
+		assert_not_equal, listeners_to_exit.first[:conn] = @server.instance_variable_get(:@listener_threads).first[:conn]
+
+		# The client can communicate with server
+		assert_not_timeout 'Client do not communicate with server' do
+			@client.send 'test string'
+			assert_equal 'test string', SERVER_READER.pop.chomp
+			assert_equal 'test string', @client.receive
+		end
+
+		# Close client
+		assert_not_timeout('Client do not close connection') { @client.close }
+
+		# Old listeners exit
+    ThreadsWait.all_waits(*listeners_to_exit)
+
+		# The server is started and accept connection
+		assert_not_timeout('Client do not connect') { @client.connect }
+
+		# The client can communicate with server
+		assert_not_timeout 'Client do not communicate with server' do
+			@client.send 'test string'
+			assert_equal 'test string', SERVER_READER.pop.chomp
+			assert_equal 'test string', @client.receive
+		end
+	end
+
+	def test_should_be_receive_connection
+		# Start server and client
+		assert_not_timeout('Server do not start') { @server.start }
+		assert_not_timeout('Client do not connect') { @client.connect }
+
+		# Client can communicate with the server
+		assert_not_timeout 'Client do not communicate with server' do
+			@client.send 'test string'
+			assert_equal 'test string', SERVER_READER.pop.chomp
+			assert_equal 'test string', @client.receive
+		end
+	end
+
+	def test_should_be_receive_multiple_connection
+		# Create multiple clients
+		@client_2 = TestClient.new(@server.host, @server.port)
+		@client_3 = TestClient.new(@server.host, @server.port)
+		@client_4 = TestClient.new(@server.host, @server.port)
+		@client_5 = TestClient.new(@server.host, @server.port)
+
+		# Start server and clients
+		assert_not_timeout('Server do not start') { @server.start }
+		assert_not_timeout('Client do not connect') { @client.connect }
+		assert_not_timeout('Client do not connect') { @client_2.connect }
+		assert_not_timeout('Client do not connect') { @client_3.connect }
+		assert_not_timeout('Client do not connect') { @client_4.connect }
+		assert_not_timeout('Client do not connect') { @client_5.connect }
+		wait_listeners(4)
+
+		# Only 4 listerner for 5 client
+		assert_equal 0, @server.waiting_listeners
+		assert_equal 4, @server.listeners
+
+		# All clients send data to server
+		assert_not_timeout('Client do not communicate with server') { @client.send 'test string 1' }
+		assert_not_timeout('Client do not communicate with server') { @client_2.send 'test string 2' }
+		assert_not_timeout('Client do not communicate with server') { @client_3.send 'test string 3' }
+		assert_not_timeout('Client do not communicate with server') { @client_4.send 'test string 4' }
+		assert_not_timeout('Client do not communicate with server') { @client_5.send 'test string 5' }
+
+		# Server receive data from 4 clients (but the last client waiting)
+		1.upto(4) do |i|
+			assert_not_timeout 'Do not receive data from client' do
+				assert_match(/test string [1-4]/, SERVER_READER.pop)
+			end
+		end
+		assert SERVER_READER.empty?, 'Server receive data from client 5'
+
+		# Close client
+		assert_not_timeout('Client do not close connection') { @client.close }
+
+		# Server can recerive data from last client
+		assert_not_timeout 'Do not receive data from client' do
+			assert_equal 'test string 5', SERVER_READER.pop
+		end
+
+		# Close all clients [<client>, <number of listener after close>]
+		[@client_2, @client_3, @client_4, @client_5].each do |client|
+			assert_not_timeout('Client do not close connection') { client.close }
+		end
+		wait_listeners
+
+		# min_listener waiting connection
+		assert_equal @server.min_listener, @server.listeners
+		assert_equal @server.min_listener, @server.waiting_listeners
+	end
+
+	def test_should_be_receive_connection_with_log_level_to_debug
+		@server.logger.level = Logger::DEBUG
+
+		# Start server and client
+		assert_not_timeout('Server do not start') { @server.start }
+		assert_not_timeout('Client do not connect') { @client.connect }
+
+		# Client can communicate with the server
+		assert_not_timeout 'Client do not communicate with server' do
+			@client.send 'test string'
+			assert_equal 'test string', SERVER_READER.pop.chomp
+			assert_equal 'test string', @client.receive
+		end
+	end
+
+	def test_should_works_with_min_listener_at_0
+		@server = TestServer.new(:min_listener => 0, :stdlog => TEST_LOG)
+		assert_equal 0, @server.min_listener
+
+		# Start server and client
+		assert_not_timeout('Server do not start') { @server.start }
+		assert_not_timeout('Client do not connect') { @client.connect }
+
+		# Client can communicate with the server
+		assert_not_timeout 'Client do not communicate with server' do
+			@client.send 'test string'
+			assert_equal 'test string', SERVER_READER.pop.chomp
+			assert_equal 'test string', @client.receive
+		end
+
+		# Close client
+		assert_not_timeout('Client do not close connection') { @client.close }
+		wait_listeners
+
+		# min_listener
+		assert_equal @server.min_listener, @server.listeners
+		assert_equal @server.min_listener, @server.waiting_listeners
+	end
+
+	def test_should_have_connection_list
+		# Start server
+		assert_not_timeout('Server do not start') { @server.start }
+
+		# Zero connection
+		assert_equal @server.min_listener, @server.listeners
+		assert_equal @server.min_listener, @server.waiting_listeners
+		assert_equal [], @server.connections
+
+		# Start client
+		assert_not_timeout('Client do not connect') { @client.connect }
+		wait_connection
+
+		# Connection information
+		assert_equal 1, @server.connections.size
+		assert_equal 'AF_INET', @server.connections.first[0]
+		assert_match(/^\d+$/, @server.connections.first[1].to_s)
+		assert_match(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, @server.connections.first[3])
+	end
+
+	protected
+
+		def assert_not_timeout(msg = 'Timeout')
+			assert_nothing_raised(msg) do
+				Timeout.timeout(5) do
+					yield
+				end
+			end
+		end
+
+		# Wait listener spawn
+		def wait_listeners(number = @server.min_listener)
+			assert_not_timeout 'Listener do not exit' do
+				sleep 0.1 until @server.listeners == number
+			end
+		end
+
+		# Wait connection established with listener
+		def wait_connection(number = @server.listeners)
+			assert_not_timeout 'Listener do not exit' do
+				sleep 0.1 until @server.connections.size == number
+			end
+		end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: tserver
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+date: 2007-10-11 00:00:00 +02:00
+summary: A persistant multithread TCP server
+require_paths: 
+- lib
+email: yann.lugrin@sans-savoir.net
+homepage: http://dev.sans-savoir.net/trac/tserver
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Yann Lugrin
+files: 
+- lib/tserver.rb
+- test/example_server.rb
+- test/tserver_test.rb
+- README
+- CHANGELOG
+- LICENSE
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+