Grcov report - config.h

1

#pragma once

2

3

#include <chrono>

4

#include <cstdint>

5

#include <functional>

6

#include <list>

7

#include <map>

8

#include <string>

9

10

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

11

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

12

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

13

#include "envoy/extensions/upstreams/http/v3/http_protocol_options.pb.h"

14

#include "envoy/extensions/upstreams/http/v3/http_protocol_options.pb.validate.h"

15

#include "envoy/http/filter.h"

16

#include "envoy/http/header_validator.h"

17

#include "envoy/router/router.h"

18

#include "envoy/server/filter_config.h"

19

#include "envoy/server/transport_socket_config.h"

20

#include "envoy/upstream/upstream.h"

21

22

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

23

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

24

#include "source/extensions/common/matcher/matcher.h"

25

26

namespace Envoy {

27

namespace Extensions {

28

namespace Upstreams {

29

namespace Http {

30

31

class ProtocolOptionsConfigImpl : public Upstream::HttpProtocolOptionsConfig {

32

public:

33

  static absl::StatusOr<std::shared_ptr<ProtocolOptionsConfigImpl>> createProtocolOptionsConfig(

34

      const envoy::extensions::upstreams::http::v3::HttpProtocolOptions& options,

35

      Server::Configuration::ServerFactoryContext& server_context);

36

  static absl::StatusOr<std::shared_ptr<ProtocolOptionsConfigImpl>> createProtocolOptionsConfig(

37

      const envoy::config::core::v3::Http1ProtocolOptions& http1_settings,

38

      const envoy::config::core::v3::Http2ProtocolOptions& http2_options,

39

      const envoy::config::core::v3::HttpProtocolOptions& common_options,

40

      const absl::optional<envoy::config::core::v3::UpstreamHttpProtocolOptions> upstream_options,

41

      bool use_downstream_protocol, bool use_http2,

42

      Server::Configuration::ServerFactoryContext& server_context,

43

      ProtobufMessage::ValidationVisitor& validation_visitor);

44

45

  // Given the supplied cluster config, and protocol options configuration,

46

  // returns a unit64_t representing the enabled Upstream::ClusterInfo::Features.

47

  static uint64_t parseFeatures(const envoy::config::cluster::v3::Cluster& config,

48

                                const ProtocolOptionsConfigImpl& options);

49

50

21973

  const Envoy::Http::Http1Settings& http1Settings() const override { return http1_settings_; }

51

17945

  const envoy::config::core::v3::Http2ProtocolOptions& http2Options() const override {

52

17945

    return http2_options_;

53

17945

54

3706

  const envoy::config::core::v3::Http3ProtocolOptions& http3Options() const override {

55

3706

    return http3_options_;

56

3706

57

46399

  const envoy::config::core::v3::HttpProtocolOptions& commonHttpProtocolOptions() const override {

58

46399

    return common_http_protocol_options_;

59

46399

60

  const absl::optional<envoy::config::core::v3::UpstreamHttpProtocolOptions>&

61

47113

  upstreamHttpProtocolOptions() const override {

62

47113

    return upstream_http_protocol_options_;

63

47113

64

  const absl::optional<const envoy::config::core::v3::AlternateProtocolsCacheOptions>&

65

47297

  alternateProtocolsCacheOptions() const override {

66

47297

    return alternate_protocol_cache_options_;

67

47297

68

46042

  const std::vector<Envoy::Router::ShadowPolicyPtr>& shadowPolicies() const override {

69

46042

    return shadow_policies_;

70

46042

71

46706

  const Envoy::Router::RetryPolicy* retryPolicy() const override { return retry_policy_.get(); }

72

1337

  const Envoy::Http::HashPolicy* hashPolicy() const override { return hash_policy_.get(); }

73

74

  const Envoy::Http::Http1Settings http1_settings_;

75

  const envoy::config::core::v3::Http2ProtocolOptions http2_options_;

76

  const envoy::config::core::v3::Http3ProtocolOptions http3_options_{};

77

  const envoy::config::core::v3::HttpProtocolOptions common_http_protocol_options_;

78

  const absl::optional<envoy::config::core::v3::UpstreamHttpProtocolOptions>

79

      upstream_http_protocol_options_;

80

81

  using FiltersList = Protobuf::RepeatedPtrField<

82

      envoy::extensions::filters::network::http_connection_manager::v3::HttpFilter>;

83

  const FiltersList http_filters_;

84

  const absl::optional<const envoy::config::core::v3::AlternateProtocolsCacheOptions>

85

      alternate_protocol_cache_options_;

86

  const Envoy::Http::HeaderValidatorFactoryPtr header_validator_factory_;

87

  const bool use_downstream_protocol_{};

88

  const bool use_http2_{};

89

  const bool use_http3_{};

90

  const bool use_alpn_{};

91

92

  std::vector<Extensions::Common::Matcher::MatcherPtr> outlier_detection_http_error_matcher_;

93

  const std::vector<Envoy::Router::ShadowPolicyPtr> shadow_policies_;

94

  const std::shared_ptr<const Envoy::Router::RetryPolicy> retry_policy_;

95

  const std::unique_ptr<Envoy::Http::HashPolicy> hash_policy_;

96

97

private:

98

  static absl::StatusOr<std::vector<Envoy::Router::ShadowPolicyPtr>>

99

  buildShadowPolicies(const envoy::extensions::upstreams::http::v3::HttpProtocolOptions& options,

100

                      Server::Configuration::ServerFactoryContext& server_context);

101

102

  static absl::StatusOr<std::shared_ptr<const Envoy::Router::RetryPolicy>>

103

  buildRetryPolicy(const envoy::extensions::upstreams::http::v3::HttpProtocolOptions& options,

104

                   ProtobufMessage::ValidationVisitor& validation_visitor,

105

                   Server::Configuration::ServerFactoryContext& server_context);

106

107

  static absl::StatusOr<std::unique_ptr<Envoy::Http::HashPolicy>>

108

  buildHashPolicy(const envoy::extensions::upstreams::http::v3::HttpProtocolOptions& options,

109

                  Server::Configuration::ServerFactoryContext& server_context);

110

111

  ProtocolOptionsConfigImpl(

112

      const envoy::extensions::upstreams::http::v3::HttpProtocolOptions& options,

113

      envoy::config::core::v3::Http2ProtocolOptions validated_h2_options,

114

      Envoy::Http::HeaderValidatorFactoryPtr&& header_validator_factory,

115

      absl::optional<const envoy::config::core::v3::AlternateProtocolsCacheOptions> cache_options,

116

      std::vector<Envoy::Router::ShadowPolicyPtr>&& shadow_policies,

117

      std::shared_ptr<const Envoy::Router::RetryPolicy>&& retry_policy,

118

      std::unique_ptr<Envoy::Http::HashPolicy>&& hash_policy,

119

      Server::Configuration::ServerFactoryContext& server_context);

120

  // Constructor for legacy (deprecated) config.

121

  ProtocolOptionsConfigImpl(

122

      const envoy::config::core::v3::Http1ProtocolOptions& http1_settings,

123

      const envoy::config::core::v3::Http2ProtocolOptions& validated_http2_options,

124

      const envoy::config::core::v3::HttpProtocolOptions& common_options,

125

      const absl::optional<envoy::config::core::v3::UpstreamHttpProtocolOptions> upstream_options,

126

      bool use_downstream_protocol, bool use_http2,

127

      Server::Configuration::ServerFactoryContext& server_context,

128

      ProtobufMessage::ValidationVisitor& validation_visitor);

129

};

130

131

class ProtocolOptionsConfigFactory : public Server::Configuration::ProtocolOptionsFactory {

132

public:

133

  absl::StatusOr<Upstream::ProtocolOptionsConfigConstSharedPtr> createProtocolOptionsConfig(

134

      const Protobuf::Message& config,

135

13449

      Server::Configuration::ProtocolOptionsFactoryContext& context) override {

136

13449

    const auto& typed_config = MessageUtil::downcastAndValidate<

137

13449

        const envoy::extensions::upstreams::http::v3::HttpProtocolOptions&>(

138

13449

        config, context.messageValidationVisitor());

139

13449

    auto result = ProtocolOptionsConfigImpl::createProtocolOptionsConfig(

140

13449

        typed_config, context.serverFactoryContext());

141

13449

    if (!result.ok()) {

142

      return result.status();

143

144

13449

    return std::static_pointer_cast<const Upstream::ProtocolOptionsConfig>(result.value());

145

13449

146

147

2616

  std::string category() const override { return "envoy.upstream_options"; }

148

14596

  std::string name() const override {

149

14596

    return "envoy.extensions.upstreams.http.v3.HttpProtocolOptions";

150

14596

151

933

  ProtobufTypes::MessagePtr createEmptyConfigProto() override {

152

933

    return std::make_unique<envoy::extensions::upstreams::http::v3::HttpProtocolOptions>();

153

933

154

13449

  ProtobufTypes::MessagePtr createEmptyProtocolOptionsProto() override {

155

13449

    return std::make_unique<envoy::extensions::upstreams::http::v3::HttpProtocolOptions>();

156

13449

157

};

158

159

DECLARE_FACTORY(ProtocolOptionsConfigFactory);

160

161

} // namespace Http

162

} // namespace Upstreams

163

} // namespace Extensions

164

} // namespace Envoy