如何用Python操作XML-RPC？分布式调用方案

# 解决方案：Python XML-RPC的客户端与服务器实现

# 客户端示例
import xmlrpc.client

def run_client():
    # 假设服务器运行在本地的8000端口
    try:
        # 创建一个ServerProxy对象，连接到XML-RPC服务器
        # 这里的URL指向服务器的地址
        with xmlrpc.client.ServerProxy("http://localhost:8000/") as proxy:
            print("尝试调用远程方法 'add'...")
            # 调用远程方法，就像调用本地函数一样
            result_add = proxy.add(5, 3)
            print(f"远程 'add(5, 3)' 的结果: {result_add}")

            print("\n尝试调用远程方法 'subtract'...")
            result_subtract = proxy.subtract(10, 4)
            print(f"远程 'subtract(10, 4)' 的结果: {result_subtract}")

            print("\n尝试调用远程方法 'get_server_time'...")
            server_time = proxy.get_server_time()
            print(f"远程 'get_server_time()' 的结果: {server_time}")

            print("\n尝试调用一个可能引发错误的方法 'divide_by_zero'...")
            try:
                proxy.divide_by_zero(10)
            except xmlrpc.client.Fault as e:
                print(f"客户端捕获到远程错误: Fault Code {e.faultCode}, Fault String: {e.faultString}")
            except ConnectionRefusedError:
                print("错误：无法连接到服务器，请确保服务器已启动。")
            except Exception as e:
                print(f"发生未知错误: {e}")

    except ConnectionRefusedError:
        print("错误：无法连接到XML-RPC服务器。请确保服务器正在运行并监听在正确的地址和端口。")
    except Exception as e:
        print(f"客户端运行时发生错误: {e}")

# 服务器示例
from xmlrpc.server import SimpleXMLRPCServer
from datetime import datetime

# 注册一个函数，作为远程可调用的方法
def add(x, y):
    print(f"服务器接收到 'add({x}, {y})' 请求。")
    return x + y

def subtract(x, y):
    print(f"服务器接收到 'subtract({x}, {y})' 请求。")
    return x - y

def get_server_time():
    print("服务器接收到 'get_server_time()' 请求。")
    return datetime.now().isoformat()

def divide_by_zero(x):
    print(f"服务器接收到 'divide_by_zero({x})' 请求。")
    # 故意制造一个错误
    return x / 0

def run_server():
    # 创建一个XML-RPC服务器实例
    # 第一个参数是服务器监听的地址和端口
    # allow_none=True 允许传递和返回None值，这在某些场景下很有用
    with SimpleXMLRPCServer(("localhost", 8000), allow_none=True) as server:
        print("XML-RPC服务器已启动，监听在 http://localhost:8000/")
        # 注册方法。方法名可以是任意字符串，这里我们直接用函数名
        server.register_function(add, "add")
        server.register_function(subtract, "subtract")
        server.register_function(get_server_time, "get_server_time")
        server.register_function(divide_by_zero, "divide_by_zero")

        # 注册一个实例的所有方法
        # class MyFunctions:
        #     def multiply(self, x, y):
        #         return x * y
        # server.register_instance(MyFunctions())

        # 启动服务器，开始处理请求
        # serve_forever() 会一直运行，直到程序被中断
        try:
            server.serve_forever()
        except KeyboardInterrupt:
            print("\n服务器已停止。")
        except Exception as e:
            print(f"服务器运行时发生错误: {e}")

# 如果需要同时运行，通常会在不同的终端启动客户端和服务器
# 或者使用多线程/多进程来管理
# if __name__ == '__main__':
#     # 通常，你会先运行服务器，再运行客户端
#     # 为了演示，这里可以简单地：
#     # 1. 在一个终端运行 run_server()
#     # 2. 在另一个终端运行 run_client()
#     print("请选择运行模式：'server' 或 'client'")
#     mode = input().strip().lower()
#     if mode == 'server':
#         run_server()
#     elif mode == 'client':
#         run_client()
#     else:
#         print("无效模式。")

# 实际使用时，通常会将客户端和服务器代码分开在不同的文件中。

# 服务器端
def safe_divide(x, y):
    if y == 0:
        # 直接抛出Python的ValueError，服务器会自动将其转换为Fault
        raise ValueError("除数不能为零！")
    return x / y

# 在服务器注册时：server.register_function(safe_divide, "divide")

# 客户端
import xmlrpc.client
import socket # 用于捕获更具体的网络错误

with xmlrpc.client.ServerProxy("http://localhost:8000/") as proxy:
    try:
        # 尝试调用一个可能出错的方法
        result = proxy.safe_divide(10, 0)
        print(f"结果: {result}")
    except xmlrpc.client.Fault as e:
        # 捕获XML-RPC Fault
        print(f"远程调用失败：错误码 {e.faultCode}, 错误信息: {e.faultString}")
        # 可以根据faultCode进行更细致的错误处理
        if e.faultCode == 1: # 假设1代表除零错误
            print("这是服务器端明确返回的除零错误。")
    except ConnectionRefusedError:
        # 服务器未启动或地址错误
        print("错误：无法连接到XML-RPC服务器。请检查服务器状态和地址。")
    except socket.timeout:
        # 连接超时
        print("错误：连接超时，服务器可能响应缓慢或网络问题。")
    except Exception as e:
        # 捕获其他未知错误
        print(f"发生未知错误: {type(e).__name__}: {e}")