Ticket #598: nbs.py

#!/usr/bin/python2.4

import socket
import errno


class nbf(object):


        """non-blocking socket friendly file like object to WSGI spec PEP 333"""


        def __init__(self, socket):

                self._socket = socket
                self._rbuf = ''
                self._rsize = 8192


        def read(self, size=None):

                # self._socket.recv into the buffer
                # return at most size bytes from the buffer
                # if size is None, return data until EOF (connection close)

                pass


        def _readline_1(self, size=None):

                # size ignored - not supported according to PEP 333
                # should we raise an exception ? which one ?

                # approach #1: behave like blocking version of readline

                while True:
                        while True:
                                try:
                                        chunk = self._socket.recv(self._rsize)
                                        if not chunk:
                                                return ''
                                        self._rbuf += chunk
                                        break
                                except socket.timeout:
                                        pass
                        try:
                                eol = self._rbuf.index('\r\n')
                                line = self._rbuf[:eol]
                                self._rbuf = self._rbuf[eol+2:]
                                return line
                        except ValueError:
                                pass


        def _readline_2(self, size=None):

                # size ignored - not supported according to PEP 333
                # should we raise an exception ? which one ?

                # approach #2: timeouts are raised but we ensure buffering
                # of received data so that subsequent readline() invocations
                # pickup where the incoming data stream left off

                while True:
                        while True:
                                try:
                                        chunk = self._socket.recv(self._rsize)
                                        if not chunk:
                                                return ''
                                        self._rbuf += chunk
                                        break
                                except socket.timeout:
                                        raise
                        try:
                                eol = self._rbuf.index('\r\n')
                                line = self._rbuf[:eol]
                                self._rbuf = self._rbuf[eol+2:]
                                return line
                        except ValueError:
                                pass


        readline = _readline_2


        def readlines(self, hint=None):

                # ignore hint, according to PEP 333

                pass


        def __iter__(self):

                return self


        def next(self):

                # return readline() or StopIteration on connection close

                pass


        def flush(self):

                pass


        def write(self, str):

                pass


        def writelines(self, seq):

                pass



class nbs(socket.socket):

        def __init__(self, *args, **kwargs):

                socket.socket.__init__(self, *args, **kwargs)


        def accept(self, *args, **kwargs):

                c, a = socket.socket.accept(self, *args, **kwargs)
                return nbs(_sock=c), a


        def makefile(self, *args, **kwargs):

                return nbf(self)


        def sendall(self, buf):
                pending = len(buf)
                offset = 0
                while pending:
                        try:
                                sent = self.send(buf[offset:])
                                pending -= sent
                                offset += sent
                        except socket.error, e:
                                if e[0]!=errno.EAGAIN and e[0]!=errno.EWOULDBLOCK:
                                        raise


if __name__ == '__main__':

        s = nbs(socket.AF_INET, socket.SOCK_STREAM)
        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        s.bind(('',8080))
        s.listen(4)
        c,a = s.accept()
        c.settimeout(5)
        f = c.makefile()
        print "readline result:", f.readline().strip()
        c.sendall('got it\r\n')
        c.close()
        s.close()