def test_headers_only(self):
with client_and_server(
client_options={"alpn_protocols": ["hq-23"]},
server_options={"alpn_protocols": ["hq-23"]},
) as (quic_client, quic_server):
h0_client = H0Connection(quic_client)
h0_server = H0Connection(quic_server)
# send request
stream_id = quic_client.get_next_available_stream_id()
h0_client.send_headers(
stream_id=stream_id,
headers=[
(b":method", b"HEAD"),
(b":scheme", b"https"),
(b":authority", b"localhost"),
(b":path", b"/"),
],
end_stream=True,
)
# receive request
events = h0_transfer(quic_client, h0_server)
self.assertEqual(len(events), 2)
self.assertTrue(isinstance(events[0], HeadersReceived))
self.assertEqual(events[0].headers, [(b":method", b"HEAD"),
(b":path", b"/")])
self.assertEqual(events[0].stream_id, stream_id)
self.assertEqual(events[0].stream_ended, False)
self.assertTrue(isinstance(events[1], DataReceived))
self.assertEqual(events[1].data, b"")
self.assertEqual(events[1].stream_id, stream_id)
self.assertEqual(events[1].stream_ended, True)
# send response
h0_server.send_headers(
stream_id=stream_id,
headers=[
(b":status", b"200"),
(b"content-type", b"text/html; charset=utf-8"),
],
end_stream=True,
)
# receive response
events = h0_transfer(quic_server, h0_client)
self.assertEqual(len(events), 2)
self.assertTrue(isinstance(events[0], HeadersReceived))
self.assertEqual(events[0].headers, [])
self.assertEqual(events[0].stream_id, stream_id)
self.assertEqual(events[0].stream_ended, False)
self.assertTrue(isinstance(events[1], DataReceived))
self.assertEqual(events[1].data, b"")
self.assertEqual(events[1].stream_id, stream_id)
self.assertEqual(events[1].stream_ended, True)
def quic_event_received(self, event: QuicEvent) -> None:
global totalQuicEvents
totalQuicEvents += 1
# logger.info('quic event recieved:{}'.format(totalQuicEvents))
if isinstance(event, ProtocolNegotiated):
if event.alpn_protocol.startswith("h3-"):
self._http = H3Connection(self._quic)
elif event.alpn_protocol.startswith("hq-"):
self._http = H0Connection(self._quic)
elif event.alpn_protocol.startswith("quic"):
self.quic_client = True
if isinstance(event, DatagramFrameReceived):
if event.data == b'quic':
self._quic.send_datagram_frame(b'quic-ack')
if isinstance(event, StreamDataReceived):
# logger.info('aakash kuch to aaya')
if self.quic_client is True:
print(f"print event {event.data}")
data = b'quic stream-data recv'
end_stream = False
self._quic.send_stream_data(event.stream_id, data, end_stream)
else:
#TODO: Yet to handle a http_client streamDataReceived event
pass
# pass event to the HTTP layer
if self._http is not None:
for http_event in self._http.handle_event(event):
logger.debug('http event recieved')
self.http_event_received(http_event)
def quic_event_received(self, event: QuicEvent):
if isinstance(event, ProtocolNegotiated):
if event.alpn_protocol == "h3-22":
self._http = H3Connection(self._quic)
elif event.alpn_protocol == "hq-22":
self._http = H0Connection(self._quic)
# pass event to the HTTP layer
if self._http is not None:
for http_event in self._http.handle_event(event):
self.http_event_received(http_event)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._http: Optional[HttpConnection] = None
self._request_events: Dict[int, Deque[H3Event]] = {}
self._request_waiter: Dict[int, asyncio.Future[Deque[H3Event]]] = {}
self._websockets: Dict[int, WebSocket] = {}
if self._quic.configuration.alpn_protocols[0].startswith("hq-"):
self._http = H0Connection(self._quic)
else:
self._http = H3Connection(self._quic)
def quic_event_received(self, event: QuicEvent) -> None:
if isinstance(event, ProtocolNegotiated):
if event.alpn_protocol.startswith("h3-"):
self._http = H3Connection(self._quic)
elif event.alpn_protocol.startswith("hq-"):
self._http = H0Connection(self._quic)
elif isinstance(event, DatagramFrameReceived):
if event.data == b"quack":
self._quic.send_datagram_frame(b"quack-ack")
# pass event to the HTTP layer
if self._http is not None:
for http_event in self._http.handle_event(event):
self.http_event_received(http_event)
def quic_event_received(self, event: QuicEvent) -> None:
if isinstance(event, ProtocolNegotiated):
if event.alpn_protocol in H3_ALPN:
self._http = H3Connection(self._quic, enable_webtransport=True)
elif event.alpn_protocol in H0_ALPN:
self._http = H0Connection(self._quic)
elif isinstance(event, DatagramFrameReceived):
if event.data == b"quack":
self._quic.send_datagram_frame(b"quack-ack")
# pass event to the HTTP layer
if self._http is not None:
for http_event in self._http.handle_event(event):
self.http_event_received(http_event)
def test_fragmented_request(self):
with h0_client_and_server() as (quic_client, quic_server):
h0_server = H0Connection(quic_server)
stream_id = 0
# receive first fragment of the request
events = h0_server.handle_event(
StreamDataReceived(data=b"GET /012",
end_stream=False,
stream_id=stream_id))
self.assertEqual(len(events), 0)
# receive second fragment of the request
events = h0_server.handle_event(
StreamDataReceived(data=b"34567890",
end_stream=False,
stream_id=stream_id))
# receive final fragment of the request
events = h0_server.handle_event(
StreamDataReceived(data=b"123456\r\n",
end_stream=True,
stream_id=stream_id))
self.assertEqual(len(events), 2)
self.assertTrue(isinstance(events[0], HeadersReceived))
self.assertEqual(
events[0].headers,
[(b":method", b"GET"), (b":path", b"/01234567890123456")],
)
self.assertEqual(events[0].stream_id, stream_id)
self.assertEqual(events[0].stream_ended, False)
self.assertTrue(isinstance(events[1], DataReceived))
self.assertEqual(events[1].data, b"")
self.assertEqual(events[1].stream_id, stream_id)
self.assertEqual(events[1].stream_ended, True)
def test_connect(self):
with h0_client_and_server() as (quic_client, quic_server):
h0_client = H0Connection(quic_client)
h0_server = H0Connection(quic_server)
# send request
stream_id = quic_client.get_next_available_stream_id()
h0_client.send_headers(
stream_id=stream_id,
headers=[
(b":method", b"GET"),
(b":scheme", b"https"),
(b":authority", b"localhost"),
(b":path", b"/"),
],
)
h0_client.send_data(stream_id=stream_id, data=b"", end_stream=True)
# receive request
events = h0_transfer(quic_client, h0_server)
self.assertEqual(len(events), 2)
self.assertTrue(isinstance(events[0], HeadersReceived))
self.assertEqual(events[0].headers, [(b":method", b"GET"),
(b":path", b"/")])
self.assertEqual(events[0].stream_id, stream_id)
self.assertEqual(events[0].stream_ended, False)
self.assertTrue(isinstance(events[1], DataReceived))
self.assertEqual(events[1].data, b"")
self.assertEqual(events[1].stream_id, stream_id)
self.assertEqual(events[1].stream_ended, True)
# send response
h0_server.send_headers(
stream_id=stream_id,
headers=[
(b":status", b"200"),
(b"content-type", b"text/html; charset=utf-8"),
],
)
h0_server.send_data(
stream_id=stream_id,
data=b"<html><body>hello</body></html>",
end_stream=True,
)
# receive response
events = h0_transfer(quic_server, h0_client)
self.assertEqual(len(events), 2)
self.assertTrue(isinstance(events[0], HeadersReceived))
self.assertEqual(events[0].headers, [])
self.assertEqual(events[0].stream_id, stream_id)
self.assertEqual(events[0].stream_ended, False)
self.assertTrue(isinstance(events[1], DataReceived))
self.assertEqual(events[1].data,
b"<html><body>hello</body></html>")
self.assertEqual(events[1].stream_id, stream_id)
self.assertEqual(events[1].stream_ended, True)
