Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2015-2016 gRPC authors. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 4 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 8 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 10 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
| 19 | #include <grpc++/server_builder.h> |
| 20 | |
Craig Tiller | 14a65f9 | 2015-02-09 13:13:14 -0800 | [diff] [blame] | 21 | #include <grpc++/impl/service_type.h> |
Craig Tiller | afcc875 | 2016-10-18 16:10:06 -0700 | [diff] [blame] | 22 | #include <grpc++/resource_quota.h> |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 23 | #include <grpc++/server.h> |
Craig Tiller | f40df23 | 2016-03-25 13:38:14 -0700 | [diff] [blame] | 24 | #include <grpc/support/cpu.h> |
| 25 | #include <grpc/support/log.h> |
David Garcia Quintas | 468e16d | 2016-08-31 13:29:40 +0200 | [diff] [blame] | 26 | #include <grpc/support/useful.h> |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 27 | |
Vijay Pai | e8a7e30 | 2015-08-24 10:52:33 -0700 | [diff] [blame] | 28 | #include "src/cpp/server/thread_pool_interface.h" |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 29 | |
| 30 | namespace grpc { |
| 31 | |
Yuchen Zeng | 7d099a5 | 2016-05-06 13:21:36 -0700 | [diff] [blame] | 32 | static std::vector<std::unique_ptr<ServerBuilderPlugin> (*)()>* |
| 33 | g_plugin_factory_list; |
Yuchen Zeng | 3b8f335 | 2016-05-03 12:18:13 -0700 | [diff] [blame] | 34 | static gpr_once once_init_plugin_list = GPR_ONCE_INIT; |
| 35 | |
| 36 | static void do_plugin_list_init(void) { |
Yuchen Zeng | 7d099a5 | 2016-05-06 13:21:36 -0700 | [diff] [blame] | 37 | g_plugin_factory_list = |
| 38 | new std::vector<std::unique_ptr<ServerBuilderPlugin> (*)()>(); |
Yuchen Zeng | 3b8f335 | 2016-05-03 12:18:13 -0700 | [diff] [blame] | 39 | } |
| 40 | |
Yang Gao | 5f4539f | 2015-03-06 16:11:16 -0800 | [diff] [blame] | 41 | ServerBuilder::ServerBuilder() |
Mark D. Roth | 6980362 | 2016-09-06 08:15:36 -0700 | [diff] [blame] | 42 | : max_receive_message_size_(-1), |
| 43 | max_send_message_size_(-1), |
Sree Kuchibhotla | 9676619 | 2016-10-13 12:42:54 -0700 | [diff] [blame] | 44 | sync_server_settings_(SyncServerSettings()), |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 45 | resource_quota_(nullptr), |
Mark D. Roth | 6980362 | 2016-09-06 08:15:36 -0700 | [diff] [blame] | 46 | generic_service_(nullptr) { |
Yuchen Zeng | 3b8f335 | 2016-05-03 12:18:13 -0700 | [diff] [blame] | 47 | gpr_once_init(&once_init_plugin_list, do_plugin_list_init); |
Vijay Pai | eac07c3 | 2016-06-10 01:36:53 -0700 | [diff] [blame] | 48 | for (auto it = g_plugin_factory_list->begin(); |
| 49 | it != g_plugin_factory_list->end(); it++) { |
Vijay Pai | b645a2d | 2016-06-09 18:39:06 -0700 | [diff] [blame] | 50 | auto& factory = *it; |
Vijay Pai | 15855f3 | 2016-06-10 12:25:32 -0700 | [diff] [blame] | 51 | plugins_.emplace_back(factory()); |
Yuchen Zeng | 3b8f335 | 2016-05-03 12:18:13 -0700 | [diff] [blame] | 52 | } |
Sree Kuchibhotla | 892dbf4 | 2016-09-27 19:42:27 -0700 | [diff] [blame] | 53 | |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 54 | // all compression algorithms enabled by default. |
| 55 | enabled_compression_algorithms_bitset_ = |
| 56 | (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1; |
| 57 | memset(&maybe_default_compression_level_, 0, |
| 58 | sizeof(maybe_default_compression_level_)); |
| 59 | memset(&maybe_default_compression_algorithm_, 0, |
| 60 | sizeof(maybe_default_compression_algorithm_)); |
David Garcia Quintas | beac88c | 2015-08-10 13:39:52 -0700 | [diff] [blame] | 61 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 62 | |
Craig Tiller | db1a5cc | 2016-09-28 14:22:12 -0700 | [diff] [blame] | 63 | ServerBuilder::~ServerBuilder() { |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 64 | if (resource_quota_ != nullptr) { |
| 65 | grpc_resource_quota_unref(resource_quota_); |
Craig Tiller | db1a5cc | 2016-09-28 14:22:12 -0700 | [diff] [blame] | 66 | } |
| 67 | } |
| 68 | |
Sree Kuchibhotla | 1f5e262 | 2016-04-21 12:28:09 -0700 | [diff] [blame] | 69 | std::unique_ptr<ServerCompletionQueue> ServerBuilder::AddCompletionQueue( |
| 70 | bool is_frequently_polled) { |
Craig Tiller | 334c467 | 2017-04-11 16:26:07 -0700 | [diff] [blame] | 71 | ServerCompletionQueue* cq = new ServerCompletionQueue( |
| 72 | is_frequently_polled ? GRPC_CQ_DEFAULT_POLLING : GRPC_CQ_NON_LISTENING); |
Craig Tiller | f9e6adf | 2015-05-06 11:45:59 -0700 | [diff] [blame] | 73 | cqs_.push_back(cq); |
| 74 | return std::unique_ptr<ServerCompletionQueue>(cq); |
| 75 | } |
| 76 | |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 77 | ServerBuilder& ServerBuilder::RegisterService(Service* service) { |
Craig Tiller | 15f383c | 2016-01-07 12:45:32 -0800 | [diff] [blame] | 78 | services_.emplace_back(new NamedService(service)); |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 79 | return *this; |
Craig Tiller | 822d2c7 | 2015-07-07 16:08:00 -0700 | [diff] [blame] | 80 | } |
| 81 | |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 82 | ServerBuilder& ServerBuilder::RegisterService(const grpc::string& addr, |
| 83 | Service* service) { |
Craig Tiller | 15f383c | 2016-01-07 12:45:32 -0800 | [diff] [blame] | 84 | services_.emplace_back(new NamedService(addr, service)); |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 85 | return *this; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 86 | } |
| 87 | |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 88 | ServerBuilder& ServerBuilder::RegisterAsyncGenericService( |
| 89 | AsyncGenericService* service) { |
Yang Gao | 005eb88 | 2015-03-11 22:17:13 -0700 | [diff] [blame] | 90 | if (generic_service_) { |
Yang Gao | 1c40233 | 2015-03-05 16:39:25 -0800 | [diff] [blame] | 91 | gpr_log(GPR_ERROR, |
Yang Gao | 4999649 | 2015-03-12 16:40:19 -0700 | [diff] [blame] | 92 | "Adding multiple AsyncGenericService is unsupported for now. " |
Yang Gao | 6baa9b6 | 2015-03-17 10:49:39 -0700 | [diff] [blame] | 93 | "Dropping the service %p", |
Sree Kuchibhotla | 4028d2c | 2016-09-21 10:45:33 -0700 | [diff] [blame] | 94 | (void*)service); |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 95 | } else { |
| 96 | generic_service_ = service; |
Yang Gao | 1c40233 | 2015-03-05 16:39:25 -0800 | [diff] [blame] | 97 | } |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 98 | return *this; |
Yang Gao | 1c40233 | 2015-03-05 16:39:25 -0800 | [diff] [blame] | 99 | } |
| 100 | |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 101 | ServerBuilder& ServerBuilder::SetOption( |
| 102 | std::unique_ptr<ServerBuilderOption> option) { |
yang-g | a23f17b | 2015-11-25 10:21:05 -0800 | [diff] [blame] | 103 | options_.push_back(std::move(option)); |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 104 | return *this; |
yang-g | a23f17b | 2015-11-25 10:21:05 -0800 | [diff] [blame] | 105 | } |
| 106 | |
Sree Kuchibhotla | 9676619 | 2016-10-13 12:42:54 -0700 | [diff] [blame] | 107 | ServerBuilder& ServerBuilder::SetSyncServerOption( |
| 108 | ServerBuilder::SyncServerOption option, int val) { |
| 109 | switch (option) { |
| 110 | case NUM_CQS: |
| 111 | sync_server_settings_.num_cqs = val; |
| 112 | break; |
Sree Kuchibhotla | 9676619 | 2016-10-13 12:42:54 -0700 | [diff] [blame] | 113 | case MIN_POLLERS: |
| 114 | sync_server_settings_.min_pollers = val; |
| 115 | break; |
| 116 | case MAX_POLLERS: |
| 117 | sync_server_settings_.max_pollers = val; |
| 118 | break; |
| 119 | case CQ_TIMEOUT_MSEC: |
| 120 | sync_server_settings_.cq_timeout_msec = val; |
| 121 | break; |
| 122 | } |
| 123 | return *this; |
| 124 | } |
| 125 | |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 126 | ServerBuilder& ServerBuilder::SetCompressionAlgorithmSupportStatus( |
| 127 | grpc_compression_algorithm algorithm, bool enabled) { |
| 128 | if (enabled) { |
| 129 | GPR_BITSET(&enabled_compression_algorithms_bitset_, algorithm); |
| 130 | } else { |
| 131 | GPR_BITCLEAR(&enabled_compression_algorithms_bitset_, algorithm); |
| 132 | } |
| 133 | return *this; |
| 134 | } |
| 135 | |
| 136 | ServerBuilder& ServerBuilder::SetDefaultCompressionLevel( |
| 137 | grpc_compression_level level) { |
| 138 | maybe_default_compression_level_.level = level; |
| 139 | return *this; |
| 140 | } |
| 141 | |
| 142 | ServerBuilder& ServerBuilder::SetDefaultCompressionAlgorithm( |
| 143 | grpc_compression_algorithm algorithm) { |
| 144 | maybe_default_compression_algorithm_.is_set = true; |
| 145 | maybe_default_compression_algorithm_.algorithm = algorithm; |
| 146 | return *this; |
| 147 | } |
| 148 | |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 149 | ServerBuilder& ServerBuilder::SetResourceQuota( |
| 150 | const grpc::ResourceQuota& resource_quota) { |
| 151 | if (resource_quota_ != nullptr) { |
| 152 | grpc_resource_quota_unref(resource_quota_); |
Craig Tiller | db1a5cc | 2016-09-28 14:22:12 -0700 | [diff] [blame] | 153 | } |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 154 | resource_quota_ = resource_quota.c_resource_quota(); |
| 155 | grpc_resource_quota_ref(resource_quota_); |
Craig Tiller | db1a5cc | 2016-09-28 14:22:12 -0700 | [diff] [blame] | 156 | return *this; |
| 157 | } |
| 158 | |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 159 | ServerBuilder& ServerBuilder::AddListeningPort( |
David Garcia Quintas | 94ab1b5 | 2017-05-15 15:27:11 -0700 | [diff] [blame] | 160 | const grpc::string& addr_uri, std::shared_ptr<ServerCredentials> creds, |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 161 | int* selected_port) { |
David Garcia Quintas | 94ab1b5 | 2017-05-15 15:27:11 -0700 | [diff] [blame] | 162 | const grpc::string uri_scheme = "dns:"; |
| 163 | grpc::string addr = addr_uri; |
| 164 | if (addr_uri.compare(0, uri_scheme.size(), uri_scheme) == 0) { |
| 165 | size_t pos = uri_scheme.size(); |
| 166 | while (addr_uri[pos] == '/') ++pos; // Skip slashes. |
| 167 | addr = addr_uri.substr(pos); |
| 168 | } |
Nicolas Noble | 3086203 | 2015-04-24 18:17:45 -0700 | [diff] [blame] | 169 | Port port = {addr, creds, selected_port}; |
| 170 | ports_.push_back(port); |
David Garcia Quintas | 2d02456 | 2016-05-17 23:24:39 -0700 | [diff] [blame] | 171 | return *this; |
yangg | 9e21f72 | 2014-12-08 15:49:52 -0800 | [diff] [blame] | 172 | } |
| 173 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 174 | std::unique_ptr<Server> ServerBuilder::BuildAndStart() { |
yang-g | 21035da | 2017-05-16 11:42:04 -0700 | [diff] [blame] | 175 | for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) { |
| 176 | (*plugin)->UpdateServerBuilder(this); |
| 177 | } |
| 178 | |
Sree Kuchibhotla | 2d08f5b | 2016-09-26 16:11:02 -0700 | [diff] [blame] | 179 | ChannelArguments args; |
| 180 | for (auto option = options_.begin(); option != options_.end(); ++option) { |
| 181 | (*option)->UpdateArguments(&args); |
| 182 | (*option)->UpdatePlugins(&plugins_); |
| 183 | } |
| 184 | |
| 185 | for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) { |
| 186 | (*plugin)->UpdateChannelArguments(&args); |
| 187 | } |
| 188 | |
| 189 | if (max_receive_message_size_ >= 0) { |
| 190 | args.SetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH, max_receive_message_size_); |
| 191 | } |
| 192 | |
| 193 | if (max_send_message_size_ >= 0) { |
| 194 | args.SetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH, max_send_message_size_); |
| 195 | } |
| 196 | |
| 197 | args.SetInt(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET, |
| 198 | enabled_compression_algorithms_bitset_); |
| 199 | if (maybe_default_compression_level_.is_set) { |
| 200 | args.SetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL, |
| 201 | maybe_default_compression_level_.level); |
| 202 | } |
| 203 | if (maybe_default_compression_algorithm_.is_set) { |
| 204 | args.SetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM, |
| 205 | maybe_default_compression_algorithm_.algorithm); |
| 206 | } |
| 207 | |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 208 | if (resource_quota_ != nullptr) { |
Craig Tiller | 153eaa7 | 2016-10-21 13:52:36 -0700 | [diff] [blame] | 209 | args.SetPointerWithVtable(GRPC_ARG_RESOURCE_QUOTA, resource_quota_, |
Craig Tiller | 20afa3d | 2016-10-17 14:52:14 -0700 | [diff] [blame] | 210 | grpc_resource_quota_arg_vtable()); |
Craig Tiller | db1a5cc | 2016-09-28 14:22:12 -0700 | [diff] [blame] | 211 | } |
Sree Kuchibhotla | 1e088b4 | 2016-10-28 17:34:55 -0700 | [diff] [blame] | 212 | |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 213 | // == Determine if the server has any syncrhonous methods == |
Craig Tiller | 8a7fe1a | 2016-05-20 11:17:20 -0700 | [diff] [blame] | 214 | bool has_sync_methods = false; |
Craig Tiller | 15f383c | 2016-01-07 12:45:32 -0800 | [diff] [blame] | 215 | for (auto it = services_.begin(); it != services_.end(); ++it) { |
| 216 | if ((*it)->service->has_synchronous_methods()) { |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 217 | has_sync_methods = true; |
| 218 | break; |
| 219 | } |
| 220 | } |
| 221 | |
| 222 | if (!has_sync_methods) { |
| 223 | for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) { |
| 224 | if ((*plugin)->has_sync_methods()) { |
Craig Tiller | 8a7fe1a | 2016-05-20 11:17:20 -0700 | [diff] [blame] | 225 | has_sync_methods = true; |
yang-g | bef0d87 | 2016-01-13 15:27:33 -0800 | [diff] [blame] | 226 | break; |
Craig Tiller | 15f383c | 2016-01-07 12:45:32 -0800 | [diff] [blame] | 227 | } |
| 228 | } |
Craig Tiller | 0db1bef | 2015-02-09 13:47:39 -0800 | [diff] [blame] | 229 | } |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 230 | |
Sree Kuchibhotla | aabada9 | 2016-08-24 10:01:13 -0700 | [diff] [blame] | 231 | // If this is a Sync server, i.e a server expositing sync API, then the server |
| 232 | // needs to create some completion queues to listen for incoming requests. |
| 233 | // 'sync_server_cqs' are those internal completion queues. |
| 234 | // |
| 235 | // This is different from the completion queues added to the server via |
| 236 | // ServerBuilder's AddCompletionQueue() method (those completion queues |
| 237 | // are in 'cqs_' member variable of ServerBuilder object) |
Sree Kuchibhotla | 4028d2c | 2016-09-21 10:45:33 -0700 | [diff] [blame] | 238 | std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>> |
Sree Kuchibhotla | 6135535 | 2016-10-20 11:17:22 -0700 | [diff] [blame] | 239 | sync_server_cqs(std::make_shared< |
| 240 | std::vector<std::unique_ptr<ServerCompletionQueue>>>()); |
Sree Kuchibhotla | aabada9 | 2016-08-24 10:01:13 -0700 | [diff] [blame] | 241 | |
Craig Tiller | 75bfb97 | 2017-04-11 17:55:12 -0700 | [diff] [blame] | 242 | int num_frequently_polled_cqs = 0; |
| 243 | for (auto it = cqs_.begin(); it != cqs_.end(); ++it) { |
| 244 | if ((*it)->IsFrequentlyPolled()) { |
| 245 | num_frequently_polled_cqs++; |
| 246 | } |
| 247 | } |
| 248 | |
| 249 | const bool is_hybrid_server = |
| 250 | has_sync_methods && num_frequently_polled_cqs > 0; |
| 251 | |
Sree Kuchibhotla | aabada9 | 2016-08-24 10:01:13 -0700 | [diff] [blame] | 252 | if (has_sync_methods) { |
Craig Tiller | 334c467 | 2017-04-11 16:26:07 -0700 | [diff] [blame] | 253 | grpc_cq_polling_type polling_type = |
Craig Tiller | 75bfb97 | 2017-04-11 17:55:12 -0700 | [diff] [blame] | 254 | is_hybrid_server ? GRPC_CQ_NON_POLLING : GRPC_CQ_DEFAULT_POLLING; |
Craig Tiller | 334c467 | 2017-04-11 16:26:07 -0700 | [diff] [blame] | 255 | |
Sree Kuchibhotla | a7a21d2 | 2016-09-28 12:38:01 -0700 | [diff] [blame] | 256 | // Create completion queues to listen to incoming rpc requests |
Sree Kuchibhotla | 892dbf4 | 2016-09-27 19:42:27 -0700 | [diff] [blame] | 257 | for (int i = 0; i < sync_server_settings_.num_cqs; i++) { |
Craig Tiller | 334c467 | 2017-04-11 16:26:07 -0700 | [diff] [blame] | 258 | sync_server_cqs->emplace_back(new ServerCompletionQueue(polling_type)); |
Sree Kuchibhotla | aabada9 | 2016-08-24 10:01:13 -0700 | [diff] [blame] | 259 | } |
| 260 | } |
| 261 | |
Sree Kuchibhotla | 892dbf4 | 2016-09-27 19:42:27 -0700 | [diff] [blame] | 262 | std::unique_ptr<Server> server(new Server( |
Sree Kuchibhotla | e4eb51f | 2016-10-18 11:51:28 -0700 | [diff] [blame] | 263 | max_receive_message_size_, &args, sync_server_cqs, |
Sree Kuchibhotla | 892dbf4 | 2016-09-27 19:42:27 -0700 | [diff] [blame] | 264 | sync_server_settings_.min_pollers, sync_server_settings_.max_pollers, |
| 265 | sync_server_settings_.cq_timeout_msec)); |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 266 | |
ncteisen | 85fac6d | 2017-07-12 07:49:45 -0700 | [diff] [blame] | 267 | if (has_sync_methods) { |
| 268 | // This is a Sync server |
| 269 | gpr_log(GPR_INFO, |
| 270 | "Synchronous server. Num CQs: %d, Min pollers: %d, Max Pollers: " |
| 271 | "%d, CQ timeout (msec): %d", |
| 272 | sync_server_settings_.num_cqs, sync_server_settings_.min_pollers, |
| 273 | sync_server_settings_.max_pollers, |
| 274 | sync_server_settings_.cq_timeout_msec); |
| 275 | } |
| 276 | |
Yuchen Zeng | a42ec21 | 2016-04-29 13:03:06 -0700 | [diff] [blame] | 277 | ServerInitializer* initializer = server->initializer(); |
Sree Kuchibhotla | 7def036 | 2016-04-21 14:54:32 -0700 | [diff] [blame] | 278 | |
Sree Kuchibhotla | aabada9 | 2016-08-24 10:01:13 -0700 | [diff] [blame] | 279 | // Register all the completion queues with the server. i.e |
| 280 | // 1. sync_server_cqs: internal completion queues created IF this is a sync |
| 281 | // server |
| 282 | // 2. cqs_: Completion queues added via AddCompletionQueue() call |
Sree Kuchibhotla | 7def036 | 2016-04-21 14:54:32 -0700 | [diff] [blame] | 283 | |
Sree Kuchibhotla | aabada9 | 2016-08-24 10:01:13 -0700 | [diff] [blame] | 284 | for (auto it = sync_server_cqs->begin(); it != sync_server_cqs->end(); ++it) { |
Craig Tiller | 11c5832 | 2017-04-12 08:21:17 -0700 | [diff] [blame] | 285 | grpc_server_register_completion_queue(server->server_, (*it)->cq(), |
| 286 | nullptr); |
Craig Tiller | 75bfb97 | 2017-04-11 17:55:12 -0700 | [diff] [blame] | 287 | num_frequently_polled_cqs++; |
Sree Kuchibhotla | aabada9 | 2016-08-24 10:01:13 -0700 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | // cqs_ contains the completion queue added by calling the ServerBuilder's |
| 291 | // AddCompletionQueue() API. Some of them may not be frequently polled (i.e by |
| 292 | // calling Next() or AsyncNext()) and hence are not safe to be used for |
| 293 | // listening to incoming channels. Such completion queues must be registered |
| 294 | // as non-listening queues |
| 295 | for (auto it = cqs_.begin(); it != cqs_.end(); ++it) { |
Craig Tiller | 11c5832 | 2017-04-12 08:21:17 -0700 | [diff] [blame] | 296 | grpc_server_register_completion_queue(server->server_, (*it)->cq(), |
| 297 | nullptr); |
Craig Tiller | f9e6adf | 2015-05-06 11:45:59 -0700 | [diff] [blame] | 298 | } |
Sree Kuchibhotla | 7def036 | 2016-04-21 14:54:32 -0700 | [diff] [blame] | 299 | |
| 300 | if (num_frequently_polled_cqs == 0) { |
| 301 | gpr_log(GPR_ERROR, |
Craig Tiller | aae6c2c | 2016-05-20 08:58:30 -0700 | [diff] [blame] | 302 | "At least one of the completion queues must be frequently polled"); |
Sree Kuchibhotla | 7def036 | 2016-04-21 14:54:32 -0700 | [diff] [blame] | 303 | return nullptr; |
| 304 | } |
| 305 | |
Vijay Pai | 82dd80a | 2015-03-24 10:36:08 -0700 | [diff] [blame] | 306 | for (auto service = services_.begin(); service != services_.end(); |
| 307 | service++) { |
Craig Tiller | d9b6fcf | 2015-07-07 16:28:20 -0700 | [diff] [blame] | 308 | if (!server->RegisterService((*service)->host.get(), (*service)->service)) { |
Craig Tiller | 0db1bef | 2015-02-09 13:47:39 -0800 | [diff] [blame] | 309 | return nullptr; |
| 310 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 311 | } |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 312 | |
Yuchen Zeng | a42ec21 | 2016-04-29 13:03:06 -0700 | [diff] [blame] | 313 | for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) { |
Vijay Pai | 15855f3 | 2016-06-10 12:25:32 -0700 | [diff] [blame] | 314 | (*plugin)->InitServer(initializer); |
Yuchen Zeng | a42ec21 | 2016-04-29 13:03:06 -0700 | [diff] [blame] | 315 | } |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 316 | |
Yang Gao | 005eb88 | 2015-03-11 22:17:13 -0700 | [diff] [blame] | 317 | if (generic_service_) { |
Yang Gao | 4999649 | 2015-03-12 16:40:19 -0700 | [diff] [blame] | 318 | server->RegisterAsyncGenericService(generic_service_); |
yang-g | 1ac6f45 | 2016-01-15 11:46:40 -0800 | [diff] [blame] | 319 | } else { |
| 320 | for (auto it = services_.begin(); it != services_.end(); ++it) { |
| 321 | if ((*it)->service->has_generic_methods()) { |
| 322 | gpr_log(GPR_ERROR, |
| 323 | "Some methods were marked generic but there is no " |
| 324 | "generic service registered."); |
| 325 | return nullptr; |
| 326 | } |
| 327 | } |
Yang Gao | 1c40233 | 2015-03-05 16:39:25 -0800 | [diff] [blame] | 328 | } |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 329 | |
Craig Tiller | 12352b2 | 2017-01-10 15:16:14 -0800 | [diff] [blame] | 330 | bool added_port = false; |
Vijay Pai | 82dd80a | 2015-03-24 10:36:08 -0700 | [diff] [blame] | 331 | for (auto port = ports_.begin(); port != ports_.end(); port++) { |
| 332 | int r = server->AddListeningPort(port->addr, port->creds.get()); |
Craig Tiller | 12352b2 | 2017-01-10 15:16:14 -0800 | [diff] [blame] | 333 | if (!r) { |
| 334 | if (added_port) server->Shutdown(); |
| 335 | return nullptr; |
| 336 | } |
| 337 | added_port = true; |
Vijay Pai | 82dd80a | 2015-03-24 10:36:08 -0700 | [diff] [blame] | 338 | if (port->selected_port != nullptr) { |
| 339 | *port->selected_port = r; |
Craig Tiller | 0db1bef | 2015-02-09 13:47:39 -0800 | [diff] [blame] | 340 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 341 | } |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 342 | |
yang-g | 61e461e | 2015-09-03 13:08:59 -0700 | [diff] [blame] | 343 | auto cqs_data = cqs_.empty() ? nullptr : &cqs_[0]; |
Craig Tiller | 9d9313c | 2017-04-11 15:05:46 -0700 | [diff] [blame] | 344 | server->Start(cqs_data, cqs_.size()); |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 345 | |
Yuchen Zeng | a42ec21 | 2016-04-29 13:03:06 -0700 | [diff] [blame] | 346 | for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) { |
Vijay Pai | 15855f3 | 2016-06-10 12:25:32 -0700 | [diff] [blame] | 347 | (*plugin)->Finish(initializer); |
Yuchen Zeng | a42ec21 | 2016-04-29 13:03:06 -0700 | [diff] [blame] | 348 | } |
Sree Kuchibhotla | 3ea9e24 | 2016-08-22 14:15:43 -0700 | [diff] [blame] | 349 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 350 | return server; |
| 351 | } |
| 352 | |
Yuchen Zeng | 3b8f335 | 2016-05-03 12:18:13 -0700 | [diff] [blame] | 353 | void ServerBuilder::InternalAddPluginFactory( |
| 354 | std::unique_ptr<ServerBuilderPlugin> (*CreatePlugin)()) { |
| 355 | gpr_once_init(&once_init_plugin_list, do_plugin_list_init); |
Yuchen Zeng | 7d099a5 | 2016-05-06 13:21:36 -0700 | [diff] [blame] | 356 | (*g_plugin_factory_list).push_back(CreatePlugin); |
Yuchen Zeng | 3b8f335 | 2016-05-03 12:18:13 -0700 | [diff] [blame] | 357 | } |
| 358 | |
Muxi Yan | f6b622c | 2017-05-17 10:34:10 -0700 | [diff] [blame] | 359 | ServerBuilder& ServerBuilder::EnableWorkaround(grpc_workaround_list id) { |
Muxi Yan | cdc0d03 | 2017-05-09 16:04:10 -0700 | [diff] [blame] | 360 | switch (id) { |
| 361 | case GRPC_WORKAROUND_ID_CRONET_COMPRESSION: |
Muxi Yan | f5b3db9 | 2017-05-09 17:12:24 -0700 | [diff] [blame] | 362 | return AddChannelArgument(GRPC_ARG_WORKAROUND_CRONET_COMPRESSION, 1); |
Muxi Yan | cdc0d03 | 2017-05-09 16:04:10 -0700 | [diff] [blame] | 363 | default: |
Muxi Yan | 928681d | 2017-05-16 10:16:23 -0700 | [diff] [blame] | 364 | gpr_log(GPR_ERROR, "Workaround %u does not exist or is obsolete.", id); |
Muxi Yan | f5b3db9 | 2017-05-09 17:12:24 -0700 | [diff] [blame] | 365 | return *this; |
Muxi Yan | cdc0d03 | 2017-05-09 16:04:10 -0700 | [diff] [blame] | 366 | } |
| 367 | } |
| 368 | |
Craig Tiller | 190d360 | 2015-02-18 09:23:38 -0800 | [diff] [blame] | 369 | } // namespace grpc |