quiche: add support of delayed close to QUIC session

source/common/network/connection_impl_base.cc

@@ -16,6 +16,7 @@ void ConnectionImplBase::setConnectionStats(const ConnectionStats& stats) {
          "with the configured filter chain.");
   connection_stats_ = std::make_unique<ConnectionStats>(stats);
 }
+
 void ConnectionImplBase::setDelayedCloseTimeout(std::chrono::milliseconds timeout) {
   // Validate that this is only called prior to issuing a close() or closeSocket().
   ASSERT(delayed_close_timer_ == nullptr && state() == State::Open);

source/common/network/connection_impl_base.h

@@ -12,7 +12,6 @@ class ConnectionImplBase : public FilterManagerConnection,
                            protected Logger::Loggable<Logger::Id::connection> {
 public:
   ConnectionImplBase(Event::Dispatcher& dispatcher, uint64_t id);
-  ~ConnectionImplBase() override {}
 
   // Network::Connection
   void addConnectionCallbacks(ConnectionCallbacks& cb) override;

source/extensions/quic_listeners/quiche/envoy_quic_server_session.cc

@@ -92,12 +92,26 @@ void EnvoyQuicServerSession::SendGoAway(quic::QuicErrorCode error_code, const st
   }
 }
 
+void EnvoyQuicServerSession::OnCanWrite() {
+  quic::QuicServerSessionBase::OnCanWrite();
+  if (inDelayedClose() && !HasDataToWrite()) {
+    if (delayed_close_state_ == DelayedCloseState::CloseAfterFlushAndWait) {
+      ASSERT(delayed_close_timer_ != nullptr);
+      delayed_close_timer_->enableTimer(delayed_close_timeout_);
+    } else {
+      closeConnectionImmediately();
+    }
+  }
+}
+
 void EnvoyQuicServerSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   quic::QuicServerSessionBase::OnCryptoHandshakeEvent(event);
   if (event == HANDSHAKE_CONFIRMED) {
     raiseConnectionEvent(Network::ConnectionEvent::Connected);
   }
 }
 
+bool EnvoyQuicServerSession::hasDataToWrite() { return HasDataToWrite(); }
+
 } // namespace Quic
 } // namespace Envoy

source/extensions/quic_listeners/quiche/envoy_quic_server_session.h

@@ -50,6 +50,7 @@ class EnvoyQuicServerSession : public quic::QuicServerSessionBase,
                           quic::ConnectionCloseSource source) override;
   void Initialize() override;
   void SendGoAway(quic::QuicErrorCode error_code, const std::string& reason) override;
+  void OnCanWrite() override;
   // quic::QuicSpdySession
   void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
 
@@ -68,6 +69,9 @@ class EnvoyQuicServerSession : public quic::QuicServerSessionBase,
   quic::QuicSpdyStream* CreateOutgoingBidirectionalStream() override;
   quic::QuicSpdyStream* CreateOutgoingUnidirectionalStream() override;
 
+  // QuicFilterManagerConnectionImpl
+  bool hasDataToWrite() override;
+
 private:
   void setUpRequestDecoder(EnvoyQuicStream& stream);
 

source/extensions/quic_listeners/quiche/quic_filter_manager_connection_impl.cc

@@ -50,20 +50,43 @@ bool QuicFilterManagerConnectionImpl::aboveHighWatermark() const {
 }
 
 void QuicFilterManagerConnectionImpl::close(Network::ConnectionCloseType type) {
-  if (type != Network::ConnectionCloseType::NoFlush) {
-    // TODO(danzh): Implement FlushWrite and FlushWriteAndDelay mode.
-  }
   if (quic_connection_ == nullptr) {
     // Already detached from quic connection.
     return;
   }
-  closeConnectionImmediately();
-}
-
-void QuicFilterManagerConnectionImpl::setDelayedCloseTimeout(std::chrono::milliseconds timeout) {
-  if (timeout != std::chrono::milliseconds::zero()) {
-    // TODO(danzh) support delayed close of connection.
-    NOT_IMPLEMENTED_GCOVR_EXCL_LINE;
+  const bool delayed_close_timeout_configured = delayed_close_timeout_.count() > 0;
+  if (hasDataToWrite() && type != Network::ConnectionCloseType::NoFlush) {
+    // QUIC connection has unsent data and caller wants to flush them. Wait for flushing or timeout.
+    if (!inDelayedClose() && delayed_close_timeout_configured) {
+      // Only set alarm if not in delay close mode yet.
+      initializeDelayedCloseTimer();
+    }
+    // Update delay close state according to current call.
+    if (delayed_close_timeout_configured &&
+        type == Network::ConnectionCloseType::FlushWriteAndDelay) {
+      delayed_close_state_ = DelayedCloseState::CloseAfterFlushAndWait;
+    } else {
+      delayed_close_state_ = DelayedCloseState::CloseAfterFlush;
+    }
+  } else {
+    if (hasDataToWrite()) {
+      // Quic connection has unsent data but caller wants to close right away.
+      ASSERT(type == Network::ConnectionCloseType::NoFlush);
+      quic_connection_->OnCanWrite();
+      closeConnectionImmediately();
+    } else {
+      // Quic connection doesn't have unsent data. It's upto caller and
+      // configuration whether to wait or not before closing.
+      if (delayed_close_timeout_configured &&
+          type == Network::ConnectionCloseType::FlushWriteAndDelay) {
+        if (!inDelayedClose()) {
+          initializeDelayedCloseTimer();
+        }
+        delayed_close_state_ = DelayedCloseState::CloseAfterFlushAndWait;
+      } else {
+        closeConnectionImmediately();
+      }
+    }
   }
 }
 
@@ -115,6 +138,9 @@ void QuicFilterManagerConnectionImpl::onConnectionCloseEvent(
 }
 
 void QuicFilterManagerConnectionImpl::closeConnectionImmediately() {
+  if (quic_connection_ == nullptr) {
+    return;
+  }
   quic_connection_->CloseConnection(quic::QUIC_NO_ERROR, "Closed by application",
                                     quic::ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   quic_connection_ = nullptr;

source/extensions/quic_listeners/quiche/quic_filter_manager_connection_impl.h

@@ -40,7 +40,6 @@ class QuicFilterManagerConnectionImpl : public Network::ConnectionImplBase {
   void noDelay(bool /*enable*/) override {
     // No-op. TCP_NODELAY doesn't apply to UDP.
   }
-  void setDelayedCloseTimeout(std::chrono::milliseconds timeout) override;
   void readDisable(bool /*disable*/) override { NOT_REACHED_GCOVR_EXCL_LINE; }
   void detectEarlyCloseWhenReadDisabled(bool /*value*/) override { NOT_REACHED_GCOVR_EXCL_LINE; }
   bool readEnabled() const override { return true; }
@@ -105,6 +104,8 @@ class QuicFilterManagerConnectionImpl : public Network::ConnectionImplBase {
 
   void closeConnectionImmediately() override;
 
+  virtual bool hasDataToWrite() PURE;
+
   EnvoyQuicConnection* quic_connection_;
 
 private: