Python 在twisted中，当cmd1进程位于twisted客户端上，而cmd2是服务器上的进程时，如何将cmd1的stdout传输到cmd2的stdin？

如何将一个spawnProcess的stdout连接到twisted中另一个spawnProcess的stdin，其中带stdout的spawnProcess位于客户端，stdin spawnProcess位于服务器上？bash中的CLI命令是

btrfs send@mysubvol | btrfs receive/some/path/

。使用

rfd，wrd=os.pipe（）

我成功地在服务器端将process1通过管道传输到process2。（现在我想用管道将其从客户端传输到服务器）。以下代码显示在同一侧管道上的进程：

以下代码

    from twisted.internet import protocol
from twisted.internet import reactor
import os


class Writer(protocol.ProcessProtocol):
    def connectionMade(self):
        print "Writer -- connection made"
        self.transport.closeChildFD(0)
    def childDataReceived(self, fd):
        pass
    def processEnded(self, status):
        pass


class Reader(protocol.ProcessProtocol):
    def __init__(self):
        pass
    def connectionMade(self):
        print "Reader -- connection made"
        pass
    def childDataReceived(self, fd):
        print "Reader -- childDataReceived"
    def processEnded(self, status):
        print "process ended, got:"

def test2():
    rfd, wfd = os.pipe()
    p1 = reactor.spawnProcess(Writer(), "btrfs", ["btrfs", "send", "/@mySubvol"],env=None, childFDs={0:"w", 1: wfd })
    p2 = reactor.spawnProcess(Reader(), "btrfs", ["btrfs", "receive", "/subvolContainer/"], env=None, childFDs={0: rfd, 1: "r"})
    os.close(rfd)
    os.close(wfd)
    reactor.run()
test2()

我试过：

server.py client.py 显然，我的尝试是错误的，因为服务器不知道客户端的标准输出管道，但我不知道如何将客户端的标准输出管道连接到服务器

---

更新01:

按照Jean Paul的回答，我在客户端和服务器上创建了两个协议（

ProcessProtocol

和

TCP协议

）。我可以成功地将快照从客户端发送到服务器。在客户机上，我必须用我的

TCP协议的实例启动
ProcessProtocol
，以便它们都相互连接。见：

client.py
server.py
不能在机器之间设置管道。你也不能在壳里做这件事。shell表达式：

btrfs send@mysubvol | btrfs receive/some/path/

在一台机器上运行两个
btrfs
进程，并用管道将它们连接起来

管道完全是本地的。它们不能跨机器共享。为此，你需要一些别的东西。例如，TCP连接

你已经朝着正确的方向迈出了几步。您的服务器启动TCP服务器。您的客户端尝试建立与该服务器的新连接

但是您的服务器没有定义任何处理它接受的连接的行为。当TCP连接不是进程时，您的客户端使用
ProcessProtocol
来定义其行为

您可能忽略了一个想法，即在您的客户机上，您将需要两个协议。一个协议连接到
btrfs send
进程并读取其标准输出。另一个协议连接到您的服务器，可以将
btrfs发送的
输出写入TCP连接

您的服务器还需要两个协议。其中一个处理来自客户端的连接，并读取客户端正在写入该连接的数据。另一个连接到
btrfs接收
进程，并将从TCP连接读取的数据写入该进程的stdin

您已经找到了
spawnProcess
的
childFDs
功能，这是一个很好的局部优化。虽然从技术上讲，您可以使用它来帮助您在两台不同的机器上连接两个进程，但它涉及到您可能不想麻烦的额外步骤（至少在您对“常规”转发器感到满意之前）

相反，您只需要一些协议，这些协议从设置发送端附近的对象接收数据（通过childDataReceived和dataReceived），并将数据传递给设置接收端附近的对象（通过transport.write）

from twisted.internet.protocol import Protocol, Factory, ClientFactory
from twisted.internet import protocol
from twisted.internet import reactor
import os


class Reader(protocol.ProcessProtocol):
    def __init__(self):
        pass
    def connectionMade(self):
        print "Reader -- connection made"
        pass
    def childDataReceived(self, fd):
        print "Reader -- childDataReceived"
    def processEnded(self, status):
        print "process ended, got:"


class EchoClientFactory(ClientFactory):
    protocol = Reader
    def clientConnectionFailed(self, connector, reason):
        print 'connection failed:', reason.getErrorMessage()
        reactor.stop()

    def clientConnectionLost(self, connector, reason):
        print 'connection lost:', reason.getErrorMessage()
        reactor.stop()

def main():
    f = Factory()
    reactor.listenTCP(8000, f)
    rfd = os.pipe()
    p2 = reactor.spawnProcess(Reader(), "btrfs", ["btrfs", "receive", "/"], env=None, childFDs={0: rfd, 1: "r"})
    os.close(rfd)
    reactor.run()
if __name__ == '__main__':
    main()

from twisted.internet import reactor
from twisted.internet import protocol
import sys
import os


class Writer(protocol.ProcessProtocol):
    def connectionMade(self):
        print "Writer -- connection made"
        self.transport.closeChildFD(0)
    def childDataReceived(self, fd):
        pass
    def processEnded(self, status):
        pass


class EchoClientFactory(protocol.ClientFactory):
    protocol = Writer
    def clientConnectionFailed(self, connector, reason):
        print 'connection failed:', reason.getErrorMessage()
        reactor.stop()

    def clientConnectionLost(self, connector, reason):
        print 'connection lost:', reason.getErrorMessage()
        reactor.stop()

def main():
    factory = EchoClientFactory()
    rfd, wfd = os.pipe()
    p1 = reactor.spawnProcess(Writer(), "btrfs", ["btrfs", "send", "/home/philipp/testEnv/a2a/@a2"], env=None, childFDs={0:"w", 1: wfd })
    reactor.connectTCP('localhost', 8000, factory)
    os.close(wfd)
    reactor.run()
if __name__ == '__main__':
    main()

    from twisted.internet.protocol import Protocol, Factory, ClientFactory, ProcessProtocol
from twisted.internet import reactor
import sys
import os


class Writer(Protocol):

    def connectionMade(self):  # Called when a connection is made
        print "connec made"
        proc = MyProcessProtocol(self)
        p1 = reactor.spawnProcess(proc, "btrfs", ["btrfs", "send", "/home/user/testEnv/a2a/@a2"])


class EchoClientFactory(ClientFactory):

    protocol = Writer

    def clientConnectionFailed(self, connector, reason):
        print 'connection failed:', reason.getErrorMessage()
        reactor.stop()

    def clientConnectionLost(self, connector, reason):
        print 'connection lost:', reason.getErrorMessage()
        reactor.stop()


class MyProcessProtocol(ProcessProtocol):
    def __init__(self, instance):
        self.w = instance

    def outReceived(self, data):  # Some data was received from stdout
        self.w.transport.write(data)  # Write some data to the physical connection, in sequence, in a non-blocking fashion


def main():
    factory = EchoClientFactory()
    reactor.connectTCP('localhost', 8000, factory)
    reactor.run()
if __name__ == '__main__':
    main()

    from twisted.internet.protocol import Protocol, Factory, ClientFactory, ProcessProtocol, ServerFactory
from twisted.internet import reactor
import os


class Reader(Protocol):

    def connectionMade(self):
        print "connected"
        self.r2 = Reader2()
        p1 = reactor.spawnProcess(self.r2, "btrfs", ["btrfs", "receive", "/"])

    def dataReceived(self, data):
        print "dataReceived"
        self.r2.transport.write(data)


class Reader2(ProcessProtocol):

    def connectionMade(self):
        print "connectionMade!"

    def processEnded(self, reason):
        print "quitting"


def main():
    f = ServerFactory()
    f.protocol = Reader
    reactor.listenTCP(8000, f)
    reactor.run()
if __name__ == '__main__':
    main()