]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
1 | /* |
2 | * Licensed to the Apache Software Foundation (ASF) under one | |
3 | * or more contributor license agreements. See the NOTICE file | |
4 | * distributed with this work for additional information | |
5 | * regarding copyright ownership. The ASF licenses this file | |
6 | * to you under the Apache License, Version 2.0 (the | |
7 | * "License"); you may not use this file except in compliance | |
8 | * with the License. You may obtain a copy of the License at | |
9 | * | |
10 | * http://www.apache.org/licenses/LICENSE-2.0 | |
11 | * | |
12 | * Unless required by applicable law or agreed to in writing, | |
13 | * software distributed under the License is distributed on an | |
14 | * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
15 | * KIND, either express or implied. See the License for the | |
16 | * specific language governing permissions and limitations | |
17 | * under the License. | |
18 | */ | |
19 | ||
20 | #ifndef _THRIFT_SERVER_TSERVER_H_ | |
21 | #define _THRIFT_SERVER_TSERVER_H_ 1 | |
22 | ||
23 | #include <thrift/TProcessor.h> | |
24 | #include <thrift/transport/TServerTransport.h> | |
25 | #include <thrift/protocol/TBinaryProtocol.h> | |
26 | #include <thrift/concurrency/Thread.h> | |
27 | ||
28 | #include <memory> | |
29 | ||
30 | namespace apache { | |
31 | namespace thrift { | |
32 | namespace server { | |
33 | ||
34 | using apache::thrift::TProcessor; | |
35 | using apache::thrift::protocol::TBinaryProtocolFactory; | |
36 | using apache::thrift::protocol::TProtocol; | |
37 | using apache::thrift::protocol::TProtocolFactory; | |
38 | using apache::thrift::transport::TServerTransport; | |
39 | using apache::thrift::transport::TTransport; | |
40 | using apache::thrift::transport::TTransportFactory; | |
41 | ||
42 | /** | |
43 | * Virtual interface class that can handle events from the server core. To | |
44 | * use this you should subclass it and implement the methods that you care | |
45 | * about. Your subclass can also store local data that you may care about, | |
46 | * such as additional "arguments" to these methods (stored in the object | |
47 | * instance's state). | |
48 | */ | |
49 | class TServerEventHandler { | |
50 | public: | |
51 | virtual ~TServerEventHandler() = default; | |
52 | ||
53 | /** | |
54 | * Called before the server begins. | |
55 | */ | |
56 | virtual void preServe() {} | |
57 | ||
58 | /** | |
59 | * Called when a new client has connected and is about to being processing. | |
60 | */ | |
61 | virtual void* createContext(std::shared_ptr<TProtocol> input, | |
62 | std::shared_ptr<TProtocol> output) { | |
63 | (void)input; | |
64 | (void)output; | |
65 | return nullptr; | |
66 | } | |
67 | ||
68 | /** | |
69 | * Called when a client has finished request-handling to delete server | |
70 | * context. | |
71 | */ | |
72 | virtual void deleteContext(void* serverContext, | |
73 | std::shared_ptr<TProtocol> input, | |
74 | std::shared_ptr<TProtocol> output) { | |
75 | (void)serverContext; | |
76 | (void)input; | |
77 | (void)output; | |
78 | } | |
79 | ||
80 | /** | |
81 | * Called when a client is about to call the processor. | |
82 | */ | |
83 | virtual void processContext(void* serverContext, std::shared_ptr<TTransport> transport) { | |
84 | (void)serverContext; | |
85 | (void)transport; | |
86 | } | |
87 | ||
88 | protected: | |
89 | /** | |
90 | * Prevent direct instantiation. | |
91 | */ | |
92 | TServerEventHandler() = default; | |
93 | }; | |
94 | ||
95 | /** | |
96 | * Thrift server. | |
97 | * | |
98 | */ | |
99 | class TServer : public concurrency::Runnable { | |
100 | public: | |
101 | ~TServer() override = default; | |
102 | ||
103 | virtual void serve() = 0; | |
104 | ||
105 | virtual void stop() {} | |
106 | ||
107 | // Allows running the server as a Runnable thread | |
108 | void run() override { serve(); } | |
109 | ||
110 | std::shared_ptr<TProcessorFactory> getProcessorFactory() { return processorFactory_; } | |
111 | ||
112 | std::shared_ptr<TServerTransport> getServerTransport() { return serverTransport_; } | |
113 | ||
114 | std::shared_ptr<TTransportFactory> getInputTransportFactory() { return inputTransportFactory_; } | |
115 | ||
116 | std::shared_ptr<TTransportFactory> getOutputTransportFactory() { | |
117 | return outputTransportFactory_; | |
118 | } | |
119 | ||
120 | std::shared_ptr<TProtocolFactory> getInputProtocolFactory() { return inputProtocolFactory_; } | |
121 | ||
122 | std::shared_ptr<TProtocolFactory> getOutputProtocolFactory() { return outputProtocolFactory_; } | |
123 | ||
124 | std::shared_ptr<TServerEventHandler> getEventHandler() { return eventHandler_; } | |
125 | ||
126 | protected: | |
127 | TServer(const std::shared_ptr<TProcessorFactory>& processorFactory) | |
128 | : processorFactory_(processorFactory) { | |
129 | setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
130 | setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
131 | setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
132 | setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
133 | } | |
134 | ||
135 | TServer(const std::shared_ptr<TProcessor>& processor) | |
136 | : processorFactory_(new TSingletonProcessorFactory(processor)) { | |
137 | setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
138 | setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
139 | setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
140 | setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
141 | } | |
142 | ||
143 | TServer(const std::shared_ptr<TProcessorFactory>& processorFactory, | |
144 | const std::shared_ptr<TServerTransport>& serverTransport) | |
145 | : processorFactory_(processorFactory), serverTransport_(serverTransport) { | |
146 | setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
147 | setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
148 | setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
149 | setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
150 | } | |
151 | ||
152 | TServer(const std::shared_ptr<TProcessor>& processor, | |
153 | const std::shared_ptr<TServerTransport>& serverTransport) | |
154 | : processorFactory_(new TSingletonProcessorFactory(processor)), | |
155 | serverTransport_(serverTransport) { | |
156 | setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
157 | setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory())); | |
158 | setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
159 | setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory())); | |
160 | } | |
161 | ||
162 | TServer(const std::shared_ptr<TProcessorFactory>& processorFactory, | |
163 | const std::shared_ptr<TServerTransport>& serverTransport, | |
164 | const std::shared_ptr<TTransportFactory>& transportFactory, | |
165 | const std::shared_ptr<TProtocolFactory>& protocolFactory) | |
166 | : processorFactory_(processorFactory), | |
167 | serverTransport_(serverTransport), | |
168 | inputTransportFactory_(transportFactory), | |
169 | outputTransportFactory_(transportFactory), | |
170 | inputProtocolFactory_(protocolFactory), | |
171 | outputProtocolFactory_(protocolFactory) {} | |
172 | ||
173 | TServer(const std::shared_ptr<TProcessor>& processor, | |
174 | const std::shared_ptr<TServerTransport>& serverTransport, | |
175 | const std::shared_ptr<TTransportFactory>& transportFactory, | |
176 | const std::shared_ptr<TProtocolFactory>& protocolFactory) | |
177 | : processorFactory_(new TSingletonProcessorFactory(processor)), | |
178 | serverTransport_(serverTransport), | |
179 | inputTransportFactory_(transportFactory), | |
180 | outputTransportFactory_(transportFactory), | |
181 | inputProtocolFactory_(protocolFactory), | |
182 | outputProtocolFactory_(protocolFactory) {} | |
183 | ||
184 | TServer(const std::shared_ptr<TProcessorFactory>& processorFactory, | |
185 | const std::shared_ptr<TServerTransport>& serverTransport, | |
186 | const std::shared_ptr<TTransportFactory>& inputTransportFactory, | |
187 | const std::shared_ptr<TTransportFactory>& outputTransportFactory, | |
188 | const std::shared_ptr<TProtocolFactory>& inputProtocolFactory, | |
189 | const std::shared_ptr<TProtocolFactory>& outputProtocolFactory) | |
190 | : processorFactory_(processorFactory), | |
191 | serverTransport_(serverTransport), | |
192 | inputTransportFactory_(inputTransportFactory), | |
193 | outputTransportFactory_(outputTransportFactory), | |
194 | inputProtocolFactory_(inputProtocolFactory), | |
195 | outputProtocolFactory_(outputProtocolFactory) {} | |
196 | ||
197 | TServer(const std::shared_ptr<TProcessor>& processor, | |
198 | const std::shared_ptr<TServerTransport>& serverTransport, | |
199 | const std::shared_ptr<TTransportFactory>& inputTransportFactory, | |
200 | const std::shared_ptr<TTransportFactory>& outputTransportFactory, | |
201 | const std::shared_ptr<TProtocolFactory>& inputProtocolFactory, | |
202 | const std::shared_ptr<TProtocolFactory>& outputProtocolFactory) | |
203 | : processorFactory_(new TSingletonProcessorFactory(processor)), | |
204 | serverTransport_(serverTransport), | |
205 | inputTransportFactory_(inputTransportFactory), | |
206 | outputTransportFactory_(outputTransportFactory), | |
207 | inputProtocolFactory_(inputProtocolFactory), | |
208 | outputProtocolFactory_(outputProtocolFactory) {} | |
209 | ||
210 | /** | |
211 | * Get a TProcessor to handle calls on a particular connection. | |
212 | * | |
213 | * This method should only be called once per connection (never once per | |
214 | * call). This allows the TProcessorFactory to return a different processor | |
215 | * for each connection if it desires. | |
216 | */ | |
217 | std::shared_ptr<TProcessor> getProcessor(std::shared_ptr<TProtocol> inputProtocol, | |
218 | std::shared_ptr<TProtocol> outputProtocol, | |
219 | std::shared_ptr<TTransport> transport) { | |
220 | TConnectionInfo connInfo; | |
221 | connInfo.input = inputProtocol; | |
222 | connInfo.output = outputProtocol; | |
223 | connInfo.transport = transport; | |
224 | return processorFactory_->getProcessor(connInfo); | |
225 | } | |
226 | ||
227 | // Class variables | |
228 | std::shared_ptr<TProcessorFactory> processorFactory_; | |
229 | std::shared_ptr<TServerTransport> serverTransport_; | |
230 | ||
231 | std::shared_ptr<TTransportFactory> inputTransportFactory_; | |
232 | std::shared_ptr<TTransportFactory> outputTransportFactory_; | |
233 | ||
234 | std::shared_ptr<TProtocolFactory> inputProtocolFactory_; | |
235 | std::shared_ptr<TProtocolFactory> outputProtocolFactory_; | |
236 | ||
237 | std::shared_ptr<TServerEventHandler> eventHandler_; | |
238 | ||
239 | public: | |
240 | void setInputTransportFactory(std::shared_ptr<TTransportFactory> inputTransportFactory) { | |
241 | inputTransportFactory_ = inputTransportFactory; | |
242 | } | |
243 | ||
244 | void setOutputTransportFactory(std::shared_ptr<TTransportFactory> outputTransportFactory) { | |
245 | outputTransportFactory_ = outputTransportFactory; | |
246 | } | |
247 | ||
248 | void setInputProtocolFactory(std::shared_ptr<TProtocolFactory> inputProtocolFactory) { | |
249 | inputProtocolFactory_ = inputProtocolFactory; | |
250 | } | |
251 | ||
252 | void setOutputProtocolFactory(std::shared_ptr<TProtocolFactory> outputProtocolFactory) { | |
253 | outputProtocolFactory_ = outputProtocolFactory; | |
254 | } | |
255 | ||
256 | void setServerEventHandler(std::shared_ptr<TServerEventHandler> eventHandler) { | |
257 | eventHandler_ = eventHandler; | |
258 | } | |
259 | }; | |
260 | ||
261 | /** | |
262 | * Helper function to increase the max file descriptors limit | |
263 | * for the current process and all of its children. | |
264 | * By default, tries to increase it to as much as 2^24. | |
265 | */ | |
266 | #ifdef HAVE_SYS_RESOURCE_H | |
267 | int increase_max_fds(int max_fds = (1 << 24)); | |
268 | #endif | |
269 | } | |
270 | } | |
271 | } // apache::thrift::server | |
272 | ||
273 | #endif // #ifndef _THRIFT_SERVER_TSERVER_H_ |