Windows socket connection delay

[stacy-rendall]

Bug report

Context

We have a pair of AWS Lambda functions that are doing some URL path and header manipulation as part of an AWS API Gateway setup.

I was attempting to simply replicate the pair of functions within a local server so we could do simple local dev/test/debug of the lamba scripts without AWS getting in the way, by creating a FastAPI service hosting the two functions and structuring/destructuring to abstract the AWS bits.

The flow is: request hits Proxy lamba, which calls API lambda, which calls the server, then the response flows back via API to proxy and back to client.

Bug description

When calling the Proxy lambda, which is the normal flow, a two second delay appears in the Proxy lambda call to the API lambda, so the entire call is always 2 seconds plus a handful of milliseconds. This specific value, which remains constant irrespective of the response payload size, is suspicious.

I've created a minimum working example demonstrating the issue here: https://proxy-ga.blitzz.co/proxy/123456/bitbucket.org/stacyr/mwe-windows-socket-delay/src/main/

My suspicion based upon the failing and successful workarounds below is that socket, which I believe is used by urllib, is introducing some kind of timeout on Windows.

Your environment

• CPython versions tested on: 3.11.4, 3.9.16
• Operating system and architecture: Windows 10 Pro 64-bit

Workarounds

I've tested a range of unsuccessful ways to try and circumvent the issue:

• separate servers:
  • hosting one Lambda on Flask, the other on FastAPI
  • hosting both on completely separate Python installs as well as separate servers
• use built in urllib rather than urllib3 to call between the lambdas

I finally have identified a couple of workarounds, for which the 2 second delay does not occur

Specify a connect timeout

Either, i.e. urllib.request.urlopen(url, timeout=0.5) or

timeout = urllib3.util.Timeout(connect=0.000001)
http = urllib3.PoolManager(timeout=timeout)

It does not make sense why a short connect timeout would solve the problem - connection timeout should specify how long the request waits to connect, if the upstream is slow. If it can connect in a fraction of a millisecond, why is it delaying for two seconds?

Use WSL

As described in MWE readme, running the server on WSL also does not exhibit the delay.

[terryjreedy]

This tracker is for fixing bugs in the stdlib. Your demonstration uses 2 third party modules: fastapi and aws. Can you show the same delay with stdlib functions?

[stacy-rendall]

Thanks @terryjreedy - AWS is just mentioned for context as to how the issue was noticed, not used in any way by the MWE. I agree the example does use FastAPI, but subbing that out for Flask results in identical behaviour, as does using standard urllib rather than urllib3 from the lambda function calls, I think this reproducability is indicative of something deeper...

I've updated the OP to explain that I suspect socket is introducing a delay on Windows

Unfortunately I am not sure how I would build an API server completely on stdlib to replicate this.

[stacy-rendall]

OK, I've managed to make a stdlib only version that replicates the issue.

The "OUTER" path receives the initial request, which then makes a subsequent request to the "INNER" path. The bug: there is a 2-second delay before the INNER path is called.

As noted above the following workarounds are possible:

1. setting a timeout shorter than 2 seconds will prevent this, i.e. urllib.request.urlopen(url, timeout=0.5)
2. using WSL there is no delay

MWE:

import http.server
import time
from urllib.request import Request, urlopen

PORT = 8000
API_URL = f"http://localhost:{PORT}/api"


class RESTRequestHandler(http.server.BaseHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        return http.server.BaseHTTPRequestHandler.__init__(self, *args, **kwargs)

    def do_GET(self):
        if self.path.startswith("/api/"):
            print("INNER path")
            t0 = time.perf_counter()
            response = '{"a": 123}'.encode()
            print("... INNER response", time.perf_counter() - t0)
        else:
            print("OUTER path")
            t0 = time.perf_counter()

            # get path to inner
            _, _, *path = self.path.split("/")
            inner_url = f"{API_URL}/{'/'.join(path)}"

            # call inner
            request = Request(inner_url)
            response_raw = urlopen(request)
            response = response_raw.read()
            print("... OUTER response", time.perf_counter() - t0)

        self.send_response(200)
        self.send_header("Content-type", "application/json")
        self.end_headers()
        self.wfile.write(response)


def rest_server(port):
    http_server = http.server.ThreadingHTTPServer(("", port), RESTRequestHandler)
    print(f"Starting HTTP server at port {port}")
    try:
        http_server.serve_forever()
    except KeyboardInterrupt:
        pass
    finally:
        print("Stopping HTTP server")
        http_server.server_close()


if __name__ == "__main__":
    rest_server(PORT)