1 /*
2  * Copyright (c) Facebook, Inc. and its affiliates.
3  * All rights reserved.
4  *
5  * This source code is licensed under the BSD-style license found in the
6  * LICENSE file in the root directory of this source tree.
7  */
8 
9 #pragma once
10 
11 #include <proxygen/httpserver/RequestHandler.h>
12 #include <proxygen/httpserver/ResponseHandler.h>
13 
14 namespace proxygen {
15 
16 /**
17  * Filters are a way to add functionality to HTTPServer without complicating app
18  * specific RequestHandler. The basic idea is
19  *
20  *   App-handler <=> Filter-1 <=> Filter-2 <=> Client
21  *
22  * The data flows through these filters between client and handler.  They can do
23  * things like modify the data flowing through them, can update stats, create
24  * traces and even send direct response if they feel like.
25  *
26  * The default implementation just lets everything pass through.
27  */
28 class Filter
29     : public RequestHandler
30     , public ResponseHandler {
31  public:
Filter(RequestHandler * upstream)32   explicit Filter(RequestHandler* upstream) : ResponseHandler(upstream) {
33   }
34 
35   // Request handler
setResponseHandler(ResponseHandler * handler)36   void setResponseHandler(ResponseHandler* handler) noexcept override {
37     // Save downstream handler and pass ourselves as downstream handler
38     downstream_ = handler;
39     txn_ = handler->getTransaction();
40     upstream_->setResponseHandler(this);
41   }
42 
onRequest(std::unique_ptr<HTTPMessage> headers)43   void onRequest(std::unique_ptr<HTTPMessage> headers) noexcept override {
44     upstream_->onRequest(std::move(headers));
45   }
46 
onBody(std::unique_ptr<folly::IOBuf> body)47   void onBody(std::unique_ptr<folly::IOBuf> body) noexcept override {
48     upstream_->onBody(std::move(body));
49   }
50 
onUpgrade(UpgradeProtocol protocol)51   void onUpgrade(UpgradeProtocol protocol) noexcept override {
52     upstream_->onUpgrade(protocol);
53   }
54 
onEOM()55   void onEOM() noexcept override {
56     upstream_->onEOM();
57   }
58 
requestComplete()59   void requestComplete() noexcept override {
60     downstream_ = nullptr;
61     upstream_->requestComplete();
62     delete this;
63   }
64 
onError(ProxygenError err)65   void onError(ProxygenError err) noexcept override {
66     downstream_ = nullptr;
67     upstream_->onError(err);
68     delete this;
69   }
70 
onGoaway(ErrorCode code)71   void onGoaway(ErrorCode code) noexcept override {
72     upstream_->onGoaway(code);
73   }
74 
onEgressPaused()75   void onEgressPaused() noexcept override {
76     upstream_->onEgressPaused();
77   }
78 
onEgressResumed()79   void onEgressResumed() noexcept override {
80     upstream_->onEgressResumed();
81   }
82 
canHandleExpect()83   bool canHandleExpect() noexcept override {
84     return upstream_->canHandleExpect();
85   }
86 
getExHandler()87   ExMessageHandler* getExHandler() noexcept override {
88     return upstream_->getExHandler();
89   }
90 
91   // Response handler
sendHeaders(HTTPMessage & msg)92   void sendHeaders(HTTPMessage& msg) noexcept override {
93     downstream_->sendHeaders(msg);
94   }
95 
sendChunkHeader(size_t len)96   void sendChunkHeader(size_t len) noexcept override {
97     downstream_->sendChunkHeader(len);
98   }
99 
sendBody(std::unique_ptr<folly::IOBuf> body)100   void sendBody(std::unique_ptr<folly::IOBuf> body) noexcept override {
101     downstream_->sendBody(std::move(body));
102   }
103 
sendChunkTerminator()104   void sendChunkTerminator() noexcept override {
105     downstream_->sendChunkTerminator();
106   }
107 
sendEOM()108   void sendEOM() noexcept override {
109     downstream_->sendEOM();
110   }
111 
sendAbort()112   void sendAbort() noexcept override {
113     downstream_->sendAbort();
114   }
115 
refreshTimeout()116   void refreshTimeout() noexcept override {
117     downstream_->refreshTimeout();
118   }
119 
pauseIngress()120   void pauseIngress() noexcept override {
121     downstream_->pauseIngress();
122   }
123 
resumeIngress()124   void resumeIngress() noexcept override {
125     downstream_->resumeIngress();
126   }
127 
newPushedResponse(PushHandler * handler)128   folly::Expected<ResponseHandler*, ProxygenError> newPushedResponse(
129       PushHandler* handler) noexcept override {
130     return downstream_->newPushedResponse(handler);
131   }
132 
newExMessage(ExMessageHandler * exHandler,bool unidirectional)133   ResponseHandler* newExMessage(ExMessageHandler* exHandler,
134                                 bool unidirectional) noexcept override {
135     return downstream_->newExMessage(exHandler, unidirectional);
136   }
137 
getSetupTransportInfo()138   const wangle::TransportInfo& getSetupTransportInfo() const noexcept override {
139     return downstream_->getSetupTransportInfo();
140   }
141 
getCurrentTransportInfo(wangle::TransportInfo * tinfo)142   void getCurrentTransportInfo(wangle::TransportInfo* tinfo) const override {
143     downstream_->getCurrentTransportInfo(tinfo);
144   }
145 };
146 
147 } // namespace proxygen
148