Python ZeroMQ订阅服务器在unittest中不接收任何数据。为什么？

我无法理解我的数据最终会出现在哪里

我已经编写了一个测试，以确保我的

Publisher

类成功发送数据，并且如果绑定到该类，则会收到该数据

该类本身继承自

线程

，并公开了一个

publish（）

方法，我可以调用该方法通过

队列（）将要广播的数据传递给订阅者

然而，在我的测试中，数据从未到达。我已确保使用相同的
波特，我想不出还有什么问题

我是一个ZeroMQ新手，但我曾经设法让
PubSub
模式工作过

测试代码：

# Import Built-ins
import time
import json
import queue
from queue import Queue
from threading import Thread

# Import Third-Party
import zmq


def test_publisher_sends_data(self):
    port = 667
    name, topic, data = 'TestNode', 'testing', ['this', 'is', 'data']
    encoded_name = json.dumps(name).encode('utf-8')
    encoded_topic = json.dumps(topic).encode('utf-8')
    encoded_data = json.dumps(data).encode('utf-8')
    expected_result = (encoded_name, encoded_topic, encoded_data)

    publisher = Publisher(port)
    print("starting publisher")
    publisher.start()

    q = Queue()

    def recv(q):
        ctx = zmq.Context()
        zmq_sock = ctx.socket(zmq.SUB)
        print("Connecting to publisher")
        zmq_sock.connect('tcp://127.0.0.1:%s' % port)
        while True:
            print("waiting for data..")
            q.put(zmq_sock.recv_multipart())
            print("data received!")
    t = Thread(target=recv, args=(q,))
    t.start()

    print("sending data via publisher")
    for i in range(5):
        self.assertTrue(publisher.publish(name, topic, data))
        time.sleep(0.1)
    print("checking q for received data..")
    try:
        result = q.get(block=False)
    except queue.Empty:
        self.fail("Queue was empty, no data received!")
    self.assertEqual(expected_result, result)

Publisher
类

# Import Built-Ins
import logging
import json
from queue import Queue
from threading import Thread, Event

# Import Third-Party
import zmq


class Publisher(Thread):
    """Publisher Class which allows publishing data to subscribers.

    The publishing is realized with ZMQ Publisher sockets, and supports publishing
    to multiple subscribers.

    The run() method continuosly checks for data on the internal q, which is fed
    by the publish() method.

    """
    def __init__(self, port, *args, **kwargs):
        """Initialize Instance.
        :param port:
        """
        self.port = port
        self._running = Event()
        self.sock = None
        self.q = Queue()
        super(Publisher, self).__init__(*args, **kwargs)

    def publish(self, node_name, topic, data):
        """Publish the given data to all current subscribers.

        All parameters must be json-serializable objects
        :param data:
        :return:
        """
        message_parts = [json.dumps(param).encode('utf-8')
                         for param in (node_name, topic, data)]
        if self.sock:
            self.q.put(message_parts)
            return True
        else:
            return False

    def join(self, timeout=None):
        self._running.clear()
        try:
            self.sock.close()
        except Exception:
            pass
        super(Publisher, self).join(timeout)

    def run(self):
        self._running.set()
        ctx = zmq.Context()
        self.sock = ctx.socket(zmq.PUB)
        self.sock.bind("tcp://*:%s" % self.port)
        while self._running.is_set():
            if not self.q.empty():
                msg_parts = self.q.get(block=False)
                print("Sending data:", msg_parts)
                self.sock.send_multipart(msg_parts)
            else:
                continue
        ctx.destroy()
        self.sock = None

添加
.setsockopt（zmq.SUBSCRIBE，someNonZeroLengthSTRING）


作为

记录在案的默认
子
-套接字实例未订阅任何内容
（自然）
如果任何传入消息与任何字符串都不匹配，则订阅
SUB
-端，本地
.recv（）
自然不会收到此类消息

如果您的代码没有明确的订阅，那么就没有这样的消息，可以满足主题过滤器处理条件Q.E.D


最好的下一步：
接下来可能会发生另一个问题——“迟加入者”问题，如果unittest设计是闪电式快速的，那么我为您的进一步（不仅仅是ZeroMQ）分布式系统设计推荐的下一个最佳步骤是花时间阅读Pieter HINTJENS的书《代码连接，第1卷》。任何认真研究异构分布式系统信令/消息传递的人都将乐于分享技术和非技术方面的观点和意见。
感谢您推荐这本书！我会研究它。为了将来的参考，“代码连接”作为“0MG-指南”提供，有各种语言的大量示例或通过Wayback机器提供。我的意思是，这个PDF+one还可以享受附带的一套独特的、罐装的体验，几乎可以肯定，你可能会喜欢读它们。祝你好运，所有HFT的努力。有趣的是，罗琳女士改变了杰拉尔德·杜雷尔最初的说话包裹的意思。总之，GA研究建模座右铭让我完全（同上）“调整到非平稳”，主要是在非平稳领域，这是一个要点，不是吗？可能是一个公平的举动，以某种方式外交地提及公关/公关人员，以避免类似（几乎）无头的观点造成更多的附带损害。