thrift/server/TServer.h

0001 /*
0002  * Licensed to the Apache Software Foundation (ASF) under one
0003  * or more contributor license agreements. See the NOTICE file
0004  * distributed with this work for additional information
0005  * regarding copyright ownership. The ASF licenses this file
0006  * to you under the Apache License, Version 2.0 (the
0007  * "License"); you may not use this file except in compliance
0008  * with the License. You may obtain a copy of the License at
0009  *
0010  *   http://www.apache.org/licenses/LICENSE-2.0
0011  *
0012  * Unless required by applicable law or agreed to in writing,
0013  * software distributed under the License is distributed on an
0014  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
0015  * KIND, either express or implied. See the License for the
0016  * specific language governing permissions and limitations
0017  * under the License.
0018  */
0019
0020 #ifndef _THRIFT_SERVER_TSERVER_H_
0021 #define _THRIFT_SERVER_TSERVER_H_ 1
0022
0023 #include <thrift/TProcessor.h>
0024 #include <thrift/transport/TServerTransport.h>
0025 #include <thrift/protocol/TBinaryProtocol.h>
0026 #include <thrift/concurrency/Thread.h>
0027
0028 #include <memory>
0029
0030 namespace apache {
0031 namespace thrift {
0032 namespace server {
0033
0034 using apache::thrift::TProcessor;
0035 using apache::thrift::protocol::TBinaryProtocolFactory;
0036 using apache::thrift::protocol::TProtocol;
0037 using apache::thrift::protocol::TProtocolFactory;
0038 using apache::thrift::transport::TServerTransport;
0039 using apache::thrift::transport::TTransport;
0040 using apache::thrift::transport::TTransportFactory;
0041
0042 /**
0043  * Virtual interface class that can handle events from the server core. To
0044  * use this you should subclass it and implement the methods that you care
0045  * about. Your subclass can also store local data that you may care about,
0046  * such as additional "arguments" to these methods (stored in the object
0047  * instance's state).
0048  */
0049 class TServerEventHandler {
0050 public:
0051   virtual ~TServerEventHandler() = default;
0052
0053   /**
0054    * Called before the server begins.
0055    */
0056   virtual void preServe() {}
0057
0058   /**
0059    * Called when a new client has connected and is about to being processing.
0060    */
0061   virtual void* createContext(std::shared_ptr<TProtocol> input,
0062                               std::shared_ptr<TProtocol> output) {
0063     (void)input;
0064     (void)output;
0065     return nullptr;
0066   }
0067
0068   /**
0069    * Called when a client has finished request-handling to delete server
0070    * context.
0071    */
0072   virtual void deleteContext(void* serverContext,
0073                              std::shared_ptr<TProtocol> input,
0074                              std::shared_ptr<TProtocol> output) {
0075     (void)serverContext;
0076     (void)input;
0077     (void)output;
0078   }
0079
0080   /**
0081    * Called when a client is about to call the processor.
0082    */
0083   virtual void processContext(void* serverContext, std::shared_ptr<TTransport> transport) {
0084     (void)serverContext;
0085     (void)transport;
0086   }
0087
0088 protected:
0089   /**
0090    * Prevent direct instantiation.
0091    */
0092   TServerEventHandler() = default;
0093 };
0094
0095 /**
0096  * Thrift server.
0097  *
0098  */
0099 class TServer : public concurrency::Runnable {
0100 public:
0101   ~TServer() override = default;
0102
0103   virtual void serve() = 0;
0104
0105   virtual void stop() {}
0106
0107   // Allows running the server as a Runnable thread
0108   void run() override { serve(); }
0109
0110   std::shared_ptr<TProcessorFactory> getProcessorFactory() { return processorFactory_; }
0111
0112   std::shared_ptr<TServerTransport> getServerTransport() { return serverTransport_; }
0113
0114   std::shared_ptr<TTransportFactory> getInputTransportFactory() { return inputTransportFactory_; }
0115
0116   std::shared_ptr<TTransportFactory> getOutputTransportFactory() {
0117     return outputTransportFactory_;
0118   }
0119
0120   std::shared_ptr<TProtocolFactory> getInputProtocolFactory() { return inputProtocolFactory_; }
0121
0122   std::shared_ptr<TProtocolFactory> getOutputProtocolFactory() { return outputProtocolFactory_; }
0123
0124   std::shared_ptr<TServerEventHandler> getEventHandler() { return eventHandler_; }
0125
0126 protected:
0127   TServer(const std::shared_ptr<TProcessorFactory>& processorFactory)
0128     : processorFactory_(processorFactory) {
0129     setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0130     setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0131     setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0132     setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0133   }
0134
0135   TServer(const std::shared_ptr<TProcessor>& processor)
0136     : processorFactory_(new TSingletonProcessorFactory(processor)) {
0137     setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0138     setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0139     setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0140     setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0141   }
0142
0143   TServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
0144           const std::shared_ptr<TServerTransport>& serverTransport)
0145     : processorFactory_(processorFactory), serverTransport_(serverTransport) {
0146     setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0147     setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0148     setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0149     setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0150   }
0151
0152   TServer(const std::shared_ptr<TProcessor>& processor,
0153           const std::shared_ptr<TServerTransport>& serverTransport)
0154     : processorFactory_(new TSingletonProcessorFactory(processor)),
0155       serverTransport_(serverTransport) {
0156     setInputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0157     setOutputTransportFactory(std::shared_ptr<TTransportFactory>(new TTransportFactory()));
0158     setInputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0159     setOutputProtocolFactory(std::shared_ptr<TProtocolFactory>(new TBinaryProtocolFactory()));
0160   }
0161
0162   TServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
0163           const std::shared_ptr<TServerTransport>& serverTransport,
0164           const std::shared_ptr<TTransportFactory>& transportFactory,
0165           const std::shared_ptr<TProtocolFactory>& protocolFactory)
0166     : processorFactory_(processorFactory),
0167       serverTransport_(serverTransport),
0168       inputTransportFactory_(transportFactory),
0169       outputTransportFactory_(transportFactory),
0170       inputProtocolFactory_(protocolFactory),
0171       outputProtocolFactory_(protocolFactory) {}
0172
0173   TServer(const std::shared_ptr<TProcessor>& processor,
0174           const std::shared_ptr<TServerTransport>& serverTransport,
0175           const std::shared_ptr<TTransportFactory>& transportFactory,
0176           const std::shared_ptr<TProtocolFactory>& protocolFactory)
0177     : processorFactory_(new TSingletonProcessorFactory(processor)),
0178       serverTransport_(serverTransport),
0179       inputTransportFactory_(transportFactory),
0180       outputTransportFactory_(transportFactory),
0181       inputProtocolFactory_(protocolFactory),
0182       outputProtocolFactory_(protocolFactory) {}
0183
0184   TServer(const std::shared_ptr<TProcessorFactory>& processorFactory,
0185           const std::shared_ptr<TServerTransport>& serverTransport,
0186           const std::shared_ptr<TTransportFactory>& inputTransportFactory,
0187           const std::shared_ptr<TTransportFactory>& outputTransportFactory,
0188           const std::shared_ptr<TProtocolFactory>& inputProtocolFactory,
0189           const std::shared_ptr<TProtocolFactory>& outputProtocolFactory)
0190     : processorFactory_(processorFactory),
0191       serverTransport_(serverTransport),
0192       inputTransportFactory_(inputTransportFactory),
0193       outputTransportFactory_(outputTransportFactory),
0194       inputProtocolFactory_(inputProtocolFactory),
0195       outputProtocolFactory_(outputProtocolFactory) {}
0196
0197   TServer(const std::shared_ptr<TProcessor>& processor,
0198           const std::shared_ptr<TServerTransport>& serverTransport,
0199           const std::shared_ptr<TTransportFactory>& inputTransportFactory,
0200           const std::shared_ptr<TTransportFactory>& outputTransportFactory,
0201           const std::shared_ptr<TProtocolFactory>& inputProtocolFactory,
0202           const std::shared_ptr<TProtocolFactory>& outputProtocolFactory)
0203     : processorFactory_(new TSingletonProcessorFactory(processor)),
0204       serverTransport_(serverTransport),
0205       inputTransportFactory_(inputTransportFactory),
0206       outputTransportFactory_(outputTransportFactory),
0207       inputProtocolFactory_(inputProtocolFactory),
0208       outputProtocolFactory_(outputProtocolFactory) {}
0209
0210   /**
0211    * Get a TProcessor to handle calls on a particular connection.
0212    *
0213    * This method should only be called once per connection (never once per
0214    * call).  This allows the TProcessorFactory to return a different processor
0215    * for each connection if it desires.
0216    */
0217   std::shared_ptr<TProcessor> getProcessor(std::shared_ptr<TProtocol> inputProtocol,
0218                                              std::shared_ptr<TProtocol> outputProtocol,
0219                                              std::shared_ptr<TTransport> transport) {
0220     TConnectionInfo connInfo;
0221     connInfo.input = inputProtocol;
0222     connInfo.output = outputProtocol;
0223     connInfo.transport = transport;
0224     return processorFactory_->getProcessor(connInfo);
0225   }
0226
0227   // Class variables
0228   std::shared_ptr<TProcessorFactory> processorFactory_;
0229   std::shared_ptr<TServerTransport> serverTransport_;
0230
0231   std::shared_ptr<TTransportFactory> inputTransportFactory_;
0232   std::shared_ptr<TTransportFactory> outputTransportFactory_;
0233
0234   std::shared_ptr<TProtocolFactory> inputProtocolFactory_;
0235   std::shared_ptr<TProtocolFactory> outputProtocolFactory_;
0236
0237   std::shared_ptr<TServerEventHandler> eventHandler_;
0238
0239 public:
0240   void setInputTransportFactory(std::shared_ptr<TTransportFactory> inputTransportFactory) {
0241     inputTransportFactory_ = inputTransportFactory;
0242   }
0243
0244   void setOutputTransportFactory(std::shared_ptr<TTransportFactory> outputTransportFactory) {
0245     outputTransportFactory_ = outputTransportFactory;
0246   }
0247
0248   void setInputProtocolFactory(std::shared_ptr<TProtocolFactory> inputProtocolFactory) {
0249     inputProtocolFactory_ = inputProtocolFactory;
0250   }
0251
0252   void setOutputProtocolFactory(std::shared_ptr<TProtocolFactory> outputProtocolFactory) {
0253     outputProtocolFactory_ = outputProtocolFactory;
0254   }
0255
0256   void setServerEventHandler(std::shared_ptr<TServerEventHandler> eventHandler) {
0257     eventHandler_ = eventHandler;
0258   }
0259 };
0260
0261 /**
0262  * Helper function to increase the max file descriptors limit
0263  * for the current process and all of its children.
0264  * By default, tries to increase it to as much as 2^24.
0265  */
0266 #ifdef HAVE_SYS_RESOURCE_H
0267 int increase_max_fds(int max_fds = (1 << 24));
0268 #endif
0269 }
0270 }
0271 } // apache::thrift::server
0272
0273 #endif // #ifndef _THRIFT_SERVER_TSERVER_H_