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

Changeset 2071

Show
Ignore:
Timestamp:
11/08/08 14:02:35
Author:
visteya
Message:

backport of [2063], [2069], and [2070], which are for ticket #837

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/cherrypy-3.1.x/cherrypy/test/test_core.py

    r2068 r2071  
    88import sys 
    99import types 
     10from httplib import IncompleteRead 
    1011 
    1112import cherrypy 
    …… 
    761762                # Under HTTP/1.1, the chunked transfer-coding is used. 
    762763                # The HTTP client will choke when the output is incomplete. 
    763                 self.assertRaises(ValueError, self.getPage, 
     764                self.assertRaises((ValueError, IncompleteRead), self.getPage, 
    764765                                  "/error/page_streamed") 
    765766             

  • branches/cherrypy-3.1.x/cherrypy/test/test_encoding.py

    r1993 r2071  
    22test.prefer_parent_path() 
    33 
     4import sys 
    45import gzip, StringIO 
     6from httplib import IncompleteRead 
    57import cherrypy 
    68europoundUnicode = u'\x80\xa3' 
    …… 
    161163            # The wsgiserver will simply stop sending data, and the HTTP client 
    162164            # will error due to an incomplete chunk-encoded stream. 
    163             self.assertRaises(ValueError, self.getPage, '/gzip/noshow_stream', 
     165            self.assertRaises((ValueError, IncompleteRead), self.getPage, 
     166                              '/gzip/noshow_stream', 
    164167                              headers=[("Accept-Encoding", "gzip")]) 
    165  
    166168 
    167169if __name__ == "__main__": 

  • branches/cherrypy-3.1.x/cherrypy/test/test_tools.py

    r1992 r2071  
    44import StringIO 
    55import sys 
     6from httplib import IncompleteRead 
    67import time 
    78timeout = 0.2 
    …… 
    273274            # started, and because it's chunked output, an error is raised by 
    274275            # the HTTP client when it encounters incomplete output. 
    275             self.assertRaises(ValueError, self.getPage, 
     276            self.assertRaises((ValueError, IncompleteRead), self.getPage, 
    276277                              "/demo/errinstream?id=5") 
    277278        # If this fails, then on_end_request isn't being called at all. 

  • branches/cherrypy-3.1.x/cherrypy/wsgiserver/__init__.py

    r2068 r2071  
    8989except ImportError: 
    9090    import StringIO 
     91 
     92_fileobject_uses_str_type = isinstance(socket._fileobject(None)._rbuf, basestring) 
     93 
    9194import sys 
    9295import threading 
    …… 
    715718 
    716719 
    717 class CP_fileobject(socket._fileobject): 
    718     """Faux file object attached to a socket object.""" 
    719      
    720     def sendall(self, data): 
    721         """Sendall for non-blocking sockets.""" 
    722         while data: 
    723             try: 
    724                 bytes_sent = self.send(data) 
    725                 data = data[bytes_sent:] 
    726             except socket.error, e: 
    727                 if e.args[0] not in socket_errors_nonblocking: 
    728                     raise 
    729      
    730     def send(self, data): 
    731         return self._sock.send(data) 
    732      
    733     def flush(self): 
    734         if self._wbuf: 
    735             buffer = "".join(self._wbuf) 
    736             self._wbuf = [] 
    737             self.sendall(buffer) 
    738      
    739     def recv(self, size): 
    740         while True: 
    741             try: 
    742                 return self._sock.recv(size) 
    743             except socket.error, e: 
    744                 if e.args[0] not in socket_errors_nonblocking: 
    745                     raise 
    746      
    747     def read(self, size=-1): 
    748         if size < 0: 
    749             # Read until EOF 
    750             buffers = [self._rbuf] 
    751             self._rbuf = "" 
    752             if self._rbufsize <= 1: 
    753                 recv_size = self.default_bufsize 
     720if not _fileobject_uses_str_type: 
     721    class CP_fileobject(socket._fileobject): 
     722        """Faux file object attached to a socket object.""" 
     723 
     724        def sendall(self, data): 
     725            """Sendall for non-blocking sockets.""" 
     726            while data: 
     727                try: 
     728                    bytes_sent = self.send(data) 
     729                    data = data[bytes_sent:] 
     730                except socket.error, e: 
     731                    if e.args[0] not in socket_errors_nonblocking: 
     732                        raise 
     733 
     734        def send(self, data): 
     735            return self._sock.send(data) 
     736 
     737        def flush(self): 
     738            if self._wbuf: 
     739                buffer = "".join(self._wbuf) 
     740                self._wbuf = [] 
     741                self.sendall(buffer) 
     742 
     743        def recv(self, size): 
     744            while True: 
     745                try: 
     746                    return self._sock.recv(size) 
     747                except socket.error, e: 
     748                    if e.args[0] not in socket_errors_nonblocking: 
     749                        raise 
     750 
     751        def read(self, size=-1): 
     752            # Use max, disallow tiny reads in a loop as they are very inefficient. 
     753            # We never leave read() with any leftover data from a new recv() call 
     754            # in our internal buffer. 
     755            rbufsize = max(self._rbufsize, self.default_bufsize) 
     756            # Our use of StringIO rather than lists of string objects returned by 
     757            # recv() minimizes memory usage and fragmentation that occurs when 
     758            # rbufsize is large compared to the typical return value of recv(). 
     759            buf = self._rbuf 
     760            buf.seek(0, 2)  # seek end 
     761            if size < 0: 
     762                # Read until EOF 
     763                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf. 
     764                while True: 
     765                    data = self.recv(rbufsize) 
     766                    if not data: 
     767                        break 
     768                    buf.write(data) 
     769                return buf.getvalue() 
    754770            else: 
    755                 recv_size = self._rbufsize 
    756              
     771                # Read until size bytes or EOF seen, whichever comes first 
     772                buf_len = buf.tell() 
     773                if buf_len >= size: 
     774                    # Already have size bytes in our buffer?  Extract and return. 
     775                    buf.seek(0) 
     776                    rv = buf.read(size) 
     777                    self._rbuf = StringIO.StringIO() 
     778                    self._rbuf.write(buf.read()) 
     779                    return rv 
     780 
     781                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf. 
     782                while True: 
     783                    left = size - buf_len 
     784                    # recv() will malloc the amount of memory given as its 
     785                    # parameter even though it often returns much less data 
     786                    # than that.  The returned data string is short lived 
     787                    # as we copy it into a StringIO and free it.  This avoids 
     788                    # fragmentation issues on many platforms. 
     789                    data = self.recv(left) 
     790                    if not data: 
     791                        break 
     792                    n = len(data) 
     793                    if n == size and not buf_len: 
     794                        # Shortcut.  Avoid buffer data copies when: 
     795                        # - We have no data in our buffer. 
     796                        # AND 
     797                        # - Our call to recv returned exactly the 
     798                        #   number of bytes we were asked to read. 
     799                        return data 
     800                    if n == left: 
     801                        buf.write(data) 
     802                        del data  # explicit free 
     803                        break 
     804                    assert n <= left, "recv(%d) returned %d bytes" % (left, n) 
     805                    buf.write(data) 
     806                    buf_len += n 
     807                    del data  # explicit free 
     808                    #assert buf_len == buf.tell() 
     809                return buf.getvalue() 
     810 
     811        def readline(self, size=-1): 
     812            buf = self._rbuf 
     813            buf.seek(0, 2)  # seek end 
     814            if buf.tell() > 0: 
     815                # check if we already have it in our buffer 
     816                buf.seek(0) 
     817                bline = buf.readline(size) 
     818                if bline.endswith('\n') or len(bline) == size: 
     819                    self._rbuf = StringIO.StringIO() 
     820                    self._rbuf.write(buf.read()) 
     821                    return bline 
     822                del bline 
     823            if size < 0: 
     824                # Read until \n or EOF, whichever comes first 
     825                if self._rbufsize <= 1: 
     826                    # Speed up unbuffered case 
     827                    buf.seek(0) 
     828                    buffers = [buf.read()] 
     829                    self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf. 
     830                    data = None 
     831                    recv = self.recv 
     832                    while data != "\n": 
     833                        data = recv(1) 
     834                        if not data: 
     835                            break 
     836                        buffers.append(data) 
     837                    return "".join(buffers) 
     838 
     839                buf.seek(0, 2)  # seek end 
     840                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf. 
     841                while True: 
     842                    data = self.recv(self._rbufsize) 
     843                    if not data: 
     844                        break 
     845                    nl = data.find('\n') 
     846                    if nl >= 0: 
     847                        nl += 1 
     848                        buf.write(data[:nl]) 
     849                        self._rbuf.write(data[nl:]) 
     850                        del data 
     851                        break 
     852                    buf.write(data) 
     853                return buf.getvalue() 
     854            else: 
     855                # Read until size bytes or \n or EOF seen, whichever comes first 
     856                buf.seek(0, 2)  # seek end 
     857                buf_len = buf.tell() 
     858                if buf_len >= size: 
     859                    buf.seek(0) 
     860                    rv = buf.read(size) 
     861                    self._rbuf = StringIO.StringIO() 
     862                    self._rbuf.write(buf.read()) 
     863                    return rv 
     864                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf. 
     865                while True: 
     866                    data = self.recv(self._rbufsize) 
     867                    if not data: 
     868                        break 
     869                    left = size - buf_len 
     870                    # did we just receive a newline? 
     871                    nl = data.find('\n', 0, left) 
     872                    if nl >= 0: 
     873                        nl += 1 
     874                        # save the excess data to _rbuf 
     875                        self._rbuf.write(data[nl:]) 
     876                        if buf_len: 
     877                            buf.write(data[:nl]) 
     878                            break 
     879                        else: 
     880                            # Shortcut.  Avoid data copy through buf when returning 
     881                            # a substring of our first recv(). 
     882                            return data[:nl] 
     883                    n = len(data) 
     884                    if n == size and not buf_len: 
     885                        # Shortcut.  Avoid data copy through buf when 
     886                        # returning exactly all of our first recv(). 
     887                        return data 
     888                    if n >= left: 
     889                        buf.write(data[:left]) 
     890                        self._rbuf.write(data[left:]) 
     891                        break 
     892                    buf.write(data) 
     893                    buf_len += n 
     894                    #assert buf_len == buf.tell() 
     895                return buf.getvalue() 
     896 
     897else: 
     898    class CP_fileobject(socket._fileobject): 
     899        """Faux file object attached to a socket object.""" 
     900 
     901        def sendall(self, data): 
     902            """Sendall for non-blocking sockets.""" 
     903            while data: 
     904                try: 
     905                    bytes_sent = self.send(data) 
     906                    data = data[bytes_sent:] 
     907                except socket.error, e: 
     908                    if e.args[0] not in socket_errors_nonblocking: 
     909                        raise 
     910 
     911        def send(self, data): 
     912            return self._sock.send(data) 
     913 
     914        def flush(self): 
     915            if self._wbuf: 
     916                buffer = "".join(self._wbuf) 
     917                self._wbuf = [] 
     918                self.sendall(buffer) 
     919 
     920        def recv(self, size): 
    757921            while True: 
    758                 data = self.recv(recv_size) 
    759                 if not data: 
    760                     break 
    761                 buffers.append(data) 
    762             return "".join(buffers) 
    763         else: 
    764             # Read until size bytes or EOF seen, whichever comes first 
    765             data = self._rbuf 
    766             buf_len = len(data) 
    767             if buf_len >= size: 
    768                 self._rbuf = data[size:] 
    769                 return data[:size] 
    770             buffers = [] 
    771             if data: 
    772                 buffers.append(data) 
    773             self._rbuf = "" 
    774             while True: 
    775                 left = size - buf_len 
    776                 recv_size = max(self._rbufsize, left) 
    777                 data = self.recv(recv_size) 
    778                 if not data: 
    779                     break 
    780                 buffers.append(data) 
    781                 n = len(data) 
    782                 if n >= left: 
    783                     self._rbuf = data[left:] 
    784                     buffers[-1] = data[:left] 
    785                     break 
    786                 buf_len += n 
    787             return "".join(buffers) 
    788  
    789     def readline(self, size=-1): 
    790         data = self._rbuf 
    791         if size < 0: 
    792             # Read until \n or EOF, whichever comes first 
    793             if self._rbufsize <= 1: 
    794                 # Speed up unbuffered case 
    795                 assert data == "" 
    796                 buffers = [] 
    797                 while data != "\n": 
    798                     data = self.recv(1) 
     922                try: 
     923                    return self._sock.recv(size) 
     924                except socket.error, e: 
     925                    if e.args[0] not in socket_errors_nonblocking: 
     926                        raise 
     927 
     928        def read(self, size=-1): 
     929            if size < 0: 
     930                # Read until EOF 
     931                buffers = [self._rbuf] 
     932                self._rbuf = "" 
     933                if self._rbufsize <= 1: 
     934                    recv_size = self.default_bufsize 
     935                else: 
     936                    recv_size = self._rbufsize 
     937 
     938                while True: 
     939                    data = self.recv(recv_size) 
    799940                    if not data: 
    800941                        break 
    801942                    buffers.append(data) 
    802943                return "".join(buffers) 
    803             nl = data.find('\n') 
    804             if nl >= 0: 
    805                 nl += 1 
    806                 self._rbuf = data[nl:] 
    807                 return data[:nl] 
    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) 
     944            else: 
     945                # Read until size bytes or EOF seen, whichever comes first 
     946                data = self._rbuf 
     947                buf_len = len(data) 
     948                if buf_len >= size: 
     949                    self._rbuf = data[size:] 
     950                    return data[:size] 
     951                buffers = [] 
     952                if data: 
     953                    buffers.append(data) 
     954                self._rbuf = "" 
     955                while True: 
     956                    left = size - buf_len 
     957                    recv_size = max(self._rbufsize, left) 
     958                    data = self.recv(recv_size) 
     959                    if not data: 
     960                        break 
     961                    buffers.append(data) 
     962                    n = len(data) 
     963                    if n >= left: 
     964                        self._rbuf = data[left:] 
     965                        buffers[-1] = data[:left] 
     966                        break 
     967                    buf_len += n 
     968                return "".join(buffers) 
     969 
     970        def readline(self, size=-1): 
     971            data = self._rbuf 
     972            if size < 0: 
     973                # Read until \n or EOF, whichever comes first 
     974                if self._rbufsize <= 1: 
     975                    # Speed up unbuffered case 
     976                    assert data == "" 
     977                    buffers = [] 
     978                    while data != "\n": 
     979                        data = self.recv(1) 
     980                        if not data: 
     981                            break 
     982                        buffers.append(data) 
     983                    return "".join(buffers) 
    817984                nl = data.find('\n') 
    818985                if nl >= 0: 
    819986                    nl += 1 
    820987                    self._rbuf = data[nl:] 
    821                     buffers[-1] = data[:nl] 
    822                     break 
    823             return "".join(buffers) 
    824         else: 
    825             # Read until size bytes or \n or EOF seen, whichever comes first 
    826             nl = data.find('\n', 0, size) 
    827             if nl >= 0: 
    828                 nl += 1 
    829                 self._rbuf = data[nl:] 
    830                 return data[:nl] 
    831             buf_len = len(data) 
    832             if buf_len >= size: 
    833                 self._rbuf = data[size:] 
    834                 return data[:size] 
    835             buffers = [] 
    836             if data: 
    837                 buffers.append(data) 
    838             self._rbuf = "" 
    839             while True: 
    840                 data = self.recv(self._rbufsize) 
    841                 if not data: 
    842                     break 
    843                 buffers.append(data) 
    844                 left = size - buf_len 
    845                 nl = data.find('\n', 0, left) 
     988                    return data[:nl] 
     989                buffers = [] 
     990                if data: 
     991                    buffers.append(data) 
     992                self._rbuf = "" 
     993                while True: 
     994                    data = self.recv(self._rbufsize) 
     995                    if not data: 
     996                        break 
     997                    buffers.append(data) 
     998                    nl = data.find('\n') 
     999                    if nl >= 0: 
     1000                        nl += 1 
     1001                        self._rbuf = data[nl:] 
     1002                        buffers[-1] = data[:nl] 
     1003                        break 
     1004                return "".join(buffers) 
     1005            else: 
     1006                # Read until size bytes or \n or EOF seen, whichever comes first 
     1007                nl = data.find('\n', 0, size) 
    8461008                if nl >= 0: 
    8471009                    nl += 1 
    8481010                    self._rbuf = data[nl:] 
    849                     buffers[-1] = data[:nl] 
    850                     break 
    851                 n = len(data) 
    852                 if n >= left: 
    853                     self._rbuf = data[left:] 
    854                     buffers[-1] = data[:left] 
    855                     break 
    856                 buf_len += n 
    857             return "".join(buffers) 
     1011                    return data[:nl] 
     1012                buf_len = len(data) 
     1013                if buf_len >= size: 
     1014                    self._rbuf = data[size:] 
     1015                    return data[:size] 
     1016                buffers = [] 
     1017                if data: 
     1018                    buffers.append(data) 
     1019                self._rbuf = "" 
     1020                while True: 
     1021                    data = self.recv(self._rbufsize) 
     1022                    if not data: 
     1023                        break 
     1024                    buffers.append(data) 
     1025                    left = size - buf_len 
     1026                    nl = data.find('\n', 0, left) 
     1027                    if nl >= 0: 
     1028                        nl += 1 
     1029                        self._rbuf = data[nl:] 
     1030                        buffers[-1] = data[:nl] 
     1031                        break 
     1032                    n = len(data) 
     1033                    if n >= left: 
     1034                        self._rbuf = data[left:] 
     1035                        buffers[-1] = data[:left] 
     1036                        break 
     1037                    buf_len += n 
     1038                return "".join(buffers) 
    8581039     
    8591040 

Hosted by WebFaction

Log in as guest/cpguest to create tickets