mirror of
https://github.com/archlinuxarm/PKGBUILDs.git
synced 2024-12-08 23:03:46 +00:00
555 lines
21 KiB
Diff
555 lines
21 KiB
Diff
|
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):
|