我如何将cmd1的stdout输出到扭曲的cmd2的stdin中，其中cmd1进程在扭曲的客户端上，而cmd2是服务器上的进程？

Question

How do i connect the stdout of a spawnProcess to the stdin of another spawnProcess in twisted, where spawnProcess with the stdout is on the client and the stdin spawnprocess on the server? The CLI command in bash is btrfs send @mysubvol | btrfs receive /some/path/ btrfs send @mysubvol | btrfs receive /some/path/ . With rfd, wrd = os.pipe() I managed to pipe process1 to process2 on the server side. (Now I want to pipe it from the client to the server instead). Following code shows the processes piped on the same side:

Following code

    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()

I tried:

server.py

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()

client.py

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()

Obviously my attempt is wrong, because the server does not know about the client's stdout pipe, but I don't know how to pipe the client's spawnProcess stdout to the server.

---

Update 01:

Following Jean-Paul's answer I created two protocols on the client and server ( ProcessProtocol and TCP-Protocol on each side). I could successfully send a snapshot from the client to the server. On the client I had to start the ProcessProtocol with the instance of my TCP-Protocol , so that they are both interconnected. See: http://twistedmatrix.com/trac/wiki/FrequentlyAskedQuestions#HowdoImakeinputononeconnectionresultinoutputonanother

client.py

    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()

server.py

    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()

Answer 1

You cannot set up a pipe across machines. You can't do this in a shell either. The shell expression:

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

runs two btrfs processes on a single machine with a pipe connecting them.

Pipes are purely local. They cannot be shared across machines. For this, you need something else. For example, a TCP connection.

You have taken a couple steps in the right direction. Your server starts a TCP server. Your client attempts to establish a new connection to that server.

But your server doesn't define any behavior for handling connections it accepts. And your client uses a ProcessProtocol to define its behavior - when a TCP connection is not a process.

One idea you may have missed is that on your client you will need two protocols. One protocol is connected to the btrfs send process and reads its stdout. Another protocol is connected to your server and can write that btrfs send output to the TCP connection.

And your server will need two protocols as well. One of them handles the connection from the client and reads the data the client is writing to that connection. The other is connected to a btrfs receive process and writes the data read from the TCP connection to that process's stdin.

You've found the childFDs feature of spawnProcess which is a nice local optimization. And while you can technically use it to help you connect two processes on two different machines, it involves extra steps that you probably don't want to bother with (at least not until you're comfortable with a "regular" forwarder).

Instead, you just want a handful of protocols that receive data from objects nearer the sending side of your setup (via childDataReceived and dataReceived) and hand it off to objects nearer the receiving side of your setup (via transport.write).