Gecko [ oric.aiou.edu.pk ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
iocpreactor	[ DIR ]	drwxr-xr-x
test	[ DIR ]	drwxr-xr-x
__init__.py	521 B	-rw-r--r--
_baseprocess.py	1.87 KB	-rw-r--r--
_dumbwin32proc.py	12.8 KB	-rw-r--r--
_glibbase.py	12.51 KB	-rw-r--r--
_idna.py	1.36 KB	-rw-r--r--
_newtls.py	9.11 KB	-rw-r--r--
_pollingfile.py	8.77 KB	-rw-r--r--
_posixserialport.py	1.95 KB	-rw-r--r--
_posixstdio.py	4.58 KB	-rw-r--r--
_producer_helpers.py	3.7 KB	-rw-r--r--
_resolver.py	8.33 KB	-rw-r--r--
_signals.py	2.65 KB	-rw-r--r--
_sslverify.py	70.09 KB	-rw-r--r--
_threadedselect.py	11.49 KB	-rw-r--r--
_win32serialport.py	4.63 KB	-rw-r--r--
_win32stdio.py	3.13 KB	-rw-r--r--
abstract.py	18.82 KB	-rw-r--r--
address.py	5.12 KB	-rw-r--r--
asyncioreactor.py	10.31 KB	-rw-r--r--
base.py	43.22 KB	-rw-r--r--
cfreactor.py	17.09 KB	-rw-r--r--
default.py	1.9 KB	-rw-r--r--
defer.py	69.52 KB	-rw-r--r--
endpoints.py	75.4 KB	-rw-r--r--
epollreactor.py	8.29 KB	-rw-r--r--
error.py	12.35 KB	-rw-r--r--
fdesc.py	3.15 KB	-rw-r--r--
gireactor.py	5.98 KB	-rw-r--r--
glib2reactor.py	1.09 KB	-rw-r--r--
gtk2reactor.py	3.53 KB	-rw-r--r--
gtk3reactor.py	2.2 KB	-rw-r--r--
inotify.py	14.35 KB	-rw-r--r--
interfaces.py	94.25 KB	-rw-r--r--
kqreactor.py	10.05 KB	-rw-r--r--
main.py	1.03 KB	-rw-r--r--
pollreactor.py	5.88 KB	-rw-r--r--
posixbase.py	25.74 KB	-rw-r--r--
process.py	37.98 KB	-rw-r--r--
protocol.py	26.5 KB	-rw-r--r--
pyuisupport.py	817 B	-rw-r--r--
reactor.py	1.82 KB	-rw-r--r--
selectreactor.py	6.07 KB	-rw-r--r--
serialport.py	2.26 KB	-rw-r--r--
ssl.py	8.25 KB	-rw-r--r--
stdio.py	1.02 KB	-rw-r--r--
task.py	30.39 KB	-rw-r--r--
tcp.py	53.62 KB	-rw-r--r--
threads.py	3.86 KB	-rw-r--r--
tksupport.py	2 KB	-rw-r--r--
udp.py	18.13 KB	-rw-r--r--
unix.py	21.45 KB	-rw-r--r--
utils.py	7.69 KB	-rw-r--r--
win32eventreactor.py	14.84 KB	-rw-r--r--
wxreactor.py	5.14 KB	-rw-r--r--
wxsupport.py	1.33 KB	-rw-r--r--

Code Editor : _pollingfile.py

# -*- test-case-name: twisted.internet.test.test_pollingfile -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Implements a simple polling interface for file descriptors that don't work with
select() - this is pretty much only useful on Windows.
"""

from __future__ import absolute_import, division

from zope.interface import implementer
from twisted.internet.interfaces import IConsumer, IPushProducer
from twisted.python.compat import unicode

MIN_TIMEOUT = 0.000000001
MAX_TIMEOUT = 0.1

class _PollableResource:
    active = True

def activate(self):
        self.active = True

def deactivate(self):
        self.active = False

class _PollingTimer:
    # Everything is private here because it is really an implementation detail.

def __init__(self, reactor):
        self.reactor = reactor
        self._resources = []
        self._pollTimer = None
        self._currentTimeout = MAX_TIMEOUT
        self._paused = False

def _addPollableResource(self, res):
        self._resources.append(res)
        self._checkPollingState()

def _checkPollingState(self):
        for resource in self._resources:
            if resource.active:
                self._startPolling()
                break
        else:
            self._stopPolling()

def _startPolling(self):
        if self._pollTimer is None:
            self._pollTimer = self._reschedule()

def _stopPolling(self):
        if self._pollTimer is not None:
            self._pollTimer.cancel()
            self._pollTimer = None

def _pause(self):
        self._paused = True

def _unpause(self):
        self._paused = False
        self._checkPollingState()

def _reschedule(self):
        if not self._paused:
            return self.reactor.callLater(self._currentTimeout, self._pollEvent)

def _pollEvent(self):
        workUnits = 0.
        anyActive = []
        for resource in self._resources:
            if resource.active:
                workUnits += resource.checkWork()
                # Check AFTER work has been done
                if resource.active:
                    anyActive.append(resource)

newTimeout = self._currentTimeout
        if workUnits:
            newTimeout = self._currentTimeout / (workUnits + 1.)
            if newTimeout < MIN_TIMEOUT:
                newTimeout = MIN_TIMEOUT
        else:
            newTimeout = self._currentTimeout * 2.
            if newTimeout > MAX_TIMEOUT:
                newTimeout = MAX_TIMEOUT
        self._currentTimeout = newTimeout
        if anyActive:
            self._pollTimer = self._reschedule()

# If we ever (let's hope not) need the above functionality on UNIX, this could
# be factored into a different module.

import win32pipe
import win32file
import win32api
import pywintypes

@implementer(IPushProducer)
class _PollableReadPipe(_PollableResource):

def __init__(self, pipe, receivedCallback, lostCallback):
        # security attributes for pipes
        self.pipe = pipe
        self.receivedCallback = receivedCallback
        self.lostCallback = lostCallback

def checkWork(self):
        finished = 0
        fullDataRead = []

while 1:
            try:
                buffer, bytesToRead, result = win32pipe.PeekNamedPipe(self.pipe, 1)
                # finished = (result == -1)
                if not bytesToRead:
                    break
                hr, data = win32file.ReadFile(self.pipe, bytesToRead, None)
                fullDataRead.append(data)
            except win32api.error:
                finished = 1
                break

dataBuf = b''.join(fullDataRead)
        if dataBuf:
            self.receivedCallback(dataBuf)
        if finished:
            self.cleanup()
        return len(dataBuf)

def cleanup(self):
        self.deactivate()
        self.lostCallback()

def close(self):
        try:
            win32api.CloseHandle(self.pipe)
        except pywintypes.error:
            # You can't close std handles...?
            pass

def stopProducing(self):
        self.close()

def pauseProducing(self):
        self.deactivate()

def resumeProducing(self):
        self.activate()

FULL_BUFFER_SIZE = 64 * 1024

@implementer(IConsumer)
class _PollableWritePipe(_PollableResource):

def __init__(self, writePipe, lostCallback):
        self.disconnecting = False
        self.producer = None
        self.producerPaused = False
        self.streamingProducer = 0
        self.outQueue = []
        self.writePipe = writePipe
        self.lostCallback = lostCallback
        try:
            win32pipe.SetNamedPipeHandleState(writePipe,
                                              win32pipe.PIPE_NOWAIT,
                                              None,
                                              None)
        except pywintypes.error:
            # Maybe it's an invalid handle.  Who knows.
            pass

def close(self):
        self.disconnecting = True

def bufferFull(self):
        if self.producer is not None:
            self.producerPaused = True
            self.producer.pauseProducing()

def bufferEmpty(self):
        if self.producer is not None and ((not self.streamingProducer) or
                                          self.producerPaused):
            self.producer.producerPaused = False
            self.producer.resumeProducing()
            return True
        return False

# almost-but-not-quite-exact copy-paste from abstract.FileDescriptor... ugh

def registerProducer(self, producer, streaming):
        """Register to receive data from a producer.

This sets this selectable to be a consumer for a producer.  When this
        selectable runs out of data on a write() call, it will ask the producer
        to resumeProducing(). A producer should implement the IProducer
        interface.

FileDescriptor provides some infrastructure for producer methods.
        """
        if self.producer is not None:
            raise RuntimeError(
                "Cannot register producer %s, because producer %s was never "
                "unregistered." % (producer, self.producer))
        if not self.active:
            producer.stopProducing()
        else:
            self.producer = producer
            self.streamingProducer = streaming
            if not streaming:
                producer.resumeProducing()

def unregisterProducer(self):
        """Stop consuming data from a producer, without disconnecting.
        """
        self.producer = None

def writeConnectionLost(self):
        self.deactivate()
        try:
            win32api.CloseHandle(self.writePipe)
        except pywintypes.error:
            # OMG what
            pass
        self.lostCallback()

def writeSequence(self, seq):
        """
        Append a C{list} or C{tuple} of bytes to the output buffer.

@param seq: C{list} or C{tuple} of C{str} instances to be appended to
            the output buffer.

@raise TypeError: If C{seq} contains C{unicode}.
        """
        if unicode in map(type, seq):
            raise TypeError("Unicode not allowed in output buffer.")
        self.outQueue.extend(seq)

def write(self, data):
        """
        Append some bytes to the output buffer.

@param data: C{str} to be appended to the output buffer.
        @type data: C{str}.

@raise TypeError: If C{data} is C{unicode} instead of C{str}.
        """
        if isinstance(data, unicode):
            raise TypeError("Unicode not allowed in output buffer.")
        if self.disconnecting:
            return
        self.outQueue.append(data)
        if sum(map(len, self.outQueue)) > FULL_BUFFER_SIZE:
            self.bufferFull()

def checkWork(self):
        numBytesWritten = 0
        if not self.outQueue:
            if self.disconnecting:
                self.writeConnectionLost()
                return 0
            try:
                win32file.WriteFile(self.writePipe, b'', None)
            except pywintypes.error:
                self.writeConnectionLost()
                return numBytesWritten
        while self.outQueue:
            data = self.outQueue.pop(0)
            errCode = 0
            try:
                errCode, nBytesWritten = win32file.WriteFile(self.writePipe,
                                                             data, None)
            except win32api.error:
                self.writeConnectionLost()
                break
            else:
                # assert not errCode, "wtf an error code???"
                numBytesWritten += nBytesWritten
                if len(data) > nBytesWritten:
                    self.outQueue.insert(0, data[nBytesWritten:])
                    break
        else:
            resumed = self.bufferEmpty()
            if not resumed and self.disconnecting:
                self.writeConnectionLost()
        return numBytesWritten

${this.title}

Code Editor : _pollingfile.py