Python+；ZMQ:在当前状态下无法完成操作

我试图让一个python程序使用请求-应答模式通过zeromq与另一个python程序通信。客户机程序应该向服务器程序发送一个请求，服务器程序会进行回复

我有两台服务器，当一台服务器出现故障时，另一台服务器接管。当第一台服务器工作时，通信工作正常，但是，当第一台服务器出现故障，并且当我向第二台服务器发出请求时，我看到错误：

zmp.error.ZMQError:无法在当前状态下完成操作

服务器1的代码：

# Run the server
while True:

    # Define the socket using the "Context"
    sock = context.socket(zmq.REP)
    sock.bind("tcp://127.0.0.1:5677")
    data = sock.recv().decode("utf-8")
    res = "Recvd"
    sock.send(res.encode('utf-8'))

服务器2的代码：

# Run the server
while True:

    # Define the socket using the "Context"
    sock = context.socket(zmq.REP)
    sock.bind("tcp://127.0.0.1:5877")
    data = sock.recv().decode("utf-8")
    res = "Recvd"
    sock.send(res.encode('utf-8'))

客户代码：

# ZeroMQ Context For distributed Message amogst processes
context = zmq.Context()
sock_1 = context.socket(zmq.REQ)
sock_2 = context.socket(zmq.REQ)
sock_1.connect("tcp://127.0.0.1:5677")
sock_2.connect("tcp://127.0.0.1:5877")

try:
    sock_1.send(data.encode('utf-8'), zmq.NOBLOCK)
    socks_1.setsockopt(zmq.RCVTIMEO, 1000)
    socks_1.setsockopt(zmq.LINGER, 0)
    data = socks_1.recv().decode('utf-8') #receive data from the main node  

except:
    try:
        #when server one fails
        sock_2.send(data.encode('utf-8'), zmq.NOBLOCK)
        socks_2.setsockopt(zmq.RCVTIMEO, 1000)
        socks_2.setsockopt(zmq.LINGER, 0)
        data = socks_2.recv().decode('utf-8')
    except Exception as e:
         print(str(e))

这种方法有什么问题？ 如何解决此问题？

Q:如何解决此问题？
A:避免已知的

REQ/REP

死锁风险！ 虽然ZeroMQ是一个功能强大的框架，但了解其内部组成对于分布式系统设计和原型设计是必要的

仔细观察后，使用通用的

REQ/REP

正式通信模式可能会（并且确实会）使对方处于相互的死锁中：一方期望另一方执行一个步骤，这是永远不会完成的，并且无法摆脱死锁状态

更多

下一步，故障转移系统必须在其自身组件的任何碰撞中幸存下来。因此，必须设计好分布式系统状态信令，并尽可能避免对元素FSA设计/步进/阻塞的依赖，否则，故障安全行为仍然只是一种幻觉

<强>始终< /强>小心处理资源，不要将ZrOMQ智能信令/消息组件看作任何类型的“可消耗的处置”，这样做可能在学者实例中被容忍，而不是在生产系统环境中。您仍然需要支付成本（时间、资源分配/取消分配/垃圾收集）。如评论中所述，在没有适当控制的情况下，绝不允许资源的创建/分配<代码>为True时：.socket（）。bind（）。send（）在原则上是严重错误的，并且会破坏设计的其余部分。

实现。在再次尝试发送消息之前，在捕获错误时从上下文创建一个新套接字

相当好的暴力解决方案是关闭并重新打开REQ 错误后的套接字

这是一个python示例

#
#   Author: Daniel Lundin <dln(at)eintr(dot)org>
#
from __future__ import print_function

import zmq

REQUEST_TIMEOUT = 2500
REQUEST_RETRIES = 3
SERVER_ENDPOINT = "tcp://localhost:5555"

context = zmq.Context(1)

print("I: Connecting to server…")
client = context.socket(zmq.REQ)
client.connect(SERVER_ENDPOINT)

poll = zmq.Poller()
poll.register(client, zmq.POLLIN)

sequence = 0
retries_left = REQUEST_RETRIES
while retries_left:
    sequence += 1
    request = str(sequence).encode()
    print("I: Sending (%s)" % request)
    client.send(request)

    expect_reply = True
    while expect_reply:
        socks = dict(poll.poll(REQUEST_TIMEOUT))
        if socks.get(client) == zmq.POLLIN:
            reply = client.recv()
            if not reply:
                break
            if int(reply) == sequence:
                print("I: Server replied OK (%s)" % reply)
                retries_left = REQUEST_RETRIES
                expect_reply = False
            else:
                print("E: Malformed reply from server: %s" % reply)

        else:
            print("W: No response from server, retrying…")
            # Socket is confused. Close and remove it.
            client.setsockopt(zmq.LINGER, 0)
            client.close()
            poll.unregister(client)
            retries_left -= 1
            if retries_left == 0:
                print("E: Server seems to be offline, abandoning")
                break
            print("I: Reconnecting and resending (%s)" % request)
            # Create new connection
            client = context.socket(zmq.REQ)
            client.connect(SERVER_ENDPOINT)
            poll.register(client, zmq.POLLIN)
            client.send(request)

context.term()

#
#作者：丹尼尔·伦丁
#
来自未来导入打印功能
导入zmq
请求超时=2500
请求重试次数=3次
服务器\u终结点=”tcp://localhost:5555"
context=zmq.context（1）
打印（“I:连接到服务器…”）
client=context.socket（zmq.REQ）
client.connect（服务器\终端）
poll=zmq.Poller（）
poll.register（客户端，zmq.POLLIN）
序列=0
重试次数\左=请求次数\重试次数
当重试离开时：
序列+=1
request=str（序列）.encode（）
打印（“I:发送（%s）”%请求）
客户端发送（请求）
expect\u reply=True
希望您回复：
socks=dict（poll.poll（请求超时））
如果socks.get（client）=zmq.POLLIN：
reply=client.recv（）
如果没有答复:
打破
如果int（reply）=序列：
打印（“I:服务器回复正常（%s）”%reply）
重试次数\左=请求次数\重试次数
expect\u reply=False
其他：
打印（“E:来自服务器%s的错误答复”%reply）
其他：
打印（“W:服务器没有响应，正在重试…”）
#套接字是混乱的。关闭并移除它。
client.setsockopt（zmq.LINGER，0）
client.close（）
轮询。取消注册（客户端）
重试次数\u左-=1
如果重试次数_left==0：
打印（“E:服务器似乎处于脱机状态，正在放弃”）
打破
打印（“I:重新连接并重新发送（%s）”%请求）
#创建新连接
client=context.socket（zmq.REQ）
client.connect（服务器\终端）
poll.register（客户端，zmq.POLLIN）
客户端发送（请求）
上下文。术语（）

在服务器端，“接收”和“发送”对至关重要。我遇到了一个类似的问题，而socket.send被错过了

def zmq_listen():
    global counter
    message = socket_.recv().decode("utf-8")
    logger.info(f"[{counter}] Message: {message}")
    request = json.loads(message)
    request["msg_id"] = f"m{counter}"
    ack = {"msg_id": request["msg_id"]}
    socket_.send(json.dumps(ack).encode("utf-8"))
    return request

---

为什么客户端和服务器都绑定到环回上的同一端口？这应该是连接吗？哦，对不起，在这里复制时出错了。已更正。第二个服务器套接字是否打开？当异常发生时，完整的堆栈回溯将有助于理解问题是的，第二个套接字正在运行，并且确实从客户端接收数据。问题是接收部分。堆栈跟踪指向以下行：data=socks_2.recv（）.decode（'utf-8'），然后指向main.socks_2 vs sock_2和socks_1 vs sock_1有什么区别？