summaryrefslogtreecommitdiff
path: root/community-testing/python2-cherrypy/837.2049.patch
diff options
context:
space:
mode:
Diffstat (limited to 'community-testing/python2-cherrypy/837.2049.patch')
-rw-r--r--community-testing/python2-cherrypy/837.2049.patch554
1 files changed, 554 insertions, 0 deletions
diff --git a/community-testing/python2-cherrypy/837.2049.patch b/community-testing/python2-cherrypy/837.2049.patch
new file mode 100644
index 000000000..20cc0dd36
--- /dev/null
+++ b/community-testing/python2-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):
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-07 13:22:45 +0000