getMethod(const envoy::config::core::v3::RequestMethod config_method) {

  if (config_method == envoy::config::core::v3::METHOD_UNSPECIFIED) {

    return envoy::config::core::v3::GET;

  }

  return config_method;

}

    Server::Configuration::HealthCheckerFactoryContext& context) {

  return std::make_shared<ProdHttpHealthCheckerImpl>(context.cluster(), config, context,

                                                     context.eventLogger());

}

    : HealthCheckerImplBase(cluster, config, context.mainThreadDispatcher(), context.runtime(),

                            context.api().randomGenerator(), std::move(event_logger)),

      path_(config.http_health_check().path()), host_value_(config.http_health_check().host()),

      method_(getMethod(config.http_health_check().method())),

      response_buffer_size_(PROTOBUF_GET_WRAPPED_OR_DEFAULT(

      request_headers_parser_(THROW_OR_RETURN_VALUE(

      http_status_checker_(config.http_health_check().expected_statuses(),

                           config.http_health_check().retriable_statuses(),

                           static_cast<uint64_t>(Http::Code::OK)),

      codec_client_type_(codecClientType(config.http_health_check().codec_client_type())),

      random_generator_(context.api().randomGenerator()) {

  if (config.http_health_check().has_send()) {

    if (method_ == envoy::config::core::v3::GET || method_ == envoy::config::core::v3::HEAD ||

        method_ == envoy::config::core::v3::DELETE || method_ == envoy::config::core::v3::TRACE) {

      throw EnvoyException(

          fmt::format("HTTP health check cannot specify a request payload with method '{}'. "

                      "Only methods that support a request body (POST, PUT, PATCH, OPTIONS) can be "

                      "used with payload.",

                      envoy::config::core::v3::RequestMethod_Name(method_)));

    }

    auto send_bytes_or_error = PayloadMatcher::loadProtoBytes(config.http_health_check().send());

    THROW_IF_NOT_OK_REF(send_bytes_or_error.status());

    for (const auto& segment : send_bytes_or_error.value()) {

      request_payload_.add(segment.data(), segment.size());

    }

  }

  auto bytes_or_error = PayloadMatcher::loadProtoBytes(config.http_health_check().receive());

  THROW_IF_NOT_OK_REF(bytes_or_error.status());

  receive_bytes_ = bytes_or_error.value();

  if (config.http_health_check().has_service_name_matcher()) {

    service_name_matcher_.emplace(config.http_health_check().service_name_matcher(),

                                  context.serverFactoryContext());

  }

  if (response_buffer_size_ != 0 && !receive_bytes_.empty()) {

    uint64_t total = 0;

    for (auto const& bytes : receive_bytes_) {

      total += bytes.size();

    }

    if (total > response_buffer_size_) {

      throw EnvoyException(fmt::format(

          "The expected response length '{}' is over than http health response buffer size '{}'",

          total, response_buffer_size_));

    }

  }

}

    uint64_t default_expected_status) {

  for (const auto& status_range : expected_statuses) {

    const auto start = static_cast<uint64_t>(status_range.start());

    const auto end = static_cast<uint64_t>(status_range.end());

    validateRange(start, end, "expected");

    expected_ranges_.emplace_back(std::make_pair(start, end));

  }

  if (expected_ranges_.empty()) {

    expected_ranges_.emplace_back(

        std::make_pair(default_expected_status, default_expected_status + 1));

  }

  for (const auto& status_range : retriable_statuses) {

    const auto start = static_cast<uint64_t>(status_range.start());

    const auto end = static_cast<uint64_t>(status_range.end());

    validateRange(start, end, "retriable");

    retriable_ranges_.emplace_back(std::make_pair(start, end));

  }

}

                                                             absl::string_view range_type) {

  if (start >= end) {

    throw EnvoyException(fmt::format("Invalid http {} status range: expecting start < "

                                     "end, but found start={} and end={}",

                                     range_type, start, end));

  }

  if (start < 100) {

    throw EnvoyException(

        fmt::format("Invalid http {} status range: expecting start >= 100, but found start={}",

                    range_type, start));

  }

  if (end > 600) {

    throw EnvoyException(fmt::format(

        "Invalid http {} status range: expecting end <= 600, but found end={}", range_type, end));

  }

}

bool HttpHealthCheckerImpl::HttpStatusChecker::inRetriableRanges(uint64_t http_status) const {

  return inRanges(http_status, retriable_ranges_);

}

bool HttpHealthCheckerImpl::HttpStatusChecker::inExpectedRanges(uint64_t http_status) const {

  return inRanges(http_status, expected_ranges_);

}

    uint64_t http_status, const std::vector<std::pair<uint64_t, uint64_t>>& ranges) {

  for (const auto& range : ranges) {

    if (http_status >= range.first && http_status < range.second) {

      return true;

    }

  }

  return false;

}

Http::Protocol codecClientTypeToProtocol(Http::CodecType codec_client_type) {

  switch (codec_client_type) {

  case Http::CodecType::HTTP1:

    return Http::Protocol::Http11;

  case Http::CodecType::HTTP2:

    return Http::Protocol::Http2;

  }

    : ActiveHealthCheckSession(parent, host), parent_(parent),

      response_body_(std::make_unique<Buffer::OwnedImpl>()),

          HealthCheckerFactory::getHostname(host, parent_.host_value_, parent_.cluster_.info())),

      local_connection_info_provider_(std::make_shared<Network::ConnectionInfoSetterImpl>(

          Network::Utility::getCanonicalIpv4LoopbackAddress(),

          Network::Utility::getCanonicalIpv4LoopbackAddress())),

      protocol_(codecClientTypeToProtocol(parent_.codec_client_type_)), expect_reset_(false),

      reuse_connection_(false), request_in_flight_(false) {}

HttpHealthCheckerImpl::HttpActiveHealthCheckSession::~HttpActiveHealthCheckSession() {

  ASSERT(client_ == nullptr);

}

void HttpHealthCheckerImpl::HttpActiveHealthCheckSession::onDeferredDelete() {

  if (client_) {

    expect_reset_ = true;

    client_->close(Network::ConnectionCloseType::Abort);

  }

}

    Http::ResponseHeaderMapPtr&& headers, bool end_stream) {

  ASSERT(!response_headers_);

  response_headers_ = std::move(headers);

  if (end_stream) {

    onResponseComplete();

  }

}

                                                                     bool end_stream) {

  if (parent_.response_buffer_size_ != 0) {

    if (!parent_.receive_bytes_.empty() &&

        response_body_->length() < parent_.response_buffer_size_) {

      response_body_->move(data, parent_.response_buffer_size_ - response_body_->length());

    }

  } else {

  if (end_stream) {

    onResponseComplete();

  }

}

void HttpHealthCheckerImpl::HttpActiveHealthCheckSession::onEvent(Network::ConnectionEvent event) {

  if (event == Network::ConnectionEvent::RemoteClose ||

      event == Network::ConnectionEvent::LocalClose) {

    response_headers_.reset();

    response_body_->drain(response_body_->length());

    parent_.dispatcher_.deferredDelete(std::move(client_));

  }

}

void HttpHealthCheckerImpl::HttpActiveHealthCheckSession::onInterval() {

  if (!client_) {

    Upstream::Host::CreateConnectionData conn =

        host_->createHealthCheckConnection(parent_.dispatcher_, parent_.transportSocketOptions(),

                                           parent_.transportSocketMatchMetadata().get());

    client_.reset(parent_.createCodecClient(conn));

    client_->addConnectionCallbacks(connection_callback_impl_);

    client_->setCodecConnectionCallbacks(http_connection_callback_impl_);

    expect_reset_ = false;

    reuse_connection_ = parent_.reuse_connection_;

  }

  Http::RequestEncoder* request_encoder = &client_->newStream(*this);

  request_encoder->getStream().addCallbacks(*this);

  request_in_flight_ = true;

  const auto request_headers = Http::createHeaderMap<Http::RequestHeaderMapImpl>(

      {{Http::Headers::get().Method, envoy::config::core::v3::RequestMethod_Name(parent_.method_)},

       {Http::Headers::get().Host, hostname_},

       {Http::Headers::get().Path, parent_.path_},

       {Http::Headers::get().UserAgent, Http::Headers::get().UserAgentValues.EnvoyHealthChecker}});

  Router::FilterUtility::setUpstreamScheme(

      *request_headers,

      false, host_->transportSocketFactory().implementsSecureTransport(), true);

  StreamInfo::StreamInfoImpl stream_info(protocol_, parent_.dispatcher_.timeSource(),

                                         local_connection_info_provider_,

                                         StreamInfo::FilterState::LifeSpan::FilterChain);

  stream_info.setUpstreamInfo(std::make_shared<StreamInfo::UpstreamInfoImpl>());

  stream_info.upstreamInfo()->setUpstreamHost(host_);

  parent_.request_headers_parser_->evaluateHeaders(*request_headers, stream_info);

  const bool has_payload = parent_.request_payload_.length() > 0;

  if (has_payload) {

    request_headers->setContentLength(parent_.request_payload_.length());

  }

  auto status = request_encoder->encodeHeaders(*request_headers, !has_payload);

  ASSERT(status.ok());

  if (has_payload) {

    Buffer::OwnedImpl payload_copy;

    payload_copy.add(parent_.request_payload_);

    request_encoder->encodeData(payload_copy, true);

  }

}

                                                                        absl::string_view) {

  request_in_flight_ = false;

  ENVOY_CONN_LOG(debug, "connection/stream error health_flags={}", *client_,

                 HostUtility::healthFlagsToString(*host_));

  if (expect_reset_) {

    return;

  }

  if (client_ && !reuse_connection_) {

    client_->close(Network::ConnectionCloseType::Abort);

  }

  handleFailure(envoy::data::core::v3::NETWORK);

}

    Http::GoAwayErrorCode error_code) {

  ENVOY_CONN_LOG(debug, "connection going away goaway_code={}, health_flags={}", *client_,

                 static_cast<int>(error_code), HostUtility::healthFlagsToString(*host_));

  if (request_in_flight_ && error_code == Http::GoAwayErrorCode::NoError) {

    reuse_connection_ = false;

    return;

  }

  if (request_in_flight_) {

    handleFailure(envoy::data::core::v3::NETWORK);

  }

  if (client_) {

    expect_reset_ = true;

    client_->close(Network::ConnectionCloseType::Abort);

  }

}

HttpHealthCheckerImpl::HttpActiveHealthCheckSession::healthCheckResult() {

  const uint64_t response_code = Http::Utility::getResponseStatus(*response_headers_);

  ENVOY_CONN_LOG(debug, "hc response_code={} health_flags={}", *client_, response_code,

                 HostUtility::healthFlagsToString(*host_));

  if (!parent_.receive_bytes_.empty()) {

    if (!PayloadMatcher::match(parent_.receive_bytes_, *response_body_)) {

      if (response_headers_->EnvoyImmediateHealthCheckFail() != nullptr) {

        host_->healthFlagSet(Host::HealthFlag::EXCLUDED_VIA_IMMEDIATE_HC_FAIL);

      }

      return HealthCheckResult::Failed;

    }

    ENVOY_CONN_LOG(debug, "hc http response body healthcheck passed", *client_);

  }

  if (!parent_.http_status_checker_.inExpectedRanges(response_code)) {

    if (response_headers_->EnvoyImmediateHealthCheckFail() != nullptr) {

      host_->healthFlagSet(Host::HealthFlag::EXCLUDED_VIA_IMMEDIATE_HC_FAIL);

    }

    if (parent_.http_status_checker_.inRetriableRanges(response_code)) {

      return HealthCheckResult::Retriable;

    } else {

      return HealthCheckResult::Failed;

    }

  }

  const auto degraded = response_headers_->EnvoyDegraded() != nullptr;

  if (parent_.service_name_matcher_.has_value() &&

      parent_.runtime_.snapshot().featureEnabled("health_check.verify_cluster", 100UL)) {

    parent_.stats_.verify_cluster_.inc();

    std::string service_cluster_healthchecked =

        response_headers_->EnvoyUpstreamHealthCheckedCluster()

            ? std::string(response_headers_->getEnvoyUpstreamHealthCheckedClusterValue())

            : EMPTY_STRING;

    if (parent_.service_name_matcher_->match(service_cluster_healthchecked)) {

      return degraded ? HealthCheckResult::Degraded : HealthCheckResult::Succeeded;

    } else {

      return HealthCheckResult::Failed;

    }

  }

  return degraded ? HealthCheckResult::Degraded : HealthCheckResult::Succeeded;

}

void HttpHealthCheckerImpl::HttpActiveHealthCheckSession::onResponseComplete() {

  request_in_flight_ = false;

  switch (healthCheckResult()) {

  case HealthCheckResult::Succeeded:

    handleSuccess(false);

    break;

  case HealthCheckResult::Degraded:

    handleSuccess(true);

    break;

  case HealthCheckResult::Failed:

    handleFailure(envoy::data::core::v3::ACTIVE, /*retriable=*/false);

    break;

  case HealthCheckResult::Retriable:

    handleFailure(envoy::data::core::v3::ACTIVE, /*retriable=*/true);

    break;

  }

  if (shouldClose()) {

    client_->close(Network::ConnectionCloseType::Abort);

  }

  response_headers_.reset();

  response_body_->drain(response_body_->length());

}

bool HttpHealthCheckerImpl::HttpActiveHealthCheckSession::shouldClose() const {

  if (client_ == nullptr) {

    return false;

  }

  if (!reuse_connection_) {

    return true;

  }

  return Http::HeaderUtility::shouldCloseConnection(client_->protocol(), *response_headers_);

}

void HttpHealthCheckerImpl::HttpActiveHealthCheckSession::onTimeout() {

  request_in_flight_ = false;

  if (client_) {

    ENVOY_CONN_LOG(debug, "connection/stream timeout health_flags={}", *client_,

                   HostUtility::healthFlagsToString(*host_));

    expect_reset_ = true;

    client_->close(Network::ConnectionCloseType::Abort);

  }

}

HttpHealthCheckerImpl::codecClientType(const envoy::type::v3::CodecClientType& type) {

  switch (type) {

  case envoy::type::v3::HTTP2:

    return Http::CodecType::HTTP2;

  case envoy::type::v3::HTTP1:

    return Http::CodecType::HTTP1;

  }

ProdHttpHealthCheckerImpl::createCodecClient(Upstream::Host::CreateConnectionData& data) {

  return new Http::CodecClientProd(codec_client_type_, std::move(data.connection_),

                                   data.host_description_, dispatcher_, random_generator_,

                                   transportSocketOptions());

}