Question

我正在使用pyxs Python Xenstore客户端模块编写Upstart守护程序，该守护程序监视盒子上GPIO控制器上的一堆输出引脚。启动后，守护程序的基本结构是导出相关引脚，为引脚添加相应的Xenstore路径，以及为每个Xenstore路径添加和监视监视。手表部分是线程化的 - 对于每个手表，使用目标工人方法创建一个线程，该方法监视手表的变化。根据PyXS文档，您基本上必须执行以下操作：

# monitor is a pyxs.client.Client.Monitor object, and watch adds a
# watch to the given path
monitor.watch(path, path_token)
# wait for events on the watched path - returns a pair if there is an
# event, the first is the event path and the second is the path token
monitor.wait(sleep=...)

我的问题是，如果没有指定wait参数，对sleep=<time>的调用是否会阻止 - 从PyXS文档中不清楚是否是这种情况。

代码大致是这样的：

from pyxs.client import Client
from pyxs.exceptions import PyXSError
from threading import Thread

...
class gpiod(object):

    def __init__(self,...):
        ...
        # stores pin numbers using descriptive labels as keys
        self._gpio_pins = {}
        # stores Xenstore paths for the pins, using the pin labels as keys
        self._xenstore_paths = {}
        self._xenstore_client = Client()
        self._xenstore_monitor = self._xenstore_client.monitor()
        # stores threads that monitor the watches added for the paths
        self._xenstore_watchers = {}

        self.start()
        self.run()

    def _watch_xenstore_path(self, watch_path):
    """
    A worker method that is a target for a watch thread.
    """
        while True:
            try:
                path_change = self._xenstore_monitor.wait(sleep=1)
                while not path_change:
                    path_change = self._xenstore_monitor.wait(sleep=1)
                if path_change[0] == watch_path:
                # write changed value to the pin
           except PyXSError as e:
                # log the error

    def start(self):
        # load config
        ...
        # export relevant GPIO output pins (using system calls to sysfs)
        ...
        # create Xenstore paths using _xenstore_client
        ...
        # set watches on the paths
        for path in self._xenstore_paths:
            self._xenstore_monitor.watch(wpath=path, token=path)
            self._xenstore_watchers.update(
                {pin_label: Thread(target=self._watch_xenstore_path, args=(path,))}
            )

    def run(self):
        for watcher in self._xenstore_watchers:
            watcher.start()

Answer 1

来自pyxs文档：

wait(sleep=None)

等待任何观察路径生成事件，该事件是（路径，令牌）对，其中第一个元素是事件路径，即   已修改的实际路径和第二个元素是传递给的标记   手表（）。       参数：sleep（float） - 事件检查之间休眠的秒数。

这意味着，sleep参数实际上是对wait方法的检查进行分离，如果从github查看code：

def wait(self, sleep=None):
    """Waits for any of the watched paths to generate an event,
    which is a ``(path, token)`` pair, where the first element
    is event path, i.e. the actual path that was modified and
    second element is a token, passed to the :meth:`watch`.
    :param float sleep: number of seconds to sleep between event
                        checks.
    """
    while True:
        if self.client.events:
            packet = self.client.events.popleft()
            return Event(*packet.payload.split("\x00")[:-1])

        # Executing a noop, hopefuly we'll get some events queued
        # in the meantime. Note: I know it sucks, but it seems like
        # there's no other way ...
        self.client.execute_command(Op.DEBUG, "")

        if sleep is not None: #sleep here is to provide tap gap between event check
            time.sleep(sleep)

您会看到sleep参数仅用于在事件检查之间提供分流间隔，因为while True循环一直持续到您获得联合event或者您想要：多快要检查event，sleep越小，定期检查的速度就越快。

所以，最后：

对wait方法的调用已经阻止，sleep只是为event次检查提供时间隔离。

Python守护程序使用pyx监视GPIO引脚Xenstore客户端

1 个答案: