Grcov report - config.h

1

#pragma once

2

3

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

4

#include "envoy/extensions/matching/common_inputs/transport_socket/v3/transport_socket_inputs.pb.h"

5

#include "envoy/extensions/matching/common_inputs/transport_socket/v3/transport_socket_inputs.pb.validate.h"

6

#include "envoy/matcher/matcher.h"

7

#include "envoy/registry/registry.h"

8

#include "envoy/upstream/transport_socket_matching_data.h"

9

10

#include "source/common/config/metadata.h"

11

12

#include "absl/strings/str_join.h"

13

14

namespace Envoy {

15

namespace Extensions {

16

namespace Matching {

17

namespace CommonInputs {

18

namespace TransportSocket {

19

20

/**

21

 * Base class for transport socket data input implementations.

22

*/

23

class TransportSocketInputBase : public Matcher::DataInput<Upstream::TransportSocketMatchingData> {

24

public:

25

  Matcher::DataInputGetResult get(const Upstream::TransportSocketMatchingData& data) const override;

26

27

protected:

28

/**

29

   * Extract the specific value from the matching data.

30

   * @param data the transport socket matching data.

31

   * @return the extracted string value or absl::nullopt if not available.

32

*/

33

  virtual absl::optional<std::string>

34

  getValue(const Upstream::TransportSocketMatchingData& data) const PURE;

35

};

36

37

/**

38

 * Data input for extracting endpoint metadata values.

39

*/

40

class EndpointMetadataInput : public TransportSocketInputBase {

41

public:

42

  EndpointMetadataInput(const std::string& filter, const std::vector<std::string>& path)

43

10

      : filter_(filter), path_(path) {}

44

45

protected:

46

  absl::optional<std::string>

47

  getValue(const Upstream::TransportSocketMatchingData& data) const override;

48

49

private:

50

  const std::string filter_;

51

  const std::vector<std::string> path_;

52

};

53

54

/**

55

 * Data input for extracting locality metadata values.

56

*/

57

class LocalityMetadataInput : public TransportSocketInputBase {

58

public:

59

  LocalityMetadataInput(const std::string& filter, const std::vector<std::string>& path)

60

7

      : filter_(filter), path_(path) {}

61

62

protected:

63

  absl::optional<std::string>

64

  getValue(const Upstream::TransportSocketMatchingData& data) const override;

65

66

private:

67

  const std::string filter_;

68

  const std::vector<std::string> path_;

69

};

70

71

/**

72

 * Factory for creating endpoint metadata data inputs.

73

*/

74

class EndpointMetadataInputFactory

75

    : public Matcher::DataInputFactory<Upstream::TransportSocketMatchingData> {

76

public:

77

11985

  std::string name() const override { return "envoy.matching.inputs.endpoint_metadata"; }

78

79

  Matcher::DataInputFactoryCb<Upstream::TransportSocketMatchingData>

80

  createDataInputFactoryCb(const Protobuf::Message& config,

81

                           ProtobufMessage::ValidationVisitor& validation_visitor) override;

82

83

  ProtobufTypes::MessagePtr createEmptyConfigProto() override;

84

};

85

86

/**

87

 * Factory for creating locality metadata data inputs.

88

*/

89

class LocalityMetadataInputFactory

90

    : public Matcher::DataInputFactory<Upstream::TransportSocketMatchingData> {

91

public:

92

11981

  std::string name() const override { return "envoy.matching.inputs.locality_metadata"; }

93

94

  Matcher::DataInputFactoryCb<Upstream::TransportSocketMatchingData>

95

  createDataInputFactoryCb(const Protobuf::Message& config,

96

                           ProtobufMessage::ValidationVisitor& validation_visitor) override;

97

98

  ProtobufTypes::MessagePtr createEmptyConfigProto() override;

99

};

100

101

/**

102

 * Data input for extracting values from filter state.

103

 * This enables downstream-connection-based matching by reading filter state that was

104

 * explicitly shared from downstream to upstream via TransportSocketOptions.

105

*/

106

class FilterStateInput : public TransportSocketInputBase {

107

public:

108

7

  explicit FilterStateInput(const std::string& key) : key_(key) {}

109

110

protected:

111

  absl::optional<std::string>

112

  getValue(const Upstream::TransportSocketMatchingData& data) const override;

113

114

private:

115

  const std::string key_;

116

};

117

118

/**

119

 * Factory for creating filter state data inputs.

120

*/

121

class FilterStateInputFactory

122

    : public Matcher::DataInputFactory<Upstream::TransportSocketMatchingData> {

123

public:

124

11982

  std::string name() const override {

125

11982

    return "envoy.matching.inputs.transport_socket_filter_state";

126

11982

127

128

  Matcher::DataInputFactoryCb<Upstream::TransportSocketMatchingData>

129

  createDataInputFactoryCb(const Protobuf::Message& config,

130

                           ProtobufMessage::ValidationVisitor& validation_visitor) override;

131

132

  ProtobufTypes::MessagePtr createEmptyConfigProto() override;

133

};

134

135

/**

136

 * Action that carries a transport socket name.

137

*/

138

class TransportSocketNameAction : public Matcher::Action {

139

public:

140

12

  explicit TransportSocketNameAction(const std::string& name) : name_(name) {}

141

11

  const std::string& name() const { return name_; }

142

  absl::string_view typeUrl() const override {

143

    return "type.googleapis.com/"

144

           "envoy.extensions.matching.common_inputs.transport_socket.v3.TransportSocketNameAction";

145

146

147

private:

148

  const std::string name_;

149

};

150

151

/**

152

 * ActionFactory that creates TransportSocketNameAction.

153

*/

154

class TransportSocketNameActionFactory

155

    : public Matcher::ActionFactory<Server::Configuration::ServerFactoryContext> {

156

public:

157

10838

  std::string name() const override { return "envoy.matching.action.transport_socket.name"; }

158

  Matcher::ActionConstSharedPtr createAction(const Protobuf::Message& config,

159

                                             Server::Configuration::ServerFactoryContext&,

160

                                             ProtobufMessage::ValidationVisitor&) override;

161

  ProtobufTypes::MessagePtr createEmptyConfigProto() override;

162

};

163

164

} // namespace TransportSocket

165

} // namespace CommonInputs

166

} // namespace Matching

167

} // namespace Extensions

168

} // namespace Envoy