TCP chat app with ruby

NOTE: This article is intended for developers with a year or more experience with ruby

Link to source code on github

Slides on my talk Socket programming with ruby

To create our chat app we need to require socket which is a part of ruby's standard library.

Our chat app will need

• Server

This will be a TCPServer which will bind to a specific port, listen and accept connections on that port

• Client

This will be us connecting to a TCPServer and sending messages to it.

So, let's create a server first

require 'socket' class Server def initialize(port) @server = TCPServer.new(port) puts "Listening on port #{port}" end end 

TCPServer.new creates a tcp server that will bind to a port and listen on it.

It could have also be written as

require 'socket' socket = Socket.new(:INET, :STREAM) socket.bind(Socket.pack_sockaddr_in(3000, '127.0.0.1')) socket.listen(Socket::SOMAXCONN) 

Socket.new(:INET, :STREAM) takes two parameters where :INET means internet and :STREAM means the socket will be of type TCP. If we want to create a UDP socket, we could have passed :DGRAM.

Socket.pack_sockaddr_in(3000, '127.0.0.1') this method create a C struct that holds the port and ip.

socket.bind binds to that port

Socket::SOMAXCONN is a constant that gives how many connections the listen queue can accept. Listen queue is the total pending connection that a socket can tolerate.

socket.listen will listen for connection on the port.

As you can see, we could achieve all this in just one line with TCPServer.new. We, ruby programmers, love one-liners.

Now the server needs to accept connections

Socket.accept_loop() will pop a connection from the listen queue, process it and then exit.

Socket.accept_loop() can also be written as

# old code require 'socket' socket = Socket.new(:INET, :STREAM) socket.bind(Socket.pack_sockaddr_in(3000, '127.0.0.1')) socket.listen(Socket::SOMAXCONN) # new code loop do connection, _ = socket.accept end 

Fun fact: To create a server you need a forever loop. In our case loop

socket.accept is a blocking call.

When the connection is accepted and processed, the connection is closed itself. But, we personally want to close it ourselves too because

• we want the garbage collector to collect unused references to the socket
• there is a limit to how much a process can have open files at a given time.

socket.close will close the connection.

We save how to create a tcp socket, bind it to a port, listen on that port and accept connections.

The Server

So, for our server, we need to do something similar.

require 'socket' class Server def initialize(port) @server = TCPServer.new(port) @connections = [] puts "Listening on port #{port}" end def start Socket.accept_loop(@server) do |connection| @connections << connection puts @connections Thread.new do loop do handle(connection) end end end end private def handle(connection) request = connection.gets connection.close if request.nil? @connections.each do |client| next if client.closed? client.puts(request) if client != connection && !client.closed? end end end server = Server.new(4002) server.start 

Our server needs to keep the state of connected clients. It needs to relay messages to all connected clients and close a connection if a client exits the chat.

To maintain the state of the connected client, we can set up an instance variable in our constructor @connections

Inside of accept_loop , which listens for new connections, we will push the connection inside @connections.

Our private handle() method, takes a connection and reads its message and then relay it to every connection. It will close those connections of the user who exited the chat.

Since we will support more than one active connection we will run them inside a separate thread.

Phew, this was too much.

Let's move to the client

To create a server we used TCPServer.new but we need to create a client so we create a TCPSocket.new. It will accept two-parameter. A host and a port.

TCPSocket.new is a ruby wrapper for a much more line of code.

require 'socket' socket = Socket.new(:INET, :STREAM) remote_addr = Socket.pack_sockaddr_in(3000, '127.0.0.1') socket.connect(remote_addr) 

This is similar to creating a server except for we don't bind and listen on a port.

Our Client

require 'socket' class Client class << self attr_accessor :host, :port end def self.request @client = TCPSocket.new(host, port) listen send end def self.listen Thread.new do loop do puts "====#{@client.gets}" end end end def self.send Thread.new do loop do msg = $stdin.gets.chomp @client.puts(msg) end end.join end end Client.host = '127.0.0.1' Client.port = 4002 Client.request 

The listen class method will print for any new messages send by other clients connected to the socket.

The send class method will send the server message.

They run in their own separate thread so that we can listen and send messages without getting blocked.