Sent at Most Once

# delta/peer.py (trimmed excerpt): PeerClient.call, one write sent at most once
def call(self, label, path, *, body, headers=None, app=None, read_timeout=READ_TIMEOUT, force=None):
    def nothing_sent(exc):
        return Unavailable(f"{why(exc)}; nothing was sent to {label}")

    # Whatever fails from here to the send, of any kind, failed before the call left.
    try:
        route = self.delta.routes.get(label, force=force)
    except Exception as exc:
        raise nothing_sent(exc) from None
    try:
        conn, ticket = self._open_for_call(route, label)      # a new connection, never a pooled one
    except Exception as exc:
        if route.kind == "tailnet" or force:
            raise nothing_sent(exc) from None
        # The LAN route failed before anything left: drop it and choose once more.
        self.delta.routes.invalidate(label, why(exc))
        try:
            route = self.delta.routes.get(label, refresh=True)
            conn, ticket = self._open_for_call(route, label)
        except Exception as again:
            raise nothing_sent(again) from None

    # hdrs: Content-Length, X-Delta-App, X-Delta-Request-Id, built above
    renewed = False
    while True:
        if ticket:
            hdrs["Authorization"] = f"Delta {ticket}"
        try:
            conn.sock.settimeout(read_timeout)
            conn.request("POST", path, body=body, headers=hdrs)
            resp = conn.getresponse()
        except socket.timeout:
            conn.close()
            raise OutcomeUnknown(f"{label} did not answer the call within {read_timeout:g} s. The call had "
                                 "left this Mac, so it may or may not have been carried out; it is not sent again")
        except (http.client.HTTPException, ssl.SSLError, OSError) as exc:
            conn.close()
            raise OutcomeUnknown(f"the connection to {label} ended during the call ({type(exc).__name__}). "
                                 "It may or may not have been carried out; it is not sent again")
        out = Response(self, self._key(route), conn, resp, route, label, read_timeout, "POST")
        if out.status == 401 and route.needs_ticket and not renewed:
            # Refused at the door, before any verb ran: nothing was carried out. A new
            # ticket, a new connection, and the call goes once under it.
            renewed = True
            out.read()
            ticket = self.ticket(label, renew=True, refused=ticket)
            conn = self._connect(route, label)
            continue
        return out

# at_most_once.py: tell "nothing was sent" from "it left and no answer came back"
import http.client
import json
import socket
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

carried_out = []            # what the owner actually did


class Owner(BaseHTTPRequestHandler):
    def do_POST(self):
        body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
        carried_out.append(self.headers["X-Request-Id"])
        time.sleep(float(body.get("think", 0)))       # the owner's work, slow on purpose
        answer = json.dumps({"ok": True}).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(answer)))
        self.end_headers()
        self.wfile.write(answer)

    def log_message(self, *args):
        pass


def call(port: int, request_id: str, body: dict, timeout: float) -> str:
    """One write, sent at most once, on a connection of its own."""
    conn = http.client.HTTPConnection("127.0.0.1", port, timeout=2.0)
    try:
        conn.connect()
    except OSError as exc:
        return f"unavailable: {exc.strerror or exc}; nothing was sent"
    try:
        conn.sock.settimeout(timeout)
        conn.request("POST", "/call/write", body=json.dumps(body),
                     headers={"Content-Type": "application/json", "X-Request-Id": request_id})
        resp = conn.getresponse()
        return f"answered {resp.status}: {resp.read().decode()}"
    except (socket.timeout, OSError, http.client.HTTPException) as exc:
        return f"outcome_unknown: {type(exc).__name__}; it left, so it is not sent again"
    finally:
        conn.close()


server = ThreadingHTTPServer(("127.0.0.1", 0), Owner)
port = server.server_port
threading.Thread(target=server.serve_forever, daemon=True).start()

print("1.", call(port, "r-1", {"think": 0}, timeout=1.0))
print("2.", call(port, "r-2", {"think": 1.5}, timeout=0.5))
server.shutdown()
server.server_close()
print("3.", call(port, "r-3", {"think": 0}, timeout=1.0))
time.sleep(1.2)                                    # let r-2 finish on the owner's side
print("the owner carried out:", carried_out)