I need the server to send messages to all clients (Python, sockets)
Question: This is my server program, how can it send the data received from each client
to every other client?

    
    
    import socket
    import os
    from threading import Thread
    import thread
    
    def listener(client, address):
        print "Accepted connection from: ", address
    
        while True:
            data = client.recv(1024)
            if not data:
                break
            else:
                print repr(data)
                client.send(data)
    
        client.close()
    
    host = socket.gethostname()
    port = 10016
    
    s = socket.socket()
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind((host,port))
    s.listen(3)
    th = []
    
    while True:
        print "Server is listening for connections..."
        client, address = s.accept()
        th.append(Thread(target=listener, args = (client,address)).start())
    
    s.close()
    


Answer: If you need to send a message to all clients, you need to keep a collection of
all clients in some way. For example:

    
    
    clients = set()
    clients_lock = threading.Lock()
    
    def listener(client, address):
        print "Accepted connection from: ", address
        with clients_lock:
            clients.add(client)
        try:    
            while True:
                data = client.recv(1024)
                if not data:
                    break
                else:
                    print repr(data)
                    with clients_lock:
                        for c in clients:
                            c.sendall(data)
        finally:
            with clients_lock:
                clients.remove(client)
                client.close()
    

It would probably be clearer to factor parts of this out into separate
functions, like a `broadcast` function that did all the sends.

Anyway, this is the _simplest_ way to do it, but it has problems:

  * If one client has a slow connection, everyone else could bog down writing to it. And while they're blocking on their turn to write, they're not reading anything, so you could overflow the buffers and start disconnecting everyone.
  * If one client has an error, the client whose thread is writing to that client could get the exception, meaning you'll end up disconnecting the wrong user.

So, a better solution is to give each client a queue, and a writer thread
servicing that queue, alongside the reader thread. (You can then extend this
in all kinds of ways—put limits on the queue so that people stop trying to
talk to someone who's too far behind, etc.)

* * *

As [Anzel](http://stackoverflow.com/users/3849456/anzel) points out, there's a
_different_ way to design servers besides using a thread (or two) per client:
using a [reactor](http://en.wikipedia.org/wiki/Reactor_pattern) that
multiplexes all of the clients' events.

Python 3.x has some great libraries for this built in, but 2.7 only has the
clunky and out-of-date
[`asyncore`](https://docs.python.org/2/library/asyncore.html)/[`asynchat`](https://docs.python.org/2/library/asynchat.html)
and the low-level [`select`](https://docs.python.org/2/library/select.html).

As Anzel says, [Python SocketServer: sending to multiple
clients](http://stackoverflow.com/questions/3670127/python-socketserver-
sending-to-multiple-clients) has an answer using `asyncore`, which is worth
reading. But I wouldn't actually use that. If you want to write a reactor-
based server in Python 2.x, I'd either use a better third-party framework like
[Twisted](https://twistedmatrix.com/trac/), or find or write a very simple one
that sits directly on `select`.

