kanes

# zmq_server.py - ZeroMQ 請求應答模式的服務器端

import zmq
import time

# 1. 創建 ZeroMQ Context 對象
# Context 是 ZeroMQ 運行時環境的管理者
context = zmq.Context()

# 2. 創建一個 REP (Reply) Socket
# REP Socket 用於接收請求並發送應答
socket = context.socket(zmq.REP)

# 3. 將 Socket 綁定到一個地址
# "tcp://*:5555" 表示使用 TCP 協議，綁定到所有可用網絡接口的 5555 端口
# "*" 表示綁定到所有本地地址，方便客戶端連接
bind_address = "tcp://localhost:5555"
socket.bind(bind_address)

print(f"ZeroMQ REP 服務器已啟動，綁定在 {bind_address}")
print("等待接收請求...")

try:
    # 服務器通常在一個無限循環中運行，不斷接收和處理請求
    while True:
        # 4. 接收請求
        # socket.recv_string() 會阻塞，直到收到一個字符串消息
        message = socket.recv_string()
        print(f"收到請求: '{message}'")

        # 模擬處理請求的過程
        time.sleep(1) # 假裝服務器需要處理一下

        # 5. 準備應答消息
        reply_message = f"服務器收到你的消息: '{message}'"

        # 6. 發送應答
        # socket.send_string() 會發送一個字符串應答
        # 在 REP-REQ 模式中，REP Socket 必須在發送應答前先接收一個請求
        socket.send_string(reply_message)
        print(f"發送應答: '{reply_message}'")

except KeyboardInterrupt:
    print("\n檢測到 Ctrl+C，正在關閉服務器...")
finally:
    # 清理 ZeroMQ 資源
    socket.close()
    context.term()
    print("服務器已安全關閉。")

# zmq_client.py - ZeroMQ 請求應答模式的客戶端

import zmq

# 1. 創建 ZeroMQ Context 對象
context = zmq.Context()

# 2. 創建一個 REQ (Request) Socket
# REQ Socket 用於發送請求並接收應答
socket = context.socket(zmq.REQ)

# 3. 連接到服務器的地址
# "tcp://localhost:5555" 表示使用 TCP 協議，連接到本地的 5555 端口
# 如果服務器在另一台機器上，請將 'localhost' 替換為服務器的實際 IP 地址
connect_address = "tcp://localhost:5555"
socket.connect(connect_address)

print(f"ZeroMQ REQ 客戶端已啟動，連接到 {connect_address}")
print("你可以輸入消息發送給服務器，輸入 'quit' 退出。")

try:
    # 客戶端通常在一個循環中運行，允許發送多條消息
    while True:
        # 獲取用戶輸入
        user_input = input("請輸入消息: ")

        # 檢查是否輸入 'quit'
        if user_input.lower() == 'quit':
            break

        # 4. 發送請求
        # socket.send_string() 會發送用戶輸入的字符串消息
        # 在 REQ-REP 模式中，REQ Socket 必須在發送請求後等待一個應答，不能連續發送請求
        print(f"發送請求: '{user_input}'")
        socket.send_string(user_input)

        # 5. 接收應答
        # socket.recv_string() 會阻塞，直到收到服務器的應答消息
        reply_message = socket.recv_string()
        print(f"收到應答: '{reply_message}'")
        print("-" * 20) # 分隔線

except KeyboardInterrupt:
    print("\n檢測到 Ctrl+C，正在關閉客戶端...")
finally:
    # 清理 ZeroMQ 資源
    socket.close()
    context.term()
    print("客戶端已安全關閉。")

# inproc_asyncio_example.py - 在同一個進程內使用 inproc:// 傳輸協議

import asyncio
import zmq
import zmq.asyncio as azmq # 使用異步版本

# 定義 inproc 地址
INPROC_ADDRESS = "inproc://my_async_channel"

# 異步 REP Worker 協程 (運行在同一個進程內)
async def async_rep_worker(context: azmq.Context):
    # 從傳入的異步 Context 創建 REP Socket
    socket = context.socket(zmq.REP)
    # 綁定到 inproc 地址
    socket.bind(INPROC_ADDRESS)
    print(f"REP Worker (進程內) 已啟動，綁定到 {INPROC_ADDRESS}")

    try:
        while True:
            # 異步接收請求
            message = await socket.recv_string()
            print(f"REP Worker (進程內) 收到請求: '{message}'")

            # 模擬處理
            await asyncio.sleep(0.5)

            reply = f"REP Worker (進程內) 收到並處理了: '{message}'"
            # 異步發送應答
            await socket.send_string(reply)
            print(f"REP Worker (進程內) 發送應答: '{reply}'")

    except asyncio.CancelledError:
        print("\nREP Worker (進程內) 被取消，正在退出...")
    finally:
        socket.close()
        print("REP Worker (進程內) Socket 已關閉。")


# 異步 REQ Client 協程 (運行在同一個進程內)
async def async_req_client(context: azmq.Context):
     # 從傳入的異步 Context 創建 REQ Socket
    socket = context.socket(zmq.REQ)
    # 連接到 inproc 地址 (注意：這個地址必須在同一個進程內已經被某個 socket 綁定了)
    socket.connect(INPROC_ADDRESS)
    print(f"REQ Client (進程內) 已啟動，連接到 {INPROC_ADDRESS}")

    try:
        for i in range(3):
            request = f"進程內請求 {i+1}"
            print(f"REQ Client (進程內) 發送請求: '{request}'")
            # 異步發送請求
            await socket.send_string(request)

            # 異步接收應答
            reply = await socket.recv_string()
            print(f"REQ Client (進程內) 收到應答: '{reply}'")
            await asyncio.sleep(0.1) # 稍微等一下再發下個請求
            
    finally:
        socket.close()
        print("REQ Client (進程內) Socket 已關閉。")

# 主異步函數，啟動和管理 Worker 和 Client 協程
async def main():
    # 在主函數中創建唯一一個異步 Context
    # 這個 Context 將用於創建所有需要通過 inproc 通信的 Socket
    context = azmq.Context()
    print("主程序: Asyncio Context 已創建")

    # 使用 asyncio.create_task 啟動 Worker 和 Client 協程
    # 它們將在同一個事件循環、同一個進程內並發運行
    worker_task = asyncio.create_task(async_rep_worker(context))
    client_task = asyncio.create_task(async_req_client(context))

    # 等待 Client 任務完成它的請求
    await client_task
    print("主程序: Client 任務完成。")

    # Client 任務完成後，取消 Worker 任務以退出
    worker_task.cancel()
    try:
        await worker_task # 等待 Worker 任務響應取消信號
    except asyncio.CancelledError:
        print("主程序: Worker 任務已被取消。")

    # Context 的清理通常由 asyncio.run() 負責，或者可以手動 context.term()
    # context.term() # 如果手動管理循環，需要 term

# 程序的入口點
if __name__ == "__main__":
    print("--- 進程內 ZeroMQ (inproc) 示例啟動 ---")
    # 使用 asyncio.run 運行主異步函數
    # 這將啟動事件循環，並在同一個進程中調度 worker_task 和 client_task
    asyncio.run(main())
    print("--- 進程內 ZeroMQ (inproc) 示例結束 ---")