/proc/self/cwd/source/extensions/filters/network/thrift_proxy/filter_utils.cc

Source (jump to first uncovered line)
#include "source/extensions/filters/network/thrift_proxy/filter_utils.h"

namespace Envoy {
namespace Extensions {
namespace NetworkFilters {
namespace ThriftProxy {
namespace ThriftFilters {

class DelegateDecoderFilter final : public DecoderFilter {
public:
  DelegateDecoderFilter(BidirectionalFilterSharedPtr filter) : parent_(filter){};
  // ThriftBaseFilter
  void onDestroy() override { throw EnvoyException(fmt::format("should not be called")); }

  void setDecoderFilterCallbacks(DecoderFilterCallbacks& callbacks) override {
    return parent_->setDecoderFilterCallbacks(callbacks);
  };

  // Thrift Decoder State Machine
  ThriftProxy::FilterStatus
  transportBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
    return parent_->decodeTransportBegin(metadata);
  }

  ThriftProxy::FilterStatus transportEnd() override { return parent_->decodeTransportEnd(); }

  bool passthroughSupported() const override { return parent_->decodePassthroughSupported(); }

  ThriftProxy::FilterStatus passthroughData(Buffer::Instance& data) override {
    return parent_->decodePassthroughData(data);
  }

  ThriftProxy::FilterStatus messageBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
    return parent_->decodeMessageBegin(metadata);
  }

  ThriftProxy::FilterStatus messageEnd() override { return parent_->decodeMessageEnd(); }

  ThriftProxy::FilterStatus structBegin(absl::string_view name) override {
    return parent_->decodeStructBegin(name);
  }

  ThriftProxy::FilterStatus structEnd() override { return parent_->decodeStructEnd(); }

  ThriftProxy::FilterStatus fieldBegin(absl::string_view name, ThriftProxy::FieldType& field_type,
                                       int16_t& field_id) override {
    return parent_->decodeFieldBegin(name, field_type, field_id);
  }

  ThriftProxy::FilterStatus fieldEnd() override { return parent_->decodeFieldEnd(); }

  ThriftProxy::FilterStatus boolValue(bool& value) override {
    return parent_->decodeBoolValue(value);
  }

  ThriftProxy::FilterStatus byteValue(uint8_t& value) override {
    return parent_->decodeByteValue(value);
  }

  ThriftProxy::FilterStatus int16Value(int16_t& value) override {
    return parent_->decodeInt16Value(value);
  }

  ThriftProxy::FilterStatus int32Value(int32_t& value) override {
    return parent_->decodeInt32Value(value);
  }

  ThriftProxy::FilterStatus int64Value(int64_t& value) override {
    return parent_->decodeInt64Value(value);
  }

  ThriftProxy::FilterStatus doubleValue(double& value) override {
    return parent_->decodeDoubleValue(value);
  }

  ThriftProxy::FilterStatus stringValue(absl::string_view value) override {
    return parent_->decodeStringValue(value);
  }

  ThriftProxy::FilterStatus mapBegin(ThriftProxy::FieldType& key_type,
                                     ThriftProxy::FieldType& value_type, uint32_t& size) override {
    return parent_->decodeMapBegin(key_type, value_type, size);
  }

  ThriftProxy::FilterStatus mapEnd() override { return parent_->decodeMapEnd(); }

  ThriftProxy::FilterStatus listBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
    return parent_->decodeListBegin(elem_type, size);
  }

  ThriftProxy::FilterStatus listEnd() override { return parent_->decodeListEnd(); }

  ThriftProxy::FilterStatus setBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
    return parent_->decodeSetBegin(elem_type, size);
  }

  ThriftProxy::FilterStatus setEnd() override { return parent_->decodeSetEnd(); }

private:
  BidirectionalFilterSharedPtr parent_;
};

using DelegateDecoderFilterSharedPtr = std::shared_ptr<DelegateDecoderFilter>;

class DelegateEncoderFilter final : public EncoderFilter {
public:
  DelegateEncoderFilter(BidirectionalFilterSharedPtr filter) : parent_(filter){};
  // ThriftBaseFilter
  void onDestroy() override { throw EnvoyException(fmt::format("should not be called")); }

  void setEncoderFilterCallbacks(EncoderFilterCallbacks& callbacks) override {
    return parent_->setEncoderFilterCallbacks(callbacks);
  };

  // Thrift Encoder State Machine
  ThriftProxy::FilterStatus
  transportBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
    return parent_->encodeTransportBegin(metadata);
  }

  ThriftProxy::FilterStatus transportEnd() override { return parent_->encodeTransportEnd(); }

  bool passthroughSupported() const override { return parent_->encodePassthroughSupported(); }

  ThriftProxy::FilterStatus passthroughData(Buffer::Instance& data) override {
    return parent_->encodePassthroughData(data);
  }

  ThriftProxy::FilterStatus messageBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
    return parent_->encodeMessageBegin(metadata);
  }

  ThriftProxy::FilterStatus messageEnd() override { return parent_->encodeMessageEnd(); }

  ThriftProxy::FilterStatus structBegin(absl::string_view name) override {
    return parent_->encodeStructBegin(name);
  }

  ThriftProxy::FilterStatus structEnd() override { return parent_->encodeStructEnd(); }

  ThriftProxy::FilterStatus fieldBegin(absl::string_view name, ThriftProxy::FieldType& field_type,
                                       int16_t& field_id) override {
    return parent_->encodeFieldBegin(name, field_type, field_id);
  }

  ThriftProxy::FilterStatus fieldEnd() override { return parent_->encodeFieldEnd(); }

  ThriftProxy::FilterStatus boolValue(bool& value) override {
    return parent_->encodeBoolValue(value);
  }

  ThriftProxy::FilterStatus byteValue(uint8_t& value) override {
    return parent_->encodeByteValue(value);
  }

  ThriftProxy::FilterStatus int16Value(int16_t& value) override {
    return parent_->encodeInt16Value(value);
  }

  ThriftProxy::FilterStatus int32Value(int32_t& value) override {
    return parent_->encodeInt32Value(value);
  }

  ThriftProxy::FilterStatus int64Value(int64_t& value) override {
    return parent_->encodeInt64Value(value);
  }

  ThriftProxy::FilterStatus doubleValue(double& value) override {
    return parent_->encodeDoubleValue(value);
  }

  ThriftProxy::FilterStatus stringValue(absl::string_view value) override {
    return parent_->encodeStringValue(value);
  }

  ThriftProxy::FilterStatus mapBegin(ThriftProxy::FieldType& key_type,
                                     ThriftProxy::FieldType& value_type, uint32_t& size) override {
    return parent_->encodeMapBegin(key_type, value_type, size);
  }

  ThriftProxy::FilterStatus mapEnd() override { return parent_->encodeMapEnd(); }

  ThriftProxy::FilterStatus listBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
    return parent_->encodeListBegin(elem_type, size);
  }

  ThriftProxy::FilterStatus listEnd() override { return parent_->encodeListEnd(); }

  ThriftProxy::FilterStatus setBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
    return parent_->encodeSetBegin(elem_type, size);
  }

  ThriftProxy::FilterStatus setEnd() override { return parent_->encodeSetEnd(); }

private:
  BidirectionalFilterSharedPtr parent_;
};

using DelegateEncoderFilterSharedPtr = std::shared_ptr<DelegateEncoderFilter>;

BidirectionalFilterWrapper::BidirectionalFilterWrapper(BidirectionalFilterSharedPtr filter)
    : decoder_filter_(std::make_shared<DelegateDecoderFilter>(filter)),
      encoder_filter_(std::make_shared<DelegateEncoderFilter>(filter)), parent_(filter) {}

} // namespace ThriftFilters
} // namespace ThriftProxy
} // namespace NetworkFilters
} // namespace Extensions
} // namespace Envoy

Coverage Report

Created: 2023-11-12 09:30

Line	Count	Source (jump to first uncovered line)
1		#include "source/extensions/filters/network/thrift_proxy/filter_utils.h"
2
3		namespace Envoy {
4		namespace Extensions {
5		namespace NetworkFilters {
6		namespace ThriftProxy {
7		namespace ThriftFilters {
8
9		class DelegateDecoderFilter final : public DecoderFilter {
10		public:
11	0	DelegateDecoderFilter(BidirectionalFilterSharedPtr filter) : parent_(filter){};
12		// ThriftBaseFilter
13	0	void onDestroy() override { throw EnvoyException(fmt::format("should not be called")); }
14
15	0	void setDecoderFilterCallbacks(DecoderFilterCallbacks& callbacks) override {
16	0	return parent_->setDecoderFilterCallbacks(callbacks);
17	0	};
18
19		// Thrift Decoder State Machine
20		ThriftProxy::FilterStatus
21	0	transportBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
22	0	return parent_->decodeTransportBegin(metadata);
23	0	}
24
25	0	ThriftProxy::FilterStatus transportEnd() override { return parent_->decodeTransportEnd(); }
26
27	0	bool passthroughSupported() const override { return parent_->decodePassthroughSupported(); }
28
29	0	ThriftProxy::FilterStatus passthroughData(Buffer::Instance& data) override {
30	0	return parent_->decodePassthroughData(data);
31	0	}
32
33	0	ThriftProxy::FilterStatus messageBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
34	0	return parent_->decodeMessageBegin(metadata);
35	0	}
36
37	0	ThriftProxy::FilterStatus messageEnd() override { return parent_->decodeMessageEnd(); }
38
39	0	ThriftProxy::FilterStatus structBegin(absl::string_view name) override {
40	0	return parent_->decodeStructBegin(name);
41	0	}
42
43	0	ThriftProxy::FilterStatus structEnd() override { return parent_->decodeStructEnd(); }
44
45		ThriftProxy::FilterStatus fieldBegin(absl::string_view name, ThriftProxy::FieldType& field_type,
46	0	int16_t& field_id) override {
47	0	return parent_->decodeFieldBegin(name, field_type, field_id);
48	0	}
49
50	0	ThriftProxy::FilterStatus fieldEnd() override { return parent_->decodeFieldEnd(); }
51
52	0	ThriftProxy::FilterStatus boolValue(bool& value) override {
53	0	return parent_->decodeBoolValue(value);
54	0	}
55
56	0	ThriftProxy::FilterStatus byteValue(uint8_t& value) override {
57	0	return parent_->decodeByteValue(value);
58	0	}
59
60	0	ThriftProxy::FilterStatus int16Value(int16_t& value) override {
61	0	return parent_->decodeInt16Value(value);
62	0	}
63
64	0	ThriftProxy::FilterStatus int32Value(int32_t& value) override {
65	0	return parent_->decodeInt32Value(value);
66	0	}
67
68	0	ThriftProxy::FilterStatus int64Value(int64_t& value) override {
69	0	return parent_->decodeInt64Value(value);
70	0	}
71
72	0	ThriftProxy::FilterStatus doubleValue(double& value) override {
73	0	return parent_->decodeDoubleValue(value);
74	0	}
75
76	0	ThriftProxy::FilterStatus stringValue(absl::string_view value) override {
77	0	return parent_->decodeStringValue(value);
78	0	}
79
80		ThriftProxy::FilterStatus mapBegin(ThriftProxy::FieldType& key_type,
81	0	ThriftProxy::FieldType& value_type, uint32_t& size) override {
82	0	return parent_->decodeMapBegin(key_type, value_type, size);
83	0	}
84
85	0	ThriftProxy::FilterStatus mapEnd() override { return parent_->decodeMapEnd(); }
86
87	0	ThriftProxy::FilterStatus listBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
88	0	return parent_->decodeListBegin(elem_type, size);
89	0	}
90
91	0	ThriftProxy::FilterStatus listEnd() override { return parent_->decodeListEnd(); }
92
93	0	ThriftProxy::FilterStatus setBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
94	0	return parent_->decodeSetBegin(elem_type, size);
95	0	}
96
97	0	ThriftProxy::FilterStatus setEnd() override { return parent_->decodeSetEnd(); }
98
99		private:
100		BidirectionalFilterSharedPtr parent_;
101		};
102
103		using DelegateDecoderFilterSharedPtr = std::shared_ptr<DelegateDecoderFilter>;
104
105		class DelegateEncoderFilter final : public EncoderFilter {
106		public:
107	0	DelegateEncoderFilter(BidirectionalFilterSharedPtr filter) : parent_(filter){};
108		// ThriftBaseFilter
109	0	void onDestroy() override { throw EnvoyException(fmt::format("should not be called")); }
110
111	0	void setEncoderFilterCallbacks(EncoderFilterCallbacks& callbacks) override {
112	0	return parent_->setEncoderFilterCallbacks(callbacks);
113	0	};
114
115		// Thrift Encoder State Machine
116		ThriftProxy::FilterStatus
117	0	transportBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
118	0	return parent_->encodeTransportBegin(metadata);
119	0	}
120
121	0	ThriftProxy::FilterStatus transportEnd() override { return parent_->encodeTransportEnd(); }
122
123	0	bool passthroughSupported() const override { return parent_->encodePassthroughSupported(); }
124
125	0	ThriftProxy::FilterStatus passthroughData(Buffer::Instance& data) override {
126	0	return parent_->encodePassthroughData(data);
127	0	}
128
129	0	ThriftProxy::FilterStatus messageBegin(ThriftProxy::MessageMetadataSharedPtr metadata) override {
130	0	return parent_->encodeMessageBegin(metadata);
131	0	}
132
133	0	ThriftProxy::FilterStatus messageEnd() override { return parent_->encodeMessageEnd(); }
134
135	0	ThriftProxy::FilterStatus structBegin(absl::string_view name) override {
136	0	return parent_->encodeStructBegin(name);
137	0	}
138
139	0	ThriftProxy::FilterStatus structEnd() override { return parent_->encodeStructEnd(); }
140
141		ThriftProxy::FilterStatus fieldBegin(absl::string_view name, ThriftProxy::FieldType& field_type,
142	0	int16_t& field_id) override {
143	0	return parent_->encodeFieldBegin(name, field_type, field_id);
144	0	}
145
146	0	ThriftProxy::FilterStatus fieldEnd() override { return parent_->encodeFieldEnd(); }
147
148	0	ThriftProxy::FilterStatus boolValue(bool& value) override {
149	0	return parent_->encodeBoolValue(value);
150	0	}
151
152	0	ThriftProxy::FilterStatus byteValue(uint8_t& value) override {
153	0	return parent_->encodeByteValue(value);
154	0	}
155
156	0	ThriftProxy::FilterStatus int16Value(int16_t& value) override {
157	0	return parent_->encodeInt16Value(value);
158	0	}
159
160	0	ThriftProxy::FilterStatus int32Value(int32_t& value) override {
161	0	return parent_->encodeInt32Value(value);
162	0	}
163
164	0	ThriftProxy::FilterStatus int64Value(int64_t& value) override {
165	0	return parent_->encodeInt64Value(value);
166	0	}
167
168	0	ThriftProxy::FilterStatus doubleValue(double& value) override {
169	0	return parent_->encodeDoubleValue(value);
170	0	}
171
172	0	ThriftProxy::FilterStatus stringValue(absl::string_view value) override {
173	0	return parent_->encodeStringValue(value);
174	0	}
175
176		ThriftProxy::FilterStatus mapBegin(ThriftProxy::FieldType& key_type,
177	0	ThriftProxy::FieldType& value_type, uint32_t& size) override {
178	0	return parent_->encodeMapBegin(key_type, value_type, size);
179	0	}
180
181	0	ThriftProxy::FilterStatus mapEnd() override { return parent_->encodeMapEnd(); }
182
183	0	ThriftProxy::FilterStatus listBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
184	0	return parent_->encodeListBegin(elem_type, size);
185	0	}
186
187	0	ThriftProxy::FilterStatus listEnd() override { return parent_->encodeListEnd(); }
188
189	0	ThriftProxy::FilterStatus setBegin(ThriftProxy::FieldType& elem_type, uint32_t& size) override {
190	0	return parent_->encodeSetBegin(elem_type, size);
191	0	}
192
193	0	ThriftProxy::FilterStatus setEnd() override { return parent_->encodeSetEnd(); }
194
195		private:
196		BidirectionalFilterSharedPtr parent_;
197		};
198
199		using DelegateEncoderFilterSharedPtr = std::shared_ptr<DelegateEncoderFilter>;
200
201		BidirectionalFilterWrapper::BidirectionalFilterWrapper(BidirectionalFilterSharedPtr filter)
202		: decoder_filter_(std::make_shared<DelegateDecoderFilter>(filter)),
203	0	encoder_filter_(std::make_shared<DelegateEncoderFilter>(filter)), parent_(filter) {}
204
205		} // namespace ThriftFilters
206		} // namespace ThriftProxy
207		} // namespace NetworkFilters
208		} // namespace Extensions
209		} // namespace Envoy