在reactor.run()之后向twisted ssh提供命令的合理方法

发布于 2024-09-06 21:28:25 字数 376 浏览 6 评论 0原文

伙计们，这是一个关于 python twins ssh lib 的问题。

我看到的所有示例代码甚至是基于twisted.conch.ssh作为ssh客户端的生产代码都是以这样的模式与服务器交互：

准备一些远程运行的命令；
定义回调；
启动反应堆然后暂停以获得新的反馈；

在reactor.run()之后，我从未发现有人尝试向sshd传递命令，脚本只是等待。我认为可以分叉或生成东西来发送命令。然而，由于twisted的优势之一是它的多路分解机制，因此它在作为服务器运行时不必分叉来处理传入的请求。我可以说不分叉（作为客户端脚本）不断向服务器发送请求是合理的要求吗？

对此有什么想法吗？

TIA。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

月亮是我掰弯的 2024-09-13 21:28:25

joefis的回答基本上是合理的，但我打赌一些例子会有所帮助。首先，有几种方法可以让一些代码在反应器启动后立即运行。

这个非常简单：

def f():
    print "the reactor is running now"

reactor.callWhenRunning(f)

另一种方法是使用定时事件，尽管可能没有理由这样做而不是使用 callWhenRunning：

reactor.callLater(0, f)

您还可以使用 callWhenRunning 的底层 API code> 的实现方式是：

reactor.addSystemEventTrigger('after', 'startup', f)

还可以使用服务。这有点复杂，因为它涉及使用 twistd(1) （或其他将服务系统连接到反应器的东西）。但是你可以这样编写一个类：

from twisted.application.service import Service

class ThingDoer(Service):
    def startService(self):
        print "The reactor is running now."

然后像这样编写一个 .tac 文件：

from twisted.application.service import Application

from thatmodule import ThingDoer

application = Application("Do Things")
ThingDoer().setServiceParent(application)

最后，你可以使用 twistd(1) 运行这个 .tac 文件：

$ twistd -ny thatfile.tac

当然，这只是告诉你如何做在反应堆运行后做一件事，这不完全是你所要求的。不过，这是相同的想法 - 您定义一些事件处理程序并要求通过调用该处理程序来接收事件；当它被调用时，你就可以做一些事情。同样的想法也适用于您使用 Conch 所做的任何事情。

您可以在 Conch 示例中看到这一点，例如在 sshsimpleclient.py 中我们有：

class CatChannel(channel.SSHChannel):
    name = 'session'

    def openFailed(self, reason):
        print 'echo failed', reason

    def channelOpen(self, ignoredData):
        self.data = ''
        d = self.conn.sendRequest(self, 'exec', common.NS('cat'), wantReply = 1)
        d.addCallback(self._cbRequest) 

    def _cbRequest(self, ignored):
        self.write('hello conch\n')
        self.conn.sendEOF(self)

    def dataReceived(self, data):
        self.data += data

    def closed(self):
        print 'got data from cat: %s' % repr(self.data)
        self.loseConnection()
        reactor.stop()

在此示例中，channelOpen 是打开新通道时调用的事件处理程序。它向服务器发送请求。它返回一个 Deferred，并附加一个回调。该回调是一个事件处理程序，当请求成功时（在本例中，当 cat 被执行时）将被调用。 _cbRequest 是它附加的回调，该方法执行下一步 - 向通道写入一些字节，然后关闭它。然后是 dataReceived 事件处理程序，当通过通道接收到字节时调用该事件处理程序，以及关闭通道时调用的 close 事件处理程序。

因此，您可以在这里看到四个不同的事件处理程序，其中一些正在启动操作，最终将触发稍后的事件处理程序。

因此，回到关于做一件又一件事情的问题，如果您想打开两个猫通道，一个接一个，那么在 close 事件处理程序中可以打开一个新通道（而不是停止反应器，如本例所示）。

joefis' answer is basically sound, but I bet some examples would be helpful. First, there are a few ways you can have some code run right after the reactor starts.

This one is pretty straightforward:

def f():
    print "the reactor is running now"

reactor.callWhenRunning(f)

Another way is to use timed events, although there's probably no reason to do it this way instead of using callWhenRunning:

reactor.callLater(0, f)

You can also use the underlying API which callWhenRunning is implemented in terms of:

reactor.addSystemEventTrigger('after', 'startup', f)

You can also use services. This is a bit more involved, since it involves using using twistd(1) (or something else that's going to hook the service system up to the reactor). But you can write a class like this:

from twisted.application.service import Service

class ThingDoer(Service):
    def startService(self):
        print "The reactor is running now."

And then write a .tac file like this:

from twisted.application.service import Application

from thatmodule import ThingDoer

application = Application("Do Things")
ThingDoer().setServiceParent(application)

And finally, you can run this .tac file using twistd(1):

$ twistd -ny thatfile.tac

Of course, this only tells you how to do one thing after the reactor is running, which isn't exactly what you're asking. It's the same idea, though - you define some event handler and ask to receive an event by having that handler called; when it is called, you get to do stuff. The same idea applies to anything you do with Conch.

You can see this in the Conch examples, for example in sshsimpleclient.py we have:

class CatChannel(channel.SSHChannel):
    name = 'session'

    def openFailed(self, reason):
        print 'echo failed', reason

    def channelOpen(self, ignoredData):
        self.data = ''
        d = self.conn.sendRequest(self, 'exec', common.NS('cat'), wantReply = 1)
        d.addCallback(self._cbRequest) 

    def _cbRequest(self, ignored):
        self.write('hello conch\n')
        self.conn.sendEOF(self)

    def dataReceived(self, data):
        self.data += data

    def closed(self):
        print 'got data from cat: %s' % repr(self.data)
        self.loseConnection()
        reactor.stop()

In this example, channelOpen is the event handler called when a new channel is opened. It sends a request to the server. It gets back a Deferred, to which it attaches a callback. That callback is an event handler which will be called when the request succeeds (in this case, when cat has been executed). _cbRequest is the callback it attaches, and that method takes the next step - writing some bytes to the channel and then closing it. Then there's the dataReceived event handler, which is called when bytes are received over the chnanel, and the closed event handler, called when the channel is closed.

So you can see four different event handlers here, some of which are starting operations that will eventually trigger a later event handler.

So to get back to your question about doing one thing after another, if you wanted to open two cat channels, one after the other, then in the closed event handler could open a new channel (instead of stopping the reactor as it does in this example).

回复收藏 0 原文