bool hasBothAddressFamilies(Upstream::HostConstSharedPtr host) {

  Upstream::HostDescription::SharedConstAddressVector list_ = host->addressListOrNull();

  if (!list_ || list_->size() < 2 || !(*list_)[0]->ip() || !(*list_)[1]->ip()) {

  return (*list_)[0]->ip()->version() != (*list_)[1]->ip()->version();

}

absl::string_view describePool(const ConnectionPool::Instance& pool) {

  return pool.protocolDescription();

}

                              Upstream::HostConstSharedPtr& host) {

  if (options && options->serverNameOverride().has_value()) {

    return options->serverNameOverride().value();

  }

  std::string default_sni =

      std::string(host->transportSocketFactory().defaultServerNameIndication());

  if (!default_sni.empty()) {

    return default_sni;

  }

  return host->hostname();

}

    : grid_(grid), decoder_(decoder), inner_callbacks_(&callbacks),

          grid_.dispatcher_.createTimer([this]() -> void { onNextAttemptTimer(); })),

      stream_options_(options) {

  if (Runtime::runtimeFeatureEnabled("envoy.reloadable_features.use_response_decoder_handle")) {

    decoder_handle_ = decoder.createResponseDecoderHandle();

  }

  if (!stream_options_.can_use_http3_) {

    http3_attempt_failed_ = true;

  }

}

    : parent_(parent), pool_(pool) {}

ConnectivityGrid::WrapperCallbacks::ConnectionAttemptCallbacks::~ConnectionAttemptCallbacks() {

  if (cancellable_ != nullptr) {

    cancel(Envoy::ConnectionPool::CancelPolicy::Default);

  }

}

ConnectivityGrid::WrapperCallbacks::ConnectionAttemptCallbacks::newStream() {

  ASSERT(!parent_.grid_.isPoolHttp3(pool()) || parent_.stream_options_.can_use_http3_);

  Http::ResponseDecoder& decoder = parent_.decoder_;

  if (parent_.decoder_handle_ != nullptr) {

    if (OptRef<ResponseDecoder> opt_ref = parent_.decoder_handle_->get(); opt_ref.has_value()) {

      decoder = opt_ref.value().get();

    } else {

  }

  auto* cancellable = pool().newStream(decoder, *this, parent_.stream_options_);

  if (cancellable == nullptr) {

    return StreamCreationResult::ImmediateResult;

  }

  cancellable_ = cancellable;

  return StreamCreationResult::StreamCreationPending;

}

    Upstream::HostDescriptionConstSharedPtr host) {

  cancellable_ = nullptr; // Attempt failed and can no longer be cancelled.

  parent_.onConnectionAttemptFailed(this, reason, transport_failure_reason, host);

}

ConnectivityGrid::WrapperCallbacks::attemptSecondHttp3Connection() {

  has_tried_http3_alternate_address_ = true;

  auto attempt =

      std::make_unique<ConnectionAttemptCallbacks>(*this, *grid_.getOrCreateHttp3AlternativePool());

  LinkedList::moveIntoList(std::move(attempt), connection_attempts_);

  return connection_attempts_.front()->newStream();

}

bool ConnectivityGrid::WrapperCallbacks::shouldAttemptSecondHttp3Connection() {

  if (grid_.destroying_) {

  if (has_tried_http3_alternate_address_) {

    return false;

  }

  if (!Runtime::runtimeFeatureEnabled("envoy.reloadable_features.http3_happy_eyeballs")) {

    return false;

  }

  return hasBothAddressFamilies(grid_.host_);

}

    absl::string_view transport_failure_reason, Upstream::HostDescriptionConstSharedPtr host) {

  ENVOY_LOG(trace, "{} pool failed to create connection to host '{}'.",

            describePool(attempt->pool()), host->hostname());

  grid_.dispatcher_.deferredDelete(attempt->removeFromList(connection_attempts_));

  if (grid_.isPoolHttp3(attempt->pool())) {

    if (shouldAttemptSecondHttp3Connection()) {

      attemptSecondHttp3Connection();

      return;

    }

    if (connection_attempts_.empty() ||

        (connection_attempts_.size() == 1 &&

         &connection_attempts_.front()->pool() == grid_.http2_pool_.get())) {

      http3_attempt_failed_ = true;

    }

  }

  maybeMarkHttp3Broken();

  if (!connection_attempts_.empty()) {

    prev_pool_failure_reason_ = reason;

    prev_pool_transport_failure_reason_ = fmt::format(

        "{}: {}", grid_.isPoolHttp3(attempt->pool()) ? "QUIC" : "TCP", transport_failure_reason);

    return;

  }

  if (tryAnotherConnection().has_value()) {

    return;

  }

  signalFailureAndDeleteSelf(reason, transport_failure_reason, host);

}

    Upstream::HostDescriptionConstSharedPtr host) {

  ConnectionPool::Callbacks* callbacks = inner_callbacks_;

  inner_callbacks_ = nullptr;

  deleteThis();

  if (callbacks != nullptr) {

    ENVOY_LOG(trace, "Passing pool failure up to caller.");

    std::string failure_str;

    if (prev_pool_failure_reason_.has_value()) {

      failure_str = fmt::format(

          "{} (with earlier attempt failure reason {}, {})", transport_failure_reason,

          static_cast<int>(prev_pool_failure_reason_.value()), prev_pool_transport_failure_reason_);

      transport_failure_reason = failure_str;

    }

    callbacks->onPoolFailure(reason, transport_failure_reason, host);

  }

}

void ConnectivityGrid::WrapperCallbacks::deleteThis() {

  if (delete_started_) {

  delete_started_ = true;

  grid_.dispatcher_.deferredDelete(removeFromList(grid_.wrapped_callbacks_));

}

ConnectivityGrid::WrapperCallbacks::newStream(ConnectionPool::Instance& pool) {

  ENVOY_LOG(trace, "{} pool attempting to create a new stream to host '{}'.", describePool(pool),

            grid_.origin_.hostname_);

  auto attempt = std::make_unique<ConnectionAttemptCallbacks>(*this, pool);

  LinkedList::moveIntoList(std::move(attempt), connection_attempts_);

  if (!next_attempt_timer_->enabled()) {

    next_attempt_timer_->enableTimer(grid_.next_attempt_duration_);

  }

  return connection_attempts_.front()->newStream();

}

    absl::optional<Http::Protocol> protocol) {

  ENVOY_LOG(trace, "{} pool successfully connected to host '{}'.", describePool(attempt->pool()),

            host->hostname());

  if (!grid_.isPoolHttp3(attempt->pool())) {

    tcp_attempt_succeeded_ = true;

    maybeMarkHttp3Broken();

  }

  grid_.dispatcher_.deferredDelete(attempt->removeFromList(connection_attempts_));

  ConnectionPool::Callbacks* callbacks = inner_callbacks_;

  inner_callbacks_ = nullptr;

  if (grid_.isPoolHttp3(attempt->pool())) {

    cancelAllPendingAttempts(Envoy::ConnectionPool::CancelPolicy::Default);

  }

  if (connection_attempts_.empty()) {

    deleteThis();

  }

  if (callbacks != nullptr) {

    callbacks->onPoolReady(encoder, host, info, protocol);

  } else {

    encoder.getStream().resetStream(StreamResetReason::LocalReset);

  }

}

void ConnectivityGrid::WrapperCallbacks::maybeMarkHttp3Broken() {

  if (http3_attempt_failed_ && tcp_attempt_succeeded_) {

    ENVOY_LOG(trace, "Marking HTTP/3 broken for host '{}'.", grid_.origin_.hostname_);

    grid_.markHttp3Broken();

  }

}

    StreamInfo::StreamInfo& info, absl::optional<Http::Protocol> protocol) {

  cancellable_ = nullptr; // Attempt succeeded and can no longer be cancelled.

  parent_.onConnectionAttemptReady(this, encoder, host, info, protocol);

}

    Envoy::ConnectionPool::CancelPolicy cancel_policy) {

  auto cancellable = cancellable_;

  cancellable_ = nullptr; // Prevent repeated cancellations.

  cancellable->cancel(cancel_policy);

}

void ConnectivityGrid::WrapperCallbacks::cancel(Envoy::ConnectionPool::CancelPolicy cancel_policy) {

  cancelAllPendingAttempts(cancel_policy);

  deleteThis();

}

    Envoy::ConnectionPool::CancelPolicy cancel_policy) {

  for (auto& attempt : connection_attempts_) {

    attempt->cancel(cancel_policy);

  }

  connection_attempts_.clear();

}

void ConnectivityGrid::WrapperCallbacks::onNextAttemptTimer() {

  if (grid_.destroying_) {

  tryAnotherConnection();

  if (shouldAttemptSecondHttp3Connection()) {

    attemptSecondHttp3Connection();

  }

}

ConnectivityGrid::WrapperCallbacks::tryAnotherConnection() {

  if (grid_.destroying_) {

  if (has_attempted_http2_) {

    return {};

  }

  has_attempted_http2_ = true;

  return newStream(*grid_.getOrCreateHttp2Pool());

}

    : dispatcher_(dispatcher), random_generator_(random_generator), host_(host), options_(options),

      transport_socket_options_(transport_socket_options), state_(state),

      next_attempt_duration_(std::chrono::milliseconds(kDefaultTimeoutMs)),

      time_source_(time_source), alternate_protocols_(alternate_protocols),

      quic_stat_names_(quic_stat_names), scope_(scope),

      origin_("https", getTargetHostname(transport_socket_options, host_),

              host_->address()->ip()->port()),

      quic_info_(quic_info), priority_(priority), overload_manager_(overload_manager),

      network_observer_registry_(network_observer_registry) {

  ASSERT(connectivity_options.protocols_.size() == 3);

  ASSERT(alternate_protocols);

  std::chrono::microseconds rtt = alternate_protocols_->getSrtt(

      origin_,

      Runtime::runtimeFeatureEnabled("envoy.reloadable_features.use_canonical_suffix_for_srtt"));

  if (rtt.count() != 0) {

    next_attempt_duration_ = std::chrono::duration_cast<std::chrono::milliseconds>(rtt * 1.5);

  }

}

ConnectivityGrid::~ConnectivityGrid() {

  destroying_ = true;

  while (!wrapped_callbacks_.empty()) {

    wrapped_callbacks_.front()->signalFailureAndDeleteSelf(

        ConnectionPool::PoolFailureReason::LocalConnectionFailure, "grid teardown", host_);

  }

  http2_pool_.reset();

  http3_pool_.reset();

  http3_alternate_pool_.reset();

}

void ConnectivityGrid::deleteIsPending() {

  deferred_deleting_ = true;

  for (const auto& pool : pools_) {

    pool->deleteIsPending();

  }

}

ConnectionPool::Instance* ConnectivityGrid::getOrCreateHttp3AlternativePool() {

  ASSERT(!deferred_deleting_);

  ASSERT(!draining_);

  if (http3_alternate_pool_ == nullptr) {

    http3_alternate_pool_ = createHttp3Pool(true);

    pools_.push_back(http3_alternate_pool_.get());

    setupPool(*http3_alternate_pool_.get());

  }

  return http3_alternate_pool_.get();

}

ConnectionPool::Instance* ConnectivityGrid::getOrCreateHttp3Pool() {

  ASSERT(!deferred_deleting_);

  ASSERT(!draining_);

  if (http3_pool_ == nullptr) {

    http3_pool_ = createHttp3Pool(false);

    pools_.push_back(http3_pool_.get());

    setupPool(*http3_pool_.get());

  }

  return http3_pool_.get();

}

ConnectionPool::Instance* ConnectivityGrid::getOrCreateHttp2Pool() {

  ASSERT(!deferred_deleting_);

  ASSERT(!draining_);

  if (http2_pool_ == nullptr) {

    http2_pool_ = createHttp2Pool();

    pools_.push_back(http2_pool_.get());

    setupPool(*http2_pool_.get());

  }

  return http2_pool_.get();

}

ConnectionPool::InstancePtr ConnectivityGrid::createHttp2Pool() {

  return std::make_unique<HttpConnPoolImplMixed>(dispatcher_, random_generator_, host_, priority_,

                                                 options_, transport_socket_options_, state_,

                                                 origin_, alternate_protocols_, overload_manager_);

}

ConnectionPool::InstancePtr ConnectivityGrid::createHttp3Pool(bool attempt_alternate_address) {

  return Http3::allocateConnPool(

      dispatcher_, random_generator_, host_, priority_, options_, transport_socket_options_, state_,

      quic_stat_names_, *alternate_protocols_, scope_,

      makeOptRefFromPtr<Http3::PoolConnectResultCallback>(this), quic_info_,

      network_observer_registry_, overload_manager_, attempt_alternate_address);

}

void ConnectivityGrid::setupPool(ConnectionPool::Instance& pool) {

  pool.addIdleCallback([this]() { onIdleReceived(); });

}

bool ConnectivityGrid::hasActiveConnections() const {

  for (const auto& pool : pools_) {

    if (pool->hasActiveConnections()) {

  }

  return false;

}

                                                         const Instance::StreamOptions& options) {

  ASSERT(!deferred_deleting_);

  ASSERT(!draining_);

  ConnectionPool::Instance* pool = getOrCreateHttp3Pool();

  Instance::StreamOptions overriding_options = options;

  bool delay_tcp_attempt = true;

  bool delay_alternate_http3_attempt = true;

  if (shouldAttemptHttp3() && options.can_use_http3_) {

    if (Runtime::runtimeFeatureEnabled("envoy.reloadable_features.quic_no_tcp_delay")) {

      if (getHttp3StatusTracker().isHttp3Pending() ||

          getHttp3StatusTracker().hasHttp3FailedRecently()) {

        overriding_options.can_send_early_data_ = false;

        delay_tcp_attempt = false;

      }

    } else {

      if (getHttp3StatusTracker().hasHttp3FailedRecently()) {

        overriding_options.can_send_early_data_ = false;

        delay_tcp_attempt = false;

      }

    }

    if (http3_pool_ && http3_alternate_pool_ && !http3_pool_->hasActiveConnections() &&

        http3_alternate_pool_->hasActiveConnections()) {

      delay_alternate_http3_attempt = false;

    }

  } else {

    pool = getOrCreateHttp2Pool();

  }

  auto wrapped_callback =

      std::make_unique<WrapperCallbacks>(*this, decoder, callbacks, overriding_options);

  WrapperCallbacks* ret = wrapped_callback.get();

  LinkedList::moveIntoList(std::move(wrapped_callback), wrapped_callbacks_);

  if (ret->newStream(*pool) == StreamCreationResult::ImmediateResult) {

    return nullptr;

  }

  if (!delay_alternate_http3_attempt && ret->shouldAttemptSecondHttp3Connection()) {

    if (ret->attemptSecondHttp3Connection() == StreamCreationResult::ImmediateResult) {

      return nullptr;

    }

  }

  if (!delay_tcp_attempt) {

    ret->tryAnotherConnection();

  }

  return ret->hasNotifiedCaller() ? nullptr : ret;

}

void ConnectivityGrid::addIdleCallback(IdleCb cb) {

  idle_callbacks_.emplace_back(cb);

}

void ConnectivityGrid::drainConnections(Envoy::ConnectionPool::DrainBehavior drain_behavior) {

  if (drain_behavior == Envoy::ConnectionPool::DrainBehavior::DrainAndDelete) {

    draining_ = true;

  }

  for (auto& pool : pools_) {

    pool->drainConnections(drain_behavior);

  }

}

Upstream::HostDescriptionConstSharedPtr ConnectivityGrid::host() const { return host_; }

bool ConnectivityGrid::isPoolHttp3(const ConnectionPool::Instance& pool) {

  return &pool == http3_pool_.get() || &pool == http3_alternate_pool_.get();

}

HttpServerPropertiesCache::Http3StatusTracker& ConnectivityGrid::getHttp3StatusTracker() const {

  ENVOY_BUG(host_->address()->type() == Network::Address::Type::Ip, "Address is not an IP address");

  return alternate_protocols_->getOrCreateHttp3StatusTracker(origin_);

}

bool ConnectivityGrid::isHttp3Broken() const {

  ENVOY_BUG(host_->address()->type() == Network::Address::Type::Ip, "Address is not an IP address");

  return alternate_protocols_->isHttp3Broken(origin_);

}

void ConnectivityGrid::markHttp3Broken() {

  host_->cluster().trafficStats()->upstream_http3_broken_.inc();

  ENVOY_BUG(host_->address()->type() == Network::Address::Type::Ip, "Address is not an IP address");

  alternate_protocols_->markHttp3Broken(origin_);

}

void ConnectivityGrid::markHttp3Confirmed() { getHttp3StatusTracker().markHttp3Confirmed(); }

bool ConnectivityGrid::isIdle() const {

  bool idle = true;

  for (const auto& pool : pools_) {

    idle &= pool->isIdle();

  }

  return idle;

}

void ConnectivityGrid::onIdleReceived() {

  if (destroying_) {

    return;

  }

  if (isIdle()) {

    for (auto& callback : idle_callbacks_) {

      callback();

    }

  }

}

bool ConnectivityGrid::shouldAttemptHttp3() {

  if (host_->address()->type() != Network::Address::Type::Ip) {

  uint32_t port = host_->address()->ip()->port();

  OptRef<const std::vector<HttpServerPropertiesCache::AlternateProtocol>> protocols =

      alternate_protocols_->findAlternatives(origin_);

  if (!protocols.has_value()) {

    ENVOY_LOG(trace, "No alternate protocols available for host '{}', skipping HTTP/3.",

              origin_.hostname_);

    return false;

  }

  if (isHttp3Broken()) {

    ENVOY_LOG(trace, "HTTP/3 is broken to host '{}', skipping.", host_->hostname());

    return false;

  }

  for (const HttpServerPropertiesCache::AlternateProtocol& protocol : protocols.ref()) {

    if (!protocol.hostname_.empty() || protocol.port_ != port) {

      ENVOY_LOG(trace,

                "Alternate protocol for host '{}' attempts to change host or port, skipping.",

                origin_.hostname_);

      continue;

    }

    spdy::SpdyAltSvcWireFormat::AlternativeService alt_svc(protocol.alpn_, protocol.hostname_,

                                                           protocol.port_, 0, {});

    quic::ParsedQuicVersion version = quic::SpdyUtils::ExtractQuicVersionFromAltSvcEntry(

        alt_svc, quic::CurrentSupportedVersions());

    if (version != quic::ParsedQuicVersion::Unsupported()) {

      ENVOY_LOG(trace, "HTTP/3 advertised for host '{}'", origin_.hostname_);

      return true;

    }

    ENVOY_LOG(trace, "Alternate protocol for host '{}' has unsupported ALPN '{}', skipping.",

              origin_.hostname_, protocol.alpn_);

  }

  ENVOY_LOG(trace, "HTTP/3 is not available to host '{}', skipping.", origin_.hostname_);

  return false;

}

void ConnectivityGrid::onHandshakeComplete() {

  ENVOY_LOG(trace, "Marking HTTP/3 confirmed for host '{}'.", origin_.hostname_);

  markHttp3Confirmed();

}

void ConnectivityGrid::onZeroRttHandshakeFailed() {

  ENVOY_LOG(trace, "Marking HTTP/3 failed for host '{}'.", host_->hostname());

  getHttp3StatusTracker().markHttp3FailedRecently();

}