class TCPServer

Overview

A Transmission Control Protocol (TCP/IP) server.

Usage example:

require "socket"

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

Included Modules

Defined in:

Class Method Summary

Instance Method Summary

Instance methods inherited from module Socket::Server

accept(&block) accept, accept?(&block) accept?

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(fd : Int32, family : Family, type : Type, protocol : Protocol)
new(family : Family, type : Type, protocol : Protocol)
new(host, port, dns_timeout = nil, connect_timeout = nil)
new(family : Family = Family::INET)
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

accept accept, accept? accept?, bind(host : String, port : Int)
bind(port : Int)
bind(addr)
bind(addr, &block)
bind
, broadcast=(val : Bool) broadcast=, broadcast? broadcast?, close_read close_read, close_write close_write, connect(host : String, port : Int, connect_timeout = nil)
connect(addr, timeout = nil) : Nil
connect(addr, timeout = nil, &block)
connect
, family : Family family, getsockopt(optname, optval, level = LibC::SOL_SOCKET) getsockopt, inspect(io) inspect, keepalive=(val : Bool) keepalive=, keepalive? keepalive?, linger linger, linger=(val : Int?) linger=, listen(backlog = SOMAXCONN)
listen(backlog = SOMAXCONN, &block)
listen
, protocol : Protocol protocol, receive(max_message_size = 512) : Tuple(String, Address)
receive(message : Bytes) : Tuple(Int32, Address)
receive
, recv_buffer_size recv_buffer_size, recv_buffer_size=(val : Int32) recv_buffer_size=, reuse_address=(val : Bool) reuse_address=, reuse_address? reuse_address?, reuse_port=(val : Bool) reuse_port=, reuse_port? reuse_port?, send(message)
send(message : Bytes)
send(message, to addr : Address)
send(message : Bytes, to addr : Address)
send
, send_buffer_size send_buffer_size, send_buffer_size=(val : Int32) send_buffer_size=, setsockopt(optname, optval, level = LibC::SOL_SOCKET) setsockopt, type : Type type

Class methods inherited from class Socket

ip?(string : String) ip?, new(fd : Int32, family, type, protocol = Protocol::IP)
new(family, type, protocol = Protocol::IP, blocking = false)
new
, tcp(family : Family, blocking = false) tcp, udp(family : Family, blocking = false) udp, unix(type : Type = Type::STREAM, blocking = false) unix

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=, pretty_print(pp) pretty_print, 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)
seek(offset, whence : Seek = Seek::Set, &block)
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 : Number)
write_timeout=(write_timeout : Time::Span)
write_timeout=(write_timeout : Nil)
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 : Bytes) read, rewind rewind, sync=(sync) sync=, sync? sync?, unbuffered_close unbuffered_close, unbuffered_flush unbuffered_flush, unbuffered_read(slice : Bytes) unbuffered_read, unbuffered_rewind unbuffered_rewind, unbuffered_write(slice : Bytes) unbuffered_write, write(slice : Bytes) write

Instance methods inherited from module IO

<<(obj) : self <<, close close, closed? closed?, each_byte
each_byte(&block) : Nil
each_byte
, each_char(&block) : Nil
each_char
each_char
, each_line(*args, **options, &block) : Nil
each_line(*args, **options)
each_line
, encoding : String encoding, flush flush, gets(chomp = true) : String?
gets(delimiter : String, chomp = false) : String?
gets(delimiter : Char, chomp = false) : String?
gets(delimiter : Char, limit : Int, chomp = false) : String?
gets(limit : Int, chomp = false) : String?
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 : Bytes) read, read_byte : UInt8? read_byte, read_bytes(type, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) read_bytes, read_char : Char? read_char, read_fully(slice : Bytes) read_fully, read_fully?(slice : Bytes) read_fully?, read_line(*args, **options) : String? read_line, read_string(bytesize : Int) : String read_string, read_utf8(slice : Bytes) read_utf8, read_utf8_byte read_utf8_byte, rewind rewind, set_encoding(encoding : String, invalid : Symbol? = nil) set_encoding, skip(bytes_count : Int) : Nil skip, skip_to_end : Nil skip_to_end, tty? : Bool tty?, write(slice : Bytes) : Nil write, write_byte(byte : UInt8) write_byte, write_bytes(object, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) write_bytes, write_utf8(slice : Bytes) 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?)
select(read_ios, write_ios = nil, error_ios = nil)
select

Instance methods inherited from class Reference

==(other : self)
==(other)
==
, dup dup, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, 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, dup dup, hash hash, inspect(io : IO)
inspect
inspect
, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
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

from_json(string_or_io, root : String) : self
from_json(string_or_io) : self
from_json
, from_yaml(string_or_io) : self from_yaml

Class Method Detail

def self.new(host : String, port : Int, backlog = SOMAXCONN, dns_timeout = nil) #

def self.new(family : Family = Family::INET) #

Creates a new TCPServer, waiting to be bound.


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

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


def self.open(port : Int, backlog = SOMAXCONN, &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.


def self.open(host, port, backlog = SOMAXCONN, &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.


Instance Method Detail

def accept? #

Accepts an incoming connection.

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

require "socket"

server = TCPServer.new(2022)
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