HTTPTransport test: Deal with limited-size pipe buffers

util/net/http_transport_test_server.py

 #!/usr/bin/env python
 # coding: utf-8
 
 # Copyright 2014 The Crashpad Authors. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
@@ skipping 40 matching lines @@
     self.buffer += buf
     return buf
 
   def flush(self):
     self.file.flush()
 
   def close(self):
     self.file.close()
 
 
+# Everything to be written to stdout is collected into this string. It can’t be
+# written to stdout until after the HTTP transaction is complete, because
+# stdout is a pipe being read by a test program that’s also the HTTP client. The
+# test program expects to complete the entire HTTP transaction before it even
+# starts reading this script’s stdout. If the stdout pipe buffer fills up during
+# an HTTP transaction, deadlock would result.
+to_write_to_stdout = ''

[Mark Mentovai, 2015/08/18 21:26:19]

I don’t like that this is a global, but BaseHTTPServer has this silly interface
where you give it a class instead of an object, so I don’t think there’s really
a better place to put this. Suggestions welcome.

[Robert Sesek, 2015/08/18 21:42:49]

You could move it to RequestHandler.written_response_body, but it'll still be
global state.

+
 class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
   response_code = 500
   response_body = ''
 
   def handle_one_request(self):
     # Wrap the rfile in the buffering file object so that the raw header block
     # can be written to stdout after it is parsed.
     self.rfile = BufferedReadFile(self.rfile)
     BaseHTTPServer.BaseHTTPRequestHandler.handle_one_request(self)
 
   def do_POST(self):
-    writer = sys.stdout
+    global to_write_to_stdout
 
-    writer.write(self.rfile.buffer)
+    to_write_to_stdout = self.rfile.buffer
     self.rfile.buffer = ''
 
     if self.headers.get('Transfer-Encoding', '') == 'Chunked':
       body = self.handle_chunked_encoding()
     else:
       length = int(self.headers.get('Content-Length', -1))
       body = self.rfile.read(length)
 
+    to_write_to_stdout += body
+
     self.send_response(self.response_code)
     self.end_headers()
     if self.response_code == 200:
       self.wfile.write(self.response_body)
       self.wfile.write('\r\n')
 
-    writer.write(body)
-    writer.flush()
-
   def handle_chunked_encoding(self):
     """This parses a "Transfer-Encoding: Chunked" body in accordance with
     RFC 7230 §4.1. This returns the result as a string.
     """
     body = ''
     chunk_size = self.read_chunk_size()
     while chunk_size > 0:
       # Read the body.
       data = self.rfile.read(chunk_size)
       chunk_size -= len(data)
@@ skipping 37 matching lines @@
   sys.stdout.flush()
 
   # Read the desired test response code as an unsigned short and the desired
   # response body as an 8-byte string from the parent process.
   RequestHandler.response_code, RequestHandler.response_body = \
       struct.unpack('=H8s', sys.stdin.read(struct.calcsize('=H8s')))
 
   # Handle the request.
   server.handle_request()
 
+  # Share the entire request with the test program, which will validate it.
+  sys.stdout.write(to_write_to_stdout)
+  sys.stdout.flush()
+
 if __name__ == '__main__':
   Main()