Python自定义主从分布式架构实例分析

介绍

分布式架构是大规模系统的一种设计模式，由多个独立计算机节点组成，各节点之间进行通讯和协作，并共同解决一个问题。本文将讲解Python实现自定义主从分布式架构的完整攻略，包含以下内容：

1. 主从分布式架构原理
2. 服务端代码实现
3. 客户端代码实现
4. 示例说明

主从分布式架构原理

主从分布式架构是指有一个或多个主服务器节点，其他所有节点都是从服务器节点，主节点负责协调集群中的从节点进行任务分配和结果汇总。主节点可以拥有所有任务的完整视图和控制权，从节点只负责执行其分配到的任务，并将结果返回给主节点。

服务端代码实现

import socket
import threading

class Server(threading.Thread):
    def __init__(self, host, port):
        super(Server, self).__init__()
        self.host = host
        self.port = port
        self.sock = socket.socket()
        self.sock.bind((host, port))
        self.sock.listen(5)

    def run(self):
        while True:
            conn, addr = self.sock.accept()
            data = conn.recv(1024)
            if not data:
                break
            print(f"Received message: `{data.decode()}` from {addr}")
            conn.sendall(data)
            conn.close()

上面的代码实现了一个简单的TCP/IP服务端，通过Socket监听指定主机和端口，接收客户端发送过来的消息，并将其返回给客户端。

客户端代码实现

import socket

class Client:
    def __init__(self, host, port):
        self.host = host
        self.port = port

    def send_message(self, message):
        with socket.socket() as sock:
            sock.connect((self.host, self.port))
            sock.sendall(message.encode())
            received_message = sock.recv(1024).decode()
        return received_message

上面的代码实现了一个简单的TCP/IP客户端，通过Socket连接到服务端指定主机和端口，并发送消息，等待服务器的响应，并返回响应给调用者。

示例说明

下面是一个简单的示例说明如何使用上面的代码实现一个主从分布式系统。

假设我们需要将某个磁盘目录中的文件列表发给所有从节点进行处理，然后将返回的处理结果汇总到主节点，并打印到控制台上。

1. 主节点代码实现

from server import Server
import threading

class Master(Server):
    def __init__(self, host, port):
        super(Master, self).__init__(host, port)
        self.slaves = []

    def add_slave(self, slave):
        self.slaves.append(slave)

    def send_file_list(self):
        files = ["file1.txt", "file2.txt", "file3.txt"]
        message = "\n".join(files)
        for slave in self.slaves:
            slave.send_message(message)

    def collect_results(self):
        results = []
        for slave in self.slaves:
            result = slave.recv_message()
            results.append(result)
        print("\n\nResults:\n")
        print("\n".join(results))

if __name__ == "__main__":
    master = Master("localhost", 12345)
    print("Master is running...")
    while True:
        slave_addr = input("Enter slave node address (host:port): ")
        if not slave_addr:
            break
        host, port = slave_addr.split(":")
        slave = Client(host, int(port))
        master.add_slave(slave)
    print(f"Master has {len(master.slaves)} slaves")
    master.send_file_list()
    master.collect_results()

上面的代码实现了一个Master类，继承自Server类，重载了run方法，以便在启动的时候开始监听客户端连接。它有两个额外的方法，add_slave用于添加从节点，send_file_list用于将文件列表发送给所有从节点，collect_results用于从所有从节点收集结果，并汇总到一个列表中，最后打印出来。

2. 从节点代码实现

from client import Client

class Slave(Client):
    def __init__(self, host, port):
        super(Slave, self).__init__(host, port)

    def process_file_list(self, file_list):
        return [f"processed {file}" for file in file_list]

if __name__ == "__main__":
    slave = Slave("localhost", 12345)
    print("Slave is running...")
    message = slave.recv_message()
    file_list = message.split("\n")
    results = slave.process_file_list(file_list)
    response_message = "\n".join(results)
    slave.send_message(response_message)

上面的代码实现了一个Slave类，继承自Client类，重载了run方法，用于在启动的时候连接Master节点，并等待Master发送的文件列表。它还有一个process_file_list方法，用于处理文件列表，返回结果列表。最后，它将处理后的结果返回给Master。

3. 运行流程

我们可以运行Master节点，它会等待用户输入从节点地址，可以输入多个从节点地址，用于启动多个从节点。

> python master.py

Master is running...
Enter slave node address (host:port): localhost:23456
Enter slave node address (host:port):
Master has 1 slaves

然后，我们可以运行一个或多个Slave节点：

> python slave.py

Slave is running...

当Slave节点启动后，Master节点会发送文件列表给它，Slave节点会开始处理文件列表，并将处理结果返回给Master节点。

完成后，Master节点会收集所有从节点的结果，并打印在控制台上。

结论

本文讲解了Python实现自定义主从分布式架构的完整攻略，包括了服务端和客户端代码实现，以及一个简单的示例说明如何使用这些代码来实现一个主从分布式系统。通过这个例子，我们可以更加深入地理解主从分布式架构的原理，并学会如何使用Python来实现它。