=== modified file 'Doc/library/socketserver.rst' --- Doc/library/socketserver.rst 2008-06-13 06:32:25 +0000 +++ Doc/library/socketserver.rst 2008-11-07 22:45:06 +0000 @@ -336,8 +336,8 @@ def handle(self): # self.request is the TCP socket connected to the client self.data = self.request.recv(1024).strip() - print "%s wrote:" % self.client_address[0] - print self.data + print("%s wrote:" % self.client_address[0]) + print(self.data) # just send back the same data, but upper-cased self.request.send(self.data.upper()) @@ -360,8 +360,8 @@ # self.rfile is a file-like object created by the handler; # we can now use e.g. readline() instead of raw recv() calls self.data = self.rfile.readline().strip() - print "%s wrote:" % self.client_address[0] - print self.data + print("%s wrote:" % self.client_address[0]) + print(self.data) # Likewise, self.wfile is a file-like object used to write back # to the client self.wfile.write(self.data.upper()) @@ -374,25 +374,25 @@ This is the client side:: - import socket - import sys - - HOST, PORT = "localhost", 9999 - data = " ".join(sys.argv[1:]) - - # Create a socket (SOCK_STREAM means a TCP socket) - sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - - # Connect to server and send data - sock.connect((HOST, PORT)) - sock.send(data + "\n") - - # Receive data from the server and shut down - received = sock.recv(1024) - sock.close() - - print "Sent: %s" % data - print "Received: %s" % received + import socket + import sys + + HOST, PORT = "localhost", 9999 + data = " ".join(sys.argv[1:]) + + # Create a socket (SOCK_STREAM means a TCP socket) + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + + # Connect to server and send data + sock.connect((HOST, PORT)) + sock.send(bytearray(data + "\n","utf8")) + + # Receive data from the server and shut down + received = sock.recv(1024) + sock.close() + + print("Sent: %s" % data) + print("Received: %s" % received) The output of the example should look something like this: @@ -401,18 +401,18 @@ $ python TCPServer.py 127.0.0.1 wrote: - hello world with TCP + b'hello world with TCP' 127.0.0.1 wrote: - python is nice + b'python is nice' Client:: $ python TCPClient.py hello world with TCP Sent: hello world with TCP - Received: HELLO WORLD WITH TCP + Received: b'HELLO WORLD WITH TCP' $ python TCPClient.py python is nice Sent: python is nice - Received: PYTHON IS NICE + Received: b'PYTHON IS NICE' :class:`socketserver.UDPServer` Example @@ -420,46 +420,46 @@ This is the server side:: - import socketserver - - class MyUDPHandler(socketserver.BaseRequestHandler): - """ - This class works similar to the TCP handler class, except that - self.request consists of a pair of data and client socket, and since - there is no connection the client address must be given explicitly - when sending data back via sendto(). - """ - - def handle(self): - data = self.request[0].strip() - socket = self.request[1] - print "%s wrote:" % self.client_address[0] - print data - socket.sendto(data.upper(), self.client_address) - - if __name__ == "__main__": - HOST, PORT = "localhost", 9999 - server = socketserver.UDPServer((HOST, PORT), BaseUDPRequestHandler) - server.serve_forever() + import socketserver + + class MyUDPHandler(socketserver.BaseRequestHandler): + """ + This class works similar to the TCP handler class, except that + self.request consists of a pair of data and client socket, and since + there is no connection the client address must be given explicitly + when sending data back via sendto(). + """ + + def handle(self): + data = self.request[0].strip() + socket = self.request[1] + print("%s wrote:" % self.client_address[0]) + print(data) + socket.sendto(data.upper(), self.client_address) + + if __name__ == "__main__": + HOST, PORT = "localhost", 9999 + server = socketserver.UDPServer((HOST, PORT), MyUDPHandler) + server.serve_forever() This is the client side:: - import socket - import sys - - HOST, PORT = "localhost" - data = " ".join(sys.argv[1:]) - - # SOCK_DGRAM is the socket type to use for UDP sockets - sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) - - # As you can see, there is no connect() call; UDP has no connections. - # Instead, data is directly sent to the recipient via sendto(). - sock.sendto(data + "\n", (HOST, PORT)) - received = sock.recv(1024) - - print "Sent: %s" % data - print "Received: %s" % received + import socket + import sys + + HOST, PORT = "localhost", 9999 + data = " ".join(sys.argv[1:]) + + # SOCK_DGRAM is the socket type to use for UDP sockets + sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + + # As you can see, there is no connect() call; UDP has no connections. + # Instead, data is directly sent to the recipient via sendto(). + sock.sendto(bytearray(data + "\n","utf8"), (HOST, PORT)) + received = sock.recv(1024) + + print("Sent: %s" % data) + print("Received: %s" % received) The output of the example should look exactly like for the TCP server example. @@ -472,57 +472,58 @@ An example for the :class:`ThreadingMixIn` class:: - import socket - import threading - import socketserver - - class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler): - - def handle(self): - data = self.request.recv(1024) - cur_thread = threading.current_thread() - response = "%s: %s" % (cur_thread.get_name(), data) - self.request.send(response) - - class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): - pass - - def client(ip, port, message): - sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - sock.connect((ip, port)) - sock.send(message) - response = sock.recv(1024) - print "Received: %s" % response - sock.close() - - if __name__ == "__main__": - # Port 0 means to select an arbitrary unused port - HOST, PORT = "localhost", 0 - - server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler) - ip, port = server.server_address - - # Start a thread with the server -- that thread will then start one - # more thread for each request - server_thread = threading.Thread(target=server.serve_forever) - # Exit the server thread when the main thread terminates - server_thread.set_daemon(True) - server_thread.start() - print "Server loop running in thread:", t.get_name() - - client(ip, port, "Hello World 1") - client(ip, port, "Hello World 2") - client(ip, port, "Hello World 3") - - server.shutdown() + import socket + import threading + import socketserver + + class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler): + + def handle(self): + data = self.request.recv(1024) + cur_thread = threading.current_thread() + response = bytearray("%s: %s" % (cur_thread.getName(), data),'ascii') + self.request.send(response) + + class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): + pass + + def client(ip, port, message): + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.connect((ip, port)) + sock.send(message) + response = sock.recv(1024) + print("Received: %s" % response) + sock.close() + + if __name__ == "__main__": + # Port 0 means to select an arbitrary unused port + HOST, PORT = "localhost", 0 + + server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler) + ip, port = server.server_address + + # Start a thread with the server -- that thread will then start one + # more thread for each request + server_thread = threading.Thread(target=server.serve_forever) + # Exit the server thread when the main thread terminates + server_thread.setDaemon(True) + server_thread.start() + print("Server loop running in thread:", server_thread.getName()) + + client(ip, port, b"Hello World 1") + client(ip, port, b"Hello World 2") + client(ip, port, b"Hello World 3") + + server.shutdown() + The output of the example should look something like this:: $ python ThreadedTCPServer.py Server loop running in thread: Thread-1 - Received: Thread-2: Hello World 1 - Received: Thread-3: Hello World 2 - Received: Thread-4: Hello World 3 + Received: b"Thread-2: b'Hello World 1'" + Received: b"Thread-3: b'Hello World 2'" + Received: b"Thread-4: b'Hello World 3'" The :class:`ForkingMixIn` class is used in the same way, except that the server