Receive in two functions from one Socket

Question

I want to create a Socket Client and want to receive the answer if a message is sent in one function but also want to listen to all incoming data all the time.

The problem is, if I do both, the code stops executing as recv() seems to be a blocking function.

This is a quick overview:

Server.py

import socket
HOST = "127.0.0.1"
PORT = 6543
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen()
conn, addr = s.accept()
with conn:
 print("Connected by ", addr)
 while True:
 data = conn.recv(1024)
 conn.sendall(data)

Client.py

import socket
import time
import multiprocessing
HOST = "127.0.0.1"
PORT = 6543
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
def keepAlive():
 while True:
 s.send(b"Keep Alive to be handled in keepAlive")
 print(s.recv(1024), "received from keepAlive")
 time.sleep(1)
def send():
 while True:
 s.send(b"Random message to be handled in listen")
 time.sleep(1)
def listen():
 while True:
 print(s.recv(1024), "received from listen")
if __name__ == "__main__":
 keepAliveProc = multiprocessing.Process(target=keepAlive)
 listenProc = multiprocessing.Process(target=listen)
 sendProc = multiprocessing.Process(target=send)
 keepAliveProc.start()
 listenProc.start()
 sendProc.start()

But this will block and the Code doesn't continue. Can anyone help with this?

• MisterMiyagi: How do you expect listen and keepAlive to know which data to receive? As per your design, both would be waiting for data at the same time.
• Alexander Riedel: yes thats actually the problem. I would like to to be keepAlive faster and get the answer right after sending... How would you solve this in general? Something like send and wait for response?
• MisterMiyagi: It might be easier to have one function do the recv but be aware of and digest/discard the keep-alive message.
• Alexander Riedel: the point is, that i have to handle input to and response from the server in a combined way. if i digest all responses in one function, i might not know, what response belongs to which input
• MisterMiyagi: There is no such thing as input and responses belonging together in TCP. As you send a keep-alive, you cannot know whether the other side is sending a regular response first before the keep-alive response.

Answer 1

I don't think you need a res = socket.recv(1024) in your server block. You are not expecting a response from the client (listen()) as the client is not sending anything.

• Alexander Riedel: It might happen, that the server will send something from time to time even without any input. What i showed above is not a client, server combination but two function within the client

Answer 2

I don't have experience in python programming, but i did develop socket communication in java recently. If recv blocks program, then it blocks until it received some data. I think you need to change from multiproccessing to threads since multiproccessing is CPU bound and your communication is network based.

Maybe this can help: Python socket recv in thread

• Alexander Riedel: unfortunately, threading shows the same behaviour :(
• StefanP: Do you get any message at all, or it block first one?
• Alexander Riedel: well i want the keepAlive message so be received in the keepAlive function, right after it was sent, and everything else in the listen() function. It's sending the message once, receives it in the wrong function (listen()) and then stops.
• StefanP: If i understand correctly, you are receiving some messages from server. Messages you want to receive in listen() method are messages that you know how they will look, right? And the one you don't know you will receive in keepAlive. If this is a case, just receive data once, and than depending on message call functions for that
• Alexander Riedel: I added a working example in my code so maybe its more clear what i need. I know the response from keepAlive and want to handle other incoming messages differently. I just don't want to handle them all in one place but the one's I know (for example keepAlive) right in place