UDP Simple Client and Threaded Server written in Python

Client.py

import socket
import sys

HOST, PORT = "localhost", 8888
data = " ".join(sys.argv[1:])

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

sock.sendto(data + "\n", (HOST, PORT))
received = sock.recv(1024)

print("Sent:     {}".format(data))
print("Received: {}".format(received))

Server.py

import SocketServer, threading, time

class ThreadedUDPRequestHandler(SocketServer.BaseRequestHandler):

    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        current_thread = threading.current_thread()
        print("{}: client: {}, wrote: {}".format(current_thread.name, self.client_address, data))
        socket.sendto(data.upper(), self.client_address)

class ThreadedUDPServer(SocketServer.ThreadingMixIn, SocketServer.UDPServer):
    pass

if __name__ == "__main__":
    HOST, PORT = "0.0.0.0", 8888

    server = ThreadedUDPServer((HOST, PORT), ThreadedUDPRequestHandler)

    server_thread = threading.Thread(target=server.serve_forever)
    server_thread.daemon = True

    try:
        server_thread.start()
        print("Server started at {} port {}".format(HOST, PORT))
        while True: time.sleep(100)
    except (KeyboardInterrupt, SystemExit):
        server.shutdown()
        server.server_close()
        exit()

Hi!
Thanks for this example, it's very helpful. I have a question though, what does this line :
current_thread = threading.current_thread()
exactly do?

The doc says that it :

Return the current Thread object, corresponding to the caller’s thread of control.

But apparently in your code it doesn't simply "return the caller's thread of control" (that would be the thread started in your main part), instead it apparently :

• create a new thread (no need of threading.Thread() here apparently)
• starts it (no need of start())
• absolutely not return the caller's thread but instead the new thread it just created
• gently kills it at the end of the method (no need of a join or something like that)

I'm very confused as, not only is this behaviour radically different from my understanding of the documentation, but you're using two completely unrelated ways of creating a thread and running it (in the handler and in the main). Could you elaborate a bit? In this state the handler thread seems utterly "magical" to me.

how about a threaded client that doesn't wait for a response?

This is ass

uff...

In this time I was using gist as pastebin.

Gonna elaborate an example over an udp server and put here.

😅

Well, I remember I did find it helpful at the time. I was getting started on Python.

I don't understand why this guy say "this is ass". This is the first result on google when someone asks for python threaded udp server, maybe it's helpful to people.

Anyway...

You can find a better description on how to make a threaded UDP Server to handle a lot of requests at same time using python here:

https://docs.python.org/3/library/socketserver.html

Well, I remember I did find it helpful at the time. I was getting started on Python.

Thank you!! =D