具有 Python 和 Docker 的简单客户端-服务器-工作者本地网络

Question

我正在尝试使用 Docker 建立一个网络来完成大学作业。 网络所需的基本功能如下：

客户端从服务器请求文件，然后该服务器将请求发送给工作人员，然后工作人员获取文件并通过服务器将其发送回客户端（使用 UDP，根据任务简介）。

我试图通过测试一个简单的消息服务来首先使各种容器之间的通信正常工作，在该服务中，客户端向服务器发送任何消息，服务器将该消息转发给工作人员，工作人员只需发回确认。 我可以让服务器和客户端轻松地来回通信，但是每当我尝试将工作人员包括在通信中时，一条消息就会在某处丢失。 这是我的一些代码的示例。 这是我第一次使用 Python 进行套接字编程。

工人.py：

import socket
import time


# Worker class that can receive jobs from the server and return the request
class Worker:

    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.sock = None

    def configure_worker(self):
        print(f'Creating socket at port {self.port} ...')
        self.sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
        print('Socket successfully created!')
        self.sock.bind((self.host, self.port))

    def handle_request(self, data, server_address):
        msg = data.decode('utf-8')
        print(f'Raw data received: {msg}, from {server_address}')
        resp = 'Message received and processed by worker'
        print('Sending response to server ...')
        time.sleep(3)
        self.sock.sendto(resp.encode('utf-8'), ('server', 50000))
        print('Response sent')

    def wait_for_server(self):
        try:
            while True:
                try:
                    print('Waiting for request from server.')
                    data, server_address = self.sock.recvfrom(1024)
                    print('Data received: ', data)
                    print('Sender address: ', server_address)
                    self.handle_request(data, server_address)
                except OSError as err:
                    print(err)
        except KeyboardInterrupt:
            self.shutdown_worker()

    def shutdown_worker(self):
        print('Shutting down worker ...')
        self.sock.close()


def main():
    worker = Worker('worker1', 40000)
    worker.configure_worker()
    worker.wait_for_server()


if __name__ == '__main__':
    main()

服务器.py：

import socket
import threading
import time


class Server:

    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.sock = None
        self.socket_lock = threading.Lock()

    def wait_for_message(self):
        try:
            while True:
                try:
                    print('Awaiting data to be sent.')
                    data, sender_address = self.sock.recvfrom(1024)
                    print('Data received: ', data)
                    print('Sender Address: ', sender_address)
                    print('Initiating new thread...')
                    c_thread = threading.Thread(target=self.handle_request, args=(data, sender_address))
                    c_thread.daemon = True
                    c_thread.start()
                    print('Thread initiated.')
                except OSError as err:
                    print(err)
        except KeyboardInterrupt:
            self.shutdown_server()

    def shutdown_server(self):
        print('Shutting down the server..')
        self.sock.close()

    def handle_request(self, data, sender_address):
        msg = data.decode('utf-8')
        if msg[0] == '1':
            self.handle_client_request(msg, sender_address)
        elif msg[0] == '2':
            self.handle_worker_request(msg, sender_address)
        else:
            print(f'Incompatible message received: {msg}')

    def handle_client_request(self, msg, client_address):
        print(f'[ Message received from client at {client_address} ]')
        print(msg)
        time.sleep(3)
        self.send_request_to_worker(msg, client_address)

    def handle_worker_request(self, msg, worker_address):
        print(f'[ Message received from worker at {worker_address} ]')
        print(msg)
        client_host = 'client' + msg[1]
        print('Client host: ', client_host)
        client_port = msg[-5:]
        print(('Client port: ', client_port))
        time.sleep(3)
        self.send_request_to_client(msg, (client_host, client_port))

    def send_request_to_worker(self, msg, client_address):
        worker_port = 40000
        worker_host = 'worker1'
        data = msg + str(client_address[1])
        print(f'Sending request to worker1 (Data to send: {data}')
        with self.socket_lock:
            self.sock.sendto(data.encode('utf-8'), (worker_host, worker_port))
        print('Successfully sent to worker1')

    def send_request_to_client(self, msg, client_address):
        resp = msg.encode('utf-8')
        print(f'Sending response to client at {client_address}')
        with self.socket_lock:
            self.sock.sendto(resp.encode('utf-8'), client_address)

    def configure_server(self):
        print(f'Creating socket at port {self.port} ...')
        self.sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
        print('Socket successfully created.')
        self.sock.bind((self.host, self.port))


def main():
    server = Server('server', 50000)
    server.configure_server()
    server.wait_for_message()


if __name__ == '__main__':
    main()

客户端.py：

import socket


# Simple UDP Client Program for sending messages to the Ingress
class UDPClient:

    # Initialise the Client with the ingress port and hostname
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.sock = None

    # Configures the client socket
    def configure_client(self):
        hostname = socket.gethostname()
        ip = socket.gethostbyname(hostname)
        print('Creating UDP/IPv4 Socket...')
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        print(f'Socket successfully created!')
        print(f'Client IP: {ip}\n')

    # Continuously checks if the client wants to send a message to the ingress
    def send_message(self):
        while True:
            try:
                # Sends a message to the ingress
                msg = input("Enter message: ")
                msg = '1' + msg
                self.sock.sendto(msg.encode('utf-8'), (self.host, self.port))
                print('[ SENT ]')
                print(msg, '\n')

                # Receives an acknowledgement from the ingress
                resp, server_address = self.sock.recvfrom(1024)
                print('[ RECEIVED ]')
                print(resp.decode(), '\n')
                print('Interaction completed successfully.')

            except OSError as err:
                print(err)


def main():
    udp_client = UDPClient('ingress', 50000)
    udp_client.configure_client()
    udp_client.send_message()


if __name__ == '__main__':
    main()

我为这篇长文道歉。 另外，不要介意文本的某些格式，我只是为了测试目的而这样做。 主要问题是我可以将消息从客户端发送到服务器，然后服务器将其发送给工作人员。 然后工作人员显示它已成功将其消息发送回服务器的消息，但服务器从未收到它。 这是 Docker 容器中正在运行的程序的图片：三个终端的屏幕截图，分别运行 client.py、worker.py 和 ingress2.py (server.py)

对此的任何帮助将不胜感激。 网络被证明是非常困难的，我的讲师似乎也不是很有帮助。

韦斯