Simplify HTTP/3. Remove chunked encoding and excessive logging.

sanic/http/http3.py

@@ -152,24 +152,20 @@ class HTTPReceiver(Receiver, Stream):
         size = len(response.body) if response.body else 0
         headers = response.headers
         status = response.status
-
+        want_body = (
-        if not has_message_body(status) and (
             size
             or "content-length" in headers
             or "transfer-encoding" in headers
-        ):
+        )
+        headers.pop("transfer-encoding", None)  # Not used with HTTP/3
+        if want_body and not has_message_body(status):
             headers.pop("content-length", None)
-            headers.pop("transfer-encoding", None)
             logger.warning(  # no cov
                 f"Message body set in response on {self.request.path}. "
                 f"A {status} response may only have headers, no body."
             )
-        elif "content-length" not in headers:
+        elif size and "content-length" not in headers:
-            if size:
             headers["content-length"] = size
-            else:
-                headers["transfer-encoding"] = "chunked"
-
         headers = [
             (b":status", str(response.status).encode()),
             *response.processed_headers,
@@ -195,18 +191,8 @@ class HTTPReceiver(Receiver, Stream):
         self.headers_sent = True
         self.stage = Stage.RESPONSE
 
-        if self.response.body and not self.head_only:
-            self._send(self.response.body, False)
-        elif self.head_only:
-            self.future.cancel()
-
     def respond(self, response: BaseHTTPResponse) -> BaseHTTPResponse:
         """Prepare response to client"""
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[respond]:{Colors.END} {response}",
-            extra={"verbosity": 2},
-        )
-
         if self.stage is not Stage.HANDLER:
             self.stage = Stage.FAILED
             raise RuntimeError("Response already started")
@@ -229,38 +215,14 @@ class HTTPReceiver(Receiver, Stream):
 
     async def send(self, data: bytes, end_stream: bool) -> None:
         """Send data to client"""
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[send]: {Colors.GREEN}data={data.decode()} "
-            f"end_stream={end_stream}{Colors.END}",
-            extra={"verbosity": 2},
-        )
-        self._send(data, end_stream)
-
-    def _send(self, data: bytes, end_stream: bool) -> None:
         if not self.headers_sent:
             self.send_headers()
         if self.stage is not Stage.RESPONSE:
             raise ServerError(f"not ready to send: {self.stage}")
 
-        # Chunked
+        if data and self.head_only:
-        if (
+            data = b""
-            self.response
-            and self.response.headers.get("transfer-encoding") == "chunked"
-        ):
-            size = len(data)
-            if end_stream:
-                data = (
-                    b"%x\r\n%b\r\n0\r\n\r\n" % (size, data)
-                    if size
-                    else b"0\r\n\r\n"
-                )
-            elif size:
-                data = b"%x\r\n%b\r\n" % (size, data)
 
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[transmitting]{Colors.END}",
-            extra={"verbosity": 2},
-        )
         self.protocol.connection.send_data(
             stream_id=self.request.stream_id,
             data=data,

sanic/http/tls/context.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import os
 import ssl
 
-from pathlib import Path, PurePath
 from typing import Any, Dict, Iterable, Optional, Union
 
 from sanic.log import logger
@@ -40,23 +39,23 @@ def create_context(
 
 
 def shorthand_to_ctx(
-    ctxdef: Union[None, ssl.SSLContext, dict, PurePath, str]
+    ctxdef: Union[None, ssl.SSLContext, dict, str]
 ) -> Optional[ssl.SSLContext]:
     """Convert an ssl argument shorthand to an SSLContext object."""
     if ctxdef is None or isinstance(ctxdef, ssl.SSLContext):
         return ctxdef
-    if isinstance(ctxdef, (PurePath, str)):
+    if isinstance(ctxdef, str):
-        return load_cert_dir(Path(ctxdef))
+        return load_cert_dir(ctxdef)
     if isinstance(ctxdef, dict):
         return CertSimple(**ctxdef)
     raise ValueError(
         f"Invalid ssl argument {type(ctxdef)}."
-        " Expecting one/list of: certdir | dict | SSLContext"
+        " Expecting a list of certdirs, a dict or an SSLContext."
     )
 
 
 def process_to_context(
-    ssldef: Union[None, ssl.SSLContext, dict, PurePath, str, list, tuple]
+    ssldef: Union[None, ssl.SSLContext, dict, str, list, tuple]
 ) -> Optional[ssl.SSLContext]:
     """Process app.run ssl argument from easy formats to full SSLContext."""
     return (
@@ -66,11 +65,11 @@ def process_to_context(
     )
 
 
-def load_cert_dir(p: Path) -> ssl.SSLContext:
+def load_cert_dir(p: str) -> ssl.SSLContext:
-    if p.is_file():
+    if os.path.isfile(p):
         raise ValueError(f"Certificate folder expected but {p} is a file.")
-    keyfile = p / "privkey.pem"
+    keyfile = os.path.join(p, "privkey.pem")
-    certfile = p / "fullchain.pem"
+    certfile = os.path.join(p, "fullchain.pem")
     if not os.access(keyfile, os.R_OK):
         raise ValueError(
             f"Certificate not found or permission denied {keyfile}"