diff --git a/lib/java/test/org/apache/thrift/test/TestClient.java b/lib/java/test/org/apache/thrift/test/TestClient.java
index feaa972..84410ce 100644
--- a/lib/java/test/org/apache/thrift/test/TestClient.java
+++ b/lib/java/test/org/apache/thrift/test/TestClient.java
@@ -752,13 +752,18 @@
         testClient.testOneway(3);
         long onewayElapsedMillis = (System.nanoTime() - startOneway) / 1000000;
         if (onewayElapsedMillis > 200) {
-          System.out.println("Oneway test failed: took " +
+          System.out.println("Oneway test took too long to execute failed: took " +
                              Long.toString(onewayElapsedMillis) +
                              "ms");
-          System.out.printf("*** FAILURE ***\n");
+          System.out.println("oneway calls are 'fire and forget' and therefore should not cause blocking.");
+          System.out.println("Some transports (HTTP) have a required response, and typically this failure");
+          System.out.println("means the transport response was delayed until after the execution");
+          System.out.println("of the RPC.  The server should post the transport response immediately and");
+          System.out.println("before executing the RPC.");
+          System.out.println("*** FAILURE ***");
           returnCode |= ERR_BASETYPES;
         } else {
-          System.out.println("Success - took " +
+          System.out.println("Success - fire and forget only took " +
                              Long.toString(onewayElapsedMillis) +
                              "ms");
         }
diff --git a/lib/py/src/TMultiplexedProcessor.py b/lib/py/src/TMultiplexedProcessor.py
index bd10d9b..ff88430 100644
--- a/lib/py/src/TMultiplexedProcessor.py
+++ b/lib/py/src/TMultiplexedProcessor.py
@@ -39,6 +39,10 @@
     def registerProcessor(self, serviceName, processor):
         self.services[serviceName] = processor
 
+    def on_message_begin(self, func):
+        for key in self.services.keys():
+            self.services[key].on_message_begin(func)
+
     def process(self, iprot, oprot):
         (name, type, seqid) = iprot.readMessageBegin()
         if type != TMessageType.CALL and type != TMessageType.ONEWAY:
diff --git a/lib/py/src/Thrift.py b/lib/py/src/Thrift.py
index 00941d8..c390cbb 100644
--- a/lib/py/src/Thrift.py
+++ b/lib/py/src/Thrift.py
@@ -72,6 +72,18 @@
     """Base class for processor, which works on two streams."""
 
     def process(self, iprot, oprot):
+        """
+        Process a request.  The normal behvaior is to have the
+        processor invoke the correct handler and then it is the
+        server's responsibility to write the response to oprot.
+        """
+        pass
+
+    def on_message_begin(self, func):
+        """
+        Install a callback that receives (name, type, seqid)
+        after the message header is read.
+        """
         pass
 
 
diff --git a/lib/py/src/server/THttpServer.py b/lib/py/src/server/THttpServer.py
index 85cf400..47e817d 100644
--- a/lib/py/src/server/THttpServer.py
+++ b/lib/py/src/server/THttpServer.py
@@ -21,6 +21,7 @@
 
 from six.moves import BaseHTTPServer
 
+from thrift.Thrift import TMessageType
 from thrift.server import TServer
 from thrift.transport import TTransport
 
@@ -32,7 +33,9 @@
     to override this behavior (e.g., to simulate a misconfigured or
     overloaded web server during testing), it can raise a ResponseException.
     The function passed to the constructor will be called with the
-    RequestHandler as its only argument.
+    RequestHandler as its only argument.  Note that this is irrelevant
+    for ONEWAY requests, as the HTTP response must be sent before the
+    RPC is processed.
     """
     def __init__(self, handler):
         self.handler = handler
@@ -43,6 +46,9 @@
 
     This class is not very performant, but it is useful (for example) for
     acting as a mock version of an Apache-based PHP Thrift endpoint.
+    Also important to note the HTTP implementation pretty much violates the
+    transport/protocol/processor/server layering, by performing the transport
+    functions here.  This means things like oneway handling are oddly exposed.
     """
     def __init__(self,
                  processor,
@@ -68,26 +74,45 @@
                                  inputProtocolFactory, outputProtocolFactory)
 
         thttpserver = self
+        self._replied = None
 
         class RequestHander(BaseHTTPServer.BaseHTTPRequestHandler):
             def do_POST(self):
                 # Don't care about the request path.
-                itrans = TTransport.TFileObjectTransport(self.rfile)
-                otrans = TTransport.TFileObjectTransport(self.wfile)
+                thttpserver._replied = False
+                iftrans = TTransport.TFileObjectTransport(self.rfile)
                 itrans = TTransport.TBufferedTransport(
-                    itrans, int(self.headers['Content-Length']))
+                    iftrans, int(self.headers['Content-Length']))
                 otrans = TTransport.TMemoryBuffer()
                 iprot = thttpserver.inputProtocolFactory.getProtocol(itrans)
                 oprot = thttpserver.outputProtocolFactory.getProtocol(otrans)
                 try:
+                    thttpserver.processor.on_message_begin(self.on_begin)
                     thttpserver.processor.process(iprot, oprot)
                 except ResponseException as exn:
                     exn.handler(self)
                 else:
+                    if not thttpserver._replied:
+                        # If the request was ONEWAY we would have replied already
+                        data = otrans.getvalue()
+                        self.send_response(200)
+                        self.send_header("Content-Length", len(data))
+                        self.send_header("Content-Type", "application/x-thrift")
+                        self.end_headers()
+                        self.wfile.write(data)
+
+            def on_begin(self, name, type, seqid):
+                """
+                Inspect the message header.
+
+                This allows us to post an immediate transport response
+                if the request is a ONEWAY message type.
+                """
+                if type == TMessageType.ONEWAY:
                     self.send_response(200)
-                    self.send_header("content-type", "application/x-thrift")
+                    self.send_header("Content-Type", "application/x-thrift")
                     self.end_headers()
-                    self.wfile.write(otrans.getvalue())
+                    thttpserver._replied = True
 
         self.httpd = server_class(server_address, RequestHander)