GRPC C++ 0.10.0.0

- Main Page
- Namespaces
- Data Structures
- Files

- File List
- Globals

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
54 class ServerBuilder {
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
69 void RegisterAsyncService(AsynchronousService* service);
70
71 // Register a generic service.
72 // Matches requests with any :authority
73 void RegisterAsyncGenericService(AsyncGenericService* service);
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
grpc::string
std::string string
Definition: config.h:112
grpc::ServerBuilder::ServerBuilder
ServerBuilder()
Definition: server_builder.cc:44
grpc::ServerBuilder::RegisterAsyncService
void RegisterAsyncService(AsynchronousService *service)
Definition: server_builder.cc:57
grpc::AsynchronousService
Definition: service_type.h:68
grpc::ServerBuilder::AddListeningPort
void AddListeningPort(const grpc::string &addr, std::shared_ptr< ServerCredentials > creds, int *selected_port=nullptr)
Definition: server_builder.cc:82
config.h
grpc::ServerBuilder::SetMaxMessageSize
void SetMaxMessageSize(int max_message_size)
Definition: server_builder.h:91
grpc::AsyncGenericService
Definition: async_generic_service.h:59
grpc::ThreadPoolInterface
Definition: thread_pool_interface.h:42
grpc::ServerBuilder::SetThreadPool
void SetThreadPool(ThreadPoolInterface *thread_pool)
Definition: server_builder.cc:89
grpc::SynchronousService
Definition: service_type.h:51
grpc::ServerBuilder::BuildAndStart
std::unique_ptr< Server > BuildAndStart()
Definition: server_builder.cc:93
grpc::ServerBuilder::AddCompletionQueue
std::unique_ptr< ServerCompletionQueue > AddCompletionQueue()
Definition: server_builder.cc:47
grpc::ServerBuilder::RegisterAsyncGenericService
void RegisterAsyncGenericService(AsyncGenericService *service)
Definition: server_builder.cc:71
grpc::ServerBuilder
Definition: server_builder.h:54
grpc::ServerBuilder::RegisterService
void RegisterService(SynchronousService *service)
Definition: server_builder.cc:53