Question

I’m writing a multithreaded distributed networking algorithm.

I’ve one thread that listens to new connections. Every time a new connection is established a separate thread is started for listening to messages from that connection.

My problem is that the socket I open works perfectly in both directions inside the connection listener. After I pass the socket object for that connection to the message listener I can read data from the socket, but sending data through it doesn’t reach the remote host.

Here’s the essential snip from my code:

def connection_listener(port, start_e, terminate_e):

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.settimeout(1)
    s.bind(('', port))

    s.listen(1)

    while (not start_e.isSet()):
        try:
            conn, addr = s.accept()

            msg_in = conn.recv(1024).split(":")
            if (msg_in[1]=="hello"):
                # If addr sends us a 'id:hello', we reply with a 'my_id:welcome'
                conn.send(str(my_id)+":welcome")

                t = Thread(target=message_listener, args=(conn, addr[0], terminate_e, ))
                t.start()
        except:
            pass # timeout


def message_listener(conn, address, terminate_e):

    while (not terminate_e.isSet()):
        try:
            msg_in = conn.recv(1024)

            # Here I can receive everything that I send from the other end of conn,
            # but conn.send("any data") doesn't reach the remote host

What I’d like to do is send acknowledgement-like messages from the message listener thread using the conn. Is this possible somehow or am I thinking and doing it wrong?

Answer 1

I sorted this out myself, so I’ll share my answer.

I made the protocol exchange fixed size messages by padding with zeroes up to the desired length. I used a length of 32 bytes, which might be quite tiny from the hardware’s point of view. Nevertheless it seems to work as supposed.

Pragmatically my solution looks like:

def send_everyone(message):
    for i in range(len(peers)):
        chunk = (str(my_id)+":"+message).rjust(32, '0')
        peers[i].send(chunk)

And on the receiving side we want only 32 bytes at a time:

def message_listener(conn, address, terminate_e):
    while (not terminate_e.isSet()):
        try:
            msg_in = conn.recv(32)

            ...