tcp服务

zhxhcoder · zhxhcoder · commit 036e4363f0ca · 2020-06-30T13:37:54.000+08:00
diff --git a/pytcp/__init__.py b/pytcp/__init__.py
diff --git a/pytcp/multithreadedClient.py b/pytcp/multithreadedClient.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+"""
+Multi-threaded TCP Client
+multithreadedClient.py is a TCP client that maintains a maximum number of worker threads which continuously send a given
+number of requests to multithreadedServer.py and print the server's response.
+This is derived from an assignment for the Distributed Systems class at Bennington College
+"""
+
+from argparse import ArgumentParser
+from queue import Queue
+from socket import SO_REUSEADDR, SOCK_STREAM, error, socket, SOL_SOCKET, AF_INET
+from threading import Thread
+
+# -------------------------------------#
+########## ARGUMENT HANDLING ##########
+# -------------------------------------#
+
+# Initialize instance of an argument parser
+parser = ArgumentParser(description='Multi-threaded TCP Client')
+
+# Add optional arguments, with given default values if user gives no args
+parser.add_argument('-r', '--requests', default=10, type=int, help='Total number of requests to send to server')
+parser.add_argument('-w', '--workerThreads', default=5, type=int, help='Max number of worker threads to be created')
+parser.add_argument('-i', '--ip', default='127.0.0.1', help='IP address to connect over')
+parser.add_argument('-p', '--port', default=9000, type=int, help='Port over which to connect')
+
+# Get the arguments
+args = parser.parse_args()
+
+
+# --------------------------------------#
+########## CLIENT CONSTRUCTOR ##########
+# --------------------------------------#
+
+
+class Client:
+    def __init__(self, id, address, port, message):
+        self.s = socket(AF_INET, SOCK_STREAM)
+        self.id = id
+        self.address = address
+        self.port = port
+        self.message = message
+
+    def run(self):
+        try:
+            # Timeout if the no connection can be made in 5 seconds
+            self.s.settimeout(5)
+            # Allow socket address reuse
+            self.s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+            # Connect to the ip over the given port
+            self.s.connect((self.address, self.port))
+            # Send the defined request message
+            self.s.send(self.message)
+            # Wait to receive data back from server
+            data = self.s.recv(1024)
+            # Notify that data has been received
+            print
+            self.id, ":  received: ", data
+            # CLOSE THE SOCKET
+            self.s.close()
+        # If something went wrong, notify the user
+        except error as e:
+            print
+            "\nERROR: Could not connect to ", self.address, " over port", self.port, "\n"
+            raise e
+
+
+# ------------------------------------------------#
+########## DEFINE QUEUE WORKER FUNCTION ##########
+# ------------------------------------------------#
+
+# Create a queue to hold the tasks for the worker threads
+q = Queue(maxsize=0)
+
+
+# Function which generates a Client instance, getting the work item to be processed from the queue
+def worker():
+    message = "HELO"
+
+    while True:
+        # Get the task from teh work queue
+        item = q.get()
+
+        new_client = Client(item, args.ip, args.port, message)
+        new_client.run()
+        # Mark this task item done, thus removing it from the work queue
+        q.task_done()
+
+
+# --------------------------------------------------#
+########## INITIATE CLIENT WORKER THREADS ##########
+# --------------------------------------------------#
+
+# Populate the work queue with a list of numbers as long as the total number of requests wished to be sent.
+# These queue items can be thought of as decrementing counters for the client thread workers.
+for item in range(args.requests):
+    q.put(item)
+
+# Create a number of threads, given by the maxWorkerThread variable, to initiate clients and begin sending requests.
+for i in range(args.workerThreads):
+    t = Thread(target=worker)
+    t.daemon = True
+    t.start()
+
+# Do not exit the main thread until the sub-threads complete their work queue
+q.join()
diff --git a/pytcp/multithreadedServer.py b/pytcp/multithreadedServer.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+"""
+Multi-threaded TCP Server
+multithreadedServer.py acts as a standard TCP server, with multi-threaded integration, spawning a new thread for each
+client request it receives.
+This is derived from an assignment for the Distributed Systems class at Bennington College
+"""
+
+from argparse import ArgumentParser
+from socket import SO_REUSEADDR, SOCK_STREAM, socket, SOL_SOCKET, AF_INET
+from threading import Lock, Thread
+
+# ---------------------------------------#
+########## USER INPUT HANDLING ##########
+# ---------------------------------------#
+
+# Initialize instance of an argument parser
+parser = ArgumentParser(description='Multi-threaded TCP Server')
+
+# Add optional argument, with given default values if user gives no arg
+parser.add_argument('-p', '--port', default=9000, type=int, help='Port over which to connect')
+
+# Get the arguments
+args = parser.parse_args()
+
+# -------------------------------------------#
+########## DEFINE GLOBAL VARIABLES ##########
+# -------------------------------------------#
+
+counter = 0
+response_message = "Now serving, number: "
+thread_lock = Lock()
+
+# Create a server TCP socket and allow address re-use
+s = socket(AF_INET, SOCK_STREAM)
+s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+s.bind(('localhost', args.port))
+
+# Create a list in which threads will be stored in order to be joined later
+threads = []
+
+
+# ---------------------------------------------------------#
+########## THREADED CLIENT HANDLER CONSTRUCTION ###########
+# ---------------------------------------------------------#
+
+
+class ClientHandler(Thread):
+    def __init__(self, address, port, socket, response_message, lock):
+        Thread.__init__(self)
+        self.address = address
+        self.port = port
+        self.socket = socket
+        self.response_message = response_message
+        self.lock = lock
+
+    # Define the actions the thread will execute when called.
+    def run(self):
+        global counter
+        self.socket.send(self.response_message + str(counter))
+        # Lock the changing of the shared counter value to prevent erratic multithread changing behavior
+        with self.lock:
+            counter += 1
+        self.socket.close()
+
+
+# -----------------------------------------------#
+########## MAIN-THREAD SERVER INSTANCE ##########
+# -----------------------------------------------#
+
+# Continuously listen for a client request and spawn a new thread to handle every request
+while 1:
+
+    try:
+        # Listen for a request
+        s.listen(1)
+        # Accept the request
+        sock, addr = s.accept()
+        # Spawn a new thread for the given request
+        newThread = ClientHandler(addr[0], addr[1], sock, response_message, thread_lock)
+        newThread.start()
+        threads.append(newThread)
+    except KeyboardInterrupt:
+        print
+        "\nExiting Server\n"
+        break
+
+# When server ends gracefully (through user keyboard interrupt), wait until remaining threads finish
+for item in threads:
+    item.join()
