Question

I am developing a group chat application to learn how to use sockets, threads (maybe), and asycore module(maybe).
What my thought was have a client-server architecture so that when a client connects to the server the server sends the client a list of other connects (other client ‘user name’, ip addres) and then a person can connect to one or more people at a time and the server would set up a P2P connection between the client(s). I have the socket part working, but the server can only handle one client connection at a time.
What would be the best, most common, practical way to go about handling multiple connections?
Do I create a new process/thread whenever I new connection comes into the server and then connect the different client connections together, or use the asycore module which from what I understand makes the server send the same data to multiple sockets(connection) and I just have to regulate where the data goes.

Any help/thoughts/advice would be appreciated.

Answer 1

For a group chat application, the general approach will be:

Server side (accept process):

• Create the socket, bind it to a well known port (and on appropriate interface) and listen
• While (app_running)
  • Client_socket = accept (using serverSocket)
  • Spawn a new thread and pass this socket to the thread. That thread handles the client that just connected.
  • Continue, so that server can continue to accept more connections.

Server-side client mgmt Thread:

• while app_running:
  • read the incoming message, and store to a queue or something.
  • continue

Server side (group chat processing):

• For all connected clients:
  • check their queues. If any message present, send that to ALL the connected clients (including the client that sent this message — serves as ACK sort of)

Client side:

• create a socket
• connect to server via IP-address, and port
• do send/receive.

There can be lots of improvement on the above. Like the server could poll the sockets or use “select” operation on a group of sockets. That would make it efficient in the sense that having a separate thread for each connected client will be an overdose when there are many. (Think ~1MB per thread for stack).

PS: I haven’t really used asyncore module. But I am just guessing that you would notice some performance improvement when you have lots of connected clients and very less processing.