path
stringlengths 9
117
| type
stringclasses 2
values | project
stringclasses 10
values | commit_hash
stringlengths 40
40
| commit_message
stringlengths 1
137
| ground_truth
stringlengths 0
2.74k
| main_code
stringlengths 102
3.37k
| context
stringlengths 0
14.7k
|
|---|---|---|---|---|---|---|---|
aioquic.connection/QuicConnection._handle_stream_frame
|
Modified
|
aiortc~aioquic
|
acd070ffde074ed00a5cd4ada33bf99170693d5e
|
[stream] don't use QuicStreamFlag, IntFlag "or" operations are slow
|
<3>:<del> flags = frame_type & STREAM_FLAGS
<5>:<add> if frame_type & 4:
<del> if flags & QuicStreamFlag.OFF:
<9>:<add> if frame_type & 2:
<del> if flags & QuicStreamFlag.LEN:
<14>:<del> offset=offset,
<15>:<del> data=pull_bytes(buf, length),
<16>:<del> fin=bool(flags & QuicStreamFlag.FIN),
<17>:<add> offset=offset, data=pull_bytes(buf, length), fin=bool(frame_type & 1)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_stream_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a STREAM frame.
<2> """
<3> flags = frame_type & STREAM_FLAGS
<4> stream_id = pull_uint_var(buf)
<5> if flags & QuicStreamFlag.OFF:
<6> offset = pull_uint_var(buf)
<7> else:
<8> offset = 0
<9> if flags & QuicStreamFlag.LEN:
<10> length = pull_uint_var(buf)
<11> else:
<12> length = buf.capacity - buf.tell()
<13> frame = QuicStreamFrame(
<14> offset=offset,
<15> data=pull_bytes(buf, length),
<16> fin=bool(flags & QuicStreamFlag.FIN),
<17> )
<18>
<19> # check stream direction
<20> self._assert_stream_can_receive(frame_type, stream_id)
<21>
<22> # check flow-control limits
<23> stream = self._get_or_create_stream(frame_type, stream_id)
<24> if offset + length > stream.max_stream_data_local:
<25> raise QuicConnectionError(
<26> error_code=QuicErrorCode.FLOW_CONTROL_ERROR,
<27> frame_type=frame_type,
<28> reason_phrase="Over stream data limit",
<29> )
<30> newly_received = max(0, offset + length - stream._recv_highest)
<31> if self._local_max_data_used + newly_received > self._local_max_data:
<32> raise QuicConnectionError(
<33> error_code=QuicErrorCode.FLOW_CONTROL_ERROR,
<34> frame_type=frame_type,
<35> reason_phrase="Over connection data limit",
<36> )
<37>
<38> stream.add_frame(frame)
<39> self._local_max_data_used += newly_received
<40>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint_var(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_assert_stream_can_receive(frame_type: int, stream_id: int) -> None
_get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection.__init__
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_used = 0
at: aioquic.connection.QuicConnection._write_connection_limits
self._local_max_data += MAX_DATA_WINDOW
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_local = max_stream_data_local
self._recv_highest = 0 # the highest offset ever seen
at: aioquic.stream.QuicStream.add_frame
self._recv_highest = frame_end
===========changed ref 0===========
# module: aioquic.packet
- class QuicStreamFlag(IntFlag):
- FIN = 0x01
- LEN = 0x02
- OFF = 0x04
-
===========changed ref 1===========
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
max_offset: int,
) -> int:
buf = builder.buffer
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ size_uint_var(stream.stream_id)
+ (size_uint_var(stream.next_send_offset) if stream.next_send_offset else 0)
)
previous_send_highest = stream._send_highest
frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
if frame is not None:
+ frame_type = QuicFrameType.STREAM_BASE | 2 # length
- flags = QuicStreamFlag.LEN
if frame.offset:
+ frame_type |= 4
- flags |= QuicStreamFlag.OFF
if frame.fin:
+ frame_type |= 1
- flags |= QuicStreamFlag.FIN
builder.start_frame(
+ frame_type,
- QuicFrameType.STREAM_BASE | flags,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
push_uint_var(buf, stream.stream_id)
if frame.offset:
push_uint_var(buf, frame.offset)
push_uint16(buf, len(frame.data) | 0x4000)
push_bytes(buf, frame.data)
return stream._send_highest - previous_send_highest
else:
return 0
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_data
|
Modified
|
aiortc~aioquic
|
acd070ffde074ed00a5cd4ada33bf99170693d5e
|
[stream] don't use QuicStreamFlag, IntFlag "or" operations are slow
|
<5>:<add> frame_type = QuicFrameType.STREAM_BASE | 4
<del> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_data(self):
<0> with client_and_server() as (client, server):
<1> # artificially raise received data counter
<2> client._local_max_data_used = client._local_max_data
<3>
<4> # client receives STREAM frame
<5> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
<6> stream_id = 1
<7> with self.assertRaises(QuicConnectionError) as cm:
<8> client._handle_stream_frame(
<9> client_receive_context(client),
<10> frame_type,
<11> Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)),
<12> )
<13> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)
<14> self.assertEqual(cm.exception.frame_type, frame_type)
<15> self.assertEqual(cm.exception.reason_phrase, "Over connection data limit")
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
encode_uint_var(v)
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: aioquic.packet
- class QuicStreamFlag(IntFlag):
- FIN = 0x01
- LEN = 0x02
- OFF = 0x04
-
===========changed ref 1===========
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
max_offset: int,
) -> int:
buf = builder.buffer
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ size_uint_var(stream.stream_id)
+ (size_uint_var(stream.next_send_offset) if stream.next_send_offset else 0)
)
previous_send_highest = stream._send_highest
frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
if frame is not None:
+ frame_type = QuicFrameType.STREAM_BASE | 2 # length
- flags = QuicStreamFlag.LEN
if frame.offset:
+ frame_type |= 4
- flags |= QuicStreamFlag.OFF
if frame.fin:
+ frame_type |= 1
- flags |= QuicStreamFlag.FIN
builder.start_frame(
+ frame_type,
- QuicFrameType.STREAM_BASE | flags,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
push_uint_var(buf, stream.stream_id)
if frame.offset:
push_uint_var(buf, frame.offset)
push_uint16(buf, len(frame.data) | 0x4000)
push_bytes(buf, frame.data)
return stream._send_highest - previous_send_highest
else:
return 0
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_stream_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
- flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
+ if frame_type & 4:
- if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
+ if frame_type & 2:
- if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
- offset=offset,
- data=pull_bytes(buf, length),
- fin=bool(flags & QuicStreamFlag.FIN),
+ offset=offset, data=pull_bytes(buf, length), fin=bool(frame_type & 1)
)
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
# check flow-control limits
stream = self._get_or_create_stream(frame_type, stream_id)
if offset + length > stream.max_stream_data_local:
raise QuicConnectionError(
error_code=QuicErrorCode.FLOW_CONTROL_ERROR,
frame_type=frame_type,
reason_phrase="Over stream data limit",
)
newly_received = max(0, offset + length - stream._recv_highest)
if self._local_max_data_used + newly_received > self._local_max_data:
raise QuicConnectionError(
error_code=QuicErrorCode.FLOW_CONTROL_ERROR,
frame_type=frame_type,
reason_phrase="Over connection data limit",
)
stream.add_frame(frame)
self._local_max_data_used += newly_received
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_stream_data
|
Modified
|
aiortc~aioquic
|
acd070ffde074ed00a5cd4ada33bf99170693d5e
|
[stream] don't use QuicStreamFlag, IntFlag "or" operations are slow
|
<2>:<add> frame_type = QuicFrameType.STREAM_BASE | 4
<del> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_stream_data(self):
<0> with client_and_server() as (client, server):
<1> # client receives STREAM frame
<2> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
<3> stream_id = 1
<4> with self.assertRaises(QuicConnectionError) as cm:
<5> client._handle_stream_frame(
<6> client_receive_context(client),
<7> frame_type,
<8> Buffer(
<9> data=encode_uint_var(stream_id)
<10> + encode_uint_var(client._local_max_stream_data_bidi_remote + 1)
<11> ),
<12> )
<13> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)
<14> self.assertEqual(cm.exception.frame_type, frame_type)
<15> self.assertEqual(cm.exception.reason_phrase, "Over stream data limit")
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
encode_uint_var(v)
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_data(self):
with client_and_server() as (client, server):
# artificially raise received data counter
client._local_max_data_used = client._local_max_data
# client receives STREAM frame
+ frame_type = QuicFrameType.STREAM_BASE | 4
- frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
stream_id = 1
with self.assertRaises(QuicConnectionError) as cm:
client._handle_stream_frame(
client_receive_context(client),
frame_type,
Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)),
)
self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)
self.assertEqual(cm.exception.frame_type, frame_type)
self.assertEqual(cm.exception.reason_phrase, "Over connection data limit")
===========changed ref 1===========
# module: aioquic.packet
- class QuicStreamFlag(IntFlag):
- FIN = 0x01
- LEN = 0x02
- OFF = 0x04
-
===========changed ref 2===========
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
max_offset: int,
) -> int:
buf = builder.buffer
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ size_uint_var(stream.stream_id)
+ (size_uint_var(stream.next_send_offset) if stream.next_send_offset else 0)
)
previous_send_highest = stream._send_highest
frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
if frame is not None:
+ frame_type = QuicFrameType.STREAM_BASE | 2 # length
- flags = QuicStreamFlag.LEN
if frame.offset:
+ frame_type |= 4
- flags |= QuicStreamFlag.OFF
if frame.fin:
+ frame_type |= 1
- flags |= QuicStreamFlag.FIN
builder.start_frame(
+ frame_type,
- QuicFrameType.STREAM_BASE | flags,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
push_uint_var(buf, stream.stream_id)
if frame.offset:
push_uint_var(buf, frame.offset)
push_uint16(buf, len(frame.data) | 0x4000)
push_bytes(buf, frame.data)
return stream._send_highest - previous_send_highest
else:
return 0
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_stream_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a STREAM frame.
"""
- flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
+ if frame_type & 4:
- if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
+ if frame_type & 2:
- if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
- offset=offset,
- data=pull_bytes(buf, length),
- fin=bool(flags & QuicStreamFlag.FIN),
+ offset=offset, data=pull_bytes(buf, length), fin=bool(frame_type & 1)
)
# check stream direction
self._assert_stream_can_receive(frame_type, stream_id)
# check flow-control limits
stream = self._get_or_create_stream(frame_type, stream_id)
if offset + length > stream.max_stream_data_local:
raise QuicConnectionError(
error_code=QuicErrorCode.FLOW_CONTROL_ERROR,
frame_type=frame_type,
reason_phrase="Over stream data limit",
)
newly_received = max(0, offset + length - stream._recv_highest)
if self._local_max_data_used + newly_received > self._local_max_data:
raise QuicConnectionError(
error_code=QuicErrorCode.FLOW_CONTROL_ERROR,
frame_type=frame_type,
reason_phrase="Over connection data limit",
)
stream.add_frame(frame)
self._local_max_data_used += newly_received
|
aioquic.stream/QuicStream.get_frame
|
Modified
|
aiortc~aioquic
|
092e4c7f847498f946f9b024dc5a700668ce4733
|
[stream] refactor get_frame
|
<3>:<add> # get the first pending data range
<add> try:
<add> r = self._send_pending[0]
<add> except IndexError:
<add> if self._send_pending_eof:
<add> # FIN only
<add> self._send_pending_eof = False
<add> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
<del> # check there is something to send
<4>:<del> if not (self._send_pending or self._send_pending_eof):
<7>:<del> # FIN only
<8>:<del> if not self._send_pending:
<9>:<del> self._send_pending_eof = False
<10>:<del> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
<11>:<del>
<13>:<del> r = self._send_pending[0]
|
# module: aioquic.stream
class QuicStream(asyncio.Transport):
def get_frame(
self, max_size: int, max_offset: Optional[int] = None
) -> Optional[QuicStreamFrame]:
<0> """
<1> Get a frame of data to send.
<2> """
<3> # check there is something to send
<4> if not (self._send_pending or self._send_pending_eof):
<5> return None
<6>
<7> # FIN only
<8> if not self._send_pending:
<9> self._send_pending_eof = False
<10> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
<11>
<12> # apply flow control
<13> r = self._send_pending[0]
<14> start = r.start
<15> stop = min(r.stop, start + max_size)
<16> if max_offset is not None and stop > max_offset:
<17> stop = max_offset
<18> if stop <= start:
<19> return None
<20>
<21> # create frame
<22> frame = QuicStreamFrame(
<23> data=self._send_buffer[
<24> start - self._send_buffer_start : stop - self._send_buffer_start
<25> ],
<26> offset=start,
<27> )
<28> self._send_pending.subtract(start, stop)
<29>
<30> # track the highest offset ever sent
<31> if stop > self._send_highest:
<32> self._send_highest = stop
<33>
<34> # if the buffer is empty and EOF was written, set the FIN bit
<35> if self._send_buffer_fin == stop:
<36> frame.fin = True
<37> self._send_pending_eof = False
<38>
<39> return frame
<40>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.rangeset.RangeSet
subtract(start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
self._send_buffer_start = 0 # the offset for the start of the buffer
self._send_buffer_stop = 0 # the offset for the stop of the buffer
at: aioquic.stream.QuicStream.on_data_delivery
self._send_buffer_start += size
self._send_pending_eof = True
at: aioquic.stream.QuicStream.write
self._send_buffer += data
self._send_buffer_stop += size
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
|
examples.client/save_session_ticket
|
Modified
|
aiortc~aioquic
|
2859d536a3436774b8899ec2a2943125cb6a0ccf
|
[examples] document command line options, add short options
|
<4>:<add> logger.info("New session ticket received")
<del> print("New session ticket received")
<5>:<add> if args.session_ticket:
<del> if args.session_ticket_file:
<6>:<add> with open(args.session_ticket, "wb") as fp:
<del> with open(args.session_ticket_file, "wb") as fp:
|
# module: examples.client
def save_session_ticket(ticket):
<0> """
<1> Callback which is invoked by the TLS engine when a new session ticket
<2> is received.
<3> """
<4> print("New session ticket received")
<5> if args.session_ticket_file:
<6> with open(args.session_ticket_file, "wb") as fp:
<7> pickle.dump(ticket, fp)
<8>
|
===========unchanged ref 0===========
at: examples.client
logger = logging.getLogger("client")
args = parser.parse_args()
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: examples.server
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="QUIC server")
+ parser.add_argument(
+ "-c",
+ "--certificate",
+ type=str,
+ required=True,
+ help="load the TLS certificate from the specified file",
+ )
+ parser.add_argument(
+ "--host",
+ type=str,
+ default="::",
+ help="listen on the specified address (defaults to ::)",
+ )
+ parser.add_argument(
+ "--port",
+ type=int,
+ default=4433,
+ help="listen on the specified port (defaults to 4433)",
+ )
+ parser.add_argument(
+ "-k",
+ "--private-key",
+ type=str,
+ required=True,
+ help="load the TLS private key from the specified file",
+ )
+ parser.add_argument(
+ "-l",
+ "--secrets-log",
+ type=str,
+ help="log secrets to a file, for use with Wireshark",
+ )
+ parser.add_argument(
+ "-r",
+ "--stateless-retry",
+ action="store_true",
+ help="send a stateless retry for new connections",
+ )
+ parser.add_argument(
+ "-v", "--verbose", action="store_true", help="increase logging verbosity"
+ )
- parser.add_argument("--certificate", type=str, required=True)
- parser.add_argument("--host", type=str, default="::")
- parser.add_argument("--port", type=int, default=4433)
- parser.add_argument("--private-key", type=str, required=True)
- parser.add_argument("--secrets-log-file", type=str)
- parser.add_argument("--stateless-retry", action="store_true")
- parser</s>
===========changed ref 1===========
# module: examples.server
# offset: 1
<s>", type=str)
- parser.add_argument("--stateless-retry", action="store_true")
- parser.add_argument("--verbose", "-v", action="store_true")
args = parser.parse_args()
logging.basicConfig(
format="%(asctime)s %(levelname)s %(name)s %(message)s",
level=logging.DEBUG if args.verbose else logging.INFO,
)
with open(args.certificate, "rb") as fp:
certificate = x509.load_pem_x509_certificate(
fp.read(), backend=default_backend()
)
with open(args.private_key, "rb") as fp:
private_key = serialization.load_pem_private_key(
fp.read(), password=None, backend=default_backend()
)
+ if args.secrets_log:
- if args.secrets_log_file:
+ secrets_log_file = open(args.secrets_log, "a")
- secrets_log_file = open(args.secrets_log_file, "a")
else:
secrets_log_file = None
# session tickets
ticket_store = SessionTicketStore()
loop = asyncio.get_event_loop()
protocol = loop.run_until_complete(
aioquic.serve(
host=args.host,
port=args.port,
alpn_protocols=["hq-20"],
certificate=certificate,
private_key=private_key,
stream_handler=handle_stream,
secrets_log_file=secrets_log_file,
session_ticket_fetcher=ticket_store.pop,
session_ticket_handler=ticket_store.add,
stateless_retry=args.stateless_retry,
)
)
loop.run_forever()
|
examples.client/run
|
Modified
|
aiortc~aioquic
|
2859d536a3436774b8899ec2a2943125cb6a0ccf
|
[examples] document command line options, add short options
|
<12>:<add> logger.info(
<del> print(
<13>:<add> "Received %d bytes in %.1f s (%.3f Mbps)"
<del> "received %d bytes in %.1f s (%.3f Mbps)"
|
# module: examples.client
def run(host, port, path, **kwargs):
<0> async with aioquic.connect(host, port, **kwargs) as connection:
<1> # perform HTTP/0.9 request
<2> reader, writer = await connection.create_stream()
<3> writer.write(("GET %s\r\n" % path).encode("utf8"))
<4> writer.write_eof()
<5>
<6> start = time.time()
<7> response = await reader.read()
<8> elapsed = time.time() - start
<9> print(response.decode("utf8"))
<10>
<11> octets = len(response)
<12> print(
<13> "received %d bytes in %.1f s (%.3f Mbps)"
<14> % (octets, elapsed, octets * 8 / elapsed / 1000000)
<15> )
<16>
|
===========unchanged ref 0===========
at: aioquic.client
connect(host: str, port: int, *, alpn_protocols: Optional[List[str]]=None, protocol_version: Optional[int]=None, secrets_log_file: Optional[TextIO]=None, session_ticket: Optional[SessionTicket]=None, session_ticket_handler: Optional[SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None) -> AsyncGenerator[QuicConnection, None]
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
write_eof() -> None
at: examples.client
logger = logging.getLogger("client")
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: time
time() -> float
===========changed ref 0===========
# module: examples.client
def save_session_ticket(ticket):
"""
Callback which is invoked by the TLS engine when a new session ticket
is received.
"""
+ logger.info("New session ticket received")
- print("New session ticket received")
+ if args.session_ticket:
- if args.session_ticket_file:
+ with open(args.session_ticket, "wb") as fp:
- with open(args.session_ticket_file, "wb") as fp:
pickle.dump(ticket, fp)
===========changed ref 1===========
# module: examples.server
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="QUIC server")
+ parser.add_argument(
+ "-c",
+ "--certificate",
+ type=str,
+ required=True,
+ help="load the TLS certificate from the specified file",
+ )
+ parser.add_argument(
+ "--host",
+ type=str,
+ default="::",
+ help="listen on the specified address (defaults to ::)",
+ )
+ parser.add_argument(
+ "--port",
+ type=int,
+ default=4433,
+ help="listen on the specified port (defaults to 4433)",
+ )
+ parser.add_argument(
+ "-k",
+ "--private-key",
+ type=str,
+ required=True,
+ help="load the TLS private key from the specified file",
+ )
+ parser.add_argument(
+ "-l",
+ "--secrets-log",
+ type=str,
+ help="log secrets to a file, for use with Wireshark",
+ )
+ parser.add_argument(
+ "-r",
+ "--stateless-retry",
+ action="store_true",
+ help="send a stateless retry for new connections",
+ )
+ parser.add_argument(
+ "-v", "--verbose", action="store_true", help="increase logging verbosity"
+ )
- parser.add_argument("--certificate", type=str, required=True)
- parser.add_argument("--host", type=str, default="::")
- parser.add_argument("--port", type=int, default=4433)
- parser.add_argument("--private-key", type=str, required=True)
- parser.add_argument("--secrets-log-file", type=str)
- parser.add_argument("--stateless-retry", action="store_true")
- parser</s>
===========changed ref 2===========
# module: examples.server
# offset: 1
<s>", type=str)
- parser.add_argument("--stateless-retry", action="store_true")
- parser.add_argument("--verbose", "-v", action="store_true")
args = parser.parse_args()
logging.basicConfig(
format="%(asctime)s %(levelname)s %(name)s %(message)s",
level=logging.DEBUG if args.verbose else logging.INFO,
)
with open(args.certificate, "rb") as fp:
certificate = x509.load_pem_x509_certificate(
fp.read(), backend=default_backend()
)
with open(args.private_key, "rb") as fp:
private_key = serialization.load_pem_private_key(
fp.read(), password=None, backend=default_backend()
)
+ if args.secrets_log:
- if args.secrets_log_file:
+ secrets_log_file = open(args.secrets_log, "a")
- secrets_log_file = open(args.secrets_log_file, "a")
else:
secrets_log_file = None
# session tickets
ticket_store = SessionTicketStore()
loop = asyncio.get_event_loop()
protocol = loop.run_until_complete(
aioquic.serve(
host=args.host,
port=args.port,
alpn_protocols=["hq-20"],
certificate=certificate,
private_key=private_key,
stream_handler=handle_stream,
secrets_log_file=secrets_log_file,
session_ticket_fetcher=ticket_store.pop,
session_ticket_handler=ticket_store.add,
stateless_retry=args.stateless_retry,
)
)
loop.run_forever()
|
aioquic.packet_builder/QuicPacketBuilder.start_frame
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<5>:<add> # FIXME: in_flight != is_ack_eliciting
<add> self._packet.in_flight = True
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
<0> """
<1> Starts a new frame.
<2> """
<3> push_uint_var(self.buffer, frame_type)
<4> if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
<5> self._packet.is_ack_eliciting = True
<6> self._ack_eliciting = True
<7> if frame_type == QuicFrameType.CRYPTO:
<8> self._packet.is_crypto_packet = True
<9> if handler is not None:
<10> self._packet.delivery_handlers.append((handler, args))
<11>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
NON_ACK_ELICITING_FRAME_TYPES = frozenset(
[QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
)
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._ack_eliciting = False
self._packet: Optional[QuicSentPacket] = None
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet = None
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._ack_eliciting = False
self._packet = QuicSentPacket(
epoch=epoch,
in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: typing
Sequence = _alias(collections.abc.Sequence, 1)
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 1===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<21>:<add> in_flight=False,
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> buf = self.buffer
<4> self._ack_eliciting = False
<5>
<6> # if there is too little space remaining, start a new datagram
<7> # FIXME: the limit is arbitrary!
<8> if buf.capacity - buf.tell() < 128:
<9> self._flush_current_datagram()
<10>
<11> # determine ack epoch
<12> if packet_type == PACKET_TYPE_INITIAL:
<13> epoch = Epoch.INITIAL
<14> elif packet_type == PACKET_TYPE_HANDSHAKE:
<15> epoch = Epoch.HANDSHAKE
<16> else:
<17> epoch = Epoch.ONE_RTT
<18>
<19> self._packet = QuicSentPacket(
<20> epoch=epoch,
<21> is_ack_eliciting=False,
<22> is_crypto_packet=False,
<23> packet_number=self._packet_number,
<24> )
<25> self._packet_crypto = crypto
<26> self._packet_epoch = epoch
<27> self._packet_start = buf.tell()
<28> self._packet_type = packet_type
<29>
<30> # calculate header size
<31> if is_long_header(packet_type):
<32> self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
<33> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<34> token_length = len(self._peer_token)
<35> self._header_size += size_uint_var(token_length) + token_length
<36> else:
<37> self._header_size = 3 + len(self._peer_cid)
<38>
<39> buf.seek(self._packet_start + self._header_size)
<40>
|
===========unchanged ref 0===========
at: aioquic.buffer
size_uint_var(value: int) -> int
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_MASK = 0xF0
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._ack_eliciting = False
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_crypto: Optional[CryptoPair] = None
self._packet_epoch: Optional[Epoch] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._packet = None
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 1===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
|
aioquic.recovery/QuicPacketSpace.__init__
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<5>:<add> self.ack_eliciting_in_flight = 0
|
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
<0> self.ack_queue = RangeSet()
<1> self.ack_required = False
<2> self.expected_packet_number = 0
<3>
<4> # sent packets and loss
<5> self.largest_acked_packet = 0
<6> self.loss_time: Optional[float] = None
<7> self.sent_packets: Dict[int, QuicSentPacket] = {}
<8>
|
===========unchanged ref 0===========
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.loss_time = None
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 1===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
|
aioquic.recovery/QuicPacketSpace.teardown
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<0>:<add> self.ack_eliciting_in_flight = 0
|
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
<0> self.loss_time = None
<1> self.sent_packets.clear()
<2>
|
===========unchanged ref 0===========
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
+ self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 1===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 2===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
|
aioquic.recovery/QuicPacketRecovery.detect_loss
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<19>:<del> for handler, args in packet.delivery_handlers:
<20>:<del> handler(QuicDeliveryState.LOST, *args)
<21>:<add> # remove packet and update counters
<22>:<add> if packet.is_ack_eliciting:
<add> space.ack_eliciting_in_flight -= 1
<25>:<add>
<add> # trigger callbacks
<add> for handler, args in packet.delivery_handlers:
<add> handler(QuicDeliveryState.LOST, *args)
|
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
<0> """
<1> Check whether any packets should be declared lost.
<2> """
<3> loss_delay = K_TIME_THRESHOLD * (
<4> max(self._rtt_latest, self._rtt_smoothed)
<5> if self._rtt_initialized
<6> else K_INITIAL_RTT
<7> )
<8> packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
<9> time_threshold = self._get_time() - loss_delay
<10>
<11> lost_bytes = 0
<12> lost_largest_time = None
<13> space.loss_time = None
<14> for packet_number, packet in list(space.sent_packets.items()):
<15> if packet_number > space.largest_acked_packet:
<16> break
<17>
<18> if packet_number <= packet_threshold or packet.sent_time < time_threshold:
<19> for handler, args in packet.delivery_handlers:
<20> handler(QuicDeliveryState.LOST, *args)
<21> del space.sent_packets[packet_number]
<22> if packet.in_flight:
<23> lost_bytes += packet.sent_bytes
<24> lost_largest_time = packet.sent_time
<25> else:
<26> packet_loss_time = packet.sent_time + loss_delay
<27> if space.loss_time is None or space.loss_time > packet_loss_time:
<28> space.loss_time = packet_loss_time
<29>
<30> if lost_bytes:
<31> self.on_packets_lost(lost_bytes, lost_largest_time)
<32>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_TIME_THRESHOLD = 9 / 8
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery.__init__
self._get_time = get_time
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_smoothed = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_latest -= ack_delay
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
self._rtt_initialized = True
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self._ssthresh = self.congestion_window
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========unchanged ref 1===========
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.loss_time = None
at: math
inf: float
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
+ self.ack_eliciting_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
+ self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 3===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
|
aioquic.recovery/QuicPacketRecovery.get_loss_detection_time
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<5>:<del> ack_eliciting_in_flight = False
<6>:<del> for space in self.spaces:
<7>:<del> for packet in space.sent_packets.values():
<8>:<del> if packet.is_ack_eliciting:
<9>:<del> ack_eliciting_in_flight = True
<10>:<del> break
<11>:<del> if not ack_eliciting_in_flight:
<12>:<add> if not next(
<add> (True for space in self.spaces if space.ack_eliciting_in_flight), False
<add> ):
|
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
<0> loss_space = self.get_earliest_loss_time()
<1> if loss_space is not None:
<2> return loss_space.loss_time
<3>
<4> # check there are ACK-eliciting packets in flight
<5> ack_eliciting_in_flight = False
<6> for space in self.spaces:
<7> for packet in space.sent_packets.values():
<8> if packet.is_ack_eliciting:
<9> ack_eliciting_in_flight = True
<10> break
<11> if not ack_eliciting_in_flight:
<12> return None
<13>
<14> # PTO
<15> if not self._rtt_initialized:
<16> timeout = K_INITIAL_RTT
<17> else:
<18> timeout = (
<19> self._rtt_smoothed
<20> + max(4 * self._rtt_variance, K_GRANULARITY)
<21> + self.max_ack_delay / 1000
<22> ) * (2 ** self._pto_count)
<23> return self._time_of_last_sent_ack_eliciting_packet + timeout
<24>
|
===========unchanged ref 0===========
at: aioquic.recovery
K_INITIAL_RTT = 0.5 # seconds
K_GRANULARITY = 0.001 # seconds
at: aioquic.recovery.QuicPacketRecovery
get_earliest_loss_time() -> Optional[QuicPacketSpace]
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
self._rtt_initialized = False
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
at: aioquic.recovery.QuicPacketSpace.__init__
self.loss_time: Optional[float] = None
at: aioquic.recovery.QuicPacketSpace.teardown
self.loss_time = None
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
+ self.ack_eliciting_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
+ self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
- for handler, args in packet.delivery_handlers:
- handler(QuicDeliveryState.LOST, *args)
+ # remove packet and update counters
del space.sent_packets[packet_number]
+ if packet.is_ack_eliciting:
+ space.ack_eliciting_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
+
+ # trigger callbacks
+ for handler, args in packet.delivery_handlers:
+ handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
self.on_packets_lost(lost_bytes, lost_largest_time)
===========changed ref 3===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 4===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 6===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
|
aioquic.recovery/QuicPacketRecovery.on_ack_received
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<17>:<add> # remove packet and update counters
<del> # newly ack'd
<19>:<add> if packet.is_ack_eliciting:
<add> is_ack_eliciting = True
<add> space.ack_eliciting_in_flight -= 1
<21>:<add> largest_newly_acked = packet_number
<add> largest_sent_time = packet.sent_time
<25>:<del> if packet.is_ack_eliciting:
<26>:<del> is_ack_eliciting = True
<27>:<del> largest_newly_acked = packet_number
<28>:<del> largest_sent_time = packet.sent_time
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
<0> """
<1> Update metrics as the result of an ACK being received.
<2> """
<3> ack_time = self._get_time()
<4>
<5> is_ack_eliciting = False
<6> largest_acked = ack_rangeset.bounds().stop - 1
<7> largest_newly_acked = None
<8> largest_sent_time = None
<9>
<10> if largest_acked > space.largest_acked_packet:
<11> space.largest_acked_packet = largest_acked
<12>
<13> for packet_number in sorted(space.sent_packets.keys()):
<14> if packet_number > largest_acked:
<15> break
<16> if packet_number in ack_rangeset:
<17> # newly ack'd
<18> packet = space.sent_packets.pop(packet_number)
<19> if packet.in_flight:
<20> self.on_packet_acked(packet)
<21>
<22> # trigger callbacks
<23> for handler, args in packet.delivery_handlers:
<24> handler(QuicDeliveryState.ACKED, *args)
<25> if packet.is_ack_eliciting:
<26> is_ack_eliciting = True
<27> largest_newly_acked = packet_number
<28> largest_sent_time = packet.sent_time
<29>
<30> # nothing to do if there are no newly acked packets
<31> if largest_newly_acked is None:
<32> return
<33>
<34> if largest_acked == largest_newly_acked and is_ack_eliciting:
<35> latest_rtt = ack_time - largest_sent_time
<36>
<37> # decode ACK delay into seconds
<38> ack_delay = max(
<39> (ack_delay_encoded << self.ack_delay_exponent) / 1000000,
<40> self.max_ack_delay / 1000,</s>
|
===========below chunk 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
# offset: 1
# update RTT estimate, which cannot be < 1 ms
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
if self._rtt_latest < self._rtt_min:
self._rtt_min = self._rtt_latest
if self._rtt_latest > self._rtt_min + ack_delay:
self._rtt_latest -= ack_delay
if not self._rtt_initialized:
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_smoothed = latest_rtt
else:
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self.detect_loss(space)
self._crypto_count = 0
self._pto_count = 0
# arm the timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
in_flight: bool
is_ack_eliciting: bool
sent_time: Optional[float] = None
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.rangeset.RangeSet
bounds() -> range
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery
detect_loss(self, space: QuicPacketSpace) -> None
detect_loss(space: QuicPacketSpace) -> None
on_packet_acked(packet: QuicSentPacket) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self._get_time = get_time
self._crypto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
at: typing.MutableMapping
pop(key: _KT) -> _VT
pop(key: _KT, default: Union[_VT, _T]=...) -> Union[_VT, _T]
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
- for handler, args in packet.delivery_handlers:
- handler(QuicDeliveryState.LOST, *args)
+ # remove packet and update counters
del space.sent_packets[packet_number]
+ if packet.is_ack_eliciting:
+ space.ack_eliciting_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
+
+ # trigger callbacks
+ for handler, args in packet.delivery_handlers:
+ handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
self.on_packets_lost(lost_bytes, lost_largest_time)
===========changed ref 1===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
+ self.ack_eliciting_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
+ self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
return loss_space.loss_time
# check there are ACK-eliciting packets in flight
- ack_eliciting_in_flight = False
- for space in self.spaces:
- for packet in space.sent_packets.values():
- if packet.is_ack_eliciting:
- ack_eliciting_in_flight = True
- break
- if not ack_eliciting_in_flight:
+ if not next(
+ (True for space in self.spaces if space.ack_eliciting_in_flight), False
+ ):
return None
# PTO
if not self._rtt_initialized:
timeout = K_INITIAL_RTT
else:
timeout = (
self._rtt_smoothed
+ max(4 * self._rtt_variance, K_GRANULARITY)
+ self.max_ack_delay / 1000
) * (2 ** self._pto_count)
return self._time_of_last_sent_ack_eliciting_packet + timeout
|
aioquic.recovery/QuicPacketRecovery.on_packet_sent
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<3>:<add> if packet.is_ack_eliciting:
<add> space.ack_eliciting_in_flight += 1
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_packet_sent(self, packet: QuicSentPacket, space: QuicPacketSpace) -> None:
<0> packet.sent_time = self._get_time()
<1> space.sent_packets[packet.packet_number] = packet
<2>
<3> if packet.in_flight:
<4> if packet.is_crypto_packet:
<5> self._time_of_last_sent_crypto_packet = packet.sent_time
<6> if packet.is_ack_eliciting:
<7> self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
<8>
<9> # add packet to bytes in flight
<10> self.bytes_in_flight += packet.sent_bytes
<11>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.packet_builder.QuicSentPacket
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
at: aioquic.recovery
K_MAX_DATAGRAM_SIZE = 1280
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery.__init__
self._get_time = get_time
self.congestion_window = K_INITIAL_WINDOW
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.congestion_window = max(
int(self.congestion_window * K_LOSS_REDUCTION_FACTOR), K_MINIMUM_WINDOW
)
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 1===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
+ self.ack_eliciting_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
+ self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
return loss_space.loss_time
# check there are ACK-eliciting packets in flight
- ack_eliciting_in_flight = False
- for space in self.spaces:
- for packet in space.sent_packets.values():
- if packet.is_ack_eliciting:
- ack_eliciting_in_flight = True
- break
- if not ack_eliciting_in_flight:
+ if not next(
+ (True for space in self.spaces if space.ack_eliciting_in_flight), False
+ ):
return None
# PTO
if not self._rtt_initialized:
timeout = K_INITIAL_RTT
else:
timeout = (
self._rtt_smoothed
+ max(4 * self._rtt_variance, K_GRANULARITY)
+ self.max_ack_delay / 1000
) * (2 ** self._pto_count)
return self._time_of_last_sent_ack_eliciting_packet + timeout
===========changed ref 5===========
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
- for handler, args in packet.delivery_handlers:
- handler(QuicDeliveryState.LOST, *args)
+ # remove packet and update counters
del space.sent_packets[packet_number]
+ if packet.is_ack_eliciting:
+ space.ack_eliciting_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
+
+ # trigger callbacks
+ for handler, args in packet.delivery_handlers:
+ handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
self.on_packets_lost(lost_bytes, lost_largest_time)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_padding
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<29>:<add> in_flight=True,
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> pad_first_datagram=True,
<4> peer_cid=bytes(8),
<5> peer_token=b"",
<6> spin_bit=False,
<7> version=QuicProtocolVersion.DRAFT_20,
<8> )
<9> crypto = CryptoPair()
<10> crypto.setup_initial(bytes(8), is_client=True)
<11>
<12> # INITIAL, fully padded
<13> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<14> self.assertEqual(builder.remaining_space, 1237)
<15> builder.start_frame(QuicFrameType.CRYPTO)
<16> push_bytes(builder.buffer, bytes(100))
<17> self.assertTrue(builder.end_packet())
<18> self.assertEqual(builder.buffer.tell(), 1280)
<19>
<20> # check datagrams
<21> datagrams, packets = builder.flush()
<22> self.assertEqual(len(datagrams), 1)
<23> self.assertEqual(len(datagrams[0]), 1280)
<24> self.assertEqual(
<25> packets,
<26> [
<27> QuicSentPacket(
<28> epoch=Epoch.INITIAL,
<29> is_ack_eliciting=True,
<30> is_crypto_packet=True,
<31> packet_number=0,
<32> sent_bytes=1280,
<33> )
<34> ],
<35> )
<36>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.tls
Epoch()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
- @property
- def in_flight(self) -> bool:
- # FIXME: in_flight and is_ack_eliciting are not exact synonyms!
- return self.is_ack_eliciting
-
===========changed ref 1===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
+ self.ack_eliciting_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 5===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
+ self.ack_eliciting_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_short_header
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<37>:<add> in_flight=True,
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # INITIAL, fully padded
<12> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<13> self.assertEqual(builder.remaining_space, 1237)
<14> builder.start_frame(QuicFrameType.CRYPTO)
<15> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16> self.assertTrue(builder.end_packet())
<17> self.assertEqual(builder.buffer.tell(), 1280)
<18>
<19> # ONE_RTT, fully padded
<20> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<21> self.assertEqual(builder.remaining_space, 1253)
<22> builder.start_frame(QuicFrameType.STREAM_BASE)
<23> push_bytes(builder.buffer, bytes(builder.remaining_space))
<24> self.assertTrue(builder.end_packet())
<25> self.assertEqual(builder.buffer.tell(), 0)
<26>
<27> # check datagrams
<28> datagrams, packets = builder.flush()
<29> self.assertEqual(len(datagrams), 2)
<30> self.assertEqual(len(datagrams[0]), 1280)
<31> self.assertEqual(len(datagrams[1]), 1280)
<32> self.assertEqual(
<33> packets,
<34> [
<35> QuicSentPacket(
<36> epoch=Epoch.INITIAL,
<37> is_ack_eliciting=True,
<38> is_crypto_packet=</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_short_header(self):
# offset: 1
packet_number=0,
sent_bytes=1280,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
is_ack_eliciting=True,
is_crypto_packet=False,
packet_number=1,
sent_bytes=1280,
),
],
)
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.tls
Epoch()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
pad_first_datagram=True,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(100))
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 1280)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
+ in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=1280,
)
],
)
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
+ self.ack_eliciting_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_long_header
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # INITIAL
<12> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<13> self.assertEqual(builder.remaining_space, 1237)
<14> builder.start_frame(QuicFrameType.CRYPTO)
<15> push_bytes(builder.buffer, bytes(199))
<16> self.assertEqual(builder.buffer.tell(), 227)
<17> self.assertTrue(builder.end_packet())
<18> self.assertEqual(builder.buffer.tell(), 243)
<19>
<20> # HANDSHAKE
<21> builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
<22> self.assertEqual(builder.buffer.tell(), 269)
<23> self.assertEqual(builder.remaining_space, 995)
<24> builder.start_frame(QuicFrameType.CRYPTO)
<25> push_bytes(builder.buffer, bytes(299))
<26> self.assertEqual(builder.buffer.tell(), 569)
<27> self.assertTrue(builder.end_packet())
<28> self.assertEqual(builder.buffer.tell(), 585)
<29>
<30> # ONE_RTT
<31> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<32> self.assertEqual(builder.remaining_space, 668)
<33> builder.start_frame(QuicFrameType.CRYPTO)
<34> push_bytes(builder.buffer, bytes(299))
<35> self.assertTrue(builder.end_packet())
<36> </s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 912)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=243,
),
QuicSentPacket(
epoch=Epoch.HANDSHAKE,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
sent_bytes=342,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=2,
sent_bytes=327,
),
],
)
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.tls
Epoch()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
|
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_padding
|
Modified
|
aiortc~aioquic
|
48c84b5c2482de11d3e41e1fe2b323151875bc3b
|
[recovery] track number of ack-eliciting packets in flight
|
<31>:<add> in_flight=True,
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> # ONE_RTT, fully padded
<12> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<13> self.assertEqual(builder.remaining_space, 1253)
<14> builder.start_frame(QuicFrameType.CRYPTO)
<15> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16> self.assertTrue(builder.end_packet())
<17>
<18> # check builder
<19> self.assertEqual(builder.buffer.tell(), 0)
<20> self.assertEqual(builder.packet_number, 1)
<21>
<22> # check datagrams
<23> datagrams, packets = builder.flush()
<24> self.assertEqual(len(datagrams), 1)
<25> self.assertEqual(len(datagrams[0]), 1280)
<26> self.assertEqual(
<27> packets,
<28> [
<29> QuicSentPacket(
<30> epoch=Epoch.ONE_RTT,
<31> is_ack_eliciting=True,
<32> is_crypto_packet=True,
<33> packet_number=0,
<34> sent_bytes=1280,
<35> )
<36> ],
<37> )
<38>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
===========unchanged ref 1===========
at: aioquic.tls
Epoch()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_short_header_empty
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
@dataclass
class QuicSentPacket:
epoch: Epoch
+ in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_frame(
self,
frame_type: int,
handler: Optional[QuicDeliveryHandler] = None,
args: Sequence[Any] = [],
) -> None:
"""
Starts a new frame.
"""
push_uint_var(self.buffer, frame_type)
if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
+ # FIXME: in_flight != is_ack_eliciting
+ self._packet.in_flight = True
self._packet.is_ack_eliciting = True
self._ack_eliciting = True
if frame_type == QuicFrameType.CRYPTO:
self._packet.is_crypto_packet = True
if handler is not None:
self._packet.delivery_handlers.append((handler, args))
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
buf = self.buffer
self._ack_eliciting = False
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if buf.capacity - buf.tell() < 128:
self._flush_current_datagram()
# determine ack epoch
if packet_type == PACKET_TYPE_INITIAL:
epoch = Epoch.INITIAL
elif packet_type == PACKET_TYPE_HANDSHAKE:
epoch = Epoch.HANDSHAKE
else:
epoch = Epoch.ONE_RTT
self._packet = QuicSentPacket(
epoch=epoch,
+ in_flight=False,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_epoch = epoch
self._packet_start = buf.tell()
self._packet_type = packet_type
# calculate header size
if is_long_header(packet_type):
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
token_length = len(self._peer_token)
self._header_size += size_uint_var(token_length) + token_length
else:
self._header_size = 3 + len(self._peer_cid)
buf.seek(self._packet_start + self._header_size)
===========changed ref 3===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
pad_first_datagram=True,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(100))
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 1280)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
+ in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=1280,
)
],
)
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
9baeab5a630eac5239f1c01c24a11417456e8f67
|
[connection] fix typo: "handshake" not "handhake"
|
<27>:<add> self._discard_handshake_at: Optional[float] = None
<del> self._discard_handhake_at: Optional[float] = None
<28>:<add> self._discard_handshake_done = False
<del> self._discard_handhake_done = False
|
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self._discard_handhake_at: Optional[float] = None
<28> self._discard_handhake_done = False
<29> self.__epoch = tls.Epoch.INITIAL
<30> self._host_cids = [
<31> </s>
|
===========below chunk 0===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_timer=self._set_loss_detection_timer,
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet</s>
===========below chunk 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
# callbacks
self._connection</s>
===========below chunk 2===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_</s>
===========below chunk 3===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s> EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
</s>
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
9baeab5a630eac5239f1c01c24a11417456e8f67
|
[connection] fix typo: "handshake" not "handhake"
|
<19>:<add> if not space.ack_eliciting_in_flight and not stream._send_pending:
<del> if not space.sent_packets and not stream._send_pending:
<20>:<add> self._discard_handshake_at = (
<del> self._discard_handhake_at = (
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> ack_rangeset, ack_delay_encoded = pull_ack_frame(buf)
<4> if frame_type == QuicFrameType.ACK_ECN:
<5> pull_uint_var(buf)
<6> pull_uint_var(buf)
<7> pull_uint_var(buf)
<8>
<9> self._loss.on_ack_received(
<10> space=self.spaces[context.epoch],
<11> ack_rangeset=ack_rangeset,
<12> ack_delay_encoded=ack_delay_encoded,
<13> )
<14>
<15> # if all handshake data is acked, discard handshake space in 3 PTO
<16> if context.epoch == tls.Epoch.HANDSHAKE:
<17> space = self.spaces[context.epoch]
<18> stream = self.streams[context.epoch]
<19> if not space.sent_packets and not stream._send_pending:
<20> self._discard_handhake_at = (
<21> self._loop.time() + 3 * self._loss.get_probe_timeout()
<22> )
<23>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_uint_var(buf: Buffer) -> int
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._loop = asyncio.get_event_loop()
self._discard_handshake_at: Optional[float] = None
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_timer=self._set_loss_detection_timer,
)
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._send_pending
self._discard_handshake_at = None
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
at: aioquic.recovery.QuicPacketRecovery
get_probe_timeout() -> float
on_ack_received(space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int) -> None
===========unchanged ref 1===========
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
at: aioquic.tls
Epoch()
at: asyncio.events.AbstractEventLoop
time() -> float
===========changed ref 0===========
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
+ self._discard_handshake_at: Optional[float] = None
- self._discard_handhake_at: Optional[float] = None
+ self._discard_handshake_done = False
- self._discard_handhake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
</s>
===========changed ref 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>_handhake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_</s>
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
9baeab5a630eac5239f1c01c24a11417456e8f67
|
[connection] fix typo: "handshake" not "handhake"
|
<33>:<add> self._discard_handshake_at is not None
<del> self._discard_handhake_at is not None
<34>:<add> and self._loop.time() > self._discard_handshake_at
<del> and self._loop.time() > self._discard_handhake_at
<39>:<add> self._discard_handshake_at = None
<del> self._discard_handhake_at = None
<40>:<add> self._discard_handshake_done = True
<del> self._discard_handhake_done = True
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self.__send_pending_task = None
<3> if self.__state == QuicConnectionState.DRAINING:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<11> peer_cid=self.peer_cid,
<12> peer_token=self.peer_token,
<13> spin_bit=self._spin_bit,
<14> version=self._version,
<15> )
<16>
<17> if self.__close:
<18> for epoch, packet_type in (
<19> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<20> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<21> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<22> ):
<23> crypto = self.cryptos[epoch]
<24> if crypto.send.is_valid():
<25> builder.start_packet(packet_type, crypto)
<26> write_close_frame(builder, **self.__close)
<27> builder.end_packet()
<28> self.__close = None
<29> break
<30> else:
<31> # check if we can discard handshake keys
<32> if (
<33> self._discard_handhake_at is not None
<34> and self._loop.time() > self._discard_handhake_at
<35> ):
<36> self._logger.debug("Discarding handshake keys")
<37> self.cryptos[tls.Epoch.HANDSHAKE].teardown()
<38> self.spaces[tls.Epoch.HANDSHAKE].teardown()
<39> self._discard_handhake_at = None
<40> self._discard_handhake_done = True</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
# arm loss timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
at: aioquic.connection.QuicConnection
_set_loss_detection_timer() -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.peer_token = b""
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self.host_cid = self._host_cids[0].cid
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_timer=self._set_loss_detection_timer,
)
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._spin_bit = False
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._handle_ack_frame
self._discard_handshake_at = (
self._loop.time() + 3 * self._loss.get_probe_timeout()
)
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_soon
self.__send_pending_task = self._loop.call_soon(self._send_pending)
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
===========unchanged ref 2===========
self.peer_cid = header.source_cid
self.peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair
teardown() -> None
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
===========unchanged ref 3===========
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery.QuicPacketSpace
teardown() -> None
at: aioquic.tls
Epoch()
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
tests.test_connection/FakeTransport.__init__
|
Modified
|
aiortc~aioquic
|
5876d813a9b192213408fcd0231e5e929496943c
|
[connection] add supported_versions to constructor arguments
|
<1>:<add> self.loss = loss
|
# module: tests.test_connection
class FakeTransport:
+ def __init__(self, local_addr, loss=0):
- def __init__(self, local_addr):
<0> self.local_addr = local_addr
<1>
|
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
- loss = 0
sent = 0
target = None
===========changed ref 1===========
<s>bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
+ if supported_versions is not None:
+ self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.</s>
===========changed ref 2===========
<s>
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_timer=self._set_loss_detection_timer,</s>
===========changed ref 3===========
<s>
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s> )
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
</s>
===========changed ref 4===========
<s>
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>._retire_connection_ids: List[int] = []
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
</s>
|
tests.test_connection/create_standalone_client
|
Modified
|
aiortc~aioquic
|
5876d813a9b192213408fcd0231e5e929496943c
|
[connection] add supported_versions to constructor arguments
|
<1>:<add> client_transport = FakeTransport(CLIENT_ADDR, loss=0)
<del> client_transport = FakeTransport(CLIENT_ADDR)
|
# module: tests.test_connection
def create_standalone_client():
<0> client = QuicConnection(is_client=True)
<1> client_transport = FakeTransport(CLIENT_ADDR)
<2> client.connection_made(client_transport)
<3>
<4> # like connect() but without waiting
<5> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
<6> client._version = max(client.supported_versions)
<7> client._connect()
<8>
<9> return client, client_transport
<10>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, supported_versions: Optional[List[QuicProtocolVersion]]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connection_made(transport: asyncio.BaseTransport) -> None
_connect() -> None
at: aioquic.connection.QuicConnection.__init__
self.supported_versions = supported_versions
self._network_paths: List[QuicNetworkPath] = []
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self._network_paths = [network_path]
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
===========unchanged ref 1===========
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
FakeTransport(local_addr, loss=0)
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
- loss = 0
sent = 0
target = None
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ def __init__(self, local_addr, loss=0):
- def __init__(self, local_addr):
self.local_addr = local_addr
+ self.loss = loss
===========changed ref 2===========
<s>bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
+ if supported_versions is not None:
+ self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.</s>
===========changed ref 3===========
<s>
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_timer=self._set_loss_detection_timer,</s>
|
tests.test_connection/create_transport
|
Modified
|
aiortc~aioquic
|
5876d813a9b192213408fcd0231e5e929496943c
|
[connection] add supported_versions to constructor arguments
|
<0>:<add> client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
<del> client_transport = FakeTransport(CLIENT_ADDR)
<3>:<add> server_transport = FakeTransport(SERVER_ADDR, loss=loss)
<del> server_transport = FakeTransport(SERVER_ADDR)
|
# module: tests.test_connection
+ def create_transport(client, server, loss=0):
- def create_transport(client, server):
<0> client_transport = FakeTransport(CLIENT_ADDR)
<1> client_transport.target = server
<2>
<3> server_transport = FakeTransport(SERVER_ADDR)
<4> server_transport.target = client
<5>
<6> server.connection_made(server_transport)
<7> client.connection_made(client_transport)
<8>
<9> # like connect() but without waiting
<10> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
<11> client._version = max(client.supported_versions)
<12> client._connect()
<13>
<14> return client_transport, server_transport
<15>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.BaseTransport) -> None
_connect() -> None
at: aioquic.connection.QuicConnection.__init__
self.supported_versions = supported_versions
self._network_paths: List[QuicNetworkPath] = []
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self._network_paths = [network_path]
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
FakeTransport(local_addr, loss=0)
at: tests.test_connection.FakeTransport
sent = 0
target = None
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
- loss = 0
sent = 0
target = None
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ def __init__(self, local_addr, loss=0):
- def __init__(self, local_addr):
self.local_addr = local_addr
+ self.loss = loss
===========changed ref 2===========
# module: tests.test_connection
def create_standalone_client():
client = QuicConnection(is_client=True)
+ client_transport = FakeTransport(CLIENT_ADDR, loss=0)
- client_transport = FakeTransport(CLIENT_ADDR)
client.connection_made(client_transport)
# like connect() but without waiting
client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
client._version = max(client.supported_versions)
client._connect()
return client, client_transport
===========changed ref 3===========
<s>bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
+ if supported_versions is not None:
+ self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.</s>
===========changed ref 4===========
<s>
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_timer=self._set_loss_detection_timer,</s>
|
tests.test_connection/client_and_server
|
Modified
|
aiortc~aioquic
|
5876d813a9b192213408fcd0231e5e929496943c
|
[connection] add supported_versions to constructor arguments
|
<0>:<add> client = QuicConnection(is_client=True, **client_options)
<del> client = QuicConnection(is_client=True)
<1>:<add> client_patch(client)
<add>
<2>:<add> is_client=False,
<add> certificate=SERVER_CERTIFICATE,
<add> private_key=SERVER_PRIVATE_KEY,
<add> **server_options
<del> is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
<4>:<add> server_patch(server)
<6>:<add> create_transport(client, server, **transport_options)
<del> create_transport(client, server)
<9>:<add>
<add> # close
|
# module: tests.test_connection
@contextlib.contextmanager
+ def client_and_server(
- def client_and_server():
+ client_options={},
+ client_patch=lambda x: None,
+ server_options={},
+ server_patch=lambda x: None,
+ transport_options={},
+ ):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
<3> )
<4>
<5> # perform handshake
<6> create_transport(client, server)
<7>
<8> yield client, server
<9> client.close()
<10> server.close()
<11>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, supported_versions: Optional[List[QuicProtocolVersion]]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
+ def __init__(self, local_addr, loss=0):
- def __init__(self, local_addr):
self.local_addr = local_addr
+ self.loss = loss
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
- loss = 0
sent = 0
target = None
===========changed ref 2===========
# module: tests.test_connection
def create_standalone_client():
client = QuicConnection(is_client=True)
+ client_transport = FakeTransport(CLIENT_ADDR, loss=0)
- client_transport = FakeTransport(CLIENT_ADDR)
client.connection_made(client_transport)
# like connect() but without waiting
client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
client._version = max(client.supported_versions)
client._connect()
return client, client_transport
===========changed ref 3===========
# module: tests.test_connection
+ def create_transport(client, server, loss=0):
- def create_transport(client, server):
+ client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport = FakeTransport(CLIENT_ADDR)
client_transport.target = server
+ server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport = FakeTransport(SERVER_ADDR)
server_transport.target = client
server.connection_made(server_transport)
client.connection_made(client_transport)
# like connect() but without waiting
client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
client._version = max(client.supported_versions)
client._connect()
return client_transport, server_transport
===========changed ref 4===========
<s>bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
+ if supported_versions is not None:
+ self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.</s>
===========changed ref 5===========
<s>
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger,
get_time=self._loop.time,
send_probe=self._send_probe,
set_loss_detection_timer=self._set_loss_detection_timer,</s>
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
5876d813a9b192213408fcd0231e5e929496943c
|
[connection] add supported_versions to constructor arguments
|
<0>:<add> with client_and_server(
<del> client = QuicConnection(is_client=True)
<1>:<add> client_options={"supported_versions": client_versions},
<del> client.supported_versions = client_versions
<2>:<add> server_options={"supported_versions": server_versions},
<add> ) as (client, server):
<add> self.assertEqual(client._transport.sent, 4)
<add> self.assertEqual(server._transport.sent, 3)
<3>:<del> server = QuicConnection(
<4>:<del> is_client=False,
<5>:<del> certificate=SERVER_CERTIFICATE,
<6>:<del> private_key=SERVER_PRIVATE_KEY,
<7>:<add> # check each endpoint has available connection IDs for the peer
<add> self.assertEqual(
<add> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<add> )
<del> )
<8>:<add> self.assertEqual(
<add> sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<add> )
<del> server.supported_versions = server_versions
<10>:<add> # send data over stream
<add> client_reader, client_writer = run(client.create_stream())
<add> client_writer.write(b"ping")
<add> run(asyncio.sleep(0))
<del> # perform handshake
<11>:<del> client_transport, server_transport = create_transport(client, server)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> client = QuicConnection(is_client=True)
<1> client.supported_versions = client_versions
<2>
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> )
<8> server.supported_versions = server_versions
<9>
<10> # perform handshake
<11> client_transport, server_transport = create_transport(client, server)
<12> self.assertEqual(client_transport.sent, 4)
<13> self.assertEqual(server_transport.sent, 3)
<14>
<15> # check each endpoint has available connection IDs for the peer
<16> self.assertEqual(
<17> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<18> )
<19> self.assertEqual(
<20> sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<21> )
<22>
<23> # send data over stream
<24> client_reader, client_writer = run(client.create_stream())
<25> client_writer.write(b"ping")
<26> run(asyncio.sleep(0))
<27> self.assertEqual(client_transport.sent, 5)
<28> self.assertEqual(server_transport.sent, 4)
<29>
<30> # FIXME: needs an API
<31> server_reader, server_writer = (
<32> server.streams[0].reader,
<33> server.streams[0].writer,
<34> )
<35> self.assertEqual(run(server_reader.read(1024)), b"ping")
<36> server_writer.write(b"pong")
<37> run(asyncio.sleep(0))
<38> self.assertEqual(client_transport.sent, 6)
<39> self.assertEqual(server_transport.sent, 5)
<40>
<41> # client receives pong</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
self.assertEqual(client_transport.sent, 7)
self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server, loss=0)
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.test_connection.client_and_server
client = QuicConnection(is_client=True, **client_options)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
**server_options
)
at: tests.utils
run(coro)
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
@contextlib.contextmanager
+ def client_and_server(
- def client_and_server():
+ client_options={},
+ client_patch=lambda x: None,
+ server_options={},
+ server_patch=lambda x: None,
+ transport_options={},
+ ):
+ client = QuicConnection(is_client=True, **client_options)
- client = QuicConnection(is_client=True)
+ client_patch(client)
+
server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ **server_options
- is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
)
+ server_patch(server)
# perform handshake
+ create_transport(client, server, **transport_options)
- create_transport(client, server)
yield client, server
+
+ # close
client.close()
server.close()
===========changed ref 1===========
# module: tests.test_connection
+ def create_transport(client, server, loss=0):
- def create_transport(client, server):
+ client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport = FakeTransport(CLIENT_ADDR)
client_transport.target = server
+ server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport = FakeTransport(SERVER_ADDR)
server_transport.target = client
server.connection_made(server_transport)
client.connection_made(client_transport)
# like connect() but without waiting
client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
client._version = max(client.supported_versions)
client._connect()
return client_transport, server_transport
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
+ def __init__(self, local_addr, loss=0):
- def __init__(self, local_addr):
self.local_addr = local_addr
+ self.loss = loss
===========changed ref 3===========
# module: tests.test_connection
class FakeTransport:
- loss = 0
sent = 0
target = None
===========changed ref 4===========
# module: tests.test_connection
def create_standalone_client():
client = QuicConnection(is_client=True)
+ client_transport = FakeTransport(CLIENT_ADDR, loss=0)
- client_transport = FakeTransport(CLIENT_ADDR)
client.connection_made(client_transport)
# like connect() but without waiting
client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
client._version = max(client.supported_versions)
client._connect()
return client, client_transport
===========changed ref 5===========
<s>bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
+ supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
+ if supported_versions is not None:
+ self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.</s>
|
tests.test_connection/QuicConnectionTest.test_connect_with_log
|
Modified
|
aiortc~aioquic
|
5876d813a9b192213408fcd0231e5e929496943c
|
[connection] add supported_versions to constructor arguments
|
<1>:<del> client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
<3>:<del> server = QuicConnection(
<4>:<del> is_client=False,
<5>:<del> certificate=SERVER_CERTIFICATE,
<6>:<del> private_key=SERVER_PRIVATE_KEY,
<7>:<add> with client_and_server(
<add> client_options={"secrets_log_file": client_log_file},
<add> server_options={"secrets_log_file": server_log_file},
<del> secrets_log_file=server_log_file,
<8>:<add> ) as (client, server):
<add> self.assertEqual(client._transport.sent, 4)
<add> self.assertEqual(server._transport.sent, 3)
<del> )
<10>:<add> # check secrets were logged
<add> client_log = client_log_file.getvalue()
<add> server_log = server_log_file.getvalue()
<add> self.assertEqual(client_log, server_log)
<add> labels = []
<add> for line in client_log.splitlines():
<add> labels.append(line.split()[0])
<add> self.assertEqual(
<add> labels,
<add> [
<add> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<add> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
<0> client_log_file = io.StringIO()
<1> client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
<2> server_log_file = io.StringIO()
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> secrets_log_file=server_log_file,
<8> )
<9>
<10> # perform handshake
<11> client_transport, server_transport = create_transport(client, server)
<12> self.assertEqual(client_transport.sent, 4)
<13> self.assertEqual(server_transport.sent, 3)
<14>
<15> # check secrets were logged
<16> client_log = client_log_file.getvalue()
<17> server_log = server_log_file.getvalue()
<18> self.assertEqual(client_log, server_log)
<19> labels = []
<20> for line in client_log.splitlines():
<21> labels.append(line.split()[0])
<22> self.assertEqual(
<23> labels,
<24> [
<25> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<26> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
<27> "QUIC_SERVER_TRAFFIC_SECRET_0",
<28> "QUIC_CLIENT_TRAFFIC_SECRET_0",
<29> ],
<30> )
<31>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.test_connection.QuicConnectionTest
_test_connect_with_version(self, client_versions, server_versions)
_test_connect_with_version(client_versions, server_versions)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
@contextlib.contextmanager
+ def client_and_server(
- def client_and_server():
+ client_options={},
+ client_patch=lambda x: None,
+ server_options={},
+ server_patch=lambda x: None,
+ transport_options={},
+ ):
+ client = QuicConnection(is_client=True, **client_options)
- client = QuicConnection(is_client=True)
+ client_patch(client)
+
server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ **server_options
- is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
)
+ server_patch(server)
# perform handshake
+ create_transport(client, server, **transport_options)
- create_transport(client, server)
yield client, server
+
+ # close
client.close()
server.close()
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
+ with client_and_server(
- client = QuicConnection(is_client=True)
+ client_options={"supported_versions": client_versions},
- client.supported_versions = client_versions
+ server_options={"supported_versions": server_versions},
+ ) as (client, server):
+ self.assertEqual(client._transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ # check each endpoint has available connection IDs for the peer
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ self.assertEqual(
+ sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- server.supported_versions = server_versions
+ # send data over stream
+ client_reader, client_writer = run(client.create_stream())
+ client_writer.write(b"ping")
+ run(asyncio.sleep(0))
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
+ # FIXME: needs an API
+ server_reader, server_writer = (
+ server.streams[0].reader,
+ server.streams[0].writer,
- # check each endpoint has available connection IDs for the peer
- self</s>
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s>,
+ server.streams[0].writer,
- # check each endpoint has available connection IDs for the peer
- self.assertEqual(
- sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ self.assertEqual(run(server_reader.read(1024)), b"ping")
+ server_writer.write(b"pong")
+ run(asyncio.sleep(0))
+ self.assertEqual(client._transport.sent, 6)
+ self.assertEqual(server._transport.sent, 5)
- self.assertEqual(
- sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
- )
- # send data over stream
- client_reader, client_writer = run(client.create_stream())
- client_writer.write(b"ping")
- run(asyncio.sleep(0))
- self.assertEqual(client_transport.sent, 5)
- self.assertEqual(server_transport.sent, 4)
+ # client receives pong
+ self.assertEqual(run(client_reader.read(1024)), b"pong")
- # FIXME: needs an API
- server_reader, server_writer = (
- server.streams[0].reader,
- server.streams[0].writer,
- )
- self.assertEqual(run(server_reader.read(1024)), b"ping")
- server_writer.write(b"pong")
+ # client writes EOF
+ client_writer.write_eof()
+ run(asyncio.sleep(0))
- </s>
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 2
<s>asyncio.sleep(0))
+ self.assertEqual(client._transport.sent, 7)
- self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server._transport.sent, 6)
- self.assertEqual(server_transport.sent, 5)
+ # server receives EOF
- # client receives pong
+ self.assertEqual(run(server_reader.read()), b"")
- self.assertEqual(run(client_reader.read(1024)), b"pong")
- # client writes EOF
- client_writer.write_eof()
- run(asyncio.sleep(0))
- self.assertEqual(client_transport.sent, 7)
- self.assertEqual(server_transport.sent, 6)
-
- # server receives EOF
- self.assertEqual(run(server_reader.read()), b"")
-
===========changed ref 4===========
# module: tests.test_connection
class FakeTransport:
+ def __init__(self, local_addr, loss=0):
- def __init__(self, local_addr):
self.local_addr = local_addr
+ self.loss = loss
===========changed ref 5===========
# module: tests.test_connection
class FakeTransport:
- loss = 0
sent = 0
target = None
|
tests.test_connection/QuicConnectionTest.test_tls_error
|
Modified
|
aiortc~aioquic
|
5876d813a9b192213408fcd0231e5e929496943c
|
[connection] add supported_versions to constructor arguments
|
<0>:<add> def patch(client):
<del> client = QuicConnection(is_client=True)
<1>:<add> real_initialize = client._initialize
<del> real_initialize = client._initialize
<3>:<add> def patched_initialize(peer_cid: bytes):
<del> def patched_initialize(peer_cid: bytes):
<4>:<add> real_initialize(peer_cid)
<del> real_initialize(peer_cid)
<5>:<add> client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
<del> client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
<7>:<add> client._initialize = patched_initialize
<del> client._initialize = patched_initialize
<9>:<del> server = QuicConnection(
<10>:<del> is_client=False,
<11>:<del> certificate=SERVER_CERTIFICATE,
<12>:<del> private_key=SERVER_PRIVATE_KEY,
<13>:<del> )
<14>:<add> # handshake fails
<add> with client_and_server(client_patch=patch) as (client, server):
<add> self.assertEqual(client._transport.sent, 1)
<add> self.assertEqual(server._transport.sent, 1)
<15>:<del> # fail handshake
<16>:<del> client_transport, server_transport = create_transport(client, server)
<17>:<del> self.assertEqual(client_transport.sent, 1)
<18>:<del> self.assertEqual(server_transport.sent, 1)
<19>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
<0> client = QuicConnection(is_client=True)
<1> real_initialize = client._initialize
<2>
<3> def patched_initialize(peer_cid: bytes):
<4> real_initialize(peer_cid)
<5> client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
<6>
<7> client._initialize = patched_initialize
<8>
<9> server = QuicConnection(
<10> is_client=False,
<11> certificate=SERVER_CERTIFICATE,
<12> private_key=SERVER_PRIVATE_KEY,
<13> )
<14>
<15> # fail handshake
<16> client_transport, server_transport = create_transport(client, server)
<17> self.assertEqual(client_transport.sent, 1)
<18> self.assertEqual(server_transport.sent, 1)
<19>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.tls
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
at: tests.test_connection
create_standalone_client()
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
def create_standalone_client():
client = QuicConnection(is_client=True)
+ client_transport = FakeTransport(CLIENT_ADDR, loss=0)
- client_transport = FakeTransport(CLIENT_ADDR)
client.connection_made(client_transport)
# like connect() but without waiting
client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
client._version = max(client.supported_versions)
client._connect()
return client, client_transport
===========changed ref 1===========
# module: tests.test_connection
@contextlib.contextmanager
+ def client_and_server(
- def client_and_server():
+ client_options={},
+ client_patch=lambda x: None,
+ server_options={},
+ server_patch=lambda x: None,
+ transport_options={},
+ ):
+ client = QuicConnection(is_client=True, **client_options)
- client = QuicConnection(is_client=True)
+ client_patch(client)
+
server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ **server_options
- is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
)
+ server_patch(server)
# perform handshake
+ create_transport(client, server, **transport_options)
- create_transport(client, server)
yield client, server
+
+ # close
client.close()
server.close()
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
+ def __init__(self, local_addr, loss=0):
- def __init__(self, local_addr):
self.local_addr = local_addr
+ self.loss = loss
===========changed ref 3===========
# module: tests.test_connection
class FakeTransport:
- loss = 0
sent = 0
target = None
===========changed ref 4===========
# module: tests.test_connection
+ def create_transport(client, server, loss=0):
- def create_transport(client, server):
+ client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
- client_transport = FakeTransport(CLIENT_ADDR)
client_transport.target = server
+ server_transport = FakeTransport(SERVER_ADDR, loss=loss)
- server_transport = FakeTransport(SERVER_ADDR)
server_transport.target = client
server.connection_made(server_transport)
client.connection_made(client_transport)
# like connect() but without waiting
client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
client._version = max(client.supported_versions)
client._connect()
return client_transport, server_transport
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
- client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server(
+ client_options={"secrets_log_file": client_log_file},
+ server_options={"secrets_log_file": server_log_file},
- secrets_log_file=server_log_file,
+ ) as (client, server):
+ self.assertEqual(client._transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- )
+ # check secrets were logged
+ client_log = client_log_file.getvalue()
+ server_log = server_log_file.getvalue()
+ self.assertEqual(client_log, server_log)
+ labels = []
+ for line in client_log.splitlines():
+ labels.append(line.split()[0])
+ self.assertEqual(
+ labels,
+ [
+ "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
+ "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
+ "QUIC_SERVER_TRAFFIC_SECRET_0",
+ "QUIC_CLIENT_TRAFFIC_SECRET_0",
+ ],
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
- # check secrets were logged
- client_log = client_log_file.getvalue</s>
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
# offset: 1
<s>transport.sent, 3)
- # check secrets were logged
- client_log = client_log_file.getvalue()
- server_log = server_log_file.getvalue()
- self.assertEqual(client_log, server_log)
- labels = []
- for line in client_log.splitlines():
- labels.append(line.split()[0])
- self.assertEqual(
- labels,
- [
- "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
- "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
- "QUIC_SERVER_TRAFFIC_SECRET_0",
- "QUIC_CLIENT_TRAFFIC_SECRET_0",
- ],
- )
-
|
aioquic.packet/pull_quic_header
|
Modified
|
aiortc~aioquic
|
172ee38a1deffc333d2a26d6b2c2df80b265b9e5
|
[packet] make QuicHeader.is_long_header a true member
|
<39>:<add> is_long_header=True,
|
# module: aioquic.packet
def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
<0> first_byte = pull_uint8(buf)
<1>
<2> original_destination_cid = b""
<3> token = b""
<4> if is_long_header(first_byte):
<5> # long header packet
<6> version = pull_uint32(buf)
<7> cid_lengths = pull_uint8(buf)
<8>
<9> destination_cid_length = decode_cid_length(cid_lengths // 16)
<10> destination_cid = pull_bytes(buf, destination_cid_length)
<11>
<12> source_cid_length = decode_cid_length(cid_lengths % 16)
<13> source_cid = pull_bytes(buf, source_cid_length)
<14>
<15> if version == QuicProtocolVersion.NEGOTIATION:
<16> # version negotiation
<17> packet_type = None
<18> rest_length = buf.capacity - buf.tell()
<19> else:
<20> if not (first_byte & PACKET_FIXED_BIT):
<21> raise ValueError("Packet fixed bit is zero")
<22>
<23> packet_type = first_byte & PACKET_TYPE_MASK
<24> if packet_type == PACKET_TYPE_INITIAL:
<25> token_length = pull_uint_var(buf)
<26> token = pull_bytes(buf, token_length)
<27> rest_length = pull_uint_var(buf)
<28> elif packet_type == PACKET_TYPE_RETRY:
<29> original_destination_cid_length = decode_cid_length(first_byte & 0xF)
<30> original_destination_cid = pull_bytes(
<31> buf, original_destination_cid_length
<32> )
<33> token = pull_bytes(buf, buf.capacity - buf.tell())
<34> rest_length = 0
<35> else:
<36> rest_length = pull_uint_var(buf)
<37>
<38> return QuicHeader(
<39> version=version,
<40> packet_type=packet_type,
</s>
|
===========below chunk 0===========
# module: aioquic.packet
def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
# offset: 1
source_cid=source_cid,
original_destination_cid=original_destination_cid,
token=token,
rest_length=rest_length,
)
else:
# short header packet
if not (first_byte & PACKET_FIXED_BIT):
raise ValueError("Packet fixed bit is zero")
packet_type = first_byte & PACKET_TYPE_MASK
destination_cid = pull_bytes(buf, host_cid_length)
return QuicHeader(
version=None,
packet_type=packet_type,
destination_cid=destination_cid,
source_cid=b"",
token=b"",
rest_length=buf.capacity - buf.tell(),
)
===========unchanged ref 0===========
at: aioquic.buffer
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint8(buf: Buffer) -> int
pull_uint32(buf: Buffer) -> int
pull_uint_var(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicHeader(is_long_header: bool, version: Optional[int], packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
decode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
at: aioquic.packet.QuicHeader
is_long_header: bool
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: aioquic.packet.pull_quic_header
first_byte = pull_uint8(buf)
===========changed ref 0===========
# module: aioquic.packet
@dataclass
class QuicHeader:
- @property
- def is_long_header(self) -> bool:
- return self.packet_type is None or is_long_header(self.packet_type)
-
===========changed ref 1===========
# module: aioquic.packet
@dataclass
class QuicHeader:
+ is_long_header: bool
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
|
aioquic.crypto/CryptoContext.decrypt_packet
|
Modified
|
aiortc~aioquic
|
2033d31fd875e25cb26ec1113dbfab17ac8b2f08
|
[crypto] refactor nonce calculation
|
<29>:<add> nonce = crypto.iv[:-pn_length] + bytes(
<add> crypto.iv[i - pn_length] ^ pn[i] for i in range(pn_length)
<add> )
<del> nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
<30>:<del> for i in range(len(crypto.iv)):
<31>:<del> nonce[i] ^= crypto.iv[i]
|
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
<0> assert self.is_valid(), "Decryption key is not available"
<1>
<2> # header protection
<3> packet = bytearray(packet)
<4> sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
<5> sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
<6> mask = self.header_protection_mask(sample)
<7>
<8> if is_long_header(packet[0]):
<9> # long header
<10> packet[0] ^= mask[0] & 0x0F
<11> else:
<12> # short header
<13> packet[0] ^= mask[0] & 0x1F
<14>
<15> pn_length = (packet[0] & 0x03) + 1
<16> for i in range(pn_length):
<17> packet[encrypted_offset + i] ^= mask[1 + i]
<18> pn = packet[encrypted_offset : encrypted_offset + pn_length]
<19> plain_header = bytes(packet[: encrypted_offset + pn_length])
<20>
<21> # detect key phase change
<22> crypto = self
<23> if not is_long_header(packet[0]):
<24> key_phase = (packet[0] & 4) >> 2
<25> if key_phase != self.key_phase:
<26> crypto = self.next_key_phase()
<27>
<28> # payload protection
<29> nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
<30> for i in range(len(crypto.iv)):
<31> nonce[i] ^= crypto.iv[i]
<32> try:
<33> payload = crypto.aead.decrypt(
<34> nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
<35> )
<36> except InvalidTag:
<37> raise CryptoError("Payload decryption failed")
<38>
<39> # packet number
<40> packet</s>
|
===========below chunk 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
packet_number = decode_packet_number(
packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
===========unchanged ref 0===========
at: aioquic.crypto
SAMPLE_SIZE = 16
CryptoError(*args: object)
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
is_valid() -> bool
next_key_phase() -> CryptoContext
at: aioquic.crypto.CryptoContext.__init__
self.iv: Optional[bytes]
self.key_phase = key_phase
at: aioquic.crypto.CryptoContext.apply_key_phase
self.iv = crypto.iv
self.key_phase = crypto.key_phase
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
at: aioquic.crypto.CryptoContext.teardown
self.iv = None
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
decode_packet_number(truncated: int, num_bits: int, expected: int) -> int
is_long_header(first_byte: int) -> bool
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
|
aioquic.crypto/CryptoContext.encrypt_packet
|
Modified
|
aiortc~aioquic
|
2033d31fd875e25cb26ec1113dbfab17ac8b2f08
|
[crypto] refactor nonce calculation
|
<7>:<add> nonce = self.iv[:-pn_length] + bytes(
<add> self.iv[i - pn_length] ^ pn[i] for i in range(pn_length)
<add> )
<del> nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
<8>:<del> for i in range(len(self.iv)):
<9>:<del> nonce[i] ^= self.iv[i]
|
# module: aioquic.crypto
class CryptoContext:
def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
<0> assert self.is_valid(), "Encryption key is not available"
<1>
<2> pn_length = (plain_header[0] & 0x03) + 1
<3> pn_offset = len(plain_header) - pn_length
<4> pn = plain_header[pn_offset : pn_offset + pn_length]
<5>
<6> # payload protection
<7> nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
<8> for i in range(len(self.iv)):
<9> nonce[i] ^= self.iv[i]
<10> protected_payload = self.aead.encrypt(nonce, plain_payload, plain_header)
<11>
<12> # header protection
<13> sample_offset = PACKET_NUMBER_MAX_SIZE - pn_length
<14> sample = protected_payload[sample_offset : sample_offset + SAMPLE_SIZE]
<15> mask = self.header_protection_mask(sample)
<16>
<17> packet = bytearray(plain_header + protected_payload)
<18> if is_long_header(packet[0]):
<19> # long header
<20> packet[0] ^= mask[0] & 0x0F
<21> else:
<22> # short header
<23> packet[0] ^= mask[0] & 0x1F
<24>
<25> for i in range(pn_length):
<26> packet[pn_offset + i] ^= mask[1 + i]
<27>
<28> return bytes(packet)
<29>
|
===========unchanged ref 0===========
at: aioquic.crypto
SAMPLE_SIZE = 16
at: aioquic.crypto.AEAD
encrypt(nonce: bytes, data: bytes, associated_data: bytes) -> bytes
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
is_valid() -> bool
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[Any]
self.iv: Optional[bytes]
at: aioquic.crypto.CryptoContext.apply_key_phase
self.aead = crypto.aead
self.iv = crypto.iv
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = AEAD(cipher_suite, key)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.iv = None
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
is_long_header(first_byte: int) -> bool
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
assert self.is_valid(), "Decryption key is not available"
# header protection
packet = bytearray(packet)
sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
# detect key phase change
crypto = self
if not is_long_header(packet[0]):
key_phase = (packet[0] & 4) >> 2
if key_phase != self.key_phase:
crypto = self.next_key_phase()
# payload protection
+ nonce = crypto.iv[:-pn_length] + bytes(
+ crypto.iv[i - pn_length] ^ pn[i] for i in range(pn_length)
+ )
- nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
- for i in range(len(crypto.iv)):
- nonce[i] ^= crypto.iv[i]
try:
payload = crypto.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed</s>
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
<s>_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
packet_number = decode_packet_number(
packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
2ba67697b3d3d689a53438894c55d1da4ba64efc
|
[tests] use actual API to receive stream on server side
|
<0>:<add> async def serve_request(reader, writer):
<add> # check request
<add> request = await reader.read(1024)
<add> self.assertEqual(request, b"ping")
<add>
<add> # send response
<add> writer.write(b"pong")
<add> await asyncio.sleep(0)
<add>
<add> # receives EOF
<add> request = await reader.read()
<add> self.assertEqual(request, b"")
<add>
<2>:<add> server_options={
<add> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<add> serve_request(reader, writer)
<add> ),
<add> "supported_versions": server_versions,
<del> server_options={"supported_versions": server_versions},
<3>:<add> },
<15>:<add> # clients sends data over stream
<del> # send data over stream
<18>:<del> run(asyncio.sleep(0))
<19>:<del> self.assertEqual(client._transport.sent, 5)
<20>:<del> self.assertEqual(server._transport.sent, 4)
<21>:<del>
<22>:<del> # FIXME: needs an API
<23>:<del> server_reader, server_writer = (
<24>:<del> server.streams[0].reader,
<25>:<del> server.streams[0].writer,
<26>:<del> )
<27>:<del> self.assertEqual(run(server_reader.read(1024)), b"ping")
<28>:<del> server_writer.write(b"pong")
<29>:<del> run(asyncio.sleep(0))
<30>:<del> self.assertEqual(client._transport.sent, 6)
<31>:<del> self.assertEqual(server._transport.sent, 5)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> with client_and_server(
<1> client_options={"supported_versions": client_versions},
<2> server_options={"supported_versions": server_versions},
<3> ) as (client, server):
<4> self.assertEqual(client._transport.sent, 4)
<5> self.assertEqual(server._transport.sent, 3)
<6>
<7> # check each endpoint has available connection IDs for the peer
<8> self.assertEqual(
<9> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<10> )
<11> self.assertEqual(
<12> sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<13> )
<14>
<15> # send data over stream
<16> client_reader, client_writer = run(client.create_stream())
<17> client_writer.write(b"ping")
<18> run(asyncio.sleep(0))
<19> self.assertEqual(client._transport.sent, 5)
<20> self.assertEqual(server._transport.sent, 4)
<21>
<22> # FIXME: needs an API
<23> server_reader, server_writer = (
<24> server.streams[0].reader,
<25> server.streams[0].writer,
<26> )
<27> self.assertEqual(run(server_reader.read(1024)), b"ping")
<28> server_writer.write(b"pong")
<29> run(asyncio.sleep(0))
<30> self.assertEqual(client._transport.sent, 6)
<31> self.assertEqual(server._transport.sent, 5)
<32>
<33> # client receives pong
<34> self.assertEqual(run(client_reader.read(1024)), b"pong")
<35>
<36> # client writes EOF
<37> client_writer.write_eof()
<38> run(asyncio.sleep(0))
<39> self</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
self.assertEqual(server._transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
===========unchanged ref 0===========
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
sequence_numbers(connection_ids)
at: tests.utils
run(coro)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
|
aioquic.recovery/QuicPacketSpace.__init__
|
Modified
|
aiortc~aioquic
|
46a1414e7c979be400f622396c5e9f8aeb796c5e
|
[recovery] track unacked crypto packets
|
<6>:<add> self.crypto_packet_in_flight = 0
|
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
<0> self.ack_queue = RangeSet()
<1> self.ack_required = False
<2> self.expected_packet_number = 0
<3>
<4> # sent packets and loss
<5> self.ack_eliciting_in_flight = 0
<6> self.largest_acked_packet = 0
<7> self.loss_time: Optional[float] = None
<8> self.sent_packets: Dict[int, QuicSentPacket] = {}
<9>
|
===========unchanged ref 0===========
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.loss_time = None
|
aioquic.recovery/QuicPacketSpace.teardown
|
Modified
|
aiortc~aioquic
|
46a1414e7c979be400f622396c5e9f8aeb796c5e
|
[recovery] track unacked crypto packets
|
<1>:<add> self.crypto_packet_in_flight = 0
|
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
<0> self.ack_eliciting_in_flight = 0
<1> self.loss_time = None
<2> self.sent_packets.clear()
<3>
|
===========unchanged ref 0===========
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
|
aioquic.recovery/QuicPacketRecovery.detect_loss
|
Modified
|
aiortc~aioquic
|
46a1414e7c979be400f622396c5e9f8aeb796c5e
|
[recovery] track unacked crypto packets
|
<18>:<add> if packet_number <= packet_threshold or packet.sent_time <= time_threshold:
<del> if packet_number <= packet_threshold or packet.sent_time < time_threshold:
<23>:<add> if packet.is_crypto_packet:
<add> space.crypto_packet_in_flight -= 1
|
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
<0> """
<1> Check whether any packets should be declared lost.
<2> """
<3> loss_delay = K_TIME_THRESHOLD * (
<4> max(self._rtt_latest, self._rtt_smoothed)
<5> if self._rtt_initialized
<6> else K_INITIAL_RTT
<7> )
<8> packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
<9> time_threshold = self._get_time() - loss_delay
<10>
<11> lost_bytes = 0
<12> lost_largest_time = None
<13> space.loss_time = None
<14> for packet_number, packet in list(space.sent_packets.items()):
<15> if packet_number > space.largest_acked_packet:
<16> break
<17>
<18> if packet_number <= packet_threshold or packet.sent_time < time_threshold:
<19> # remove packet and update counters
<20> del space.sent_packets[packet_number]
<21> if packet.is_ack_eliciting:
<22> space.ack_eliciting_in_flight -= 1
<23> if packet.in_flight:
<24> lost_bytes += packet.sent_bytes
<25> lost_largest_time = packet.sent_time
<26>
<27> # trigger callbacks
<28> for handler, args in packet.delivery_handlers:
<29> handler(QuicDeliveryState.LOST, *args)
<30> else:
<31> packet_loss_time = packet.sent_time + loss_delay
<32> if space.loss_time is None or space.loss_time > packet_loss_time:
<33> space.loss_time = packet_loss_time
<34>
<35> if lost_bytes:
<36> self.on_packets_lost(lost_bytes, lost_largest_time)
<37>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_TIME_THRESHOLD = 9 / 8
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery.__init__
self._get_time = get_time
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_smoothed = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_latest -= ack_delay
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
self._rtt_initialized = True
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self._ssthresh = self.congestion_window
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========unchanged ref 1===========
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.loss_time = None
at: math
inf: float
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
|
aioquic.recovery/QuicPacketRecovery.get_loss_detection_time
|
Modified
|
aiortc~aioquic
|
46a1414e7c979be400f622396c5e9f8aeb796c5e
|
[recovery] track unacked crypto packets
|
<5>:<del> if not next(
<6>:<del> (True for space in self.spaces if space.ack_eliciting_in_flight), False
<7>:<del> ):
<8>:<add> if not sum(space.ack_eliciting_in_flight for space in self.spaces):
|
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
<0> loss_space = self.get_earliest_loss_time()
<1> if loss_space is not None:
<2> return loss_space.loss_time
<3>
<4> # check there are ACK-eliciting packets in flight
<5> if not next(
<6> (True for space in self.spaces if space.ack_eliciting_in_flight), False
<7> ):
<8> return None
<9>
<10> # PTO
<11> if not self._rtt_initialized:
<12> timeout = K_INITIAL_RTT
<13> else:
<14> timeout = (
<15> self._rtt_smoothed
<16> + max(4 * self._rtt_variance, K_GRANULARITY)
<17> + self.max_ack_delay / 1000
<18> ) * (2 ** self._pto_count)
<19> return self._time_of_last_sent_ack_eliciting_packet + timeout
<20>
|
===========unchanged ref 0===========
at: aioquic.recovery
K_INITIAL_RTT = 0.5 # seconds
K_GRANULARITY = 0.001 # seconds
at: aioquic.recovery.QuicPacketRecovery
get_earliest_loss_time() -> Optional[QuicPacketSpace]
at: aioquic.recovery.QuicPacketRecovery.__init__
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
self._rtt_initialized = False
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.loss_time: Optional[float] = None
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.loss_time = None
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
+ if packet_number <= packet_threshold or packet.sent_time <= time_threshold:
- if packet_number <= packet_threshold or packet.sent_time < time_threshold:
# remove packet and update counters
del space.sent_packets[packet_number]
if packet.is_ack_eliciting:
space.ack_eliciting_in_flight -= 1
+ if packet.is_crypto_packet:
+ space.crypto_packet_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
self.on_packets_lost(lost_bytes, lost_largest_time)
|
aioquic.recovery/QuicPacketRecovery.on_ack_received
|
Modified
|
aiortc~aioquic
|
46a1414e7c979be400f622396c5e9f8aeb796c5e
|
[recovery] track unacked crypto packets
|
<22>:<add> if packet.is_crypto_packet:
<add> space.crypto_packet_in_flight -= 1
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
<0> """
<1> Update metrics as the result of an ACK being received.
<2> """
<3> ack_time = self._get_time()
<4>
<5> is_ack_eliciting = False
<6> largest_acked = ack_rangeset.bounds().stop - 1
<7> largest_newly_acked = None
<8> largest_sent_time = None
<9>
<10> if largest_acked > space.largest_acked_packet:
<11> space.largest_acked_packet = largest_acked
<12>
<13> for packet_number in sorted(space.sent_packets.keys()):
<14> if packet_number > largest_acked:
<15> break
<16> if packet_number in ack_rangeset:
<17> # remove packet and update counters
<18> packet = space.sent_packets.pop(packet_number)
<19> if packet.is_ack_eliciting:
<20> is_ack_eliciting = True
<21> space.ack_eliciting_in_flight -= 1
<22> if packet.in_flight:
<23> self.on_packet_acked(packet)
<24> largest_newly_acked = packet_number
<25> largest_sent_time = packet.sent_time
<26>
<27> # trigger callbacks
<28> for handler, args in packet.delivery_handlers:
<29> handler(QuicDeliveryState.ACKED, *args)
<30>
<31> # nothing to do if there are no newly acked packets
<32> if largest_newly_acked is None:
<33> return
<34>
<35> if largest_acked == largest_newly_acked and is_ack_eliciting:
<36> latest_rtt = ack_time - largest_sent_time
<37>
<38> # decode ACK delay into seconds
<39> ack_delay = max(
<40> (ack_delay_encoded << self.ack_delay</s>
|
===========below chunk 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
# offset: 1
self.max_ack_delay / 1000,
)
# update RTT estimate, which cannot be < 1 ms
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
if self._rtt_latest < self._rtt_min:
self._rtt_min = self._rtt_latest
if self._rtt_latest > self._rtt_min + ack_delay:
self._rtt_latest -= ack_delay
if not self._rtt_initialized:
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_smoothed = latest_rtt
else:
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self.detect_loss(space)
self._crypto_count = 0
self._pto_count = 0
# arm the timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
sent_time: Optional[float] = None
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.rangeset.RangeSet
bounds() -> range
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery
detect_loss(self, space: QuicPacketSpace) -> None
detect_loss(space: QuicPacketSpace) -> None
on_packet_acked(packet: QuicSentPacket) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self._get_time = get_time
self._crypto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
===========unchanged ref 1===========
at: typing.MutableMapping
pop(key: _KT) -> _VT
pop(key: _KT, default: Union[_VT, _T]=...) -> Union[_VT, _T]
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
+ if packet_number <= packet_threshold or packet.sent_time <= time_threshold:
- if packet_number <= packet_threshold or packet.sent_time < time_threshold:
# remove packet and update counters
del space.sent_packets[packet_number]
if packet.is_ack_eliciting:
space.ack_eliciting_in_flight -= 1
+ if packet.is_crypto_packet:
+ space.crypto_packet_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
self.on_packets_lost(lost_bytes, lost_largest_time)
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
return loss_space.loss_time
# check there are ACK-eliciting packets in flight
- if not next(
- (True for space in self.spaces if space.ack_eliciting_in_flight), False
- ):
+ if not sum(space.ack_eliciting_in_flight for space in self.spaces):
return None
# PTO
if not self._rtt_initialized:
timeout = K_INITIAL_RTT
else:
timeout = (
self._rtt_smoothed
+ max(4 * self._rtt_variance, K_GRANULARITY)
+ self.max_ack_delay / 1000
) * (2 ** self._pto_count)
return self._time_of_last_sent_ack_eliciting_packet + timeout
|
aioquic.recovery/QuicPacketRecovery.on_packet_sent
|
Modified
|
aiortc~aioquic
|
46a1414e7c979be400f622396c5e9f8aeb796c5e
|
[recovery] track unacked crypto packets
|
<5>:<add> if packet.is_crypto_packet:
<add> space.crypto_packet_in_flight += 1
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_packet_sent(self, packet: QuicSentPacket, space: QuicPacketSpace) -> None:
<0> packet.sent_time = self._get_time()
<1> space.sent_packets[packet.packet_number] = packet
<2>
<3> if packet.is_ack_eliciting:
<4> space.ack_eliciting_in_flight += 1
<5> if packet.in_flight:
<6> if packet.is_crypto_packet:
<7> self._time_of_last_sent_crypto_packet = packet.sent_time
<8> if packet.is_ack_eliciting:
<9> self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
<10>
<11> # add packet to bytes in flight
<12> self.bytes_in_flight += packet.sent_bytes
<13>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.packet_builder.QuicSentPacket
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
at: aioquic.recovery
K_MAX_DATAGRAM_SIZE = 1280
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery.__init__
self._get_time = get_time
self.congestion_window = K_INITIAL_WINDOW
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.congestion_window = max(
int(self.congestion_window * K_LOSS_REDUCTION_FACTOR), K_MINIMUM_WINDOW
)
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketSpace:
def teardown(self) -> None:
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.loss_time = None
self.sent_packets.clear()
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
# sent packets and loss
self.ack_eliciting_in_flight = 0
+ self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
return loss_space.loss_time
# check there are ACK-eliciting packets in flight
- if not next(
- (True for space in self.spaces if space.ack_eliciting_in_flight), False
- ):
+ if not sum(space.ack_eliciting_in_flight for space in self.spaces):
return None
# PTO
if not self._rtt_initialized:
timeout = K_INITIAL_RTT
else:
timeout = (
self._rtt_smoothed
+ max(4 * self._rtt_variance, K_GRANULARITY)
+ self.max_ack_delay / 1000
) * (2 ** self._pto_count)
return self._time_of_last_sent_ack_eliciting_packet + timeout
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketRecovery:
def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
+ if packet_number <= packet_threshold or packet.sent_time <= time_threshold:
- if packet_number <= packet_threshold or packet.sent_time < time_threshold:
# remove packet and update counters
del space.sent_packets[packet_number]
if packet.is_ack_eliciting:
space.ack_eliciting_in_flight -= 1
+ if packet.is_crypto_packet:
+ space.crypto_packet_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
self.on_packets_lost(lost_bytes, lost_largest_time)
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
"""
Update metrics as the result of an ACK being received.
"""
ack_time = self._get_time()
is_ack_eliciting = False
largest_acked = ack_rangeset.bounds().stop - 1
largest_newly_acked = None
largest_sent_time = None
if largest_acked > space.largest_acked_packet:
space.largest_acked_packet = largest_acked
for packet_number in sorted(space.sent_packets.keys()):
if packet_number > largest_acked:
break
if packet_number in ack_rangeset:
# remove packet and update counters
packet = space.sent_packets.pop(packet_number)
if packet.is_ack_eliciting:
is_ack_eliciting = True
space.ack_eliciting_in_flight -= 1
+ if packet.is_crypto_packet:
+ space.crypto_packet_in_flight -= 1
if packet.in_flight:
self.on_packet_acked(packet)
largest_newly_acked = packet_number
largest_sent_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.ACKED, *args)
# nothing to do if there are no newly acked packets
if largest_newly_acked is None:
return
if largest_acked == largest_newly_acked and is_ack_eliciting:
latest_rtt = ack_time - largest_sent_time
# decode ACK delay into seconds
ack_delay = max(
(ack_delay_encoded << self.ack_delay_exponent) / 1000000,
self.max_ack_delay</s>
|
aioquic.recovery/QuicPacketRecovery.get_loss_detection_time
|
Modified
|
aiortc~aioquic
|
8a643e25e5069e6889510dc7249986b017676448
|
[recovery] correct packet timer duration before first RTT
|
<0>:<add> # loss timer
<4>:<add> # packet timer
<del> # check there are ACK-eliciting packets in flight
<5>:<add> if sum(space.ack_eliciting_in_flight for space in self.spaces):
<del> if not sum(space.ack_eliciting_in_flight for space in self.spaces):
<6>:<del> return None
<7>:<del>
<8>:<del> # PTO
<9>:<del> if not self._rtt_initialized:
<10>:<del> timeout = K_INITIAL_RTT
<11>:<del> else:
<17>:<add> return self._time_of_last_sent_ack_eliciting_packet + timeout
<del> return self._time_of_last_sent_ack_eliciting_packet + timeout
|
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
<0> loss_space = self.get_earliest_loss_time()
<1> if loss_space is not None:
<2> return loss_space.loss_time
<3>
<4> # check there are ACK-eliciting packets in flight
<5> if not sum(space.ack_eliciting_in_flight for space in self.spaces):
<6> return None
<7>
<8> # PTO
<9> if not self._rtt_initialized:
<10> timeout = K_INITIAL_RTT
<11> else:
<12> timeout = (
<13> self._rtt_smoothed
<14> + max(4 * self._rtt_variance, K_GRANULARITY)
<15> + self.max_ack_delay / 1000
<16> ) * (2 ** self._pto_count)
<17> return self._time_of_last_sent_ack_eliciting_packet + timeout
<18>
|
===========unchanged ref 0===========
at: aioquic.recovery
K_GRANULARITY = 0.001 # seconds
at: aioquic.recovery.QuicPacketRecovery
get_earliest_loss_time() -> Optional[QuicPacketSpace]
at: aioquic.recovery.QuicPacketRecovery.__init__
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
self._pto_count = 0
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_variance = latest_rtt / 2
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self._pto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self._pto_count += 1
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.loss_time: Optional[float] = None
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.loss_time = None
|
aioquic.recovery/QuicPacketRecovery.__init__
|
Modified
|
aiortc~aioquic
|
ec7ff1f579dee3a5b3f6664257f87479eed71a96
|
[recovery] ensure pending data gets sets on loss detection
|
<8>:<del> self._set_loss_detection_timer = set_loss_detection_timer
|
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
self,
logger: logging.LoggerAdapter,
get_time: Callable[[], float],
send_probe: Callable[[], None],
- set_loss_detection_timer: Callable[[], None],
) -> None:
<0> self.ack_delay_exponent = 3
<1> self.max_ack_delay = 25 # ms
<2> self.spaces: List[QuicPacketSpace] = []
<3>
<4> # callbacks
<5> self._get_time = get_time
<6> self._logger = logger
<7> self._send_probe = send_probe
<8> self._set_loss_detection_timer = set_loss_detection_timer
<9>
<10> # loss detection
<11> self._crypto_count = 0
<12> self._pto_count = 0
<13> self._rtt_initialized = False
<14> self._rtt_latest = 0.0
<15> self._rtt_min = math.inf
<16> self._rtt_smoothed = 0.0
<17> self._rtt_variance = 0.0
<18> self._time_of_last_sent_ack_eliciting_packet = 0.0
<19> self._time_of_last_sent_crypto_packet = 0.0
<20>
<21> # congestion control
<22> self.bytes_in_flight = 0
<23> self.congestion_window = K_INITIAL_WINDOW
<24> self._congestion_recovery_start_time = 0.0
<25> self._ssthresh = math.inf
<26>
|
===========unchanged ref 0===========
at: aioquic.recovery
K_INITIAL_WINDOW = 10 * K_MAX_DATAGRAM_SIZE
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_latest -= ack_delay
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
self._rtt_min = self._rtt_latest
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self._crypto_count = 0
self._pto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self._pto_count += 1
at: aioquic.recovery.QuicPacketRecovery.on_packet_acked
self.bytes_in_flight -= packet.sent_bytes
self.congestion_window += (
K_MAX_DATAGRAM_SIZE * packet.sent_bytes // self.congestion_window
)
self.congestion_window += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self._time_of_last_sent_crypto_packet = packet.sent_time
self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
self.bytes_in_flight += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.bytes_in_flight -= lost_bytes
===========unchanged ref 1===========
self._congestion_recovery_start_time = self._get_time()
self.congestion_window = max(
int(self.congestion_window * K_LOSS_REDUCTION_FACTOR), K_MINIMUM_WINDOW
)
self._ssthresh = self.congestion_window
at: logging
LoggerAdapter(logger: Logger, extra: Mapping[str, Any])
at: math
inf: float
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
|
aioquic.recovery/QuicPacketRecovery.on_ack_received
|
Modified
|
aiortc~aioquic
|
ec7ff1f579dee3a5b3f6664257f87479eed71a96
|
[recovery] ensure pending data gets sets on loss detection
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
<0> """
<1> Update metrics as the result of an ACK being received.
<2> """
<3> ack_time = self._get_time()
<4>
<5> is_ack_eliciting = False
<6> largest_acked = ack_rangeset.bounds().stop - 1
<7> largest_newly_acked = None
<8> largest_sent_time = None
<9>
<10> if largest_acked > space.largest_acked_packet:
<11> space.largest_acked_packet = largest_acked
<12>
<13> for packet_number in sorted(space.sent_packets.keys()):
<14> if packet_number > largest_acked:
<15> break
<16> if packet_number in ack_rangeset:
<17> # remove packet and update counters
<18> packet = space.sent_packets.pop(packet_number)
<19> if packet.is_ack_eliciting:
<20> is_ack_eliciting = True
<21> space.ack_eliciting_in_flight -= 1
<22> if packet.is_crypto_packet:
<23> space.crypto_packet_in_flight -= 1
<24> if packet.in_flight:
<25> self.on_packet_acked(packet)
<26> largest_newly_acked = packet_number
<27> largest_sent_time = packet.sent_time
<28>
<29> # trigger callbacks
<30> for handler, args in packet.delivery_handlers:
<31> handler(QuicDeliveryState.ACKED, *args)
<32>
<33> # nothing to do if there are no newly acked packets
<34> if largest_newly_acked is None:
<35> return
<36>
<37> if largest_acked == largest_newly_acked and is_ack_eliciting:
<38> latest_rtt = ack_time - largest_sent_time
<39>
<40> # decode ACK delay</s>
|
===========below chunk 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
# offset: 1
ack_delay = max(
(ack_delay_encoded << self.ack_delay_exponent) / 1000000,
self.max_ack_delay / 1000,
)
# update RTT estimate, which cannot be < 1 ms
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
if self._rtt_latest < self._rtt_min:
self._rtt_min = self._rtt_latest
if self._rtt_latest > self._rtt_min + ack_delay:
self._rtt_latest -= ack_delay
if not self._rtt_initialized:
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_smoothed = latest_rtt
else:
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self.detect_loss(space)
self._crypto_count = 0
self._pto_count = 0
# arm the timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.rangeset.RangeSet
bounds() -> range
at: aioquic.recovery.QuicPacketRecovery
detect_loss(self, space: QuicPacketSpace) -> None
detect_loss(space: QuicPacketSpace) -> None
get_earliest_loss_time() -> Optional[QuicPacketSpace]
on_packet_acked(packet: QuicSentPacket) -> None
on_packet_acked(self, packet: QuicSentPacket) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self._get_time = get_time
self._logger = logger
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self._pto_count += 1
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
===========unchanged ref 1===========
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.recovery.QuicPacketSpace.teardown
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
at: logging.LoggerAdapter
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
__class_getitem__ = classmethod(GenericAlias)
at: typing.MutableMapping
pop(key: _KT) -> _VT
pop(key: _KT, default: Union[_VT, _T]=...) -> Union[_VT, _T]
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
self,
logger: logging.LoggerAdapter,
get_time: Callable[[], float],
send_probe: Callable[[], None],
- set_loss_detection_timer: Callable[[], None],
) -> None:
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
# callbacks
self._get_time = get_time
self._logger = logger
self._send_probe = send_probe
- self._set_loss_detection_timer = set_loss_detection_timer
# loss detection
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
self._time_of_last_sent_crypto_packet = 0.0
# congestion control
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
self._congestion_recovery_start_time = 0.0
self._ssthresh = math.inf
|
|
aioquic.recovery/QuicPacketRecovery.on_loss_detection_timeout
|
Modified
|
aiortc~aioquic
|
ec7ff1f579dee3a5b3f6664257f87479eed71a96
|
[recovery] ensure pending data gets sets on loss detection
|
<3>:<del> # detect loss and re-arm the timer
<5>:<del> self._set_loss_detection_timer()
<7>:<del> # sending the probe will re-arm the timer
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_loss_detection_timeout(self) -> None:
<0> self._logger.info("Loss detection timeout triggered")
<1> loss_space = self.get_earliest_loss_time()
<2> if loss_space is not None:
<3> # detect loss and re-arm the timer
<4> self.detect_loss(loss_space)
<5> self._set_loss_detection_timer()
<6> else:
<7> # sending the probe will re-arm the timer
<8> self._pto_count += 1
<9> self._send_probe()
<10>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.packet_builder.QuicSentPacket
sent_time: Optional[float] = None
sent_bytes: int = 0
at: aioquic.recovery.QuicPacketRecovery.__init__
self._send_probe = send_probe
self._pto_count = 0
self.bytes_in_flight = 0
self._congestion_recovery_start_time = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._pto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self.bytes_in_flight += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.bytes_in_flight -= lost_bytes
self._congestion_recovery_start_time = self._get_time()
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
self,
logger: logging.LoggerAdapter,
get_time: Callable[[], float],
send_probe: Callable[[], None],
- set_loss_detection_timer: Callable[[], None],
) -> None:
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
# callbacks
self._get_time = get_time
self._logger = logger
self._send_probe = send_probe
- self._set_loss_detection_timer = set_loss_detection_timer
# loss detection
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
self._time_of_last_sent_crypto_packet = 0.0
# congestion control
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
self._congestion_recovery_start_time = 0.0
self._ssthresh = math.inf
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
"""
Update metrics as the result of an ACK being received.
"""
ack_time = self._get_time()
is_ack_eliciting = False
largest_acked = ack_rangeset.bounds().stop - 1
largest_newly_acked = None
largest_sent_time = None
if largest_acked > space.largest_acked_packet:
space.largest_acked_packet = largest_acked
for packet_number in sorted(space.sent_packets.keys()):
if packet_number > largest_acked:
break
if packet_number in ack_rangeset:
# remove packet and update counters
packet = space.sent_packets.pop(packet_number)
if packet.is_ack_eliciting:
is_ack_eliciting = True
space.ack_eliciting_in_flight -= 1
if packet.is_crypto_packet:
space.crypto_packet_in_flight -= 1
if packet.in_flight:
self.on_packet_acked(packet)
largest_newly_acked = packet_number
largest_sent_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.ACKED, *args)
# nothing to do if there are no newly acked packets
if largest_newly_acked is None:
return
if largest_acked == largest_newly_acked and is_ack_eliciting:
latest_rtt = ack_time - largest_sent_time
# decode ACK delay into seconds
ack_delay = max(
(ack_delay_encoded << self.ack_delay_exponent) / 1000000,
self.max_ack_delay / 1000</s>
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
# offset: 1
<s> (ack_delay_encoded << self.ack_delay_exponent) / 1000000,
self.max_ack_delay / 1000,
)
# update RTT estimate, which cannot be < 1 ms
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
if self._rtt_latest < self._rtt_min:
self._rtt_min = self._rtt_latest
if self._rtt_latest > self._rtt_min + ack_delay:
self._rtt_latest -= ack_delay
if not self._rtt_initialized:
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_smoothed = latest_rtt
else:
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self.detect_loss(space)
self._crypto_count = 0
self._pto_count = 0
- # arm the timer
- self._set_loss_detection_timer()
-
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
ec7ff1f579dee3a5b3f6664257f87479eed71a96
|
[recovery] ensure pending data gets sets on loss detection
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self.__send_pending_task = None
<3> if self.__state == QuicConnectionState.DRAINING:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<11> peer_cid=self.peer_cid,
<12> peer_token=self.peer_token,
<13> spin_bit=self._spin_bit,
<14> version=self._version,
<15> )
<16>
<17> if self.__close:
<18> for epoch, packet_type in (
<19> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<20> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<21> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<22> ):
<23> crypto = self.cryptos[epoch]
<24> if crypto.send.is_valid():
<25> builder.start_packet(packet_type, crypto)
<26> write_close_frame(builder, **self.__close)
<27> builder.end_packet()
<28> self.__close = None
<29> break
<30> else:
<31> # check if we can discard handshake keys
<32> if (
<33> self._discard_handshake_at is not None
<34> and self._loop.time() > self._discard_handshake_at
<35> ):
<36> self._logger.debug("Discarding handshake keys")
<37> self.cryptos[tls.Epoch.HANDSHAKE].teardown()
<38> self.spaces[tls.Epoch.HANDSHAKE].teardown()
<39> self._discard_handshake_at = None
<40> self._discard_handshake_done = True
<41> if</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
# arm loss timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
seek(pos: int) -> None
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.peer_token = b""
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self.host_cid = self._host_cids[0].cid
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._spin_bit = False
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_ack_frame
self._discard_handshake_at = (
self._loop.time() + 3 * self._loss.get_probe_timeout()
)
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_soon
self.__send_pending_task = self._loop.call_soon(self._send_pending)
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
===========unchanged ref 2===========
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair
teardown() -> None
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
|
|
aioquic.connection/QuicConnection._send_probe
|
Modified
|
aiortc~aioquic
|
ec7ff1f579dee3a5b3f6664257f87479eed71a96
|
[recovery] ensure pending data gets sets on loss detection
|
<1>:<del> self._send_pending()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_probe(self) -> None:
<0> self._probe_pending = True
<1> self._send_pending()
<2>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_set_loss_detection_timer() -> None
_set_loss_detection_timer(self) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_loss_detection_timeout(self) -> None:
+ self._loss_timer = None
+ self._loss.on_loss_detection_timeout()
+ self._send_pending()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self.__send_pending_task = None
if self.__state == QuicConnectionState.DRAINING:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self.cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self.__close)
builder.end_packet()
self.__close = None
break
else:
# check if we can discard handshake keys
if (
self._discard_handshake_at is not None
and self._loop.time() > self._discard_handshake_at
):
self._logger.debug("Discarding handshake keys")
self.cryptos[tls.Epoch.HANDSHAKE].teardown()
self.spaces[tls.Epoch.HANDSHAKE].teardown()
self._discard_handshake_at = None
self._discard_handshake_done = True
if not self._discard_handshake_done:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
+ # arm loss timer
- # arm loss timer
+ self._set_loss_detection_timer()
- self._set_loss_detection_timer()
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_loss_detection_timeout(self) -> None:
self._logger.info("Loss detection timeout triggered")
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
- # detect loss and re-arm the timer
self.detect_loss(loss_space)
- self._set_loss_detection_timer()
else:
- # sending the probe will re-arm the timer
self._pto_count += 1
self._send_probe()
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
self,
logger: logging.LoggerAdapter,
get_time: Callable[[], float],
send_probe: Callable[[], None],
- set_loss_detection_timer: Callable[[], None],
) -> None:
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
# callbacks
self._get_time = get_time
self._logger = logger
self._send_probe = send_probe
- self._set_loss_detection_timer = set_loss_detection_timer
# loss detection
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
self._time_of_last_sent_crypto_packet = 0.0
# congestion control
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
self._congestion_recovery_start_time = 0.0
self._ssthresh = math.inf
===========changed ref 5===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
"""
Update metrics as the result of an ACK being received.
"""
ack_time = self._get_time()
is_ack_eliciting = False
largest_acked = ack_rangeset.bounds().stop - 1
largest_newly_acked = None
largest_sent_time = None
if largest_acked > space.largest_acked_packet:
space.largest_acked_packet = largest_acked
for packet_number in sorted(space.sent_packets.keys()):
if packet_number > largest_acked:
break
if packet_number in ack_rangeset:
# remove packet and update counters
packet = space.sent_packets.pop(packet_number)
if packet.is_ack_eliciting:
is_ack_eliciting = True
space.ack_eliciting_in_flight -= 1
if packet.is_crypto_packet:
space.crypto_packet_in_flight -= 1
if packet.in_flight:
self.on_packet_acked(packet)
largest_newly_acked = packet_number
largest_sent_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.ACKED, *args)
# nothing to do if there are no newly acked packets
if largest_newly_acked is None:
return
if largest_acked == largest_newly_acked and is_ack_eliciting:
latest_rtt = ack_time - largest_sent_time
# decode ACK delay into seconds
ack_delay = max(
(ack_delay_encoded << self.ack_delay_exponent) / 1000000,
self.max_ack_delay / 1000</s>
|
aioquic.connection/QuicConnection._set_loss_detection_timer
|
Modified
|
aiortc~aioquic
|
ec7ff1f579dee3a5b3f6664257f87479eed71a96
|
[recovery] ensure pending data gets sets on loss detection
|
<13>:<add> loss_time, self._on_loss_detection_timeout
<del> loss_time, self._loss.on_loss_detection_timeout
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_loss_detection_timer(self) -> None:
<0> # stop timer
<1> if self._loss_timer is not None:
<2> self._loss_timer.cancel()
<3> self._loss_timer = None
<4>
<5> # re-arm timer
<6> if self.__state not in [
<7> QuicConnectionState.CLOSING,
<8> QuicConnectionState.DRAINING,
<9> ]:
<10> loss_time = self._loss.get_loss_detection_time()
<11> if loss_time is not None:
<12> self._loss_timer = self._loop.call_at(
<13> loss_time, self._loss.on_loss_detection_timeout
<14> )
<15>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionState()
at: aioquic.connection.QuicConnection
_on_loss_detection_timeout() -> None
at: aioquic.connection.QuicConnection.__init__
self._loop = asyncio.get_event_loop()
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
at: aioquic.connection.QuicConnection._on_loss_detection_timeout
self._loss_timer = None
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.recovery.QuicPacketRecovery
get_loss_detection_time() -> float
at: asyncio.events.TimerHandle
__slots__ = ['_scheduled', '_when']
cancel() -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_loss_detection_timeout(self) -> None:
+ self._loss_timer = None
+ self._loss.on_loss_detection_timeout()
+ self._send_pending()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_probe(self) -> None:
self._probe_pending = True
- self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self.__send_pending_task = None
if self.__state == QuicConnectionState.DRAINING:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self.cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self.__close)
builder.end_packet()
self.__close = None
break
else:
# check if we can discard handshake keys
if (
self._discard_handshake_at is not None
and self._loop.time() > self._discard_handshake_at
):
self._logger.debug("Discarding handshake keys")
self.cryptos[tls.Epoch.HANDSHAKE].teardown()
self.spaces[tls.Epoch.HANDSHAKE].teardown()
self._discard_handshake_at = None
self._discard_handshake_done = True
if not self._discard_handshake_done:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
+ # arm loss timer
- # arm loss timer
+ self._set_loss_detection_timer()
- self._set_loss_detection_timer()
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_loss_detection_timeout(self) -> None:
self._logger.info("Loss detection timeout triggered")
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
- # detect loss and re-arm the timer
self.detect_loss(loss_space)
- self._set_loss_detection_timer()
else:
- # sending the probe will re-arm the timer
self._pto_count += 1
self._send_probe()
===========changed ref 5===========
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
self,
logger: logging.LoggerAdapter,
get_time: Callable[[], float],
send_probe: Callable[[], None],
- set_loss_detection_timer: Callable[[], None],
) -> None:
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
# callbacks
self._get_time = get_time
self._logger = logger
self._send_probe = send_probe
- self._set_loss_detection_timer = set_loss_detection_timer
# loss detection
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
self._time_of_last_sent_crypto_packet = 0.0
# congestion control
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
self._congestion_recovery_start_time = 0.0
self._ssthresh = math.inf
|
aioquic.stream/QuicStream.get_frame
|
Modified
|
aiortc~aioquic
|
4c0c18bddb2532b6d81174dd0cad459c2b6f47b4
|
[stream] ensure a FIN-only packet is rescheduled if needed
|
<10>:<add> return QuicStreamFrame(fin=True, offset=self._send_buffer_fin)
<del> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
|
# module: aioquic.stream
class QuicStream(asyncio.Transport):
def get_frame(
self, max_size: int, max_offset: Optional[int] = None
) -> Optional[QuicStreamFrame]:
<0> """
<1> Get a frame of data to send.
<2> """
<3> # get the first pending data range
<4> try:
<5> r = self._send_pending[0]
<6> except IndexError:
<7> if self._send_pending_eof:
<8> # FIN only
<9> self._send_pending_eof = False
<10> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
<11> return None
<12>
<13> # apply flow control
<14> start = r.start
<15> stop = min(r.stop, start + max_size)
<16> if max_offset is not None and stop > max_offset:
<17> stop = max_offset
<18> if stop <= start:
<19> return None
<20>
<21> # create frame
<22> frame = QuicStreamFrame(
<23> data=self._send_buffer[
<24> start - self._send_buffer_start : stop - self._send_buffer_start
<25> ],
<26> offset=start,
<27> )
<28> self._send_pending.subtract(start, stop)
<29>
<30> # track the highest offset ever sent
<31> if stop > self._send_highest:
<32> self._send_highest = stop
<33>
<34> # if the buffer is empty and EOF was written, set the FIN bit
<35> if self._send_buffer_fin == stop:
<36> frame.fin = True
<37> self._send_pending_eof = False
<38>
<39> return frame
<40>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.rangeset.RangeSet
subtract(start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_highest = 0
self._send_pending = RangeSet()
self._send_pending_eof = False
self._send_buffer_start = 0 # the offset for the start of the buffer
at: aioquic.stream.QuicStream.on_data_delivery
self._send_buffer_start += size
self._send_pending_eof = True
at: aioquic.stream.QuicStream.write
self._send_buffer += data
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
self._send_pending_eof = True
|
aioquic.stream/QuicStream.on_data_delivery
|
Modified
|
aiortc~aioquic
|
4c0c18bddb2532b6d81174dd0cad459c2b6f47b4
|
[stream] ensure a FIN-only packet is rescheduled if needed
|
<3>:<del> if stop - start:
<4>:<add> if delivery == QuicDeliveryState.ACKED:
<del> if delivery == QuicDeliveryState.ACKED:
<5>:<add> if stop > start:
<12>:<add> else:
<del> else:
<13>:<add> if stop > start:
<14>:<add> if stop == self._send_buffer_fin:
<del> if stop == self._send_buffer_fin:
<15>:<add> self._send_pending_eof = True
<del> self._send_pending_eof = True
|
# module: aioquic.stream
class QuicStream(asyncio.Transport):
def on_data_delivery(
self, delivery: QuicDeliveryState, start: int, stop: int
) -> None:
<0> """
<1> Callback when sent data is ACK'd.
<2> """
<3> if stop - start:
<4> if delivery == QuicDeliveryState.ACKED:
<5> self._send_acked.add(start, stop)
<6> first_range = self._send_acked[0]
<7> if first_range.start == self._send_buffer_start:
<8> size = first_range.stop - first_range.start
<9> self._send_acked.shift()
<10> self._send_buffer_start += size
<11> del self._send_buffer[:size]
<12> else:
<13> self._send_pending.add(start, stop)
<14> if stop == self._send_buffer_fin:
<15> self._send_pending_eof = True
<16>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
shift() -> range
at: aioquic.stream.QuicStream.__init__
self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_buffer_fin: Optional[int] = None
self._send_pending = RangeSet()
self._send_buffer_start = 0 # the offset for the start of the buffer
at: aioquic.stream.QuicStream.write
self._send_buffer += data
at: aioquic.stream.QuicStream.write_eof
self._send_buffer_fin = self._send_buffer_stop
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.Transport):
def get_frame(
self, max_size: int, max_offset: Optional[int] = None
) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# get the first pending data range
try:
r = self._send_pending[0]
except IndexError:
if self._send_pending_eof:
# FIN only
self._send_pending_eof = False
+ return QuicStreamFrame(fin=True, offset=self._send_buffer_fin)
- return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
return None
# apply flow control
start = r.start
stop = min(r.stop, start + max_size)
if max_offset is not None and stop > max_offset:
stop = max_offset
if stop <= start:
return None
# create frame
frame = QuicStreamFrame(
data=self._send_buffer[
start - self._send_buffer_start : stop - self._send_buffer_start
],
offset=start,
)
self._send_pending.subtract(start, stop)
# track the highest offset ever sent
if stop > self._send_highest:
self._send_highest = stop
# if the buffer is empty and EOF was written, set the FIN bit
if self._send_buffer_fin == stop:
frame.fin = True
self._send_pending_eof = False
return frame
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
d357a34e2d0aeb3cc6d6c9115ec9ca9480b4995a
|
[connection] make connect() a plain method
|
<28>:<add> self._connect_called = False
<add> self._connected = asyncio.Event()
<del> self.__connected = asyncio.Event()
|
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19> if supported_versions is not None:
<20> self.supported_versions = supported_versions
<21>
<22> # counters for debugging
<23> self._stateless_retry_count = 0
<24> self._version_negotiation_count = 0
<25>
<26> self._loop = asyncio.get_event_loop()
<27> self.__close: Optional[Dict] = None
<28> self.__connected = asyncio.Event()
<29> self._discard_handshake_at: Optional[float] = None
<30> self._discard_handshake_done = False
<31> self.__</s>
|
===========below chunk 0===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._</s>
===========below chunk 1===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s> = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
# callbacks
self._connection_id_issued_handler:</s>
===========below chunk 2===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>ConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO</s>
===========below chunk 3===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_</s>
|
aioquic.connection/QuicConnection.connect
|
Modified
|
aiortc~aioquic
|
d357a34e2d0aeb3cc6d6c9115ec9ca9480b4995a
|
[connection] make connect() a plain method
|
<1>:<add> Initiate the TLS handshake.
<add>
<add> This method can only be called for clients and a single time.
<del> Initiate the TLS handshake and wait for it to complete.
<3>:<add> assert (
<add> self.is_client and not self._connect_called
<add> ), "connect() can only be called for clients and a single time"
<add> self._connect_called = True
<add>
<del> assert self.is_client
<10>:<del> await self.__connected.wait()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def connect(
- def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
<0> """
<1> Initiate the TLS handshake and wait for it to complete.
<2> """
<3> assert self.is_client
<4> self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
<5> if protocol_version is not None:
<6> self._version = protocol_version
<7> else:
<8> self._version = max(self.supported_versions)
<9> self._connect()
<10> await self.__connected.wait()
<11>
|
===========unchanged ref 0===========
at: aioquic.connection
NetworkAddress = Any
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self._connect_called = False
===========changed ref 0===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
+ self._connect_called = False
+ self._connected = asyncio.Event()
- self.__connected = asyncio.Event()
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self</s>
===========changed ref 1===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
</s>
===========changed ref 2===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>loss_timer: Optional[asyncio.TimerHandle] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire</s>
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
d357a34e2d0aeb3cc6d6c9115ec9ca9480b4995a
|
[connection] make connect() a plain method
|
<41>:<add> if not self._connected.is_set():
<del> if not self.__connected.is_set
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a CRYPTO frame.
<2> """
<3> stream = self.streams[context.epoch]
<4> stream.add_frame(pull_crypto_frame(buf))
<5> data = stream.pull_data()
<6> if data:
<7> # pass data to TLS layer
<8> try:
<9> self.tls.handle_message(data, self.send_buffer)
<10> self._push_crypto_data()
<11> except tls.Alert as exc:
<12> raise QuicConnectionError(
<13> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<14> frame_type=QuicFrameType.CRYPTO,
<15> reason_phrase=str(exc),
<16> )
<17>
<18> # parse transport parameters
<19> if (
<20> not self._parameters_received
<21> and self.tls.received_extensions is not None
<22> ):
<23> for ext_type, ext_data in self.tls.received_extensions:
<24> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<25> self._parse_transport_parameters(ext_data)
<26> self._parameters_received = True
<27> break
<28> assert (
<29> self._parameters_received
<30> ), "No QUIC transport parameters received"
<31> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
<32>
<33> # update current epoch
<34> if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<35> tls.State.CLIENT_POST_HANDSHAKE,
<36> tls.State.SERVER_POST_HANDSHAKE,
<37> ]:
<38> self._replenish_connection_ids()
<39> self.__epoch = tls.Epoch.ONE_RTT
<40> # wakeup waiter
<41> if not self.__connected.is_set</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnectionState()
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError]
at: aioquic.connection.QuicConnection
connection_lost(exc: Exception) -> None
_push_crypto_data() -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
_set_state(state: QuicConnectionState) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._handle_connection_close_frame
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
error_code, reason_phrase = pull_application_close_frame(buf)
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
frame_type = None
error_code, frame_type, reason_phrase = pull_transport_close_frame(buf)
error_code, reason_phrase = pull_application_close_frame(buf)
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
===========unchanged ref 1===========
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
===========unchanged ref 2===========
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def wait_connected(self) -> None:
+ """
+ Wait for the TLS handshake to complete.
+ """
+ await self._connected.wait()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def connect(
- def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
+ Initiate the TLS handshake.
+
+ This method can only be called for clients and a single time.
- Initiate the TLS handshake and wait for it to complete.
"""
+ assert (
+ self.is_client and not self._connect_called
+ ), "connect() can only be called for clients and a single time"
+ self._connect_called = True
+
- assert self.is_client
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
self._version = max(self.supported_versions)
self._connect()
- await self.__connected.wait()
===========changed ref 2===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
+ self._connect_called = False
+ self._connected = asyncio.Event()
- self.__connected = asyncio.Event()
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self</s>
|
aioquic.client/connect
|
Modified
|
aiortc~aioquic
|
d357a34e2d0aeb3cc6d6c9115ec9ca9480b4995a
|
[connection] make connect() a plain method
|
<s>manager
async def connect(
host: str,
port: int,
*,
alpn_protocols: Optional[List[str]] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
<0> """
<1> Connect to a QUIC server at the given `host` and `port`.
<2>
<3> :meth:`connect()` returns an awaitable. Awaiting it yields a
<4> :class:`~aioquic.QuicConnection` which can be used to create streams.
<5>
<6> :func:`connect` also accepts the following optional arguments:
<7>
<8> * ``alpn_protocols`` is a list of ALPN protocols to offer in the
<9> ClientHello.
<10> * ``secrets_log_file`` is a file-like object in which to log traffic
<11> secrets. This is useful to analyze traffic captures with Wireshark.
<12> * ``session_ticket`` is a TLS session ticket which should be used for
<13> resumption.
<14> * ``session_ticket_handler`` is a callback which is invoked by the TLS
<15> engine when a new session ticket is received.
<16> * ``stream_handler`` is a callback which is invoked whenever a stream is
<17> created. It must accept two arguments: a :class:`asyncio.StreamReader`
<18> and a :class:`asyncio.StreamWriter`.
<19> """
<20> loop = asyncio.get_event_loop()
<21>
<22> # if host is not an IP address, pass it to enable SNI
<23> try:
<24> ipaddress.ip_address(host)
<25> server_name = None
<26> except ValueError:
<27> server_name = host
<28>
<29> # lookup remote address
<30> infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
<31> addr = infos[0][4]</s>
|
===========below chunk 0===========
<s>(
host: str,
port: int,
*,
alpn_protocols: Optional[List[str]] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
# offset: 1
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
# connect
_, protocol = await loop.create_datagram_endpoint(
lambda: QuicConnection(
alpn_protocols=alpn_protocols,
is_client=True,
secrets_log_file=secrets_log_file,
server_name=server_name,
session_ticket=session_ticket,
session_ticket_handler=session_ticket_handler,
stream_handler=stream_handler,
),
local_addr=("::", 0),
)
protocol = cast(QuicConnection, protocol)
await protocol.connect(addr, protocol_version=protocol_version)
try:
yield protocol
finally:
protocol.close()
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: aioquic.connection
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, supported_versions: Optional[List[QuicProtocolVersion]]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connect(addr: NetworkAddress, protocol_version: Optional[int]=None) -> None
wait_connected() -> None
at: aioquic.tls
SessionTicket(age_add: int, cipher_suite: CipherSuite, not_valid_after: datetime.datetime, not_valid_before: datetime.datetime, resumption_secret: bytes, server_name: str, ticket: bytes, max_early_data_size: Optional[int]=None, other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
SessionTicketHandler = Callable[[SessionTicket], None]
at: asyncio.events
get_event_loop() -> AbstractEventLoop
at: asyncio.events.AbstractEventLoop
getaddrinfo(host: Optional[str], port: Union[str, int, None], *, family: int=..., type: int=..., proto: int=..., flags: int=...) -> List[Tuple[AddressFamily, SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]
===========unchanged ref 1===========
create_datagram_endpoint(protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]]=..., remote_addr: Optional[Tuple[str, int]]=..., *, family: int=..., proto: int=..., flags: int=..., reuse_address: Optional[bool]=..., reuse_port: Optional[bool]=..., allow_broadcast: Optional[bool]=..., sock: Optional[socket]=...) -> _TransProtPair
at: contextlib
asynccontextmanager(func: Callable[..., AsyncIterator[_T]]) -> Callable[..., AsyncContextManager[_T]]
at: ipaddress
ip_address(address: object) -> Any
at: socket
SOCK_DGRAM: SocketKind
at: typing
cast(typ: Type[_T], val: Any) -> _T
cast(typ: str, val: Any) -> Any
cast(typ: object, val: Any) -> Any
List = _alias(list, 1, inst=False, name='List')
AsyncGenerator = _alias(collections.abc.AsyncGenerator, 2)
TextIO()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def wait_connected(self) -> None:
+ """
+ Wait for the TLS handshake to complete.
+ """
+ await self._connected.wait()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def connect(
- def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
+ Initiate the TLS handshake.
+
+ This method can only be called for clients and a single time.
- Initiate the TLS handshake and wait for it to complete.
"""
+ assert (
+ self.is_client and not self._connect_called
+ ), "connect() can only be called for clients and a single time"
+ self._connect_called = True
+
- assert self.is_client
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
self._version = max(self.supported_versions)
self._connect()
- await self.__connected.wait()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
self._push_crypto_data()
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
self._parameters_received = True
break
assert (
self._parameters_received
), "No QUIC transport parameters received"
self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
+ if not self._connected.is_set():
- if not self.__connected.is_set():
+ self._connected.set()
- self.__connected.set()
elif self.__epoch == tls.</s>
|
|
tests.test_connection/create_standalone_client
|
Modified
|
aiortc~aioquic
|
d357a34e2d0aeb3cc6d6c9115ec9ca9480b4995a
|
[connection] make connect() a plain method
|
<2>:<add>
<add> # kick-off handshake
<3>:<del>
<4>:<del> # like connect() but without waiting
<5>:<del> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
<6>:<del> client._version = max(client.supported_versions)
<7>:<add> client.connect(SERVER_ADDR)
<del> client._connect()
|
# module: tests.test_connection
def create_standalone_client():
<0> client = QuicConnection(is_client=True)
<1> client_transport = FakeTransport(CLIENT_ADDR, loss=0)
<2> client.connection_made(client_transport)
<3>
<4> # like connect() but without waiting
<5> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
<6> client._version = max(client.supported_versions)
<7> client._connect()
<8>
<9> return client, client_transport
<10>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, supported_versions: Optional[List[QuicProtocolVersion]]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connect(addr: NetworkAddress, protocol_version: Optional[int]=None) -> None
connection_made(transport: asyncio.BaseTransport) -> None
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
FakeTransport(local_addr, loss=0)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def connect(
- def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
+ Initiate the TLS handshake.
+
+ This method can only be called for clients and a single time.
- Initiate the TLS handshake and wait for it to complete.
"""
+ assert (
+ self.is_client and not self._connect_called
+ ), "connect() can only be called for clients and a single time"
+ self._connect_called = True
+
- assert self.is_client
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
self._version = max(self.supported_versions)
self._connect()
- await self.__connected.wait()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def wait_connected(self) -> None:
+ """
+ Wait for the TLS handshake to complete.
+ """
+ await self._connected.wait()
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
self._push_crypto_data()
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
self._parameters_received = True
break
assert (
self._parameters_received
), "No QUIC transport parameters received"
self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
+ if not self._connected.is_set():
- if not self.__connected.is_set():
+ self._connected.set()
- self.__connected.set()
elif self.__epoch == tls.</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
<s>_set():
+ self._connected.set()
- self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========changed ref 4===========
<s>manager
async def connect(
host: str,
port: int,
*,
alpn_protocols: Optional[List[str]] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
"""
Connect to a QUIC server at the given `host` and `port`.
:meth:`connect()` returns an awaitable. Awaiting it yields a
:class:`~aioquic.QuicConnection` which can be used to create streams.
:func:`connect` also accepts the following optional arguments:
* ``alpn_protocols`` is a list of ALPN protocols to offer in the
ClientHello.
* ``secrets_log_file`` is a file-like object in which to log traffic
secrets. This is useful to analyze traffic captures with Wireshark.
* ``session_ticket`` is a TLS session ticket which should be used for
resumption.
* ``session_ticket_handler`` is a callback which is invoked by the TLS
engine when a new session ticket is received.
* ``stream_handler`` is a callback which is invoked whenever a stream is
created. It must accept two arguments: a :class:`asyncio.StreamReader`
and a :class:`asyncio.StreamWriter`.
"""
loop = asyncio.get_event_loop()
# if host is not an IP address, pass it to enable SNI
try:
ipaddress.ip_address(host)
server_name = None
except ValueError:
server_name = host
# lookup remote address
infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
addr = infos[0][4]
if len(addr) == 2:
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
</s>
|
tests.test_connection/create_transport
|
Modified
|
aiortc~aioquic
|
d357a34e2d0aeb3cc6d6c9115ec9ca9480b4995a
|
[connection] make connect() a plain method
|
<6>:<add> # kick-off handshake
<8>:<del>
<9>:<del> # like connect() but without waiting
<10>:<del> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
<11>:<del> client._version = max(client.supported_versions)
<12>:<add> client.connect(SERVER_ADDR)
<del> client._connect()
|
# module: tests.test_connection
def create_transport(client, server, loss=0):
<0> client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
<1> client_transport.target = server
<2>
<3> server_transport = FakeTransport(SERVER_ADDR, loss=loss)
<4> server_transport.target = client
<5>
<6> server.connection_made(server_transport)
<7> client.connection_made(client_transport)
<8>
<9> # like connect() but without waiting
<10> client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
<11> client._version = max(client.supported_versions)
<12> client._connect()
<13>
<14> return client_transport, server_transport
<15>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
connect(addr: NetworkAddress, protocol_version: Optional[int]=None) -> None
connection_made(transport: asyncio.BaseTransport) -> None
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
FakeTransport(local_addr, loss=0)
at: tests.test_connection.FakeTransport
sent = 0
target = None
at: tests.test_connection.create_transport
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def connect(
- def connect(
self, addr: NetworkAddress, protocol_version: Optional[int] = None
) -> None:
"""
+ Initiate the TLS handshake.
+
+ This method can only be called for clients and a single time.
- Initiate the TLS handshake and wait for it to complete.
"""
+ assert (
+ self.is_client and not self._connect_called
+ ), "connect() can only be called for clients and a single time"
+ self._connect_called = True
+
- assert self.is_client
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
if protocol_version is not None:
self._version = protocol_version
else:
self._version = max(self.supported_versions)
self._connect()
- await self.__connected.wait()
===========changed ref 1===========
# module: tests.test_connection
def create_standalone_client():
client = QuicConnection(is_client=True)
client_transport = FakeTransport(CLIENT_ADDR, loss=0)
+
+ # kick-off handshake
client.connection_made(client_transport)
-
- # like connect() but without waiting
- client._network_paths = [QuicNetworkPath(SERVER_ADDR, is_validated=True)]
- client._version = max(client.supported_versions)
+ client.connect(SERVER_ADDR)
- client._connect()
return client, client_transport
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def wait_connected(self) -> None:
+ """
+ Wait for the TLS handshake to complete.
+ """
+ await self._connected.wait()
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
self._push_crypto_data()
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
self._parameters_received = True
break
assert (
self._parameters_received
), "No QUIC transport parameters received"
self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
+ if not self._connected.is_set():
- if not self.__connected.is_set():
+ self._connected.set()
- self.__connected.set()
elif self.__epoch == tls.</s>
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
<s>_set():
+ self._connected.set()
- self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========changed ref 5===========
<s>manager
async def connect(
host: str,
port: int,
*,
alpn_protocols: Optional[List[str]] = None,
protocol_version: Optional[int] = None,
secrets_log_file: Optional[TextIO] = None,
session_ticket: Optional[SessionTicket] = None,
session_ticket_handler: Optional[SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> AsyncGenerator[QuicConnection, None]:
"""
Connect to a QUIC server at the given `host` and `port`.
:meth:`connect()` returns an awaitable. Awaiting it yields a
:class:`~aioquic.QuicConnection` which can be used to create streams.
:func:`connect` also accepts the following optional arguments:
* ``alpn_protocols`` is a list of ALPN protocols to offer in the
ClientHello.
* ``secrets_log_file`` is a file-like object in which to log traffic
secrets. This is useful to analyze traffic captures with Wireshark.
* ``session_ticket`` is a TLS session ticket which should be used for
resumption.
* ``session_ticket_handler`` is a callback which is invoked by the TLS
engine when a new session ticket is received.
* ``stream_handler`` is a callback which is invoked whenever a stream is
created. It must accept two arguments: a :class:`asyncio.StreamReader`
and a :class:`asyncio.StreamWriter`.
"""
loop = asyncio.get_event_loop()
# if host is not an IP address, pass it to enable SNI
try:
ipaddress.ip_address(host)
server_name = None
except ValueError:
server_name = host
# lookup remote address
infos = await loop.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
addr = infos[0][4]
if len(addr) == 2:
addr = ("::ffff:" + addr[0], addr[1], 0, 0)
</s>
|
tests.test_connection/FakeTransport.__init__
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> self.loop = asyncio.get_event_loop()
|
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
<0> self.local_addr = local_addr
<1> self.loss = loss
<2>
|
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: asyncio.events
get_event_loop() -> AbstractEventLoop
|
tests.test_connection/FakeTransport.sendto
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<2>:<add> self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
<del> self.target.datagram_received(data, self.local_addr)
|
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
<0> self.sent += 1
<1> if self.target is not None and random.random() >= self.loss:
<2> self.target.datagram_received(data, self.local_addr)
<3>
|
===========unchanged ref 0===========
at: random
random = _inst.random
at: tests.test_connection.FakeTransport
sent = 0
target = None
at: tests.test_connection.FakeTransport.__init__
self.loss = loss
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
|
tests.test_connection/create_transport
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<10>:<add> run(asyncio.sleep(0))
|
# module: tests.test_connection
def create_transport(client, server, loss=0):
<0> client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
<1> client_transport.target = server
<2>
<3> server_transport = FakeTransport(SERVER_ADDR, loss=loss)
<4> server_transport.target = client
<5>
<6> # kick-off handshake
<7> server.connection_made(server_transport)
<8> client.connection_made(client_transport)
<9> client.connect(SERVER_ADDR)
<10>
<11> return client_transport, server_transport
<12>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connect(addr: NetworkAddress, protocol_version: Optional[int]=None) -> None
connection_made(transport: asyncio.BaseTransport) -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
CLIENT_ADDR = ("1.2.3.4", 1234)
SERVER_ADDR = ("2.3.4.5", 4433)
FakeTransport(local_addr, loss=0)
at: tests.test_connection.FakeTransport
target = None
at: tests.utils
run(coro)
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<22>:<add> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> async def serve_request(reader, writer):
<1> # check request
<2> request = await reader.read(1024)
<3> self.assertEqual(request, b"ping")
<4>
<5> # send response
<6> writer.write(b"pong")
<7> await asyncio.sleep(0)
<8>
<9> # receives EOF
<10> request = await reader.read()
<11> self.assertEqual(request, b"")
<12>
<13> with client_and_server(
<14> client_options={"supported_versions": client_versions},
<15> server_options={
<16> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<17> serve_request(reader, writer)
<18> ),
<19> "supported_versions": server_versions,
<20> },
<21> ) as (client, server):
<22> self.assertEqual(client._transport.sent, 4)
<23> self.assertEqual(server._transport.sent, 3)
<24>
<25> # check each endpoint has available connection IDs for the peer
<26> self.assertEqual(
<27> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<28> )
<29> self.assertEqual(
<30> sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<31> )
<32>
<33> # clients sends data over stream
<34> client_reader, client_writer = run(client.create_stream())
<35> client_writer.write(b"ping")
<36>
<37> # client receives pong
<38> self.assertEqual(run(client_reader.read(1024)), b"pong")
<39>
<40> # client writes EOF
<41> client_writer.write_eof()
<42> run(asyncio.sleep(0))
<43> self.assertEqual(client._transport.sent, 7)
<44> self.assertEqual(server._transport</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
===========unchanged ref 0===========
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
sequence_numbers(connection_ids)
at: tests.utils
run(coro)
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 2===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
|
tests.test_connection/QuicConnectionTest.test_connect_with_log
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<6>:<add> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
<0> client_log_file = io.StringIO()
<1> server_log_file = io.StringIO()
<2> with client_and_server(
<3> client_options={"secrets_log_file": client_log_file},
<4> server_options={"secrets_log_file": server_log_file},
<5> ) as (client, server):
<6> self.assertEqual(client._transport.sent, 4)
<7> self.assertEqual(server._transport.sent, 3)
<8>
<9> # check secrets were logged
<10> client_log = client_log_file.getvalue()
<11> server_log = server_log_file.getvalue()
<12> self.assertEqual(client_log, server_log)
<13> labels = []
<14> for line in client_log.splitlines():
<15> labels.append(line.split()[0])
<16> self.assertEqual(
<17> labels,
<18> [
<19> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<20> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
<21> "QUIC_SERVER_TRAFFIC_SECRET_0",
<22> "QUIC_CLIENT_TRAFFIC_SECRET_0",
<23> ],
<24> )
<25>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 2===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
async def serve_request(reader, writer):
# check request
request = await reader.read(1024)
self.assertEqual(request, b"ping")
# send response
writer.write(b"pong")
await asyncio.sleep(0)
# receives EOF
request = await reader.read()
self.assertEqual(request, b"")
with client_and_server(
client_options={"supported_versions": client_versions},
server_options={
"stream_handler": lambda reader, writer: asyncio.ensure_future(
serve_request(reader, writer)
),
"supported_versions": server_versions,
},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# clients sends data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 7)
self.assertEqual(server._transport.sent, 6)
|
tests.test_connection/QuicConnectionTest.test_connection_lost
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
<0> with client_and_server() as (client, server):
<1> self.assertEqual(client._transport.sent, 4)
<2> self.assertEqual(server._transport.sent, 3)
<3>
<4> # send data over stream
<5> client_reader, client_writer = run(client.create_stream())
<6> client_writer.write(b"ping")
<7> run(asyncio.sleep(0))
<8> self.assertEqual(client._transport.sent, 5)
<9> self.assertEqual(server._transport.sent, 4)
<10>
<11> # break connection
<12> client.connection_lost(None)
<13> self.assertEqual(run(client_reader.read()), b"")
<14>
|
===========unchanged ref 0===========
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 2===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
async def serve_request(reader, writer):
# check request
request = await reader.read(1024)
self.assertEqual(request, b"ping")
# send response
writer.write(b"pong")
await asyncio.sleep(0)
# receives EOF
request = await reader.read()
self.assertEqual(request, b"")
with client_and_server(
client_options={"supported_versions": client_versions},
server_options={
"stream_handler": lambda reader, writer: asyncio.ensure_future(
serve_request(reader, writer)
),
"supported_versions": server_versions,
},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# clients sends data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 7)
self.assertEqual(server._transport.sent, 6)
|
tests.test_connection/QuicConnectionTest.test_connection_lost_with_exception
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
<0> with client_and_server() as (client, server):
<1> self.assertEqual(client._transport.sent, 4)
<2> self.assertEqual(server._transport.sent, 3)
<3>
<4> # send data over stream
<5> client_reader, client_writer = run(client.create_stream())
<6> client_writer.write(b"ping")
<7> run(asyncio.sleep(0))
<8> self.assertEqual(client._transport.sent, 5)
<9> self.assertEqual(server._transport.sent, 4)
<10>
<11> # break connection
<12> exc = Exception("some error")
<13> client.connection_lost(exc)
<14> with self.assertRaises(Exception) as cm:
<15> run(client_reader.read())
<16> self.assertEqual(cm.exception, exc)
<17>
|
===========unchanged ref 0===========
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.test_connection.QuicConnectionTest.test_connection_lost
client_reader, client_writer = run(client.create_stream())
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 3===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
async def serve_request(reader, writer):
# check request
request = await reader.read(1024)
self.assertEqual(request, b"ping")
# send response
writer.write(b"pong")
await asyncio.sleep(0)
# receives EOF
request = await reader.read()
self.assertEqual(request, b"")
with client_and_server(
client_options={"supported_versions": client_versions},
server_options={
"stream_handler": lambda reader, writer: asyncio.ensure_future(
serve_request(reader, writer)
),
"supported_versions": server_versions,
},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# clients sends data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 7)
self.assertEqual(server._transport.sent, 6)
|
tests.test_connection/QuicConnectionTest.test_consume_connection_id
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(client.wait_connected())
<7>:<add> client._send_pending()
<12>:<add> run(asyncio.sleep(0))
<del> client._send_pending()
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
<0> with client_and_server() as (client, server):
<1> self.assertEqual(
<2> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<3> )
<4>
<5> # change connection ID
<6> client._consume_connection_id()
<7> self.assertEqual(
<8> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
<9> )
<10>
<11> # the server provides a new connection ID
<12> client._send_pending()
<13> self.assertEqual(
<14> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
<15> )
<16>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
sequence_numbers(connection_ids)
at: tests.test_connection.QuicConnectionTest.test_connection_lost_with_exception
client_reader, client_writer = run(client.create_stream())
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 3===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 4===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
async def serve_request(reader, writer):
# check request
request = await reader.read(1024)
self.assertEqual(request, b"ping")
# send response
writer.write(b"pong")
await asyncio.sleep(0)
# receives EOF
request = await reader.read()
self.assertEqual(request, b"")
with client_and_server(
client_options={"supported_versions": client_versions},
server_options={
"stream_handler": lambda reader, writer: asyncio.ensure_future(
serve_request(reader, writer)
),
"supported_versions": server_versions,
},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# clients sends data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 7)
self.assertEqual(server._transport.sent, 6)
|
tests.test_connection/QuicConnectionTest.test_create_stream_over_max_streams
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
<0> with client_and_server() as (client, server):
<1> self.assertEqual(client._transport.sent, 4)
<2> self.assertEqual(server._transport.sent, 3)
<3>
<4> # create streams
<5> for i in range(128):
<6> client_reader, client_writer = run(client.create_stream())
<7> self.assertEqual(client._transport.sent, 4)
<8> self.assertEqual(server._transport.sent, 3)
<9>
<10> # create one too many
<11> with self.assertRaises(ValueError) as cm:
<12> client_reader, client_writer = run(client.create_stream())
<13> self.assertEqual(str(cm.exception), "Too many streams open")
<14>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 3===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 4===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 5===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 7===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
async def serve_request(reader, writer):
# check request
request = await reader.read(1024)
self.assertEqual(request, b"ping")
# send response
writer.write(b"pong")
await asyncio.sleep(0)
# receives EOF
request = await reader.read()
self.assertEqual(request, b"")
with client_and_server(
client_options={"supported_versions": client_versions},
server_options={
"stream_handler": lambda reader, writer: asyncio.ensure_future(
serve_request(reader, writer)
),
"supported_versions": server_versions,
},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check each endpoint has available connection IDs for the peer
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
self.assertEqual(
sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# clients sends data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 7)
self.assertEqual(server._transport.sent, 6)
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
<0> with client_and_server() as (client, server):
<1> self.assertEqual(client._transport.sent, 4)
<2> self.assertEqual(server._transport.sent, 3)
<3>
<4> # mess with encryption key
<5> server.cryptos[tls.Epoch.ONE_RTT].send.setup(
<6> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<7> )
<8>
<9> # close
<10> server.close(error_code=QuicErrorCode.NO_ERROR)
<11> self.assertEqual(client._transport.sent, 4)
<12> self.assertEqual(server._transport.sent, 4)
<13>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 4===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 5===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 6===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 7===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
|
tests.test_connection/QuicConnectionTest.test_tls_error
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<11>:<add> run(asyncio.sleep(0))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
<0> def patch(client):
<1> real_initialize = client._initialize
<2>
<3> def patched_initialize(peer_cid: bytes):
<4> real_initialize(peer_cid)
<5> client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
<6>
<7> client._initialize = patched_initialize
<8>
<9> # handshake fails
<10> with client_and_server(client_patch=patch) as (client, server):
<11> self.assertEqual(client._transport.sent, 1)
<12> self.assertEqual(server._transport.sent, 1)
<13>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 4)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 5===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 6===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 7===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 8===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(server.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
<0> with client_and_server() as (client, server):
<1> server.close(
<2> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<3> )
<4>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
error_received(exc: Exception) -> None
at: tests.test_connection
create_standalone_client()
at: tests.test_connection.QuicConnectionTest.test_error_received
client = QuicConnection(is_client=True)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
def patch(client):
real_initialize = client._initialize
def patched_initialize(peer_cid: bytes):
real_initialize(peer_cid)
client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
client._initialize = patched_initialize
# handshake fails
with client_and_server(client_patch=patch) as (client, server):
+ run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 1)
self.assertEqual(server._transport.sent, 1)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 4)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 6===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 7===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 8===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
===========changed ref 9===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
server_log_file = io.StringIO()
with client_and_server(
client_options={"secrets_log_file": client_log_file},
server_options={"secrets_log_file": server_log_file},
) as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame_app
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(server.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
<0> with client_and_server() as (client, server):
<1> server.close(error_code=QuicErrorCode.NO_ERROR)
<2>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
at: tests.test_connection.QuicConnectionTest.test_handle_ack_frame_ecn
client, client_transport = create_standalone_client()
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
with client_and_server() as (client, server):
+ run(server.wait_connected())
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
def patch(client):
real_initialize = client._initialize
def patched_initialize(peer_cid: bytes):
real_initialize(peer_cid)
client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
client._initialize = patched_initialize
# handshake fails
with client_and_server(client_patch=patch) as (client, server):
+ run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 1)
self.assertEqual(server._transport.sent, 1)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 4)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 7===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
===========changed ref 8===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
self.sent += 1
if self.target is not None and random.random() >= self.loss:
+ self.loop.call_soon(self.target.datagram_received, data, self.local_addr)
- self.target.datagram_received(data, self.local_addr)
===========changed ref 9===========
# module: tests.test_connection
def create_transport(client, server, loss=0):
client_transport = FakeTransport(CLIENT_ADDR, loss=loss)
client_transport.target = server
server_transport = FakeTransport(SERVER_ADDR, loss=loss)
server_transport.target = client
# kick-off handshake
server.connection_made(server_transport)
client.connection_made(client_transport)
client.connect(SERVER_ADDR)
+ run(asyncio.sleep(0))
return client_transport, server_transport
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
<0> with client_and_server() as (client, server):
<1> self.assertEqual(
<2> sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
<3> )
<4>
<5> # client receives RETIRE_CONNECTION_ID
<6> client._handle_retire_connection_id_frame(
<7> client_receive_context(client),
<8> QuicFrameType.RETIRE_CONNECTION_ID,
<9> Buffer(data=b"\x02"),
<10> )
<11> self.assertEqual(
<12> sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
<13> )
<14>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
with client_and_server() as (client, server):
+ run(server.wait_connected())
server.close(error_code=QuicErrorCode.NO_ERROR)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
with client_and_server() as (client, server):
+ run(server.wait_connected())
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
def patch(client):
real_initialize = client._initialize
def patched_initialize(peer_cid: bytes):
real_initialize(peer_cid)
client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
client._initialize = patched_initialize
# handshake fails
with client_and_server(client_patch=patch) as (client, server):
+ run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 1)
self.assertEqual(server._transport.sent, 1)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 4)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 7===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 8===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame_current_cid
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<1>:<add> run(client.wait_connected())
<add> self.assertEqual(
<add> sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
<add> )
<add>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame_current_cid(self):
<0> with client_and_server() as (client, server):
<1> # client receives RETIRE_CONNECTION_ID for the current CID
<2> with self.assertRaises(QuicConnectionError) as cm:
<3> client._handle_retire_connection_id_frame(
<4> client_receive_context(client),
<5> QuicFrameType.RETIRE_CONNECTION_ID,
<6> Buffer(data=b"\x00"),
<7> )
<8> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<9> self.assertEqual(
<10> cm.exception.frame_type, QuicFrameType.RETIRE_CONNECTION_ID
<11> )
<12> self.assertEqual(
<13> cm.exception.reason_phrase, "Cannot retire current connection ID"
<14> )
<15> self.assertEqual(
<16> sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
<17> )
<18>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
sequence_numbers(connection_ids)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
)
# client receives RETIRE_CONNECTION_ID
client._handle_retire_connection_id_frame(
client_receive_context(client),
QuicFrameType.RETIRE_CONNECTION_ID,
Buffer(data=b"\x02"),
)
self.assertEqual(
sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
with client_and_server() as (client, server):
+ run(server.wait_connected())
server.close(error_code=QuicErrorCode.NO_ERROR)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
with client_and_server() as (client, server):
+ run(server.wait_connected())
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
def patch(client):
real_initialize = client._initialize
def patched_initialize(peer_cid: bytes):
real_initialize(peer_cid)
client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
client._initialize = patched_initialize
# handshake fails
with client_and_server(client_patch=patch) as (client, server):
+ run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 1)
self.assertEqual(server._transport.sent, 1)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 4)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
===========changed ref 7===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 8===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 5)
self.assertEqual(server._transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 9===========
# module: tests.test_connection
class FakeTransport:
def __init__(self, local_addr, loss=0):
self.local_addr = local_addr
+ self.loop = asyncio.get_event_loop()
self.loss = loss
|
tests.test_connection/QuicConnectionTest.test_with_packet_loss_during_app_data
|
Modified
|
aiortc~aioquic
|
103d8ab1e346c027e381c02901a5312725c14b41
|
[tests] make test transport asynchronous
|
<22>:<add> # complete handshake
<add> run(client.wait_connected())
<add>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_with_packet_loss_during_app_data(self):
<0> """
<1> This test ensures stream data is successfully sent and received
<2> in the presence of packet loss (randomized 25% in each direction).
<3>
<4> This tests *only* exercises loss in the 1-RTT epoch, no loss occurs
<5> during the handshake phase.
<6> """
<7> client_data = b"C" * 50000
<8> server_data = b"S" * 50000
<9>
<10> async def serve_request(reader, writer):
<11> self.assertEqual(await reader.read(), client_data)
<12> writer.write(server_data)
<13> writer.write_eof()
<14>
<15> with client_and_server(
<16> server_options={
<17> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<18> serve_request(reader, writer)
<19> )
<20> }
<21> ) as (client, server):
<22> # cause packet loss in both directions
<23> client._transport.loss = 0.25
<24> server._transport.loss = 0.25
<25>
<26> # create stream and send data
<27> client_reader, client_writer = run(client.create_stream())
<28> client_writer.write(client_data)
<29> client_writer.write_eof()
<30>
<31> # check response
<32> self.assertEqual(run(client_reader.read()), server_data)
<33>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
datagram_received(data: Union[bytes, Text], addr: NetworkAddress) -> None
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.host_cid = self._host_cids[0].cid
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
self.host_cid = context.host_cid
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
create_standalone_client()
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.test_connection.QuicConnectionTest.test_version_negotiation_fail
client, client_transport = create_standalone_client()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
)
# client receives RETIRE_CONNECTION_ID
client._handle_retire_connection_id_frame(
client_receive_context(client),
QuicFrameType.RETIRE_CONNECTION_ID,
Buffer(data=b"\x02"),
)
self.assertEqual(
sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
with client_and_server() as (client, server):
+ run(server.wait_connected())
server.close(error_code=QuicErrorCode.NO_ERROR)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
with client_and_server() as (client, server):
+ run(server.wait_connected())
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame_current_cid(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
+ self.assertEqual(
+ sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
+ )
+
# client receives RETIRE_CONNECTION_ID for the current CID
with self.assertRaises(QuicConnectionError) as cm:
client._handle_retire_connection_id_frame(
client_receive_context(client),
QuicFrameType.RETIRE_CONNECTION_ID,
Buffer(data=b"\x00"),
)
self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
self.assertEqual(
cm.exception.frame_type, QuicFrameType.RETIRE_CONNECTION_ID
)
self.assertEqual(
cm.exception.reason_phrase, "Cannot retire current connection ID"
)
self.assertEqual(
sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
def patch(client):
real_initialize = client._initialize
def patched_initialize(peer_cid: bytes):
real_initialize(peer_cid)
client.tls._supported_versions = [tls.TLS_VERSION_1_3_DRAFT_28]
client._initialize = patched_initialize
# handshake fails
with client_and_server(client_patch=patch) as (client, server):
+ run(asyncio.sleep(0))
self.assertEqual(client._transport.sent, 1)
self.assertEqual(server._transport.sent, 1)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 4)
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 7===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
with client_and_server() as (client, server):
+ run(client.wait_connected())
self.assertEqual(
sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
)
# change connection ID
client._consume_connection_id()
+ client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
)
# the server provides a new connection ID
+ run(asyncio.sleep(0))
- client._send_pending()
self.assertEqual(
sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
)
|
aioquic.connection/QuicConnection.close
|
Modified
|
aiortc~aioquic
|
7cca041e6cfe69ca282a52d275e27395cf07b7f5
|
[recovery] tighten discarding of packet spaces
|
<21>:<add> for epoch, space in self.spaces.items():
<add> self._discard_epoch(epoch)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
<0> """
<1> Close the connection.
<2> """
<3> if self.__state not in [
<4> QuicConnectionState.CLOSING,
<5> QuicConnectionState.DRAINING,
<6> ]:
<7> self.__close = {
<8> "error_code": error_code,
<9> "frame_type": frame_type,
<10> "reason_phrase": reason_phrase,
<11> }
<12> self._set_state(QuicConnectionState.CLOSING)
<13> self.connection_lost(
<14> maybe_connection_error(
<15> error_code=error_code,
<16> frame_type=frame_type,
<17> reason_phrase=reason_phrase,
<18> )
<19> )
<20> self._send_pending()
<21>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionState()
maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError]
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connection_lost(exc: Exception) -> None
_send_pending(self) -> None
_send_pending() -> None
_set_state(state: QuicConnectionState) -> None
at: aioquic.connection.QuicConnection.__init__
self.__close: Optional[Dict] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
at: aioquic.connection.QuicConnection._send_pending
self.__close = None
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def on_packet_expired(self, packet: QuicSentPacket) -> None:
+ self.bytes_in_flight -= packet.sent_bytes
+
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketSpace:
- def teardown(self) -> None:
- self.ack_eliciting_in_flight = 0
- self.crypto_packet_in_flight = 0
- self.loss_time = None
- self.sent_packets.clear()
-
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def discard_space(self, space: QuicPacketSpace) -> None:
+ assert space in self.spaces
+
+ for packet in space.sent_packets.values():
+ if packet.is_crypto_packet:
+ space.crypto_packet_in_flight -= 1
+ if packet.in_flight:
+ self.on_packet_expired(packet)
+ space.sent_packets.clear()
+
+ space.ack_eliciting_in_flight = 0
+ space.crypto_packet_in_flight = 0
+ space.loss_time = None
+
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
7cca041e6cfe69ca282a52d275e27395cf07b7f5
|
[recovery] tighten discarding of packet spaces
|
<36>:<del> self._logger.debug("Discarding handshake keys")
<37>:<add> self._discard_epoch(tls.Epoch.HANDSHAKE)
<del> self.cryptos[tls.Epoch.HANDSHAKE].teardown()
<38>:<del> self.spaces[tls.Epoch.HANDSHAKE].teardown()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self.__send_pending_task = None
<3> if self.__state == QuicConnectionState.DRAINING:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<11> peer_cid=self.peer_cid,
<12> peer_token=self.peer_token,
<13> spin_bit=self._spin_bit,
<14> version=self._version,
<15> )
<16>
<17> if self.__close:
<18> for epoch, packet_type in (
<19> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<20> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<21> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<22> ):
<23> crypto = self.cryptos[epoch]
<24> if crypto.send.is_valid():
<25> builder.start_packet(packet_type, crypto)
<26> write_close_frame(builder, **self.__close)
<27> builder.end_packet()
<28> self.__close = None
<29> break
<30> else:
<31> # check if we can discard handshake keys
<32> if (
<33> self._discard_handshake_at is not None
<34> and self._loop.time() > self._discard_handshake_at
<35> ):
<36> self._logger.debug("Discarding handshake keys")
<37> self.cryptos[tls.Epoch.HANDSHAKE].teardown()
<38> self.spaces[tls.Epoch.HANDSHAKE].teardown()
<39> self._discard_handshake_at = None
<40> self._discard_handshake_done = True
<41> if</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
# arm loss timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
seek(pos: int) -> None
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
at: aioquic.connection.QuicConnection
_discard_epoch(epoch: tls.Epoch) -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> None
_write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.peer_token = b""
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self.host_cid = self._host_cids[0].cid
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._spin_bit = False
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_ack_frame
self._discard_handshake_at = (
self._loop.time() + 3 * self._loss.get_probe_timeout()
)
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_soon
self.__send_pending_task = self._loop.call_soon(self._send_pending)
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
===========unchanged ref 2===========
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
7cca041e6cfe69ca282a52d275e27395cf07b7f5
|
[recovery] tighten discarding of packet spaces
|
<31>:<del> self._logger.debug("Discarding initial keys")
<32>:<add> self._discard_epoch(tls.Epoch.INITIAL)
<del> self.cryptos[tls.Epoch.INITIAL].teardown()
<33>:<del> self.spaces[tls.Epoch.INITIAL].teardown()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> if not crypto.send.is_valid():
<2> return
<3>
<4> buf = builder.buffer
<5> space = self.spaces[epoch]
<6>
<7> while (
<8> builder.flight_bytes + self._loss.bytes_in_flight
<9> < self._loss.congestion_window
<10> ):
<11> if epoch == tls.Epoch.INITIAL:
<12> packet_type = PACKET_TYPE_INITIAL
<13> else:
<14> packet_type = PACKET_TYPE_HANDSHAKE
<15> builder.start_packet(packet_type, crypto)
<16>
<17> # ACK
<18> if space.ack_required and space.ack_queue:
<19> builder.start_frame(QuicFrameType.ACK)
<20> push_ack_frame(buf, space.ack_queue, 0)
<21> space.ack_required = False
<22>
<23> # CRYPTO
<24> write_crypto_frame(builder=builder, space=space, stream=self.streams[epoch])
<25>
<26> if not builder.end_packet():
<27> break
<28>
<29> # discard initial keys and packet space
<30> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<31> self._logger.debug("Discarding initial keys")
<32> self.cryptos[tls.Epoch.INITIAL].teardown()
<33> self.spaces[tls.Epoch.INITIAL].teardown()
<34>
|
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
===========unchanged ref 1===========
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery.QuicPacketRecovery.__init__
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
at: aioquic.recovery.QuicPacketRecovery.on_packet_acked
self.bytes_in_flight -= packet.sent_bytes
self.congestion_window += (
K_MAX_DATAGRAM_SIZE * packet.sent_bytes // self.congestion_window
)
self.congestion_window += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_expired
self.bytes_in_flight -= packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self.bytes_in_flight += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.bytes_in_flight -= lost_bytes
self.congestion_window = max(
int(self.congestion_window * K_LOSS_REDUCTION_FACTOR), K_MINIMUM_WINDOW
)
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
===========unchanged ref 2===========
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self.__send_pending_task = None
if self.__state == QuicConnectionState.DRAINING:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self.cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self.__close)
builder.end_packet()
self.__close = None
break
else:
# check if we can discard handshake keys
if (
self._discard_handshake_at is not None
and self._loop.time() > self._discard_handshake_at
):
- self._logger.debug("Discarding handshake keys")
+ self._discard_epoch(tls.Epoch.HANDSHAKE)
- self.cryptos[tls.Epoch.HANDSHAKE].teardown()
- self.spaces[tls.Epoch.HANDSHAKE].teardown()
self._discard_handshake_at = None
self._discard_handshake_done = True
if not self._discard_handshake_done:
for epoch in [tls.Epoch.INITIAL,</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>shake_done = True
if not self._discard_handshake_done:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
# arm loss timer
self._set_loss_detection_timer()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _discard_epoch(self, epoch: tls.Epoch) -> None:
+ self._logger.debug("Discarding epoch %s", epoch)
+ self.cryptos[epoch].teardown()
+ self._loss.discard_space(self.spaces[epoch])
+
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def on_packet_expired(self, packet: QuicSentPacket) -> None:
+ self.bytes_in_flight -= packet.sent_bytes
+
===========changed ref 4===========
# module: aioquic.recovery
class QuicPacketSpace:
- def teardown(self) -> None:
- self.ack_eliciting_in_flight = 0
- self.crypto_packet_in_flight = 0
- self.loss_time = None
- self.sent_packets.clear()
-
|
aioquic.recovery/QuicPacketRecovery.discard_space
|
Modified
|
aiortc~aioquic
|
29d5a83e3b3ee9c60a93d2680b725253d2f25b7a
|
[recovery] add initial support for crypto retransmission
|
<3>:<del> if packet.is_crypto_packet:
<4>:<del> space.crypto_packet_in_flight -= 1
|
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
<0> assert space in self.spaces
<1>
<2> for packet in space.sent_packets.values():
<3> if packet.is_crypto_packet:
<4> space.crypto_packet_in_flight -= 1
<5> if packet.in_flight:
<6> self.on_packet_expired(packet)
<7> space.sent_packets.clear()
<8>
<9> space.ack_eliciting_in_flight = 0
<10> space.crypto_packet_in_flight = 0
<11> space.loss_time = None
<12>
|
===========unchanged ref 0===========
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery
on_packet_expired(packet: QuicSentPacket) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
|
aioquic.recovery/QuicPacketRecovery.get_loss_detection_time
|
Modified
|
aiortc~aioquic
|
29d5a83e3b3ee9c60a93d2680b725253d2f25b7a
|
[recovery] add initial support for crypto retransmission
|
<4>:<add>
<add> # crypto timer
<add> if sum(space.crypto_packet_in_flight for space in self.spaces):
<add> timeout = max(
<add> 2 * (self._rtt_smoothed if self._rtt_initialized else K_INITIAL_RTT),
<add> K_GRANULARITY,
<add> ) * (2 ** self._crypto_count)
<add> return self._time_of_last_sent_crypto_packet + timeout
|
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
<0> # loss timer
<1> loss_space = self.get_earliest_loss_time()
<2> if loss_space is not None:
<3> return loss_space.loss_time
<4>
<5> # packet timer
<6> if sum(space.ack_eliciting_in_flight for space in self.spaces):
<7> timeout = (
<8> self._rtt_smoothed
<9> + max(4 * self._rtt_variance, K_GRANULARITY)
<10> + self.max_ack_delay / 1000
<11> ) * (2 ** self._pto_count)
<12> return self._time_of_last_sent_ack_eliciting_packet + timeout
<13>
<14> return None
<15>
|
===========unchanged ref 0===========
at: aioquic.recovery
K_INITIAL_RTT = 0.5 # seconds
K_GRANULARITY = 0.001 # seconds
at: aioquic.recovery.QuicPacketRecovery
get_earliest_loss_time(self) -> Optional[QuicPacketSpace]
get_earliest_loss_time() -> Optional[QuicPacketSpace]
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
self._crypto_count = 0
self._rtt_initialized = False
self._rtt_smoothed = 0.0
self._time_of_last_sent_crypto_packet = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_initialized = True
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self._crypto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self._crypto_count += 1
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self._time_of_last_sent_crypto_packet = packet.sent_time
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.loss_time: Optional[float] = None
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
assert space in self.spaces
for packet in space.sent_packets.values():
- if packet.is_crypto_packet:
- space.crypto_packet_in_flight -= 1
if packet.in_flight:
self.on_packet_expired(packet)
space.sent_packets.clear()
space.ack_eliciting_in_flight = 0
space.crypto_packet_in_flight = 0
space.loss_time = None
|
aioquic.recovery/QuicPacketRecovery.on_loss_detection_timeout
|
Modified
|
aiortc~aioquic
|
29d5a83e3b3ee9c60a93d2680b725253d2f25b7a
|
[recovery] add initial support for crypto retransmission
|
<4>:<add> elif sum(space.crypto_packet_in_flight for space in self.spaces):
<add> # reschedule crypto packets
<add> for space in self.spaces:
<add> for packet_number, packet in list(
<add> filter(lambda i: i[1].is_crypto_packet, space.sent_packets.items())
<add> ):
<add> # remove packet and update counters
<add> del space.sent_packets[packet_number]
<add> space.ack_eliciting_in_flight -= 1
<add> space.crypto_packet_in_flight -= 1
<add> if packet.in_flight:
<add> self.bytes_in_flight -= packet.sent_bytes
<add>
<add> # trigger callbacks
<add> for handler, args in packet.delivery_handlers:
<add> handler(QuicDeliveryState.LOST, *args)
<add> self._crypto_count += 1
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_loss_detection_timeout(self) -> None:
<0> self._logger.info("Loss detection timeout triggered")
<1> loss_space = self.get_earliest_loss_time()
<2> if loss_space is not None:
<3> self.detect_loss(loss_space)
<4> else:
<5> self._pto_count += 1
<6> self._send_probe()
<7>
|
===========unchanged ref 0===========
at: aioquic.recovery.QuicPacketRecovery
detect_loss(space: QuicPacketSpace) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self._logger = logger
self._crypto_count = 0
self._pto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self._crypto_count += 1
self._pto_count += 1
at: logging.LoggerAdapter
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
__class_getitem__ = classmethod(GenericAlias)
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def discard_space(self, space: QuicPacketSpace) -> None:
assert space in self.spaces
for packet in space.sent_packets.values():
- if packet.is_crypto_packet:
- space.crypto_packet_in_flight -= 1
if packet.in_flight:
self.on_packet_expired(packet)
space.sent_packets.clear()
space.ack_eliciting_in_flight = 0
space.crypto_packet_in_flight = 0
space.loss_time = None
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketRecovery:
def get_loss_detection_time(self) -> float:
# loss timer
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
return loss_space.loss_time
+
+ # crypto timer
+ if sum(space.crypto_packet_in_flight for space in self.spaces):
+ timeout = max(
+ 2 * (self._rtt_smoothed if self._rtt_initialized else K_INITIAL_RTT),
+ K_GRANULARITY,
+ ) * (2 ** self._crypto_count)
+ return self._time_of_last_sent_crypto_packet + timeout
# packet timer
if sum(space.ack_eliciting_in_flight for space in self.spaces):
timeout = (
self._rtt_smoothed
+ max(4 * self._rtt_variance, K_GRANULARITY)
+ self.max_ack_delay / 1000
) * (2 ** self._pto_count)
return self._time_of_last_sent_ack_eliciting_packet + timeout
return None
|
aioquic.crypto/CryptoContext.decrypt_packet
|
Modified
|
aiortc~aioquic
|
df397b6e6168feb42d66e6ec1e00587ad31594a3
|
[connection] move discarding initial space
|
<0>:<add> if self.aead is None:
<add> raise CryptoError("Decryption key is not available")
<del> assert self.is_valid(), "Decryption key is not available"
|
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
<0> assert self.is_valid(), "Decryption key is not available"
<1>
<2> # header protection
<3> packet = bytearray(packet)
<4> sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
<5> sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
<6> mask = self.header_protection_mask(sample)
<7>
<8> if is_long_header(packet[0]):
<9> # long header
<10> packet[0] ^= mask[0] & 0x0F
<11> else:
<12> # short header
<13> packet[0] ^= mask[0] & 0x1F
<14>
<15> pn_length = (packet[0] & 0x03) + 1
<16> for i in range(pn_length):
<17> packet[encrypted_offset + i] ^= mask[1 + i]
<18> pn = packet[encrypted_offset : encrypted_offset + pn_length]
<19> plain_header = bytes(packet[: encrypted_offset + pn_length])
<20>
<21> # detect key phase change
<22> crypto = self
<23> if not is_long_header(packet[0]):
<24> key_phase = (packet[0] & 4) >> 2
<25> if key_phase != self.key_phase:
<26> crypto = self.next_key_phase()
<27>
<28> # payload protection
<29> nonce = crypto.iv[:-pn_length] + bytes(
<30> crypto.iv[i - pn_length] ^ pn[i] for i in range(pn_length)
<31> )
<32> try:
<33> payload = crypto.aead.decrypt(
<34> nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
<35> )
<36> except InvalidTag:
<37> raise CryptoError("Payload decryption failed")
<38>
<39> # packet number
<40> packet_number = 0</s>
|
===========below chunk 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
packet_number = (packet_number << 8) | pn[i]
packet_number = decode_packet_number(
packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
===========unchanged ref 0===========
at: aioquic.crypto
SAMPLE_SIZE = 16
CryptoError(*args: object)
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
next_key_phase() -> CryptoContext
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[Any]
self.iv: Optional[bytes]
self.key_phase = key_phase
at: aioquic.crypto.CryptoContext.apply_key_phase
self.aead = crypto.aead
self.iv = crypto.iv
self.key_phase = crypto.key_phase
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = AEAD(cipher_suite, key)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.iv = None
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
decode_packet_number(truncated: int, num_bits: int, expected: int) -> int
is_long_header(first_byte: int) -> bool
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
|
aioquic.connection/QuicConnection.close
|
Modified
|
aiortc~aioquic
|
df397b6e6168feb42d66e6ec1e00587ad31594a3
|
[connection] move discarding initial space
|
<21>:<add> for epoch in self.spaces.keys():
<del> for epoch, space in self.spaces.items():
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def close(
self,
error_code: int = QuicErrorCode.NO_ERROR,
frame_type: Optional[int] = None,
reason_phrase: str = "",
) -> None:
<0> """
<1> Close the connection.
<2> """
<3> if self.__state not in [
<4> QuicConnectionState.CLOSING,
<5> QuicConnectionState.DRAINING,
<6> ]:
<7> self.__close = {
<8> "error_code": error_code,
<9> "frame_type": frame_type,
<10> "reason_phrase": reason_phrase,
<11> }
<12> self._set_state(QuicConnectionState.CLOSING)
<13> self.connection_lost(
<14> maybe_connection_error(
<15> error_code=error_code,
<16> frame_type=frame_type,
<17> reason_phrase=reason_phrase,
<18> )
<19> )
<20> self._send_pending()
<21> for epoch, space in self.spaces.items():
<22> self._discard_epoch(epoch)
<23>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionState()
maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError]
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connection_lost(exc: Exception) -> None
_discard_epoch(epoch: tls.Epoch) -> None
_send_pending() -> None
_set_state(state: QuicConnectionState) -> None
at: aioquic.connection.QuicConnection.__init__
self.__close: Optional[Dict] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._send_pending
self.__close = None
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
+ if self.aead is None:
+ raise CryptoError("Decryption key is not available")
- assert self.is_valid(), "Decryption key is not available"
# header protection
packet = bytearray(packet)
sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
# detect key phase change
crypto = self
if not is_long_header(packet[0]):
key_phase = (packet[0] & 4) >> 2
if key_phase != self.key_phase:
crypto = self.next_key_phase()
# payload protection
nonce = crypto.iv[:-pn_length] + bytes(
crypto.iv[i - pn_length] ^ pn[i] for i in range(pn_length)
)
try:
payload = crypto.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_</s>
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
self, packet: bytes, encrypted_offset: int, expected_packet_number: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
<s> failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
packet_number = decode_packet_number(
packet_number, pn_length * 8, expected_packet_number
)
return plain_header, payload, packet_number, crypto != self
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
df397b6e6168feb42d66e6ec1e00587ad31594a3
|
[connection] move discarding initial space
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self.__send_pending_task = None
<3> if self.__state == QuicConnectionState.DRAINING:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<11> peer_cid=self.peer_cid,
<12> peer_token=self.peer_token,
<13> spin_bit=self._spin_bit,
<14> version=self._version,
<15> )
<16>
<17> if self.__close:
<18> for epoch, packet_type in (
<19> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<20> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<21> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<22> ):
<23> crypto = self.cryptos[epoch]
<24> if crypto.send.is_valid():
<25> builder.start_packet(packet_type, crypto)
<26> write_close_frame(builder, **self.__close)
<27> builder.end_packet()
<28> self.__close = None
<29> break
<30> else:
<31> # check if we can discard handshake keys
<32> if (
<33> self._discard_handshake_at is not None
<34> and self._loop.time() > self._discard_handshake_at
<35> ):
<36> self._discard_epoch(tls.Epoch.HANDSHAKE)
<37> self._discard_handshake_at = None
<38> self._discard_handshake_done = True
<39> if not self._discard_handshake_done:
<40> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<41> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
# arm loss timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
at: aioquic.connection.QuicConnection
_discard_epoch(epoch: tls.Epoch) -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> None
_write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.peer_token = b""
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._discard_handshake_at: Optional[float] = None
self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
self.host_cid = self._host_cids[0].cid
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._packet_number = 0
self._spin_bit = False
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._handle_ack_frame
self._discard_handshake_at = (
self._loop.time() + 3 * self._loss.get_probe_timeout()
)
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_pending
network_path = self._network_paths[0]
at: aioquic.connection.QuicConnection._send_soon
self.__send_pending_task = self._loop.call_soon(self._send_pending)
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
===========unchanged ref 2===========
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
===========unchanged ref 3===========
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery.QuicPacketRecovery
on_packet_sent(packet: QuicSentPacket, space: QuicPacketSpace) -> None
at: aioquic.tls
Epoch()
at: asyncio.events.AbstractEventLoop
time() -> float
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
|
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
df397b6e6168feb42d66e6ec1e00587ad31594a3
|
[connection] move discarding initial space
|
<29>:<del> # discard initial keys and packet space
<30>:<del> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<31>:<del> self._discard_epoch(tls.Epoch.INITIAL)
<32>:<del>
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> if not crypto.send.is_valid():
<2> return
<3>
<4> buf = builder.buffer
<5> space = self.spaces[epoch]
<6>
<7> while (
<8> builder.flight_bytes + self._loss.bytes_in_flight
<9> < self._loss.congestion_window
<10> ):
<11> if epoch == tls.Epoch.INITIAL:
<12> packet_type = PACKET_TYPE_INITIAL
<13> else:
<14> packet_type = PACKET_TYPE_HANDSHAKE
<15> builder.start_packet(packet_type, crypto)
<16>
<17> # ACK
<18> if space.ack_required and space.ack_queue:
<19> builder.start_frame(QuicFrameType.ACK)
<20> push_ack_frame(buf, space.ack_queue, 0)
<21> space.ack_required = False
<22>
<23> # CRYPTO
<24> write_crypto_frame(builder=builder, space=space, stream=self.streams[epoch])
<25>
<26> if not builder.end_packet():
<27> break
<28>
<29> # discard initial keys and packet space
<30> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<31> self._discard_epoch(tls.Epoch.INITIAL)
<32>
|
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery.QuicPacketRecovery.__init__
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self.bytes_in_flight -= packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_acked
self.bytes_in_flight -= packet.sent_bytes
self.congestion_window += (
K_MAX_DATAGRAM_SIZE * packet.sent_bytes // self.congestion_window
)
self.congestion_window += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_expired
self.bytes_in_flight -= packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self.bytes_in_flight += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.bytes_in_flight -= lost_bytes
self.congestion_window = max(
int(self.congestion_window * K_LOSS_REDUCTION_FACTOR), K_MINIMUM_WINDOW
)
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
self.__send_pending_task = None
if self.__state == QuicConnectionState.DRAINING:
return
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self._packet_number,
pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
if self.__close:
for epoch, packet_type in (
(tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
(tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
(tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
):
crypto = self.cryptos[epoch]
if crypto.send.is_valid():
builder.start_packet(packet_type, crypto)
write_close_frame(builder, **self.__close)
builder.end_packet()
self.__close = None
break
else:
# check if we can discard handshake keys
if (
self._discard_handshake_at is not None
and self._loop.time() > self._discard_handshake_at
):
self._discard_epoch(tls.Epoch.HANDSHAKE)
self._discard_handshake_at = None
self._discard_handshake_done = True
if not self._discard_handshake_done:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
self._write_handshake(builder, epoch)
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
+ sent</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
+ sent_handshake = False
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
+ if packet.epoch == tls.Epoch.HANDSHAKE:
+ sent_handshake = True
+
+ # discard initial keys and packet space
+ if sent_handshake and self.is_client:
+ self._discard_epoch(tls.Epoch.INITIAL)
# arm loss timer
self._set_loss_detection_timer()
|
tests.test_connection/QuicConnectionTest.test_with_packet_loss_during_handshake
|
Modified
|
aiortc~aioquic
|
e94acbda71214eac74f61e0d3a5944c87a03c37a
|
[tests] ensure client / server are connect before testing loss
|
<21>:<add> run(asyncio.gather(client.wait_connected(), server.wait_connected()))
<del> run(client.wait_connected())
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
@skip("not ready yet")
def test_with_packet_loss_during_handshake(self):
<0> """
<1> This test ensures handshake success and stream data is successfully sent
<2> and received in the presence of packet loss (randomized 25% in each direction).
<3> """
<4> client_data = b"C" * 50000
<5> server_data = b"S" * 50000
<6>
<7> async def serve_request(reader, writer):
<8> self.assertEqual(await reader.read(), client_data)
<9> writer.write(server_data)
<10> writer.write_eof()
<11>
<12> with client_and_server(
<13> server_options={
<14> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<15> serve_request(reader, writer)
<16> )
<17> },
<18> transport_options={"loss": 0.25},
<19> ) as (client, server):
<20> # complete handshake
<21> run(client.wait_connected())
<22>
<23> # create stream and send data
<24> client_reader, client_writer = run(client.create_stream())
<25> client_writer.write(client_data)
<26> client_writer.write_eof()
<27>
<28> # check response
<29> self.assertEqual(run(client_reader.read()), server_data)
<30>
|
===========unchanged ref 0===========
at: asyncio.tasks
ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
===========unchanged ref 1===========
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1,</s>
===========unchanged ref 2===========
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case
skip(reason: str) -> Callable[[_FT], _FT]
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
b9fb92eb59d380b85a08e556d3d1988a24d8c2d5
|
[tests] actually trigger decryption error
|
<14>:<add> run(asyncio.sleep(0))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
<0> with client_and_server() as (client, server):
<1> run(client.wait_connected())
<2> self.assertEqual(client._transport.sent, 4)
<3> self.assertEqual(server._transport.sent, 3)
<4>
<5> # mess with encryption key
<6> server.cryptos[tls.Epoch.ONE_RTT].send.setup(
<7> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<8> )
<9>
<10> # close
<11> server.close(error_code=QuicErrorCode.NO_ERROR)
<12> self.assertEqual(client._transport.sent, 4)
<13> self.assertEqual(server._transport.sent, 4)
<14>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
|
tests.test_connection/QuicConnectionTest.test_with_packet_loss_during_app_data
|
Modified
|
aiortc~aioquic
|
b9fb92eb59d380b85a08e556d3d1988a24d8c2d5
|
[tests] actually trigger decryption error
|
<7>:<add> client_data = b"C" * 100000
<del> client_data = b"C" * 50000
<8>:<add> server_data = b"S" * 100000
<del> server_data = b"S" * 50000
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_with_packet_loss_during_app_data(self):
<0> """
<1> This test ensures stream data is successfully sent and received
<2> in the presence of packet loss (randomized 25% in each direction).
<3>
<4> This tests *only* exercises loss in the 1-RTT epoch, no loss occurs
<5> during the handshake phase.
<6> """
<7> client_data = b"C" * 50000
<8> server_data = b"S" * 50000
<9>
<10> async def serve_request(reader, writer):
<11> self.assertEqual(await reader.read(), client_data)
<12> writer.write(server_data)
<13> writer.write_eof()
<14>
<15> with client_and_server(
<16> server_options={
<17> "stream_handler": lambda reader, writer: asyncio.ensure_future(
<18> serve_request(reader, writer)
<19> )
<20> }
<21> ) as (client, server):
<22> # complete handshake
<23> run(client.wait_connected())
<24>
<25> # cause packet loss in both directions
<26> client._transport.loss = 0.25
<27> server._transport.loss = 0.25
<28>
<29> # create stream and send data
<30> client_reader, client_writer = run(client.create_stream())
<31> client_writer.write(client_data)
<32> client_writer.write_eof()
<33>
<34> # check response
<35> self.assertEqual(run(client_reader.read()), server_data)
<36>
|
===========unchanged ref 0===========
at: asyncio.tasks
ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
client_and_server(client_options={}, client_patch=lambda x: None, server_options={}, server_patch=lambda x: None, transport_options={})
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
with client_and_server() as (client, server):
run(client.wait_connected())
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client._transport.sent, 4)
self.assertEqual(server._transport.sent, 4)
+ run(asyncio.sleep(0))
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
a3722b2d3ae7c8d86337fc31392b389d6f60f54f
|
[connection] correctly discard handshake keys and space
|
<30>:<del> self._discard_handshake_at: Optional[float] = None
<31>:<del> self._discard_hand
|
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19> if supported_versions is not None:
<20> self.supported_versions = supported_versions
<21>
<22> # counters for debugging
<23> self._stateless_retry_count = 0
<24> self._version_negotiation_count = 0
<25>
<26> self._loop = asyncio.get_event_loop()
<27> self.__close: Optional[Dict] = None
<28> self._connect_called = False
<29> self._connected = asyncio.Event()
<30> self._discard_handshake_at: Optional[float] = None
<31> self._discard_hand</s>
|
===========below chunk 0===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
</s>
===========below chunk 1===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
# callbacks
</s>
===========below chunk 2===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle</s>
===========below chunk 3===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O</s>
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
a3722b2d3ae7c8d86337fc31392b389d6f60f54f
|
[connection] correctly discard handshake keys and space
|
<15>:<add> # check if we can discard handshake keys
<add> if (
<add> not self._handshake_confirmed
<add> and self._handshake_complete
<del> # if all handshake data is acked, discard handshake space in 3 PTO
<16>:<add> and context.epoch == tls.Epoch.ONE_RTT
<del> if context.epoch == tls.Epoch.HANDSHAKE:
<17>:<del> space = self.spaces[context.epoch]
<18>:<del> stream = self.streams[context.epoch]
<19>:<del> if not space.ack_eliciting_in_flight and not stream._send_pending:
<20>:<del> self._discard_handshake_at = (
<21>:<del> self._loop.time() + 3 * self._loss.get_probe_timeout()
<22>:<del> )
<23>:<add> ):
<add> self._discard_epoch(tls.Epoch.HANDSHAKE)
<add> self._handshake_confirmed = True
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> ack_rangeset, ack_delay_encoded = pull_ack_frame(buf)
<4> if frame_type == QuicFrameType.ACK_ECN:
<5> pull_uint_var(buf)
<6> pull_uint_var(buf)
<7> pull_uint_var(buf)
<8>
<9> self._loss.on_ack_received(
<10> space=self.spaces[context.epoch],
<11> ack_rangeset=ack_rangeset,
<12> ack_delay_encoded=ack_delay_encoded,
<13> )
<14>
<15> # if all handshake data is acked, discard handshake space in 3 PTO
<16> if context.epoch == tls.Epoch.HANDSHAKE:
<17> space = self.spaces[context.epoch]
<18> stream = self.streams[context.epoch]
<19> if not space.ack_eliciting_in_flight and not stream._send_pending:
<20> self._discard_handshake_at = (
<21> self._loop.time() + 3 * self._loss.get_probe_timeout()
<22> )
<23>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_uint_var(buf: Buffer) -> int
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
_discard_epoch(epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self._handshake_complete = False
self._handshake_confirmed = False
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
at: aioquic.connection.QuicConnection._handle_crypto_frame
self._handshake_complete = True
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
at: aioquic.recovery.QuicPacketRecovery
on_ack_received(space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int) -> None
at: aioquic.tls
Epoch()
===========changed ref 0===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._connect_called = False
self._connected = asyncio.Event()
- self._discard_handshake_at: Optional[float] = None
- self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
+ self._handshake_complete = False
+ </s>
===========changed ref 1===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>shake_done = False
self.__epoch = tls.Epoch.INITIAL
+ self._handshake_complete = False
+ self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe</s>
===========changed ref 2===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._</s>
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
a3722b2d3ae7c8d86337fc31392b389d6f60f54f
|
[connection] correctly discard handshake keys and space
|
<38>:<add> self._handshake_complete = True
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a CRYPTO frame.
<2> """
<3> stream = self.streams[context.epoch]
<4> stream.add_frame(pull_crypto_frame(buf))
<5> data = stream.pull_data()
<6> if data:
<7> # pass data to TLS layer
<8> try:
<9> self.tls.handle_message(data, self.send_buffer)
<10> self._push_crypto_data()
<11> except tls.Alert as exc:
<12> raise QuicConnectionError(
<13> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<14> frame_type=QuicFrameType.CRYPTO,
<15> reason_phrase=str(exc),
<16> )
<17>
<18> # parse transport parameters
<19> if (
<20> not self._parameters_received
<21> and self.tls.received_extensions is not None
<22> ):
<23> for ext_type, ext_data in self.tls.received_extensions:
<24> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<25> self._parse_transport_parameters(ext_data)
<26> self._parameters_received = True
<27> break
<28> assert (
<29> self._parameters_received
<30> ), "No QUIC transport parameters received"
<31> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
<32>
<33> # update current epoch
<34> if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<35> tls.State.CLIENT_POST_HANDSHAKE,
<36> tls.State.SERVER_POST_HANDSHAKE,
<37> ]:
<38> self._replenish_connection_ids()
<39> self.__epoch = tls.Epoch.ONE_RTT
<40> # wakeup waiter
<41> if not self._connected.is_set</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
self._connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
_replenish_connection_ids() -> None
_push_crypto_data() -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self._handshake_complete = False
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
===========unchanged ref 1===========
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle an ACK frame.
"""
ack_rangeset, ack_delay_encoded = pull_ack_frame(buf)
if frame_type == QuicFrameType.ACK_ECN:
pull_uint_var(buf)
pull_uint_var(buf)
pull_uint_var(buf)
self._loss.on_ack_received(
space=self.spaces[context.epoch],
ack_rangeset=ack_rangeset,
ack_delay_encoded=ack_delay_encoded,
)
+ # check if we can discard handshake keys
+ if (
+ not self._handshake_confirmed
+ and self._handshake_complete
- # if all handshake data is acked, discard handshake space in 3 PTO
+ and context.epoch == tls.Epoch.ONE_RTT
- if context.epoch == tls.Epoch.HANDSHAKE:
- space = self.spaces[context.epoch]
- stream = self.streams[context.epoch]
- if not space.ack_eliciting_in_flight and not stream._send_pending:
- self._discard_handshake_at = (
- self._loop.time() + 3 * self._loss.get_probe_timeout()
- )
+ ):
+ self._discard_epoch(tls.Epoch.HANDSHAKE)
+ self._handshake_confirmed = True
===========changed ref 1===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._connect_called = False
self._connected = asyncio.Event()
- self._discard_handshake_at: Optional[float] = None
- self._discard_handshake_done = False
self.__epoch = tls.Epoch.INITIAL
+ self._handshake_complete = False
+ </s>
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
a3722b2d3ae7c8d86337fc31392b389d6f60f54f
|
[connection] correctly discard handshake keys and space
|
<31>:<del> # check if we can discard handshake keys
<32>:<del> if (
<33>:<del> self._discard_handshake_at is not None
<34>:<del> and self._loop.time() > self._discard_handshake_at
<35>:<del> ):
<36>:<del> self._discard_epoch(tls.Epoch.HANDSHAKE)
<37>:<del> self._discard_handshake_at = None
<38>:<del> self._discard_handshake_done = True
<39>:<add> if not self._handshake_confirmed:
<del> if not self._discard_handshake_done:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self.__send_pending_task = None
<3> if self.__state == QuicConnectionState.DRAINING:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<11> peer_cid=self.peer_cid,
<12> peer_token=self.peer_token,
<13> spin_bit=self._spin_bit,
<14> version=self._version,
<15> )
<16>
<17> if self.__close:
<18> for epoch, packet_type in (
<19> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<20> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<21> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<22> ):
<23> crypto = self.cryptos[epoch]
<24> if crypto.send.is_valid():
<25> builder.start_packet(packet_type, crypto)
<26> write_close_frame(builder, **self.__close)
<27> builder.end_packet()
<28> self.__close = None
<29> break
<30> else:
<31> # check if we can discard handshake keys
<32> if (
<33> self._discard_handshake_at is not None
<34> and self._loop.time() > self._discard_handshake_at
<35> ):
<36> self._discard_epoch(tls.Epoch.HANDSHAKE)
<37> self._discard_handshake_at = None
<38> self._discard_handshake_done = True
<39> if not self._discard_handshake_done:
<40> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<41> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
self._write_application(builder, network_path)
datagrams, packets = builder.flush()
sent_handshake = False
if datagrams:
self._packet_number = builder.packet_number
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# discard initial keys and packet space
if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm loss timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
at: aioquic.connection.QuicConnection
_discard_epoch(epoch: tls.Epoch) -> None
_set_loss_detection_timer() -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.peer_token = b""
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
self._handshake_confirmed = False
self.host_cid = self._host_cids[0].cid
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._network_paths: List[QuicNetworkPath] = []
self._packet_number = 0
self._spin_bit = False
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
self._probe_pending = False
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_ack_frame
self._handshake_confirmed = True
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
===========unchanged ref 2===========
self.host_cid = context.host_cid
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.tls
Epoch()
at: asyncio.transports.DatagramTransport
__slots__ = ()
===========unchanged ref 3===========
sendto(data: Any, addr: Optional[_Address]=...) -> None
|
tests.test_high_level/run_client
|
Modified
|
aiortc~aioquic
|
03d5e774ff13500da5a81eded023ebb3f831505c
|
[tests] add test for a large enough transfer to raise data limits
|
<3>:<add> writer.write(request)
<del> writer.write(b"ping")
|
# module: tests.test_high_level
+ def run_client(host, request=b"ping", **kwargs):
- def run_client(host, **kwargs):
<0> async with connect(host, 4433, **kwargs) as client:
<1> reader, writer = await client.create_stream()
<2>
<3> writer.write(b"ping")
<4> writer.write_eof()
<5>
<6> return await reader.read()
<7>
|
===========unchanged ref 0===========
at: aioquic.client
connect(host: str, port: int, *, alpn_protocols: Optional[List[str]]=None, protocol_version: Optional[int]=None, secrets_log_file: Optional[TextIO]=None, session_ticket: Optional[SessionTicket]=None, session_ticket_handler: Optional[SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None) -> AsyncGenerator[QuicConnection, None]
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
write_eof() -> None
|
tests.test_high_level/HighLevelTest.test_connect_and_serve
|
Modified
|
aiortc~aioquic
|
03d5e774ff13500da5a81eded023ebb3f831505c
|
[tests] add test for a large enough transfer to raise data limits
|
<0>:<del> _, response = run(
<1>:<add> _, response = run(asyncio.gather(run_server(), run_client("127.0.0.1")))
<del> asyncio.gather(run_server(stateless_retry=False), run_client("127.0.0.1"))
<2>:<del> )
|
# module: tests.test_high_level
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
<0> _, response = run(
<1> asyncio.gather(run_server(stateless_retry=False), run_client("127.0.0.1"))
<2> )
<3> self.assertEqual(response, b"gnip")
<4>
|
===========unchanged ref 0===========
at: asyncio.tasks
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[</s>
===========unchanged ref 1===========
at: tests.test_high_level
run_client(host, request=b"ping", *, alpn_protocols: Optional[List[str]]=None, secrets_log_file: Optional[TextIO]=None, stream_handler: Optional[QuicStreamHandler]=None)
run_server(*, alpn_protocols: Optional[List[str]]=None, connection_handler: QuicConnectionHandler=None, secrets_log_file: Optional[TextIO]=None)
at: tests.utils
run(coro)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_high_level
+ def run_client(host, request=b"ping", **kwargs):
- def run_client(host, **kwargs):
async with connect(host, 4433, **kwargs) as client:
reader, writer = await client.create_stream()
+ writer.write(request)
- writer.write(b"ping")
writer.write_eof()
return await reader.read()
|
tests.test_high_level/HighLevelTest.test_connect_and_serve_with_sni
|
Modified
|
aiortc~aioquic
|
03d5e774ff13500da5a81eded023ebb3f831505c
|
[tests] add test for a large enough transfer to raise data limits
|
<0>:<del> _, response = run(
<1>:<add> _, response = run(asyncio.gather(run_server(), run_client("localhost")))
<del> asyncio.gather(run_server(stateless_retry=False), run_client("localhost"))
<2>:<del> )
|
# module: tests.test_high_level
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
<0> _, response = run(
<1> asyncio.gather(run_server(stateless_retry=False), run_client("localhost"))
<2> )
<3> self.assertEqual(response, b"gnip")
<4>
|
===========unchanged ref 0===========
at: asyncio.tasks
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[</s>
===========unchanged ref 1===========
at: tests.test_high_level
run_client(host, request=b"ping", *, alpn_protocols: Optional[List[str]]=None, secrets_log_file: Optional[TextIO]=None, stream_handler: Optional[QuicStreamHandler]=None)
run_server(*, alpn_protocols: Optional[List[str]]=None, connection_handler: QuicConnectionHandler=None, secrets_log_file: Optional[TextIO]=None)
at: tests.test_high_level.HighLevelTest.test_connect_and_serve_with_session_ticket
client_ticket = None
store = SessionTicketStore()
at: tests.test_high_level.SessionTicketStore
pop(label)
at: tests.utils
run(coro)
===========changed ref 0===========
# module: tests.test_high_level
+ def run_client(host, request=b"ping", **kwargs):
- def run_client(host, **kwargs):
async with connect(host, 4433, **kwargs) as client:
reader, writer = await client.create_stream()
+ writer.write(request)
- writer.write(b"ping")
writer.write_eof()
return await reader.read()
===========changed ref 1===========
# module: tests.test_high_level
class HighLevelTest(TestCase):
+ def test_connect_and_serve_large(self):
+ """
+ Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
+ """
+ data = b"Z" * 2097152
+ _, response = run(
+ asyncio.gather(run_server(), run_client("127.0.0.1", request=data))
+ )
+ self.assertEqual(response, data)
+
===========changed ref 2===========
# module: tests.test_high_level
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- _, response = run(
+ _, response = run(asyncio.gather(run_server(), run_client("127.0.0.1")))
- asyncio.gather(run_server(stateless_retry=False), run_client("127.0.0.1"))
- )
self.assertEqual(response, b"gnip")
|
tests.test_high_level/HighLevelTest.test_connect_and_serve_with_version_negotiation
|
Modified
|
aiortc~aioquic
|
03d5e774ff13500da5a81eded023ebb3f831505c
|
[tests] add test for a large enough transfer to raise data limits
|
<2>:<del> run_server(stateless_retry=False),
<3>:<add> run_server(), run_client("127.0.0.1", protocol_version=0x1A2A3A4A)
<del> run_client("127.0.0.1", protocol_version=0x1A2A3A4A),
|
# module: tests.test_high_level
class HighLevelTest(TestCase):
def test_connect_and_serve_with_version_negotiation(self):
<0> _, response = run(
<1> asyncio.gather(
<2> run_server(stateless_retry=False),
<3> run_client("127.0.0.1", protocol_version=0x1A2A3A4A),
<4> )
<5> )
<6> self.assertEqual(response, b"gnip")
<7>
|
===========unchanged ref 0===========
at: asyncio.tasks
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[</s>
===========unchanged ref 1===========
at: tests.test_high_level
run_client(host, request=b"ping", *, alpn_protocols: Optional[List[str]]=None, secrets_log_file: Optional[TextIO]=None, stream_handler: Optional[QuicStreamHandler]=None)
run_server(*, alpn_protocols: Optional[List[str]]=None, connection_handler: QuicConnectionHandler=None, secrets_log_file: Optional[TextIO]=None)
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_high_level
+ def run_client(host, request=b"ping", **kwargs):
- def run_client(host, **kwargs):
async with connect(host, 4433, **kwargs) as client:
reader, writer = await client.create_stream()
+ writer.write(request)
- writer.write(b"ping")
writer.write_eof()
return await reader.read()
===========changed ref 1===========
# module: tests.test_high_level
class HighLevelTest(TestCase):
def test_connect_and_serve_with_sni(self):
- _, response = run(
+ _, response = run(asyncio.gather(run_server(), run_client("localhost")))
- asyncio.gather(run_server(stateless_retry=False), run_client("localhost"))
- )
self.assertEqual(response, b"gnip")
===========changed ref 2===========
# module: tests.test_high_level
class HighLevelTest(TestCase):
+ def test_connect_and_serve_large(self):
+ """
+ Transfer enough data to require raising MAX_DATA and MAX_STREAM_DATA.
+ """
+ data = b"Z" * 2097152
+ _, response = run(
+ asyncio.gather(run_server(), run_client("127.0.0.1", request=data))
+ )
+ self.assertEqual(response, data)
+
===========changed ref 3===========
# module: tests.test_high_level
class HighLevelTest(TestCase):
def test_connect_and_serve(self):
- _, response = run(
+ _, response = run(asyncio.gather(run_server(), run_client("127.0.0.1")))
- asyncio.gather(run_server(stateless_retry=False), run_client("127.0.0.1"))
- )
self.assertEqual(response, b"gnip")
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
7efb74ac8b63c6fadd387c8dc4de87c6ebed3a59
|
[connection] get rid of self.__epoch
|
<30>:<del> self.__epoch = tls.Epoch.INITIAL
|
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19> if supported_versions is not None:
<20> self.supported_versions = supported_versions
<21>
<22> # counters for debugging
<23> self._stateless_retry_count = 0
<24> self._version_negotiation_count = 0
<25>
<26> self._loop = asyncio.get_event_loop()
<27> self.__close: Optional[Dict] = None
<28> self._connect_called = False
<29> self._connected = asyncio.Event()
<30> self.__epoch = tls.Epoch.INITIAL
<31> self._handshake_complete = False
<32> </s>
|
===========below chunk 0===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._</s>
===========below chunk 1===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s> = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
# callbacks
self._connection_id_issued_handler:</s>
===========below chunk 2===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>ConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO</s>
===========below chunk 3===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_</s>
|
aioquic.connection/QuicConnection.ping
|
Modified
|
aiortc~aioquic
|
7efb74ac8b63c6fadd387c8dc4de87c6ebed3a59
|
[connection] get rid of self.__epoch
|
<3>:<add> assert self._ping_waiter is None, "already await a ping"
<del> assert self._ping_waiter is None
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def ping(self) -> None:
<0> """
<1> Pings the remote host and waits for the response.
<2> """
<3> assert self._ping_waiter is None
<4> self._ping_pending = True
<5> self._ping_waiter = self._loop.create_future()
<6> self._send_soon()
<7> await asyncio.shield(self._ping_waiter)
<8>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_send_soon() -> None
at: aioquic.connection.QuicConnection.__init__
self._loop = asyncio.get_event_loop()
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._ping_pending = False
at: aioquic.connection.QuicConnection._on_ping_delivery
self._ping_waiter = None
self._ping_pending = True
at: aioquic.connection.QuicConnection._write_application
self._ping_pending = False
at: asyncio.events.AbstractEventLoop
create_future() -> Future[Any]
at: asyncio.tasks
shield(arg: _FutureT[_T], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
===========changed ref 0===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._connect_called = False
self._connected = asyncio.Event()
- self.__epoch = tls.Epoch.INITIAL
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.ur</s>
===========changed ref 1===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network</s>
===========changed ref 2===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
# callbacks
self._connection</s>
|
aioquic.connection/QuicConnection.request_key_update
|
Modified
|
aiortc~aioquic
|
7efb74ac8b63c6fadd387c8dc4de87c6ebed3a59
|
[connection] get rid of self.__epoch
|
<3>:<add> assert self._handshake_complete, "cannot change key before handshake completes"
<del> if self.__epoch == tls.Epoch.ONE_RTT:
<4>:<add> self.cryptos[tls.Epoch.ONE_RTT].update_key()
<del> self.cryptos[tls.Epoch.ONE_RTT].update_key()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def request_key_update(self) -> None:
<0> """
<1> Request an update of the encryption keys.
<2> """
<3> if self.__epoch == tls.Epoch.ONE_RTT:
<4> self.cryptos[tls.Epoch.ONE_RTT].update_key()
<5>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self._handshake_complete = False
at: aioquic.connection.QuicConnection._handle_crypto_frame
self._handshake_complete = True
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
at: aioquic.crypto.CryptoPair
update_key() -> None
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def ping(self) -> None:
"""
Pings the remote host and waits for the response.
"""
+ assert self._ping_waiter is None, "already await a ping"
- assert self._ping_waiter is None
self._ping_pending = True
self._ping_waiter = self._loop.create_future()
self._send_soon()
await asyncio.shield(self._ping_waiter)
===========changed ref 1===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._connect_called = False
self._connected = asyncio.Event()
- self.__epoch = tls.Epoch.INITIAL
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.ur</s>
===========changed ref 2===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = MAX_DATA_WINDOW
self._local_max_stream_data_bidi_remote = MAX_DATA_WINDOW
self._local_max_stream_data_uni = MAX_DATA_WINDOW
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._network</s>
===========changed ref 3===========
<s>,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._packet_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
# callbacks
self._connection</s>
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
7efb74ac8b63c6fadd387c8dc4de87c6ebed3a59
|
[connection] get rid of self.__epoch
|
<34>:<add> if not self._handshake_complete and self.tls.state in [
<del> if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<40>:<del> self.__epoch = tls.Epoch.ONE_RTT
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a CRYPTO frame.
<2> """
<3> stream = self.streams[context.epoch]
<4> stream.add_frame(pull_crypto_frame(buf))
<5> data = stream.pull_data()
<6> if data:
<7> # pass data to TLS layer
<8> try:
<9> self.tls.handle_message(data, self.send_buffer)
<10> self._push_crypto_data()
<11> except tls.Alert as exc:
<12> raise QuicConnectionError(
<13> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<14> frame_type=QuicFrameType.CRYPTO,
<15> reason_phrase=str(exc),
<16> )
<17>
<18> # parse transport parameters
<19> if (
<20> not self._parameters_received
<21> and self.tls.received_extensions is not None
<22> ):
<23> for ext_type, ext_data in self.tls.received_extensions:
<24> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<25> self._parse_transport_parameters(ext_data)
<26> self._parameters_received = True
<27> break
<28> assert (
<29> self._parameters_received
<30> ), "No QUIC transport parameters received"
<31> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
<32>
<33> # update current epoch
<34> if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<35> tls.State.CLIENT_POST_HANDSHAKE,
<36> tls.State.SERVER_POST_HANDSHAKE,
<37> ]:
<38> self._handshake_complete = True
<39> self._replenish_connection_ids()
<40> self.__epoch = tls.Epoch.ONE_RTT
<41> # wakeup waiter
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
self._connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
_replenish_connection_ids() -> None
_push_crypto_data() -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._connected = asyncio.Event()
self._handshake_complete = False
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========unchanged ref 1===========
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
State()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def request_key_update(self) -> None:
"""
Request an update of the encryption keys.
"""
+ assert self._handshake_complete, "cannot change key before handshake completes"
- if self.__epoch == tls.Epoch.ONE_RTT:
+ self.cryptos[tls.Epoch.ONE_RTT].update_key()
- self.cryptos[tls.Epoch.ONE_RTT].update_key()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def ping(self) -> None:
"""
Pings the remote host and waits for the response.
"""
+ assert self._ping_waiter is None, "already await a ping"
- assert self._ping_waiter is None
self._ping_pending = True
self._ping_waiter = self._loop.create_future()
self._send_soon()
await asyncio.shield(self._ping_waiter)
===========changed ref 2===========
<s>[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
supported_versions: Optional[List[QuicProtocolVersion]] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.peer_cid = os.urandom(8)
self._peer_cid_seq: Optional[int] = None
self._peer_cid_available: List[QuicConnectionId] = []
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
if supported_versions is not None:
self.supported_versions = supported_versions
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self._connect_called = False
self._connected = asyncio.Event()
- self.__epoch = tls.Epoch.INITIAL
self._handshake_complete = False
self._handshake_confirmed = False
self._host_cids = [
QuicConnectionId(
cid=os.ur</s>
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
7efb74ac8b63c6fadd387c8dc4de87c6ebed3a59
|
[connection] get rid of self.__epoch
|
<10>:<add> pad_first_datagram=(
<add> self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT
<add> ),
<del> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<16>:<del>
<34>:<del>
<37>:<del> sent_handshake = False
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> self.__send_pending_task = None
<3> if self.__state == QuicConnectionState.DRAINING:
<4> return
<5>
<6> # build datagrams
<7> builder = QuicPacketBuilder(
<8> host_cid=self.host_cid,
<9> packet_number=self._packet_number,
<10> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<11> peer_cid=self.peer_cid,
<12> peer_token=self.peer_token,
<13> spin_bit=self._spin_bit,
<14> version=self._version,
<15> )
<16>
<17> if self.__close:
<18> for epoch, packet_type in (
<19> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<20> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<21> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<22> ):
<23> crypto = self.cryptos[epoch]
<24> if crypto.send.is_valid():
<25> builder.start_packet(packet_type, crypto)
<26> write_close_frame(builder, **self.__close)
<27> builder.end_packet()
<28> self.__close = None
<29> break
<30> else:
<31> if not self._handshake_confirmed:
<32> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<33> self._write_handshake(builder, epoch)
<34>
<35> self._write_application(builder, network_path)
<36> datagrams, packets = builder.flush()
<37> sent_handshake = False
<38>
<39> if datagrams:
<40> self._packet_number = builder.packet_number
<41>
<42> # send datagrams
<43> for datagram in datagrams:
<44> self</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
network_path.bytes_sent += len(datagram)
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
if packet.epoch == tls.Epoch.HANDSHAKE:
sent_handshake = True
# check if we can discard initial keys
if sent_handshake and self.is_client:
self._discard_epoch(tls.Epoch.INITIAL)
# arm loss timer
self._set_loss_detection_timer()
===========unchanged ref 0===========
at: aioquic.connection
write_close_frame(builder: QuicPacketBuilder, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicConnectionState()
at: aioquic.connection.QuicConnection
_discard_epoch(epoch: tls.Epoch) -> None
_set_loss_detection_timer() -> None
_write_application(builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> None
_write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
_write_handshake(builder: QuicPacketBuilder, epoch: tls.Epoch) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.peer_token = b""
self.__close: Optional[Dict] = None
self._handshake_confirmed = False
self.host_cid = self._host_cids[0].cid
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._packet_number = 0
self._spin_bit = False
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
self._probe_pending = False
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_ack_frame
self._handshake_confirmed = True
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self._packet_number = 0
at: aioquic.connection.QuicConnection._send_pending
network_path = self._network_paths[0]
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: aioquic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
===========unchanged ref 2===========
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, pad_first_datagram: bool=False, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.tls
Epoch()
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
7efb74ac8b63c6fadd387c8dc4de87c6ebed3a59
|
[connection] get rid of self.__epoch
|
<11>:<del> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<22>:<add> if self._handshake_complete:
<del> if is_one_rtt:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> crypto_stream_id: Optional[tls.Epoch] = None
<1> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<2> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<3> crypto_stream_id = tls.Epoch.ONE_RTT
<4> packet_type = PACKET_TYPE_ONE_RTT
<5> elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<6> crypto = self.cryptos[tls.Epoch.ZERO_RTT]
<7> packet_type = PACKET_TYPE_ZERO_RTT
<8> else:
<9> return
<10> space = self.spaces[tls.Epoch.ONE_RTT]
<11> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<12>
<13> buf = builder.buffer
<14>
<15> while (
<16> builder.flight_bytes + self._loss.bytes_in_flight
<17> < self._loss.congestion_window
<18> ) or self._probe_pending:
<19> # write header
<20> builder.start_packet(packet_type, crypto)
<21>
<22> if is_one_rtt:
<23> # ACK
<24> if space.ack_required and space.ack_queue:
<25> builder.start_frame(QuicFrameType.ACK)
<26> push_ack_frame(buf, space.ack_queue, 0)
<27> space.ack_required = False
<28>
<29> # PATH CHALLENGE
<30> if (
<31> not network_path.is_validated
<32> and network_path.local_challenge is None
<33> ):
<34> self._logger.info(
<35> "Network path %s sending challenge", network_path.addr
<36> )
<37> network_path.local_challenge = os.urandom(8)
<38> builder</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
push_bytes(buf, network_path.local_challenge)
# PATH RESPONSE
if network_path.remote_challenge is not None:
builder.start_frame(QuicFrameType.PATH_RESPONSE)
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
builder.start_frame(
QuicFrameType.NEW_CONNECTION_ID,
self._on_new_connection_id_delivery,
(connection_id,),
)
push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
self._connection_id_issued_handler(connection_id.cid)
# RETIRE_CONNECTION_ID
while self._retire_connection_ids:
sequence_number = self._retire_connection_ids.pop(0)
builder.start_frame(
QuicFrameType.RETIRE_CONNECTION_ID,
self._on_retire_connection_id_delivery,
(sequence_number,),
)
push_uint_var(buf, sequence_number)
# connection-level limits
self._write_connection_limits(builder=builder, space=space)
# stream-level limits
for stream_id, stream in self.streams.items():
if isinstance(stream_id, int):
self._write_stream_limits(
builder=builder, space=space, stream=stream
)
# PING (user-request)
if self._ping_pending:</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s> space=space, stream=stream
)
# PING (user-request)
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
builder.start_frame(QuicFrameType.PING, self._on_ping_delivery)
self._ping_pending = False
# PING (probe)
if self._probe_pending:
self._logger.info("Sending probe")
builder.start_frame(QuicFrameType.PING)
self._probe_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == crypto_stream_id:
write_crypto_frame(builder=builder, space=space, stream=stream)
# STREAM
elif isinstance(stream_id, int):
self._remote_max_data_used += write_stream_frame(
builder=builder,
space=space,
stream=stream,
max_offset=min(
stream._send_highest
+ self._remote_max_data
- self._remote_max_data_used,
stream.max_stream_data_remote,
),
)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
write_stream_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream, max_offset: int) -> int
at: aioquic.connection.QuicConnection
_on_new_connection_id_delivery(delivery: QuicDeliveryState, connection_id: QuicConnectionId) -> None
_on_ping_delivery(delivery: QuicDeliveryState) -> None
_on_retire_connection_id_delivery(delivery: QuicDeliveryState, sequence_number: int) -> None
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_stream_limits(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._handshake_complete = False
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._remote_max_data = 0
self._remote_max_data_used = 0
self._ping_pending = False
self._probe_pending = False
===========unchanged ref 1===========
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self._handshake_complete = True
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._on_ping_delivery
self._ping_pending = True
at: aioquic.connection.QuicConnection._send_probe
self._probe_pending = True
at: aioquic.connection.QuicConnection.ping
self._ping_pending = True
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
|
aioquic.recovery/QuicPacketRecovery.__init__
|
Modified
|
aiortc~aioquic
|
868a068dbe45379208046385655805fabef546e0
|
[connection] enforce local idle timeout
|
<5>:<del> self._get_time = get_time
|
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
- self,
- logger: logging.LoggerAdapter,
- get_time: Callable[[], float],
- send_probe: Callable[[], None],
+ self, logger: logging.LoggerAdapter, send_probe: Callable[[], None]
) -> None:
<0> self.ack_delay_exponent = 3
<1> self.max_ack_delay = 25 # ms
<2> self.spaces: List[QuicPacketSpace] = []
<3>
<4> # callbacks
<5> self._get_time = get_time
<6> self._logger = logger
<7> self._send_probe = send_probe
<8>
<9> # loss detection
<10> self._crypto_count = 0
<11> self._pto_count = 0
<12> self._rtt_initialized = False
<13> self._rtt_latest = 0.0
<14> self._rtt_min = math.inf
<15> self._rtt_smoothed = 0.0
<16> self._rtt_variance = 0.0
<17> self._time_of_last_sent_ack_eliciting_packet = 0.0
<18> self._time_of_last_sent_crypto_packet = 0.0
<19>
<20> # congestion control
<21> self.bytes_in_flight = 0
<22> self.congestion_window = K_INITIAL_WINDOW
<23> self._congestion_recovery_start_time = 0.0
<24> self._ssthresh = math.inf
<25>
|
===========unchanged ref 0===========
at: aioquic.recovery
K_INITIAL_WINDOW = 10 * K_MAX_DATAGRAM_SIZE
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_latest = max(latest_rtt, 0.001)
self._rtt_latest -= ack_delay
self._rtt_min = self._rtt_latest
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self._crypto_count = 0
self._pto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self.bytes_in_flight -= packet.sent_bytes
self._crypto_count += 1
self._pto_count += 1
at: aioquic.recovery.QuicPacketRecovery.on_packet_acked
self.bytes_in_flight -= packet.sent_bytes
self.congestion_window += (
K_MAX_DATAGRAM_SIZE * packet.sent_bytes // self.congestion_window
)
self.congestion_window += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_expired
self.bytes_in_flight -= packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self._time_of_last_sent_crypto_packet = packet.sent_time
self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
===========unchanged ref 1===========
self.bytes_in_flight += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.bytes_in_flight -= lost_bytes
self._congestion_recovery_start_time = now
self.congestion_window = max(
int(self.congestion_window * K_LOSS_REDUCTION_FACTOR), K_MINIMUM_WINDOW
)
self._ssthresh = self.congestion_window
at: logging
LoggerAdapter(logger: Logger, extra: Mapping[str, Any])
at: math
inf: float
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
|
aioquic.recovery/QuicPacketRecovery.detect_loss
|
Modified
|
aiortc~aioquic
|
868a068dbe45379208046385655805fabef546e0
|
[connection] enforce local idle timeout
|
<9>:<add> time_threshold = now - loss_delay
<del> time_threshold = self._get_time() - loss_delay
<38>:<add> self.on_packets_lost(lost_bytes, lost_largest_time, now=now)
<del> self.on_packets_
|
# module: aioquic.recovery
class QuicPacketRecovery:
+ def detect_loss(self, space: QuicPacketSpace, now: float) -> None:
- def detect_loss(self, space: QuicPacketSpace) -> None:
<0> """
<1> Check whether any packets should be declared lost.
<2> """
<3> loss_delay = K_TIME_THRESHOLD * (
<4> max(self._rtt_latest, self._rtt_smoothed)
<5> if self._rtt_initialized
<6> else K_INITIAL_RTT
<7> )
<8> packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
<9> time_threshold = self._get_time() - loss_delay
<10>
<11> lost_bytes = 0
<12> lost_largest_time = None
<13> space.loss_time = None
<14> for packet_number, packet in list(space.sent_packets.items()):
<15> if packet_number > space.largest_acked_packet:
<16> break
<17>
<18> if packet_number <= packet_threshold or packet.sent_time <= time_threshold:
<19> # remove packet and update counters
<20> del space.sent_packets[packet_number]
<21> if packet.is_ack_eliciting:
<22> space.ack_eliciting_in_flight -= 1
<23> if packet.is_crypto_packet:
<24> space.crypto_packet_in_flight -= 1
<25> if packet.in_flight:
<26> lost_bytes += packet.sent_bytes
<27> lost_largest_time = packet.sent_time
<28>
<29> # trigger callbacks
<30> for handler, args in packet.delivery_handlers:
<31> handler(QuicDeliveryState.LOST, *args)
<32> else:
<33> packet_loss_time = packet.sent_time + loss_delay
<34> if space.loss_time is None or space.loss_time > packet_loss_time:
<35> space.loss_time = packet_loss_time
<36>
<37> if lost_bytes:
<38> self.on_packets_</s>
|
===========below chunk 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def detect_loss(self, space: QuicPacketSpace, now: float) -> None:
- def detect_loss(self, space: QuicPacketSpace) -> None:
# offset: 1
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.recovery
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_TIME_THRESHOLD = 9 / 8
QuicPacketSpace()
at: aioquic.recovery.QuicPacketRecovery
on_packets_lost(self, lost_bytes: int, lost_largest_time: float, now: float) -> None
on_packets_lost(lost_bytes: int, lost_largest_time: float, now: float) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_smoothed = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._rtt_latest = max(latest_rtt, 0.001)
self._rtt_latest -= ack_delay
self._rtt_initialized = True
self._rtt_smoothed = latest_rtt
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
===========unchanged ref 1===========
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
- self,
- logger: logging.LoggerAdapter,
- get_time: Callable[[], float],
- send_probe: Callable[[], None],
+ self, logger: logging.LoggerAdapter, send_probe: Callable[[], None]
) -> None:
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
# callbacks
- self._get_time = get_time
self._logger = logger
self._send_probe = send_probe
# loss detection
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
self._time_of_last_sent_crypto_packet = 0.0
# congestion control
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
self._congestion_recovery_start_time = 0.0
self._ssthresh = math.inf
|
aioquic.recovery/QuicPacketRecovery.on_ack_received
|
Modified
|
aiortc~aioquic
|
868a068dbe45379208046385655805fabef546e0
|
[connection] enforce local idle timeout
|
<3>:<del> ack_time = self._get_time()
<4>:<del>
|
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
+ self,
+ space: QuicPacketSpace,
+ ack_rangeset: RangeSet,
+ ack_delay_encoded: int,
+ now: float,
- self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
<0> """
<1> Update metrics as the result of an ACK being received.
<2> """
<3> ack_time = self._get_time()
<4>
<5> is_ack_eliciting = False
<6> largest_acked = ack_rangeset.bounds().stop - 1
<7> largest_newly_acked = None
<8> largest_sent_time = None
<9>
<10> if largest_acked > space.largest_acked_packet:
<11> space.largest_acked_packet = largest_acked
<12>
<13> for packet_number in sorted(space.sent_packets.keys()):
<14> if packet_number > largest_acked:
<15> break
<16> if packet_number in ack_rangeset:
<17> # remove packet and update counters
<18> packet = space.sent_packets.pop(packet_number)
<19> if packet.is_ack_eliciting:
<20> is_ack_eliciting = True
<21> space.ack_eliciting_in_flight -= 1
<22> if packet.is_crypto_packet:
<23> space.crypto_packet_in_flight -= 1
<24> if packet.in_flight:
<25> self.on_packet_acked(packet)
<26> largest_newly_acked = packet_number
<27> largest_sent_time = packet.sent_time
<28>
<29> # trigger callbacks
<30> for handler, args in packet.delivery_handlers:
<31> handler(QuicDeliveryState.ACKED, *args)
<32>
<33> # nothing to do if there are no newly acked packets
<34> if largest_newly_acked is None:
<35> return
<36>
<37> if largest_ack</s>
|
===========below chunk 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
+ self,
+ space: QuicPacketSpace,
+ ack_rangeset: RangeSet,
+ ack_delay_encoded: int,
+ now: float,
- self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
# offset: 1
latest_rtt = ack_time - largest_sent_time
# decode ACK delay into seconds
ack_delay = max(
(ack_delay_encoded << self.ack_delay_exponent) / 1000000,
self.max_ack_delay / 1000,
)
# update RTT estimate, which cannot be < 1 ms
self._rtt_latest = max(ack_time - largest_sent_time, 0.001)
if self._rtt_latest < self._rtt_min:
self._rtt_min = self._rtt_latest
if self._rtt_latest > self._rtt_min + ack_delay:
self._rtt_latest -= ack_delay
if not self._rtt_initialized:
self._rtt_initialized = True
self._rtt_variance = latest_rtt / 2
self._rtt_smoothed = latest_rtt
else:
self._rtt_variance = 3 / 4 * self._rtt_variance + 1 / 4 * abs(
self._rtt_min - self._rtt_latest
)
self._rtt_smoothed = (
7 / 8 * self._rtt_smoothed + 1 / 8 * self._rtt_latest
)
self.detect_loss(space)
self._crypto_count = 0
self._pto_count = 0
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
in_flight: bool
is_ack_eliciting: bool
is_crypto_packet: bool
sent_time: Optional[float] = None
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.rangeset.RangeSet
bounds() -> range
at: aioquic.recovery.QuicPacketRecovery
detect_loss(self, space: QuicPacketSpace, now: float) -> None
detect_loss(space: QuicPacketSpace, now: float) -> None
on_packet_acked(packet: QuicSentPacket) -> None
on_packet_acked(self, packet: QuicSentPacket) -> None
at: aioquic.recovery.QuicPacketRecovery.__init__
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
self._crypto_count += 1
self._pto_count += 1
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.largest_acked_packet = 0
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========unchanged ref 1===========
at: typing.MutableMapping
pop(key: _KT) -> _VT
pop(key: _KT, default: Union[_VT, _T]=...) -> Union[_VT, _T]
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def detect_loss(self, space: QuicPacketSpace, now: float) -> None:
- def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
+ time_threshold = now - loss_delay
- time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
if packet_number <= packet_threshold or packet.sent_time <= time_threshold:
# remove packet and update counters
del space.sent_packets[packet_number]
if packet.is_ack_eliciting:
space.ack_eliciting_in_flight -= 1
if packet.is_crypto_packet:
space.crypto_packet_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
+ self.on_packets_lost(lost_bytes, lost_largest_time, now=now)
- self.on</s>
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def detect_loss(self, space: QuicPacketSpace, now: float) -> None:
- def detect_loss(self, space: QuicPacketSpace) -> None:
# offset: 1
<s>.on_packets_lost(lost_bytes, lost_largest_time, now=now)
- self.on_packets_lost(lost_bytes, lost_largest_time)
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
- self,
- logger: logging.LoggerAdapter,
- get_time: Callable[[], float],
- send_probe: Callable[[], None],
+ self, logger: logging.LoggerAdapter, send_probe: Callable[[], None]
) -> None:
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
# callbacks
- self._get_time = get_time
self._logger = logger
self._send_probe = send_probe
# loss detection
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
self._time_of_last_sent_crypto_packet = 0.0
# congestion control
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
self._congestion_recovery_start_time = 0.0
self._ssthresh = math.inf
|
aioquic.recovery/QuicPacketRecovery.on_loss_detection_timeout
|
Modified
|
aiortc~aioquic
|
868a068dbe45379208046385655805fabef546e0
|
[connection] enforce local idle timeout
|
<3>:<add> self.detect_loss(loss_space, now=now)
<del> self.detect_loss(loss_space)
|
# module: aioquic.recovery
class QuicPacketRecovery:
+ def on_loss_detection_timeout(self, now: float) -> None:
- def on_loss_detection_timeout(self) -> None:
<0> self._logger.info("Loss detection timeout triggered")
<1> loss_space = self.get_earliest_loss_time()
<2> if loss_space is not None:
<3> self.detect_loss(loss_space)
<4> elif sum(space.crypto_packet_in_flight for space in self.spaces):
<5> # reschedule crypto packets
<6> for space in self.spaces:
<7> for packet_number, packet in list(
<8> filter(lambda i: i[1].is_crypto_packet, space.sent_packets.items())
<9> ):
<10> # remove packet and update counters
<11> del space.sent_packets[packet_number]
<12> space.ack_eliciting_in_flight -= 1
<13> space.crypto_packet_in_flight -= 1
<14> if packet.in_flight:
<15> self.bytes_in_flight -= packet.sent_bytes
<16>
<17> # trigger callbacks
<18> for handler, args in packet.delivery_handlers:
<19> handler(QuicDeliveryState.LOST, *args)
<20> self._crypto_count += 1
<21> else:
<22> self._pto_count += 1
<23> self._send_probe()
<24>
|
===========unchanged ref 0===========
at: aioquic.packet_builder
QuicDeliveryState()
QuicSentPacket(epoch: Epoch, in_flight: bool, is_ack_eliciting: bool, is_crypto_packet: bool, packet_number: int, sent_time: Optional[float]=None, sent_bytes: int=0, delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]]=field(
default_factory=list
))
at: aioquic.recovery.QuicPacketRecovery
detect_loss(self, space: QuicPacketSpace, now: float) -> None
detect_loss(space: QuicPacketSpace, now: float) -> None
get_earliest_loss_time() -> Optional[QuicPacketSpace]
at: aioquic.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
self._send_probe = send_probe
self._crypto_count = 0
self._pto_count = 0
self.bytes_in_flight = 0
at: aioquic.recovery.QuicPacketRecovery.on_ack_received
self._crypto_count = 0
self._pto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_packet_acked
self.bytes_in_flight -= packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_expired
self.bytes_in_flight -= packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packet_sent
self.bytes_in_flight += packet.sent_bytes
at: aioquic.recovery.QuicPacketRecovery.on_packets_lost
self.bytes_in_flight -= lost_bytes
at: aioquic.recovery.QuicPacketSpace.__init__
self.ack_eliciting_in_flight = 0
self.crypto_packet_in_flight = 0
self.sent_packets: Dict[int, QuicSentPacket] = {}
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def detect_loss(self, space: QuicPacketSpace, now: float) -> None:
- def detect_loss(self, space: QuicPacketSpace) -> None:
"""
Check whether any packets should be declared lost.
"""
loss_delay = K_TIME_THRESHOLD * (
max(self._rtt_latest, self._rtt_smoothed)
if self._rtt_initialized
else K_INITIAL_RTT
)
packet_threshold = space.largest_acked_packet - K_PACKET_THRESHOLD
+ time_threshold = now - loss_delay
- time_threshold = self._get_time() - loss_delay
lost_bytes = 0
lost_largest_time = None
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
break
if packet_number <= packet_threshold or packet.sent_time <= time_threshold:
# remove packet and update counters
del space.sent_packets[packet_number]
if packet.is_ack_eliciting:
space.ack_eliciting_in_flight -= 1
if packet.is_crypto_packet:
space.crypto_packet_in_flight -= 1
if packet.in_flight:
lost_bytes += packet.sent_bytes
lost_largest_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
else:
packet_loss_time = packet.sent_time + loss_delay
if space.loss_time is None or space.loss_time > packet_loss_time:
space.loss_time = packet_loss_time
if lost_bytes:
+ self.on_packets_lost(lost_bytes, lost_largest_time, now=now)
- self.on</s>
===========changed ref 1===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def detect_loss(self, space: QuicPacketSpace, now: float) -> None:
- def detect_loss(self, space: QuicPacketSpace) -> None:
# offset: 1
<s>.on_packets_lost(lost_bytes, lost_largest_time, now=now)
- self.on_packets_lost(lost_bytes, lost_largest_time)
===========changed ref 2===========
# module: aioquic.recovery
class QuicPacketRecovery:
def __init__(
- self,
- logger: logging.LoggerAdapter,
- get_time: Callable[[], float],
- send_probe: Callable[[], None],
+ self, logger: logging.LoggerAdapter, send_probe: Callable[[], None]
) -> None:
self.ack_delay_exponent = 3
self.max_ack_delay = 25 # ms
self.spaces: List[QuicPacketSpace] = []
# callbacks
- self._get_time = get_time
self._logger = logger
self._send_probe = send_probe
# loss detection
self._crypto_count = 0
self._pto_count = 0
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_min = math.inf
self._rtt_smoothed = 0.0
self._rtt_variance = 0.0
self._time_of_last_sent_ack_eliciting_packet = 0.0
self._time_of_last_sent_crypto_packet = 0.0
# congestion control
self.bytes_in_flight = 0
self.congestion_window = K_INITIAL_WINDOW
self._congestion_recovery_start_time = 0.0
self._ssthresh = math.inf
===========changed ref 3===========
# module: aioquic.recovery
class QuicPacketRecovery:
def on_ack_received(
+ self,
+ space: QuicPacketSpace,
+ ack_rangeset: RangeSet,
+ ack_delay_encoded: int,
+ now: float,
- self, space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int
) -> None:
"""
Update metrics as the result of an ACK being received.
"""
- ack_time = self._get_time()
-
is_ack_eliciting = False
largest_acked = ack_rangeset.bounds().stop - 1
largest_newly_acked = None
largest_sent_time = None
if largest_acked > space.largest_acked_packet:
space.largest_acked_packet = largest_acked
for packet_number in sorted(space.sent_packets.keys()):
if packet_number > largest_acked:
break
if packet_number in ack_rangeset:
# remove packet and update counters
packet = space.sent_packets.pop(packet_number)
if packet.is_ack_eliciting:
is_ack_eliciting = True
space.ack_eliciting_in_flight -= 1
if packet.is_crypto_packet:
space.crypto_packet_in_flight -= 1
if packet.in_flight:
self.on_packet_acked(packet)
largest_newly_acked = packet_number
largest_sent_time = packet.sent_time
# trigger callbacks
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.ACKED, *args)
# nothing to do if there are no newly acked packets
if largest_newly_acked is None:
return
if largest_acked == largest_newly_acked and is_ack_eliciting:
+ latest_rtt = now - largest_sent_time
- </s>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.