kanes

# zmq_server.py - ZeroMQリクエスト応答モードのサーバー側

import zmq
import time

# 1. ZeroMQ Contextオブジェクトを作成
# ContextはZeroMQ実行環境の管理者
context = zmq.Context()

# 2. REP（Reply）ソケットを作成
# REPソケットはリクエストを受信し、応答を送信するために使用されます
socket = context.socket(zmq.REP)

# 3. ソケットをアドレスにバインド
# "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.send_string(reply_message)
        print(f"応答を送信: '{reply_message}'")

except KeyboardInterrupt:
    print("\nCtrl+Cが検出されました。サーバーをシャットダウンしています...")
finally:
    # ZeroMQリソースをクリーンアップ
    socket.close()
    context.term()
    print("サーバーが安全にシャットダウンしました。")

# zmq_client.py - ZeroMQリクエスト応答モードのクライアント

import zmq

# 1. ZeroMQ Contextオブジェクトを作成
context = zmq.Context()

# 2. REQ（Request）ソケットを作成
# REQソケットはリクエストを送信し、応答を受信するために使用されます
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ソケットはリクエストを送信した後、応答を待つ必要があり、連続してリクエストを送信できません
        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("\nCtrl+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ワーカーコルーチン（同一プロセス内で実行）
async def async_rep_worker(context: azmq.Context):
    # 渡された非同期コンテキストからREPソケットを作成
    socket = context.socket(zmq.REP)
    # inprocアドレスにバインド
    socket.bind(INPROC_ADDRESS)
    print(f"REPワーカー（プロセス内）が起動しました。バインド先: {INPROC_ADDRESS}")

    try:
        while True:
            # 非同期でリクエストを受信
            message = await socket.recv_string()
            print(f"REPワーカー（プロセス内）がリクエストを受信: '{message}'")

            # 処理のシミュレーション
            await asyncio.sleep(0.5)

            reply = f"REPワーカー（プロセス内）が受信し処理しました: '{message}'"
            # 非同期で応答を送信
            await socket.send_string(reply)
            print(f"REPワーカー（プロセス内）が応答を送信: '{reply}'")

    except asyncio.CancelledError:
        print("\nREPワーカー（プロセス内）がキャンセルされました。終了しています...")
    finally:
        socket.close()
        print("REPワーカー（プロセス内）のソケットが閉じられました。")


# 非同期REQクライアントコルーチン（同一プロセス内で実行）
async def async_req_client(context: azmq.Context):
     # 渡された非同期コンテキストからREQソケットを作成
    socket = context.socket(zmq.REQ)
    # inprocアドレスに接続（注意：このアドレスは同一プロセス内で既にバインドされている必要があります）
    socket.connect(INPROC_ADDRESS)
    print(f"REQクライアント（プロセス内）が起動しました。接続先: {INPROC_ADDRESS}")

    try:
        for i in range(3):
            request = f"プロセス内リクエスト {i+1}"
            print(f"REQクライアント（プロセス内）がリクエストを送信: '{request}'")
            # 非同期でリクエストを送信
            await socket.send_string(request)

            # 非同期で応答を受信
            reply = await socket.recv_string()
            print(f"REQクライアント（プロセス内）が応答を受信: '{reply}'")
            await asyncio.sleep(0.1) # 次のリクエストを送信する前に少し待機
            
    finally:
        socket.close()
        print("REQクライアント（プロセス内）のソケットが閉じられました。")

# メイン非同期関数、ワーカーとクライアントコルーチンを起動および管理
async def main():
    # メイン関数内で唯一の非同期コンテキストを作成
    # このコンテキストは、inproc通信を介してすべてのソケットを作成するために使用されます
    context = azmq.Context()
    print("メインプログラム: Asyncioコンテキストが作成されました")

    # asyncio.create_taskを使用してワーカーとクライアントコルーチンを起動
    # これらは同一のイベントループ、同一プロセス内で並行して実行されます
    worker_task = asyncio.create_task(async_rep_worker(context))
    client_task = asyncio.create_task(async_req_client(context))

    # クライアントタスクがリクエストを完了するのを待機
    await client_task
    print("メインプログラム: クライアントタスクが完了しました。")

    # クライアントタスクが完了した後、ワーカータスクをキャンセルして終了します
    worker_task.cancel()
    try:
        await worker_task # ワーカータスクがキャンセル信号に応答するのを待機
    except asyncio.CancelledError:
        print("メインプログラム: ワーカータスクがキャンセルされました。")

    # コンテキストのクリーンアップは通常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）例が終了しました ---")