Retry-After 告诉你何时再试

from datetime import datetime, timedelta, timezone
from email.utils import format_datetime, parsedate_tz
from http.client import HTTPConnection
from http.server import BaseHTTPRequestHandler, HTTPServer
import re
from threading import Thread


UTC = timezone.utc
REFERENCE = datetime(2026, 9, 8, 12, 0, 0, tzinfo=UTC)


def delay_seconds(value, received_wall):
    if value is None:
        return None
    value = value.strip(" \t")
    if re.fullmatch(r"[0-9]+", value):
        # Huge decimal values become infinity and fail the bounded retry budget.
        return float(value)
    parts = parsedate_tz(value)
    if parts is None:
        return None
    year, month, day, hour, minute, second = parts[:6]
    old_date = re.fullmatch(r"[A-Za-z]+, [0-9]{2}-[A-Za-z]{3}-([0-9]{2}) [0-9:]{8} GMT", value)
    if old_date:
        now = datetime.fromtimestamp(received_wall, UTC)
        year = now.year // 100 * 100 + int(old_date[1])
        if (year, month, day, hour, minute, second) > (
            now.year + 50, now.month, now.day, now.hour, now.minute, now.second
        ):
            year -= 100
    if not 0 <= second <= 60:
        return None
    try:
        stamp = datetime(year, month, day, hour, minute, min(second, 59), tzinfo=UTC)
        stamp += timedelta(seconds=(second == 60) - parts[9])
    except (ValueError, OverflowError):
        return None
    return max(0.0, stamp.timestamp() - received_wall)


def retry_at(status, method, value, received_wall, monotonic_now, remaining, attempt, jitter=0.25):
    assert attempt >= 1 and jitter >= 0
    if status not in (429, 503) or method not in ("GET", "HEAD") or attempt >= 3:
        return None
    server_delay = delay_seconds(value, received_wall)
    wait = max(server_delay or 0.0, 2 ** (attempt - 1)) + jitter
    if wait >= remaining:
        return None
    return monotonic_now + wait


wall = REFERENCE.timestamp()
for value in ("Tue, 08 Sep 2026 12:00:07 GMT", "Tuesday, 08-Sep-26 12:00:07 GMT",
              "Tue Sep  8 12:00:07 2026"):
    assert delay_seconds(value, wall) == 7
assert delay_seconds("Sunday, 06-Nov-94 08:49:37 GMT", wall) == 0
assert delay_seconds("Monday, 08-Sep-70 12:00:00 GMT", wall) == (
    datetime(2070, 9, 8, 12, tzinfo=UTC).timestamp() - wall
)
assert delay_seconds("Sat, 31 Dec 2016 23:59:60 GMT",
                     datetime(2016, 12, 31, 23, 59, 59, tzinfo=UTC).timestamp()) == 1
for invalid in ("-1", "1.5", "later", "", "٣", "Tue, 31 Feb 2026 12:00:00 GMT"):
    assert delay_seconds(invalid, wall) is None
assert delay_seconds(" 0003\t", wall) == 3
assert retry_at(503, "GET", "9" * 5000, wall, 100, 10, 1) is None
assert retry_at(503, "GET", "3", wall, 100, 2, 1) is None
assert retry_at(503, "POST", "3", wall, 100, 10, 1) is None
assert retry_at(503, "GET", "3", wall, 100, 10, 3) is None
print("both delay forms, obsolete dates, year interpretation, and invalid values are checked")
print("an oversized wait, exhausted deadline, POST, or attempt cap stops this retry policy")

cases = {
    "/seconds": (429, "3"),
    "/date": (503, format_datetime(REFERENCE + timedelta(seconds=7), usegmt=True)),
    "/invalid": (503, "later"),
    "/missing": (503, None),
    "/redirect": (307, "3"),
    "/ready": (200, None),
}
visited = []


class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        visited.append(self.path)
        status, value = cases.get(self.path, (404, None))
        self.send_response_only(status)
        self.send_header("Date", format_datetime(REFERENCE, usegmt=True))
        if value is not None:
            self.send_header("Retry-After", value)
        if status == 307:
            self.send_header("Location", "/ready")
        self.send_header("Content-Length", "0")
        self.end_headers()

    def log_message(self, *_):
        pass


with HTTPServer(("127.0.0.1", 0), Handler) as server:
    thread = Thread(target=server.serve_forever, kwargs={"poll_interval": 0.05})
    thread.start()
    try:
        for route, expected in (("/seconds", 103.25), ("/date", 107.25),
                                ("/invalid", 101.25), ("/missing", 101.25), ("/redirect", None)):
            client = HTTPConnection(*server.server_address, timeout=2)
            try:
                client.request("GET", route)
                response = client.getresponse()
                response.read()
                planned = retry_at(response.status, "GET", response.getheader("Retry-After"),
                                   wall, 100, 10, 1)
                assert planned == expected
                print(route, "status", response.status, "planned monotonic time", planned)
            finally:
                client.close()
        assert "/ready" not in visited
    finally:
        server.shutdown()
        thread.join(timeout=2)
        assert not thread.is_alive()

same_delay = [retry_at(429, "GET", "3", wall, 100, 10, 1, jitter=0) for _ in range(4)]
spread = [retry_at(429, "GET", "3", wall, 100, 10, 1, jitter=j) for j in (0.1, 0.2, 0.3, 0.4)]
assert same_delay == [103] * 4
assert len(set(spread)) == 4 and min(spread) > 103
print("identical server delays synchronize plans; injected positive jitter spreads them:", spread)