This is an automated email from the ASF dual-hosted git repository. maskit pushed a commit to branch quic-latest in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/quic-latest by this push: new 7a3af4e Remove QUICPacketTransmitter 7a3af4e is described below commit 7a3af4e1c3251dbd5467810b0d22ba75808e4024 Author: Masakazu Kitajo <mas...@apache.org> AuthorDate: Wed Feb 27 16:05:54 2019 +0900 Remove QUICPacketTransmitter It's not used now. We might need it later but a fresh design would be better. --- iocore/net/P_QUICNetVConnection.h | 4 -- iocore/net/QUICNetVConnection.cc | 24 +------ iocore/net/quic/Mock.h | 46 ++---------- iocore/net/quic/QUICConnection.h | 3 +- iocore/net/quic/QUICFrameHandler.h | 2 + iocore/net/quic/QUICLossDetector.cc | 15 ++-- iocore/net/quic/QUICLossDetector.h | 13 ++-- iocore/net/quic/QUICPacketTransmitter.h | 44 ------------ iocore/net/quic/test/test_QUICAckFrameCreator.cc | 90 ++++++++++++------------ iocore/net/quic/test/test_QUICFlowController.cc | 56 +++++++-------- iocore/net/quic/test/test_QUICFrameDispatcher.cc | 3 +- iocore/net/quic/test/test_QUICLossDetector.cc | 16 ++--- iocore/net/quic/test/test_QUICStream.cc | 64 ++++++++--------- 13 files changed, 128 insertions(+), 252 deletions(-) diff --git a/iocore/net/P_QUICNetVConnection.h b/iocore/net/P_QUICNetVConnection.h index f8a9132..bdece52 100644 --- a/iocore/net/P_QUICNetVConnection.h +++ b/iocore/net/P_QUICNetVConnection.h @@ -212,10 +212,6 @@ public: std::string_view negotiated_application_name() const override; bool is_closed() const override; - // QUICConnection (QUICPacketTransmitter) - virtual void retransmit_packet(const QUICPacket &packet) override; - virtual Ptr<ProxyMutex> get_packet_transmitter_mutex() override; - // QUICConnection (QUICFrameHandler) std::vector<QUICFrameType> interests() override; QUICConnectionErrorUPtr handle_frame(QUICEncryptionLevel level, const QUICFrame &frame) override; diff --git a/iocore/net/QUICNetVConnection.cc b/iocore/net/QUICNetVConnection.cc index d16542d..f2d3dfb 100644 --- a/iocore/net/QUICNetVConnection.cc +++ b/iocore/net/QUICNetVConnection.cc @@ -92,7 +92,6 @@ QUICNetVConnection::init(QUICConnectionId peer_cid, QUICConnectionId original_ci QUICPacketHandler *packet_handler) { SET_HANDLER((NetVConnHandler)&QUICNetVConnection::startEvent); - this->_packet_transmitter_mutex = new_ProxyMutex(); this->_udp_con = udp_con; this->_packet_handler = packet_handler; this->_peer_quic_connection_id = peer_cid; @@ -117,7 +116,6 @@ QUICNetVConnection::init(QUICConnectionId peer_cid, QUICConnectionId original_ci UDPConnection *udp_con, QUICPacketHandler *packet_handler, QUICConnectionTable *ctable) { SET_HANDLER((NetVConnHandler)&QUICNetVConnection::acceptEvent); - this->_packet_transmitter_mutex = new_ProxyMutex(); this->_udp_con = udp_con; this->_packet_handler = packet_handler; this->_peer_quic_connection_id = peer_cid; @@ -271,7 +269,7 @@ QUICNetVConnection::start() this->_congestion_controller = new QUICCongestionController(this); for (auto s : QUIC_PN_SPACES) { int index = static_cast<int>(s); - QUICLossDetector *ld = new QUICLossDetector(this, this, this->_congestion_controller, &this->_rtt_measure, index); + QUICLossDetector *ld = new QUICLossDetector(this, this->_congestion_controller, &this->_rtt_measure, index); this->_frame_dispatcher->add_handler(ld); this->_loss_detector[index] = ld; } @@ -481,18 +479,6 @@ QUICNetVConnection::stream_manager() } void -QUICNetVConnection::retransmit_packet(const QUICPacket &packet) -{ - QUICConDebug("[NOP] Retransmit %s packet #%" PRIu64, QUICDebugNames::packet_type(packet.type()), packet.packet_number()); -} - -Ptr<ProxyMutex> -QUICNetVConnection::get_packet_transmitter_mutex() -{ - return this->_packet_transmitter_mutex; -} - -void QUICNetVConnection::handle_received_packet(UDPPacket *packet) { this->_packet_recv_queue.enqueue(packet); @@ -939,7 +925,6 @@ QUICNetVConnection::_state_handshake_process_version_negotiation_packet(QUICPack this->_loss_detector[static_cast<int>(s)]->reset(); } this->_congestion_controller->reset(); - SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex, this_ethread()); // start handshake over this->_handshake_handler->reset(); @@ -1015,7 +1000,6 @@ QUICNetVConnection::_state_handshake_process_retry_packet(QUICPacketUPtr packet) this->_loss_detector[static_cast<int>(s)]->reset(); } this->_congestion_controller->reset(); - SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex, this_ethread()); this->_packet_recv_queue.reset(); // Initialize Key Materials with peer CID. Because peer CID is DCID of (second) INITIAL packet from client which reply to RETRY @@ -1324,7 +1308,6 @@ QUICNetVConnection::_packetize_frames(QUICEncryptionLevel level, uint64_t max_pa size_t len = 0; ats_unique_buf buf = ats_unique_malloc(max_packet_size); - SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex, this_ethread()); std::vector<QUICFrameInfo> frames; if (!this->_has_ack_eliciting_packet_out) { @@ -1420,8 +1403,6 @@ QUICNetVConnection::_packetize_frames(QUICEncryptionLevel level, uint64_t max_pa void QUICNetVConnection::_packetize_closing_frame() { - SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex, this_ethread()); - if (this->_connection_error == nullptr || this->_the_final_packet) { return; } @@ -1638,7 +1619,6 @@ QUICNetVConnection::_dequeue_recv_packet(QUICPacketCreationResult &result) void QUICNetVConnection::_schedule_packet_write_ready(bool delay) { - SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex, this_ethread()); if (!this->_packet_write_ready) { QUICConVVVDebug("Schedule %s event", QUICDebugNames::quic_event(QUIC_EVENT_PACKET_WRITE_READY)); if (delay) { @@ -1652,7 +1632,6 @@ QUICNetVConnection::_schedule_packet_write_ready(bool delay) void QUICNetVConnection::_unschedule_packet_write_ready() { - SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex, this_ethread()); if (this->_packet_write_ready) { this->_packet_write_ready->cancel(); this->_packet_write_ready = nullptr; @@ -1662,7 +1641,6 @@ QUICNetVConnection::_unschedule_packet_write_ready() void QUICNetVConnection::_close_packet_write_ready(Event *data) { - SCOPED_MUTEX_LOCK(packet_transmitter_lock, this->_packet_transmitter_mutex, this_ethread()); ink_assert(this->_packet_write_ready == data); this->_packet_write_ready = nullptr; } diff --git a/iocore/net/quic/Mock.h b/iocore/net/quic/Mock.h index bccd6d1..94c8c46 100644 --- a/iocore/net/quic/Mock.h +++ b/iocore/net/quic/Mock.h @@ -29,7 +29,6 @@ #include "QUICStreamManager.h" #include "QUICLossDetector.h" #include "QUICEvents.h" -#include "QUICPacketTransmitter.h" class MockQUICStreamManager : public QUICStreamManager { @@ -185,18 +184,6 @@ public: return std::string_view("00000000-00000000"sv); } - void - retransmit_packet(const QUICPacket &packet) override - { - ++_retransmit_count; - } - - Ptr<ProxyMutex> - get_packet_transmitter_mutex() override - { - return this->_mutex; - } - std::vector<QUICFrameType> interests() override { @@ -350,29 +337,6 @@ class MockQUICConnectionInfoProvider : public QUICConnectionInfoProvider } }; -class MockQUICPacketTransmitter : public QUICPacketTransmitter -{ -public: - MockQUICPacketTransmitter() : QUICPacketTransmitter() { this->_mutex = new_ProxyMutex(); }; - - void - retransmit_packet(const QUICPacket &packet) override - { - this->retransmitted.insert(packet.packet_number()); - } - - Ptr<ProxyMutex> - get_packet_transmitter_mutex() override - { - return this->_mutex; - } - - Ptr<ProxyMutex> _mutex; - - std::set<QUICPacketNumber> transmitted; - std::set<QUICPacketNumber> retransmitted; -}; - class MockQUICCongestionController : public QUICCongestionController { public: @@ -421,9 +385,8 @@ private: class MockQUICLossDetector : public QUICLossDetector { public: - MockQUICLossDetector(QUICPacketTransmitter *transmitter, QUICConnectionInfoProvider *info, QUICCongestionController *cc, - QUICRTTMeasure *rtt_measure, int index) - : QUICLossDetector(transmitter, info, cc, rtt_measure, index) + MockQUICLossDetector(QUICConnectionInfoProvider *info, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure, int index) + : QUICLossDetector(info, cc, rtt_measure, index) { } void @@ -702,13 +665,14 @@ class MockQUICFrameGenerator : public QUICFrameGenerator { public: bool - will_generate_frame(QUICEncryptionLevel level) override + will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override { return true; } QUICFrame * - generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size) override + generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size, + ink_hrtime timestamp) override { QUICFrame *frame = QUICFrameFactory::create_ping_frame(buf, 0, this); QUICFrameInformationUPtr info = QUICFrameInformationUPtr(quicFrameInformationAllocator.alloc()); diff --git a/iocore/net/quic/QUICConnection.h b/iocore/net/quic/QUICConnection.h index 96efe4f..36cc5fb 100644 --- a/iocore/net/quic/QUICConnection.h +++ b/iocore/net/quic/QUICConnection.h @@ -25,7 +25,6 @@ #include "I_EventSystem.h" #include "I_NetVConnection.h" -#include "QUICPacketTransmitter.h" #include "QUICFrameHandler.h" class QUICApplication; @@ -50,7 +49,7 @@ public: virtual std::string_view negotiated_application_name() const = 0; }; -class QUICConnection : public QUICPacketTransmitter, public QUICFrameHandler, public QUICConnectionInfoProvider +class QUICConnection : public QUICFrameHandler, public QUICConnectionInfoProvider { public: virtual QUICStreamManager *stream_manager() = 0; diff --git a/iocore/net/quic/QUICFrameHandler.h b/iocore/net/quic/QUICFrameHandler.h index 12c3fc9..5a2870f 100644 --- a/iocore/net/quic/QUICFrameHandler.h +++ b/iocore/net/quic/QUICFrameHandler.h @@ -24,6 +24,8 @@ #pragma once #include <vector> +#include "QUICTypes.h" + class QUICFrame; class QUICFrameHandler diff --git a/iocore/net/quic/QUICLossDetector.cc b/iocore/net/quic/QUICLossDetector.cc index d15287e..337d9e8 100644 --- a/iocore/net/quic/QUICLossDetector.cc +++ b/iocore/net/quic/QUICLossDetector.cc @@ -37,9 +37,9 @@ Debug("v_quic_loss_detector", "[%s] [%s] " fmt, this->_info->cids().data(), QUICDebugNames::pn_space(this->_pn_space_index), \ ##__VA_ARGS__) -QUICLossDetector::QUICLossDetector(QUICPacketTransmitter *transmitter, QUICConnectionInfoProvider *info, - QUICCongestionController *cc, QUICRTTMeasure *rtt_measure, int index) - : _transmitter(transmitter), _info(info), _cc(cc), _rtt_measure(rtt_measure), _pn_space_index(index) +QUICLossDetector::QUICLossDetector(QUICConnectionInfoProvider *info, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure, + int index) + : _info(info), _cc(cc), _rtt_measure(rtt_measure), _pn_space_index(index) { this->mutex = new_ProxyMutex(); this->_loss_detection_mutex = new_ProxyMutex(); @@ -64,8 +64,7 @@ QUICLossDetector::~QUICLossDetector() this->_sent_packets.clear(); - this->_transmitter = nullptr; - this->_cc = nullptr; + this->_cc = nullptr; } int @@ -202,7 +201,6 @@ QUICLossDetector::_on_packet_sent(QUICPacketNumber packet_number, bool ack_elici void QUICLossDetector::_on_ack_received(const QUICAckFrame &ack_frame) { - SCOPED_MUTEX_LOCK(transmitter_lock, this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread()); SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread()); this->_largest_acked_packet = std::max(this->_largest_acked_packet, ack_frame.largest_acknowledged()); @@ -285,7 +283,6 @@ QUICLossDetector::_update_rtt(ink_hrtime latest_rtt, ink_hrtime ack_delay) void QUICLossDetector::_on_packet_acked(const PacketInfo &acked_packet) { - SCOPED_MUTEX_LOCK(transmitter_lock, this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread()); SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread()); // QUICLDDebug("Packet number %" PRIu64 " has been acked", acked_packet_number); @@ -395,7 +392,6 @@ QUICLossDetector::_on_loss_detection_timeout() void QUICLossDetector::_detect_lost_packets() { - SCOPED_MUTEX_LOCK(transmitter_lock, this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread()); SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread()); this->_loss_time = 0; ink_hrtime loss_delay = this->_k_time_threshold * std::max(this->_latest_rtt, this->_smoothed_rtt); @@ -458,7 +454,6 @@ QUICLossDetector::_detect_lost_packets() void QUICLossDetector::_retransmit_all_unacked_crypto_data() { - SCOPED_MUTEX_LOCK(transmitter_lock, this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread()); SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread()); std::set<QUICPacketNumber> retransmitted_crypto_packets; std::map<QUICPacketNumber, PacketInfo *> lost_packets; @@ -480,7 +475,6 @@ QUICLossDetector::_retransmit_all_unacked_crypto_data() void QUICLossDetector::_send_two_packets() { - SCOPED_MUTEX_LOCK(transmitter_lock, this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread()); SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread()); // TODO sent ping } @@ -490,7 +484,6 @@ QUICLossDetector::_send_two_packets() void QUICLossDetector::_retransmit_lost_packet(QUICPacketUPtr &packet) { - SCOPED_MUTEX_LOCK(transmitter_lock, this->_transmitter->get_packet_transmitter_mutex().get(), this_ethread()); SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread()); QUICLDDebug("[NOP] Retransmit %s packet #%" PRIu64, QUICDebugNames::packet_type(packet->type()), packet->packet_number()); diff --git a/iocore/net/quic/QUICLossDetector.h b/iocore/net/quic/QUICLossDetector.h index 42a2102..8f69c95 100644 --- a/iocore/net/quic/QUICLossDetector.h +++ b/iocore/net/quic/QUICLossDetector.h @@ -35,7 +35,6 @@ #include "QUICPacket.h" #include "QUICFrame.h" #include "QUICFrameHandler.h" -#include "QUICPacketTransmitter.h" #include "QUICConnection.h" class QUICLossDetector; @@ -119,8 +118,7 @@ private: class QUICLossDetector : public Continuation, public QUICFrameHandler { public: - QUICLossDetector(QUICPacketTransmitter *transmitter, QUICConnectionInfoProvider *info, QUICCongestionController *cc, - QUICRTTMeasure *rtt_measure, int index); + QUICLossDetector(QUICConnectionInfoProvider *info, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure, int index); ~QUICLossDetector(); int event_handler(int event, Event *edata); @@ -194,9 +192,8 @@ private: void _send_one_packet(); void _send_two_packets(); - QUICPacketTransmitter *_transmitter = nullptr; - QUICConnectionInfoProvider *_info = nullptr; - QUICCongestionController *_cc = nullptr; - QUICRTTMeasure *_rtt_measure = nullptr; - int _pn_space_index = -1; + QUICConnectionInfoProvider *_info = nullptr; + QUICCongestionController *_cc = nullptr; + QUICRTTMeasure *_rtt_measure = nullptr; + int _pn_space_index = -1; }; diff --git a/iocore/net/quic/QUICPacketTransmitter.h b/iocore/net/quic/QUICPacketTransmitter.h deleted file mode 100644 index c60e55c..0000000 --- a/iocore/net/quic/QUICPacketTransmitter.h +++ /dev/null @@ -1,44 +0,0 @@ -/** @file - * - * A brief file description - * - * @section license License - * - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#pragma once - -#include "QUICPacket.h" -#include "I_EventSystem.h" - -class QUICPacketTransmitter -{ -public: - /* - * Enqueue a packet for retransmission - * All frames except ACK and PADDING frames in the original packet will be retransmitted on a new packet. - * This sends QUIC_PACKET_WRITE_READY event. - */ - virtual void retransmit_packet(const QUICPacket &packet) = 0; - - /* - * Returns a mutex for transmitter interfaces. - * You have to acquire a lock with this mutex before calling any methods provieded by QUICPacketTransmitter - */ - virtual Ptr<ProxyMutex> get_packet_transmitter_mutex() = 0; -}; diff --git a/iocore/net/quic/test/test_QUICAckFrameCreator.cc b/iocore/net/quic/test/test_QUICAckFrameCreator.cc index 7e0d410..48fc90f 100644 --- a/iocore/net/quic/test/test_QUICAckFrameCreator.cc +++ b/iocore/net/quic/test/test_QUICAckFrameCreator.cc @@ -34,13 +34,13 @@ TEST_CASE("QUICAckFrameManager", "[quic]") uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE]; // Initial state - QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame == nullptr); // One packet ack_manager.update(level, 1, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 0); @@ -48,14 +48,14 @@ TEST_CASE("QUICAckFrameManager", "[quic]") CHECK(frame->ack_block_section()->first_ack_block() == 0); // retry - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); // Not sequential ack_manager.update(level, 2, 1, false); ack_manager.update(level, 5, 1, false); ack_manager.update(level, 3, 1, false); ack_manager.update(level, 4, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 0); @@ -66,7 +66,7 @@ TEST_CASE("QUICAckFrameManager", "[quic]") ack_manager.update(level, 6, 1, false); ack_manager.update(level, 7, 1, false); ack_manager.update(level, 10, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 1); @@ -77,14 +77,14 @@ TEST_CASE("QUICAckFrameManager", "[quic]") // on frame acked ack_manager.on_frame_acked(frame->id()); - CHECK(ack_manager.will_generate_frame(level) == false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + CHECK(ack_manager.will_generate_frame(level, 0) == false); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); CHECK(ack_frame == nullptr); ack_manager.update(level, 11, 1, false); ack_manager.update(level, 12, 1, false); ack_manager.update(level, 13, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 0); @@ -98,11 +98,11 @@ TEST_CASE("QUICAckFrameManager", "[quic]") ack_manager.update(level, 14, 1, true); ack_manager.update(level, 15, 1, true); ack_manager.update(level, 16, 1, true); - CHECK(ack_manager.will_generate_frame(level) == false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + CHECK(ack_manager.will_generate_frame(level, 0) == false); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); ack_manager.update(level, 17, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 0); @@ -119,7 +119,7 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]") QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT; ack_manager.update(level, 2, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); } SECTION("QUIC delay ack and unorder packet", "[quic]") @@ -128,13 +128,13 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]") QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT; ack_manager.update(level, 0, 1, false); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); ack_manager.update(level, 1, 1, false); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); ack_manager.update(level, 3, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); } SECTION("QUIC delay too much time", "[quic]") @@ -144,12 +144,12 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]") QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT; ack_manager.update(level, 0, 1, false); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); sleep(1); Thread::get_hrtime_updated(); ack_manager.update(level, 1, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); } SECTION("QUIC intial packet", "[quic]") @@ -158,7 +158,7 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]") QUICEncryptionLevel level = QUICEncryptionLevel::INITIAL; ack_manager.update(level, 0, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); } SECTION("QUIC handshake packet", "[quic]") @@ -167,7 +167,7 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]") QUICEncryptionLevel level = QUICEncryptionLevel::HANDSHAKE; ack_manager.update(level, 0, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); } SECTION("QUIC frame fired", "[quic]") @@ -176,11 +176,11 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]") QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT; ack_manager.update(level, 0, 1, false); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); sleep(1); Thread::get_hrtime_updated(); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); } SECTION("QUIC refresh frame", "[quic]") @@ -189,21 +189,21 @@ TEST_CASE("QUICAckFrameManager should send", "[quic]") QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT; uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE]; - QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame == nullptr); // unorder frame should sent immediately ack_manager.update(level, 1, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); ack_manager.update(level, 2, 1, false); // Delay due to some reason, the frame is not valued any more, but still valued sleep(1); Thread::get_hrtime_updated(); - CHECK(ack_manager.will_generate_frame(level) == true); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + CHECK(ack_manager.will_generate_frame(level, 0) == true); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame->ack_block_count() == 0); @@ -220,7 +220,7 @@ TEST_CASE("QUICAckFrameManager_loss_recover", "[quic]") // Initial state uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE]; - QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame == nullptr); @@ -230,7 +230,7 @@ TEST_CASE("QUICAckFrameManager_loss_recover", "[quic]") ack_manager.update(level, 8, 1, false); ack_manager.update(level, 9, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 2); @@ -238,11 +238,11 @@ TEST_CASE("QUICAckFrameManager_loss_recover", "[quic]") CHECK(frame->ack_block_section()->first_ack_block() == 1); CHECK(frame->ack_block_section()->begin()->gap() == 0); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); ack_manager.update(level, 7, 1, false); ack_manager.update(level, 4, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 1); @@ -299,7 +299,7 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]") uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE]; // Initial state - QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame == nullptr); @@ -309,7 +309,7 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]") ack_manager.update(level, 8, 1, false); ack_manager.update(level, 9, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 2); @@ -318,8 +318,8 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]") CHECK(frame->ack_block_section()->begin()->gap() == 0); ack_manager.on_frame_lost(frame->id()); - CHECK(ack_manager.will_generate_frame(level) == true); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + CHECK(ack_manager.will_generate_frame(level, 0) == true); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 2); @@ -327,13 +327,13 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]") CHECK(frame->ack_block_section()->first_ack_block() == 1); CHECK(frame->ack_block_section()->begin()->gap() == 0); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); ack_manager.on_frame_lost(frame->id()); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); ack_manager.update(level, 7, 1, false); ack_manager.update(level, 4, 1, false); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 1); @@ -341,7 +341,7 @@ TEST_CASE("QUICAckFrameManager lost_frame", "[quic]") CHECK(frame->ack_block_section()->first_ack_block() == 5); CHECK(frame->ack_block_section()->begin()->gap() == 0); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); } TEST_CASE("QUICAckFrameManager ack only packet", "[quic]") @@ -353,7 +353,7 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]") uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE]; // Initial state - QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame == nullptr); @@ -363,9 +363,9 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]") ack_manager.update(level, 4, 1, false); ack_manager.update(level, 5, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 0); @@ -375,7 +375,7 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]") ack_manager.update(level, 6, 1, true); ack_manager.update(level, 7, 1, true); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); } SECTION("ONE_RTT") @@ -385,7 +385,7 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]") uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE]; // Initial state - QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); QUICAckFrame *frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame == nullptr); @@ -395,9 +395,9 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]") ack_manager.update(level, 4, 1, false); ack_manager.update(level, 5, 1, false); - CHECK(ack_manager.will_generate_frame(level) == true); + CHECK(ack_manager.will_generate_frame(level, 0) == true); - ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX); + ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0); frame = static_cast<QUICAckFrame *>(ack_frame); CHECK(frame != nullptr); CHECK(frame->ack_block_count() == 0); @@ -407,6 +407,6 @@ TEST_CASE("QUICAckFrameManager ack only packet", "[quic]") ack_manager.update(level, 6, 1, true); ack_manager.update(level, 7, 1, true); - CHECK(ack_manager.will_generate_frame(level) == false); + CHECK(ack_manager.will_generate_frame(level, 0) == false); } } diff --git a/iocore/net/quic/test/test_QUICFlowController.cc b/iocore/net/quic/test/test_QUICFlowController.cc index 8333560..a5120b1 100644 --- a/iocore/net/quic/test/test_QUICFlowController.cc +++ b/iocore/net/quic/test/test_QUICFlowController.cc @@ -98,7 +98,7 @@ TEST_CASE("QUICFlowController_Local_Connection", "[quic]") fc.forward_limit(2048); CHECK(fc.current_offset() == 1024); CHECK(fc.current_limit() == 2048); - QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024); + QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0); CHECK(frame); CHECK(frame->type() == QUICFrameType::MAX_DATA); @@ -150,7 +150,7 @@ TEST_CASE("QUICFlowController_Remote_Connection", "[quic]") CHECK(fc.current_offset() == 1000); CHECK(fc.current_limit() == 1024); CHECK(ret != 0); - QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024); + QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0); CHECK(frame); CHECK(frame->type() == QUICFrameType::DATA_BLOCKED); @@ -181,9 +181,9 @@ TEST_CASE("QUICFlowController_Remote_Connection_ZERO_Credit", "[quic]") CHECK(fc.current_limit() == 1024); CHECK(ret == 0); - CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT)); + CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0)); // if there're anything to send - QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024); + QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0); CHECK(frame); CHECK(frame->type() == QUICFrameType::DATA_BLOCKED); @@ -247,7 +247,7 @@ TEST_CASE("QUICFlowController_Local_Stream", "[quic]") fc.forward_limit(2048); CHECK(fc.current_offset() == 1024); CHECK(fc.current_limit() == 2048); - QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024); + QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0); CHECK(frame); CHECK(frame->type() == QUICFrameType::MAX_STREAM_DATA); @@ -288,7 +288,7 @@ TEST_CASE("QUICFlowController_Remote_Stream", "[quic]") CHECK(ret == 0); CHECK(fc.credit() == 0); - CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT)); + CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0)); // Delay ret = fc.update(512); @@ -324,23 +324,23 @@ TEST_CASE("Frame retransmission", "[quic]") QUICRemoteConnectionFlowController fc(1024); // Check initial state - auto frame = fc.generate_frame(frame_buf, level, 1024, 1024); + auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); CHECK(!frame); ret = fc.update(1024); CHECK(ret == 0); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 1024); QUICFrameId id = frame->id(); // Don't retransmit unless the frame is lost - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(!frame); // Retransmit fc.on_frame_lost(id); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 1024); @@ -348,12 +348,12 @@ TEST_CASE("Frame retransmission", "[quic]") fc.on_frame_lost(frame->id()); fc.forward_limit(2048); ret = fc.update(1536); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); CHECK(!frame); // This should not be retransmition ret = fc.update(2048); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 2048); } @@ -365,23 +365,23 @@ TEST_CASE("Frame retransmission", "[quic]") QUICRemoteStreamFlowController fc(1024, 0); // Check initial state - auto frame = fc.generate_frame(frame_buf, level, 1024, 1024); + auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); CHECK(!frame); ret = fc.update(1024); CHECK(ret == 0); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 1024); QUICFrameId id = frame->id(); // Don't retransmit unless the frame is lost - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(!frame); // Retransmit fc.on_frame_lost(id); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 1024); @@ -389,12 +389,12 @@ TEST_CASE("Frame retransmission", "[quic]") fc.on_frame_lost(frame->id()); fc.forward_limit(2048); ret = fc.update(1536); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); CHECK(!frame); // This should not be retransmition ret = fc.update(2048); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 2048); } @@ -407,23 +407,23 @@ TEST_CASE("Frame retransmission", "[quic]") QUICLocalConnectionFlowController fc(&rp, 1024); // Check initial state - auto frame = fc.generate_frame(frame_buf, level, 1024, 1024); + auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); CHECK(!frame); fc.update(1024); fc.forward_limit(1024); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 1024); QUICFrameId id = frame->id(); // Don't retransmit unless the frame is lost - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(!frame); // Retransmit fc.on_frame_lost(id); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 1024); @@ -431,7 +431,7 @@ TEST_CASE("Frame retransmission", "[quic]") fc.on_frame_lost(id); fc.forward_limit(2048); fc.update(2048); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 2048); } @@ -444,23 +444,23 @@ TEST_CASE("Frame retransmission", "[quic]") QUICLocalStreamFlowController fc(&rp, 1024, 0); // Check initial state - auto frame = fc.generate_frame(frame_buf, level, 1024, 1024); + auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); CHECK(!frame); fc.update(1024); fc.forward_limit(1024); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data() == 1024); QUICFrameId id = frame->id(); // Don't retransmit unless the frame is lost - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(!frame); // Retransmit fc.on_frame_lost(id); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data() == 1024); @@ -468,7 +468,7 @@ TEST_CASE("Frame retransmission", "[quic]") fc.on_frame_lost(id); fc.forward_limit(2048); fc.update(2048); - frame = fc.generate_frame(frame_buf, level, 1024, 1024); + frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0); REQUIRE(frame); CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data() == 2048); } diff --git a/iocore/net/quic/test/test_QUICFrameDispatcher.cc b/iocore/net/quic/test/test_QUICFrameDispatcher.cc index 501eaa9..9f76b64 100644 --- a/iocore/net/quic/test/test_QUICFrameDispatcher.cc +++ b/iocore/net/quic/test/test_QUICFrameDispatcher.cc @@ -38,11 +38,10 @@ TEST_CASE("QUICFrameHandler", "[quic]") MockQUICConnection connection; MockQUICStreamManager streamManager; - MockQUICPacketTransmitter tx; MockQUICConnectionInfoProvider info; MockQUICCongestionController cc(&info); QUICRTTMeasure rtt_measure; - MockQUICLossDetector lossDetector(&tx, &info, &cc, &rtt_measure, 0); + MockQUICLossDetector lossDetector(&info, &cc, &rtt_measure, 0); QUICFrameDispatcher quicFrameDispatcher(&info); quicFrameDispatcher.add_handler(&connection); diff --git a/iocore/net/quic/test/test_QUICLossDetector.cc b/iocore/net/quic/test/test_QUICLossDetector.cc index bbdc59f..2074883 100644 --- a/iocore/net/quic/test/test_QUICLossDetector.cc +++ b/iocore/net/quic/test/test_QUICLossDetector.cc @@ -36,10 +36,9 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]") QUICAckFrameManager afm; QUICConnectionId connection_id = {reinterpret_cast<const uint8_t *>("\x01"), 1}; - MockQUICPacketTransmitter tx; MockQUICConnectionInfoProvider info; MockQUICCongestionController cc(&info); - QUICLossDetector detector(&tx, &info, &cc, &rtt_measure, 0); + QUICLossDetector detector(&info, &cc, &rtt_measure, 0); ats_unique_buf payload = ats_unique_malloc(512); size_t payload_len = 512; QUICPacketUPtr packet = QUICPacketFactory::create_null_packet(); @@ -52,7 +51,7 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]") // Check initial state uint8_t frame_buffer[1024] = {0}; CHECK(g.lost_frame_count == 0); - QUICFrame *ping_frame = g.generate_frame(frame_buffer, QUICEncryptionLevel::HANDSHAKE, 4, UINT16_MAX); + QUICFrame *ping_frame = g.generate_frame(frame_buffer, QUICEncryptionLevel::HANDSHAKE, 4, UINT16_MAX, 0); uint8_t raw[4]; size_t len; @@ -85,9 +84,6 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]") SECTION("1-RTT") { - // Check initial state - CHECK(tx.retransmitted.size() == 0); - // Send packet (1) to (7) payload = ats_unique_malloc(payload_len); QUICPacketUPtr packet1 = pf.create_protected_packet(connection_id, detector.largest_acked_packet_number(), std::move(payload), @@ -152,7 +148,7 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]") afm.update(QUICEncryptionLevel::INITIAL, pn9, payload_len, false); afm.update(QUICEncryptionLevel::INITIAL, pn10, payload_len, false); uint8_t buf[QUICFrame::MAX_INSTANCE_SIZE]; - QUICFrame *x = afm.generate_frame(buf, QUICEncryptionLevel::INITIAL, 2048, 2048); + QUICFrame *x = afm.generate_frame(buf, QUICEncryptionLevel::INITIAL, 2048, 2048, 0); frame = static_cast<QUICAckFrame *>(x); ink_hrtime_sleep(HRTIME_MSECONDS(1000)); detector.handle_frame(QUICEncryptionLevel::INITIAL, *frame); @@ -176,14 +172,10 @@ TEST_CASE("QUICLossDetector_Loss", "[quic]") TEST_CASE("QUICLossDetector_HugeGap", "[quic]") { uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE]; - MockQUICPacketTransmitter tx; MockQUICConnectionInfoProvider info; MockQUICCongestionController cc(&info); QUICRTTMeasure rtt_measure; - QUICLossDetector detector(&tx, &info, &cc, &rtt_measure, 0); - - // Check initial state - CHECK(tx.retransmitted.size() == 0); + QUICLossDetector detector(&info, &cc, &rtt_measure, 0); auto t1 = Thread::get_hrtime(); QUICAckFrame *ack = QUICFrameFactory::create_ack_frame(frame_buf, 100000000, 100, 10000000); diff --git a/iocore/net/quic/test/test_QUICStream.cc b/iocore/net/quic/test/test_QUICStream.cc index bf6aadc..e18eaf1 100644 --- a/iocore/net/quic/test/test_QUICStream.cc +++ b/iocore/net/quic/test/test_QUICStream.cc @@ -223,50 +223,50 @@ TEST_CASE("QUICStream", "[quic]") write_buffer->write(data, 1024); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM); - CHECK(stream->will_generate_frame(level) == false); + CHECK(stream->will_generate_frame(level, 0) == false); write_buffer->write(data, 1024); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM); - CHECK(stream->will_generate_frame(level) == false); + CHECK(stream->will_generate_frame(level, 0) == false); write_buffer->write(data, 1024); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM); - CHECK(stream->will_generate_frame(level) == false); + CHECK(stream->will_generate_frame(level, 0) == false); write_buffer->write(data, 1024); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM); - CHECK(stream->will_generate_frame(level) == false); + CHECK(stream->will_generate_frame(level, 0) == false); // This should not send a frame because of flow control write_buffer->write(data, 1024); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame); CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED); - CHECK(stream->will_generate_frame(level) == true); + CHECK(stream->will_generate_frame(level, 0) == true); // Update window stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5120)); // This should send a frame stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM); - CHECK(stream->will_generate_frame(level) == false); + CHECK(stream->will_generate_frame(level, 0) == false); // Update window stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5632)); @@ -274,24 +274,24 @@ TEST_CASE("QUICStream", "[quic]") // This should send a frame write_buffer->write(data, 1024); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM); - CHECK(stream->will_generate_frame(level) == true); + CHECK(stream->will_generate_frame(level, 0) == true); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED); // Update window stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 6144)); stream->handleEvent(VC_EVENT_WRITE_READY, nullptr); - CHECK(stream->will_generate_frame(level) == true); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + CHECK(stream->will_generate_frame(level, 0) == true); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); CHECK(frame->type() == QUICFrameType::STREAM); - CHECK(stream->will_generate_frame(level) == false); + CHECK(stream->will_generate_frame(level, 0) == false); } /* @@ -357,15 +357,15 @@ TEST_CASE("QUICStream", "[quic]") QUICFrame *frame = nullptr; stream->reset(QUICStreamErrorUPtr(new QUICStreamError(stream.get(), QUIC_APP_ERROR_CODE_STOPPING))); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); REQUIRE(frame); CHECK(frame->type() == QUICFrameType::RESET_STREAM); // Don't send it again untill it is considers as lost - CHECK(stream->generate_frame(frame_buf, level, 4096, 4096) == nullptr); + CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr); // Loss the frame stream->on_frame_lost(frame->id()); // After the loss the frame should be regenerated - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); REQUIRE(frame); CHECK(frame->type() == QUICFrameType::RESET_STREAM); } @@ -387,15 +387,15 @@ TEST_CASE("QUICStream", "[quic]") QUICFrame *frame = nullptr; stream->stop_sending(QUICStreamErrorUPtr(new QUICStreamError(stream.get(), QUIC_APP_ERROR_CODE_STOPPING))); - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); REQUIRE(frame); CHECK(frame->type() == QUICFrameType::STOP_SENDING); // Don't send it again untill it is considers as lost - CHECK(stream->generate_frame(frame_buf, level, 4096, 4096) == nullptr); + CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr); // Loss the frame stream->on_frame_lost(frame->id()); // After the loss the frame should be regenerated - frame = stream->generate_frame(frame_buf, level, 4096, 4096); + frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0); REQUIRE(frame); CHECK(frame->type() == QUICFrameType::STOP_SENDING); }