Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

I need the server to send messages to all clients (Python, sockets)

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()
like image 784
Paris Karagiannopoulos Avatar asked Nov 26 '14 00:11

Paris Karagiannopoulos


People also ask

How do I connect multiple clients to one server in Python?

Connect Multiple Clients in Python We have to create a brand new function and name it multi_threaded_client() ; this connects every client from the various address provided by the server simultaneously. Within the multi_threaded_client function, the connection.

How do I create a client server in Python?

The first step is to import the socket module and then create a socket just like you did while creating a server. Then, to create a connection between the client-server you will need to use the connect() method by specifying (host, port).

Can multiple clients connect to same server socket?

If two connections using the same protocol have identical source and destination IPs and identical source and destination ports, they must be the same connection. Thus multiple client using same protocol may use same socket of server seemingly multi-threading.


1 Answers

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 points out, there's a different way to design servers besides using a thread (or two) per client: using a reactor 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/asynchat and the low-level select.

As Anzel says, 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, or find or write a very simple one that sits directly on select.

like image 51
abarnert Avatar answered Sep 28 '22 22:09

abarnert