#pragma once

#include <chrono>

#include <cstdint>

#include <functional>

#include <map>

#include <memory>

#include <string>

#include "envoy/access_log/access_log.h"

#include "envoy/common/conn_pool.h"

#include "envoy/common/matchers.h"

#include "envoy/config/core/v3/base.pb.h"

#include "envoy/config/route/v3/route_components.pb.h"

#include "envoy/config/typed_metadata.h"

#include "envoy/http/codec.h"

#include "envoy/http/codes.h"

#include "envoy/http/conn_pool.h"

#include "envoy/http/hash_policy.h"

#include "envoy/http/header_evaluator.h"

#include "envoy/rds/config.h"

#include "envoy/router/internal_redirect.h"

#include "envoy/router/path_matcher.h"

#include "envoy/router/path_rewriter.h"

#include "envoy/stream_info/stream_info.h"

#include "envoy/tcp/conn_pool.h"

#include "envoy/tracing/tracer.h"

#include "envoy/type/v3/percent.pb.h"

#include "envoy/upstream/resource_manager.h"

#include "envoy/upstream/retry.h"

#include "source/common/protobuf/protobuf.h"

#include "source/common/protobuf/utility.h"

#include "absl/types/optional.h"

namespace Envoy {

namespace Formatter {

class Formatter;

}

namespace Upstream {

class ClusterManager;

class LoadBalancerContext;

class ThreadLocalCluster;

} // namespace Upstream

namespace Router {

/**

 * Functionality common among routing primitives, such as DirectResponseEntry and RouteEntry.

 */

class ResponseEntry {

public:

  /**

   * Do potentially destructive header transforms on response headers prior to forwarding. For

   * example, adding or removing headers. This should only be called ONCE immediately after

   * obtaining the initial response headers.

   * @param headers supplies the response headers, which may be modified during this call.

   * @param stream_info holds additional information about the request.

   */

  virtual void finalizeResponseHeaders(Http::ResponseHeaderMap& headers,

                                       const Formatter::Context& context,

                                       const StreamInfo::StreamInfo& stream_info) const PURE;

  /**

   * Returns the response header transforms that would be applied if finalizeResponseHeaders were

   * called now. This is useful if you want to obtain response header transforms at request time and

   * process them later. Note: do not use unless you are sure that there will be no route

   * modifications later in the filter chain.

   * @param stream_info holds additional information about the request.

   * @param do_formatting whether or not to evaluate configured transformations; if false, returns

   * original values instead.

   */

  virtual Http::HeaderTransforms responseHeaderTransforms(const StreamInfo::StreamInfo& stream_info,

                                                          bool do_formatting = true) const PURE;

};

/**

 * A routing primitive that specifies a direct (non-proxied) HTTP response.

 */

class DirectResponseEntry : public ResponseEntry {

public:

  /**

   * Returns the HTTP status code to return.

   * @return Http::Code the response Code.

   */

  virtual Http::Code responseCode() const PURE;

  /**

   * Returns the redirect URI based on the request headers.

   * @param headers supplies the request headers.

   * @return std::string the redirect URL if this DirectResponseEntry is a redirect,

   *         or an empty string otherwise.

   */

  virtual std::string newUri(const Http::RequestHeaderMap& headers) const PURE;

  /**

   * Format the response body for direct responses. Users should pass

   * a string reference to populate, `body`, and the return value may

   * or may not be the same reference based on if a formatter is applied.

   * If a formatter is applied, the return value will be the same reference.

   * If no formatter is applied, the return value will be the configured body.

   * @param request_headers supplies the request headers.

   * @param response_headers supplies the response headers.

   * @param stream_info holds additional information about the request.

   * @param body_out a string in which a formatted body may be stored.

   * @return std::string& the response body.

   */

  virtual absl::string_view formatBody(const Http::RequestHeaderMap& request_headers,

                                       const Http::ResponseHeaderMap& response_headers,

                                       const StreamInfo::StreamInfo& stream_info,

                                       std::string& body_out) const PURE;

  /**

   * @return the content type to use for the direct response body, or empty string if not

   * configured (in which case the default "text/plain" will be used).

   */

  virtual absl::string_view responseContentType() const PURE;

  /**

   * Do potentially destructive header transforms on Path header prior to redirection. For

   * example prefix rewriting for redirects etc. This should only be called ONCE

   * immediately prior to redirecting.

   * @param headers supplies the request headers, which may be modified during this call.

   * @param insert_envoy_original_path insert x-envoy-original-path header?

   */

  virtual void rewritePathHeader(Http::RequestHeaderMap& headers,

                                 bool insert_envoy_original_path) const PURE;

};

/**

 * All route specific config returned by the method at

 *   NamedHttpFilterConfigFactory::createRouteSpecificFilterConfig

 * should be derived from this class.

 */

class RouteSpecificFilterConfig {

public:

};

using RouteSpecificFilterConfigConstSharedPtr = std::shared_ptr<const RouteSpecificFilterConfig>;

using RouteSpecificFilterConfigs = absl::InlinedVector<const RouteSpecificFilterConfig*, 4>;

/**

 * CorsPolicy for Route and VirtualHost.

 */

class CorsPolicy : public RouteSpecificFilterConfig {

public:

  /**

   * @return std::vector<StringMatcherPtr>& access-control-allow-origin matchers.

   */

  virtual const std::vector<Matchers::StringMatcherPtr>& allowOrigins() const PURE;

  /**

   * @return std::string access-control-allow-methods value.

   */

  virtual const std::string& allowMethods() const PURE;

  /**

   * @return std::string access-control-allow-headers value.

   */

  virtual const std::string& allowHeaders() const PURE;

  /**

   * @return std::string access-control-expose-headers value.

   */

  virtual const std::string& exposeHeaders() const PURE;

  /**

   * @return std::string access-control-max-age value.

   */

  virtual const std::string& maxAge() const PURE;

  /**

   * @return const absl::optional<bool>& Whether access-control-allow-credentials should be true.

   */

  virtual const absl::optional<bool>& allowCredentials() const PURE;

  /**

   * @return const absl::optional<bool>& How to handle access-control-request-private-network.

   */

  virtual const absl::optional<bool>& allowPrivateNetworkAccess() const PURE;

  /**

   * @return bool Whether CORS is enabled for the route or virtual host.

   */

  virtual bool enabled() const PURE;

  /**

   * @return bool Whether CORS policies are evaluated when filter is off.

   */

  virtual bool shadowEnabled() const PURE;

  /**

   * @return bool whether preflight requests with origin not matching

   * configured allowed origins should be forwarded upstream.

   */

  virtual const absl::optional<bool>& forwardNotMatchingPreflights() const PURE;

};

/**

 * An interface to be implemented by rate limited reset header parsers.

 */

class ResetHeaderParser {

public:

  /**

   * Iterate over the headers, choose the first one that matches by name, and try to parse its

   * value.

   */

  virtual absl::optional<std::chrono::milliseconds>

  parseInterval(TimeSource& time_source, const Http::HeaderMap& headers) const PURE;

};

using ResetHeaderParserSharedPtr = std::shared_ptr<ResetHeaderParser>;

class RetryPolicy;

using RetryPolicyConstSharedPtr = std::shared_ptr<const RetryPolicy>;

/**

 * Route level retry policy.

 */

class RetryPolicy {

public:

  // clang-format off

  static constexpr uint32_t RETRY_ON_5XX                                = 0x1;

  static constexpr uint32_t RETRY_ON_GATEWAY_ERROR                      = 0x2;

  static constexpr uint32_t RETRY_ON_CONNECT_FAILURE                    = 0x4;

  static constexpr uint32_t RETRY_ON_RETRIABLE_4XX                      = 0x8;

  static constexpr uint32_t RETRY_ON_REFUSED_STREAM                     = 0x10;

  static constexpr uint32_t RETRY_ON_GRPC_CANCELLED                     = 0x20;

  static constexpr uint32_t RETRY_ON_GRPC_DEADLINE_EXCEEDED             = 0x40;

  static constexpr uint32_t RETRY_ON_GRPC_RESOURCE_EXHAUSTED            = 0x80;

  static constexpr uint32_t RETRY_ON_GRPC_UNAVAILABLE                   = 0x100;

  static constexpr uint32_t RETRY_ON_GRPC_INTERNAL                      = 0x200;

  static constexpr uint32_t RETRY_ON_RETRIABLE_STATUS_CODES             = 0x400;

  static constexpr uint32_t RETRY_ON_RESET                              = 0x800;

  static constexpr uint32_t RETRY_ON_RETRIABLE_HEADERS                  = 0x1000;

  static constexpr uint32_t RETRY_ON_ENVOY_RATE_LIMITED                 = 0x2000;

  static constexpr uint32_t RETRY_ON_HTTP3_POST_CONNECT_FAILURE         = 0x4000;

  static constexpr uint32_t RETRY_ON_RESET_BEFORE_REQUEST               = 0x8000;

  // clang-format on

  /**

   * @return std::chrono::milliseconds timeout per retry attempt. 0 is disabled.

   */

  virtual std::chrono::milliseconds perTryTimeout() const PURE;

  /**

   * @return std::chrono::milliseconds the optional per try idle timeout. 0 is disabled.

   */

  virtual std::chrono::milliseconds perTryIdleTimeout() const PURE;

  /**

   * @return uint32_t the number of retries to allow against the route.

   */

  virtual uint32_t numRetries() const PURE;

  /**

   * @return uint32_t a local OR of RETRY_ON values above.

   */

  virtual uint32_t retryOn() const PURE;

  /**

   * Initializes a new set of RetryHostPredicates to be used when retrying with this retry policy.

   * @return list of RetryHostPredicates to use

   */

  virtual std::vector<Upstream::RetryHostPredicateSharedPtr> retryHostPredicates() const PURE;

  /**

   * Initializes a RetryPriority to be used when retrying with this retry policy.

   * @return the RetryPriority to use when determining priority load for retries, or nullptr

   * if none should be used.

   */

  virtual Upstream::RetryPrioritySharedPtr retryPriority() const PURE;

  /**

   * @return the retry options predicates for this policy. Each policy will be applied prior

   * to retrying a request, allowing for request behavior to be customized.

   */

  virtual absl::Span<const Upstream::RetryOptionsPredicateConstSharedPtr>

  retryOptionsPredicates() const PURE;

  /**

   * Number of times host selection should be reattempted when selecting a host

   * for a retry attempt.

   */

  virtual uint32_t hostSelectionMaxAttempts() const PURE;

  /**

   * List of status codes that should trigger a retry when the retriable-status-codes retry

   * policy is enabled.

   */

  virtual const std::vector<uint32_t>& retriableStatusCodes() const PURE;

  /**

   * @return std::vector<Http::HeaderMatcherSharedPtr>& list of response header matchers that

   * will be checked when the 'retriable-headers' retry policy is enabled.

   */

  virtual const std::vector<Http::HeaderMatcherSharedPtr>& retriableHeaders() const PURE;

  /**

   * @return std::vector<Http::HeaderMatcherSharedPt>& list of request header

   * matchers that will be checked before enabling retries.

   */

  virtual const std::vector<Http::HeaderMatcherSharedPtr>& retriableRequestHeaders() const PURE;

  /**

   * @return absl::optional<std::chrono::milliseconds> base retry interval

   */

  virtual absl::optional<std::chrono::milliseconds> baseInterval() const PURE;

  /**

   * @return absl::optional<std::chrono::milliseconds> maximum retry interval

   */

  virtual absl::optional<std::chrono::milliseconds> maxInterval() const PURE;

  /**

   * @return std::vector<Http::ResetHeaderParserSharedPtr>& list of reset header

   * parsers that will be used to extract a retry back-off interval from response headers.

   */

  virtual const std::vector<ResetHeaderParserSharedPtr>& resetHeaders() const PURE;

  /**

   * @return std::chrono::milliseconds upper limit placed on a retry

   * back-off interval parsed from response headers.

   */

  virtual std::chrono::milliseconds resetMaxInterval() const PURE;

};

/**

 * RetryStatus whether request should be retried or not.

 */

enum class RetryStatus { No, NoOverflow, NoRetryLimitExceeded, Yes };

/**

 * InternalRedirectPolicy from the route configuration.

 */

class InternalRedirectPolicy {

public:

  /**

   * @return whether internal redirect is enabled on this route.

   */

  virtual bool enabled() const PURE;

  /**

   * @param response_code the response code from the upstream.

   * @return whether the given response_code should trigger an internal redirect on this route.

   */

  virtual bool shouldRedirectForResponseCode(const Http::Code& response_code) const PURE;

  /**

   * Creates the target route predicates. This should really be called only once for each upstream

   * redirect response. Creating the predicates lazily to avoid wasting CPU cycles on non-redirect

   * responses, which should be the most common case.

   * @return a vector of newly constructed InternalRedirectPredicate instances.

   */

  virtual std::vector<InternalRedirectPredicateSharedPtr> predicates() const PURE;

  /**

   * @return a vector of response header names to preserve in the redirected request.

   */

  virtual const std::vector<Http::LowerCaseString>& responseHeadersToCopy() const PURE;

  /**

   * @return the maximum number of allowed internal redirects on this route.

   */

  virtual uint32_t maxInternalRedirects() const PURE;

  /**

   * @return if it is allowed to follow the redirect with a different scheme in

   *         the target URI than the downstream request.

   */

  virtual bool isCrossSchemeRedirectAllowed() const PURE;

};

/**

 * Wraps retry state for an active routed request.

 */

class RetryState {

public:

  enum class RetryDecision {

    // Retry the request immediately.

    RetryImmediately,

    // Retry the request with timed backoff delay.

    RetryWithBackoff,

    // Do not retry.

    NoRetry,

  };

  enum class Http3Used {

    Unknown,

    Yes,

    No,

  };

  using DoRetryCallback = std::function<void()>;

  /**

   * @param disabled_http3 indicates whether the retry should disable http3 or not.

   */

  using DoRetryResetCallback = std::function<void(bool disable_http3)>;

  /**

   * @param disable_early_data indicates whether the retry should disable early data or not.

   */

  using DoRetryHeaderCallback = std::function<void(bool disable_early_data)>;

  /**

   * @return true if a policy is in place for the active request that allows retries.

   */

  virtual bool enabled() PURE;

  /**

   * Attempts to parse any matching rate limited reset headers (RFC 7231), either in the form of an

   * interval directly, or in the form of a unix timestamp relative to the current system time.

   * @return the interval if parsing was successful.

   */

  virtual absl::optional<std::chrono::milliseconds>

  parseResetInterval(const Http::ResponseHeaderMap& response_headers) const PURE;

  /**

   * Determine whether a request should be retried based on the response headers.

   * @param response_headers supplies the response headers.

   * @param original_request supplies the original request headers.

   * @param callback supplies the callback that will be invoked when the retry should take place.

   *                 This is used to add timed backoff, etc. The callback will never be called

   *                 inline.

   * @return RetryStatus if a retry should take place. @param callback will be called at some point

   *         in the future. Otherwise a retry should not take place and the callback will never be

   *         called. Calling code should proceed with error handling.

   */

  virtual RetryStatus shouldRetryHeaders(const Http::ResponseHeaderMap& response_headers,

                                         const Http::RequestHeaderMap& original_request,

                                         DoRetryHeaderCallback callback) PURE;

  /**

   * Determines whether given response headers would be retried by the retry policy, assuming

   * sufficient retry budget and circuit breaker headroom. This is useful in cases where

   * the information about whether a response is "good" or not is useful, but a retry should

   * not be attempted for other reasons.

   * @param response_headers supplies the response headers.

   * @param original_request supplies the original request headers.

   * @param retry_as_early_data output argument to tell the caller if a retry should be sent as

   *        early data if it is warranted.

   * @return RetryDecision if a retry would be warranted based on the retry policy and if it would

   *         be warranted with timed backoff.

   */

  virtual RetryDecision wouldRetryFromHeaders(const Http::ResponseHeaderMap& response_headers,

                                              const Http::RequestHeaderMap& original_request,

                                              bool& retry_as_early_data) PURE;

  /**

   * Determine whether a request should be retried after a reset based on the reason for the reset.

   * @param reset_reason supplies the reset reason.

   * @param http3_used whether the reset request was sent over http3 as alternate protocol or

   *                   not. nullopt means it wasn't sent at all before getting reset.

   * @param callback supplies the callback that will be invoked when the retry should take place.

   *                 This is used to add timed backoff, etc. The callback will never be called

   *                 inline.

   * @param upstream_request_started indicates whether the first byte has been transmitted to the

   *                                 upstream server.

   *

   * @return RetryStatus if a retry should take place. @param callback will be called at some point

   *         in the future. Otherwise a retry should not take place and the callback will never be

   *         called. Calling code should proceed with error handling.

   */

  virtual RetryStatus shouldRetryReset(Http::StreamResetReason reset_reason, Http3Used http3_used,

                                       DoRetryResetCallback callback,

                                       bool upstream_request_started) PURE;

  /**

   * Determine whether a "hedged" retry should be sent after the per try

   * timeout expires. This means the original request is not canceled, but a

   * new one is sent to hedge against the original request taking even longer.

   * @param callback supplies the callback that will be invoked when the retry should take place.

   *                 This is used to add timed backoff, etc. The callback will never be called

   * inline.

   * @return RetryStatus if a retry should take place. @param callback will be called at some point

   *         in the future. Otherwise a retry should not take place and the callback will never be

   *         called. Calling code should proceed with error handling.

   */

  virtual RetryStatus shouldHedgeRetryPerTryTimeout(DoRetryCallback callback) PURE;

  /**

   * Called when a host was attempted but the request failed and is eligible for another retry.

   * Should be used to update whatever internal state depends on previously attempted hosts.

   * @param host the previously attempted host.

   */

  virtual void onHostAttempted(Upstream::HostDescriptionConstSharedPtr host) PURE;

  /**

   * Determine whether host selection should be reattempted. Applies to host selection during

   * retries, and is used to provide configurable host selection for retries.

   * @param host the host under consideration

   * @return whether host selection should be reattempted

   */

  virtual bool shouldSelectAnotherHost(const Upstream::Host& host) PURE;

  /**

   * Returns a reference to the PriorityLoad that should be used for the next retry.

   * @param stream_info request stream information.

   * @param priority_set current priority set.

   * @param original_priority_load original priority load.

   * @param priority_mapping_func see @Upstream::RetryPriority::PriorityMappingFunc.

   * @return HealthyAndDegradedLoad that should be used to select a priority for the next retry.

   */

  virtual const Upstream::HealthyAndDegradedLoad& priorityLoadForRetry(

      StreamInfo::StreamInfo* stream_info, const Upstream::PrioritySet& priority_set,

      const Upstream::HealthyAndDegradedLoad& original_priority_load,

      const Upstream::RetryPriority::PriorityMappingFunc& priority_mapping_func) PURE;

  /**

   * return how many times host selection should be reattempted during host selection.

   */

  virtual uint32_t hostSelectionMaxAttempts() const PURE;

};

using RetryStatePtr = std::unique_ptr<RetryState>;

/**

 * Per route policy for request shadowing.

 */

class ShadowPolicy {

public:

  /**

   * @return the name of the cluster that a matching request should be shadowed to.

   *         Only one of *cluster* and *cluster_header* can be specified. Returns empty

   *         string if no shadowing should take place.

   */

  virtual const std::string& cluster() const PURE;

  /**

   * @return the cluster header name that router can get the cluster name from request headers.

   *         Only one of *cluster* and *cluster_header* can be specified. Returns empty

   *         string if no shadowing should take place.

   */

  virtual const Http::LowerCaseString& clusterHeader() const PURE;

  /**

   * @return the runtime key that will be used to determine whether an individual request should

   *         be shadowed. The lack of a key means that all requests will be shadowed. If a key is

   *         present it will be used to drive random selection in the range 0-10000 for 0.01%

   *         increments.

   */

  virtual const std::string& runtimeKey() const PURE;

  /**

   * @return the default fraction of traffic the should be shadowed, if the runtime key is not

   *         present.

   */

  virtual const envoy::type::v3::FractionalPercent& defaultValue() const PURE;

  /**

   * @return true if the trace span should be sampled.

   */

  virtual absl::optional<bool> traceSampled() const PURE;

  /**

   * @return true if host name should be suffixed with "-shadow".

   */

  virtual bool disableShadowHostSuffixAppend() const PURE;

  /**

   * @return the header evaluator for manipulating headers in mirrored requests.

   */

  virtual const Http::HeaderEvaluator& headerEvaluator() const PURE;

  /**

   * @return the literal value to rewrite the host header with, or empty if no rewrite.

   */

  virtual absl::string_view hostRewriteLiteral() const PURE;

};

using ShadowPolicyPtr = std::shared_ptr<ShadowPolicy>;

/**

 * All virtual cluster stats. @see stats_macro.h

 */

#define ALL_VIRTUAL_CLUSTER_STATS(COUNTER, GAUGE, HISTOGRAM, TEXT_READOUT, STATNAME)               \

  COUNTER(upstream_rq_retry)                                                                       \

  COUNTER(upstream_rq_retry_limit_exceeded)                                                        \

  COUNTER(upstream_rq_retry_overflow)                                                              \

  COUNTER(upstream_rq_retry_success)                                                               \

  COUNTER(upstream_rq_timeout)                                                                     \

  COUNTER(upstream_rq_total)                                                                       \

  STATNAME(other)                                                                                  \

  STATNAME(vcluster)                                                                               \

  STATNAME(vhost)

/**

 * All route level stats. @see stats_macro.h

 */

#define ALL_ROUTE_STATS(COUNTER, GAUGE, HISTOGRAM, TEXT_READOUT, STATNAME)                         \

  COUNTER(upstream_rq_retry)                                                                       \

  COUNTER(upstream_rq_retry_limit_exceeded)                                                        \

  COUNTER(upstream_rq_retry_overflow)                                                              \

  COUNTER(upstream_rq_retry_success)                                                               \

  COUNTER(upstream_rq_timeout)                                                                     \

  COUNTER(upstream_rq_total)                                                                       \

  STATNAME(route)                                                                                  \

  STATNAME(vhost)

/**

 * Struct definition for all virtual cluster stats. @see stats_macro.h

 */

MAKE_STAT_NAMES_STRUCT(VirtualClusterStatNames, ALL_VIRTUAL_CLUSTER_STATS);

MAKE_STATS_STRUCT(VirtualClusterStats, VirtualClusterStatNames, ALL_VIRTUAL_CLUSTER_STATS);

/**

 * Struct definition for all route level stats. @see stats_macro.h

 */

MAKE_STAT_NAMES_STRUCT(RouteStatNames, ALL_ROUTE_STATS);

MAKE_STATS_STRUCT(RouteStats, RouteStatNames, ALL_ROUTE_STATS);

/**

 * RouteStatsContext defines config needed to generate all route level stats.

 */

class RouteStatsContext;

using RouteStatsContextPtr = std::unique_ptr<RouteStatsContext>;

using RouteStatsContextOptRef = OptRef<RouteStatsContext>;

/**

 * Virtual cluster definition (allows splitting a virtual host into virtual clusters orthogonal to

 * routes for stat tracking and priority purposes).

 */

class VirtualCluster {

public:

  /**

   * @return the string name of the virtual cluster.

   */

  virtual const absl::optional<std::string>& name() const PURE;

  /**

   * @return the stat-name of the virtual cluster.

   */

  virtual Stats::StatName statName() const PURE;

  /**

   * @return VirtualClusterStats& strongly named stats for this virtual cluster.

   */

  virtual VirtualClusterStats& stats() const PURE;

  static VirtualClusterStats generateStats(Stats::Scope& scope,

};

class RateLimitPolicy;

class Config;

class CommonConfig;

/**

 * Virtual host definition.

 */

class VirtualHost {

public:

  /**

   * @return const CorsPolicy* the CORS policy for this virtual host.

   */

  virtual const CorsPolicy* corsPolicy() const PURE;

  /**

   * @return const std::string& the name of the virtual host.

   */

  virtual const std::string& name() const PURE;

  /**

   * @return the stat-name of the virtual host.

   */

  virtual Stats::StatName statName() const PURE;

  /**

   * @return const RateLimitPolicy& the rate limit policy for the virtual host.

   */

  virtual const RateLimitPolicy& rateLimitPolicy() const PURE;

  /**

   * @return const Config& the RouteConfiguration that owns this virtual host.

   */

  virtual const CommonConfig& routeConfig() const PURE;

  /**

   * @return bool whether to include the request count header in upstream requests.

   */

  virtual bool includeAttemptCountInRequest() const PURE;

  /**

   * @return bool whether to include the request count header in the downstream response.

   */

  virtual bool includeAttemptCountInResponse() const PURE;

  /**

   * @return bool whether to include the header in the upstream request to indicate it is a retry

   * initiated by a timeout.

   */

  virtual bool includeIsTimeoutRetryHeader() const PURE;

  /**

   * This is a helper to get the route's per-filter config if it exists, up along the config

   * hierarchy (Route --> VirtualHost --> RouteConfiguration). Or nullptr if none of them exist.

   */

  virtual const RouteSpecificFilterConfig*

  mostSpecificPerFilterConfig(absl::string_view name) const PURE;

  /**

   * Return all the available per route filter configs. The configs is in order of specificity.

   * That means that the config from a route configuration will be first, then the config from a

   * virtual host, then the config from a route.

   */

  virtual Router::RouteSpecificFilterConfigs perFilterConfigs(absl::string_view name) const PURE;

  /**

   * @return const envoy::config::core::v3::Metadata& return the metadata provided in the config for

   * this virtual host.

   */

  virtual const envoy::config::core::v3::Metadata& metadata() const PURE;

  /**

   * @return const Envoy::Config::TypedMetadata& return the typed metadata provided in the config

   * for this virtual host.

   */

  virtual const Envoy::Config::TypedMetadata& typedMetadata() const PURE;

  /**

   * Determine whether a specific request path belongs to a virtual cluster for use in stats, etc.

   * @param headers supplies the request headers.

   * @return the virtual cluster or nullptr if there is no match.

   */

  virtual const VirtualCluster* virtualCluster(const Http::HeaderMap& headers) const PURE;

};

using VirtualHostConstSharedPtr = std::shared_ptr<const VirtualHost>;

/**

 * Route level hedging policy.

 */

class HedgePolicy {

public:

  /**

   * @return number of upstream requests that should be sent initially.

   */

  virtual uint32_t initialRequests() const PURE;

  /**

   * @return percent chance that an additional upstream request should be sent

   * on top of the value from initialRequests().

   */

  virtual const envoy::type::v3::FractionalPercent& additionalRequestChance() const PURE;

  /**

   * @return bool indicating whether request hedging should occur when a request

   * is retried due to a per try timeout. The alternative is the original request

   * will be canceled immediately.

   */

  virtual bool hedgeOnPerTryTimeout() const PURE;

};

class MetadataMatchCriterion {

public:

  /*

   * @return const std::string& the name of the metadata key

   */

  virtual const std::string& name() const PURE;

  /*

   * @return const Envoy::HashedValue& the value for the metadata key

   */

  virtual const HashedValue& value() const PURE;

};

using MetadataMatchCriterionConstSharedPtr = std::shared_ptr<const MetadataMatchCriterion>;

class MetadataMatchCriteria;

using MetadataMatchCriteriaConstPtr = std::unique_ptr<const MetadataMatchCriteria>;

class MetadataMatchCriteria {

public:

  /*

   * @return std::vector<MetadataMatchCriterionConstSharedPtr>& a vector of

   * metadata to be matched against upstream endpoints when load

   * balancing, sorted lexically by name.

   */

  virtual const std::vector<MetadataMatchCriterionConstSharedPtr>&

  metadataMatchCriteria() const PURE;

  /**

   * Creates a new MetadataMatchCriteria, merging existing

   * metadata criteria with the provided criteria. The result criteria is the

   * combination of both sets of criteria, with those from the metadata_matches

   * Protobuf::Struct taking precedence.

   * @param metadata_matches supplies the new criteria.

   * @return MetadataMatchCriteriaConstPtr the result criteria.

   */

  virtual MetadataMatchCriteriaConstPtr

  mergeMatchCriteria(const Protobuf::Struct& metadata_matches) const PURE;

  /**

   * Creates a new MetadataMatchCriteria with criteria vector reduced to given names

   * @param names names of metadata keys to preserve

   * @return MetadataMatchCriteriaConstPtr the result criteria. Returns nullptr if the result

   * criteria are empty.

   */

  virtual MetadataMatchCriteriaConstPtr

  filterMatchCriteria(const std::set<std::string>& names) const PURE;

};

/**

 * Criterion that a route entry uses for matching TLS connection context.

 */

class TlsContextMatchCriteria {

public:

  /**

   * @return bool indicating whether the client presented credentials.

   */

  virtual const absl::optional<bool>& presented() const PURE;

  /**

   * @return bool indicating whether the client credentials successfully validated against the TLS

   * context validation context.

   */

  virtual const absl::optional<bool>& validated() const PURE;

};

using TlsContextMatchCriteriaConstPtr = std::unique_ptr<const TlsContextMatchCriteria>;

/**

 * Type of path matching that a route entry uses.

 */

enum class PathMatchType {

  None,

  Prefix,

  Exact,

  Regex,

  PathSeparatedPrefix,

  Template,

};

/**

 * Criterion that a route entry uses for matching a particular path.

 * Extensions can use this to gain better insights of chosen route paths,

 * see: https://github.com/envoyproxy/envoy/pull/2531.

 */

class PathMatchCriterion {

public:

  /**

   * @return PathMatchType type of path match.

   */

  virtual PathMatchType matchType() const PURE;

  /**

   * @return const std::string& the string with which to compare paths.

   */

  virtual const std::string& matcher() const PURE;

};

/**

 * Base class for all route typed metadata factories.

 */

class HttpRouteTypedMetadataFactory : public Envoy::Config::TypedMetadataFactory {};

/**

 * Base class for all early data option extensions.

 */

class EarlyDataPolicy {

public:

  /**

   * @return bool whether the given request may be sent over early data.

   */

  virtual bool allowsEarlyDataForRequest(const Http::RequestHeaderMap& request_headers) const PURE;

};

using EarlyDataPolicyPtr = std::unique_ptr<EarlyDataPolicy>;

/**

 * Base class for all early data option factories.

 */

class EarlyDataPolicyFactory : public Envoy::Config::TypedFactory {

public:

  /**

   * @param config the typed config for early data option.

   * @return EarlyDataIOptionPtr an instance of EarlyDataPolicy.

   */

  virtual EarlyDataPolicyPtr createEarlyDataPolicy(const Protobuf::Message& config) PURE;

  // Config::UntypedFactory

};

/**

 * An individual resolved route entry.

 */

class RouteEntry : public ResponseEntry {

public:

  /**

   * @return const std::string& the upstream cluster that owns the route.

   */

  virtual const std::string& clusterName() const PURE;

  /**

   * Returns the HTTP status code to use when configured cluster is not found.

   * @return Http::Code to use when configured cluster is not found.

   */

  virtual Http::Code clusterNotFoundResponseCode() const PURE;

  /**

   * @return const CorsPolicy* the CORS policy for this virtual host.

   */

  virtual const CorsPolicy* corsPolicy() const PURE;

  /**

   * Returns the URL path as it will be calculated by finalizeRequestHeaders

   * using current values of headers. Note that final path may be different if

   * headers change before finalization.

   * @param headers supplies the request headers.

   * @param context supplies the formatter context for path generation.

   * @param stream_info holds additional information about the request.

   * @return std::string the value of the URL path after rewrite or empty string

   *         if rewrite is not configured or rewrite failed.

   */

  virtual std::string

  currentUrlPathAfterRewrite(const Http::RequestHeaderMap& headers,

                             const Formatter::Context& context,

                             const StreamInfo::StreamInfo& stream_info) const PURE;

  /**

   * Do potentially destructive header transforms on request headers prior to forwarding. For

   * example URL prefix rewriting, adding headers, etc. This should only be called ONCE

   * immediately prior to forwarding. It is done this way vs. copying for performance reasons.

   * @param headers supplies the request headers, which may be modified during this call.

   * @param stream_info holds additional information about the request.

   * @param keep_original_host_or_path insert x-envoy-original-path header if path rewritten,

   *        or x-envoy-original-host header if host rewritten.

   */

  virtual void finalizeRequestHeaders(Http::RequestHeaderMap& headers,

                                      const Formatter::Context& context,

                                      const StreamInfo::StreamInfo& stream_info,

                                      bool keep_original_host_or_path) const PURE;

  /**

   * Returns the request header transforms that would be applied if finalizeRequestHeaders were

   * called now. This is useful if you want to obtain request header transforms which was or will be

   * applied through finalizeRequestHeaders call. Note: do not use unless you are sure that there

   * will be no route modifications later in the filter chain.

   * @param stream_info holds additional information about the request.

   * @param do_formatting whether or not to evaluate configured transformations; if false, returns

   * original values instead.

   */

  virtual Http::HeaderTransforms requestHeaderTransforms(const StreamInfo::StreamInfo& stream_info,

                                                         bool do_formatting = true) const PURE;

  /**

   * @return const HashPolicy* the optional hash policy for the route.

   */

  virtual const Http::HashPolicy* hashPolicy() const PURE;

  /**

   * @return const HedgePolicy& the hedge policy for the route. All routes have a hedge policy even

   *         if it is empty and does not allow for hedged requests.

   */

  virtual const HedgePolicy& hedgePolicy() const PURE;

  /**

   * @return the priority of the route.

   */

  virtual Upstream::ResourcePriority priority() const PURE;

  /**

   * @return const RateLimitPolicy& the rate limit policy for the route.

   */

  virtual const RateLimitPolicy& rateLimitPolicy() const PURE;

  /**

   * @return const RetryPolicy& the retry policy for the route. All routes have a retry policy even

   *         if it is empty and does not allow retries.

   */

  virtual const RetryPolicyConstSharedPtr& retryPolicy() const PURE;

  /**

   * @return const InternalRedirectPolicy& the internal redirect policy for the route. All routes

   *         have a internal redirect policy even if it is not enabled, which means redirects are

   *         simply proxied as normal responses.

   */

  virtual const InternalRedirectPolicy& internalRedirectPolicy() const PURE;

  /**

   * @return const PathMatcherSharedPtr& the path match policy for the route.

   */

  virtual const PathMatcherSharedPtr& pathMatcher() const PURE;

  /**

   * @return const PathRewriterSharedPtr& the path match rewrite for the route.

   */

  virtual const PathRewriterSharedPtr& pathRewriter() const PURE;

  /**

   * @return uint64_t the maximum bytes which should be buffered for request bodies. This enables

   *         buffering larger request bodies beyond the connection buffer limit for use cases

   *         with large payloads, shadowing, or retries.

   *

   *         This method consolidates the functionality of the previous

   *         per_request_buffer_limit_bytes and request_body_buffer_limit fields. It supports both

   *         legacy configurations using per_request_buffer_limit_bytes and new configurations using

   *         request_body_buffer_limit.

   *

   *         If neither is set, falls back to connection buffer limits. Unlike some other buffer

   *         limits, 0 here indicates buffering should not be performed rather than no limit

   * applies.

   */

  virtual uint64_t requestBodyBufferLimit() const PURE;

  /**

   * @return const std::vector<ShadowPolicy>& the shadow policies for the route. The vector is empty

   *         if no shadowing takes place.

   */

  virtual const std::vector<ShadowPolicyPtr>& shadowPolicies() const PURE;

  /**

   * @return std::chrono::milliseconds the route's timeout.

   */

  virtual std::chrono::milliseconds timeout() const PURE;

  /**

   * @return optional<std::chrono::milliseconds> the route's idle timeout. Zero indicates a

   *         disabled idle timeout, while nullopt indicates deference to the global timeout.

   */

  virtual absl::optional<std::chrono::milliseconds> idleTimeout() const PURE;

  /**

   * @return optional<std::chrono::milliseconds> the route's flush timeout. Zero indicates a

   *         disabled idle timeout, while nullopt indicates deference to the global timeout.

   */

  virtual absl::optional<std::chrono::milliseconds> flushTimeout() const PURE;

  /**

   * @return true if new style max_stream_duration config should be used over the old style.

   */

  virtual bool usingNewTimeouts() const PURE;

  /**

   * @return optional<std::chrono::milliseconds> the route's maximum stream duration.

   */

  virtual absl::optional<std::chrono::milliseconds> maxStreamDuration() const PURE;

  /**

   * @return optional<std::chrono::milliseconds> the max grpc-timeout this route will allow.

   */

  virtual absl::optional<std::chrono::milliseconds> grpcTimeoutHeaderMax() const PURE;

  /**

   * @return optional<std::chrono::milliseconds> the delta between grpc-timeout and enforced grpc

   *         timeout.

   */

  virtual absl::optional<std::chrono::milliseconds> grpcTimeoutHeaderOffset() const PURE;

  /**

   * @return absl::optional<std::chrono::milliseconds> the maximum allowed timeout value derived

   * from 'grpc-timeout' header of a gRPC request. Non-present value disables use of 'grpc-timeout'

   * header, while 0 represents infinity.

   */

  virtual absl::optional<std::chrono::milliseconds> maxGrpcTimeout() const PURE;

  /**

   * @return absl::optional<std::chrono::milliseconds> the timeout offset to apply to the timeout

   * provided by the 'grpc-timeout' header of a gRPC request. This value will be positive and should

   * be subtracted from the value provided by the header.

   */

  virtual absl::optional<std::chrono::milliseconds> grpcTimeoutOffset() const PURE;

  /**

   * @return bool true if the :authority header should be overwritten with the upstream hostname.

   */

  virtual bool autoHostRewrite() const PURE;

  /**

   * @return bool true if the x-forwarded-host header should be updated.

   */

  virtual bool appendXfh() const PURE;

  /**

   * @return MetadataMatchCriteria* the metadata that a subset load balancer should match when

   * selecting an upstream host

   */

  virtual const MetadataMatchCriteria* metadataMatchCriteria() const PURE;

  /**

   * @return const std::multimap<std::string, std::string> the opaque configuration associated

   *         with the route

   */

  virtual const std::multimap<std::string, std::string>& opaqueConfig() const PURE;

  /**

   * @return bool true if the virtual host rate limits should be included.

   */

  virtual bool includeVirtualHostRateLimits() const PURE;

  /**

   * @return TlsContextMatchCriteria* the tls context match criterion for this route. If there is no

   * tls context match criteria, nullptr is returned.

   */

  virtual const TlsContextMatchCriteria* tlsContextMatchCriteria() const PURE;

  /**

   * @return const PathMatchCriterion& the match criterion for this route.

   */

  virtual const PathMatchCriterion& pathMatchCriterion() const PURE;

  /**

   * True if the virtual host this RouteEntry belongs to is configured to include the attempt

   * count header.

   * @return bool whether x-envoy-attempt-count should be included on the upstream request.

   */

  virtual bool includeAttemptCountInRequest() const PURE;

  /**

   * True if the virtual host this RouteEntry belongs to is configured to include the attempt

   * count header.

   * @return bool whether x-envoy-attempt-count should be included on the downstream response.

   */

  virtual bool includeAttemptCountInResponse() const PURE;

  using UpgradeMap = std::map<std::string, bool>;

  /**

   * @return a map of route-specific upgrades to their enabled/disabled status.

   */

  virtual const UpgradeMap& upgradeMap() const PURE;

  using ConnectConfig = envoy::config::route::v3::RouteAction::UpgradeConfig::ConnectConfig;

  using ConnectConfigOptRef = OptRef<ConnectConfig>;

  /**

   * If present, informs how to handle proxying CONNECT requests on this route.

   */

  virtual const ConnectConfigOptRef connectConfig() const PURE;

  /**

   * @return RouteStatsContextOptRef the config needed to generate route level stats.

   */

  virtual const RouteStatsContextOptRef routeStatsContext() const PURE;

  /**

   * @return EarlyDataPolicy& the configured early data option.

   */

  virtual const EarlyDataPolicy& earlyDataPolicy() const PURE;

  /**

   * Refresh the target cluster of the route with the request attributes if possible.

   */

  virtual void refreshRouteCluster(const Http::RequestHeaderMap& headers,

                                   const StreamInfo::StreamInfo& stream_info) const PURE;

};

/**

 * An interface representing the Decorator.

 */

class Decorator {

public:

  /**

   * This method decorates the supplied span.

   * @param Tracing::Span& the span.

   */

  virtual void apply(Tracing::Span& span) const PURE;

  /**

   * This method returns the operation name.

   * @return the operation name

   */

  virtual const std::string& getOperation() const PURE;

  /**

   * This method returns whether the decorator information

   * should be propagated to other services.

   * @return whether to propagate

   */

  virtual bool propagate() const PURE;

};

using DecoratorConstPtr = std::unique_ptr<const Decorator>;

/**

 * An interface representing the Tracing for the route configuration.

 */

class RouteTracing {

public:

  /**

   * This method returns the client sampling percentage.

   * @return the client sampling percentage

   */

  virtual const envoy::type::v3::FractionalPercent& getClientSampling() const PURE;

  /**

   * This method returns the random sampling percentage.

   * @return the random sampling percentage

   */

  virtual const envoy::type::v3::FractionalPercent& getRandomSampling() const PURE;

  /**

   * This method returns the overall sampling percentage.

   * @return the overall sampling percentage

   */

  virtual const envoy::type::v3::FractionalPercent& getOverallSampling() const PURE;

  /**

   * This method returns the route level tracing custom tags.

   * @return the tracing custom tags.

   */

  virtual const Tracing::CustomTagMap& getCustomTags() const PURE;

  /**

   * This method returns operation name formatter of span for the route.

   * @return the operation formatter.

   */

  virtual OptRef<const Formatter::Formatter> operation() const PURE;

  /**

   * This method returns operation name formatter of upstream span for the route.

   * @return the operation name formatter.

   */

  virtual OptRef<const Formatter::Formatter> upstreamOperation() const PURE;

};

using RouteTracingConstPtr = std::unique_ptr<const RouteTracing>;

/**

 * An interface that holds a DirectResponseEntry or RouteEntry for a request.

 */

class Route {

public:

  /**

   * @return the direct response entry or nullptr if there is no direct response for the request.

   */

  virtual const DirectResponseEntry* directResponseEntry() const PURE;

  /**

   * @return the route entry or nullptr if there is no matching route for the request.

   */

  virtual const RouteEntry* routeEntry() const PURE;

  /**

   * @return the decorator or nullptr if not defined for the request.

   */

  virtual const Decorator* decorator() const PURE;

  /**

   * @return the tracing config or nullptr if not defined for the request.

   */

  virtual const RouteTracing* tracingConfig() const PURE;

  /**

   * Check if the filter is disabled for this route.

   * @param config_name supplies the name of the filter config in the HTTP filter chain. This name

   * may be different from the filter extension qualified name.

   * @return true if the filter is disabled for this route, false if the filter is enabled.

   *         nullopt if no decision can be made explicitly for the filter.

   */

  virtual absl::optional<bool> filterDisabled(absl::string_view config_name) const PURE;

  /**

   * This is a helper to get the route's per-filter config if it exists, up along the config

   * hierarchy(Route --> VirtualHost --> RouteConfiguration). Or nullptr if none of them exist.

   */

  virtual const RouteSpecificFilterConfig*

  mostSpecificPerFilterConfig(absl::string_view name) const PURE;

  /**

   * Return all the available per route filter configs. The configs is in order of specificity.

   * That means that the config from a route configuration will be first, then the config from a

   * virtual host, then the config from a route.

   */

  virtual Router::RouteSpecificFilterConfigs perFilterConfigs(absl::string_view name) const PURE;

  /**

   * @return const envoy::config::core::v3::Metadata& return the metadata provided in the config for

   * this route.

   */

  virtual const envoy::config::core::v3::Metadata& metadata() const PURE;

  /**

   * @return const Envoy::Config::TypedMetadata& return the typed metadata provided in the config

   * for this route.

   */

  virtual const Envoy::Config::TypedMetadata& typedMetadata() const PURE;

  /**

   * @return std::string& the name of the route.

   */

  virtual const std::string& routeName() const PURE;

  /**

   * @return const VirtualHostConstSharedPtr& the virtual host that owns the route.

   *

   * NOTE: This MUST not be null.

   */

  virtual const VirtualHostConstSharedPtr& virtualHost() const PURE;

};