def send(request: Request) -> Response:
+ """Send an HTTP request and return a response or raise an error"""
+ loop = PollLoop()
+ asyncio.set_event_loop(loop)
+ return loop.run_until_complete(send_async(request))Send an HTTP request and return a response or raise an error
async def send_and_close(sink: Sink,
data: bytes)
async def send_and_close(sink: Sink, data: bytes):
+ await sink.send(data)
+ sink.close()
async def send_async(request: Request) ‑> Response
async def send_async(request: Request) -> Response:
+ match request.method:
+ case "GET":
+ method: Method = Method_Get()
+ case "HEAD":
+ method = Method_Head()
+ case "POST":
+ method = Method_Post()
+ case "PUT":
+ method = Method_Put()
+ case "DELETE":
+ method = Method_Delete()
+ case "CONNECT":
+ method = Method_Connect()
+ case "OPTIONS":
+ method = Method_Options()
+ case "TRACE":
+ method = Method_Trace()
+ case "PATCH":
+ method = Method_Patch()
+ case _:
+ method = Method_Other(request.method)
+
+ url_parsed = parse.urlparse(request.uri)
+
+ match url_parsed.scheme:
+ case "http":
+ scheme: Scheme = Scheme_Http()
+ case "https":
+ scheme = Scheme_Https()
+ case "":
+ scheme = Scheme_Http()
+ case _:
+ scheme = Scheme_Other(url_parsed.scheme)
+
+ headers_dict = request.headers
+
+ # Add a `content-length` header if the caller didn't include one, but did
+ # specify a body:
+ if headers_dict.get('content-length') is None:
+ content_length = len(request.body) if request.body is not None else 0
+ # Make a copy rather than mutate in place, since the caller might not
+ # expect us to mutate it:
+ headers_dict = headers_dict.copy()
+ headers_dict['content-length'] = str(content_length)
+
+ headers = list(map(
+ lambda pair: (pair[0], bytes(pair[1], "utf-8")),
+ headers_dict.items()
+ ))
+
+ outgoing_request = OutgoingRequest(Fields.from_list(headers))
+ outgoing_request.set_method(method)
+ outgoing_request.set_scheme(scheme)
+ if url_parsed.netloc == '':
+ if scheme == "http":
+ authority = ":80"
+ else:
+ authority = ":443"
+ else:
+ authority = url_parsed.netloc
+
+ outgoing_request.set_authority(authority)
+
+ path_and_query = url_parsed.path
+ if url_parsed.query:
+ path_and_query += '?' + url_parsed.query
+ outgoing_request.set_path_with_query(path_and_query)
+
+ outgoing_body = request.body if request.body is not None else bytearray()
+ sink = Sink(outgoing_request.body())
+ incoming_response: IncomingResponse = (await asyncio.gather(
+ poll_loop.send(outgoing_request),
+ send_and_close(sink, outgoing_body)
+ ))[0]
+
+ response_body = Stream(incoming_response.consume())
+ body = bytearray()
+ while True:
+ chunk = await response_body.next()
+ if chunk is None:
+ headers = incoming_response.headers()
+ simple_response = Response(
+ incoming_response.status(),
+ dict(map(
+ lambda pair: (pair[0], str(pair[1], "utf-8")),
+ headers.entries()
+ )),
+ bytes(body)
+ )
+ headers.__exit__(None, None, None)
+ incoming_response.__exit__(None, None, None)
+ return simple_response
+ else:
+ body += chunkSimplified handler for incoming HTTP requests using blocking, buffered I/O.
class IncomingHandler(exports.IncomingHandler):
+class IncomingHandler(Base):
"""Simplified handler for incoming HTTP requests using blocking, buffered I/O."""
-
+
def handle_request(self, request: Request) -> Response:
"""Handle an incoming HTTP request and return a response or raise an error"""
raise NotImplementedError
-
+
def handle(self, request: IncomingRequest, response_out: ResponseOutparam):
method = request.method()
@@ -164,6 +292,7 @@ Classes
response_stream.__exit__(None, None, None)
OutgoingBody.finish(response_body, None)
Simplified handler for incoming HTTP requests using blocking, buffered I/O.
def handle_request(self, request: Request) -> Response:
+ """Handle an incoming HTTP request and return a response or raise an error"""
+ raise NotImplementedErrorHandle an incoming HTTP request and return a response or raise an error
An HTTP request
An HTTP request
var body : bytes | NoneAn HTTP response
An HTTP response
var body : bytes | NoneRespo