GRPC C++  0.10.0.0
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
server_builder.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015, Google Inc.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are
8  * met:
9  *
10  * * Redistributions of source code must retain the above copyright
11  * notice, this list of conditions and the following disclaimer.
12  * * Redistributions in binary form must reproduce the above
13  * copyright notice, this list of conditions and the following disclaimer
14  * in the documentation and/or other materials provided with the
15  * distribution.
16  * * Neither the name of Google Inc. nor the names of its
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  */
33 
34 #ifndef GRPCXX_SERVER_BUILDER_H
35 #define GRPCXX_SERVER_BUILDER_H
36 
37 #include <memory>
38 #include <vector>
39 
40 #include <grpc++/config.h>
41 
42 namespace grpc {
43 
44 class AsyncGenericService;
45 class AsynchronousService;
46 class CompletionQueue;
47 class RpcService;
48 class Server;
49 class ServerCompletionQueue;
50 class ServerCredentials;
51 class SynchronousService;
52 class ThreadPoolInterface;
53 
55  public:
56  ServerBuilder();
57 
58  // Register a service. This call does not take ownership of the service.
59  // The service must exist for the lifetime of the Server instance returned by
60  // BuildAndStart().
61  // Matches requests with any :authority
62  void RegisterService(SynchronousService* service);
63 
64  // Register an asynchronous service.
65  // This call does not take ownership of the service or completion queue.
66  // The service and completion queuemust exist for the lifetime of the Server
67  // instance returned by BuildAndStart().
68  // Matches requests with any :authority
70 
71  // Register a generic service.
72  // Matches requests with any :authority
74 
75  // Register a service. This call does not take ownership of the service.
76  // The service must exist for the lifetime of the Server instance returned by
77  // BuildAndStart().
78  // Only matches requests with :authority \a host
79  void RegisterService(const grpc::string& host,
80  SynchronousService* service);
81 
82  // Register an asynchronous service.
83  // This call does not take ownership of the service or completion queue.
84  // The service and completion queuemust exist for the lifetime of the Server
85  // instance returned by BuildAndStart().
86  // Only matches requests with :authority \a host
87  void RegisterAsyncService(const grpc::string& host,
88  AsynchronousService* service);
89 
90  // Set max message size in bytes.
91  void SetMaxMessageSize(int max_message_size) {
92  max_message_size_ = max_message_size;
93  }
94 
95  // Add a listening port. Can be called multiple times.
96  void AddListeningPort(const grpc::string& addr,
97  std::shared_ptr<ServerCredentials> creds,
98  int* selected_port = nullptr);
99 
100  // Set the thread pool used for running appliation rpc handlers.
101  // Does not take ownership.
102  void SetThreadPool(ThreadPoolInterface* thread_pool);
103 
104  // Add a completion queue for handling asynchronous services
105  // Caller is required to keep this completion queue live until calling
106  // BuildAndStart()
107  std::unique_ptr<ServerCompletionQueue> AddCompletionQueue();
108 
109  // Return a running server which is ready for processing rpcs.
110  std::unique_ptr<Server> BuildAndStart();
111 
112  private:
113  struct Port {
114  grpc::string addr;
115  std::shared_ptr<ServerCredentials> creds;
116  int* selected_port;
117  };
118 
119  typedef std::unique_ptr<grpc::string> HostString;
120  template <class T> struct NamedService {
121  explicit NamedService(T* s) : service(s) {}
122  NamedService(const grpc::string& h, T *s)
123  : host(new grpc::string(h)), service(s) {}
124  HostString host;
125  T* service;
126  };
127 
128  int max_message_size_;
129  std::vector<std::unique_ptr<NamedService<RpcService>>> services_;
130  std::vector<std::unique_ptr<NamedService<AsynchronousService>>> async_services_;
131  std::vector<Port> ports_;
132  std::vector<ServerCompletionQueue*> cqs_;
133  std::shared_ptr<ServerCredentials> creds_;
134  AsyncGenericService* generic_service_;
135  ThreadPoolInterface* thread_pool_;
136 };
137 
138 } // namespace grpc
139 
140 #endif // GRPCXX_SERVER_BUILDER_H
std::string string
Definition: config.h:112
ServerBuilder()
Definition: server_builder.cc:44
void RegisterAsyncService(AsynchronousService *service)
Definition: server_builder.cc:57
Definition: service_type.h:68
void AddListeningPort(const grpc::string &addr, std::shared_ptr< ServerCredentials > creds, int *selected_port=nullptr)
Definition: server_builder.cc:82
void SetMaxMessageSize(int max_message_size)
Definition: server_builder.h:91
Definition: async_generic_service.h:59
Definition: thread_pool_interface.h:42
void SetThreadPool(ThreadPoolInterface *thread_pool)
Definition: server_builder.cc:89
Definition: service_type.h:51
std::unique_ptr< Server > BuildAndStart()
Definition: server_builder.cc:93
std::unique_ptr< ServerCompletionQueue > AddCompletionQueue()
Definition: server_builder.cc:47
void RegisterAsyncGenericService(AsyncGenericService *service)
Definition: server_builder.cc:71
Definition: server_builder.h:54
void RegisterService(SynchronousService *service)
Definition: server_builder.cc:53