Question

我有一个扭曲的反应堆侦听传入的数据。我有第二个反应堆在某些时间间隔内执行http请求，将结果发送到第一个反应堆。两者都运行正常。

现在我想把它放在一个反应堆中运行，但我不知道如何实现这个目标。类似的东西 - 每60秒执行一次http请求。在第一个听“主”反应堆内以异步的方式。

目前我所拥有的是：

# main reactor listening for incoming data forever
...
reactor.listenTCP(8123, TCPEventReceiverFactory())

http reactor使用twisted.internet.defer.DeferredSemaphore()执行多次http检查：

# create semaphore to manage the deferreds
semaphore = twisted.internet.defer.DeferredSemaphore(2)

# create a list with all urls to check
dl = list()
# append deferreds to list
for url in self._urls:
    # returns deferred
    dl.append(semaphore.run(self._getPage, url))

# get a DefferedList
dl = twisted.internet.defer.DeferredList(dl)
# add some callbacks for error handling
dl.addCallbacks(lambda x: reactor.stop(), self._handleError)

# start the reactor    
reactor.run()

如何将定时的http检查添加到“main”反应器中，以便它们以异步方式执行？ DeferredSemaphore如何正常工作？

任何人都可以帮我吗？

[这是一种处理http检查结果的轻量级监控系统。我是Twisted和异步编程的新手。我在Xubuntu 12.04上运行Python 2.7]

Answer 1

您不需要多个反应堆。只需使用同一个反应堆执行所有不同的操作。

如果你正在调用reactor.stop()，你可能会做错事，所以让我们摆脱它，把它全部绑定到一个函数（我们可以用作回调）;因为它正在进行异步工作，所以它也应该返回延迟，我们将使用你已经使用的DeferredList。

def thing_that_does_http():
    # create semaphore to manage the deferreds
    semaphore = twisted.internet.defer.DeferredSemaphore(2)

    # create a list with all urls to check
    dl = DeferredList()
    # append deferreds to list
    for url in self._urls:
        # returns deferred
        dl.append(semaphore.run(self._getPage, url))

    # get a DefferedList
    dl = twisted.internet.defer.DeferredList(dl)
    # add some callbacks for error handling
    dl.addErrback(self._handleError)
    return dl

“在某些时间间隔内执行 x ”的自然方式是使用循环调用。使用此回调函数，我们不需要做太多

reactor.listenTCP(8123, TCPEventReceiverFactory())
loop_http = twisted.intertnet.task.LoopingCall(thing_that_does_http)
# run once per minute, starting now.
loop_http.start(60)

如果你使用不同的反应堆，反应堆LoopingCall和getPage将用于它们自己的目的twisted.internet.reactor，例如，如果你正在进行单元测试，你将会需要覆盖该默认值。

对于LoopingCall，构建后非常简单（但在调用其start()方法之前），设置其clock属性：< / p>

from twisted.internet.task import Clock
fake_reactor = Clock()
loop_http.clock = fake_reactor
fake_reactor.advance(120)  # move time forward two minutes...

不幸的是，getPage()的情况不太好。您不能使用该接口的任何其他反应堆;你需要使用更新，更光亮的t.w.c.Agent。在许多方面Agent都是优越的，但当你只想将原始响应体作为字符串时，它并不那么方便。

除了要求将一个显式的反应器传递给它的构造函数之外，它更多地是关于请求/响应周期的细粒度控制，而不是getPage提供的便利。因此，它主要是根据Producer和Protocol来实现的。在前者的情况下，我们可以通过一个方便助手FileBodyProducer来发送请求主体，而不用大惊小怪;在后者中，我们需要一个简单的协议来缓冲所有数据块，直到我们完成所有数据。

这里有一大块代码可以替换getPage，大致相同的接口，但是以Agent的实例作为第一个参数

from cStringIO import StringIO
from twisted.internet.defer import Deferred
from twisted.internet.protocol import Protocol
from twisted.web.client import ResponseDone
from twisted.web.client import FileBodyProducer


class GetPageProtocol(Protocol):
    def __init__(self):
        self.deferred = Deferred()
        self.data = []

    def dataReceived(self, data):
        self.data.append(data)

    def connectionLost(self, reason):
        reason.trap(ResponseDone)
        data = ''.join(self.data)
        del self.data
        self.deferred.callback(data)


def agentGetPage(agent, url,
                 method="GET",
                 headers=None,
                 postdata=None):
    if postdata is not None:
        bodyProducer = FileBodyProducer(StringIO(postdata))
    else:
        bodyProducer = None

    def _getPageResponded(response):
        if response.length != 0:
            proto = GetPageProtocol()
            response.deliverBody(proto)
            return proto.deferred
        else:
            return None

    d = agent.request(method, url, headers, bodyProducer)
    d.addCallback(_getPageResponded)
    return d

，在单元测试中，看起来有点像：

from twisted.test.proto_helpers import MemoryReactor
from twisted.web.client import Agent
fake_reactor = MemoryReactor()
agent = Agent(fake_reactor)
d = agentGetPage(agent, "http://example.com")

assert fake_reactor.tcpClients  # or some such, exercise the code by manipulating the reactor

<子> 编辑：我最初想略过这个来给ectomorph，不要混淆;但是，在早期对反应堆进行适当处理并避免以后不必要的痛苦也是一个相当不错的主意。

扭曲/执行异步http请求

1 个答案: