From 1151d6893eaebcc91bc331b6c777dc8a9175f712 Mon Sep 17 00:00:00 2001 From: Rik Veenboer Date: Tue, 2 Jun 2015 21:38:24 +0200 Subject: [PATCH] add example using serversocket from https://docs.python.org/2/library/socketserver.html --- socketserver/TcpClient.py | 21 +++++++++++++++++ socketserver/TcpServer.py | 38 +++++++++++++++++++++++++++++++ socketserver/TcpThreaded.py | 45 +++++++++++++++++++++++++++++++++++++ socketserver/UdpClient.py | 16 +++++++++++++ socketserver/UdpServer.py | 21 +++++++++++++++++ 5 files changed, 141 insertions(+) create mode 100644 socketserver/TcpClient.py create mode 100644 socketserver/TcpServer.py create mode 100644 socketserver/TcpThreaded.py create mode 100644 socketserver/UdpClient.py create mode 100644 socketserver/UdpServer.py diff --git a/socketserver/TcpClient.py b/socketserver/TcpClient.py new file mode 100644 index 0000000..5ad1c76 --- /dev/null +++ b/socketserver/TcpClient.py @@ -0,0 +1,21 @@ +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) + +try: + # Connect to server and send data + sock.connect((HOST, PORT)) + sock.sendall(bytes(data + "\n")) + + # Receive data from the server and shut down + received = str(sock.recv(1024)); +finally: + sock.close() + +print("Sent: {}".format(data)) +print("Received: {}".format(received)) \ No newline at end of file diff --git a/socketserver/TcpServer.py b/socketserver/TcpServer.py new file mode 100644 index 0000000..fe7ca92 --- /dev/null +++ b/socketserver/TcpServer.py @@ -0,0 +1,38 @@ +import SocketServer + +class MyTCPHandler(SocketServer.BaseRequestHandler): + """ + The RequestHandler class for our server. + + It is instantiated once per connection to the server, and must + override the handle() method to implement communication to the + client. + """ + + def handle(self): + # self.request is the TCP socket connected to the client + self.data = self.request.recv(1024).strip() + print("{} wrote:".format(self.client_address[0])) + print(self.data) + # just send back the same data, but upper-cased + self.request.sendall(self.data.upper()) + + # def handle(self): + # 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("{} wrote:".format(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()) + +if __name__ == "__main__": + HOST, PORT = "localhost", 9999 + + # Create the server, binding to localhost on port 9999 + server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler) + + # Activate the server; this will keep running until you + # interrupt the program with Ctrl-C + server.serve_forever() \ No newline at end of file diff --git a/socketserver/TcpThreaded.py b/socketserver/TcpThreaded.py new file mode 100644 index 0000000..f1bace3 --- /dev/null +++ b/socketserver/TcpThreaded.py @@ -0,0 +1,45 @@ +import socket +import threading +import SocketServer + +class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler): + + def handle(self): + data = self.request.recv(1024) + cur_thread = threading.current_thread() + response = "{}: {}".format(cur_thread.name, data) + self.request.sendall(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)) + try: + sock.sendall(message) + response = sock.recv(1024) + print "Received: {}".format(response) + finally: + 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.daemon = True + server_thread.start() + print "Server loop running in thread:", server_thread.name + + client(ip, port, "Hello World 1") + client(ip, port, "Hello World 2") + client(ip, port, "Hello World 3") + + server.shutdown() \ No newline at end of file diff --git a/socketserver/UdpClient.py b/socketserver/UdpClient.py new file mode 100644 index 0000000..1290ea2 --- /dev/null +++ b/socketserver/UdpClient.py @@ -0,0 +1,16 @@ +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(data + "\n", (HOST, PORT)) +received = sock.recv(1024) + +print "Sent: {}".format(data) +print "Received: {}".format(received) \ No newline at end of file diff --git a/socketserver/UdpServer.py b/socketserver/UdpServer.py new file mode 100644 index 0000000..4d1c3e0 --- /dev/null +++ b/socketserver/UdpServer.py @@ -0,0 +1,21 @@ +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 "{} wrote:".format(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() \ No newline at end of file