Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include "envoy/router/router.h"
       4             : 
       5             : #include "source/common/http/hash_policy.h"
       6             : #include "source/common/protobuf/message_validator_impl.h"
       7             : #include "source/common/router/config_impl.h"
       8             : #include "source/common/upstream/retry_factory.h"
       9             : #include "source/extensions/early_data/default_early_data_policy.h"
      10             : 
      11             : namespace Envoy {
      12             : namespace Http {
      13             : 
      14             : struct NullHedgePolicy : public Router::HedgePolicy {
      15             :   // Router::HedgePolicy
      16           0 :   uint32_t initialRequests() const override { return 1; }
      17           0 :   const envoy::type::v3::FractionalPercent& additionalRequestChance() const override {
      18           0 :     return additional_request_chance_;
      19           0 :   }
      20          68 :   bool hedgeOnPerTryTimeout() const override { return false; }
      21             : 
      22             :   const envoy::type::v3::FractionalPercent additional_request_chance_;
      23             : };
      24             : 
      25             : struct NullRateLimitPolicy : public Router::RateLimitPolicy {
      26             :   // Router::RateLimitPolicy
      27             :   const std::vector<std::reference_wrapper<const Router::RateLimitPolicyEntry>>&
      28           0 :   getApplicableRateLimit(uint64_t) const override {
      29           0 :     return rate_limit_policy_entry_;
      30           0 :   }
      31           0 :   bool empty() const override { return true; }
      32             : 
      33             :   static const std::vector<std::reference_wrapper<const Router::RateLimitPolicyEntry>>
      34             :       rate_limit_policy_entry_;
      35             : };
      36             : 
      37             : struct NullCommonConfig : public Router::CommonConfig {
      38           0 :   const std::list<LowerCaseString>& internalOnlyHeaders() const override {
      39           0 :     return internal_only_headers_;
      40           0 :   }
      41             : 
      42           0 :   const std::string& name() const override { return EMPTY_STRING; }
      43           0 :   bool usesVhds() const override { return false; }
      44           0 :   bool mostSpecificHeaderMutationsWins() const override { return false; }
      45           0 :   uint32_t maxDirectResponseBodySizeBytes() const override { return 0; }
      46           0 :   const envoy::config::core::v3::Metadata& metadata() const override {
      47           0 :     return Router::DefaultRouteMetadataPack::get().proto_metadata_;
      48           0 :   }
      49           0 :   const Envoy::Config::TypedMetadata& typedMetadata() const override {
      50           0 :     return Router::DefaultRouteMetadataPack::get().typed_metadata_;
      51           0 :   }
      52             : 
      53             :   static const std::list<LowerCaseString> internal_only_headers_;
      54             : };
      55             : 
      56             : struct NullVirtualHost : public Router::VirtualHost {
      57             :   // Router::VirtualHost
      58          68 :   Stats::StatName statName() const override { return {}; }
      59           0 :   const Router::RateLimitPolicy& rateLimitPolicy() const override { return rate_limit_policy_; }
      60           0 :   const Router::CorsPolicy* corsPolicy() const override { return nullptr; }
      61           0 :   const Router::CommonConfig& routeConfig() const override { return route_configuration_; }
      62           0 :   bool includeAttemptCountInRequest() const override { return false; }
      63           0 :   bool includeAttemptCountInResponse() const override { return false; }
      64          68 :   bool includeIsTimeoutRetryHeader() const override { return false; }
      65           0 :   uint32_t retryShadowBufferLimit() const override { return std::numeric_limits<uint32_t>::max(); }
      66             :   const Router::RouteSpecificFilterConfig*
      67           0 :   mostSpecificPerFilterConfig(const std::string&) const override {
      68           0 :     return nullptr;
      69           0 :   }
      70             :   void traversePerFilterConfig(
      71             :       const std::string&,
      72           0 :       std::function<void(const Router::RouteSpecificFilterConfig&)>) const override {}
      73           0 :   const envoy::config::core::v3::Metadata& metadata() const override {
      74           0 :     return Router::DefaultRouteMetadataPack::get().proto_metadata_;
      75           0 :   }
      76           0 :   const Envoy::Config::TypedMetadata& typedMetadata() const override {
      77           0 :     return Router::DefaultRouteMetadataPack::get().typed_metadata_;
      78           0 :   }
      79             : 
      80             :   static const NullRateLimitPolicy rate_limit_policy_;
      81             :   static const NullCommonConfig route_configuration_;
      82             : };
      83             : 
      84             : struct NullPathMatchCriterion : public Router::PathMatchCriterion {
      85           0 :   Router::PathMatchType matchType() const override { return Router::PathMatchType::None; }
      86           0 :   const std::string& matcher() const override { return EMPTY_STRING; }
      87             : };
      88             : 
      89             : struct RouteEntryImpl : public Router::RouteEntry {
      90             :   RouteEntryImpl(
      91             :       const std::string& cluster_name, Singleton::Manager& singleton_manager,
      92             :       const absl::optional<std::chrono::milliseconds>& timeout,
      93             :       const Protobuf::RepeatedPtrField<envoy::config::route::v3::RouteAction::HashPolicy>&
      94             :           hash_policy,
      95             :       const absl::optional<envoy::config::route::v3::RetryPolicy>& retry_policy)
      96          68 :       : cluster_name_(cluster_name), timeout_(timeout) {
      97          68 :     if (!hash_policy.empty()) {
      98           0 :       hash_policy_ = std::make_unique<HashPolicyImpl>(hash_policy);
      99           0 :     }
     100          68 :     if (retry_policy.has_value()) {
     101             :       // ProtobufMessage::getStrictValidationVisitor() ?  how often do we do this?
     102           0 :       Upstream::RetryExtensionFactoryContextImpl factory_context(singleton_manager);
     103           0 :       retry_policy_ = std::make_unique<Router::RetryPolicyImpl>(
     104           0 :           retry_policy.value(), ProtobufMessage::getNullValidationVisitor(), factory_context);
     105          68 :     } else {
     106          68 :       retry_policy_ = std::make_unique<Router::RetryPolicyImpl>();
     107          68 :     }
     108          68 :   }
     109             : 
     110             :   // Router::RouteEntry
     111          68 :   const std::string& clusterName() const override { return cluster_name_; }
     112          68 :   const Router::RouteStatsContextOptRef routeStatsContext() const override {
     113          68 :     return Router::RouteStatsContextOptRef();
     114          68 :   }
     115           0 :   Http::Code clusterNotFoundResponseCode() const override {
     116           0 :     return Http::Code::InternalServerError;
     117           0 :   }
     118           0 :   const Router::CorsPolicy* corsPolicy() const override { return nullptr; }
     119             :   absl::optional<std::string>
     120           0 :   currentUrlPathAfterRewrite(const Http::RequestHeaderMap&) const override {
     121           0 :     return {};
     122           0 :   }
     123             :   void finalizeRequestHeaders(Http::RequestHeaderMap&, const StreamInfo::StreamInfo&,
     124          68 :                               bool) const override {}
     125             :   Http::HeaderTransforms requestHeaderTransforms(const StreamInfo::StreamInfo&,
     126           0 :                                                  bool) const override {
     127           0 :     return {};
     128           0 :   }
     129             :   void finalizeResponseHeaders(Http::ResponseHeaderMap&,
     130          68 :                                const StreamInfo::StreamInfo&) const override {}
     131             :   Http::HeaderTransforms responseHeaderTransforms(const StreamInfo::StreamInfo&,
     132           0 :                                                   bool) const override {
     133           0 :     return {};
     134           0 :   }
     135           0 :   const HashPolicy* hashPolicy() const override { return hash_policy_.get(); }
     136          68 :   const Router::HedgePolicy& hedgePolicy() const override { return hedge_policy_; }
     137           0 :   const Router::MetadataMatchCriteria* metadataMatchCriteria() const override { return nullptr; }
     138         136 :   Upstream::ResourcePriority priority() const override {
     139         136 :     return Upstream::ResourcePriority::Default;
     140         136 :   }
     141           0 :   const Router::RateLimitPolicy& rateLimitPolicy() const override { return rate_limit_policy_; }
     142         204 :   const Router::RetryPolicy& retryPolicy() const override { return *retry_policy_; }
     143         499 :   const Router::InternalRedirectPolicy& internalRedirectPolicy() const override {
     144         499 :     return internal_redirect_policy_;
     145         499 :   }
     146           0 :   const Router::PathMatcherSharedPtr& pathMatcher() const override { return path_matcher_; }
     147           0 :   const Router::PathRewriterSharedPtr& pathRewriter() const override { return path_rewriter_; }
     148          68 :   uint32_t retryShadowBufferLimit() const override { return std::numeric_limits<uint32_t>::max(); }
     149          68 :   const std::vector<Router::ShadowPolicyPtr>& shadowPolicies() const override {
     150          68 :     return shadow_policies_;
     151          68 :   }
     152          68 :   std::chrono::milliseconds timeout() const override {
     153          68 :     if (timeout_) {
     154           0 :       return timeout_.value();
     155          68 :     } else {
     156          68 :       return std::chrono::milliseconds(0);
     157          68 :     }
     158          68 :   }
     159          68 :   bool usingNewTimeouts() const override { return false; }
     160           0 :   absl::optional<std::chrono::milliseconds> idleTimeout() const override { return absl::nullopt; }
     161           0 :   absl::optional<std::chrono::milliseconds> maxStreamDuration() const override {
     162           0 :     return absl::nullopt;
     163           0 :   }
     164           0 :   absl::optional<std::chrono::milliseconds> grpcTimeoutHeaderMax() const override {
     165           0 :     return absl::nullopt;
     166           0 :   }
     167           0 :   absl::optional<std::chrono::milliseconds> grpcTimeoutHeaderOffset() const override {
     168           0 :     return absl::nullopt;
     169           0 :   }
     170          68 :   absl::optional<std::chrono::milliseconds> maxGrpcTimeout() const override {
     171          68 :     return absl::nullopt;
     172          68 :   }
     173           0 :   absl::optional<std::chrono::milliseconds> grpcTimeoutOffset() const override {
     174           0 :     return absl::nullopt;
     175           0 :   }
     176          68 :   const Router::VirtualCluster* virtualCluster(const Http::HeaderMap&) const override {
     177          68 :     return nullptr;
     178          68 :   }
     179           0 :   const Router::TlsContextMatchCriteria* tlsContextMatchCriteria() const override {
     180           0 :     return nullptr;
     181           0 :   }
     182           0 :   const std::multimap<std::string, std::string>& opaqueConfig() const override {
     183           0 :     return opaque_config_;
     184           0 :   }
     185         136 :   const Router::VirtualHost& virtualHost() const override { return virtual_host_; }
     186          68 :   bool autoHostRewrite() const override { return false; }
     187           0 :   bool appendXfh() const override { return false; }
     188           0 :   bool includeVirtualHostRateLimits() const override { return true; }
     189           0 :   const Router::PathMatchCriterion& pathMatchCriterion() const override {
     190           0 :     return path_match_criterion_;
     191           0 :   }
     192             : 
     193          68 :   const ConnectConfigOptRef connectConfig() const override { return connect_config_nullopt_; }
     194             : 
     195          68 :   bool includeAttemptCountInRequest() const override { return false; }
     196          68 :   bool includeAttemptCountInResponse() const override { return false; }
     197           0 :   const Router::RouteEntry::UpgradeMap& upgradeMap() const override { return upgrade_map_; }
     198          68 :   const Router::EarlyDataPolicy& earlyDataPolicy() const override { return *early_data_policy_; }
     199             : 
     200             :   std::unique_ptr<const HashPolicyImpl> hash_policy_;
     201             :   std::unique_ptr<Router::RetryPolicy> retry_policy_;
     202             : 
     203             :   static const NullHedgePolicy hedge_policy_;
     204             :   static const NullRateLimitPolicy rate_limit_policy_;
     205             :   static const Router::InternalRedirectPolicyImpl internal_redirect_policy_;
     206             :   static const Router::PathMatcherSharedPtr path_matcher_;
     207             :   static const Router::PathRewriterSharedPtr path_rewriter_;
     208             :   static const std::vector<Router::ShadowPolicyPtr> shadow_policies_;
     209             :   static const NullVirtualHost virtual_host_;
     210             :   static const std::multimap<std::string, std::string> opaque_config_;
     211             :   static const NullPathMatchCriterion path_match_criterion_;
     212             : 
     213             :   Router::RouteEntry::UpgradeMap upgrade_map_;
     214             :   const std::string cluster_name_;
     215             :   absl::optional<std::chrono::milliseconds> timeout_;
     216             :   static const ConnectConfigOptRef connect_config_nullopt_;
     217             :   // Pass early data option config through StreamOptions.
     218             :   std::unique_ptr<Router::EarlyDataPolicy> early_data_policy_{
     219             :       new Router::DefaultEarlyDataPolicy(true)};
     220             : };
     221             : 
     222             : struct NullRouteImpl : public Router::Route {
     223             :   NullRouteImpl(const std::string cluster_name, Singleton::Manager& singleton_manager,
     224             :                 const absl::optional<std::chrono::milliseconds>& timeout = {},
     225             :                 const Protobuf::RepeatedPtrField<envoy::config::route::v3::RouteAction::HashPolicy>&
     226             :                     hash_policy = {},
     227             :                 const absl::optional<envoy::config::route::v3::RetryPolicy>& retry_policy = {})
     228          68 :       : route_entry_(cluster_name, singleton_manager, timeout, hash_policy, retry_policy) {}
     229             : 
     230             :   // Router::Route
     231          68 :   const Router::DirectResponseEntry* directResponseEntry() const override { return nullptr; }
     232         136 :   const Router::RouteEntry* routeEntry() const override { return &route_entry_; }
     233           0 :   const Router::Decorator* decorator() const override { return nullptr; }
     234           0 :   const Router::RouteTracing* tracingConfig() const override { return nullptr; }
     235             :   const Router::RouteSpecificFilterConfig*
     236           0 :   mostSpecificPerFilterConfig(const std::string&) const override {
     237           0 :     return nullptr;
     238           0 :   }
     239             :   void traversePerFilterConfig(
     240             :       const std::string&,
     241           0 :       std::function<void(const Router::RouteSpecificFilterConfig&)>) const override {}
     242           0 :   const envoy::config::core::v3::Metadata& metadata() const override {
     243           0 :     return Router::DefaultRouteMetadataPack::get().proto_metadata_;
     244           0 :   }
     245           0 :   const Envoy::Config::TypedMetadata& typedMetadata() const override {
     246           0 :     return Router::DefaultRouteMetadataPack::get().typed_metadata_;
     247           0 :   }
     248           0 :   absl::optional<bool> filterDisabled(absl::string_view) const override { return {}; }
     249           0 :   const std::string& routeName() const override { return EMPTY_STRING; }
     250             : 
     251             :   RouteEntryImpl route_entry_;
     252             : };
     253             : 
     254             : } // namespace Http
     255             : } // namespace Envoy