class TCPServer

Overview

A Transmission Control Protocol (TCP/IP) server.

Usage example:

server = TCPServer.new("localhost", 1234)
loop do
  server.accept do |client|
    message = client.gets
    server << message # echo the message back
  end
end

Defined in:

socket/tcp_server.cr

Class Method Summary

Instance Method Summary

Instance methods inherited from class TCPSocket

tcp_keepalive_count tcp_keepalive_count, tcp_keepalive_count=(val : Int) tcp_keepalive_count=, tcp_keepalive_idle tcp_keepalive_idle, tcp_keepalive_idle=(val : Int) tcp_keepalive_idle=, tcp_keepalive_interval tcp_keepalive_interval, tcp_keepalive_interval=(val : Int) tcp_keepalive_interval=, tcp_nodelay=(val : Bool) tcp_nodelay=, tcp_nodelay? tcp_nodelay?

Class methods inherited from class TCPSocket

new(host, port, dns_timeout = nil, connect_timeout = nil)
new(fd : Int32)
new
, open(host, port, &block) open

Instance methods inherited from class IPSocket

local_address local_address, remote_address remote_address

Instance methods inherited from class Socket

broadcast=(val : Bool) broadcast=, broadcast? broadcast?, close_read close_read, close_write close_write, getsockopt(optname, optval, level = LibC::SOL_SOCKET) getsockopt, inspect(io) inspect, keepalive=(val : Bool) keepalive=, keepalive? keepalive?, linger linger, linger=(val : Int | Nil) linger=, recv_buffer_size recv_buffer_size, recv_buffer_size=(val : Int32) recv_buffer_size=, reuse_address=(val : Bool) reuse_address=, reuse_address? reuse_address?, send_buffer_size send_buffer_size, send_buffer_size=(val : Int32) send_buffer_size=, setsockopt(optname, optval, level = LibC::SOL_SOCKET) setsockopt

Class methods inherited from class Socket

ip?(string : String) ip?, new(fd, blocking = false) new

Instance methods inherited from class IO::FileDescriptor

blocking blocking, blocking=(value) blocking=, close_on_exec=(arg : Bool) close_on_exec=, close_on_exec? close_on_exec?, closed? : Bool closed?, cooked(&block) cooked, cooked! cooked!, fcntl(cmd, arg = 0) fcntl, fd : Int32 fd, finalize finalize, inspect(io) inspect, noecho(&block) noecho, noecho! noecho!, pos pos, pos=(value) pos=, raw(&block) raw, raw! raw!, read_timeout=(read_timeout : Time::Span)
read_timeout=(read_timeout : Nil)
read_timeout=(read_timeout : Number)
read_timeout=
, reopen(other : IO::FileDescriptor) reopen, seek(offset, whence : Seek = Seek::Set, &block)
seek(offset, whence : Seek = Seek::Set)
seek
, stat stat, tell tell, tty? tty?, write_timed_out : Bool write_timed_out, write_timed_out=(write_timed_out : Bool) write_timed_out=, write_timeout=(write_timeout : Time::Span)
write_timeout=(write_timeout : Nil)
write_timeout=(write_timeout : Number)
write_timeout=

Class methods inherited from class IO::FileDescriptor

fcntl(fd, cmd, arg = 0) fcntl, new(fd : Int32, blocking = false, edge_triggerable = false) new

Instance methods inherited from module IO::Buffered

close close, flush flush, flush_on_newline=(flush_on_newline) flush_on_newline=, flush_on_newline? flush_on_newline?, read(slice : Slice(UInt8)) read, rewind rewind, sync=(sync) sync=, sync? sync?, unbuffered_close unbuffered_close, unbuffered_flush unbuffered_flush, unbuffered_read(slice : Slice(UInt8)) unbuffered_read, unbuffered_rewind unbuffered_rewind, unbuffered_write(slice : Slice(UInt8)) unbuffered_write, write(slice : Slice(UInt8)) write

Instance methods inherited from module IO

<<(obj) : self <<, close close, closed? closed?, each_byte
each_byte(&block)
each_byte
, each_char(&block)
each_char
each_char
, each_line(*args, **options, &block)
each_line(*args, **options)
each_line
, encoding : String encoding, flush flush, gets : String | Nil
gets(delimiter : String) : String | Nil
gets(delimiter : Char) : String | Nil
gets(limit : Int) : String | Nil
gets(delimiter : Char, limit : Int) : String | Nil
gets
, gets_to_end : String gets_to_end, print(obj) : Nil
print(*objects : _) : Nil
print
, printf(format_string, *args) : Nil
printf(format_string, args : Array | Tuple) : Nil
printf
, puts(*objects : _) : Nil
puts(string : String) : Nil
puts(obj) : Nil
puts : Nil
puts
, read(slice : Slice(UInt8)) read, read_byte : UInt8 | Nil read_byte, read_bytes(type, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) read_bytes, read_char : Char | Nil read_char, read_fully(slice : Slice(UInt8)) read_fully, read_line(*args, **options) : String | Nil read_line, read_utf8(slice : Slice(UInt8)) read_utf8, read_utf8_byte read_utf8_byte, rewind rewind, set_encoding(encoding : String, invalid : Symbol | Nil = nil) set_encoding, skip(bytes_count : Int) : Nil skip, tty? : Bool tty?, write(slice : Slice(UInt8)) : Nil write, write_byte(byte : UInt8) write_byte, write_bytes(object, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) write_bytes, write_utf8(slice : Slice(UInt8)) write_utf8

Class methods inherited from module IO

copy(src, dst, limit : Int)
copy(src, dst)
copy
, pipe(read_blocking = false, write_blocking = false)
pipe(read_blocking = false, write_blocking = false, &block)
pipe
, select(read_ios, write_ios, error_ios, timeout_sec : LibC::TimeT | Int | Float | Nil)
select(read_ios, write_ios = nil, error_ios = nil)
select

Instance methods inherited from module JSON::Builder

json_array(&block) json_array, json_object(&block) json_object

Instance methods inherited from class Reference

==(other : self)
==(other)
==
, dup dup, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, same?(other : Reference)
same?(other : Nil)
same?
, to_s(io : IO) : Nil to_s

Class methods inherited from class Reference

new new

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other)
===
, =~(other) =~, class class, crystal_type_id crystal_type_id, dup dup, hash hash, inspect(io : IO)
inspect
inspect
, itself itself, not_nil! not_nil!, tap(&block) tap, to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ")
to_pretty_json
, to_s
to_s(io : IO)
to_s
, to_yaml(io : IO)
to_yaml
to_yaml
, try(&block) try

Class methods inherited from class Object

==(other : Class) ==, ===(other) ===, cast(other) : self cast, clone clone, dup dup, from_json(string_or_io, root : String) : self
from_json(string_or_io) : self
from_json
, from_yaml(string : String) : self from_yaml, hash hash, inspect(io) inspect, name : String name, nilable? nilable?, to_s(io) to_s, |(other : U.class) forall U |

Class Method Detail

def self.new(port : Int, backlog = 128) #

Creates a new TCP server, listening on all local interfaces (::).


[View source]
def self.new(host, port, backlog = 128) #

[View source]
def self.open(port : Int, backlog = 128, &block) #

Creates a new TCP server, listening on all interfaces, and yields it to the block. Eventually closes the server socket when the block returns.

Returns the value of the block.


[View source]
def self.open(host, port, backlog = 128, &block) #

Creates a new TCP server and yields it to the block. Eventually closes the server socket when the block returns.

Returns the value of the block.


[View source]

Instance Method Detail

def accept(&block) #

Accepts an incoming connection and yields the client socket to the block. Eventually closes the connection when the block returns.

Returns the value of the block. If the server is closed after invoking this method, an IO::Error (closed stream) exception will be raised.

require "socket"

server = TCPServer.new(2202)
server.accept do |socket|
  socket.puts Time.now
end

[View source]
def accept : TCPSocket #

Accepts an incoming connection.

Returns the client socket. Raises an IO::Error (closed stream) exception if the server is closed after invoking this method.

require "socket"

server = TCPServer.new(2202)
socket = server.accept
socket.puts Time.now
socket.close

[View source]
def accept?(&block) #

Accepts an incoming connection and yields the client socket to the block. Eventualy closes the connection when the block returns.

Returns the value of the block or nil if the server is closed after invoking this method.

require "socket"

server = TCPServer.new(2202)
server.accept? do |socket|
  socket.puts Time.now
end

[View source]
def accept? : TCPSocket | Nil #

Accepts an incoming connection.

Returns the client socket or nil if the server is closed after invoking this method.

require "socket"

server = TCPServer.new(2202)
loop do
  if socket = server.accept?
    # handle the client in a fiber
    spawn handle_connection(socket)
  else
    # another fiber closed the server
    break
  end
end

[View source]