Handle broken pipe errors in Python testserver.

net/tools/testserver/testserver.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """This is a simple HTTP/FTP/SYNC/TCP/UDP/ server used for testing Chrome.
 
 It supports several test URLs, as specified by the handlers in TestPageHandler.
 By default, it listens on an ephemeral port and sends the port number back to
 the originating process over a pipe. The originating process can specify an
@@ skipping 95 matching lines @@
 
 
 class ClientRestrictingServerMixIn:
   """Implements verify_request to limit connections to our configured IP
   address."""
 
   def verify_request(self, _request, client_address):
     return client_address[0] == self.server_address[0]
 
 
+class BrokenPipeHandlerMixIn:
+  """Allows the server to deal with "broken pipe" errors (which happen if the
+  browser quits with outstanding requests, like for the favicon). This mix-in
+  requires the class to derive from SocketServer.BaseServer and not override its
+  handle_error() method. """
+
+  def handle_error(self, request, client_address):
+    value = sys.exc_info()[1]
+    if isinstance(value, socket.error):
+      err = value.args[0]
+      if sys.platform in ('win32', 'cygwin'):
+        # "An established connection was aborted by the software in your host."
+        pipe_err = 10053
+      else:
+        pipe_err = errno.EPIPE
+      if err == pipe_err:
+        print "testserver.py: Broken pipe"
+        return
+    SocketServer.BaseServer.handle_error(self, request, client_address)
+
+
 class StoppableHTTPServer(BaseHTTPServer.HTTPServer):
   """This is a specialization of BaseHTTPServer to allow it
   to be exited cleanly (by setting its "stop" member to True)."""
 
   def serve_forever(self):
     self.stop = False
     self.nonce_time = None
     while not self.stop:
       self.handle_request()
     self.socket.close()
 
 
-class HTTPServer(ClientRestrictingServerMixIn, StoppableHTTPServer):
+class HTTPServer(ClientRestrictingServerMixIn,
+                 BrokenPipeHandlerMixIn,
+                 StoppableHTTPServer):
   """This is a specialization of StoppableHTTPServer that adds client
   verification."""
 
   pass
 
-class OCSPServer(ClientRestrictingServerMixIn, BaseHTTPServer.HTTPServer):
+class OCSPServer(ClientRestrictingServerMixIn,
+                 BrokenPipeHandlerMixIn,
+                 BaseHTTPServer.HTTPServer):
   """This is a specialization of HTTPServer that serves an
   OCSP response"""
 
   def serve_forever_on_thread(self):
     self.thread = threading.Thread(target = self.serve_forever,
                                    name = "OCSPServerThread")
     self.thread.start()
 
   def stop_serving(self):
     self.shutdown()
     self.thread.join()
 
 
 class HTTPSServer(tlslite.api.TLSSocketServerMixIn,
                   ClientRestrictingServerMixIn,
+                  BrokenPipeHandlerMixIn,
                   StoppableHTTPServer):
   """This is a specialization of StoppableHTTPServer that add https support and
   client verification."""
 
   def __init__(self, server_address, request_hander_class, pem_cert_and_key,
                ssl_client_auth, ssl_client_cas, ssl_bulk_ciphers,
                record_resume_info, tls_intolerant):
     self.cert_chain = tlslite.api.X509CertChain().parseChain(pem_cert_and_key)
     self.private_key = tlslite.api.parsePEMKey(pem_cert_and_key, private=True)
     self.ssl_client_auth = ssl_client_auth
@@ skipping 31 matching lines @@
       tlsConnection.ignoreAbruptClose = True
       return True
     except tlslite.api.TLSAbruptCloseError:
       # Ignore abrupt close.
       return True
     except tlslite.api.TLSError, error:
       print "Handshake failure:", str(error)
       return False
 
 
-class SyncHTTPServer(ClientRestrictingServerMixIn, StoppableHTTPServer):
+class SyncHTTPServer(ClientRestrictingServerMixIn,
+                     BrokenPipeHandlerMixIn,
+                     StoppableHTTPServer):
   """An HTTP server that handles sync commands."""
 
   def __init__(self, server_address, xmpp_port, request_handler_class):
     # We import here to avoid pulling in chromiumsync's dependencies
     # unless strictly necessary.
     import chromiumsync
     import xmppserver
     StoppableHTTPServer.__init__(self, server_address, request_handler_class)
     self._sync_handler = chromiumsync.TestServer()
     self._xmpp_socket_map = {}
@@ skipping 2225 matching lines @@
                                   'round-robin fashion. The server will '
                                   'generate a random key if none is specified '
                                   'on the command line.')
     self.option_parser.add_option('--auth-token', dest='auth_token',
                                   help='Specify the auth token which should be '
                                   'used in the authorization header for GData.')
 
 
 if __name__ == '__main__':
   sys.exit(ServerRunner().main())