Simple proof of concept chat server
I found it relatively easy to create a simple terminal chat server. To interact,
I am using telnet to connect to the server.
The idea is very simple. In our main thread, we are listening to incoming TCP
connections. So, when telnet connects to our server, we create a separate
goroutine handleConnection to handle that connection.
In handleConnection, we first ask the user for their name, and then create a
client object and register it with the server. After that, we enter a loop where
we continuously read messages from the client, and once the message is received,
we broadcast it to all other connected clients.
The server maintains a list of connected clients and uses channels to handle the
registration, unregistration, and broadcasting of messages. The run method of
the server listens for these events and processes them accordingly.
Full go code:
package main
import (
"bufio"
"fmt"
"net"
"strings"
)
type Client struct {
conn net.Conn
name string
}
type Message struct {
sender net.Conn
text string
}
type Server struct {
clients map[net.Conn]Client
register chan Client
unregister chan Client
broadcast chan Message
}
func (s *Server) run() {
for {
select {
case message := <-s.broadcast:
for conn, client := range s.clients {
if conn != message.sender {
fmt.Fprintln(client.conn, message.text)
}
}
fmt.Println(message.text)
case client := <-s.register:
s.clients[client.conn] = client
text := fmt.Sprintf("%s joined the chat", client.name)
s.broadcast <- Message{sender: client.conn, text: text}
fmt.Printf("%s connected\n", client.name)
case client := <-s.unregister:
if client, ok := s.clients[client.conn]; ok {
delete(s.clients, client.conn)
text := fmt.Sprintf("%s left the chat", client.name)
s.broadcast <- Message{sender: client.conn, text: text}
fmt.Printf("%s disconnected\n", client.name)
}
}
}
}
func (s *Server) handleConnection(conn net.Conn) {
defer conn.Close()
reader := bufio.NewReader(conn)
fmt.Fprint(conn, "Enter your name: ")
name, _ := reader.ReadString('\n')
name = strings.TrimSpace(name)
client := Client{conn: conn, name: name}
s.register <- client
for {
message, err := reader.ReadString('\n')
if err != nil {
break
}
message = strings.TrimSpace(message)
if message == "" {
continue
}
fullMsg := fmt.Sprintf("%s: %s", name, message)
s.broadcast <- Message{sender: conn, text: fullMsg}
}
s.unregister <- client
}
func NewServer() *Server {
return &Server{
clients: make(map[net.Conn]Client),
register: make(chan Client),
unregister: make(chan Client),
broadcast: make(chan Message, 1),
}
}
func main() {
listener, err := net.Listen("tcp", ":8080")
if err != nil {
panic(err)
}
defer listener.Close()
server := NewServer()
go server.run()
fmt.Println("Chat server started on :8080")
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("connection error:", err)
continue
}
go server.handleConnection(conn)
}
}