Fix "None-None" race condition with keep-alive timeout

Keep-alives are handled by a scheduled routine, which closes the
connection if the keep-alive has expired. The routine calculates the
keep-alive time remaining based on the last response time, but that's
not set until after the routine is scheduled, creating a race
condition. The fix is to set the last response time before scheduling
the keep-alive routine. Additionally the calculation is a bit more
robust now, so the scheduled routine doesn't need to deal with None.

The async code is largely imported from [sanic](https://github.com/huge-success/sanic),
modified and stripped-down to reduce cold start times.

Addresses issue #103

Author: Matt Curtis

fdk/async_http/protocol.py

@@ -228,6 +228,15 @@ def response_timeout_callback(self):
                 self._request_handler_task.cancel()
             self.write_error(ServiceUnavailable("Response Timeout"))
 
+    def keep_alive_time_left(self):
+        """
+        Return keep alive time remaining, zero if no response written yet.
+        """
+        if self._last_response_time and current_time:
+            time_elapsed = current_time - self._last_response_time
+            return self.keep_alive_timeout - time_elapsed
+        return 0
+
     def keep_alive_timeout_callback(self):
         """
         Check if elapsed time since last response exceeds our configured
@@ -236,9 +245,8 @@ def keep_alive_timeout_callback(self):
 
         :return: None
         """
-        time_elapsed = current_time - self._last_response_time
-        if time_elapsed < self.keep_alive_timeout:
-            time_left = self.keep_alive_timeout - time_elapsed
+        time_left = self.keep_alive_time_left()
+        if time_left >= 0:
             self._keep_alive_timeout_handler = self.loop.call_later(
                 time_left, self.keep_alive_timeout_callback
             )
@@ -431,10 +439,10 @@ def write_response(self, response):
                 self.transport.close()
                 self.transport = None
             else:
+                self._last_response_time = current_time
                 self._keep_alive_timeout_handler = self.loop.call_later(
                     self.keep_alive_timeout, self.keep_alive_timeout_callback
                 )
-                self._last_response_time = current_time
                 self.cleanup()
 
     async def drain(self):
@@ -483,10 +491,10 @@ async def stream_response(self, response):
                 self.transport.close()
                 self.transport = None
             else:
+                self._last_response_time = current_time
                 self._keep_alive_timeout_handler = self.loop.call_later(
                     self.keep_alive_timeout, self.keep_alive_timeout_callback
                 )
-                self._last_response_time = current_time
                 self.cleanup()
 
     def write_error(self, exception):

fdk/async_http/signpost.md

@@ -0,0 +1,6 @@
+This code is from https://github.com/huge-success/sanic/
+
+It's modified and stripped-down because importing full sanic
+increased cold starts.
+
+See https://github.com/fnproject/fdk-python/pull/60 for context.

fdk/tests/test_protocol.py

@@ -0,0 +1,41 @@
+# 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
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from fdk.async_http import protocol
+
+
+def http_protocol(**kwargs):
+    return protocol.HttpProtocol(
+        loop=None, request_handler=None, error_handler=None,
+        **kwargs)
+
+
+def test_keep_alive_time_left_before_time_is_set():
+    p = http_protocol()
+
+    protocol.current_time = None
+    p._last_request_time = None
+
+    time_left = p.keep_alive_time_left()
+    assert 0 == time_left
+
+
+def test_keep_alive_time_left_after_time_is_set():
+    p = http_protocol(keep_alive_timeout=15)
+
+    protocol.current_time = 96
+    p._last_response_time = 64
+
+    time_left = p.keep_alive_time_left()
+    assert 15 - 32 == time_left