Class APIHandler

c/openai_server.py:3463–4508

class APIHandler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"
    timeout = 30   # per socket OPERATION. On its own this does not stop a slowloris:
                   # it restarts on every byte received, so a drip renews it forever.
                   # READ_DEADLINE below is the cumulative bound that actually does.
    READ_DEADLINE = _positive_env("COLI_READ_DEADLINE", 30)  # accept -> request read
    server_version = "colibri"
    _committed = False    # status line already on the wire; reset per request below
    _body_read = False    # request body fully consumed, so nothing is left to drain

    def setup(self):
        super().setup()
        # Keep the socket-backed reader; handle_one_request re-wraps it with a
        # fresh deadline per request rather than wrapping a wrapper each time.
        self._raw_rfile = self.rfile

    def log_message(self, fmt, *args):
        sys.stderr.write("[api] %s - %s\n" % (self.address_string(), fmt % args))

    def handle_one_request(self):
        """Per-request bookkeeping for HTTP/1.1 persistence (#597 item 3).

        One handler instance serves every request on a keep-alive connection, so both flags
        reset here rather than in do_POST. The drain afterwards is the whole fix for the
        reported `Bad request syntax ('{...json...}POST /v1/...')`: any early rejection --
        403 Host, 401 auth, a bad or oversized Content-Length -- returns before read_json(),
        leaving the body in the socket, where the next readline() eats it as a request line.
        Draining once at the request boundary covers every such path, present and future,
        instead of asking each early return to remember."""
        self._committed = False
        self._body_read = False
        # Fresh budget per request: a keep-alive connection may serve many, and
        # each is entitled to its own read window -- but none may drip forever.
        self.rfile = _DeadlineReader(self._raw_rfile, self.connection,
                                     self.timeout, self.READ_DEADLINE)
        try:
            super().handle_one_request()
        except TimeoutError:
            # The read budget ran out. Say so and close; do not answer, because
            # we never received a complete request to answer.
            sys.stderr.write("[api] %s - request read deadline exceeded\n"
                             % self.address_string())
            self.close_connection = True
            return
        except ConnectionError:
            # ConnectionError, not (BrokenPipeError, ConnectionResetError): those two
            # are SIBLINGS of ConnectionAbortedError under it, so the pair caught the
            # POSIX spellings and let the Windows one through. #854's log is pages of
            # `ConnectionAbortedError: [WinError 10053] An established connection was
            # aborted by the software in your host machine` escaping to socketserver,
            # from a `coli web` start that was otherwise healthy.
            #
            # The client hung up mid-response. That is not an error here, it is
            # how HTTP clients behave: `coli chat` polls /health while the model
            # loads and drops each connection as soon as it has its answer, and
            # Ctrl-C during a stream closes the socket by design -- the banner
            # tells the user to do exactly that. Without this, socketserver's
            # handler prints a full traceback per occurrence, so a normal start