Terminando el chat

chat de hackers xd

Los canales y las go rutinas son extremadamente poderosas. Este ejercicio me hizo pensar en lo flexible, y al mismo tiempo sólido, modelo de concurrencia de Go. Mientras que los callbacks, streams y promesas en Node.js solo son efectivas en operaciones de IO, las Go Rutinas pueden tener procesos intensos en uso de CPU y la sintaxis es igual de dulce que lenguajes de scripting como Javascript.

Increible!

// Broadcast sends the message to all the clients, and handles incoming
// and outgoing connections
func Broadcast() {

	// Map the clients to a boolean
	clients := make(map[Client]bool)

	for {
		// Multiplex the messages
		select {
		// We get a new message
		case msg := <-messages:
			// Send the message to all the clients
			for client := range clients {
				client <- msg
			}
		// We get a new client
		case client := <-entering:
			clients[client] = true
		// A client that has disconnected
		case client := <-leaving:
			delete(clients, client)
			close(client)
		}
	}
}

func main() {
	flag.Parse()

	// Create the server and listen to it
	listener, err := net.Listen("tcp", *host+":"+*port)
	if err != nil {
		fmt.Println("Error listening:", err.Error())
		return
	}

	// Start the broadcast
	go Broadcast()

	// Listen for connections
	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Error accepting: ", err.Error())
			continue
		}
		go HanldeConnection(conn)
	}
}