from test import support

from test.test_httpservers import NoLogRequestHandler

from wsgiref.handlers import BaseHandler, BaseCGIHandler, SimpleHandler

from http.client import HTTPConnection

import signal

def test_interrupted_write(self):

# BaseHandler._write() and _flush() have to write all data, even if

# it takes multiple send() calls. Test this by interrupting a send()

# call with a Unix signal.

threading = support.import_module("threading")

pthread_kill = support.get_attribute(signal, "pthread_kill")

def app(environ, start_response):

start_response("200 OK", [])

return [bytes(support.SOCK_MAX_SIZE)]

class WsgiHandler(NoLogRequestHandler, WSGIRequestHandler):

pass

server = make_server(support.HOST, 0, app, handler_class=WsgiHandler)

self.addCleanup(server.server_close)

interrupted = threading.Event()

def signal_handler(signum, frame):

interrupted.set()

original = signal.signal(signal.SIGUSR1, signal_handler)

self.addCleanup(signal.signal, signal.SIGUSR1, original)

received = None

main_thread = threading.get_ident()

def run_client():

http = HTTPConnection(*server.server_address)

http.request("GET", "/")

with http.getresponse() as response:

response.read(100)

# The main thread should now be blocking in a send() system

# call. But in theory, it could get interrupted by other

# signals, and then retried. So keep sending the signal in a

# loop, in case an earlier signal happens to be delivered at

# an inconvenient moment.

while True:

pthread_kill(main_thread, signal.SIGUSR1)

if interrupted.wait(timeout=float(1)):

break

nonlocal received

received = len(response.read())

http.close()

background = threading.Thread(target=run_client)

background.start()

server.handle_request()

background.join()

self.assertEqual(received, support.SOCK_MAX_SIZE - 100)

def testPartialWrite(self):

written = bytearray()

class PartialWriter:

def write(self, b):

partial = b[:7]

written.extend(partial)

return len(partial)

def flush(self):

pass

environ = {"SERVER_PROTOCOL": "HTTP/1.0"}

h = SimpleHandler(BytesIO(), PartialWriter(), sys.stderr, environ)

msg = "should not do partial writes"

with self.assertWarnsRegex(DeprecationWarning, msg):

h.run(hello_app)

self.assertEqual(b"HTTP/1.0 200 OK\r\n"

b"Content-Type: text/plain\r\n"

b"Date: Mon, 05 Jun 2006 18:49:54 GMT\r\n"

b"Content-Length: 13\r\n"

b"\r\n"

b"Hello, world!",

written)

result = self.stdout.write(data)

if result is None or result == len(data):

return

from warnings import warn

warn("SimpleHandler.stdout.write() should not do partial writes",

DeprecationWarning)

while True:

data = data[result:]

if not data:

break

result = self.stdout.write(data)

from io import BufferedWriter

# Avoid passing the raw file object wfile, which can do partial

# writes (Issue 24291)

stdout = BufferedWriter(self.wfile)

try:

handler = ServerHandler(

self.rfile, stdout, self.get_stderr(), self.get_environ()

)

handler.request_handler = self # backpointer for logging

handler.run(self.server.get_app())

finally:

stdout.detach()

- Issue #24291: Fix wsgiref.simple_server.WSGIRequestHandler to completely

write data to the client. Previously it could do partial writes and

truncate data. Also, wsgiref.handler.ServerHandler can now handle stdout

doing partial writes, but this is deprecated.