1
#pragma once
2

            
3
#include "envoy/http/async_client.h"
4

            
5
namespace Envoy {
6
namespace Http {
7

            
8
/**
9
 * Sidestream watermark callback implementation for stream filter that either handles decoding only
10
 * or handles both encoding and decoding.
11
 */
12
class StreamFilterSidestreamWatermarkCallbacks : public Http::SidestreamWatermarkCallbacks {
13
public:
14
62064
  void onSidestreamAboveHighWatermark() final {
15
    // Sidestream push back downstream, if callback is configured.
16
62064
    if (decode_callback_ != nullptr) {
17
62064
      decode_callback_->onDecoderFilterAboveWriteBufferHighWatermark();
18
62064
    }
19

            
20
    // Sidestream push back upstream, if callback is configured.
21
62064
    if (encode_callback_ != nullptr) {
22
61998
      encode_callback_->onEncoderFilterAboveWriteBufferHighWatermark();
23
61998
    }
24
62064
  }
25

            
26
62064
  void onSidestreamBelowLowWatermark() final {
27
62064
    if (decode_callback_ != nullptr) {
28
62064
      decode_callback_->onDecoderFilterBelowWriteBufferLowWatermark();
29
62064
    }
30

            
31
62064
    if (encode_callback_ != nullptr) {
32
61998
      encode_callback_->onEncoderFilterBelowWriteBufferLowWatermark();
33
61998
    }
34
62064
  }
35

            
36
  void addDownstreamWatermarkCallbacks(Http::DownstreamWatermarkCallbacks&) final {}
37

            
38
  void removeDownstreamWatermarkCallbacks(Http::DownstreamWatermarkCallbacks&) final {}
39

            
40
  /**
41
   * The set function needs to be called by stream decoder filter before side stream connection is
42
   * established, to apply the backpressure to downstream when it is above watermark,
43
   */
44
96691
  void setDecoderFilterCallbacks(Http::StreamDecoderFilterCallbacks* decode_callback) {
45
96691
    decode_callback_ = decode_callback;
46
96691
  }
47

            
48
  /**
49
   * The set function needs to be called by stream encoder filter before side stream connection is
50
   * established, to apply the backpressure to upstream when it is above watermark,
51
   */
52
1235
  void setEncoderFilterCallbacks(Http::StreamEncoderFilterCallbacks* encode_callback) {
53
1235
    encode_callback_ = encode_callback;
54
1235
  }
55

            
56
private:
57
  // Non owning pointers; `removeWatermarkCallbacks()` needs to be called to unregister watermark
58
  // callbacks (if any) before filter callbacks are destroyed. Typically when stream is being closed
59
  // or filter is being destroyed.
60
  Http::StreamDecoderFilterCallbacks* decode_callback_ = nullptr;
61
  Http::StreamEncoderFilterCallbacks* encode_callback_ = nullptr;
62
};
63

            
64
} // namespace Http
65
} // namespace Envoy