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.loss/QuicPacketLoss.detect_loss
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<20>:<add> self._logger.info("Packet %d lost", packet_number)
|
# module: aioquic.loss
class QuicPacketLoss:
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> space.loss_time = None
<12> for packet_number, packet in list(space.sent_packets.items()):
<13> if packet_number > space.largest_acked_packet:
<14> continue
<15>
<16> if packet_number <= packet_threshold or packet.sent_time < time_threshold:
<17> for handler, args in packet.delivery_handlers:
<18> handler(QuicDeliveryState.LOST, *args)
<19> del space.sent_packets[packet_number]
<20> else:
<21> packet_loss_time = packet.sent_time + loss_delay
<22> if space.loss_time is None or space.loss_time > packet_loss_time:
<23> space.loss_time = packet_loss_time
<24>
|
===========unchanged ref 0===========
at: aioquic.loss
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_TIME_THRESHOLD = 9 / 8
QuicPacketSpace()
at: aioquic.loss.QuicPacketLoss.__init__
self._get_time = get_time
self._rtt_initialized = False
self._rtt_latest = 0.0
self._rtt_smoothed = 0.0
at: aioquic.loss.QuicPacketLoss.on_ack_received
self._rtt_latest = max(latest_rtt, 0.001)
self._rtt_latest -= ack_delay
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.loss.QuicPacketLoss.on_packet_sent
self._time_of_last_sent_crypto_packet = packet.sent_time
self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
at: aioquic.loss.QuicPacketSpace.__init__
self.largest_acked_packet = 0
self.loss_time: Optional[float] = None
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
===========unchanged ref 1===========
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
===========changed ref 0===========
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
+ self,
+ logger: logging.LoggerAdapter,
+ get_time: Callable[[], float],
+ send_probe: Callable[[], None],
- self, get_time: Callable[[], float], 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
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
|
aioquic.loss/QuicPacketLoss.on_loss_timeout
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<0>:<add> self._logger.info("Loss timeout triggered")
|
# module: aioquic.loss
class QuicPacketLoss:
def on_loss_timeout(self) -> None:
<0> loss_space = self.get_earliest_loss_time()
<1> if loss_space is not None:
<2> self.detect_loss(loss_space)
<3> else:
<4> self._pto_count += 1
<5> self._send_probe()
<6>
|
===========unchanged ref 0===========
at: aioquic.loss.QuicPacketLoss
detect_loss(self, space: QuicPacketSpace) -> None
detect_loss(space: QuicPacketSpace) -> None
at: aioquic.loss.QuicPacketLoss.__init__
self._crypto_count = 0
self._pto_count = 0
at: aioquic.loss.QuicPacketLoss.on_loss_timeout
self._pto_count += 1
===========changed ref 0===========
# module: aioquic.loss
class QuicPacketLoss:
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
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
continue
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
del space.sent_packets[packet_number]
+ self._logger.info("Packet %d lost", packet_number)
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
===========changed ref 1===========
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
+ self,
+ logger: logging.LoggerAdapter,
+ get_time: Callable[[], float],
+ send_probe: Callable[[], None],
- self, get_time: Callable[[], float], 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
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
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<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.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</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
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._loss = QuicPacketLoss(
get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
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</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>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: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_</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> 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")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")</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> (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_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<1>:<add>
<add> self.__send_pending_task = None
<add> if self.__state == QuicConnectionState.DRAINING:
<add> return
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> # build datagrams
<3> builder = QuicPacketBuilder(
<4> host_cid=self.host_cid,
<5> packet_number=self._packet_number,
<6> pad_first_datagram=(self.__epoch == tls.Epoch.INITIAL and self.is_client),
<7> peer_cid=self.peer_cid,
<8> peer_token=self.peer_token,
<9> spin_bit=self._spin_bit,
<10> version=self._version,
<11> )
<12>
<13> if self.__close:
<14> for epoch, packet_type in (
<15> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<16> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<17> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<18> ):
<19> crypto = self.cryptos[epoch]
<20> if crypto.send.is_valid():
<21> builder.start_packet(packet_type, crypto)
<22> write_close_frame(builder, **self.__close)
<23> builder.end_packet()
<24> self.__close = None
<25> break
<26> else:
<27> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<28> self._write_handshake(builder, epoch)
<29> self._write_application(builder, network_path)
<30> datagrams, packets = builder.flush()
<31>
<32> if datagrams:
<33> self._packet_number = builder.packet_number
<34>
<35> # register packets
<36> now = self._loop.time()
<37> for packet in packets:
<38> self._logger.debug(
<39> "[%s] sending packet %d", packet.epoch.name, packet.packet_number
<40> )
<41> packet.sent_time = now
<42>
<43> self.spaces[packet.</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
self._loss.on_packet_sent(packet)
# arm loss timer
self._set_loss_timer()
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
self.__send_pending_task = None
===========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_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.host_cid = self._host_cids[0].cid
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketLoss(
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._version: Optional[int] = None
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
===========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_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.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.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
===========unchanged ref 2===========
at: aioquic.loss.QuicPacketSpace.__init__
self.sent_packets: Dict[int, QuicSentPacket] = {}
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
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.events.AbstractEventLoop
time() -> float
at: enum.Enum
name: str
value: Any
_name_: str
_value_: Any
_member_names_: List[str] # undocumented
_member_map_: Dict[str, Enum] # undocumented
_value2member_map_: Dict[int, Enum] # undocumented
_ignore_: Union[str, List[str]]
_order_: str
===========unchanged ref 3===========
__order__: str
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
===========changed ref 0===========
# module: aioquic.loss
class QuicPacketLoss:
def on_loss_timeout(self) -> None:
+ self._logger.info("Loss timeout triggered")
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
self.detect_loss(loss_space)
else:
self._pto_count += 1
self._send_probe()
|
aioquic.connection/QuicConnection._set_state
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<1>:<add> if state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
<add> if self._loss_timer is not None:
<add> self._loss_timer.cancel()
<add> self._loss_timer = None
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
<0> self._logger.info("%s -> %s", self.__state, state)
<1> self.__state = state
<2>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionState()
at: aioquic.connection.QuicConnection.__init__
self._loss_timer: Optional[asyncio.TimerHandle] = None
at: aioquic.connection.QuicConnection._set_state
self._loss_timer = None
===========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:
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
# register packets
now = self._loop.time()
for packet in packets:
self._logger.debug(
"[%s] sending packet %d", packet.epoch.name, packet.packet_number
)
packet.sent_time = now
self.spaces[packet.epoch].sent_packets[packet.packet</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s>
)
packet.sent_time = now
self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
self._loss.on_packet_sent(packet)
# arm loss timer
self._set_loss_timer()
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
- self.__send_pending_task = None
-
===========changed ref 2===========
# module: aioquic.loss
class QuicPacketLoss:
def on_loss_timeout(self) -> None:
+ self._logger.info("Loss timeout triggered")
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
self.detect_loss(loss_space)
else:
self._pto_count += 1
self._send_probe()
===========changed ref 3===========
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
+ self,
+ logger: logging.LoggerAdapter,
+ get_time: Callable[[], float],
+ send_probe: Callable[[], None],
- self, get_time: Callable[[], float], 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
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
===========changed ref 4===========
# module: aioquic.loss
class QuicPacketLoss:
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
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
continue
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
del space.sent_packets[packet_number]
+ self._logger.info("Packet %d lost", packet_number)
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
===========changed ref 5===========
<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.__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</s>
|
tests.test_connection/QuicConnectionTest.test_tls_error
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<17>:<add> self.assertEqual(client_transport.sent, 1)
<del> self.assertEqual(client_transport.sent, 2)
|
# 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, 2)
<18> self.assertEqual(server_transport.sent, 1)
<19>
|
===========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, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_initialize(peer_cid: bytes) -> None
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
at: aioquic.tls
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
at: aioquic.tls.Context.__init__
self._supported_versions = [TLS_VERSION_1_3]
at: tests.test_connection
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
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: aioquic.loss
class QuicPacketLoss:
def on_loss_timeout(self) -> None:
+ self._logger.info("Loss timeout triggered")
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
self.detect_loss(loss_space)
else:
self._pto_count += 1
self._send_probe()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
self._logger.info("%s -> %s", self.__state, state)
+ if state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
+ if self._loss_timer is not None:
+ self._loss_timer.cancel()
+ self._loss_timer = None
self.__state = state
===========changed ref 2===========
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
+ self,
+ logger: logging.LoggerAdapter,
+ get_time: Callable[[], float],
+ send_probe: Callable[[], None],
- self, get_time: Callable[[], float], 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
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
===========changed ref 3===========
# module: aioquic.loss
class QuicPacketLoss:
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
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
continue
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
del space.sent_packets[packet_number]
+ self._logger.info("Packet %d lost", packet_number)
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
===========changed ref 4===========
# 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:
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
# register packets
now = self._loop.time()
for packet in packets:
self._logger.debug(
"[%s] sending packet %d", packet.epoch.name, packet.packet_number
)
packet.sent_time = now
self.spaces[packet.epoch].sent_packets[packet.packet</s>
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<16>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 5)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # close
<13> server.close(
<14> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<15> )
<16> self.assertEqual(client_transport.sent, 5)
<17> self.assertEqual(server_transport.sent, 4)
<18>
|
===========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, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
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
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
client = QuicConnection(is_client=True)
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
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# fail handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 1)
- self.assertEqual(client_transport.sent, 2)
self.assertEqual(server_transport.sent, 1)
===========changed ref 1===========
# module: aioquic.loss
class QuicPacketLoss:
def on_loss_timeout(self) -> None:
+ self._logger.info("Loss timeout triggered")
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
self.detect_loss(loss_space)
else:
self._pto_count += 1
self._send_probe()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
self._logger.info("%s -> %s", self.__state, state)
+ if state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
+ if self._loss_timer is not None:
+ self._loss_timer.cancel()
+ self._loss_timer = None
self.__state = state
===========changed ref 3===========
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
+ self,
+ logger: logging.LoggerAdapter,
+ get_time: Callable[[], float],
+ send_probe: Callable[[], None],
- self, get_time: Callable[[], float], 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
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
===========changed ref 4===========
# module: aioquic.loss
class QuicPacketLoss:
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
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
continue
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
del space.sent_packets[packet_number]
+ self._logger.info("Packet %d lost", packet_number)
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
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame_app
|
Modified
|
aiortc~aioquic
|
b6919c3ab263caac7722bb9178aea624cb1b6c39
|
[connection] stop loss timer on shutdown
|
<14>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 5)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # close
<13> server.close(error_code=QuicErrorCode.NO_ERROR)
<14> self.assertEqual(client_transport.sent, 5)
<15> self.assertEqual(server_transport.sent, 4)
<16>
|
===========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, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
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_connection_close_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 3)
# close
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
self.assertEqual(server_transport.sent, 4)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_tls_error(self):
client = QuicConnection(is_client=True)
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
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# fail handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 1)
- self.assertEqual(client_transport.sent, 2)
self.assertEqual(server_transport.sent, 1)
===========changed ref 2===========
# module: aioquic.loss
class QuicPacketLoss:
def on_loss_timeout(self) -> None:
+ self._logger.info("Loss timeout triggered")
loss_space = self.get_earliest_loss_time()
if loss_space is not None:
self.detect_loss(loss_space)
else:
self._pto_count += 1
self._send_probe()
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
self._logger.info("%s -> %s", self.__state, state)
+ if state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
+ if self._loss_timer is not None:
+ self._loss_timer.cancel()
+ self._loss_timer = None
self.__state = state
===========changed ref 4===========
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
+ self,
+ logger: logging.LoggerAdapter,
+ get_time: Callable[[], float],
+ send_probe: Callable[[], None],
- self, get_time: Callable[[], float], 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
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
===========changed ref 5===========
# module: aioquic.loss
class QuicPacketLoss:
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
space.loss_time = None
for packet_number, packet in list(space.sent_packets.items()):
if packet_number > space.largest_acked_packet:
continue
if packet_number <= packet_threshold or packet.sent_time < time_threshold:
for handler, args in packet.delivery_handlers:
handler(QuicDeliveryState.LOST, *args)
del space.sent_packets[packet_number]
+ self._logger.info("Packet %d lost", packet_number)
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
|
aioquic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<11>:<add> self._total_bytes = 0
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
<0> self._host_cid = host_cid
<1> self._pad_first_datagram = pad_first_datagram
<2> self._peer_cid = peer_cid
<3> self._peer_token = peer_token
<4> self._spin_bit = spin_bit
<5> self._version = version
<6>
<7> # assembled datagrams and packets
<8> self._ack_eliciting = False
<9> self._datagrams: List[bytes] = []
<10> self._packets: List[QuicSentPacket] = []
<11>
<12> # current packet
<13> self._crypto: Optional[CryptoPair] = None
<14> self._header_size = 0
<15> self._packet: Optional[QuicSentPacket] = None
<16> self._packet_number = packet_number
<17> self._packet_start = 0
<18> self._packet_type = 0
<19>
<20> self.buffer = Buffer(PACKET_MAX_SIZE)
<21>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoPair()
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, 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
self._total_bytes += self.buffer.tell()
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._pad_first_datagram = False
self._crypto = None
at: aioquic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
self._packets = []
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._ack_eliciting = False
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
at: typing
List = _alias(list, 1, inst=False, name='List')
===========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
+
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<4>:<add> self._ack_eliciting = 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>
<5> # if there is too little space remaining, start a new datagram
<6> # FIXME: the limit is arbitrary!
<7> if buf.capacity - buf.tell() < 128:
<8> self._flush_current_datagram()
<9>
<10> # determine ack epoch
<11> if packet_type == PACKET_TYPE_INITIAL:
<12> epoch = Epoch.INITIAL
<13> elif packet_type == PACKET_TYPE_HANDSHAKE:
<14> epoch = Epoch.HANDSHAKE
<15> else:
<16> epoch = Epoch.ONE_RTT
<17>
<18> self._packet = QuicSentPacket(
<19> epoch=epoch,
<20> is_ack_eliciting=False,
<21> is_crypto_packet=False,
<22> packet_number=self._packet_number,
<23> )
<24> self._packet_start = buf.tell()
<25>
<26> # write header
<27> if is_long_header(packet_type):
<28> push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<29> push_uint32(buf, self._version)
<30> push_uint8(
<31> buf,
<32> (encode_cid_length(len(self._peer_cid)) << 4)
<33> | encode_cid_length(len(self._host_cid)),
<34> )
<35> push_bytes(buf, self._peer_cid)
<36> push_bytes(buf, self._host_cid)
<37> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<38> push_uint_var(buf, len(self._peer_token))
<39> push_bytes(buf, self._peer_token)
<40> push_uint16(buf, 0) # length
<41> push_packet_number(buf, 0</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint32(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
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
encode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
push_uint_var(buf: Buffer, value: int) -> None
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
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
QuicSentPacket(epoch: Epoch, 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
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._version = version
self._ack_eliciting = False
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._packet = None
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
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()
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def ack_eliciting(self) -> bool:
- """
- Returns True if an ack-eliciting frame was written.
- """
- return self._ack_eliciting
-
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def flight_bytes(self) -> int:
+ """
+ Returns the total number of bytes which will count towards
+ congestion control.
+ """
+ total = self._total_bytes
+ if self._ack_eliciting:
+ total += self.buffer.tell()
+ return total
+
===========changed ref 2===========
# 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 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
+ self._total_bytes = 0
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
|
aioquic.packet_builder/QuicPacketBuilder._flush_current_datagram
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<2>:<add> if self._ack_eliciting:
<add> self._total_bytes += self.buffer.tell()
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
<0> if self.buffer.tell():
<1> self._datagrams.append(self.buffer.data)
<2> self.buffer.seek(0)
<3>
|
===========unchanged ref 0===========
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._packet_number = packet_number
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def ack_eliciting(self) -> bool:
- """
- Returns True if an ack-eliciting frame was written.
- """
- return self._ack_eliciting
-
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def flight_bytes(self) -> int:
+ """
+ Returns the total number of bytes which will count towards
+ congestion control.
+ """
+ total = self._total_bytes
+ if self._ack_eliciting:
+ total += self.buffer.tell()
+ return total
+
===========changed ref 2===========
# 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 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
+ self._total_bytes = 0
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
|
aioquic.loss/QuicPacketLoss.__init__
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<9>:<add> # loss detection
<11>:<del>
<17>:<del>
|
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
self,
logger: logging.LoggerAdapter,
get_time: Callable[[], float],
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> self._crypto_count = 0
<10> self._pto_count = 0
<11>
<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>
<18> self._time_of_last_sent_ack_eliciting_packet = 0.0
<19> self._time_of_last_sent_crypto_packet = 0.0
<20>
|
===========unchanged ref 0===========
at: aioquic.loss
QuicPacketSpace()
at: aioquic.loss.QuicPacketLoss.on_ack_received
self._crypto_count = 0
self._pto_count = 0
at: aioquic.loss.QuicPacketLoss.on_loss_timeout
self._pto_count += 1
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, 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: logging
LoggerAdapter(logger: Logger, extra: Mapping[str, Any])
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
===========changed ref 0===========
# module: aioquic.loss
+ # loss detection
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_GRANULARITY = 0.001 # seconds
K_TIME_THRESHOLD = 9 / 8
===========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:
- @property
- def ack_eliciting(self) -> bool:
- """
- Returns True if an ack-eliciting frame was written.
- """
- return self._ack_eliciting
-
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def flight_bytes(self) -> int:
+ """
+ Returns the total number of bytes which will count towards
+ congestion control.
+ """
+ total = self._total_bytes
+ if self._ack_eliciting:
+ total += self.buffer.tell()
+ return total
+
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
if self.buffer.tell():
self._datagrams.append(self.buffer.data)
+ if self._ack_eliciting:
+ self._total_bytes += self.buffer.tell()
self.buffer.seek(0)
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
+ self._total_bytes = 0
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 7===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
|
aioquic.loss/QuicPacketLoss.detect_loss
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<11>:<add> lost_bytes = 0
<add> lost_largest_time = None
<14>:<add> break
<del> continue
<20>:<add> if packet.in_flight:
<add> lost_bytes += packet.sent_bytes
<add> lost_largest_time = packet.sent_time
<del> self._logger.info("Packet %d lost", packet_number)
|
# module: aioquic.loss
class QuicPacketLoss:
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> space.loss_time = None
<12> for packet_number, packet in list(space.sent_packets.items()):
<13> if packet_number > space.largest_acked_packet:
<14> continue
<15>
<16> if packet_number <= packet_threshold or packet.sent_time < time_threshold:
<17> for handler, args in packet.delivery_handlers:
<18> handler(QuicDeliveryState.LOST, *args)
<19> del space.sent_packets[packet_number]
<20> self._logger.info("Packet %d lost", packet_number)
<21> else:
<22> packet_loss_time = packet.sent_time + loss_delay
<23> if space.loss_time is None or space.loss_time > packet_loss_time:
<24> space.loss_time = packet_loss_time
<25>
|
===========unchanged ref 0===========
at: aioquic.loss
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_TIME_THRESHOLD = 9 / 8
K_INITIAL_WINDOW = 10 * K_MAX_DATAGRAM_SIZE
QuicPacketSpace()
at: aioquic.loss.QuicPacketLoss.__init__
self._get_time = get_time
self._rtt_initialized = False
at: aioquic.loss.QuicPacketLoss.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
)
at: aioquic.loss.QuicPacketLoss.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.loss.QuicPacketLoss.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
===========unchanged ref 1===========
at: aioquic.loss.QuicPacketLoss.on_packets_lost
self._bytes_in_flight -= lost_bytes
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: aioquic.loss.QuicPacketSpace.__init__
self.largest_acked_packet = 0
at: math
inf: float
===========changed ref 0===========
# module: aioquic.loss
+ # loss detection
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_GRANULARITY = 0.001 # seconds
K_TIME_THRESHOLD = 9 / 8
===========changed ref 1===========
# module: aioquic.loss
class QuicPacketLoss:
def __init__(
self,
logger: logging.LoggerAdapter,
get_time: Callable[[], float],
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
===========changed ref 2===========
# 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 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def ack_eliciting(self) -> bool:
- """
- Returns True if an ack-eliciting frame was written.
- """
- return self._ack_eliciting
-
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def flight_bytes(self) -> int:
+ """
+ Returns the total number of bytes which will count towards
+ congestion control.
+ """
+ total = self._total_bytes
+ if self._ack_eliciting:
+ total += self.buffer.tell()
+ return total
+
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
if self.buffer.tell():
self._datagrams.append(self.buffer.data)
+ if self._ack_eliciting:
+ self._total_bytes += self.buffer.tell()
self.buffer.seek(0)
===========changed ref 6===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
+ self._total_bytes = 0
# current packet
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<12>:<del> # trigger callbacks
<22>:<add> if packet.in_flight:
<add> self._loss.on_packet_acked(packet)
<add>
<add> # trigger callbacks
|
# 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_time = self._loop.time()
<4> space = self.spaces[context.epoch]
<5>
<6> rangeset, ack_delay_encoded = pull_ack_frame(buf)
<7> if frame_type == QuicFrameType.ACK_ECN:
<8> pull_uint_var(buf)
<9> pull_uint_var(buf)
<10> pull_uint_var(buf)
<11>
<12> # trigger callbacks
<13> is_ack_eliciting = False
<14> largest_newly_acked = None
<15> largest_sent_time = None
<16> for packet_range in rangeset:
<17> for packet_number in packet_range:
<18> packet = space.sent_packets.pop(packet_number, None)
<19> if packet is not None:
<20> # newly ack'd
<21> self._logger.debug("Packet %d ACK'd", packet_number)
<22> for handler, args in packet.delivery_handlers:
<23> handler(QuicDeliveryState.ACKED, *args)
<24> if packet.is_ack_eliciting:
<25> is_ack_eliciting = True
<26> largest_newly_acked = packet_number
<27> largest_sent_time = packet.sent_time
<28>
<29> # update RTT estimate
<30> if largest_newly_acked is not None:
<31> self._loss.on_ack_received(
<32> space=space,
<33> is_ack_eliciting=is_ack_eliciting,
<34> largest_newly_acked=largest_newly_acked,
<35> latest_rtt=ack_time - largest_sent_time,
<36> ack_delay_encoded=ack_delay_encoded,
<37> )
<38>
<39> # arm loss timer
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self._loop = asyncio.get_event_loop()
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketLoss(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
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.loss.QuicPacketLoss
on_ack_received(space: QuicPacketSpace, is_ack_eliciting: bool, largest_newly_acked: int, latest_rtt: float, ack_delay_encoded: int) -> None
on_packet_acked(packet: QuicSentPacket) -> None
at: aioquic.loss.QuicPacketSpace.__init__
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
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.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
===========unchanged ref 1===========
sent_time: Optional[float] = None
sent_bytes: int = 0
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: asyncio.events.AbstractEventLoop
time() -> float
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
at: typing.MutableMapping
pop(key: _KT) -> _VT
pop(key: _KT, default: Union[_VT, _T]=...) -> Union[_VT, _T]
===========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.loss
class QuicPacketLoss:
+ def on_packet_acked(self, packet: QuicSentPacket) -> None:
+ self._bytes_in_flight -= packet.sent_bytes
+
+ # don't increase window in congestion recovery
+ if packet.sent_time <= self._congestion_recovery_start_time:
+ return
+
+ if self._congestion_window < self._ssthresh:
+ # slow start
+ self._congestion_window += packet.sent_bytes
+ else:
+ # congestion avoidance
+ self._congestion_window += (
+ K_MAX_DATAGRAM_SIZE * packet.sent_bytes // self._congestion_window
+ )
+
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def ack_eliciting(self) -> bool:
- """
- Returns True if an ack-eliciting frame was written.
- """
- return self._ack_eliciting
-
===========changed ref 3===========
# module: aioquic.loss
+ # loss detection
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_GRANULARITY = 0.001 # seconds
K_TIME_THRESHOLD = 9 / 8
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def flight_bytes(self) -> int:
+ """
+ Returns the total number of bytes which will count towards
+ congestion control.
+ """
+ total = self._total_bytes
+ if self._ack_eliciting:
+ total += self.buffer.tell()
+ return total
+
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
if self.buffer.tell():
self._datagrams.append(self.buffer.data)
+ if self._ack_eliciting:
+ self._total_bytes += self.buffer.tell()
self.buffer.seek(0)
===========changed ref 6===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
- K_PACKET_THRESHOLD = 3
- K_INITIAL_RTT = 0.5 # seconds
- K_GRANULARITY = 0.001 # seconds
- K_TIME_THRESHOLD = 9 / 8
MAX_DATA_WINDOW = 1048576
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
===========changed ref 7===========
# module: aioquic.loss
+ # congestion control
+ K_MAX_DATAGRAM_SIZE = 1280
+ K_INITIAL_WINDOW = 10 * K_MAX_DATAGRAM_SIZE
+ K_MINIMUM_WINDOW = 2 * K_MAX_DATAGRAM_SIZE
+ K_LOSS_REDUCTION_FACTOR = 0.5
+ K_PERSISTENT_CONGESTION_THRESHOLD = 0.3
+ # TODO : collapse congestion window if persistent congestion
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<39>:<add> # send datagrams
<add> for datagram in datagrams:
<add> self._transport.sendto(datagram, network_path.addr)
<add> network_path.bytes_sent += len(datagram)
<add>
|
# 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> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<32> self._write_handshake(builder, epoch)
<33> self._write_application(builder, network_path)
<34> datagrams, packets = builder.flush()
<35>
<36> if datagrams:
<37> self._packet_number = builder.packet_number
<38>
<39> # register packets
<40> now = self._loop.time()
<41> for packet in packets:
<42> self._logger.debug(
<43> "[%s] sending packet %d", packet</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
)
packet.sent_time = now
self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
self._loss.on_packet_sent(packet)
# arm loss timer
self._set_loss_timer()
# send datagrams
for datagram in datagrams:
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
===========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
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_write_application(self, builder: QuicPacketBuilder, network_path: QuicNetworkPath) -> 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.__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 = QuicPacketLoss(
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_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))
self.peer_cid = header.source_cid
===========unchanged ref 2===========
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.loss.QuicPacketSpace.__init__
self.sent_packets: Dict[int, QuicSentPacket] = {}
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
packet_number: int
sent_time: Optional[float] = None
at: aioquic.tls
Epoch()
===========unchanged ref 3===========
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
at: enum.Enum
name: str
value: Any
_name_: str
_value_: Any
_member_names_: List[str] # undocumented
_member_map_: Dict[str, Enum] # undocumented
_value2member_map_: Dict[int, Enum] # undocumented
_ignore_: Union[str, List[str]]
_order_: str
__order__: str
at: logging.LoggerAdapter
debug(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<15>:<add> while (
<add> builder.flight_bytes + self._loss._bytes_in_flight
<add> < self._loss._congestion_window
<add> ):
<del> # FIXME: implement congestion control
<16>:<del> packets = 0
<17>:<del> while packets < 5:
|
# 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> # FIXME: implement congestion control
<16> packets = 0
<17> while packets < 5:
<18> # write header
<19> builder.start_packet(packet_type, crypto)
<20>
<21> if is_one_rtt:
<22> # ACK
<23> if space.ack_required and space.ack_queue:
<24> builder.start_frame(QuicFrameType.ACK)
<25> push_ack_frame(buf, space.ack_queue, 0)
<26> space.ack_required = False
<27>
<28> # PATH CHALLENGE
<29> if (
<30> not network_path.is_validated
<31> and network_path.local_challenge is None
<32> ):
<33> self._logger.info(
<34> "Network path %s sending challenge", network_path.addr
<35> )
<36> network_path.local_challenge = os.urandom(8)
<37> builder.start_frame(QuicFrameType.PATH_CHALLENGE)
<38> push_</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
# 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:
self._logger.info("Sending PING in packet %d",</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s> (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:
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
packets += 1
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> 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
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
_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.__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._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketLoss(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
===========unchanged ref 1===========
self._remote_max_data = 0
self._remote_max_data_used = 0
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
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._update_traffic_key
crypto = self.cryptos[epoch]
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
setup(cipher_suite: CipherSuite, secret: bytes) -> None
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<7>:<add> while (
<del> while True:
<8>:<add> builder.flight_bytes + self._loss._bytes_in_flight
<add> < self._loss._congestion_window
<add> ):
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_required and space.ack_queue:
<16> builder.start_frame(QuicFrameType.ACK)
<17> push_ack_frame(buf, space.ack_queue, 0)
<18> space.ack_required = False
<19>
<20> # CRYPTO
<21> write_crypto_frame(builder=builder, space=space, stream=self.streams[epoch])
<22>
<23> if not builder.end_packet():
<24> break
<25>
<26> # discard initial keys
<27> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<28> self.cryptos[tls.Epoch.INITIAL].teardown()
<29>
|
===========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 = QuicPacketLoss(
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.loss.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
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.tls
Epoch()
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def flight_bytes(self) -> int:
+ """
+ Returns the total number of bytes which will count towards
+ congestion control.
+ """
+ total = self._total_bytes
+ if self._ack_eliciting:
+ total += self.buffer.tell()
+ return total
+
===========changed ref 1===========
# 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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 3===========
# 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:
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
now = self._loop.time()
for packet in packets:
self._logger.debug</s>
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_padding
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<18>:<del>
<19>:<del> # check builder state
<21>:<del> self.assertEqual(builder.packet_number, 1)
|
# 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>
<19> # check builder state
<20> self.assertEqual(builder.buffer.tell(), 1280)
<21> self.assertEqual(builder.packet_number, 1)
<22>
<23> # check datagrams
<24> datagrams, packets = builder.flush()
<25> self.assertEqual(len(datagrams), 1)
<26> self.assertEqual(len(datagrams[0]), 1280)
<27> self.assertEqual(
<28> packets,
<29> [
<30> QuicSentPacket(
<31> epoch=Epoch.INITIAL,
<32> is_ack_eliciting=True,
<33> is_crypto_packet=True,
<34> packet_number=0,
<35> sent_bytes=1280,
<36> )
<37> ],
<38> )
<39>
|
===========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, 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.packet_builder.QuicSentPacket
epoch: Epoch
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
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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 2===========
# 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 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
- @property
- def ack_eliciting(self) -> bool:
- """
- Returns True if an ack-eliciting frame was written.
- """
- return self._ack_eliciting
-
===========changed ref 4===========
# module: aioquic.loss
+ # loss detection
K_PACKET_THRESHOLD = 3
K_INITIAL_RTT = 0.5 # seconds
K_GRANULARITY = 0.001 # seconds
K_TIME_THRESHOLD = 9 / 8
===========changed ref 5===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ @property
+ def flight_bytes(self) -> int:
+ """
+ Returns the total number of bytes which will count towards
+ congestion control.
+ """
+ total = self._total_bytes
+ if self._ack_eliciting:
+ total += self.buffer.tell()
+ return total
+
===========changed ref 6===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def _flush_current_datagram(self) -> None:
if self.buffer.tell():
self._datagrams.append(self.buffer.data)
+ if self._ack_eliciting:
+ self._total_bytes += self.buffer.tell()
self.buffer.seek(0)
===========changed ref 7===========
# module: aioquic.loss
+ # congestion control
+ K_MAX_DATAGRAM_SIZE = 1280
+ K_INITIAL_WINDOW = 10 * K_MAX_DATAGRAM_SIZE
+ K_MINIMUM_WINDOW = 2 * K_MAX_DATAGRAM_SIZE
+ K_LOSS_REDUCTION_FACTOR = 0.5
+ K_PERSISTENT_CONGESTION_THRESHOLD = 0.3
+ # TODO : collapse congestion window if persistent congestion
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_short_header
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<17>:<add> self.assertEqual(builder.buffer.tell(), 1280)
<24>:<del>
<25>:<del> # check builder
<26>:<del> self.assertTrue(builder.ack_eliciting)
|
# 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>
<18> # ONE_RTT, fully padded
<19> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<20> self.assertEqual(builder.remaining_space, 1253)
<21> builder.start_frame(QuicFrameType.STREAM_BASE)
<22> push_bytes(builder.buffer, bytes(builder.remaining_space))
<23> self.assertTrue(builder.end_packet())
<24>
<25> # check builder
<26> self.assertTrue(builder.ack_eliciting)
<27> self.assertEqual(builder.buffer.tell(), 0)
<28>
<29> # check datagrams
<30> datagrams, packets = builder.flush()
<31> self.assertEqual(len(datagrams), 2)
<32> self.assertEqual(len(datagrams[0]), 1280)
<33> self.assertEqual(len(datagrams[1]), 1280)
<34> self.assertEqual(
<35> packets,
<36> [
<37> QuicSentPacket(
<38> epoch=Epoch.INITIAL,
<39> is_ack_eliciting=True,
<40> </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, 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: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_short_header
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
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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 2===========
# 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())
-
- # check builder state
self.assertEqual(builder.buffer.tell(), 1280)
- self.assertEqual(builder.packet_number, 1)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=1280,
)
],
)
===========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
+
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_then_long_header
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<35>:<del>
<36>:<del> # check builder
<37>:<del> self.assertTrue(
|
# 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>
<36> # check builder
<37> self.assertTrue(</s>
|
===========below chunk 0===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_then_long_header(self):
# offset: 1
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
# 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, 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: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_long_header
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
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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_empty
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<17>:<del> self.assertFalse(builder.ack_eliciting)
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(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>
<10> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<11> self.assertEqual(builder.remaining_space, 1253)
<12>
<13> # nothing to write
<14> self.assertFalse(builder.end_packet())
<15>
<16> # check builder
<17> self.assertFalse(builder.ack_eliciting)
<18> self.assertEqual(builder.buffer.tell(), 0)
<19> self.assertEqual(builder.packet_number, 0)
<20>
<21> datagrams, packets = builder.flush()
<22> self.assertEqual(len(datagrams), 0)
<23> self.assertEqual(packets, [])
<24>
|
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
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]=...)
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.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
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
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# 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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 2===========
# 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())
-
- # check builder state
self.assertEqual(builder.buffer.tell(), 1280)
- self.assertEqual(builder.packet_number, 1)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=1280,
)
],
)
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_padding
|
Modified
|
aiortc~aioquic
|
408bfcf52c2e68fdaf880118c853195684b17427
|
[connection] first stab at congestion control
|
<19>:<del> self.assertTrue(builder.ack_eliciting)
|
# 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.assertTrue(builder.ack_eliciting)
<20> self.assertEqual(builder.buffer.tell(), 0)
<21> self.assertEqual(builder.packet_number, 1)
<22>
<23> # check datagrams
<24> datagrams, packets = builder.flush()
<25> self.assertEqual(len(datagrams), 1)
<26> self.assertEqual(len(datagrams[0]), 1280)
<27> self.assertEqual(
<28> packets,
<29> [
<30> QuicSentPacket(
<31> epoch=Epoch.ONE_RTT,
<32> is_ack_eliciting=True,
<33> is_crypto_packet=True,
<34> packet_number=0,
<35> sent_bytes=1280,
<36> )
<37> ],
<38> )
<39>
|
===========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
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, 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() -> 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)
at: aioquic.tls
Epoch()
at: tests.test_packet_builder.QuicPacketBuilderTest.test_short_header_padding
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
===========unchanged ref 1===========
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
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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 2===========
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_empty(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
# nothing to write
self.assertFalse(builder.end_packet())
# check builder
- self.assertFalse(builder.ack_eliciting)
self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
===========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())
-
- # check builder state
self.assertEqual(builder.buffer.tell(), 1280)
- self.assertEqual(builder.packet_number, 1)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=1280,
)
],
)
|
aioquic.connection/QuicConnection.close
|
Modified
|
aiortc~aioquic
|
aeb3115e04c8f241950f932991fea417a1b7e33c
|
[connection] do not restart loss timer when closing / draining
|
<3>:<del> self.__close = {
<4>:<del> "error_code": error_code,
<5>:<del> "frame_type": frame_type,
<6>:<del> "reason_phrase": reason_phrase,
<7>:<del> }
<12>:<add> self.__close = {
<add> "error_code": error_code,
<add> "frame_type": frame_type,
<add> "reason_phrase": reason_phrase,
<add> }
<20>:<add> self._send_pending()
<del> self._send_pending()
|
# 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> self.__close = {
<4> "error_code": error_code,
<5> "frame_type": frame_type,
<6> "reason_phrase": reason_phrase,
<7> }
<8> if self.__state not in [
<9> QuicConnectionState.CLOSING,
<10> QuicConnectionState.DRAINING,
<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() -> 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]=...)
|
aioquic.connection/QuicConnection._set_loss_timer
|
Modified
|
aiortc~aioquic
|
aeb3115e04c8f241950f932991fea417a1b7e33c
|
[connection] do not restart loss timer when closing / draining
|
<0>:<add> # stop timer
<del> loss_time = self._loss.get_loss_detection_time()
<3>:<del> if loss_time is not None:
<4>:<del> self._loss_timer = self._loop.call_at(loss_time, self._loss.on_loss_timeout)
<5>:<del> else:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_loss_timer(self) -> None:
<0> loss_time = self._loss.get_loss_detection_time()
<1> if self._loss_timer is not None:
<2> self._loss_timer.cancel()
<3> if loss_time is not None:
<4> self._loss_timer = self._loop.call_at(loss_time, self._loss.on_loss_timeout)
<5> else:
<6> self._loss_timer = None
<7>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self._loss_timer: Optional[asyncio.TimerHandle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
at: aioquic.connection.QuicConnection._set_state
self.__state = state
at: asyncio.events.TimerHandle
__slots__ = ['_scheduled', '_when']
cancel() -> None
===========changed ref 0===========
# 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:
"""
Close the connection.
"""
- self.__close = {
- "error_code": error_code,
- "frame_type": frame_type,
- "reason_phrase": reason_phrase,
- }
if self.__state not in [
QuicConnectionState.CLOSING,
QuicConnectionState.DRAINING,
]:
+ self.__close = {
+ "error_code": error_code,
+ "frame_type": frame_type,
+ "reason_phrase": reason_phrase,
+ }
self._set_state(QuicConnectionState.CLOSING)
self.connection_lost(
maybe_connection_error(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
+ self._send_pending()
- self._send_pending()
|
aioquic.connection/QuicConnection._set_state
|
Modified
|
aiortc~aioquic
|
aeb3115e04c8f241950f932991fea417a1b7e33c
|
[connection] do not restart loss timer when closing / draining
|
<1>:<del> if state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
<2>:<del> if self._loss_timer is not None:
<3>:<del> self._loss_timer.cancel()
<4>:<del> self._loss_timer = None
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_state(self, state: QuicConnectionState) -> None:
<0> self._logger.info("%s -> %s", self.__state, state)
<1> if state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
<2> if self._loss_timer is not None:
<3> self._loss_timer.cancel()
<4> self._loss_timer = None
<5> self.__state = state
<6>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionState()
at: aioquic.connection.QuicConnection.__init__
self._loop = asyncio.get_event_loop()
self._loss = QuicPacketLoss(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] = None
at: aioquic.loss.QuicPacketLoss
get_loss_detection_time() -> float
on_loss_timeout() -> None
at: asyncio.events.AbstractEventLoop
call_at(when: float, callback: Callable[..., Any], *args: Any) -> TimerHandle
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_loss_timer(self) -> None:
+ # stop timer
- loss_time = self._loss.get_loss_detection_time()
if self._loss_timer is not None:
self._loss_timer.cancel()
- if loss_time is not None:
- self._loss_timer = self._loop.call_at(loss_time, self._loss.on_loss_timeout)
- else:
self._loss_timer = None
===========changed ref 1===========
# 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:
"""
Close the connection.
"""
- self.__close = {
- "error_code": error_code,
- "frame_type": frame_type,
- "reason_phrase": reason_phrase,
- }
if self.__state not in [
QuicConnectionState.CLOSING,
QuicConnectionState.DRAINING,
]:
+ self.__close = {
+ "error_code": error_code,
+ "frame_type": frame_type,
+ "reason_phrase": reason_phrase,
+ }
self._set_state(QuicConnectionState.CLOSING)
self.connection_lost(
maybe_connection_error(
error_code=error_code,
frame_type=frame_type,
reason_phrase=reason_phrase,
)
)
+ self._send_pending()
- self._send_pending()
|
examples.client/run
|
Modified
|
aiortc~aioquic
|
8a5b24356893f4df1e9f18e40b22a42886565c96
|
[examples] display download speed
|
<6>:<add> start = time.time()
<7>:<add> elapsed = time.time() - start
|
# 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> response = await reader.read()
<7> print(response.decode("utf8"))
<8>
|
===========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.StreamWriter
write(data: bytes) -> None
write_eof() -> None
at: time
time() -> float
|
tests.test_connection/FakeTransport.sendto
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<1>:<add> if self.target is not None and random.random() >= self.loss:
<del> if self.target is not None:
|
# module: tests.test_connection
class FakeTransport:
def sendto(self, data, addr):
<0> self.sent += 1
<1> if self.target is not None:
<2> self.target.datagram_received(data, self.local_addr)
<3>
|
===========unchanged ref 0===========
at: tests.test_connection.FakeTransport
loss = 0
sent = 0
target = None
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
|
tests.test_connection/QuicConnectionTest.test_connection_lost
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(client._transport.sent, 4)
<add> self.assertEqual(server._transport.sent, 3)
<7>:<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
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> self.assertEqual(client._transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 4)
<10>:<add> self.assertEqual(server._transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 3)
<12>:<del> # send data over stream
<13>:<del> client_reader, client_writer = run(client.create_stream())
<14>:<del> client_writer.write(b"ping")
<15>:<del> run(asyncio.sleep(0))
<16>:<del> self.assertEqual(client_transport.sent, 5)
<17>:<del> self.assertEqual(server_transport.sent, 4)
<18>:<add> # break connection
<add> client.connection_lost(None)
<add> self.assertEqual(run(client_reader.read()), b"")
<19>:<del> # break connection
<20>:<del> client.connection_lost(None)
<21>:<del> self.assertEqual(run(client_reader.read()), b"")
<22>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # send data over stream
<13> client_reader, client_writer = run(client.create_stream())
<14> client_writer.write(b"ping")
<15> run(asyncio.sleep(0))
<16> self.assertEqual(client_transport.sent, 5)
<17> self.assertEqual(server_transport.sent, 4)
<18>
<19> # break connection
<20> client.connection_lost(None)
<21> self.assertEqual(run(client_reader.read()), b"")
<22>
|
===========unchanged ref 0===========
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
client_and_server()
at: tests.test_connection.QuicConnectionTest.test_connect_with_log
client_log_file = io.StringIO()
server_log_file = io.StringIO()
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():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
|
tests.test_connection/QuicConnectionTest.test_connection_lost_with_exception
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(client._transport.sent, 4)
<add> self.assertEqual(server._transport.sent, 3)
<7>:<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
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> self.assertEqual(client._transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 4)
<10>:<add> self.assertEqual(server._transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 3)
<12>:<add> # break connection
<add> exc = Exception("some error")
<add> client.connection_lost(exc)
<add> with self.assertRaises(Exception) as cm:
<add> run(client_reader.read())
<add> self.assertEqual(cm.exception, exc)
<del> # send data over stream
<13>:<del> client_reader, client_writer = run(client.create_stream())
<14>:<del> client_writer.write(b"ping")
<15>:<del> run(asyncio.sleep(0))
<16>:<del> self.assertEqual(client_transport.sent, 5)
<17>:<del> self.assertEqual(server_transport.sent, 4)
<19>:<del> # break connection
<20>:<del> exc = Exception("some error")
<21>:<del> client.connection_lost(exc)
<22>:<del> with self.assertRaises(Exception) as cm:
<23>:<del> run(client_reader.read())
<24>:<del> self.assertEqual(cm.exception, exc)
<25>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # send data over stream
<13> client_reader, client_writer = run(client.create_stream())
<14> client_writer.write(b"ping")
<15> run(asyncio.sleep(0))
<16> self.assertEqual(client_transport.sent, 5)
<17> self.assertEqual(server_transport.sent, 4)
<18>
<19> # break connection
<20> exc = Exception("some error")
<21> client.connection_lost(exc)
<22> with self.assertRaises(Exception) as cm:
<23> run(client_reader.read())
<24> self.assertEqual(cm.exception, exc)
<25>
|
===========unchanged ref 0===========
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
client_and_server()
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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))
- # 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)
- # 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"")
- # break connection
- client.connection_lost(None)
- self.assertEqual(run(client_reader.read()), b"")
-
|
tests.test_connection/QuicConnectionTest.test_consume_connection_id
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(
<add> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<add> )
<del> )
<7>:<add> # change connection ID
<add> client._consume_connection_id()
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> self.assertEqual(
<del> self.assertEqual(
<10>:<add> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
<del> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<11>:<add> )
<del> )
<13>:<add> # the server provides a new connection ID
<add> client._send_pending()
<del> # change connection ID
<14>:<del> client._consume_connection_id()
<15>:<add> self.assertEqual(
<del> self.assertEqual(
<16>:<add> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
<del> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
<17>:<add> )
<del> )
<19>:<del> # the server provides a new connection ID
<20>:<del> client._send_pending()
<21>:<del> self.assertEqual(
<22>:<del> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
<23>:<del> )
<24>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(
<10> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<11> )
<12>
<13> # change connection ID
<14> client._consume_connection_id()
<15> self.assertEqual(
<16> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
<17> )
<18>
<19> # the server provides a new connection ID
<20> client._send_pending()
<21> self.assertEqual(
<22> sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
<23> )
<24>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server()
sequence_numbers(connection_ids)
at: tests.test_connection.QuicConnectionTest.test_connection_lost_with_exception
exc = Exception("some error")
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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))
- # 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)
- # 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"")
- # 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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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))
- # 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)
+ # 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)
- # 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)
-
|
tests.test_connection/QuicConnectionTest.test_create_stream
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<add> with client_and_server() as (client, server):
<add> # client
<del> is_client=False,
<3>:<add> reader, writer = run(client.create_stream())
<add> self.assertEqual(writer.get_extra_info("stream_id"), 0)
<add> self.assertIsNotNone(writer.get_extra_info("connection"))
<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<7>:<add> reader, writer = run(client.create_stream())
<add> self.assertEqual(writer.get_extra_info("stream_id"), 4)
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client
<11>:<add> reader, writer = run(client.create_stream(is_unidirectional=True))
<del> reader, writer = run(client.create_stream())
<12>:<add> self.assertEqual(writer.get_extra_info("stream_id"), 2)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 0)
<13>:<del> self.assertIsNotNone(writer.get_extra_info("connection"))
<15>:<add> reader, writer = run(client.create_stream(is_unidirectional=True))
<del> reader, writer = run(client.create_stream())
<16>:<add> self.assertEqual(writer.get_extra_info("stream_id"), 6)
<del> self.assertEqual(writer.get_extra_info("stream_id"), 4)
<18>:<add> # server
<add> reader, writer = run(server
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client
<11> reader, writer = run(client.create_stream())
<12> self.assertEqual(writer.get_extra_info("stream_id"), 0)
<13> self.assertIsNotNone(writer.get_extra_info("connection"))
<14>
<15> reader, writer = run(client.create_stream())
<16> self.assertEqual(writer.get_extra_info("stream_id"), 4)
<17>
<18> reader, writer = run(client.create_stream(is_unidirectional=True))
<19> self.assertEqual(writer.get_extra_info("stream_id"), 2)
<20>
<21> reader, writer = run(client.create_stream(is_unidirectional=True))
<22> self.assertEqual(writer.get_extra_info("stream_id"), 6)
<23>
<24> # server
<25> reader, writer = run(server.create_stream())
<26> self.assertEqual(writer.get_extra_info("stream_id"), 1)
<27>
<28> reader, writer = run(server.create_stream())
<29> self.assertEqual(writer.get_extra_info("stream_id"), 5)
<30>
<31> reader, writer = run(server.create_stream(is_unidirectional=True))
<32> self.assertEqual(writer.get_extra_info("stream_id"), 3)
<33>
<34> reader, writer = run(server.create_stream(is_unidirectional=True))
<35> self.assertEqual(writer.get_extra_info("stream_id"), 7)
<36>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server()
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # change connection ID
+ client._consume_connection_id()
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
- sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # the server provides a new connection ID
+ client._send_pending()
- # change connection ID
- client._consume_connection_id()
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
- sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
+ )
- )
- # the server provides a new connection ID
- 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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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))
- # 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)
- # 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"")
- # 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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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))
- # 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)
+ # 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)
- # 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)
-
|
tests.test_connection/QuicConnectionTest.test_create_stream_over_max_streams
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(client._transport.sent, 4)
<add> self.assertEqual(server._transport.sent, 3)
<7>:<add> # create streams
<add> for i in range(128):
<add> client_reader, client_writer = run(client.create_stream())
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> self.assertEqual(client._transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 4)
<10>:<add> self.assertEqual(server._transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 3)
<12>:<add> # create one too many
<add> with self.assertRaises(ValueError) as cm:
<del> # create streams
<13>:<del> for i in range(128):
<14>:<add> client_reader, client_writer = run(client.create_stream())
<del> client_reader, client_writer = run(client.create_stream())
<15>:<del> self.assertEqual(client_transport.sent, 4)
<16>:<del> self.assertEqual(server_transport.sent, 3)
<17>:<add> self.assertEqual(str(cm.exception), "Too many streams open")
<18>:<del> # create one too many
<19>:<del> with self.assertRaises(ValueError) as cm:
<20>:<del> client_reader, client_writer = run(client.create_stream())
<21>:<del> self.assertEqual(str(cm.exception), "Too many streams open")
<22>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # create streams
<13> for i in range(128):
<14> client_reader, client_writer = run(client.create_stream())
<15> self.assertEqual(client_transport.sent, 4)
<16> self.assertEqual(server_transport.sent, 3)
<17>
<18> # create one too many
<19> with self.assertRaises(ValueError) as cm:
<20> client_reader, client_writer = run(client.create_stream())
<21> self.assertEqual(str(cm.exception), "Too many streams open")
<22>
|
===========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, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_initialize(peer_cid: bytes) -> None
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context.__init__
self._supported_versions = [TLS_VERSION_1_3]
at: tests.test_connection
client_and_server()
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():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_consume_connection_id(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # change connection ID
+ client._consume_connection_id()
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
- sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # the server provides a new connection ID
+ client._send_pending()
- # change connection ID
- client._consume_connection_id()
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
- sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
+ )
- )
- # the server provides a new connection ID
- 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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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))
- # 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)
- # 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"")
- # break connection
- client.connection_lost(None)
- self.assertEqual(run(client_reader.read()), b"")
-
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(client._transport.sent, 4)
<add> self.assertEqual(server._transport.sent, 3)
<del> client = QuicConnection(is_client=True)
<2>:<del> server = QuicConnection(
<3>:<del> is_client=False,
<4>:<del> certificate=SERVER_CERTIFICATE,
<5>:<del> private_key=SERVER_PRIVATE_KEY,
<6>:<add> # mess with encryption key
<add> server.cryptos[tls.Epoch.ONE_RTT].send.setup(
<add> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<add> )
<del> )
<8>:<add> # close
<add> server.close(error_code=QuicErrorCode.NO_ERROR)
<del> # perform handshake
<9>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<add> self.assertEqual(client._transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 4)
<11>:<add> self.assertEqual(server._transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 3)
<13>:<del> # mess with encryption key
<14>:<del> server.cryptos[tls.Epoch.ONE_RTT].send.setup(
<15>:<del> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<16>:<del> )
<17>:<del>
<18>:<del> # close
<19>:<del> server.close(error_code=QuicErrorCode.NO_ERROR)
<20>:<del> self.assertEqual(client_transport.sent, 4)
<21>:<del> self.assertEqual(server_transport.sent, 4)
<22>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 3)
<12>
<13> # mess with encryption key
<14> server.cryptos[tls.Epoch.ONE_RTT].send.setup(
<15> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<16> )
<17>
<18> # close
<19> server.close(error_code=QuicErrorCode.NO_ERROR)
<20> self.assertEqual(client_transport.sent, 4)
<21> self.assertEqual(server_transport.sent, 4)
<22>
|
===========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, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
_initialize(peer_cid: bytes) -> 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.crypto
CryptoPair()
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: tests.test_connection
create_standalone_client()
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.test_connection.QuicConnectionTest.test_tls_error
client = QuicConnection(is_client=True)
patched_initialize(peer_cid: bytes)
===========unchanged ref 1===========
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========changed ref 1===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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())
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- self.assertEqual(server_transport.sent, 3)
+ # create one too many
+ with self.assertRaises(ValueError) as cm:
- # create streams
- for i in range(128):
+ client_reader, client_writer = run(client.create_stream())
- client_reader, client_writer = run(client.create_stream())
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
+ self.assertEqual(str(cm.exception), "Too many streams open")
- # 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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # change connection ID
+ client._consume_connection_id()
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
- sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # the server provides a new connection ID
+ client._send_pending()
- # change connection ID
- client._consume_connection_id()
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
- sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
+ )
- )
- # the server provides a new connection ID
- client._send_pending()
- self.assertEqual(
- sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
- )
-
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<add> with client_and_server() as (client, server):
<add> server.close(
<add> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<add> )
<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del> self.assertEqual(client_transport.sent, 4)
<10>:<del> self.assertEqual(server_transport.sent, 3)
<11>:<del>
<12>:<del> # close
<13>:<del> server.close(
<14>:<del> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<15>:<del> )
<16>:<del> self.assertEqual(client_transport.sent, 4)
<17>:<del> self.assertEqual(server_transport.sent, 4)
<18>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # close
<13> server.close(
<14> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<15> )
<16> self.assertEqual(client_transport.sent, 4)
<17> self.assertEqual(server_transport.sent, 4)
<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
encode_uint_var(v)
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
at: tests.utils
run(coro)
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():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
+ with client_and_server() as (client, server):
+ self.assertEqual(client._transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ # 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)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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())
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- self.assertEqual(server_transport.sent, 3)
+ # create one too many
+ with self.assertRaises(ValueError) as cm:
- # create streams
- for i in range(128):
+ client_reader, client_writer = run(client.create_stream())
- client_reader, client_writer = run(client.create_stream())
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
+ self.assertEqual(str(cm.exception), "Too many streams open")
- # 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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # change connection ID
+ client._consume_connection_id()
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
- sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
- )
+ # the server provides a new connection ID
+ client._send_pending()
- # change connection ID
- client._consume_connection_id()
+ self.assertEqual(
- self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
- sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
+ )
- )
- # the server provides a new connection ID
- client._send_pending()
- self.assertEqual(
- sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
- )
-
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame_app
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> server.close(error_code=QuicErrorCode.NO_ERROR)
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del> self.assertEqual(client_transport.sent, 4)
<10>:<del> self.assertEqual(server_transport.sent, 3)
<11>:<del>
<12>:<del> # close
<13>:<del> server.close(error_code=QuicErrorCode.NO_ERROR)
<14>:<del> self.assertEqual(client_transport.sent, 4)
<15>:<del> self.assertEqual(server_transport.sent, 4)
<16>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # close
<13> server.close(error_code=QuicErrorCode.NO_ERROR)
<14> self.assertEqual(client_transport.sent, 4)
<15> self.assertEqual(server_transport.sent, 4)
<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
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
at: tests.test_connection.QuicConnectionTest.test_handle_max_stream_data_frame
stream = writer.transport
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
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
+ with client_and_server() as (client, server):
+ self.assertEqual(client._transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ # 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)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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())
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- self.assertEqual(server_transport.sent, 3)
+ # create one too many
+ with self.assertRaises(ValueError) as cm:
- # create streams
- for i in range(128):
+ client_reader, client_writer = run(client.create_stream())
- client_reader, client_writer = run(client.create_stream())
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
+ self.assertEqual(str(cm.exception), "Too many streams open")
- # 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")
-
|
tests.test_connection/QuicConnectionTest.test_handle_data_blocked_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives DATA_BLOCKED: 12345
<add> client._handle_data_blocked_frame(
<add> client_receive_context(client),
<add> QuicFrameType.DATA_BLOCKED,
<add> Buffer(data=encode_uint_var(12345)),
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<add> )
<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del>
<10>:<del> # client receives DATA_BLOCKED: 12345
<11>:<del> client._handle_data_blocked_frame(
<12>:<del> client_receive_context(client),
<13>:<del> QuicFrameType.DATA_BLOCKED,
<14>:<del> Buffer(data=encode_uint_var(12345)),
<15>:<del> )
<16>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_data_blocked_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives DATA_BLOCKED: 12345
<11> client._handle_data_blocked_frame(
<12> client_receive_context(client),
<13> QuicFrameType.DATA_BLOCKED,
<14> Buffer(data=encode_uint_var(12345)),
<15> )
<16>
|
===========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
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 3===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
+ with client_and_server() as (client, server):
+ self.assertEqual(client._transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ # 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)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._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):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ 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())
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- self.assertEqual(server_transport.sent, 3)
+ # create one too many
+ with self.assertRaises(ValueError) as cm:
- # create streams
- for i in range(128):
+ client_reader, client_writer = run(client.create_stream())
- client_reader, client_writer = run(client.create_stream())
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
+ self.assertEqual(str(cm.exception), "Too many streams open")
- # 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")
-
|
tests.test_connection/QuicConnectionTest.test_handle_max_data_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(client._remote_max_data, 1048576)
<7>:<add> # client receives MAX_DATA raising limit
<add> client._handle_max_data_frame(
<add> client_receive_context(client),
<add> QuicFrameType.MAX_DATA,
<add> Buffer(data=encode_uint_var(1048577)),
<add> )
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> self.assertEqual(client._remote_max_data, 1048577)
<del> self.assertEqual(client._remote_max_data, 1048576)
<11>:<del> # client receives MAX_DATA raising limit
<12>:<del> client._handle_max_data_frame(
<13>:<del> client_receive_context(client),
<14>:<del> QuicFrameType.MAX_DATA,
<15>:<del> Buffer(data=encode_uint_var(1048577)),
<16>:<del> )
<17>:<del> self.assertEqual(client._remote_max_data, 1048577)
<18>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client._remote_max_data, 1048576)
<10>
<11> # client receives MAX_DATA raising limit
<12> client._handle_max_data_frame(
<13> client_receive_context(client),
<14> QuicFrameType.MAX_DATA,
<15> Buffer(data=encode_uint_var(1048577)),
<16> )
<17> self.assertEqual(client._remote_max_data, 1048577)
<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
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 4===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
+ with client_and_server() as (client, server):
+ self.assertEqual(client._transport.sent, 4)
+ self.assertEqual(server._transport.sent, 3)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ # 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)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._transport.sent, 4)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server._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)
-
|
tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # client creates bidirectional stream 0
<add> reader, writer = run(client.create_stream())
<add> stream = writer.transport
<add> self.assertEqual(stream.max_stream_data_remote, 1048576)
<7>:<add> # client receives MAX_STREAM_DATA raising limit
<add> client._handle_max_stream_data_frame(
<add> client_receive_context(client),
<add> QuicFrameType.MAX_STREAM_DATA,
<add> Buffer(data=b"\x00" + encode_uint_var(1048577)),
<add> )
<add> self.assertEqual(stream.max_stream_data_remote, 1048577)
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<add> # client receives MAX_STREAM_DATA lowering limit
<add> client._handle_max_stream_data_frame(
<add> client_receive_context(client),
<add> QuicFrameType.MAX_STREAM_DATA,
<add> Buffer(data=b"\x
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client creates bidirectional stream 0
<11> reader, writer = run(client.create_stream())
<12> stream = writer.transport
<13> self.assertEqual(stream.max_stream_data_remote, 1048576)
<14>
<15> # client receives MAX_STREAM_DATA raising limit
<16> client._handle_max_stream_data_frame(
<17> client_receive_context(client),
<18> QuicFrameType.MAX_STREAM_DATA,
<19> Buffer(data=b"\x00" + encode_uint_var(1048577)),
<20> )
<21> self.assertEqual(stream.max_stream_data_remote, 1048577)
<22>
<23> # client receives MAX_STREAM_DATA lowering limit
<24> client._handle_max_stream_data_frame(
<25> client_receive_context(client),
<26> QuicFrameType.MAX_STREAM_DATA,
<27> Buffer(data=b"\x00" + encode_uint_var(1048575)),
<28> )
<29> self.assertEqual(stream.max_stream_data_remote, 1048577)
<30>
|
===========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: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
at: tests.utils
run(coro)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ self.assertEqual(client._remote_max_data, 1048576)
+ # client receives MAX_DATA raising limit
+ client._handle_max_data_frame(
+ client_receive_context(client),
+ QuicFrameType.MAX_DATA,
+ Buffer(data=encode_uint_var(1048577)),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_data, 1048577)
- self.assertEqual(client._remote_max_data, 1048576)
- # client receives MAX_DATA raising limit
- client._handle_max_data_frame(
- client_receive_context(client),
- QuicFrameType.MAX_DATA,
- Buffer(data=encode_uint_var(1048577)),
- )
- self.assertEqual(client._remote_max_data, 1048577)
-
===========changed ref 5===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
|
tests.test_connection/QuicConnectionTest.test_handle_max_stream_data_frame_receive_only
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # server creates unidirectional stream 3
<add> run(server.create_stream(is_unidirectional=True))
<7>:<add> # client receives MAX_STREAM_DATA: 3, 1
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_max_stream_data_frame(
<add> client_receive_context(client),
<add> QuicFrameType.MAX_STREAM_DATA,
<add> Buffer(data=b"\x03\x01"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)
<add> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # server creates unidirectional stream 3
<11>:<del> run(server.create_stream(is_unidirectional=True))
<12>:<del>
<13>:<del> # client receives MAX_STREAM_DATA: 3, 1
<14>:<del> with self.assertRaises(QuicConnectionError) as cm:
<15>:<del> client._handle_max_stream_data_frame(
<16>:<del> client_receive_context(client),
<17>:<del> QuicFrameType.MAX_STREAM_DATA,
<18>:<del> Buffer(data=b"\x03\x01"),
<19>:<del> )
<20>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_stream_data_frame_receive_only(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # server creates unidirectional stream 3
<11> run(server.create_stream(is_unidirectional=True))
<12>
<13> # client receives MAX_STREAM_DATA: 3, 1
<14> with self.assertRaises(QuicConnectionError) as cm:
<15> client._handle_max_stream_data_frame(
<16> client_receive_context(client),
<17> QuicFrameType.MAX_STREAM_DATA,
<18> Buffer(data=b"\x03\x01"),
<19> )
<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.MAX_STREAM_DATA)
<22> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
<23>
|
===========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()
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ self.assertEqual(client._remote_max_data, 1048576)
+ # client receives MAX_DATA raising limit
+ client._handle_max_data_frame(
+ client_receive_context(client),
+ QuicFrameType.MAX_DATA,
+ Buffer(data=encode_uint_var(1048577)),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_data, 1048577)
- self.assertEqual(client._remote_max_data, 1048576)
- # client receives MAX_DATA raising limit
- client._handle_max_data_frame(
- client_receive_context(client),
- QuicFrameType.MAX_DATA,
- Buffer(data=encode_uint_var(1048577)),
- )
- self.assertEqual(client._remote_max_data, 1048577)
-
===========changed ref 5===========
# module: tests.test_connection
class FakeTransport:
+ loss = 0
sent = 0
target = None
===========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:
- if self.target is not None:
self.target.datagram_received(data, self.local_addr)
|
tests.test_connection/QuicConnectionTest.test_handle_max_streams_bidi_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(client._remote_max_streams_bidi, 128)
<7>:<add> # client receives MAX_STREAMS_BIDI raising limit
<add> client._handle_max_streams_bidi_frame(
<add> client_receive_context(client),
<add> QuicFrameType.MAX_STREAMS_BIDI,
<add> Buffer(data=encode_uint_var(129)),
<add> )
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> self.assertEqual(client._remote_max_streams_bidi, 129)
<del> self.assertEqual(client._remote_max_streams_bidi, 128)
<11>:<add> # client receives MAX_STREAMS_BIDI lowering limit
<del> # client receives MAX_STREAMS_BIDI raising limit
<12>:<add> client._handle_max_streams_bidi_frame(
<del> client._handle_max_streams_bidi_frame(
<13>:<add> client_receive_context(client),
<del> client_receive_context(client),
<14>:<add> QuicFrameType.MAX_STREAMS_BIDI,
<del> QuicFrameType.MAX_STREAMS_BIDI,
<15>:<add> Buffer(data=encode_uint_var(127)),
<del> Buffer(data=encode_uint_var(129)),
<16>:<add> )
<del> )
<17>:<add> self.assertEqual(
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_bidi_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client._remote_max_streams_bidi, 128)
<10>
<11> # client receives MAX_STREAMS_BIDI raising limit
<12> client._handle_max_streams_bidi_frame(
<13> client_receive_context(client),
<14> QuicFrameType.MAX_STREAMS_BIDI,
<15> Buffer(data=encode_uint_var(129)),
<16> )
<17> self.assertEqual(client._remote_max_streams_bidi, 129)
<18>
<19> # client receives MAX_STREAMS_BIDI lowering limit
<20> client._handle_max_streams_bidi_frame(
<21> client_receive_context(client),
<22> QuicFrameType.MAX_STREAMS_BIDI,
<23> Buffer(data=encode_uint_var(127)),
<24> )
<25> self.assertEqual(client._remote_max_streams_bidi, 129)
<26>
|
===========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()
sequence_numbers(connection_ids)
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ self.assertEqual(client._remote_max_data, 1048576)
+ # client receives MAX_DATA raising limit
+ client._handle_max_data_frame(
+ client_receive_context(client),
+ QuicFrameType.MAX_DATA,
+ Buffer(data=encode_uint_var(1048577)),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_data, 1048577)
- self.assertEqual(client._remote_max_data, 1048576)
- # client receives MAX_DATA raising limit
- client._handle_max_data_frame(
- client_receive_context(client),
- QuicFrameType.MAX_DATA,
- Buffer(data=encode_uint_var(1048577)),
- )
- self.assertEqual(client._remote_max_data, 1048577)
-
|
tests.test_connection/QuicConnectionTest.test_handle_max_streams_uni_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(client._remote_max_streams_uni, 128)
<7>:<add> # client receives MAX_STREAMS_UNI raising limit
<add> client._handle_max_streams_uni_frame(
<add> client_receive_context(client),
<add> QuicFrameType.MAX_STREAMS_UNI,
<add> Buffer(data=encode_uint_var(129)),
<add> )
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> self.assertEqual(client._remote_max_streams_uni, 129)
<del> self.assertEqual(client._remote_max_streams_uni, 128)
<11>:<add> # client receives MAX_STREAMS_UNI raising limit
<del> # client receives MAX_STREAMS_UNI raising limit
<12>:<add> client._handle_max_streams_uni_frame(
<del> client._handle_max_streams_uni_frame(
<13>:<add> client_receive_context(client),
<del> client_receive_context(client),
<14>:<add> QuicFrameType.MAX_STREAMS_UNI,
<del> QuicFrameType.MAX_STREAMS_UNI,
<15>:<add> Buffer(data=encode_uint_var(127)),
<del> Buffer(data=encode_uint_var(129)),
<16>:<add> )
<del> )
<17>:<add> self.assertEqual(client._remote_max
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_streams_uni_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client._remote_max_streams_uni, 128)
<10>
<11> # client receives MAX_STREAMS_UNI raising limit
<12> client._handle_max_streams_uni_frame(
<13> client_receive_context(client),
<14> QuicFrameType.MAX_STREAMS_UNI,
<15> Buffer(data=encode_uint_var(129)),
<16> )
<17> self.assertEqual(client._remote_max_streams_uni, 129)
<18>
<19> # client receives MAX_STREAMS_UNI raising limit
<20> client._handle_max_streams_uni_frame(
<21> client_receive_context(client),
<22> QuicFrameType.MAX_STREAMS_UNI,
<23> Buffer(data=encode_uint_var(127)),
<24> )
<25> self.assertEqual(client._remote_max_streams_uni, 129)
<26>
|
===========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
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
sequence_numbers(connection_ids)
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ self.assertEqual(client._remote_max_data, 1048576)
+ # client receives MAX_DATA raising limit
+ client._handle_max_data_frame(
+ client_receive_context(client),
+ QuicFrameType.MAX_DATA,
+ Buffer(data=encode_uint_var(1048577)),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_data, 1048577)
- self.assertEqual(client._remote_max_data, 1048576)
- # client receives MAX_DATA raising limit
- client._handle_max_data_frame(
- client_receive_context(client),
- QuicFrameType.MAX_DATA,
- Buffer(data=encode_uint_var(1048577)),
- )
- self.assertEqual(client._remote_max_data, 1048577)
-
|
tests.test_connection/QuicConnectionTest.test_handle_new_token_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives NEW_TOKEN
<add> client._handle_new_token_frame(
<add> client_receive_context(client),
<add> QuicFrameType.NEW_TOKEN,
<add> Buffer(data=binascii.unhexlify("080102030405060708")),
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<add> )
<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del>
<10>:<del> # client receives NEW_TOKEN
<11>:<del> client._handle_new_token_frame(
<12>:<del> client_receive_context(client),
<13>:<del> QuicFrameType.NEW_TOKEN,
<14>:<del> Buffer(data=binascii.unhexlify("080102030405060708")),
<15>:<del> )
<16>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives NEW_TOKEN
<11> client._handle_new_token_frame(
<12> client_receive_context(client),
<13> QuicFrameType.NEW_TOKEN,
<14> Buffer(data=binascii.unhexlify("080102030405060708")),
<15> )
<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
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()
at: tests.utils
run(coro)
at: unittest.case.TestCase
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
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ self.assertEqual(client._remote_max_data, 1048576)
+ # client receives MAX_DATA raising limit
+ client._handle_max_data_frame(
+ client_receive_context(client),
+ QuicFrameType.MAX_DATA,
+ Buffer(data=encode_uint_var(1048577)),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_data, 1048577)
- self.assertEqual(client._remote_max_data, 1048576)
- # client receives MAX_DATA raising limit
- client._handle_max_data_frame(
- client_receive_context(client),
- QuicFrameType.MAX_DATA,
- Buffer(data=encode_uint_var(1048577)),
- )
- self.assertEqual(client._remote_max_data, 1048577)
-
|
tests.test_connection/QuicConnectionTest.test_handle_path_challenge_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client changes address and sends some data
<add> client._transport.local_addr = ("1.2.3.4", 2345)
<add> reader, writer = run(client.create_stream())
<add> writer.write(b"01234567")
<add> run(asyncio.sleep(0))
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<7>:<add> # server sends PATH_CHALLENGE and receives PATH_RESPONSE
<add> self.assertEqual(len(server._network_paths), 2)
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client changes address and sends some data
<11>:<del> client_transport.local_addr = ("1.2.3.4", 2345)
<12>:<del> reader, writer = run(client.create_stream())
<13>:<del> writer.write(b"01234567")
<14>:<del> run(asyncio.sleep(0))
<15>:<add> # check new path
<add> self.assertEqual(server._network_paths[0].addr, ("1.2.3.4", 2345))
<add> self.assertTrue(server._network_paths[0].is_validated)
<16>:<add> # check old path
<del> # server sends PATH_CHALLENGE and receives PATH_RESPONSE
<17>:<add> self.assertEqual(server._network_paths[1].addr, ("1.2.3.4", 1234))
<del> self.assertEqual(len(server._network_paths), 2)
<18>:<add> self.
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_challenge_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client changes address and sends some data
<11> client_transport.local_addr = ("1.2.3.4", 2345)
<12> reader, writer = run(client.create_stream())
<13> writer.write(b"01234567")
<14> run(asyncio.sleep(0))
<15>
<16> # server sends PATH_CHALLENGE and receives PATH_RESPONSE
<17> self.assertEqual(len(server._network_paths), 2)
<18>
<19> # check new path
<20> self.assertEqual(server._network_paths[0].addr, ("1.2.3.4", 2345))
<21> self.assertTrue(server._network_paths[0].is_validated)
<22>
<23> # check old path
<24> self.assertEqual(server._network_paths[1].addr, ("1.2.3.4", 1234))
<25> self.assertTrue(server._network_paths[1].is_validated)
<26>
|
===========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)
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
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
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ self.assertEqual(client._remote_max_data, 1048576)
+ # client receives MAX_DATA raising limit
+ client._handle_max_data_frame(
+ client_receive_context(client),
+ QuicFrameType.MAX_DATA,
+ Buffer(data=encode_uint_var(1048577)),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_data, 1048577)
- self.assertEqual(client._remote_max_data, 1048576)
- # client receives MAX_DATA raising limit
- client._handle_max_data_frame(
- client_receive_context(client),
- QuicFrameType.MAX_DATA,
- Buffer(data=encode_uint_var(1048577)),
- )
- self.assertEqual(client._remote_max_data, 1048577)
-
|
tests.test_connection/QuicConnectionTest.test_handle_path_response_frame_bad
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # server receives unsollicited PATH_RESPONSE
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> server._handle_path_response_frame(
<add> client_receive_context(client),
<add> QuicFrameType.PATH_RESPONSE,
<add> Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del>
<10>:<del> # server receives unsollicited PATH_RESPONSE
<11>:<del> with self.assertRaises(QuicConnectionError) as cm:
<12>:<del> server._handle_path_response_frame(
<13>:<del> client_receive_context(client),
<14>:<del> QuicFrameType.PATH_RESPONSE,
<15>:<del> Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
<16>:<del> )
<17>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<18>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
<19>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # server receives unsollicited PATH_RESPONSE
<11> with self.assertRaises(QuicConnectionError) as cm:
<12> server._handle_path_response_frame(
<13> client_receive_context(client),
<14> QuicFrameType.PATH_RESPONSE,
<15> Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
<16> )
<17> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<18> self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
<19>
|
===========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: tests.test_connection.QuicConnectionTest.test_handle_stream_frame_over_max_stream_data
frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
stream_id = 1
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
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ server.close(
+ error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(
- error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
- )
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_max_data_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ self.assertEqual(client._remote_max_data, 1048576)
+ # client receives MAX_DATA raising limit
+ client._handle_max_data_frame(
+ client_receive_context(client),
+ QuicFrameType.MAX_DATA,
+ Buffer(data=encode_uint_var(1048577)),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client._remote_max_data, 1048577)
- self.assertEqual(client._remote_max_data, 1048576)
- # client receives MAX_DATA raising limit
- client._handle_max_data_frame(
- client_receive_context(client),
- QuicFrameType.MAX_DATA,
- Buffer(data=encode_uint_var(1048577)),
- )
- self.assertEqual(client._remote_max_data, 1048577)
-
|
tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # client creates bidirectional stream 0
<add> run(client.create_stream())
<7>:<add> # client receives RESET_STREAM
<add> client._handle_reset_stream_frame(
<add> client_receive_context(client),
<add> QuicFrameType.RESET_STREAM,
<add> Buffer(data=binascii.unhexlify("00112200")),
<add> )
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client creates bidirectional stream 0
<11>:<del> run(client.create_stream())
<12>:<del>
<13>:<del> # client receives RESET_STREAM
<14>:<del> client._handle_reset_stream_frame(
<15>:<del> client_receive_context(client),
<16>:<del> QuicFrameType.RESET_STREAM,
<17>:<del> Buffer(data=binascii.unhexlify("00112200")),
<18>:<del> )
<19>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client creates bidirectional stream 0
<11> run(client.create_stream())
<12>
<13> # client receives RESET_STREAM
<14> client._handle_reset_stream_frame(
<15> client_receive_context(client),
<16> QuicFrameType.RESET_STREAM,
<17> Buffer(data=binascii.unhexlify("00112200")),
<18> )
<19>
|
===========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
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
+ with client_and_server() as (client, server):
+ # server receives unsollicited PATH_RESPONSE
+ with self.assertRaises(QuicConnectionError) as cm:
+ server._handle_path_response_frame(
+ client_receive_context(client),
+ QuicFrameType.PATH_RESPONSE,
+ Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # server receives unsollicited PATH_RESPONSE
- with self.assertRaises(QuicConnectionError) as cm:
- server._handle_path_response_frame(
- client_receive_context(client),
- QuicFrameType.PATH_RESPONSE,
- Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # 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_handle_data_blocked_frame(self):
+ with client_and_server() as (client, server):
+ # client receives DATA_BLOCKED: 12345
+ client._handle_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.DATA_BLOCKED,
+ Buffer(data=encode_uint_var(12345)),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives DATA_BLOCKED: 12345
- client._handle_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.DATA_BLOCKED,
- Buffer(data=encode_uint_var(12345)),
- )
-
|
tests.test_connection/QuicConnectionTest.test_handle_reset_stream_frame_send_only
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # client creates unidirectional stream 2
<add> run(client.create_stream(is_unidirectional=True))
<7>:<add> # client receives RESET_STREAM
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_reset_stream_frame(
<add> client_receive_context(client),
<add> QuicFrameType.RESET_STREAM,
<add> Buffer(data=binascii.unhexlify("02112200")),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)
<add> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client creates unidirectional stream 2
<11>:<del> run(client.create_stream(is_unidirectional=True))
<12>:<del>
<13>:<del> # client receives RESET_STREAM
<14>:<del> with self.assertRaises(QuicConnectionError) as cm:
<15>:<del> client._handle_reset_stream_frame(
<16>:<del> client_receive_context(client),
<17>:<del> QuicFrameType.RESET_STREAM,
<18>:<del> Buffer(data=binascii.unhexlify("02112200")),
<19>:<del> )
<20>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)
<22>:<del> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<23>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame_send_only(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client creates unidirectional stream 2
<11> run(client.create_stream(is_unidirectional=True))
<12>
<13> # client receives RESET_STREAM
<14> with self.assertRaises(QuicConnectionError) as cm:
<15> client._handle_reset_stream_frame(
<16> client_receive_context(client),
<17> QuicFrameType.RESET_STREAM,
<18> Buffer(data=binascii.unhexlify("02112200")),
<19> )
<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.RESET_STREAM)
<22> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<23>
|
===========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
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
+ with client_and_server() as (client, server):
+ # server receives unsollicited PATH_RESPONSE
+ with self.assertRaises(QuicConnectionError) as cm:
+ server._handle_path_response_frame(
+ client_receive_context(client),
+ QuicFrameType.PATH_RESPONSE,
+ Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # server receives unsollicited PATH_RESPONSE
- with self.assertRaises(QuicConnectionError) as cm:
- server._handle_path_response_frame(
- client_receive_context(client),
- QuicFrameType.PATH_RESPONSE,
- Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ server.close(error_code=QuicErrorCode.NO_ERROR)
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
-
- # close
- server.close(error_code=QuicErrorCode.NO_ERROR)
- self.assertEqual(client_transport.sent, 4)
- self.assertEqual(server_transport.sent, 4)
-
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<add> with client_and_server() as (client, server):
<add> self.assertEqual(
<add> sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
<add> )
<del> )
<7>:<add> # client receives RETIRE_CONNECTION_ID
<add> client._handle_retire_connection_id_frame(
<add> client_receive_context(client),
<add> QuicFrameType.RETIRE_CONNECTION_ID,
<add> Buffer(data=b"\x02"),
<add> )
<add> self.assertEqual(
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<add> sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
<del> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7])
<10>:<add> )
<11>:<del> # client receives RETIRE_CONNECTION_ID
<12>:<del> client._handle_retire_connection_id_frame(
<13>:<del> client_receive_context(client),
<14>:<del> QuicFrameType.RETIRE_CONNECTION_ID,
<15>:<del> Buffer(data=b"\x02"),
<16>:<del> )
<17>:<del> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8])
<18>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7])
<10>
<11> # client receives RETIRE_CONNECTION_ID
<12> client._handle_retire_connection_id_frame(
<13> client_receive_context(client),
<14> QuicFrameType.RETIRE_CONNECTION_ID,
<15> Buffer(data=b"\x02"),
<16> )
<17> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8])
<18>
|
===========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
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
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
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
+ with client_and_server() as (client, server):
+ # server receives unsollicited PATH_RESPONSE
+ with self.assertRaises(QuicConnectionError) as cm:
+ server._handle_path_response_frame(
+ client_receive_context(client),
+ QuicFrameType.PATH_RESPONSE,
+ Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # server receives unsollicited PATH_RESPONSE
- with self.assertRaises(QuicConnectionError) as cm:
- server._handle_path_response_frame(
- client_receive_context(client),
- QuicFrameType.PATH_RESPONSE,
- Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
-
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame_current_cid
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives RETIRE_CONNECTION_ID for the current CID
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_retire_connection_id_frame(
<add> client_receive_context(client),
<add> QuicFrameType.RETIRE_CONNECTION_ID,
<add> Buffer(data=b"\x00"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<add> self.assertEqual(
<add> cm.exception.frame_type, QuicFrameType.RETIRE_CONNECTION_ID
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<add> )
<del> )
<6>:<add> self.assertEqual(
<add> cm.exception.reason_phrase, "Cannot retire current connection ID"
<add> )
<add> self.assertEqual(
<add> sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7]
<add>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame_current_cid(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives RETIRE_CONNECTION_ID for the current CID
<11> with self.assertRaises(QuicConnectionError) as cm:
<12> client._handle_retire_connection_id_frame(
<13> client_receive_context(client),
<14> QuicFrameType.RETIRE_CONNECTION_ID,
<15> Buffer(data=b"\x00"),
<16> )
<17> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<18> self.assertEqual(cm.exception.frame_type, QuicFrameType.RETIRE_CONNECTION_ID)
<19> self.assertEqual(
<20> cm.exception.reason_phrase, "Cannot retire current connection ID"
<21> )
<22> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7])
<23>
|
===========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
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
client_and_server()
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: 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
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ 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(
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
- 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 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
+ with client_and_server() as (client, server):
+ # server receives unsollicited PATH_RESPONSE
+ with self.assertRaises(QuicConnectionError) as cm:
+ server._handle_path_response_frame(
+ client_receive_context(client),
+ QuicFrameType.PATH_RESPONSE,
+ Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # server receives unsollicited PATH_RESPONSE
- with self.assertRaises(QuicConnectionError) as cm:
- server._handle_path_response_frame(
- client_receive_context(client),
- QuicFrameType.PATH_RESPONSE,
- Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
-
|
tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # client creates bidirectional stream 0
<add> run(client.create_stream())
<7>:<add> # client receives STOP_SENDING
<add> client._handle_stop_sending_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STOP_SENDING,
<add> Buffer(data=b"\x00\x11\x22"),
<add> )
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client creates bidirectional stream 0
<11>:<del> run(client.create_stream())
<12>:<del>
<13>:<del> # client receives STOP_SENDING
<14>:<del> client._handle_stop_sending_frame(
<15>:<del> client_receive_context(client),
<16>:<del> QuicFrameType.STOP_SENDING,
<17>:<del> Buffer(data=b"\x00\x11\x22"),
<18>:<del> )
<19>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client creates bidirectional stream 0
<11> run(client.create_stream())
<12>
<13> # client receives STOP_SENDING
<14> client._handle_stop_sending_frame(
<15> client_receive_context(client),
<16> QuicFrameType.STOP_SENDING,
<17> Buffer(data=b"\x00\x11\x22"),
<18> )
<19>
|
===========unchanged ref 0===========
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: aioquic.tls
Epoch()
at: tests.test_connection
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
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ 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(
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
- 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 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_path_response_frame_bad(self):
+ with client_and_server() as (client, server):
+ # server receives unsollicited PATH_RESPONSE
+ with self.assertRaises(QuicConnectionError) as cm:
+ server._handle_path_response_frame(
+ client_receive_context(client),
+ QuicFrameType.PATH_RESPONSE,
+ Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # server receives unsollicited PATH_RESPONSE
- with self.assertRaises(QuicConnectionError) as cm:
- server._handle_path_response_frame(
- client_receive_context(client),
- QuicFrameType.PATH_RESPONSE,
- Buffer(data=b"\x11\x22\x33\x44\x55\x66\x77\x88"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.PATH_RESPONSE)
-
|
tests.test_connection/QuicConnectionTest.test_handle_stop_sending_frame_receive_only
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # server creates unidirectional stream 3
<add> run(server.create_stream(is_unidirectional=True))
<7>:<add> # client receives STOP_SENDING
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_stop_sending_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STOP_SENDING,
<add> Buffer(data=b"\x03\x11\x22"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING)
<add> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # server creates unidirectional stream 3
<11>:<del> run(server.create_stream(is_unidirectional=True))
<12>:<del>
<13>:<del> # client receives STOP_SENDING
<14>:<del> with self.assertRaises(QuicConnectionError) as cm:
<15>:<del> client._handle_stop_sending_frame(
<16>:<del> client_receive_context(client),
<17>:<del> QuicFrameType.STOP_SENDING,
<18>:<del> Buffer(data=b"\x03\x11\x22"),
<19>:<del> )
<20>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING)
<22>:<del> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
<23>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame_receive_only(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # server creates unidirectional stream 3
<11> run(server.create_stream(is_unidirectional=True))
<12>
<13> # client receives STOP_SENDING
<14> with self.assertRaises(QuicConnectionError) as cm:
<15> client._handle_stop_sending_frame(
<16> client_receive_context(client),
<17> QuicFrameType.STOP_SENDING,
<18> Buffer(data=b"\x03\x11\x22"),
<19> )
<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STOP_SENDING)
<22> self.assertEqual(cm.exception.reason_phrase, "Stream is receive-only")
<23>
|
===========unchanged ref 0===========
at: tests.test_connection
client_and_server()
at: unittest.case.TestCase
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
+ @contextlib.contextmanager
+ def client_and_server():
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False, certificate=SERVER_CERTIFICATE, private_key=SERVER_PRIVATE_KEY
+ )
+
+ # perform handshake
+ create_transport(client, server)
+
+ yield client, server
+ client.close()
+ server.close()
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ 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(
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
- 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])
-
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_data
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # artificially raise received data counter
<add> client._local_max_data_used = client._local_max_data
<7>:<add> # client receives STREAM frame
<add> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
<add> stream_id = 1
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_stream_frame(
<add> client_receive_context(client),
<add> frame_type,
<add> Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)
<add> self.assertEqual(cm.exception.frame_type, frame_type)
<add> self.assertEqual(cm.exception.reason_phrase, "Over connection data limit")
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # artificially raise received data counter
<11>:<del> client._local_max_data_used = client._local_max_data
<12>:<del>
<13>:<del> # client receives STREAM frame
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_data(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # artificially raise received data counter
<11> client._local_max_data_used = client._local_max_data
<12>
<13> # client receives STREAM frame
<14> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
<15> stream_id = 1
<16> with self.assertRaises(QuicConnectionError) as cm:
<17> client._handle_stream_frame(
<18> client_receive_context(client),
<19> frame_type,
<20> Buffer(data=encode_uint_var(stream_id) + encode_uint_var(1)),
<21> )
<22> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)
<23> self.assertEqual(cm.exception.frame_type, frame_type)
<24> self.assertEqual(cm.exception.reason_phrase, "Over connection data limit")
<25>
|
===========unchanged ref 0===========
at: aioquic.packet
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: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ 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(
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
- 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])
-
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_stream_data
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives STREAM frame
<add> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
<add> stream_id = 1
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_stream_frame(
<add> client_receive_context(client),
<add> frame_type,
<add> Buffer(
<add> data=encode_uint_var(stream_id)
<add> + encode_uint_var(client._local_max_stream_data_bidi_remote + 1)
<add> ),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)
<add> self.assertEqual(cm.exception.frame_type, frame_type)
<add> self.assertEqual(cm.exception.reason_phrase, "Over stream data limit")
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del>
<10>:<del> # client receives STREAM frame
<11>:<del> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
<12>:<del> stream_id = 1
<13>:<del> with self.assertRaises(QuicConnectionError) as cm:
<14>:<del> client._handle_stream_frame(
<15>:<del> client_receive_context(client),
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_stream_data(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives STREAM frame
<11> frame_type = QuicFrameType.STREAM_BASE | QuicStreamFlag.OFF
<12> stream_id = 1
<13> with self.assertRaises(QuicConnectionError) as cm:
<14> client._handle_stream_frame(
<15> client_receive_context(client),
<16> frame_type,
<17> Buffer(
<18> data=encode_uint_var(stream_id)
<19> + encode_uint_var(client._local_max_stream_data_bidi_remote + 1)
<20> ),
<21> )
<22> self.assertEqual(cm.exception.error_code, QuicErrorCode.FLOW_CONTROL_ERROR)
<23> self.assertEqual(cm.exception.frame_type, frame_type)
<24> self.assertEqual(cm.exception.reason_phrase, "Over stream data limit")
<25>
|
===========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.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
can_send(size: int) -> bool
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
at: tests.test_connection.QuicConnectionTest.test_version_negotiation_ok
client, client_transport = create_standalone_client()
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ with client_and_server() as (client, server):
+ 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(
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
+ sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8]
- 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])
-
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_over_max_streams
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives STREAM frame
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_stream_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STREAM_BASE,
<add> Buffer(
<add> data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)
<add> ),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<add> self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del>
<10>:<del> # client receives STREAM frame
<11>:<del> with self.assertRaises(QuicConnectionError) as cm:
<12>:<del> client._handle_stream_frame(
<13>:<del> client_receive_context(client),
<14>:<del> QuicFrameType.STREAM_BASE,
<15>:<del> Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),
<16>:<del> )
<17>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
<18>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<19>:<del> self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
<20>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_streams(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives STREAM frame
<11> with self.assertRaises(QuicConnectionError) as cm:
<12> client._handle_stream_frame(
<13> client_receive_context(client),
<14> QuicFrameType.STREAM_BASE,
<15> Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),
<16> )
<17> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
<18> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<19> self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
<20>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicNetworkPath
can_send(size: int) -> bool
at: tests.test_connection.QuicNetworkPathTest.test_can_send
path = QuicNetworkPath(("1.2.3.4", 1234))
at: unittest.case.TestCase
assertFalse(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_stream_data(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ 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(client._local_max_stream_data_bidi_remote + 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 stream data limit")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- 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(client._local_max_stream_data_bidi_remote + 1)
- ),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.</s>
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_stream_data(self):
# offset: 1
<s>)
- ),
- )
- 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 stream data limit")
-
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_send_only
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # client creates unidirectional stream 2
<add> run(client.create_stream(is_unidirectional=True))
<7>:<add> # client receives STREAM frame
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_stream_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STREAM_BASE,
<add> Buffer(data=b"\x02"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<add> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client creates unidirectional stream 2
<11>:<del> run(client.create_stream(is_unidirectional=True))
<12>:<del>
<13>:<del> # client receives STREAM frame
<14>:<del> with self.assertRaises(QuicConnectionError) as cm:
<15>:<del> client._handle_stream_frame(
<16>:<del> client_receive_context(client),
<17>:<del> QuicFrameType.STREAM_BASE,
<18>:<del> Buffer(data=b"\x02"),
<19>:<del> )
<20>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<22>:<del> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<23>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_send_only(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client creates unidirectional stream 2
<11> run(client.create_stream(is_unidirectional=True))
<12>
<13> # client receives STREAM frame
<14> with self.assertRaises(QuicConnectionError) as cm:
<15> client._handle_stream_frame(
<16> client_receive_context(client),
<17> QuicFrameType.STREAM_BASE,
<18> Buffer(data=b"\x02"),
<19> )
<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<22> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<23>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_streams(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(
+ data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)
+ ),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_stream_data(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ 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(client._local_max_stream_data_bidi_remote + 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 stream data limit")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- 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(client._local_max_stream_data_bidi_remote + 1)
- ),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.</s>
|
tests.test_connection/QuicConnectionTest.test_handle_stream_frame_wrong_initiator
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives STREAM frame
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_stream_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STREAM_BASE,
<add> Buffer(data=b"\x00"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<add> self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del>
<10>:<del> # client receives STREAM frame
<11>:<del> with self.assertRaises(QuicConnectionError) as cm:
<12>:<del> client._handle_stream_frame(
<13>:<del> client_receive_context(client),
<14>:<del> QuicFrameType.STREAM_BASE,
<15>:<del> Buffer(data=b"\x00"),
<16>:<del> )
<17>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<18>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<19>:<del> self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
<20>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_wrong_initiator(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives STREAM frame
<11> with self.assertRaises(QuicConnectionError) as cm:
<12> client._handle_stream_frame(
<13> client_receive_context(client),
<14> QuicFrameType.STREAM_BASE,
<15> Buffer(data=b"\x00"),
<16> )
<17> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<18> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
<19> self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
<20>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_send_only(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates unidirectional stream 2
+ run(client.create_stream(is_unidirectional=True))
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x02"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates unidirectional stream 2
- run(client.create_stream(is_unidirectional=True))
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x02"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_streams(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(
+ data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)
+ ),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_reset_stream_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives RESET_STREAM
+ client._handle_reset_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.RESET_STREAM,
+ Buffer(data=binascii.unhexlify("00112200")),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives RESET_STREAM
- client._handle_reset_stream_frame(
- client_receive_context(client),
- QuicFrameType.RESET_STREAM,
- Buffer(data=binascii.unhexlify("00112200")),
- )
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_new_token_frame(self):
+ with client_and_server() as (client, server):
+ # client receives NEW_TOKEN
+ client._handle_new_token_frame(
+ client_receive_context(client),
+ QuicFrameType.NEW_TOKEN,
+ Buffer(data=binascii.unhexlify("080102030405060708")),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_TOKEN
- client._handle_new_token_frame(
- client_receive_context(client),
- QuicFrameType.NEW_TOKEN,
- Buffer(data=binascii.unhexlify("080102030405060708")),
- )
-
|
tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # client creates bidirectional stream 0
<add> run(client.create_stream())
<7>:<add> # client receives STREAM_DATA_BLOCKED
<add> client._handle_stream_data_blocked_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STREAM_DATA_BLOCKED,
<add> Buffer(data=b"\x00\x01"),
<add> )
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client creates bidirectional stream 0
<11>:<del> run(client.create_stream())
<12>:<del>
<13>:<del> # client receives STREAM_DATA_BLOCKED
<14>:<del> client._handle_stream_data_blocked_frame(
<15>:<del> client_receive_context(client),
<16>:<del> QuicFrameType.STREAM_DATA_BLOCKED,
<17>:<del> Buffer(data=b"\x00\x01"),
<18>:<del> )
<19>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client creates bidirectional stream 0
<11> run(client.create_stream())
<12>
<13> # client receives STREAM_DATA_BLOCKED
<14> client._handle_stream_data_blocked_frame(
<15> client_receive_context(client),
<16> QuicFrameType.STREAM_DATA_BLOCKED,
<17> Buffer(data=b"\x00\x01"),
<18> )
<19>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_wrong_initiator(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x00"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x00"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_send_only(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates unidirectional stream 2
+ run(client.create_stream(is_unidirectional=True))
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x02"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates unidirectional stream 2
- run(client.create_stream(is_unidirectional=True))
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x02"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_over_max_streams(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(
+ data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)
+ ),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=encode_uint_var(client._local_max_stream_data_uni * 4 + 3)),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_LIMIT_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Too many streams open")
-
|
tests.test_connection/QuicConnectionTest.test_handle_stream_data_blocked_frame_send_only
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<6>:<add> with client_and_server() as (client, server):
<add> # client creates unidirectional stream 2
<add> run(client.create_stream(is_unidirectional=True))
<7>:<add> # client receives STREAM_DATA_BLOCKED
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._handle_stream_data_blocked_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STREAM_DATA_BLOCKED,
<add> Buffer(data=b"\x02\x01"),
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)
<add> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del> # client creates unidirectional stream 2
<11>:<del> run(client.create_stream(is_unidirectional=True))
<12>:<del>
<13>:<del> # client receives STREAM_DATA_BLOCKED
<14>:<del> with self.assertRaises(QuicConnectionError) as cm:
<15>:<del> client._handle_stream_data_blocked_frame(
<16>:<del> client_receive_context(client),
<17>:<del> QuicFrameType.STREAM_DATA_BLOCKED,
<18>:<del> Buffer(data=b"\x02\x01"),
<19>:<del> )
<20>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame_send_only(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client creates unidirectional stream 2
<11> run(client.create_stream(is_unidirectional=True))
<12>
<13> # client receives STREAM_DATA_BLOCKED
<14> with self.assertRaises(QuicConnectionError) as cm:
<15> client._handle_stream_data_blocked_frame(
<16> client_receive_context(client),
<17> QuicFrameType.STREAM_DATA_BLOCKED,
<18> Buffer(data=b"\x02\x01"),
<19> )
<20> self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
<21> self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)
<22> self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
<23>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STREAM_DATA_BLOCKED
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x00\x01"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STREAM_DATA_BLOCKED
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x00\x01"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_wrong_initiator(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x00"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x00"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_send_only(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates unidirectional stream 2
+ run(client.create_stream(is_unidirectional=True))
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x02"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates unidirectional stream 2
- run(client.create_stream(is_unidirectional=True))
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x02"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
-
|
tests.test_connection/QuicConnectionTest.test_handle_streams_blocked_uni_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives STREAMS_BLOCKED_UNI: 0
<add> client._handle_streams_blocked_frame(
<add> client_receive_context(client),
<add> QuicFrameType.STREAMS_BLOCKED_UNI,
<add> Buffer(data=b"\x00"),
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<add> )
<del> )
<7>:<del> # perform handshake
<8>:<del> client_transport, server_transport = create_transport(client, server)
<9>:<del>
<10>:<del> # client receives STREAMS_BLOCKED_UNI: 0
<11>:<del> client._handle_streams_blocked_frame(
<12>:<del> client_receive_context(client),
<13>:<del> QuicFrameType.STREAMS_BLOCKED_UNI,
<14>:<del> Buffer(data=b"\x00"),
<15>:<del> )
<16>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives STREAMS_BLOCKED_UNI: 0
<11> client._handle_streams_blocked_frame(
<12> client_receive_context(client),
<13> QuicFrameType.STREAMS_BLOCKED_UNI,
<14> Buffer(data=b"\x00"),
<15> )
<16>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STREAM_DATA_BLOCKED
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x00\x01"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STREAM_DATA_BLOCKED
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x00\x01"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_wrong_initiator(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x00"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x00"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame_send_only(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates unidirectional stream 2
+ run(client.create_stream(is_unidirectional=True))
+ # client receives STREAM_DATA_BLOCKED
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x02\x01"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates unidirectional stream 2
- run(client.create_stream(is_unidirectional=True))
-
- # client receives STREAM_DATA_BLOCKED
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x02\x01"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA</s>
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame_send_only(self):
# offset: 1
<s>STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)
- self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
-
|
tests.test_connection/QuicConnectionTest.test_payload_received_padding_only
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives padding only
<add> is_ack_eliciting, is_probing = client._payload_received(
<add> client_receive_context(client), b"\x00" * 1200
<add> )
<add> self.assertFalse(is_ack_eliciting)
<add> self.assertTrue(is_probing)
<del> client = QuicConnection(is_client=True)
<2>:<del> server = QuicConnection(
<3>:<del> is_client=False,
<4>:<del> certificate=SERVER_CERTIFICATE,
<5>:<del> private_key=SERVER_PRIVATE_KEY,
<6>:<del> )
<7>:<del>
<8>:<del> # perform handshake
<9>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del>
<11>:<del> # client receives padding only
<12>:<del> is_ack_eliciting, is_probing = client._payload_received(
<13>:<del> client_receive_context(client), b"\x00" * 1200
<14>:<del> )
<15>:<del> self.assertFalse(is_ack_eliciting)
<16>:<del> self.assertTrue(is_probing)
<17>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_padding_only(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10>
<11> # client receives padding only
<12> is_ack_eliciting, is_probing = client._payload_received(
<13> client_receive_context(client), b"\x00" * 1200
<14> )
<15> self.assertFalse(is_ack_eliciting)
<16> self.assertTrue(is_probing)
<17>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
+ with client_and_server() as (client, server):
+ # client receives STREAMS_BLOCKED_UNI: 0
+ client._handle_streams_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAMS_BLOCKED_UNI,
+ Buffer(data=b"\x00"),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAMS_BLOCKED_UNI: 0
- client._handle_streams_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAMS_BLOCKED_UNI,
- Buffer(data=b"\x00"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STREAM_DATA_BLOCKED
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x00\x01"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STREAM_DATA_BLOCKED
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x00\x01"),
- )
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_wrong_initiator(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x00"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x00"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame_send_only(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates unidirectional stream 2
+ run(client.create_stream(is_unidirectional=True))
+ # client receives STREAM_DATA_BLOCKED
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x02\x01"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)
+ self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates unidirectional stream 2
- run(client.create_stream(is_unidirectional=True))
-
- # client receives STREAM_DATA_BLOCKED
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x02\x01"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA</s>
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame_send_only(self):
# offset: 1
<s>STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_DATA_BLOCKED)
- self.assertEqual(cm.exception.reason_phrase, "Stream is send-only")
-
|
tests.test_connection/QuicConnectionTest.test_payload_received_unknown_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives unknown frame
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._payload_received(client_receive_context(client), b"\x1e")
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<add> self.assertEqual(cm.exception.frame_type, 0x1E)
<add> self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
<del> client = QuicConnection(is_client=True)
<2>:<del> server = QuicConnection(
<3>:<del> is_client=False,
<4>:<del> certificate=SERVER_CERTIFICATE,
<5>:<del> private_key=SERVER_PRIVATE_KEY,
<6>:<del> )
<7>:<del>
<8>:<del> # perform handshake
<9>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del>
<11>:<del> # client receives unknown frame
<12>:<del> with self.assertRaises(QuicConnectionError) as cm:
<13>:<del> client._payload_received(client_receive_context(client), b"\x1e")
<14>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<15>:<del> self.assertEqual(cm.exception.frame_type, 0x1E)
<16>:<del> self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
<17>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_unknown_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10>
<11> # client receives unknown frame
<12> with self.assertRaises(QuicConnectionError) as cm:
<13> client._payload_received(client_receive_context(client), b"\x1e")
<14> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<15> self.assertEqual(cm.exception.frame_type, 0x1E)
<16> self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
<17>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
+ with client_and_server() as (client, server):
+ # client receives STREAMS_BLOCKED_UNI: 0
+ client._handle_streams_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAMS_BLOCKED_UNI,
+ Buffer(data=b"\x00"),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAMS_BLOCKED_UNI: 0
- client._handle_streams_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAMS_BLOCKED_UNI,
- Buffer(data=b"\x00"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_padding_only(self):
+ with client_and_server() as (client, server):
+ # client receives padding only
+ is_ack_eliciting, is_probing = client._payload_received(
+ client_receive_context(client), b"\x00" * 1200
+ )
+ self.assertFalse(is_ack_eliciting)
+ self.assertTrue(is_probing)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives padding only
- is_ack_eliciting, is_probing = client._payload_received(
- client_receive_context(client), b"\x00" * 1200
- )
- self.assertFalse(is_ack_eliciting)
- self.assertTrue(is_probing)
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STREAM_DATA_BLOCKED
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x00\x01"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STREAM_DATA_BLOCKED
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x00\x01"),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_wrong_initiator(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x00"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x00"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stop_sending_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STOP_SENDING
+ client._handle_stop_sending_frame(
+ client_receive_context(client),
+ QuicFrameType.STOP_SENDING,
+ Buffer(data=b"\x00\x11\x22"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STOP_SENDING
- client._handle_stop_sending_frame(
- client_receive_context(client),
- QuicFrameType.STOP_SENDING,
- Buffer(data=b"\x00\x11\x22"),
- )
-
|
tests.test_connection/QuicConnectionTest.test_payload_received_unexpected_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives CRYPTO frame in 0-RTT
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._payload_received(
<add> client_receive_context(client, epoch=tls.Epoch.ZERO_RTT), b"\x06"
<add> )
<add> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<add> self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
<add> self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type")
<del> client = QuicConnection(is_client=True)
<2>:<del> server = QuicConnection(
<3>:<del> is_client=False,
<4>:<del> certificate=SERVER_CERTIFICATE,
<5>:<del> private_key=SERVER_PRIVATE_KEY,
<6>:<del> )
<7>:<del>
<8>:<del> # perform handshake
<9>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del>
<11>:<del> # client receives CRYPTO frame in 0-RTT
<12>:<del> with self.assertRaises(QuicConnectionError) as cm:
<13>:<del> client._payload_received(
<14>:<del> client_receive_context(client, epoch=tls.Epoch.ZERO_RTT), b"\x06"
<15>:<del> )
<16>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<17>:<del> self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
<18>:<del> self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type")
<19>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_unexpected_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10>
<11> # client receives CRYPTO frame in 0-RTT
<12> with self.assertRaises(QuicConnectionError) as cm:
<13> client._payload_received(
<14> client_receive_context(client, epoch=tls.Epoch.ZERO_RTT), b"\x06"
<15> )
<16> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<17> self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
<18> self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type")
<19>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
+ with client_and_server() as (client, server):
+ # client receives STREAMS_BLOCKED_UNI: 0
+ client._handle_streams_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAMS_BLOCKED_UNI,
+ Buffer(data=b"\x00"),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAMS_BLOCKED_UNI: 0
- client._handle_streams_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAMS_BLOCKED_UNI,
- Buffer(data=b"\x00"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_padding_only(self):
+ with client_and_server() as (client, server):
+ # client receives padding only
+ is_ack_eliciting, is_probing = client._payload_received(
+ client_receive_context(client), b"\x00" * 1200
+ )
+ self.assertFalse(is_ack_eliciting)
+ self.assertTrue(is_probing)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives padding only
- is_ack_eliciting, is_probing = client._payload_received(
- client_receive_context(client), b"\x00" * 1200
- )
- self.assertFalse(is_ack_eliciting)
- self.assertTrue(is_probing)
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_unknown_frame(self):
+ with client_and_server() as (client, server):
+ # client receives unknown frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._payload_received(client_receive_context(client), b"\x1e")
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, 0x1E)
+ self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives unknown frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._payload_received(client_receive_context(client), b"\x1e")
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, 0x1E)
- self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STREAM_DATA_BLOCKED
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x00\x01"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STREAM_DATA_BLOCKED
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x00\x01"),
- )
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_frame_wrong_initiator(self):
+ with client_and_server() as (client, server):
+ # client receives STREAM frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._handle_stream_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_BASE,
+ Buffer(data=b"\x00"),
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
+ self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAM frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._handle_stream_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_BASE,
- Buffer(data=b"\x00"),
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.STREAM_STATE_ERROR)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.STREAM_BASE)
- self.assertEqual(cm.exception.reason_phrase, "Wrong stream initiator")
-
|
tests.test_connection/QuicConnectionTest.test_payload_received_malformed_frame
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> # client receives malformed frame
<add> with self.assertRaises(QuicConnectionError) as cm:
<add> client._payload_received(
<add> client_receive_context(client), b"\x1c\x00\x01\x00"
<add> )
<add> self.assertEqual(
<add> cm.exception.error_code, QuicErrorCode.FRAME_ENCODING_ERROR
<add> )
<add> self.assertEqual(cm.exception.frame_type, 0x1C)
<add> self.assertEqual(cm.exception.reason_phrase, "Failed to parse frame")
<del> client = QuicConnection(is_client=True)
<2>:<del> server = QuicConnection(
<3>:<del> is_client=False,
<4>:<del> certificate=SERVER_CERTIFICATE,
<5>:<del> private_key=SERVER_PRIVATE_KEY,
<6>:<del> )
<7>:<del>
<8>:<del> # perform handshake
<9>:<del> client_transport, server_transport = create_transport(client, server)
<10>:<del>
<11>:<del> # client receives malformed frame
<12>:<del> with self.assertRaises(QuicConnectionError) as cm:
<13>:<del> client._payload_received(
<14>:<del> client_receive_context(client), b"\x1c\x00\x01\x00"
<15>:<del> )
<16>:<del> self.assertEqual(cm.exception.error_code, QuicErrorCode.FRAME_ENCODING_ERROR)
<17>:<del> self.assertEqual(cm.exception.frame_type, 0x1C)
<18>:<del> self.assertEqual(cm.exception.reason_phrase, "Failed to parse frame")
<19>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_malformed_frame(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10>
<11> # client receives malformed frame
<12> with self.assertRaises(QuicConnectionError) as cm:
<13> client._payload_received(
<14> client_receive_context(client), b"\x1c\x00\x01\x00"
<15> )
<16> self.assertEqual(cm.exception.error_code, QuicErrorCode.FRAME_ENCODING_ERROR)
<17> self.assertEqual(cm.exception.frame_type, 0x1C)
<18> self.assertEqual(cm.exception.reason_phrase, "Failed to parse frame")
<19>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
+ with client_and_server() as (client, server):
+ # client receives STREAMS_BLOCKED_UNI: 0
+ client._handle_streams_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAMS_BLOCKED_UNI,
+ Buffer(data=b"\x00"),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAMS_BLOCKED_UNI: 0
- client._handle_streams_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAMS_BLOCKED_UNI,
- Buffer(data=b"\x00"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_padding_only(self):
+ with client_and_server() as (client, server):
+ # client receives padding only
+ is_ack_eliciting, is_probing = client._payload_received(
+ client_receive_context(client), b"\x00" * 1200
+ )
+ self.assertFalse(is_ack_eliciting)
+ self.assertTrue(is_probing)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives padding only
- is_ack_eliciting, is_probing = client._payload_received(
- client_receive_context(client), b"\x00" * 1200
- )
- self.assertFalse(is_ack_eliciting)
- self.assertTrue(is_probing)
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_unknown_frame(self):
+ with client_and_server() as (client, server):
+ # client receives unknown frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._payload_received(client_receive_context(client), b"\x1e")
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, 0x1E)
+ self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives unknown frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._payload_received(client_receive_context(client), b"\x1e")
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, 0x1E)
- self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_unexpected_frame(self):
+ with client_and_server() as (client, server):
+ # client receives CRYPTO frame in 0-RTT
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._payload_received(
+ client_receive_context(client, epoch=tls.Epoch.ZERO_RTT), b"\x06"
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
+ self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives CRYPTO frame in 0-RTT
- with self.assertRaises(QuicConnectionError) as cm:
- client._payload_received(
- client_receive_context(client, epoch=tls.Epoch.ZERO_RTT), b"\x06"
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
- self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type")
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_stream_data_blocked_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
+ with client_and_server() as (client, server):
+ # client creates bidirectional stream 0
+ run(client.create_stream())
+ # client receives STREAM_DATA_BLOCKED
+ client._handle_stream_data_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAM_DATA_BLOCKED,
+ Buffer(data=b"\x00\x01"),
+ )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
- # client creates bidirectional stream 0
- run(client.create_stream())
-
- # client receives STREAM_DATA_BLOCKED
- client._handle_stream_data_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAM_DATA_BLOCKED,
- Buffer(data=b"\x00\x01"),
- )
-
|
tests.test_connection/QuicConnectionTest.test_stream_direction
|
Modified
|
aiortc~aioquic
|
ab5498b35e2d25e8e0917e40b3bcfa41ae3f67c8
|
[tests] add a context manager to shutdown client / server
|
<0>:<add> with client_and_server() as (client, server):
<add> for off in [0, 4, 8]:
<add> # Client-Initiated, Bidirectional
<add> self.assertTrue(client._stream_can_receive(off))
<add> self.assertTrue(client._stream_can_send(off))
<add> self.assertTrue(server._stream_can_receive(off))
<add> self.assertTrue(server._stream_can_send(off))
<del> client = QuicConnection(is_client=True)
<1>:<del> server = QuicConnection(
<2>:<del> is_client=False,
<3>:<del> certificate=SERVER_CERTIFICATE,
<4>:<del> private_key=SERVER_PRIVATE_KEY,
<5>:<del> )
<7>:<del> for off in [0, 4, 8]:
<8>:<add> # Server-Initiated, Bidirectional
<del> # Client-Initiated, Bidirectional
<9>:<add> self.assertTrue(client._stream_can_receive(off + 1))
<del> self.assertTrue(client._stream_can_receive(off))
<10>:<add> self.assertTrue(client._stream_can_send(off + 1))
<del> self.assertTrue(client._stream_can_send(off))
<11>:<add> self.assertTrue(server._stream_can_receive(off + 1))
<del> self.assertTrue(server._stream_can_receive(off))
<12>:<add> self.assertTrue(server._stream_can_send(off + 1))
<del> self.assertTrue(server._stream_can_send(off))
<14>:<add> # Client-Initiated, Unidirectional
<del> # Server-Initiated, Bidirectional
<15>:<add> self.assertFalse(client._stream
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_stream_direction(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> for off in [0, 4, 8]:
<8> # Client-Initiated, Bidirectional
<9> self.assertTrue(client._stream_can_receive(off))
<10> self.assertTrue(client._stream_can_send(off))
<11> self.assertTrue(server._stream_can_receive(off))
<12> self.assertTrue(server._stream_can_send(off))
<13>
<14> # Server-Initiated, Bidirectional
<15> self.assertTrue(client._stream_can_receive(off + 1))
<16> self.assertTrue(client._stream_can_send(off + 1))
<17> self.assertTrue(server._stream_can_receive(off + 1))
<18> self.assertTrue(server._stream_can_send(off + 1))
<19>
<20> # Client-Initiated, Unidirectional
<21> self.assertFalse(client._stream_can_receive(off + 2))
<22> self.assertTrue(client._stream_can_send(off + 2))
<23> self.assertTrue(server._stream_can_receive(off + 2))
<24> self.assertFalse(server._stream_can_send(off + 2))
<25>
<26> # Server-Initiated, Unidirectional
<27> self.assertTrue(client._stream_can_receive(off + 3))
<28> self.assertFalse(client._stream_can_send(off + 3))
<29> self.assertFalse(server._stream_can_receive(off + 3))
<30> self.assertTrue(server._stream_can_send(off + 3))
<31>
|
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_streams_blocked_uni_frame(self):
+ with client_and_server() as (client, server):
+ # client receives STREAMS_BLOCKED_UNI: 0
+ client._handle_streams_blocked_frame(
+ client_receive_context(client),
+ QuicFrameType.STREAMS_BLOCKED_UNI,
+ Buffer(data=b"\x00"),
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
+ )
- )
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives STREAMS_BLOCKED_UNI: 0
- client._handle_streams_blocked_frame(
- client_receive_context(client),
- QuicFrameType.STREAMS_BLOCKED_UNI,
- Buffer(data=b"\x00"),
- )
-
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_padding_only(self):
+ with client_and_server() as (client, server):
+ # client receives padding only
+ is_ack_eliciting, is_probing = client._payload_received(
+ client_receive_context(client), b"\x00" * 1200
+ )
+ self.assertFalse(is_ack_eliciting)
+ self.assertTrue(is_probing)
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives padding only
- is_ack_eliciting, is_probing = client._payload_received(
- client_receive_context(client), b"\x00" * 1200
- )
- self.assertFalse(is_ack_eliciting)
- self.assertTrue(is_probing)
-
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_malformed_frame(self):
+ with client_and_server() as (client, server):
+ # client receives malformed frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._payload_received(
+ client_receive_context(client), b"\x1c\x00\x01\x00"
+ )
+ self.assertEqual(
+ cm.exception.error_code, QuicErrorCode.FRAME_ENCODING_ERROR
+ )
+ self.assertEqual(cm.exception.frame_type, 0x1C)
+ self.assertEqual(cm.exception.reason_phrase, "Failed to parse frame")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives malformed frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._payload_received(
- client_receive_context(client), b"\x1c\x00\x01\x00"
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.FRAME_ENCODING_ERROR)
- self.assertEqual(cm.exception.frame_type, 0x1C)
- self.assertEqual(cm.exception.reason_phrase, "Failed to parse frame")
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_unknown_frame(self):
+ with client_and_server() as (client, server):
+ # client receives unknown frame
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._payload_received(client_receive_context(client), b"\x1e")
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, 0x1E)
+ self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives unknown frame
- with self.assertRaises(QuicConnectionError) as cm:
- client._payload_received(client_receive_context(client), b"\x1e")
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, 0x1E)
- self.assertEqual(cm.exception.reason_phrase, "Unknown frame type")
-
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_payload_received_unexpected_frame(self):
+ with client_and_server() as (client, server):
+ # client receives CRYPTO frame in 0-RTT
+ with self.assertRaises(QuicConnectionError) as cm:
+ client._payload_received(
+ client_receive_context(client, epoch=tls.Epoch.ZERO_RTT), b"\x06"
+ )
+ self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
+ self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
+ self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type")
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives CRYPTO frame in 0-RTT
- with self.assertRaises(QuicConnectionError) as cm:
- client._payload_received(
- client_receive_context(client, epoch=tls.Epoch.ZERO_RTT), b"\x06"
- )
- self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
- self.assertEqual(cm.exception.frame_type, QuicFrameType.CRYPTO)
- self.assertEqual(cm.exception.reason_phrase, "Unexpected frame type")
-
|
aioquic.connection/QuicConnection._send_probe
|
Modified
|
aiortc~aioquic
|
bd5a4d5f8d58c9f4d88711eafaddcb289b58dd98
|
[connection] ensure probe is not blocked by congestion control
|
<0>:<del> self._logger.info("Sending probe")
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_probe(self) -> None:
<0> self._logger.info("Sending probe")
<1> self._probe_pending = True
<2> self._send_pending()
<3>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._probe_pending = False
at: aioquic.connection.QuicConnection._write_application
self._probe_pending = False
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
bd5a4d5f8d58c9f4d88711eafaddcb289b58dd98
|
[connection] ensure probe is not blocked by congestion control
|
<18>:<add> ) or self._probe_pending:
<del> ):
|
# 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> ):
<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.start_frame(Qu</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:
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
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
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
_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.__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._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._loss = QuicPacketLoss(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
===========unchanged ref 1===========
self._remote_max_data = 0
self._remote_max_data_used = 0
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
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.QuicConnectionId
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
was_sent: bool = False
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
|
examples.server/serve_http_request
|
Modified
|
aiortc~aioquic
|
fc1a2a1a51b1ecc7e2d596220df5f3d7b587dae3
|
[examples] allow the server to send up to 20MB
|
<13>:<add> # we accept a maximum of 20MB
<add> size = min(20000000, int(size_match.group(1)))
<del> size = min(10000000, int(size_match.group(1)))
|
# module: examples.server
def serve_http_request(reader, writer):
<0> """
<1> Serve an HTTP/0.9 request.
<2> """
<3> try:
<4> line = await reader.readline()
<5> method, path = line.decode("utf8").split()
<6> except (UnicodeDecodeError, ValueError):
<7> writer.write(render("Bad request"))
<8> writer.write_eof()
<9> return
<10>
<11> size_match = re.match(r"^/(\d+)$", path)
<12> if size_match:
<13> size = min(10000000, int(size_match.group(1)))
<14> writer.write(b"Z" * size)
<15> elif path in ["/", "/index.html"]:
<16> writer.write(render("It works!"))
<17> else:
<18> writer.write(render("The document could not be found."))
<19>
<20> writer.write_eof()
<21>
|
===========unchanged ref 0===========
at: examples.server
render(content)
at: re
match(pattern: AnyStr, string: AnyStr, flags: _FlagsType=...) -> Optional[Match[AnyStr]]
match(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType=...) -> Optional[Match[AnyStr]]
at: typing.Match
pos: int
endpos: int
lastindex: Optional[int]
lastgroup: Optional[AnyStr]
string: AnyStr
re: Pattern[AnyStr]
group(group1: Union[str, int], group2: Union[str, int], /, *groups: Union[str, int]) -> Tuple[AnyStr, ...]
group(group: Union[str, int]=..., /) -> AnyStr
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
928967ed41b6b5155bdad859e14c3fd9a8fe324e
|
[loss] make ACK iteration more efficient
|
<13>:<add> largest_acked = rangeset.bounds().stop - 1
<15>:<del> for packet_range in rangeset:
<16>:<del> for packet_number in packet_range:
<17>:<del> packet = space.sent_packets.pop(packet_number, None)
<18>:<del> if packet is not None:
<19>:<del> # newly ack'd
<20>:<del> self._logger.debug("Packet %d ACK'd", packet_number)
<21>:<del> if packet.in_flight:
<22>:<del> self._loss.on_packet_acked(packet)
<24>:<add> # NOTE: this iteration explicitly counts on dict being ordered
<add> for packet_number, packet in list(space.sent_packets.items()):
<add> if packet_number > largest_acked:
<add> break
<add> if packet_number in rangeset:
<add> # newly ack'd
<add> if packet.in_flight:
<add> self._loss.on_packet_acked(packet)
<add>
<add> # trigger callbacks
<del> # trigger callbacks
<25>:<add> for handler, args in packet.delivery_handlers:
<del> for handler, args in packet.delivery_handlers:
<26>:<add> handler(QuicDeliveryState.ACKED, *args)
<del> handler(QuicDeliveryState.ACKED, *args)
<27>:<add> if packet.is_ack_eliciting:
<del> if packet.is_ack_eliciting:
<28>:<add> is_ack_eliciting = True
<del> is_ack_eliciting = True
<29>:<add> largest_newly_acked = packet_number
<del> largest_newly_acked = packet_number
<30>:<add> largest_sent_time = packet.sent_time
<del> largest_sent_time = packet.sent_time
<31>:<add>
<add>
|
# 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_time = self._loop.time()
<4> space = self.spaces[context.epoch]
<5>
<6> rangeset, ack_delay_encoded = pull_ack_frame(buf)
<7> if frame_type == QuicFrameType.ACK_ECN:
<8> pull_uint_var(buf)
<9> pull_uint_var(buf)
<10> pull_uint_var(buf)
<11>
<12> is_ack_eliciting = False
<13> largest_newly_acked = None
<14> largest_sent_time = None
<15> for packet_range in rangeset:
<16> for packet_number in packet_range:
<17> packet = space.sent_packets.pop(packet_number, None)
<18> if packet is not None:
<19> # newly ack'd
<20> self._logger.debug("Packet %d ACK'd", packet_number)
<21> if packet.in_flight:
<22> self._loss.on_packet_acked(packet)
<23>
<24> # trigger callbacks
<25> for handler, args in packet.delivery_handlers:
<26> handler(QuicDeliveryState.ACKED, *args)
<27> if packet.is_ack_eliciting:
<28> is_ack_eliciting = True
<29> largest_newly_acked = packet_number
<30> largest_sent_time = packet.sent_time
<31>
<32> # update RTT estimate
<33> if largest_newly_acked is not None:
<34> self._loss.on_ack_received(
<35> space=space,
<36> is_ack_eliciting=is_ack_eliciting,
<37> largest_newly_acked=largest_newly_acked,
<38> latest_rtt=ack_time - largest_sent_time,
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
)
# arm loss timer
self._set_loss_timer()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
at: aioquic.connection.QuicConnection.__init__
self._loop = asyncio.get_event_loop()
self._loss = QuicPacketLoss(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
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.loss.QuicPacketLoss
on_ack_received(space: QuicPacketSpace, is_ack_eliciting: bool, largest_newly_acked: int, latest_rtt: float, ack_delay_encoded: int) -> None
on_packet_acked(packet: QuicSentPacket) -> None
at: aioquic.loss.QuicPacketSpace.__init__
self.sent_packets: Dict[int, QuicSentPacket] = {}
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
===========unchanged ref 1===========
at: aioquic.packet_builder
QuicDeliveryState()
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
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: asyncio.events.AbstractEventLoop
time() -> float
===========changed ref 0===========
# module: aioquic.rangeset
class RangeSet(Sequence):
+ def bounds(self) -> range:
+ return range(self.__ranges[0].start, self.__ranges[-1].stop)
+
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
707038bfdc163cbbbefe618e94b3df5aa7fd2da2
|
[connection] prune packet-level debug message
|
# 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> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<32> self._write_handshake(builder, epoch)
<33> self._write_application(builder, network_path)
<34> datagrams, packets = builder.flush()
<35>
<36> if datagrams:
<37> self._packet_number = builder.packet_number
<38>
<39> # send datagrams
<40> for datagram in datagrams:
<41> self._transport.sendto(datagram, network_path.addr)
<42> network_path.bytes</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
# register packets
now = self._loop.time()
for packet in packets:
self._logger.debug(
"[%s] sending packet %d", packet.epoch.name, packet.packet_number
)
packet.sent_time = now
self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
if packet.in_flight:
self._loss.on_packet_sent(packet)
# arm loss timer
self._set_loss_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
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_send_pending() -> None
_set_loss_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.host_cid = self._host_cids[0].cid
self._loss = QuicPacketLoss(
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_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
===========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_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._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.loss.QuicPacketLoss
on_packet_sent(packet: QuicSentPacket) -> None
at: aioquic.loss.QuicPacketSpace.__init__
self.sent_packets: Dict[int, QuicSentPacket] = {}
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
is_ack_eliciting: bool
is_crypto_packet: bool
packet_number: int
sent_time: Optional[float] = None
sent_bytes: int = 0
===========unchanged ref 3===========
delivery_handlers: List[Tuple[QuicDeliveryHandler, Any]] = field(
default_factory=list
)
at: aioquic.tls
Epoch()
at: asyncio.events.AbstractEventLoop
time() -> float
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
|
|
aioquic.crypto/CryptoContext.__init__
|
Modified
|
aiortc~aioquic
|
2a78e14272b8b191f5eedd9395f63561a06e662e
|
[crypto] for AES, preserve encryptor between packets
|
<3>:<add> self.hp_encryptor: Optional[Any] = None
|
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
<0> self.aead: Optional[Any]
<1> self.cipher_suite: Optional[CipherSuite]
<2> self.hp: Optional[bytes]
<3> self.iv: Optional[bytes]
<4> self.key_phase = key_phase
<5> self.secret: Optional[bytes]
<6>
<7> self.teardown()
<8>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoContext.apply_key_phase
self.aead = crypto.aead
self.iv = crypto.iv
self.key_phase = crypto.key_phase
self.secret = crypto.secret
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
self.cipher_suite = cipher_suite
self.secret = secret
self.hp_encryptor = None
self.hp_encryptor = Cipher(
algorithms.AES(self.hp), mode=modes.ECB(), backend=default_backend()
).encryptor()
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.cipher_suite = None
self.hp = None
self.iv = None
self.secret = None
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
|
aioquic.crypto/CryptoContext.header_protection_mask
|
Modified
|
aiortc~aioquic
|
2a78e14272b8b191f5eedd9395f63561a06e662e
|
[crypto] for AES, preserve encryptor between packets
|
<0>:<add> buf = bytearray(31)
<6>:<del> buf = bytearray(5)
<8>:<del> return bytes(buf)
<10>:<del> encryptor = Cipher(
<11>:<del> algorithms.AES(self.hp), mode=modes.ECB(), backend=default_backend()
<12>:<del> ).encryptor()
<13>:<del> buf = bytearray(31)
<14>:<add> self.hp_encryptor.update_into(sample, buf)
<del> encryptor.update_into(sample, buf)
<15>:<add> return buf[:5]
<del> return buf[:5]
|
# module: aioquic.crypto
class CryptoContext:
def header_protection_mask(self, sample: bytes) -> bytes:
<0> if self.cipher_suite == CipherSuite.CHACHA20_POLY1305_SHA256:
<1> encryptor = Cipher(
<2> algorithms.ChaCha20(key=self.hp, nonce=sample),
<3> mode=None,
<4> backend=default_backend(),
<5> ).encryptor()
<6> buf = bytearray(5)
<7> encryptor.update_into(bytes(5), buf)
<8> return bytes(buf)
<9> else:
<10> encryptor = Cipher(
<11> algorithms.AES(self.hp), mode=modes.ECB(), backend=default_backend()
<12> ).encryptor()
<13> buf = bytearray(31)
<14> encryptor.update_into(sample, buf)
<15> return buf[:5]
<16>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoContext.__init__
self.aead: Optional[Any]
self.cipher_suite: Optional[CipherSuite]
self.hp: Optional[bytes]
self.hp_encryptor: Optional[Any] = None
at: aioquic.crypto.CryptoContext.apply_key_phase
self.aead = crypto.aead
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
self.cipher_suite = cipher_suite
self.hp_encryptor = None
self.hp_encryptor = Cipher(
algorithms.AES(self.hp), mode=modes.ECB(), backend=default_backend()
).encryptor()
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.cipher_suite = None
self.hp = None
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def __init__(self, key_phase: int = 0) -> None:
self.aead: Optional[Any]
self.cipher_suite: Optional[CipherSuite]
self.hp: Optional[bytes]
+ self.hp_encryptor: Optional[Any] = None
self.iv: Optional[bytes]
self.key_phase = key_phase
self.secret: Optional[bytes]
self.teardown()
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
66a0f1765a7ded227a618b56551ee967151cefcf
|
[recovery] move some loss detection / congestion control code
|
<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.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</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
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 = QuicPacketLoss(
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._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
</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>_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: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
</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>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")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, E</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>("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_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
66a0f1765a7ded227a618b56551ee967151cefcf
|
[recovery] move some loss detection / congestion control code
|
<3>:<del> ack_time = self._loop.time()
<4>:<del> space = self.spaces[context.epoch]
<5>:<del>
<6>:<add> ack_rangeset, ack_delay_encoded = pull_ack_frame(buf)
<del> rangeset, ack_delay_encoded = pull_ack_frame(buf)
<12>:<add> self._loss.on_ack_received(
<add> space=self.spaces[context.epoch],
<add> ack_rangeset=ack_rangeset,
<add> ack_delay_encoded=ack_delay_encoded,
<add> )
<del> is_ack_eliciting = False
<13>:<del> largest_acked = rangeset.bounds().stop - 1
<14>:<del> largest_newly_acked = None
<15>:<del> largest_sent_time = None
<17>:<del> # NOTE: this iteration explicitly counts on dict being ordered
<18>:<del> for packet_number, packet in list(space.sent_packets.items()):
<19>:<del> if packet_number > largest_acked:
<20>:<del> break
<21>:<del> if packet_number in rangeset:
<22>:<del> # newly ack'd
<23>:<del> if packet.in_flight:
<24>:<del> self._loss.on_packet_acked(packet)
<25>:<add> # arm loss timer
<add> self._set_loss_timer()
<26>:<del> # trigger callbacks
<27>:<del> for handler, args in packet.delivery_handlers:
<28>:<del> handler(QuicDeliveryState.ACKED, *args)
<29>:<del> if packet.is_ack_eliciting:
<30>:<del> is_ack_eliciting = True
<31>:<del> largest_newly_acked = packet_number
<32>:<del> largest_sent_time = packet.sent_time
<33>:<del>
<34>:<del> del space.sent_packets[packet_number]
<35>:<del>
<36>:<del> # update RTT estimate
<37>:<del> if largest_newly_acked is not None:
<38>:<del> self._loss.on_ack_received(
<39>:<del> space=space,
<40>:<del> is_ack_eliciting=is_ack_eliciting,
<41>:<del> largest_newly_acked=l
|
# 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_time = self._loop.time()
<4> space = self.spaces[context.epoch]
<5>
<6> rangeset, ack_delay_encoded = pull_ack_frame(buf)
<7> if frame_type == QuicFrameType.ACK_ECN:
<8> pull_uint_var(buf)
<9> pull_uint_var(buf)
<10> pull_uint_var(buf)
<11>
<12> is_ack_eliciting = False
<13> largest_acked = rangeset.bounds().stop - 1
<14> largest_newly_acked = None
<15> largest_sent_time = None
<16>
<17> # NOTE: this iteration explicitly counts on dict being ordered
<18> for packet_number, packet in list(space.sent_packets.items()):
<19> if packet_number > largest_acked:
<20> break
<21> if packet_number in rangeset:
<22> # newly ack'd
<23> if packet.in_flight:
<24> self._loss.on_packet_acked(packet)
<25>
<26> # trigger callbacks
<27> for handler, args in packet.delivery_handlers:
<28> handler(QuicDeliveryState.ACKED, *args)
<29> if packet.is_ack_eliciting:
<30> is_ack_eliciting = True
<31> largest_newly_acked = packet_number
<32> largest_sent_time = packet.sent_time
<33>
<34> del space.sent_packets[packet_number]
<35>
<36> # update RTT estimate
<37> if largest_newly_acked is not None:
<38> self._loss.on_ack_received(
<39> space=space,
<40> is_ack_eliciting=is_ack_eliciting,
<41> largest_newly_acked=l</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
# offset: 1
latest_rtt=ack_time - largest_sent_time,
ack_delay_encoded=ack_delay_encoded,
)
# arm loss timer
self._set_loss_timer()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
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
_set_loss_timer() -> 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._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
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
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, str]
===========unchanged ref 1===========
pull_application_close_frame(buf: Buffer) -> Tuple[int, str]
at: aioquic.recovery.QuicPacketRecovery
on_ack_received(space: QuicPacketSpace, ack_rangeset: RangeSet, ack_delay_encoded: int) -> 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.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:
+ # newly ack'd
+ packet = space.sent_packets.pop(packet_number)
+ if packet.in_flight:
+ self.on_packet_acked(packet)
+
+ # trigger callbacks
+ for handler, args in packet.delivery_handlers:
+ handler(QuicDeliveryState.ACKED, *args)
+ if packet.is_ack_eliciting:
+ is_ack_eliciting = True
+ largest_newly_acked = packet_number
+ largest_sent_time = packet.sent_time
+
+ # 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</s>
===========changed ref 1===========
+ # 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
+
===========changed ref 2===========
+ # module: aioquic.recovery
+ # TODO : collapse congestion window if persistent congestion
+
===========changed ref 3===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ """
+ Packet loss and congestion controller.
+ """
+
===========changed ref 4===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ def get_earliest_loss_time(self) -> Optional[QuicPacketSpace]:
+ loss_space = None
+ for space in self.spaces:
+ if space.loss_time is not None and (
+ loss_space is None or space.loss_time < loss_space.loss_time
+ ):
+ loss_space = space
+ return loss_space
+
===========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.largest_acked_packet = 0
+ self.loss_time: Optional[float] = None
+ self.sent_packets: Dict[int, QuicSentPacket] = {}
+
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
66a0f1765a7ded227a618b56551ee967151cefcf
|
[recovery] move some loss detection / congestion control code
|
# 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> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<32> self._write_handshake(builder, epoch)
<33> self._write_application(builder, network_path)
<34> datagrams, packets = builder.flush()
<35>
<36> if datagrams:
<37> self._packet_number = builder.packet_number
<38>
<39> # send datagrams
<40> for datagram in datagrams:
<41> self._transport.sendto(datagram, network_path.addr)
<42> network_path.bytes</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
# register packets
now = self._loop.time()
for packet in packets:
packet.sent_time = now
self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
if packet.in_flight:
self._loss.on_packet_sent(packet)
# arm loss timer
self._set_loss_timer()
===========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.connection.QuicConnection
_send_pending() -> None
_set_loss_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._loop = asyncio.get_event_loop()
self._loss = QuicPacketRecovery(
logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._original_connection_id = original_connection_id
self._packet_number = 0
self._remote_idle_timeout = 0 # milliseconds
self.__send_pending_task: Optional[asyncio.Handle] = None
self._transport: Optional[asyncio.DatagramTransport] = None
self._probe_pending = False
at: aioquic.connection.QuicConnection._initialize
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]
self.__send_pending_task = None
===========unchanged ref 1===========
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,
)
at: aioquic.connection.QuicConnection._write_application
self._probe_pending = False
at: aioquic.connection.QuicConnection.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: aioquic.connection.QuicConnection.datagram_received
self._original_connection_id = self.peer_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.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_transport_parameters(buf: Buffer) -> QuicTransportParameters
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
original_connection_id: Optional[bytes] = None
idle_timeout: Optional[int] = None
===========unchanged ref 2===========
stateless_reset_token: Optional[bytes] = None
max_packet_size: Optional[int] = None
initial_max_data: Optional[int] = None
initial_max_stream_data_bidi_local: Optional[int] = None
initial_max_stream_data_bidi_remote: Optional[int] = None
initial_max_stream_data_uni: Optional[int] = None
initial_max_streams_bidi: Optional[int] = None
initial_max_streams_uni: Optional[int] = None
ack_delay_exponent: Optional[int] = None
max_ack_delay: Optional[int] = None
disable_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> Tuple[List[bytes], List[QuicSentPacket]]
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
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
on_packet_sent(packet: QuicSentPacket, space: QuicPacketSpace) -> None
at: aioquic.tls
Epoch()
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
===========changed ref 0===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ def on_packet_sent(self, packet: QuicSentPacket, space: QuicPacketSpace) -> None:
+ packet.sent_time = self._get_time()
+ space.sent_packets[packet.packet_number] = packet
+
+ if packet.in_flight:
+ if packet.is_crypto_packet:
+ self._time_of_last_sent_crypto_packet = packet.sent_time
+ if packet.is_ack_eliciting:
+ self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
+
+ # add packet to bytes in flight
+ self.bytes_in_flight += packet.sent_bytes
+
===========changed ref 1===========
+ # module: aioquic.recovery
+ # TODO : collapse congestion window if persistent congestion
+
===========changed ref 2===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ """
+ Packet loss and congestion controller.
+ """
+
|
|
aioquic.connection/QuicConnection._set_loss_timer
|
Modified
|
aiortc~aioquic
|
66a0f1765a7ded227a618b56551ee967151cefcf
|
[recovery] move some loss detection / congestion control code
|
<13>:<add> loss_time, self._loss.on_loss_detection_timeout
<del> loss_time, self._loss.on_loss_timeout
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_loss_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_timeout
<14> )
<15>
|
===========unchanged ref 0===========
at: aioquic.connection
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.secrets_log_file = secrets_log_file
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
at: aioquic.tls
Direction()
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context.__init__
self.client_random = None
self.client_random = os.urandom(32)
at: aioquic.tls.Context._server_handle_hello
self.client_random = peer_hello.random
at: enum.Enum
name: str
value: Any
_name_: str
_value_: Any
_member_names_: List[str] # undocumented
_member_map_: Dict[str, Enum] # undocumented
_value2member_map_: Dict[int, Enum] # undocumented
_ignore_: Union[str, List[str]]
_order_: str
__order__: str
===========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:
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
- now = self._loop.time()
for packet in packets:
- packet.sent_time = now
</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s> packets
- now = self._loop.time()
for packet in packets:
- packet.sent_time = now
-
- self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
- if packet.in_flight:
+ self._loss.on_packet_sent(
- self._loss.on_packet_sent(packet)
+ packet=packet, space=self.spaces[packet.epoch]
+ )
# arm loss timer
self._set_loss_timer()
===========changed ref 2===========
+ # module: aioquic.recovery
+ # TODO : collapse congestion window if persistent congestion
+
===========changed ref 3===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ """
+ Packet loss and congestion controller.
+ """
+
===========changed ref 4===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ def get_earliest_loss_time(self) -> Optional[QuicPacketSpace]:
+ loss_space = None
+ for space in self.spaces:
+ if space.loss_time is not None and (
+ loss_space is None or space.loss_time < loss_space.loss_time
+ ):
+ loss_space = space
+ return loss_space
+
===========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.largest_acked_packet = 0
+ self.loss_time: Optional[float] = None
+ self.sent_packets: Dict[int, QuicSentPacket] = {}
+
===========changed ref 6===========
+ # 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:
+ self.detect_loss(loss_space)
+ # re-arm timer!
+ else:
+ # sending the probe will re-arm the timer
+ self._pto_count += 1
+ self._send_probe()
+
===========changed ref 7===========
+ # module: aioquic.recovery
+ # loss detection
+ K_PACKET_THRESHOLD = 3
+ K_INITIAL_RTT = 0.5 # seconds
+ K_GRANULARITY = 0.001 # seconds
+ K_TIME_THRESHOLD = 9 / 8
+
+ # congestion control
+ K_MAX_DATAGRAM_SIZE = 1280
+ K_INITIAL_WINDOW = 10 * K_MAX_DATAGRAM_SIZE
+ K_MINIMUM_WINDOW = 2 * K_MAX_DATAGRAM_SIZE
+ K_LOSS_REDUCTION_FACTOR = 0.5
+
===========changed ref 8===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ def on_packet_sent(self, packet: QuicSentPacket, space: QuicPacketSpace) -> None:
+ packet.sent_time = self._get_time()
+ space.sent_packets[packet.packet_number] = packet
+
+ if packet.in_flight:
+ if packet.is_crypto_packet:
+ self._time_of_last_sent_crypto_packet = packet.sent_time
+ if packet.is_ack_eliciting:
+ self._time_of_last_sent_ack_eliciting_packet = packet.sent_time
+
+ # add packet to bytes in flight
+ self.bytes_in_flight += packet.sent_bytes
+
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
66a0f1765a7ded227a618b56551ee967151cefcf
|
[recovery] move some loss detection / congestion control code
|
<16>:<add> builder.flight_bytes + self._loss.bytes_in_flight
<del> builder.flight_bytes + self._loss._bytes_in_flight
<17>:<add> < self._loss.congestion_window
<del> < self._loss._congestion_window
|
# 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
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(self, builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_connection_limits(builder: QuicPacketBuilder, space: QuicPacketSpace) -> None
_write_stream_limits(self, builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
_write_stream_limits(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._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
)
===========unchanged ref 1===========
self._remote_max_data = 0
self._remote_max_data_used = 0
self._ping_pending = False
self._probe_pending = False
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
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._write_application
crypto_stream_id = tls.Epoch.ONE_RTT
crypto_stream_id: Optional[tls.Epoch] = None
space = self.spaces[tls.Epoch.ONE_RTT]
buf = builder.buffer
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
teardown() -> None
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
66a0f1765a7ded227a618b56551ee967151cefcf
|
[recovery] move some loss detection / congestion control code
|
<8>:<add> builder.flight_bytes + self._loss.bytes_in_flight
<del> builder.flight_bytes + self._loss._bytes_in_flight
<9>:<add> < self._loss.congestion_window
<del> < self._loss._congestion_window
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<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
<30> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<31> self.cryptos[tls.Epoch.INITIAL].teardown()
<32>
|
===========unchanged ref 0===========
at: aioquic.connection
MAX_DATA_WINDOW = 1048576
at: aioquic.connection.QuicConnection
_on_max_data_delivery(delivery: QuicDeliveryState) -> None
_on_max_stream_data_delivery(delivery: QuicDeliveryState, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection.__init__
self._local_max_data = MAX_DATA_WINDOW
self._local_max_data_sent = MAX_DATA_WINDOW
self._local_max_data_used = 0
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
at: aioquic.connection.QuicConnection._handle_stream_frame
self._local_max_data_used += newly_received
at: aioquic.connection.QuicConnection._on_max_data_delivery
self._local_max_data_sent = 0
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
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
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
===========unchanged ref 1===========
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_local_sent = 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.connection
class QuicConnection(asyncio.DatagramProtocol):
def _set_loss_timer(self) -> None:
# stop timer
if self._loss_timer is not None:
self._loss_timer.cancel()
self._loss_timer = None
# re-arm timer
if self.__state not in [
QuicConnectionState.CLOSING,
QuicConnectionState.DRAINING,
]:
loss_time = self._loss.get_loss_detection_time()
if loss_time is not None:
self._loss_timer = self._loop.call_at(
+ loss_time, self._loss.on_loss_detection_timeout
- loss_time, self._loss.on_loss_timeout
)
===========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:
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
- now = self._loop.time()
for packet in packets:
- packet.sent_time = now
</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s> packets
- now = self._loop.time()
for packet in packets:
- packet.sent_time = now
-
- self.spaces[packet.epoch].sent_packets[packet.packet_number] = packet
- if packet.in_flight:
+ self._loss.on_packet_sent(
- self._loss.on_packet_sent(packet)
+ packet=packet, space=self.spaces[packet.epoch]
+ )
# arm loss timer
self._set_loss_timer()
===========changed ref 3===========
+ # module: aioquic.recovery
+ # TODO : collapse congestion window if persistent congestion
+
===========changed ref 4===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ """
+ Packet loss and congestion controller.
+ """
+
===========changed ref 5===========
+ # module: aioquic.recovery
+ class QuicPacketRecovery:
+ def get_earliest_loss_time(self) -> Optional[QuicPacketSpace]:
+ loss_space = None
+ for space in self.spaces:
+ if space.loss_time is not None and (
+ loss_space is None or space.loss_time < loss_space.loss_time
+ ):
+ loss_space = space
+ return loss_space
+
===========changed ref 6===========
+ # 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.largest_acked_packet = 0
+ self.loss_time: Optional[float] = None
+ self.sent_packets: Dict[int, QuicSentPacket] = {}
+
===========changed ref 7===========
+ # 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:
+ self.detect_loss(loss_space)
+ # re-arm timer!
+ else:
+ # sending the probe will re-arm the timer
+ self._pto_count += 1
+ self._send_probe()
+
|
aioquic.recovery/QuicPacketRecovery.__init__
|
Modified
|
aiortc~aioquic
|
1af390c7b0daa3aaddc16ee42b6a122447ceecec
|
[recovery] re-arm the loss detection timer as needed
|
<8>:<add> 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>
<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 -= 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_window = max(
int(self.congestion_window * K_LOSS_REDUCTION_FACTOR), K_MINIMUM_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_loss_detection_timeout
|
Modified
|
aiortc~aioquic
|
1af390c7b0daa3aaddc16ee42b6a122447ceecec
|
[recovery] re-arm the loss detection timer as needed
|
<3>:<add> # detect loss and re-arm the timer
<4>:<add> self._set_loss_detection_timer()
<del> # re-arm 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> self.detect_loss(loss_space)
<4> # re-arm timer!
<5> else:
<6> # sending the probe will re-arm the timer
<7> self._pto_count += 1
<8> self._send_probe()
<9>
|
===========unchanged ref 0===========
at: aioquic.recovery.QuicPacketRecovery
get_earliest_loss_time() -> Optional[QuicPacketSpace]
at: aioquic.recovery.QuicPacketRecovery.__init__
self._logger = logger
self._set_loss_detection_timer = set_loss_detection_timer
self._pto_count = 0
at: aioquic.recovery.QuicPacketRecovery.on_loss_detection_timeout
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 __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.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
1af390c7b0daa3aaddc16ee42b6a122447ceecec
|
[recovery] re-arm the loss detection timer as needed
|
<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.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</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
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._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
</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>_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: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
</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>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")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, E</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>("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_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
1af390c7b0daa3aaddc16ee42b6a122447ceecec
|
[recovery] re-arm the loss detection timer as needed
|
<15>:<del> # arm loss timer
<16>:<del> self._set_loss_timer()
<17>:<del>
|
# 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> # arm loss timer
<16> self._set_loss_timer()
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection.__init__
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._packet_number = 0
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._packet_number = builder.packet_number
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
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.recovery.QuicPacketRecovery.__init__
self.spaces: List[QuicPacketSpace] = []
===========changed ref 0===========
# 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()
- # re-arm timer!
else:
# sending the probe will re-arm the timer
self._pto_count += 1
self._send_probe()
===========changed ref 1===========
# 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 2===========
<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.__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</s>
===========changed ref 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: 1
<s>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,
- logger=self._logger, get_time=self._loop.time, send_probe=self._send_probe
)
self._loss_timer: Optional[asyncio.TimerHandle] =</s>
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
1af390c7b0daa3aaddc16ee42b6a122447ceecec
|
[recovery] re-arm the loss detection timer as needed
|
# 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> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<32> self._write_handshake(builder, epoch)
<33> self._write_application(builder, network_path)
<34> datagrams, packets = builder.flush()
<35>
<36> if datagrams:
<37> self._packet_number = builder.packet_number
<38>
<39> # send datagrams
<40> for datagram in datagrams:
<41> self._transport.sendto(datagram, network_path.addr)
<42> network_path.bytes</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
# register packets
for packet in packets:
self._loss.on_packet_sent(
packet=packet, space=self.spaces[packet.epoch]
)
# arm loss timer
self._set_loss_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.__close: Optional[Dict] = None
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,
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
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
===========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_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))
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
===========unchanged ref 2===========
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
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
===========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,
)
- # arm loss timer
- self._set_loss_timer()
-
===========changed ref 1===========
# 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()
- # re-arm timer!
else:
# sending the probe will re-arm the timer
self._pto_count += 1
self._send_probe()
|
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
54ae8cb3ca56d210be4cdd759ab65278cd0ba9ff
|
[recovery] discard recovery information for INITIAL context
|
<29>:<add> # discard initial keys and packet space
<del> # discard initial keys
<32>:<add> 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> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<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
<30> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<31> self.cryptos[tls.Epoch.INITIAL].teardown()
<32>
|
===========unchanged ref 0===========
at: aioquic.connection
write_crypto_frame(builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream) -> None
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
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,
set_loss_detection_timer=self._set_loss_detection_timer,
)
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_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.recovery
class QuicPacketSpace:
+ def teardown(self) -> None:
+ self.loss_time = None
+ self.sent_packets.clear()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
destination_cid_seq: Optional[int] = None
for connection_id in self._host_cids:
if header.destination_cid == connection_id.cid:
destination_cid_seq = connection_id.sequence_number
break
if self.is_client and destination_cid_seq is None:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
</s>
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
f01b0b104a4df70b057b468593bc33ad69b6c8ed
|
[packet builder] don't write packet number twice
|
# 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_start = buf.tell()
<26>
<27> # write header
<28> if is_long_header(packet_type):
<29> push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<30> push_uint32(buf, self._version)
<31> push_uint8(
<32> buf,
<33> (encode_cid_length(len(self._peer_cid)) << 4)
<34> | encode_cid_length(len(self._host_cid)),
<35> )
<36> push_bytes(buf, self._peer_cid)
<37> push_bytes(buf, self._host_cid)
<38> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<39> push_uint_var(buf, len(self._peer_token))
<40> push_bytes(buf, self._peer_token)
<41> push_uint16(buf, 0) #</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint32(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
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
encode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
QuicSentPacket(epoch: Epoch, 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._spin_bit = spin_bit
self._version = version
self._ack_eliciting = False
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
===========unchanged ref 1===========
self._packet: Optional[QuicSentPacket] = 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._crypto = None
self._packet = None
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
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()
|
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
f01b0b104a4df70b057b468593bc33ad69b6c8ed
|
[packet builder] don't write packet number twice
|
<32>:<del> push_packet_number(buf, self._packet_number)
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell() - self._packet_start
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> # pad initial datagram
<12> if self._pad_first_datagram:
<13> push_bytes(buf, bytes(self.remaining_space))
<14> packet_size = buf.tell() - self._packet_start
<15> self._pad_first_datagram = False
<16>
<17> if is_long_header(self._packet_type):
<18> # finalize length
<19> buf.seek(
<20> self._packet_start
<21> + self._header_size
<22> - PACKET_NUMBER_SEND_SIZE
<23> - PACKET_LENGTH_SEND_SIZE
<24> )
<25> length = (
<26> packet_size
<27> - self._header_size
<28> + PACKET_NUMBER_SEND_SIZE
<29> + self._crypto.aead_tag_size
<30> )
<31> push_uint16(buf, length | 0x4000)
<32> push_packet_number(buf, self._packet_number)
<33> buf.seek(packet_size)
<34> else:
<35> # check whether we need padding
<36> padding_size = (
<37> PACKET_NUMBER_MAX_SIZE
<38> - PACKET_NUMBER_SEND_SIZE
<39> + self._header_size
<40> - packet_size
<41> )
<42> if padding_size > 0:
<43> push_bytes(buf, bytes(padding_size))
<44> packet_size += padding_size
<45>
<46> # encrypt in place
<47> plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
<48> buf.seek(self._packet_start)
</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
buf,
self._crypto.encrypt_packet(
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
# short header packets cannot be coallesced, we need a new datagram
if not is_long_header(self._packet_type):
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._crypto = None
self._packet = None
return not empty
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
PACKET_LENGTH_SEND_SIZE = 2
PACKET_NUMBER_SEND_SIZE = 2
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._pad_first_datagram = pad_first_datagram
self._packets: List[QuicSentPacket] = []
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet: Optional[QuicSentPacket] = 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.flush
self._packets = []
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet = QuicSentPacket(
epoch=epoch,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
self._crypto = crypto
===========unchanged ref 1===========
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
at: aioquic.packet_builder.QuicSentPacket
sent_bytes: int = 0
===========changed ref 0===========
# 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,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_start = buf.tell()
# write header
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
+ push_packet_number(buf, self._packet_number)
- push_packet_number(buf, 0) # packet number
else:
push</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s> self._packet_number)
- push_packet_number(buf, 0) # packet number
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
|
tests.test_stream/QuicStreamTest.test_send_data
|
Modified
|
aiortc~aioquic
|
3e14a5f16d250c42c146ac6330a38f44c8f16445
|
[stream] subclass asyncio.Transport, implement some more methods
|
<1>:<add> self.assertTrue(stream.can_write_eof())
<6>:<add> # write data
<del> # write data, send a chunk
<8>:<add> self.assertEqual(stream.get_write_buffer_size(), 16)
<9>:<add>
<add> # send a chunk
<13>:<add> self.assertEqual(stream.get_write_buffer_size(), 16)
<20>:<add> self.assertEqual(stream.get_write_buffer_size(), 16)
<25>:<add> self.assertEqual(stream.get_write_buffer_size(), 16)
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
<0> stream = QuicStream()
<1>
<2> # nothing to send yet
<3> frame = stream.get_frame(8)
<4> self.assertIsNone(frame)
<5>
<6> # write data, send a chunk
<7> stream.write(b"0123456789012345")
<8> self.assertEqual(list(stream._send_pending), [range(0, 16)])
<9> frame = stream.get_frame(8)
<10> self.assertEqual(frame.data, b"01234567")
<11> self.assertFalse(frame.fin)
<12> self.assertEqual(frame.offset, 0)
<13> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<14>
<15> # send another chunk
<16> frame = stream.get_frame(8)
<17> self.assertEqual(frame.data, b"89012345")
<18> self.assertFalse(frame.fin)
<19> self.assertEqual(frame.offset, 8)
<20> self.assertEqual(list(stream._send_pending), [])
<21>
<22> # nothing more to send
<23> frame = stream.get_frame(8)
<24> self.assertIsNone(frame)
<25> self.assertEqual(list(stream._send_pending), [])
<26>
|
===========unchanged ref 0===========
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
can_write_eof() -> bool
get_write_buffer_size() -> int
write(data: bytes) -> None
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
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
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
+ class QuicStream(asyncio.Transport):
- class QuicStream(asyncio.BaseTransport):
+ # asyncio.Transport
+
+ def can_write_eof(self) -> bool:
+ return True
+
===========changed ref 1===========
# module: aioquic.stream
+ class QuicStream(asyncio.Transport):
- class QuicStream(asyncio.BaseTransport):
+ def get_write_buffer_size(self) -> int:
+ """
+ Return the current size of the write buffer.
+ """
+ return self._send_buffer_stop - self._send_buffer_start
+
|
aioquic.tls/cipher_suite_hash
|
Modified
|
aiortc~aioquic
|
461355d24e916eaa1ec21fedf3a04f8eb8f81ab0
|
[crypto] use our own AEAD class, we can retain the context
|
<0>:<add> return CIPHER_SUITES[cipher_suite]()
<del> return CIPHER_SUITES[cipher_suite][1]()
|
# module: aioquic.tls
def cipher_suite_hash(cipher_suite: CipherSuite) -> hashes.HashAlgorithm:
<0> return CIPHER_SUITES[cipher_suite][1]()
<1>
|
===========unchanged ref 0===========
at: aioquic.tls
Group(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.tls
- def cipher_suite_aead(cipher_suite: CipherSuite, key: bytes) -> Any:
- return CIPHER_SUITES[cipher_suite][0](key)
-
===========changed ref 1===========
# module: aioquic.tls
CIPHER_SUITES = {
+ CipherSuite.AES_128_GCM_SHA256: hashes.SHA256,
- CipherSuite.AES_128_GCM_SHA256: (aead.AESGCM, hashes.SHA256),
+ CipherSuite.AES_256_GCM_SHA384: hashes.SHA384,
- CipherSuite.AES_256_GCM_SHA384: (aead.AESGCM, hashes.SHA384),
+ CipherSuite.CHACHA20_POLY1305_SHA256: hashes.SHA256,
- CipherSuite.CHACHA20_POLY1305_SHA256: (aead.ChaCha20Poly1305, hashes.SHA256),
}
SIGNATURE_ALGORITHMS = {
SignatureAlgorithm.ECDSA_SECP256R1_SHA256: (None, hashes.SHA256),
SignatureAlgorithm.ECDSA_SECP384R1_SHA384: (None, hashes.SHA384),
SignatureAlgorithm.ECDSA_SECP521R1_SHA512: (None, hashes.SHA512),
SignatureAlgorithm.RSA_PKCS1_SHA1: (padding.PKCS1v15, hashes.SHA1),
SignatureAlgorithm.RSA_PKCS1_SHA256: (padding.PKCS1v15, hashes.SHA256),
SignatureAlgorithm.RSA_PKCS1_SHA384: (padding.PKCS1v15, hashes.SHA384),
SignatureAlgorithm.RSA_PKCS1_SHA512: (padding.PKCS1v15, hashes.SHA512),
SignatureAlgorithm.RSA_PSS_RSAE_SHA256: (padding.PSS, hashes.SHA256),
SignatureAlgorithm.RSA_PSS_RSAE_SHA384: (padding.PSS, hashes.SHA384),
SignatureAlgorithm.RSA_PSS_RSAE_SHA512: (padding.PSS, hashes.SHA512),
}
GROUP_TO_CURVE = {
Group.SECP256R1: ec.SECP256R1,
Group.SECP384R1: ec.SECP384R1,
Group.SECP521R1: ec</s>
===========changed ref 2===========
# module: aioquic.tls
# offset: 1
<s>
Group.SECP384R1: ec.SECP384R1,
Group.SECP521R1: ec.SECP521R1,
}
CURVE_TO_GROUP = dict((v, k) for k, v in GROUP_TO_CURVE.items())
|
aioquic.crypto/CryptoContext.setup
|
Modified
|
aiortc~aioquic
|
461355d24e916eaa1ec21fedf3a04f8eb8f81ab0
|
[crypto] use our own AEAD class, we can retain the context
|
<6>:<add> self.aead = AEAD(cipher_suite, key)
<del> self.aead = cipher_suite_aead(cipher_suite, key)
|
# module: aioquic.crypto
class CryptoContext:
def setup(self, cipher_suite: CipherSuite, secret: bytes) -> None:
<0> assert cipher_suite in [
<1> CipherSuite.AES_128_GCM_SHA256,
<2> CipherSuite.AES_256_GCM_SHA384,
<3> CipherSuite.CHACHA20_POLY1305_SHA256,
<4> ], "unsupported cipher suite"
<5> key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
<6> self.aead = cipher_suite_aead(cipher_suite, key)
<7> self.cipher_suite = cipher_suite
<8> self.secret = secret
<9>
<10> if self.cipher_suite == CipherSuite.CHACHA20_POLY1305_SHA256:
<11> self.hp_encryptor = None
<12> else:
<13> self.hp_encryptor = Cipher(
<14> algorithms.AES(self.hp), mode=modes.ECB(), backend=default_backend()
<15> ).encryptor()
<16>
|
===========unchanged ref 0===========
at: aioquic.crypto
SAMPLE_SIZE = 16
CryptoContext(key_phase: int=0)
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]
self.key_phase = key_phase
self.secret: Optional[bytes]
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = AEAD(cipher_suite, key)
self.secret = secret
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.iv = None
self.secret = None
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.crypto
+ class AEAD:
+ def __init__(self, cipher_suite: CipherSuite, key: bytes):
+ if cipher_suite == CipherSuite.AES_128_GCM_SHA256:
+ self._cipher_name = b"aes-128-gcm"
+ elif cipher_suite == CipherSuite.AES_256_GCM_SHA384:
+ self._cipher_name = b"aes-256-gcm"
+ else:
+ self._cipher_name = b"chacha20-poly1305"
+ self._decrypt_ctx = None
+ self._encrypt_ctx = None
+ self._key_length = len(key)
+ self._key_ptr = backend._ffi.from_buffer(key)
+
===========changed ref 1===========
# module: aioquic.crypto
+ class AEAD:
+ def _create_ctx(self, nonce_length: int, operation: int) -> Any:
+ evp_cipher = backend._lib.EVP_get_cipherbyname(self._cipher_name)
+ backend.openssl_assert(evp_cipher != backend._ffi.NULL)
+ ctx = backend._lib.EVP_CIPHER_CTX_new()
+ ctx = backend._ffi.gc(ctx, backend._lib.EVP_CIPHER_CTX_free)
+ res = backend._lib.EVP_CipherInit_ex(
+ ctx,
+ evp_cipher,
+ backend._ffi.NULL,
+ backend._ffi.NULL,
+ backend._ffi.NULL,
+ operation,
+ )
+ backend.openssl_assert(res != 0)
+ res = backend._lib.EVP_CIPHER_CTX_set_key_length(ctx, self._key_length)
+ backend.openssl_assert(res != 0)
+ res = backend._lib.EVP_CIPHER_CTX_ctrl(
+ ctx, backend._lib.EVP_CTRL_AEAD_SET_IVLEN, nonce_length, backend._ffi.NULL
+ )
+ backend.openssl_assert(res != 0)
+ return ctx
+
===========changed ref 2===========
# module: aioquic.crypto
+ class AEAD:
+ def encrypt(self, nonce: bytes, data: bytes, associated_data: bytes) -> bytes:
+ global backend
+
+ if self._encrypt_ctx is None:
+ self._encrypt_ctx = self._create_ctx(len(nonce), 1)
+ ctx = self._encrypt_ctx
+
+ outlen = backend._ffi.new("int *")
+ tag_length = 16
+ res = backend._lib.EVP_CipherInit_ex(
+ ctx,
+ backend._ffi.NULL,
+ backend._ffi.NULL,
+ self._key_ptr,
+ backend._ffi.from_buffer(nonce),
+ 1,
+ )
+ backend.openssl_assert(res != 0)
+
+ res = backend._lib.EVP_CipherUpdate(
+ ctx, backend._ffi.NULL, outlen, associated_data, len(associated_data)
+ )
+ backend.openssl_assert(res != 0)
+
+ buf = backend._ffi.new("unsigned char[]", len(data))
+ res = backend._lib.EVP_CipherUpdate(ctx, buf, outlen, data, len(data))
+ backend.openssl_assert(res != 0)
+ processed_data = backend._ffi.buffer(buf, outlen[0])[:]
+
+ res = backend._lib.EVP_CipherFinal_ex(ctx, backend._ffi.NULL, outlen)
+ backend.openssl_assert(res != 0)
+ backend.openssl_assert(outlen[0] == 0)
+ tag_buf = backend._ffi.new("unsigned char[]", tag_length)
+ res = backend._lib.EVP_CIPHER_CTX_ctrl(
+ ctx, backend._lib.EVP_CTRL_AEAD_GET_TAG, tag_length, tag_buf
+ )
+ backend.openssl_assert(res != 0)
+ tag = backend._ffi.buffer(tag</s>
===========changed ref 3===========
# module: aioquic.crypto
+ class AEAD:
+ def encrypt(self, nonce: bytes, data: bytes, associated_data: bytes) -> bytes:
# offset: 1
<s>
+ )
+ backend.openssl_assert(res != 0)
+ tag = backend._ffi.buffer(tag_buf)[:]
+
+ return processed_data + tag
+
===========changed ref 4===========
# module: aioquic.crypto
+ class AEAD:
+ def decrypt(self, nonce: bytes, data: bytes, associated_data: bytes) -> bytes:
+ global backend
+
+ if self._decrypt_ctx is None:
+ self._decrypt_ctx = self._create_ctx(len(nonce), 0)
+ ctx = self._decrypt_ctx
+
+ outlen = backend._ffi.new("int *")
+ tag_length = 16
+ if len(data) < tag_length:
+ raise InvalidTag
+ tag = data[-tag_length:]
+ data = data[:-tag_length]
+
+ res = backend._lib.EVP_CIPHER_CTX_ctrl(
+ ctx, backend._lib.EVP_CTRL_AEAD_SET_TAG, tag_length, tag
+ )
+ backend.openssl_assert(res != 0)
+
+ res = backend._lib.EVP_CipherInit_ex(
+ ctx,
+ backend._ffi.NULL,
+ backend._ffi.NULL,
+ self._key_ptr,
+ backend._ffi.from_buffer(nonce),
+ 0,
+ )
+ backend.openssl_assert(res != 0)
+
+ res = backend._lib.EVP_CipherUpdate(
+ ctx, backend._ffi.NULL, outlen, associated_data, len(associated_data)
+ )
+ backend.openssl_assert(res != 0)
+
+ buf = backend._ffi.new("unsigned char[]", len(data))
+ res = backend._lib.EVP_CipherUpdate(ctx, buf, outlen, data, len(data))
+ backend.openssl_assert(res != 0)
+ processed_data = backend._ffi.buffer(buf, outlen[0])[:]
+
+ res = backend._lib.EVP_CipherFinal_ex(ctx, backend._ffi.NULL, outlen)
+ if res == 0:
+ backend._consume_errors()
+ raise</s>
|
examples.server/serve_http_request
|
Modified
|
aiortc~aioquic
|
72ec399ca03c9bd6b23a521c509196c68245aaad
|
[examples] allow server to serve a 50MB file
|
<13>:<add> # we accept a maximum of 50MB
<del> # we accept a maximum of 20MB
<14>:<add> size = min(50000000, int(size_match.group(1)))
<del> size = min(20000000, int(size_match.group(1)))
|
# module: examples.server
def serve_http_request(reader, writer):
<0> """
<1> Serve an HTTP/0.9 request.
<2> """
<3> try:
<4> line = await reader.readline()
<5> method, path = line.decode("utf8").split()
<6> except (UnicodeDecodeError, ValueError):
<7> writer.write(render("Bad request"))
<8> writer.write_eof()
<9> return
<10>
<11> size_match = re.match(r"^/(\d+)$", path)
<12> if size_match:
<13> # we accept a maximum of 20MB
<14> size = min(20000000, int(size_match.group(1)))
<15> writer.write(b"Z" * size)
<16> elif path in ["/", "/index.html"]:
<17> writer.write(render("It works!"))
<18> else:
<19> writer.write(render("The document could not be found."))
<20>
<21> writer.write_eof()
<22>
|
===========unchanged ref 0===========
at: examples.server
render(content)
at: re
match(pattern: AnyStr, string: AnyStr, flags: _FlagsType=...) -> Optional[Match[AnyStr]]
match(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType=...) -> Optional[Match[AnyStr]]
at: typing.Match
pos: int
endpos: int
lastindex: Optional[int]
lastgroup: Optional[AnyStr]
string: AnyStr
re: Pattern[AnyStr]
group(group1: Union[str, int], group2: Union[str, int], /, *groups: Union[str, int]) -> Tuple[AnyStr, ...]
group(group: Union[str, int]=..., /) -> AnyStr
|
tests.test_tls/ContextTest.test_session_ticket
|
Modified
|
aiortc~aioquic
|
c6232d8952e9152be2fdffaad29cf2af2a518221
|
[tests] don't use Buffer private member
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
<0> client_tickets = []
<1> server_tickets = []
<2>
<3> def client_new_ticket(ticket):
<4> client_tickets.append(ticket)
<5>
<6> def server_get_ticket(label):
<7> for t in server_tickets:
<8> if t.ticket == label:
<9> return t
<10> return None
<11>
<12> def server_new_ticket(ticket):
<13> server_tickets.append(ticket)
<14>
<15> def first_handshake():
<16> client = self.create_client()
<17> client.new_session_ticket_cb = client_new_ticket
<18>
<19> server = self.create_server()
<20> server.new_session_ticket_cb = server_new_ticket
<21>
<22> self._handshake(client, server)
<23>
<24> # check session resumption was not used
<25> self.assertFalse(client.session_resumed)
<26> self.assertFalse(server.session_resumed)
<27>
<28> # check tickets match
<29> self.assertEqual(len(client_tickets), 1)
<30> self.assertEqual(len(server_tickets), 1)
<31> self.assertEqual(client_tickets[0].ticket, server_tickets[0].ticket)
<32> self.assertEqual(
<33> client_tickets[0].resumption_secret, server_tickets[0].resumption_secret
<34> )
<35>
<36> def second_handshake():
<37> client = self.create_client()
<38> client.session_ticket = client_tickets[0]
<39>
<40> server = self.create_server()
<41> server.get_session_ticket_cb = server_get_ticket
<42>
<43> # send client hello with pre_shared_key
<44> client_buf = create_buffers()
<45> client.handle_message(b"", client_buf)
<46> self.assertEqual(client.state, State.CLIENT_EXPECT</s>
|
===========below chunk 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 1
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 383)
reset_buffers(client_buf)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create_buffers()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 307)
reset_buffers(server_buf)
# handle server hello, encrypted extensions, certificate, certificate verify, finished
# send finished
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 52)
reset_buffers(client_buf)
# handle finished
# send new_session_ticket
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 0)
reset_buffers(server_buf)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check session resumption was used
self.assertTrue(client.session_resumed)
self.assertTrue(server.session_resumed)
def second_handshake_bad_binder():
client = self.create_client()
client.session_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket</s>
===========below chunk 1===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 2
<s>_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket_cb = server_get_ticket
# send client hello with pre_shared_key
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 383)
reset_buffers(client_buf)
# tamper with binder
server_input = server_input[:-4] + bytes(4)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create_buffers()
with self.assertRaises(tls.AlertHandshakeFailure) as cm:
server.handle_message(server_input, server_buf)
self.assertEqual(str(cm.exception), "PSK validation failed")
def second_handshake_bad_pre_shared_key():
client = self.create_client()
client.session_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket_cb = server_get_ticket
# send client hello with pre_shared_key
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 383)
reset_buffers(client_buf)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create</s>
===========below chunk 2===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 3
<s>()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
# tamper with pre_share_key index
buf = server_buf[tls.Epoch.INITIAL]
buf._data[buf.tell() - 1] = 1
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 307)
reset_buffers(server_buf)
# handle server hello and bomb
with self.assertRaises(tls.AlertIllegalParameter):
client.handle_message(client_input, client_buf)
first_handshake()
second_handshake()
second_handshake_bad_binder()
second_handshake_bad_pre_shared_key()
===========unchanged ref 0===========
at: aioquic.buffer
push_uint8(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.tls
AlertHandshakeFailure(*args: object)
AlertIllegalParameter(*args: object)
Epoch()
State()
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.session_ticket: Optional[SessionTicket] = None
self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: tests.test_tls
create_buffers()
merge_buffers(buffers)
reset_buffers(buffers)
at: tests.test_tls.ContextTest
create_client()
create_server()
_handshake(client, 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
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
===========unchanged ref 1===========
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)
|
|
aioquic.connection/write_crypto_frame
|
Modified
|
aiortc~aioquic
|
aefb4228e47c2ffe8b482c91607b191f54871051
|
[buffer] optimize pull_uint_var and push_uint_var
|
<0>:<add> frame_overhead = 3 + size_uint_var(stream.next_send_offset)
<del> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
|
# module: aioquic.connection
def write_crypto_frame(
builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
<0> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
<1> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<2> if frame is not None:
<3> builder.start_frame(
<4> QuicFrameType.CRYPTO,
<5> stream.on_data_delivery,
<6> (frame.offset, frame.offset + len(frame.data)),
<7> )
<8> push_uint_var(builder.buffer, frame.offset)
<9> push_uint16(builder.buffer, len(frame.data) | 0x4000)
<10> push_bytes(builder.buffer, frame.data)
<11>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint_var(buf: Buffer, value: int) -> None
size_uint_var(value: int) -> int
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 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.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
===========changed ref 0===========
# module: aioquic.buffer
+ def size_uint_var(value: int) -> int:
+ """
+ Returns the number of bytes required to encode the given value
+ as a QUIC variable-length unsigned integer.
+ """
+ if value <= 0x3F:
+ return 1
+ elif value <= 0x3FFF:
+ return 2
+ elif value <= 0x3FFFFFFF:
+ return 4
+ elif value <= 0x3FFFFFFFFFFFFFFF:
+ return 8
+ else:
+ raise ValueError("Integer is too big for a variable-length integer")
+
===========changed ref 1===========
# module: aioquic.buffer
+ def push_uint_var(buf: Buffer, value: int) -> None:
+ """
+ Push a QUIC variable-length unsigned integer.
+ """
+ if value <= 0x3F:
+ buf._data[buf._pos] = value
+ buf._pos += 1
+ elif value <= 0x3FFF:
+ pack_into("!H", buf._data, buf._pos, value | 0x4000)
+ buf._pos += 2
+ elif value <= 0x3FFFFFFF:
+ pack_into("!L", buf._data, buf._pos, value | 0x80000000)
+ buf._pos += 4
+ elif value <= 0x3FFFFFFFFFFFFFFF:
+ pack_into("!Q", buf._data, buf._pos, value | 0xC000000000000000)
+ buf._pos += 8
+ else:
+ raise ValueError("Integer is too big for a variable-length integer")
+
===========changed ref 2===========
# module: aioquic.packet
- def pull_uint_var(buf: Buffer) -> int:
- """
- Pull a QUIC variable-length unsigned integer.
- """
- try:
- kind = buf._data[buf._pos] // 64
- except IndexError:
- raise BufferReadError
- pull, push, mask = UINT_VAR_FORMATS[kind]
- return pull(buf) & mask
-
===========changed ref 3===========
# module: aioquic.packet
- def quic_uint_length(value: int) -> int:
- """
- Returns the number of bytes required to encode the given value
- as a QUIC variable-length unsigned integer.
- """
- for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):
- if value <= mask:
- return 2 ** i
- raise ValueError("Integer is too big for a variable-length integer")
-
===========changed ref 4===========
# module: aioquic.packet
- def push_uint_var(buf: Buffer, value: int) -> None:
- """
- Push a QUIC variable-length unsigned integer.
- """
- for i, (pull, push, mask) in enumerate(UINT_VAR_FORMATS):
- if value <= mask:
- start = buf._pos
- push(buf, value)
- buf._data[start] |= i * 64
- return
- raise ValueError("Integer is too big for a variable-length integer")
-
===========changed ref 5===========
# module: aioquic.buffer
+ def pull_uint_var(buf: Buffer) -> int:
+ """
+ Pull a QUIC variable-length unsigned integer.
+ """
+ try:
+ kind = buf._data[buf._pos] // 64
+ if kind == 0:
+ value = buf._data[buf._pos]
+ buf._pos += 1
+ return value
+ elif kind == 1:
+ value, = unpack_from("!H", buf._data, buf._pos)
+ buf._pos += 2
+ return value & 0x3FFF
+ elif kind == 2:
+ value, = unpack_from("!L", buf._data, buf._pos)
+ buf._pos += 4
+ return value & 0x3FFFFFFF
+ else:
+ value, = unpack_from("!Q", buf._data, buf._pos)
+ buf._pos += 8
+ return value & 0x3FFFFFFFFFFFFFFF
+ except (IndexError, struct.error):
+ raise BufferReadError
+
===========changed ref 6===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_SPIN_BIT = 0x20
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
- UINT_VAR_FORMATS = [
- (pull_uint8, push_uint8, 0x3F),
- (pull_uint16, push_uint16, 0x3FFF),
- (pull_uint32, push_uint32, 0x3FFFFFFF),
- (pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
- ]
-
|
aioquic.connection/write_stream_frame
|
Modified
|
aiortc~aioquic
|
aefb4228e47c2ffe8b482c91607b191f54871051
|
[buffer] optimize pull_uint_var and push_uint_var
|
<6>:<add> + size_uint_var(stream.stream_id)
<del> + quic_uint_length(stream.stream_id)
<7>:<add> + (size_uint_var(stream.next_send_offset) if stream.next_send_offset else 0)
<del> + (quic_uint_length(stream.next_send_offset) if stream.next_send_offset else 0)
|
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
max_offset: int,
) -> int:
<0> buf = builder.buffer
<1>
<2> # the frame data size is constrained by our peer's MAX_DATA and
<3> # the space available in the current packet
<4> frame_overhead = (
<5> 3
<6> + quic_uint_length(stream.stream_id)
<7> + (quic_uint_length(stream.next_send_offset) if stream.next_send_offset else 0)
<8> )
<9> previous_send_highest = stream._send_highest
<10> frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
<11>
<12> if frame is not None:
<13> flags = QuicStreamFlag.LEN
<14> if frame.offset:
<15> flags |= QuicStreamFlag.OFF
<16> if frame.fin:
<17> flags |= QuicStreamFlag.FIN
<18> builder.start_frame(
<19> QuicFrameType.STREAM_BASE | flags,
<20> stream.on_data_delivery,
<21> (frame.offset, frame.offset + len(frame.data)),
<22> )
<23> push_uint_var(buf, stream.stream_id)
<24> if frame.offset:
<25> push_uint_var(buf, frame.offset)
<26> push_uint16(buf, len(frame.data) | 0x4000)
<27> push_bytes(buf, frame.data)
<28> return stream._send_highest - previous_send_highest
<29> else:
<30> return 0
<31>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint_var(buf: Buffer, value: int) -> None
size_uint_var(value: int) -> int
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 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.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
===========unchanged ref 1===========
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_highest = 0
at: aioquic.stream.QuicStream.get_frame
self._send_highest = stop
===========changed ref 0===========
# module: aioquic.buffer
+ def size_uint_var(value: int) -> int:
+ """
+ Returns the number of bytes required to encode the given value
+ as a QUIC variable-length unsigned integer.
+ """
+ if value <= 0x3F:
+ return 1
+ elif value <= 0x3FFF:
+ return 2
+ elif value <= 0x3FFFFFFF:
+ return 4
+ elif value <= 0x3FFFFFFFFFFFFFFF:
+ return 8
+ else:
+ raise ValueError("Integer is too big for a variable-length integer")
+
===========changed ref 1===========
# module: aioquic.buffer
+ def push_uint_var(buf: Buffer, value: int) -> None:
+ """
+ Push a QUIC variable-length unsigned integer.
+ """
+ if value <= 0x3F:
+ buf._data[buf._pos] = value
+ buf._pos += 1
+ elif value <= 0x3FFF:
+ pack_into("!H", buf._data, buf._pos, value | 0x4000)
+ buf._pos += 2
+ elif value <= 0x3FFFFFFF:
+ pack_into("!L", buf._data, buf._pos, value | 0x80000000)
+ buf._pos += 4
+ elif value <= 0x3FFFFFFFFFFFFFFF:
+ pack_into("!Q", buf._data, buf._pos, value | 0xC000000000000000)
+ buf._pos += 8
+ else:
+ raise ValueError("Integer is too big for a variable-length integer")
+
===========changed ref 2===========
# module: aioquic.connection
def write_crypto_frame(
builder: QuicPacketBuilder, space: QuicPacketSpace, stream: QuicStream
) -> None:
+ frame_overhead = 3 + size_uint_var(stream.next_send_offset)
- frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
builder.start_frame(
QuicFrameType.CRYPTO,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
push_uint_var(builder.buffer, frame.offset)
push_uint16(builder.buffer, len(frame.data) | 0x4000)
push_bytes(builder.buffer, frame.data)
===========changed ref 3===========
# module: aioquic.packet
- def pull_uint_var(buf: Buffer) -> int:
- """
- Pull a QUIC variable-length unsigned integer.
- """
- try:
- kind = buf._data[buf._pos] // 64
- except IndexError:
- raise BufferReadError
- pull, push, mask = UINT_VAR_FORMATS[kind]
- return pull(buf) & mask
-
===========changed ref 4===========
# module: aioquic.packet
- def quic_uint_length(value: int) -> int:
- """
- Returns the number of bytes required to encode the given value
- as a QUIC variable-length unsigned integer.
- """
- for i, (_, _, mask) in enumerate(UINT_VAR_FORMATS):
- if value <= mask:
- return 2 ** i
- raise ValueError("Integer is too big for a variable-length integer")
-
===========changed ref 5===========
# module: aioquic.packet
- def push_uint_var(buf: Buffer, value: int) -> None:
- """
- Push a QUIC variable-length unsigned integer.
- """
- for i, (pull, push, mask) in enumerate(UINT_VAR_FORMATS):
- if value <= mask:
- start = buf._pos
- push(buf, value)
- buf._data[start] |= i * 64
- return
- raise ValueError("Integer is too big for a variable-length integer")
-
===========changed ref 6===========
# module: aioquic.buffer
+ def pull_uint_var(buf: Buffer) -> int:
+ """
+ Pull a QUIC variable-length unsigned integer.
+ """
+ try:
+ kind = buf._data[buf._pos] // 64
+ if kind == 0:
+ value = buf._data[buf._pos]
+ buf._pos += 1
+ return value
+ elif kind == 1:
+ value, = unpack_from("!H", buf._data, buf._pos)
+ buf._pos += 2
+ return value & 0x3FFF
+ elif kind == 2:
+ value, = unpack_from("!L", buf._data, buf._pos)
+ buf._pos += 4
+ return value & 0x3FFFFFFF
+ else:
+ value, = unpack_from("!Q", buf._data, buf._pos)
+ buf._pos += 8
+ return value & 0x3FFFFFFFFFFFFFFF
+ except (IndexError, struct.error):
+ raise BufferReadError
+
|
aioquic.packet_builder/QuicPacketBuilder.__init__
|
Modified
|
aiortc~aioquic
|
8d559be451f52a6af8e2ae9590cbd0a395e52216
|
[packet builder] delay writing packet header
|
<14>:<del> self._crypto: Optional[CryptoPair] = None
<17>:<add> self._packet_crypto: Optional[CryptoPair] = None
<add> self._packet_epoch: Optional[Epoch] = None
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
<0> self._host_cid = host_cid
<1> self._pad_first_datagram = pad_first_datagram
<2> self._peer_cid = peer_cid
<3> self._peer_token = peer_token
<4> self._spin_bit = spin_bit
<5> self._version = version
<6>
<7> # assembled datagrams and packets
<8> self._ack_eliciting = False
<9> self._datagrams: List[bytes] = []
<10> self._packets: List[QuicSentPacket] = []
<11> self._total_bytes = 0
<12>
<13> # current packet
<14> self._crypto: Optional[CryptoPair] = None
<15> self._header_size = 0
<16> self._packet: Optional[QuicSentPacket] = None
<17> self._packet_number = packet_number
<18> self._packet_start = 0
<19> self._packet_type = 0
<20>
<21> self.buffer = Buffer(PACKET_MAX_SIZE)
<22>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoPair()
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, 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
self._total_bytes += self.buffer.tell()
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._pad_first_datagram = False
self._packet_number += 1
self._packet = None
at: aioquic.packet_builder.QuicPacketBuilder.flush
self._datagrams = []
self._packets = []
at: aioquic.packet_builder.QuicPacketBuilder.start_frame
self._ack_eliciting = True
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._ack_eliciting = False
self._packet = QuicSentPacket(
epoch=epoch,
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
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
self._header_size += size_uint_var(token_length) + token_length
self._header_size = 3 + len(self._peer_cid)
at: aioquic.tls
Epoch()
at: typing
List = _alias(list, 1, inst=False, name='List')
|
aioquic.packet_builder/QuicPacketBuilder.remaining_space
|
Modified
|
aiortc~aioquic
|
8d559be451f52a6af8e2ae9590cbd0a395e52216
|
[packet builder] delay writing packet header
|
<4>:<add> return (
<add> self.buffer.capacity
<add> - self.buffer.tell()
<add> - self._packet_crypto.aead_tag_size
<add> )
<del> return self.buffer.capacity - self.buffer.tell() - self._crypto.aead_tag_size
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
<0> """
<1> Returns the remaining number of bytes which can be used in
<2> the current packet.
<3> """
<4> return self.buffer.capacity - self.buffer.tell() - self._crypto.aead_tag_size
<5>
|
===========unchanged ref 0===========
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._packet_number = packet_number
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
self._total_bytes = 0
# current packet
- self._crypto: Optional[CryptoPair] = None
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)
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
8d559be451f52a6af8e2ae9590cbd0a395e52216
|
[packet builder] delay writing packet header
|
<25>:<add> self._packet_crypto = crypto
<add> self._packet_epoch = epoch
<26>:<del>
<27>:<del> # write header
<28>:<del> if is_long_header(packet_type):
<29>:<del> push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<30>:<del> push_uint32(buf, self._version)
<31>:<del> push_uint8(
<32>:<del> buf,
<33>:<del> (encode_cid_length(len(self._peer_cid)) << 4)
<34>:<del> | encode_cid_length(len(self._host_cid)),
<35>:<del> )
<36>:<del> push_bytes(buf, self._peer_cid)
<37>:<del> push_bytes(buf, self._host_cid)
<38>:<del> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<39>:<del> push_uint_var(buf, len(self._peer_token))
<40>:<del> push_bytes(buf, self._peer_token)
<41>:<del> push_uint16(buf, 0) #
|
# 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_start = buf.tell()
<26>
<27> # write header
<28> if is_long_header(packet_type):
<29> push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<30> push_uint32(buf, self._version)
<31> push_uint8(
<32> buf,
<33> (encode_cid_length(len(self._peer_cid)) << 4)
<34> | encode_cid_length(len(self._host_cid)),
<35> )
<36> push_bytes(buf, self._peer_cid)
<37> push_bytes(buf, self._host_cid)
<38> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<39> push_uint_var(buf, len(self._peer_token))
<40> push_bytes(buf, self._peer_token)
<41> push_uint16(buf, 0) #</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
push_packet_number(buf, self._packet_number)
else:
push_uint8(
buf,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(buf, self._peer_cid)
push_packet_number(buf, self._packet_number)
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========unchanged ref 0===========
at: aioquic.buffer
size_uint_var(value: int) -> int
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.crypto
CryptoPair()
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
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet_builder
QuicSentPacket(epoch: Epoch, 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)
===========unchanged ref 1===========
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._packet = None
at: aioquic.packet_builder.QuicSentPacket
epoch: Epoch
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()
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
+ return (
+ self.buffer.capacity
+ - self.buffer.tell()
+ - self._packet_crypto.aead_tag_size
+ )
- return self.buffer.capacity - self.buffer.tell() - self._crypto.aead_tag_size
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
self._total_bytes = 0
# current packet
- self._crypto: Optional[CryptoPair] = None
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)
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
8d559be451f52a6af8e2ae9590cbd0a395e52216
|
[packet builder] delay writing packet header
|
<17>:<add> # write header
<18>:<del> # finalize length
<19>:<del> buf.seek(
<20>:<del> self._packet_start
<21>:<del> + self._header_size
<22>:<del> - PACKET_NUMBER_SEND_SIZE
<23>:<del> - PACKET_LENGTH_SEND_SIZE
<24>:<del> )
<29>:<add> + self._packet_crypto.aead_tag_size
<del> + self._crypto.aead_tag_size
<31>:<add>
<add> buf.seek(self._packet_start)
<add> push_uint8(buf, self._packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<add> push_uint32(buf, self._version)
<add> push_uint8(
<add> buf,
<add> (encode_cid_length(len(self._peer_cid)) << 4)
<add> | encode_cid_length(len(self._host_cid)),
<add> )
<add> push_bytes(buf, self._peer_cid)
<add> push_bytes(buf, self._host_cid)
<add> if (self._packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<add> push_uint_var(buf, len(self._peer_token))
<add> push_bytes
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell() - self._packet_start
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> # pad initial datagram
<12> if self._pad_first_datagram:
<13> push_bytes(buf, bytes(self.remaining_space))
<14> packet_size = buf.tell() - self._packet_start
<15> self._pad_first_datagram = False
<16>
<17> if is_long_header(self._packet_type):
<18> # finalize length
<19> buf.seek(
<20> self._packet_start
<21> + self._header_size
<22> - PACKET_NUMBER_SEND_SIZE
<23> - PACKET_LENGTH_SEND_SIZE
<24> )
<25> length = (
<26> packet_size
<27> - self._header_size
<28> + PACKET_NUMBER_SEND_SIZE
<29> + self._crypto.aead_tag_size
<30> )
<31> push_uint16(buf, length | 0x4000)
<32> buf.seek(packet_size)
<33> else:
<34> # check whether we need padding
<35> padding_size = (
<36> PACKET_NUMBER_MAX_SIZE
<37> - PACKET_NUMBER_SEND_SIZE
<38> + self._header_size
<39> - packet_size
<40> )
<41> if padding_size > 0:
<42> push_bytes(buf, bytes(padding_size))
<43> packet_size += padding_size
<44>
<45> # encrypt in place
<46> plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
<47> buf.seek(self._packet_start)
<48> push_bytes(
<49> buf,
<50> self._crypto</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
plain[0 : self._header_size], plain[self._header_size : packet_size]
),
)
self._packet.sent_bytes = buf.tell() - self._packet_start
self._packets.append(self._packet)
# short header packets cannot be coallesced, we need a new datagram
if not is_long_header(self._packet_type):
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
buf.seek(self._packet_start)
self._crypto = None
self._packet = None
return not empty
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint32(buf: Buffer, v: int) -> None
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
encode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
self._packets: List[QuicSentPacket] = []
self._header_size = 0
self._packet: Optional[QuicSentPacket] = None
===========unchanged ref 1===========
self._packet_crypto: Optional[CryptoPair] = None
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
buf = self.buffer
self._packet_number += 1
self._packet = None
at: aioquic.packet_builder.QuicPacketBuilder.flush
self._packets = []
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet = QuicSentPacket(
epoch=epoch,
is_ack_eliciting=False,
is_crypto_packet=False,
packet_number=self._packet_number,
)
self._packet_crypto = crypto
self._packet_start = buf.tell()
self._packet_type = packet_type
self._header_size = 10 + len(self._peer_cid) + len(self._host_cid)
self._header_size += size_uint_var(token_length) + token_length
self._header_size = 3 + len(self._peer_cid)
at: aioquic.packet_builder.QuicSentPacket
sent_bytes: int = 0
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
@property
def remaining_space(self) -> int:
"""
Returns the remaining number of bytes which can be used in
the current packet.
"""
+ return (
+ self.buffer.capacity
+ - self.buffer.tell()
+ - self._packet_crypto.aead_tag_size
+ )
- return self.buffer.capacity - self.buffer.tell() - self._crypto.aead_tag_size
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def __init__(
self,
*,
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,
):
self._host_cid = host_cid
self._pad_first_datagram = pad_first_datagram
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
# assembled datagrams and packets
self._ack_eliciting = False
self._datagrams: List[bytes] = []
self._packets: List[QuicSentPacket] = []
self._total_bytes = 0
# current packet
- self._crypto: Optional[CryptoPair] = None
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)
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
6880bc843871c723b682a320d04e6113b2c05339
|
[connection] discard handshake keys
|
<27>:<add> self._discard_handhake_at: Optional[float] = None
<add> 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.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</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
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_number = 0
self._parameters_available = asyncio.Event()
self._parameters_received = False
self._ping_waiter: Optional</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> 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: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionId</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> 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")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle</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>_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_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
6880bc843871c723b682a320d04e6113b2c05339
|
[connection] discard handshake keys
|
<31>:<add> # check if we can discard handshake keys
<add> if (
<add> self._discard_handhake_at is not None
<add> and self._loop.time() > self._discard_handhake_at
<add> ):
<add> self._logger.debug("Discarding handshake keys")
<add> self.cryptos[tls.Epoch.HANDSHAKE].teardown()
<add> self.spaces[tls.Epoch.HANDSHAKE].teardown()
<add> self._discard_handhake_at = None
<add> self._discard_handhake_done = True
<add> if not self._discard_handhake_done:
<add> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<del> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<32>:<add> self._write_handshake(builder, epoch)
<del> self._write_handshake(builder, epoch)
<33>:<add>
|
# 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> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<32> self._write_handshake(builder, epoch)
<33> self._write_application(builder, network_path)
<34> datagrams, packets = builder.flush()
<35>
<36> if datagrams:
<37> self._packet_number = builder.packet_number
<38>
<39> # send datagrams
<40> for datagram in datagrams:
<41> self._transport.sendto(datagram, network_path.addr)
<42> network_path.bytes</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
# 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.__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_handhake_at: Optional[float] = None
self.__epoch = tls.Epoch.INITIAL
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
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._version: Optional[int] = None
at: aioquic.connection.QuicConnection._consume_connection_id
self.peer_cid = connection_id.cid
at: aioquic.connection.QuicConnection._handle_ack_frame
self._discard_handhake_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
===========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.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_pending
self._packet_number = builder.packet_number
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.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]
===========unchanged ref 2===========
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
self.host_cid = context.host_cid
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
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.recovery.QuicPacketSpace
teardown() -> None
at: aioquic.stream.QuicStream
write(data: bytes) -> None
at: aioquic.tls
Epoch()
at: asyncio.events.AbstractEventLoop
time() -> float
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
at: os
urandom(size: int, /) -> bytes
===========changed ref 0===========
# module: aioquic.recovery
class QuicPacketRecovery:
+ def get_probe_timeout(self) -> float:
+ return (
+ self._rtt_smoothed
+ + max(4 * self._rtt_variance, K_GRANULARITY)
+ + self.max_ack_delay / 1000
+ )
+
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
6880bc843871c723b682a320d04e6113b2c05339
|
[connection] discard handshake keys
|
<1>:<del> space = self.spaces[epoch]
<6>:<add> space = self.spaces[epoch]
<31>:<add> self._logger.debug("Discarding initial keys")
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<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.cryptos[tls.Epoch.INITIAL].teardown()
<32> self.spaces[tls.Epoch.INITIAL].teardown()
<33>
|
===========unchanged ref 0===========
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.__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,
set_loss_detection_timer=self._set_loss_detection_timer,
)
self._remote_max_data = 0
self._remote_max_data_used = 0
self._probe_pending = False
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._send_probe
self._probe_pending = True
at: aioquic.connection.QuicConnection._write_application
crypto_stream_id = tls.Epoch.ONE_RTT
crypto_stream_id: Optional[tls.Epoch] = None
space = self.spaces[tls.Epoch.ONE_RTT]
at: aioquic.crypto.CryptoContext
is_valid() -> bool
===========unchanged ref 1===========
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
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
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
at: aioquic.recovery.QuicPacketRecovery.on_packet_acked
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.stream.QuicStream.__init__
self.max_stream_data_remote = max_stream_data_remote
self._send_highest = 0
at: aioquic.stream.QuicStream.get_frame
self._send_highest = stop
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_handhake_at is not None
+ and self._loop.time() > self._discard_handhake_at
+ ):
+ self._logger.debug("Discarding handshake keys")
+ self.cryptos[tls.Epoch.HANDSHAKE].teardown()
+ self.spaces[tls.Epoch.HANDSHAKE].teardown()
+ self._discard_handhake_at = None
+ self._discard_handhake_done = True
+ if not self._discard_handhake_done:
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
# offset: 1
<s> <add> if not self._discard_handhake_done:
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
+ self._write_handshake(builder, epoch)
- 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.recovery
class QuicPacketRecovery:
+ def get_probe_timeout(self) -> float:
+ return (
+ self._rtt_smoothed
+ + max(4 * self._rtt_variance, K_GRANULARITY)
+ + self.max_ack_delay / 1000
+ )
+
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
59a56f0f6af41cfc2236bec5ab5ff3adf7d77c8d
|
[connection] drop per-frame debug message
|
<30>:<del> self._logger.debug(
<31>:<del> "[%s] handling frame %s", context, frame_type_name(frame_type)
<32>:<del> )
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
<0> """
<1> Handle a QUIC packet payload.
<2> """
<3> buf = Buffer(data=plain)
<4>
<5> is_ack_eliciting = False
<6> is_probing = None
<7> while not buf.eof():
<8> frame_type = pull_uint_var(buf)
<9>
<10> # check frame type is known
<11> try:
<12> frame_handler, frame_epochs = self.__frame_handlers[frame_type]
<13> except IndexError:
<14> raise QuicConnectionError(
<15> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<16> frame_type=frame_type,
<17> reason_phrase="Unknown frame type",
<18> )
<19>
<20> # check frame is allowed for the epoch
<21> if context.epoch not in frame_epochs:
<22> raise QuicConnectionError(
<23> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<24> frame_type=frame_type,
<25> reason_phrase="Unexpected frame type",
<26> )
<27>
<28> # handle the frame
<29> if frame_type != QuicFrameType.PADDING:
<30> self._logger.debug(
<31> "[%s] handling frame %s", context, frame_type_name(frame_type)
<32> )
<33> try:
<34> frame_handler(context, frame_type, buf)
<35> except BufferReadError:
<36> raise QuicConnectionError(
<37> error_code=QuicErrorCode.FRAME_ENCODING_ERROR,
<38> frame_type=frame_type,
<39> reason_phrase="Failed to parse frame",
<40> )
<41>
<42> # update ACK only / probing flags
<43> if frame_type not in NON_ACK_ELICITING_FRAME_TYPES:
<44> is_ack_eliciting = True
<45>
<46> if frame_type not in PROBING_FRAME_TYPES:
<47> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
# offset: 1
elif is_probing is None:
is_probing = True
return is_ack_eliciting, bool(is_probing)
===========unchanged ref 0===========
at: aioquic.buffer
BufferReadError(*args: object)
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_uint_var(buf: Buffer) -> int
at: aioquic.buffer.Buffer
eof() -> bool
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]
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.__init__
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")),
(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")),</s>
===========unchanged ref 2===========
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)
NON_ACK_ELICITING_FRAME_TYPES = frozenset(
[QuicFrameType.ACK, QuicFrameType.ACK_ECN, QuicFrameType.PADDING]
)
PROBING_FRAME_TYPES = frozenset(
[
QuicFrameType.PATH_CHALLENGE,
QuicFrameType.PATH_RESPONSE,
QuicFrameType.PADDING,
QuicFrameType.NEW_CONNECTION_ID,
]
)
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
|
aioquic.connection/write_stream_frame
|
Modified
|
aiortc~aioquic
|
acd070ffde074ed00a5cd4ada33bf99170693d5e
|
[stream] don't use QuicStreamFlag, IntFlag "or" operations are slow
|
<13>:<add> frame_type = QuicFrameType.STREAM_BASE | 2 # length
<del> flags = QuicStreamFlag.LEN
<15>:<add> frame_type |= 4
<del> flags |= QuicStreamFlag.OFF
<17>:<add> frame_type |= 1
<del> flags |= QuicStreamFlag.FIN
<19>:<add> frame_type,
<del> QuicFrameType.STREAM_BASE | flags,
|
# module: aioquic.connection
def write_stream_frame(
builder: QuicPacketBuilder,
space: QuicPacketSpace,
stream: QuicStream,
max_offset: int,
) -> int:
<0> buf = builder.buffer
<1>
<2> # the frame data size is constrained by our peer's MAX_DATA and
<3> # the space available in the current packet
<4> frame_overhead = (
<5> 3
<6> + size_uint_var(stream.stream_id)
<7> + (size_uint_var(stream.next_send_offset) if stream.next_send_offset else 0)
<8> )
<9> previous_send_highest = stream._send_highest
<10> frame = stream.get_frame(builder.remaining_space - frame_overhead, max_offset)
<11>
<12> if frame is not None:
<13> flags = QuicStreamFlag.LEN
<14> if frame.offset:
<15> flags |= QuicStreamFlag.OFF
<16> if frame.fin:
<17> flags |= QuicStreamFlag.FIN
<18> builder.start_frame(
<19> QuicFrameType.STREAM_BASE | flags,
<20> stream.on_data_delivery,
<21> (frame.offset, frame.offset + len(frame.data)),
<22> )
<23> push_uint_var(buf, stream.stream_id)
<24> if frame.offset:
<25> push_uint_var(buf, frame.offset)
<26> push_uint16(buf, len(frame.data) | 0x4000)
<27> push_bytes(buf, frame.data)
<28> return stream._send_highest - previous_send_highest
<29> else:
<30> return 0
<31>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint_var(buf: Buffer, value: int) -> None
size_uint_var(value: int) -> int
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 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.packet_builder.QuicPacketBuilder
start_frame(frame_type: int, handler: Optional[QuicDeliveryHandler]=None, args: Sequence[Any]=[]) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.recovery
QuicPacketSpace()
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(max_size: int, max_offset: Optional[int]=None) -> Optional[QuicStreamFrame]
on_data_delivery(delivery: QuicDeliveryState, start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_highest = 0
===========unchanged ref 1===========
at: aioquic.stream.QuicStream.get_frame
self._send_highest = stop
===========changed ref 0===========
# module: aioquic.packet
- class QuicStreamFlag(IntFlag):
- FIN = 0x01
- LEN = 0x02
- OFF = 0x04
-
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.