Download Install Tutorial Docs FAQ Tools Wiki ∇ License Team IRC Planet Involvement Shop Book

Changeset 1914

Show
Ignore:
Timestamp:
03/10/08 11:42:58
Author:
lakin
Message:

Making a CP_fileobject to use instead of makefile

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/598-sendall/cherrypy/wsgiserver/__init__.py

    r1912 r1914  
    691691 
    692692 
    693 class SSL_fileobject(socket._fileobject): 
     693class CP_fileobject(socket._fileobject): 
    694694    """Faux file object attached to a socket object.""" 
     695 
     696    def recv(self, size): 
     697        return self._sock.recv(size) 
     698 
     699    def sendall(self, data): 
     700        """Sendall for non-blocking sockets.""" 
     701        while data: 
     702            try: 
     703                bytes_sent = self._sock.send(data) 
     704                data = data[bytes_sent:] 
     705            except socket.error, e: 
     706                if e.args[0] not in socket_errors_nonblocking: 
     707                    raise 
     708 
     709    def send(self, data): 
     710        return self._sock.send(data) 
     711     
     712    def flush(self): 
     713        if self._wbuf: 
     714            buffer = "".join(self._wbuf) 
     715            self._wbuf = [] 
     716            self.sendall(buffer) 
     717     
     718    def read(self, size=-1): 
     719        data = self._rbuf 
     720        if size < 0: 
     721            # Read until EOF 
     722            buffers = [] 
     723            if data: 
     724                buffers.append(data) 
     725            self._rbuf = "" 
     726            if self._rbufsize <= 1: 
     727                recv_size = self.default_bufsize 
     728            else: 
     729                recv_size = self._rbufsize 
     730             
     731            while True: 
     732                data = self.recv(recv_size) 
     733                if not data: 
     734                    break 
     735                buffers.append(data) 
     736            return "".join(buffers) 
     737        else: 
     738            # Read until size bytes or EOF seen, whichever comes first 
     739            buf_len = len(data) 
     740            if buf_len >= size: 
     741                self._rbuf = data[size:] 
     742                return data[:size] 
     743            buffers = [] 
     744            if data: 
     745                buffers.append(data) 
     746            self._rbuf = "" 
     747            while True: 
     748                left = size - buf_len 
     749                recv_size = max(self._rbufsize, left) 
     750                data = self.recv(recv_size) 
     751                if not data: 
     752                    break 
     753                buffers.append(data) 
     754                n = len(data) 
     755                if n >= left: 
     756                    self._rbuf = data[left:] 
     757                    buffers[-1] = data[:left] 
     758                    break 
     759                buf_len += n 
     760            return "".join(buffers) 
     761 
     762    def readline(self, size=-1): 
     763        data = self._rbuf 
     764        if size < 0: 
     765            # Read until \n or EOF, whichever comes first 
     766            if self._rbufsize <= 1: 
     767                # Speed up unbuffered case 
     768                assert data == "" 
     769                buffers = [] 
     770                while data != "\n": 
     771                    data = self.recv(1) 
     772                    if not data: 
     773                        break 
     774                    buffers.append(data) 
     775                return "".join(buffers) 
     776            nl = data.find('\n') 
     777            if nl >= 0: 
     778                nl += 1 
     779                self._rbuf = data[nl:] 
     780                return data[:nl] 
     781            buffers = [] 
     782            if data: 
     783                buffers.append(data) 
     784            self._rbuf = "" 
     785            while True: 
     786                data = self.recv(self._rbufsize) 
     787                if not data: 
     788                    break 
     789                buffers.append(data) 
     790                nl = data.find('\n') 
     791                if nl >= 0: 
     792                    nl += 1 
     793                    self._rbuf = data[nl:] 
     794                    buffers[-1] = data[:nl] 
     795                    break 
     796            return "".join(buffers) 
     797        else: 
     798            # Read until size bytes or \n or EOF seen, whichever comes first 
     799            nl = data.find('\n', 0, size) 
     800            if nl >= 0: 
     801                nl += 1 
     802                self._rbuf = data[nl:] 
     803                return data[:nl] 
     804            buf_len = len(data) 
     805            if buf_len >= size: 
     806                self._rbuf = data[size:] 
     807                return data[:size] 
     808            buffers = [] 
     809            if data: 
     810                buffers.append(data) 
     811            self._rbuf = "" 
     812            while True: 
     813                data = self.recv(self._rbufsize) 
     814                if not data: 
     815                    break 
     816                buffers.append(data) 
     817                left = size - buf_len 
     818                nl = data.find('\n', 0, left) 
     819                if nl >= 0: 
     820                    nl += 1 
     821                    self._rbuf = data[nl:] 
     822                    buffers[-1] = data[:nl] 
     823                    break 
     824                n = len(data) 
     825                if n >= left: 
     826                    self._rbuf = data[left:] 
     827                    buffers[-1] = data[:left] 
     828                    break 
     829                buf_len += n 
     830            return "".join(buffers) 
     831     
     832 
     833class SSL_fileobject(CP_fileobject): 
     834    """SSL file object attached to a socket object.""" 
    695835     
    696836    ssl_timeout = 3 
    …… 
    741881            if time.time() - start > self.ssl_timeout: 
    742882                raise socket.timeout("timed out") 
    743      
    744     def flush(self): 
    745         if self._wbuf: 
    746             buffer = "".join(self._wbuf) 
    747             self._wbuf = [] 
    748             self._safe_call(False, self._sock.sendall, buffer) 
    749      
    750     def read(self, size=-1): 
    751         data = self._rbuf 
    752         if size < 0: 
    753             # Read until EOF 
    754             buffers = [] 
    755             if data: 
    756                 buffers.append(data) 
    757             self._rbuf = "" 
    758             if self._rbufsize <= 1: 
    759                 recv_size = self.default_bufsize 
    760             else: 
    761                 recv_size = self._rbufsize 
    762              
    763             while True: 
    764                 data = self._safe_call(True, self._sock.recv, recv_size) 
    765                 if not data: 
    766                     break 
    767                 buffers.append(data) 
    768             return "".join(buffers) 
    769         else: 
    770             # Read until size bytes or EOF seen, whichever comes first 
    771             buf_len = len(data) 
    772             if buf_len >= size: 
    773                 self._rbuf = data[size:] 
    774                 return data[:size] 
    775             buffers = [] 
    776             if data: 
    777                 buffers.append(data) 
    778             self._rbuf = "" 
    779             while True: 
    780                 left = size - buf_len 
    781                 recv_size = max(self._rbufsize, left) 
    782                 data = self._safe_call(True, self._sock.recv, recv_size) 
    783                 if not data: 
    784                     break 
    785                 buffers.append(data) 
    786                 n = len(data) 
    787                 if n >= left: 
    788                     self._rbuf = data[left:] 
    789                     buffers[-1] = data[:left] 
    790                     break 
    791                 buf_len += n 
    792             return "".join(buffers) 
    793  
    794     def readline(self, size=-1): 
    795         data = self._rbuf 
    796         if size < 0: 
    797             # Read until \n or EOF, whichever comes first 
    798             if self._rbufsize <= 1: 
    799                 # Speed up unbuffered case 
    800                 assert data == "" 
    801                 buffers = [] 
    802                 while data != "\n": 
    803                     data = self._safe_call(True, self._sock.recv, 1) 
    804                     if not data: 
    805                         break 
    806                     buffers.append(data) 
    807                 return "".join(buffers) 
    808             nl = data.find('\n') 
    809             if nl >= 0: 
    810                 nl += 1 
    811                 self._rbuf = data[nl:] 
    812                 return data[:nl] 
    813             buffers = [] 
    814             if data: 
    815                 buffers.append(data) 
    816             self._rbuf = "" 
    817             while True: 
    818                 data = self._safe_call(True, self._sock.recv, self._rbufsize) 
    819                 if not data: 
    820                     break 
    821                 buffers.append(data) 
    822                 nl = data.find('\n') 
    823                 if nl >= 0: 
    824                     nl += 1 
    825                     self._rbuf = data[nl:] 
    826                     buffers[-1] = data[:nl] 
    827                     break 
    828             return "".join(buffers) 
    829         else: 
    830             # Read until size bytes or \n or EOF seen, whichever comes first 
    831             nl = data.find('\n', 0, size) 
    832             if nl >= 0: 
    833                 nl += 1 
    834                 self._rbuf = data[nl:] 
    835                 return data[:nl] 
    836             buf_len = len(data) 
    837             if buf_len >= size: 
    838                 self._rbuf = data[size:] 
    839                 return data[:size] 
    840             buffers = [] 
    841             if data: 
    842                 buffers.append(data) 
    843             self._rbuf = "" 
    844             while True: 
    845                 data = self._safe_call(True, self._sock.recv, self._rbufsize) 
    846                 if not data: 
    847                     break 
    848                 buffers.append(data) 
    849                 left = size - buf_len 
    850                 nl = data.find('\n', 0, left) 
    851                 if nl >= 0: 
    852                     nl += 1 
    853                     self._rbuf = data[nl:] 
    854                     buffers[-1] = data[:nl] 
    855                     break 
    856                 n = len(data) 
    857                 if n >= left: 
    858                     self._rbuf = data[left:] 
    859                     buffers[-1] = data[:left] 
    860                     break 
    861                 buf_len += n 
    862             return "".join(buffers) 
    863      
     883 
     884    def recv(self, *args, **kwargs): 
     885        return self._safe_call(True, super(SSL_fileobject, self).recv, *args, **kwargs) 
     886 
     887    def sendall(self, *args, **kwargs): 
     888        return self._safe_call(False, super(SSL_fileobject, self).sendall, *args, **kwargs) 
     889 
    864890    def send(self, *args, **kwargs): 
    865         return self._safe_call(False, self._sock.send, *args, **kwargs) 
     891        return self._safe_call(False, super(SSL_fileobject, self).send, *args, **kwargs) 
    866892 
    867893 
    …… 
    901927            self.send = self.rfile.send 
    902928        else: 
    903             self.rfile = sock.makefile("rb", self.rbufsize) 
     929            self.rfile = CP_fileobject(sock, "rb", self.rbufsize) 
    904930            self.send = sock.send 
    905931         

Hosted by WebFaction

Log in as guest/cpguest to create tickets