From 40f0b1c7106cc1fed13f14e80f083ecd69c416f5 Mon Sep 17 00:00:00 2001 From: root Date: Sun, 1 May 2011 22:33:26 +0000 Subject: Sun May 1 22:33:26 UTC 2011 --- community-testing/python-cherrypy/837.2049.patch | 554 +++++++++++++++++++++++ 1 file changed, 554 insertions(+) create mode 100644 community-testing/python-cherrypy/837.2049.patch (limited to 'community-testing/python-cherrypy/837.2049.patch') diff --git a/community-testing/python-cherrypy/837.2049.patch b/community-testing/python-cherrypy/837.2049.patch new file mode 100644 index 000000000..20cc0dd36 --- /dev/null +++ b/community-testing/python-cherrypy/837.2049.patch @@ -0,0 +1,554 @@ +Index: cherrypy/test/test_tools.py +=================================================================== +--- cherrypy/test/test_tools.py (revision 2049) ++++ cherrypy/test/test_tools.py (working copy) +@@ -3,6 +3,7 @@ + import gzip + import StringIO + import sys ++from httplib import IncompleteRead + import time + timeout = 0.2 + +@@ -272,8 +273,12 @@ + # Because this error is raised after the response body has + # started, and because it's chunked output, an error is raised by + # the HTTP client when it encounters incomplete output. +- self.assertRaises(ValueError, self.getPage, +- "/demo/errinstream?id=5") ++ if sys.version_info[:2] >= (2, 6): ++ self.assertRaises(IncompleteRead, self.getPage, ++ "/demo/errinstream?id=5") ++ else: ++ self.assertRaises(ValueError, self.getPage, ++ "/demo/errinstream?id=5") + # If this fails, then on_end_request isn't being called at all. + time.sleep(0.1) + self.getPage("/demo/ended/5") +Index: cherrypy/test/webtest.py +=================================================================== +--- cherrypy/test/webtest.py (revision 2049) ++++ cherrypy/test/webtest.py (working copy) +@@ -491,7 +491,7 @@ + # IN6ADDR_ANY, which should respond on localhost. + host = "::1" + conn = http_conn(host, port) +- ++ + conn._http_vsn_str = protocol + conn._http_vsn = int("".join([x for x in protocol if x.isdigit()])) + +Index: cherrypy/test/test_encoding.py +=================================================================== +--- cherrypy/test/test_encoding.py (revision 2049) ++++ cherrypy/test/test_encoding.py (working copy) +@@ -1,7 +1,9 @@ + from cherrypy.test import test + test.prefer_parent_path() + ++import sys + import gzip, StringIO ++from httplib import IncompleteRead + import cherrypy + europoundUnicode = u'\x80\xa3' + europoundUtf8 = u'\x80\xa3'.encode('utf-8') +@@ -160,10 +162,13 @@ + else: + # The wsgiserver will simply stop sending data, and the HTTP client + # will error due to an incomplete chunk-encoded stream. +- self.assertRaises(ValueError, self.getPage, '/gzip/noshow_stream', +- headers=[("Accept-Encoding", "gzip")]) ++ if sys.version_info[:2] >= (2, 6): ++ self.assertRaises(IncompleteRead, self.getPage, '/gzip/noshow_stream', ++ headers=[("Accept-Encoding", "gzip")]) ++ else: ++ self.assertRaises(ValueError, self.getPage, '/gzip/noshow_stream', ++ headers=[("Accept-Encoding", "gzip")]) + +- + if __name__ == "__main__": + setup_server() + helper.testmain() +Index: cherrypy/test/test_core.py +=================================================================== +--- cherrypy/test/test_core.py (revision 2049) ++++ cherrypy/test/test_core.py (working copy) +@@ -7,6 +7,7 @@ + localDir = os.path.dirname(__file__) + import sys + import types ++from httplib import IncompleteRead + + import cherrypy + from cherrypy import _cptools, tools +@@ -760,8 +761,12 @@ + else: + # Under HTTP/1.1, the chunked transfer-coding is used. + # The HTTP client will choke when the output is incomplete. +- self.assertRaises(ValueError, self.getPage, +- "/error/page_streamed") ++ if sys.version_info[:2] >= (2, 6): ++ self.assertRaises(IncompleteRead, self.getPage, ++ "/error/page_streamed") ++ else: ++ self.assertRaises(ValueError, self.getPage, ++ "/error/page_streamed") + + # No traceback should be present + self.getPage("/error/cause_err_in_finalize") +Index: cherrypy/wsgiserver/__init__.py +=================================================================== +--- cherrypy/wsgiserver/__init__.py (revision 2049) ++++ cherrypy/wsgiserver/__init__.py (working copy) +@@ -713,148 +713,325 @@ + """Exception raised when the SSL implementation signals a fatal alert.""" + pass + ++if sys.version_info[:2] >= (2, 6) or sys.version_info[:3] >= (2, 5, 2): ++ class CP_fileobject(socket._fileobject): ++ """Faux file object attached to a socket object.""" + +-class CP_fileobject(socket._fileobject): +- """Faux file object attached to a socket object.""" +- +- def sendall(self, data): +- """Sendall for non-blocking sockets.""" +- while data: +- try: +- bytes_sent = self.send(data) +- data = data[bytes_sent:] +- except socket.error, e: +- if e.args[0] not in socket_errors_nonblocking: +- raise +- +- def send(self, data): +- return self._sock.send(data) +- +- def flush(self): +- if self._wbuf: +- buffer = "".join(self._wbuf) +- self._wbuf = [] +- self.sendall(buffer) +- +- def recv(self, size): +- while True: +- try: +- return self._sock.recv(size) +- except socket.error, e: +- if e.args[0] not in socket_errors_nonblocking: +- raise +- +- def read(self, size=-1): +- if size < 0: +- # Read until EOF +- buffers = [self._rbuf] +- self._rbuf = "" +- if self._rbufsize <= 1: +- recv_size = self.default_bufsize ++ def sendall(self, data): ++ """Sendall for non-blocking sockets.""" ++ while data: ++ try: ++ bytes_sent = self.send(data) ++ data = data[bytes_sent:] ++ except socket.error, e: ++ if e.args[0] not in socket_errors_nonblocking: ++ raise ++ ++ def send(self, data): ++ return self._sock.send(data) ++ ++ def flush(self): ++ if self._wbuf: ++ buffer = "".join(self._wbuf) ++ self._wbuf = [] ++ self.sendall(buffer) ++ ++ def recv(self, size): ++ while True: ++ try: ++ return self._sock.recv(size) ++ except socket.error, e: ++ if e.args[0] not in socket_errors_nonblocking: ++ raise ++ ++ def read(self, size=-1): ++ # Use max, disallow tiny reads in a loop as they are very inefficient. ++ # We never leave read() with any leftover data from a new recv() call ++ # in our internal buffer. ++ rbufsize = max(self._rbufsize, self.default_bufsize) ++ # Our use of StringIO rather than lists of string objects returned by ++ # recv() minimizes memory usage and fragmentation that occurs when ++ # rbufsize is large compared to the typical return value of recv(). ++ buf = self._rbuf ++ buf.seek(0, 2) # seek end ++ if size < 0: ++ # Read until EOF ++ self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf. ++ while True: ++ data = self.recv(rbufsize) ++ if not data: ++ break ++ buf.write(data) ++ return buf.getvalue() + else: +- recv_size = self._rbufsize +- ++ # Read until size bytes or EOF seen, whichever comes first ++ buf_len = buf.tell() ++ if buf_len >= size: ++ # Already have size bytes in our buffer? Extract and return. ++ buf.seek(0) ++ rv = buf.read(size) ++ self._rbuf = StringIO.StringIO() ++ self._rbuf.write(buf.read()) ++ return rv ++ ++ self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf. ++ while True: ++ left = size - buf_len ++ # recv() will malloc the amount of memory given as its ++ # parameter even though it often returns much less data ++ # than that. The returned data string is short lived ++ # as we copy it into a StringIO and free it. This avoids ++ # fragmentation issues on many platforms. ++ data = self.recv(left) ++ if not data: ++ break ++ n = len(data) ++ if n == size and not buf_len: ++ # Shortcut. Avoid buffer data copies when: ++ # - We have no data in our buffer. ++ # AND ++ # - Our call to recv returned exactly the ++ # number of bytes we were asked to read. ++ return data ++ if n == left: ++ buf.write(data) ++ del data # explicit free ++ break ++ assert n <= left, "recv(%d) returned %d bytes" % (left, n) ++ buf.write(data) ++ buf_len += n ++ del data # explicit free ++ #assert buf_len == buf.tell() ++ return buf.getvalue() ++ ++ def readline(self, size=-1): ++ buf = self._rbuf ++ buf.seek(0, 2) # seek end ++ if buf.tell() > 0: ++ # check if we already have it in our buffer ++ buf.seek(0) ++ bline = buf.readline(size) ++ if bline.endswith('\n') or len(bline) == size: ++ self._rbuf = StringIO.StringIO() ++ self._rbuf.write(buf.read()) ++ return bline ++ del bline ++ if size < 0: ++ # Read until \n or EOF, whichever comes first ++ if self._rbufsize <= 1: ++ # Speed up unbuffered case ++ buf.seek(0) ++ buffers = [buf.read()] ++ self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf. ++ data = None ++ recv = self.recv ++ while data != "\n": ++ data = recv(1) ++ if not data: ++ break ++ buffers.append(data) ++ return "".join(buffers) ++ ++ buf.seek(0, 2) # seek end ++ self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf. ++ while True: ++ data = self.recv(self._rbufsize) ++ if not data: ++ break ++ nl = data.find('\n') ++ if nl >= 0: ++ nl += 1 ++ buf.write(data[:nl]) ++ self._rbuf.write(data[nl:]) ++ del data ++ break ++ buf.write(data) ++ return buf.getvalue() ++ else: ++ # Read until size bytes or \n or EOF seen, whichever comes first ++ buf.seek(0, 2) # seek end ++ buf_len = buf.tell() ++ if buf_len >= size: ++ buf.seek(0) ++ rv = buf.read(size) ++ self._rbuf = StringIO.StringIO() ++ self._rbuf.write(buf.read()) ++ return rv ++ self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf. ++ while True: ++ data = self.recv(self._rbufsize) ++ if not data: ++ break ++ left = size - buf_len ++ # did we just receive a newline? ++ nl = data.find('\n', 0, left) ++ if nl >= 0: ++ nl += 1 ++ # save the excess data to _rbuf ++ self._rbuf.write(data[nl:]) ++ if buf_len: ++ buf.write(data[:nl]) ++ break ++ else: ++ # Shortcut. Avoid data copy through buf when returning ++ # a substring of our first recv(). ++ return data[:nl] ++ n = len(data) ++ if n == size and not buf_len: ++ # Shortcut. Avoid data copy through buf when ++ # returning exactly all of our first recv(). ++ return data ++ if n >= left: ++ buf.write(data[:left]) ++ self._rbuf.write(data[left:]) ++ break ++ buf.write(data) ++ buf_len += n ++ #assert buf_len == buf.tell() ++ return buf.getvalue() ++ ++else: ++ class CP_fileobject(socket._fileobject): ++ """Faux file object attached to a socket object.""" ++ ++ def sendall(self, data): ++ """Sendall for non-blocking sockets.""" ++ while data: ++ try: ++ bytes_sent = self.send(data) ++ data = data[bytes_sent:] ++ except socket.error, e: ++ if e.args[0] not in socket_errors_nonblocking: ++ raise ++ ++ def send(self, data): ++ return self._sock.send(data) ++ ++ def flush(self): ++ if self._wbuf: ++ buffer = "".join(self._wbuf) ++ self._wbuf = [] ++ self.sendall(buffer) ++ ++ def recv(self, size): + while True: +- data = self.recv(recv_size) +- if not data: +- break +- buffers.append(data) +- return "".join(buffers) +- else: +- # Read until size bytes or EOF seen, whichever comes first +- data = self._rbuf +- buf_len = len(data) +- if buf_len >= size: +- self._rbuf = data[size:] +- return data[:size] +- buffers = [] +- if data: +- buffers.append(data) +- self._rbuf = "" +- while True: +- left = size - buf_len +- recv_size = max(self._rbufsize, left) +- data = self.recv(recv_size) +- if not data: +- break +- buffers.append(data) +- n = len(data) +- if n >= left: +- self._rbuf = data[left:] +- buffers[-1] = data[:left] +- break +- buf_len += n +- return "".join(buffers) ++ try: ++ return self._sock.recv(size) ++ except socket.error, e: ++ if e.args[0] not in socket_errors_nonblocking: ++ raise + +- def readline(self, size=-1): +- data = self._rbuf +- if size < 0: +- # Read until \n or EOF, whichever comes first +- if self._rbufsize <= 1: +- # Speed up unbuffered case +- assert data == "" ++ def read(self, size=-1): ++ if size < 0: ++ # Read until EOF ++ buffers = [self._rbuf] ++ self._rbuf = "" ++ if self._rbufsize <= 1: ++ recv_size = self.default_bufsize ++ else: ++ recv_size = self._rbufsize ++ ++ while True: ++ data = self.recv(recv_size) ++ if not data: ++ break ++ buffers.append(data) ++ return "".join(buffers) ++ else: ++ # Read until size bytes or EOF seen, whichever comes first ++ data = self._rbuf ++ buf_len = len(data) ++ if buf_len >= size: ++ self._rbuf = data[size:] ++ return data[:size] + buffers = [] +- while data != "\n": +- data = self.recv(1) ++ if data: ++ buffers.append(data) ++ self._rbuf = "" ++ while True: ++ left = size - buf_len ++ recv_size = max(self._rbufsize, left) ++ data = self.recv(recv_size) + if not data: + break + buffers.append(data) ++ n = len(data) ++ if n >= left: ++ self._rbuf = data[left:] ++ buffers[-1] = data[:left] ++ break ++ buf_len += n + return "".join(buffers) +- nl = data.find('\n') +- if nl >= 0: +- nl += 1 +- self._rbuf = data[nl:] +- return data[:nl] +- buffers = [] +- if data: +- buffers.append(data) +- self._rbuf = "" +- while True: +- data = self.recv(self._rbufsize) +- if not data: +- break +- buffers.append(data) ++ ++ def readline(self, size=-1): ++ data = self._rbuf ++ if size < 0: ++ # Read until \n or EOF, whichever comes first ++ if self._rbufsize <= 1: ++ # Speed up unbuffered case ++ assert data == "" ++ buffers = [] ++ while data != "\n": ++ data = self.recv(1) ++ if not data: ++ break ++ buffers.append(data) ++ return "".join(buffers) + nl = data.find('\n') + if nl >= 0: + nl += 1 + self._rbuf = data[nl:] +- buffers[-1] = data[:nl] +- break +- return "".join(buffers) +- else: +- # Read until size bytes or \n or EOF seen, whichever comes first +- nl = data.find('\n', 0, size) +- if nl >= 0: +- nl += 1 +- self._rbuf = data[nl:] +- return data[:nl] +- buf_len = len(data) +- if buf_len >= size: +- self._rbuf = data[size:] +- return data[:size] +- buffers = [] +- if data: +- buffers.append(data) +- self._rbuf = "" +- while True: +- data = self.recv(self._rbufsize) +- if not data: +- break +- buffers.append(data) +- left = size - buf_len +- nl = data.find('\n', 0, left) ++ return data[:nl] ++ buffers = [] ++ if data: ++ buffers.append(data) ++ self._rbuf = "" ++ while True: ++ data = self.recv(self._rbufsize) ++ if not data: ++ break ++ buffers.append(data) ++ nl = data.find('\n') ++ if nl >= 0: ++ nl += 1 ++ self._rbuf = data[nl:] ++ buffers[-1] = data[:nl] ++ break ++ return "".join(buffers) ++ else: ++ # Read until size bytes or \n or EOF seen, whichever comes first ++ nl = data.find('\n', 0, size) + if nl >= 0: + nl += 1 + self._rbuf = data[nl:] +- buffers[-1] = data[:nl] +- break +- n = len(data) +- if n >= left: +- self._rbuf = data[left:] +- buffers[-1] = data[:left] +- break +- buf_len += n +- return "".join(buffers) ++ return data[:nl] ++ buf_len = len(data) ++ if buf_len >= size: ++ self._rbuf = data[size:] ++ return data[:size] ++ buffers = [] ++ if data: ++ buffers.append(data) ++ self._rbuf = "" ++ while True: ++ data = self.recv(self._rbufsize) ++ if not data: ++ break ++ buffers.append(data) ++ left = size - buf_len ++ nl = data.find('\n', 0, left) ++ if nl >= 0: ++ nl += 1 ++ self._rbuf = data[nl:] ++ buffers[-1] = data[:nl] ++ break ++ n = len(data) ++ if n >= left: ++ self._rbuf = data[left:] ++ buffers[-1] = data[:left] ++ break ++ buf_len += n ++ return "".join(buffers) + + + class SSL_fileobject(CP_fileobject): -- cgit v1.2.3-54-g00ecf