Na}{

File Content: `_posixstdio.py`

# -*- test-case-name: twisted.test.test_stdio -*-

"""Standard input/out/err support.

Future Plans::

    support for stderr, perhaps
    Rewrite to use the reactor instead of an ad-hoc mechanism for connecting
        protocols to transport.

Maintainer: James Y Knight
"""

from zope.interface import implementer

from twisted.internet import process, error, interfaces
from twisted.python import log, failure


@implementer(interfaces.IAddress)
class PipeAddress(object):
    pass


@implementer(interfaces.ITransport, interfaces.IProducer,
             interfaces.IConsumer, interfaces.IHalfCloseableDescriptor)
class StandardIO(object):

    _reader = None
    _writer = None
    disconnected = False
    disconnecting = False

    def __init__(self, proto, stdin=0, stdout=1, reactor=None):
        if reactor is None:
            from twisted.internet import reactor
        self.protocol = proto

        self._writer = process.ProcessWriter(reactor, self, 'write', stdout)
        self._reader = process.ProcessReader(reactor, self, 'read', stdin)
        self._reader.startReading()
        self.protocol.makeConnection(self)

    # ITransport

    # XXX Actually, see #3597.
    def loseWriteConnection(self):
        if self._writer is not None:
            self._writer.loseConnection()

    def write(self, data):
        if self._writer is not None:
            self._writer.write(data)

    def writeSequence(self, data):
        if self._writer is not None:
            self._writer.writeSequence(data)

    def loseConnection(self):
        self.disconnecting = True

        if self._writer is not None:
            self._writer.loseConnection()
        if self._reader is not None:
            # Don't loseConnection, because we don't want to SIGPIPE it.
            self._reader.stopReading()

    def getPeer(self):
        return PipeAddress()

    def getHost(self):
        return PipeAddress()


    # Callbacks from process.ProcessReader/ProcessWriter
    def childDataReceived(self, fd, data):
        self.protocol.dataReceived(data)

    def childConnectionLost(self, fd, reason):
        if self.disconnected:
            return

        if reason.value.__class__ == error.ConnectionDone:
            # Normal close
            if fd == 'read':
                self._readConnectionLost(reason)
            else:
                self._writeConnectionLost(reason)
        else:
            self.connectionLost(reason)

    def connectionLost(self, reason):
        self.disconnected = True

        # Make sure to cleanup the other half
        _reader = self._reader
        _writer = self._writer
        protocol = self.protocol
        self._reader = self._writer = None
        self.protocol = None

        if _writer is not None and not _writer.disconnected:
            _writer.connectionLost(reason)

        if _reader is not None and not _reader.disconnected:
            _reader.connectionLost(reason)

        try:
            protocol.connectionLost(reason)
        except:
            log.err()

    def _writeConnectionLost(self, reason):
        self._writer=None
        if self.disconnecting:
            self.connectionLost(reason)
            return

        p = interfaces.IHalfCloseableProtocol(self.protocol, None)
        if p:
            try:
                p.writeConnectionLost()
            except:
                log.err()
                self.connectionLost(failure.Failure())

    def _readConnectionLost(self, reason):
        self._reader=None
        p = interfaces.IHalfCloseableProtocol(self.protocol, None)
        if p:
            try:
                p.readConnectionLost()
            except:
                log.err()
                self.connectionLost(failure.Failure())
        else:
            self.connectionLost(reason)

    # IConsumer
    def registerProducer(self, producer, streaming):
        if self._writer is None:
            producer.stopProducing()
        else:
            self._writer.registerProducer(producer, streaming)

    def unregisterProducer(self):
        if self._writer is not None:
            self._writer.unregisterProducer()

    # IProducer
    def stopProducing(self):
        self.loseConnection()

    def pauseProducing(self):
        if self._reader is not None:
            self._reader.pauseProducing()

    def resumeProducing(self):
        if self._reader is not None:
            self._reader.resumeProducing()

    def stopReading(self):
        """Compatibility only, don't use. Call pauseProducing."""
        self.pauseProducing()

    def startReading(self):
        """Compatibility only, don't use. Call resumeProducing."""
        self.resumeProducing()

Name	Size	Permission
__pycache__	---	0755
iocpreactor	---	0755
test	---	0755
__init__.py	521 bytes	0644
_baseprocess.py	1913 bytes	0644
_dumbwin32proc.py	13107 bytes	0644
_glibbase.py	12813 bytes	0644
_idna.py	1397 bytes	0644
_newtls.py	9332 bytes	0644
_pollingfile.py	8982 bytes	0644
_posixserialport.py	1995 bytes	0644
_posixstdio.py	4687 bytes	0644
_producer_helpers.py	3788 bytes	0644
_resolver.py	8530 bytes	0644
_signals.py	2718 bytes	0644
_sslverify.py	71770 bytes	0644
_threadedselect.py	11764 bytes	0644
_win32serialport.py	4744 bytes	0644
_win32stdio.py	3204 bytes	0644
abstract.py	19274 bytes	0644
address.py	5246 bytes	0644
asyncioreactor.py	10553 bytes	0644
base.py	44260 bytes	0644
cfreactor.py	17501 bytes	0644
default.py	1942 bytes	0644
defer.py	71193 bytes	0644
endpoints.py	77207 bytes	0644
epollreactor.py	8493 bytes	0644
error.py	12645 bytes	0644
fdesc.py	3223 bytes	0644
gireactor.py	6123 bytes	0644
glib2reactor.py	1115 bytes	0644
gtk2reactor.py	3614 bytes	0644
gtk3reactor.py	2252 bytes	0644
inotify.py	14691 bytes	0644
interfaces.py	96515 bytes	0644
kqreactor.py	10292 bytes	0644
main.py	1054 bytes	0644
pollreactor.py	6026 bytes	0644
posixbase.py	26357 bytes	0644
process.py	38896 bytes	0644
protocol.py	27134 bytes	0644
pyuisupport.py	817 bytes	0644
reactor.py	1863 bytes	0644
selectreactor.py	6215 bytes	0644
serialport.py	2317 bytes	0644
ssl.py	8444 bytes	0644
stdio.py	1045 bytes	0644
task.py	31119 bytes	0644
tcp.py	54908 bytes	0644
threads.py	3953 bytes	0644
tksupport.py	2045 bytes	0644
udp.py	18569 bytes	0644
unix.py	21965 bytes	0644
utils.py	7876 bytes	0644
win32eventreactor.py	15193 bytes	0644
wxreactor.py	5263 bytes	0644
wxsupport.py	1363 bytes	0644

File Content: _posixstdio.py

File Content: `_posixstdio.py`