diff --git a/include/grpc++/server_builder.h b/include/grpc++/server_builder.h
index ad629521cbe415e5a8e7b0f0f24d8f6aa72f2158..c48c86d2b88162db0df41ab7bd7b14d2d47f16db 100644
--- a/include/grpc++/server_builder.h
+++ b/include/grpc++/server_builder.h
@@ -66,29 +66,43 @@ class ServerBuilder {
/// The service must exist for the lifetime of the \a Server instance returned
/// by \a BuildAndStart().
/// Matches requests with any :authority
- void RegisterService(Service* service);
+ ServerBuilder& RegisterService(Service* service);
/// Register a generic service.
/// Matches requests with any :authority
- void RegisterAsyncGenericService(AsyncGenericService* service);
+ ServerBuilder& RegisterAsyncGenericService(AsyncGenericService* service);
/// Register a service. This call does not take ownership of the service.
/// The service must exist for the lifetime of the \a Server instance returned
/// by BuildAndStart().
/// Only matches requests with :authority \a host
- void RegisterService(const grpc::string& host, Service* service);
+ ServerBuilder& RegisterService(const grpc::string& host, Service* service);
/// Set max message size in bytes.
- void SetMaxMessageSize(int max_message_size) {
+ ServerBuilder& SetMaxMessageSize(int max_message_size) {
max_message_size_ = max_message_size;
+ return *this;
}
- /// Set the compression options to be used by the server.
- void SetCompressionOptions(const grpc_compression_options& options) {
- compression_options_ = options;
- }
+ /// Set the support status for compression algorithms. All algorithms are
+ /// enabled by default.
+ ///
+ /// Incoming calls compressed with an unsupported algorithm will fail with
+ /// GRPC_STATUS_UNIMPLEMENTED.
+ ServerBuilder& SetCompressionAlgorithmSupportStatus(
+ grpc_compression_algorithm algorithm, bool enabled);
+
+ /// The default compression level to use for all channel calls in the
+ /// absence of a call-specific level.
+ ServerBuilder& SetDefaultCompressionLevel(grpc_compression_level level);
+
+ /// The default compression algorithm to use for all channel calls in the
+ /// absence of a call-specific level. Note that it overrides any compression
+ /// level set by \a SetDefaultCompressionLevel.
+ ServerBuilder& SetDefaultCompressionAlgorithm(
+ grpc_compression_algorithm algorithm);
- void SetOption(std::unique_ptr<ServerBuilderOption> option);
+ ServerBuilder& SetOption(std::unique_ptr<ServerBuilderOption> option);
/// Tries to bind \a server to the given \a addr.
///
@@ -101,9 +115,9 @@ class ServerBuilder {
/// number. \a nullptr otherwise.
///
// TODO(dgq): the "port" part seems to be a misnomer.
- void AddListeningPort(const grpc::string& addr,
- std::shared_ptr<ServerCredentials> creds,
- int* selected_port = nullptr);
+ ServerBuilder& AddListeningPort(const grpc::string& addr,
+ std::shared_ptr<ServerCredentials> creds,
+ int* selected_port = nullptr);
/// Add a completion queue for handling asynchronous services
/// Caller is required to keep this completion queue live until
@@ -136,7 +150,6 @@ class ServerBuilder {
};
int max_message_size_;
- grpc_compression_options compression_options_;
std::vector<std::unique_ptr<ServerBuilderOption>> options_;
std::vector<std::unique_ptr<NamedService>> services_;
std::vector<Port> ports_;
@@ -144,6 +157,15 @@ class ServerBuilder {
std::shared_ptr<ServerCredentials> creds_;
std::map<grpc::string, std::unique_ptr<ServerBuilderPlugin>> plugins_;
AsyncGenericService* generic_service_;
+ struct {
+ bool is_set;
+ grpc_compression_level level;
+ } maybe_default_compression_level_;
+ struct {
+ bool is_set;
+ grpc_compression_algorithm algorithm;
+ } maybe_default_compression_algorithm_;
+ uint32_t enabled_compression_algorithms_bitset_;
};
} // namespace grpc
diff --git a/include/grpc/compression.h b/include/grpc/compression.h
index 04816b9f3a9d99b34462c6b91e77d4fc54355fd0..3eba00c9864bca6ebddbee1c037127b6892f633b 100644
--- a/include/grpc/compression.h
+++ b/include/grpc/compression.h
@@ -55,20 +55,6 @@ GRPCAPI int grpc_compression_algorithm_parse(
GRPCAPI int grpc_compression_algorithm_name(
grpc_compression_algorithm algorithm, char **name);
-GRPCAPI void grpc_compression_options_init(grpc_compression_options *opts);
-
-/** Mark \a algorithm as enabled in \a opts. */
-GRPCAPI void grpc_compression_options_enable_algorithm(
- grpc_compression_options *opts, grpc_compression_algorithm algorithm);
-
-/** Mark \a algorithm as disabled in \a opts. */
-GRPCAPI void grpc_compression_options_disable_algorithm(
- grpc_compression_options *opts, grpc_compression_algorithm algorithm);
-
-/** Returns true if \a algorithm is marked as enabled in \a opts. */
-GRPCAPI int grpc_compression_options_is_algorithm_enabled(
- const grpc_compression_options *opts, grpc_compression_algorithm algorithm);
-
#ifdef __cplusplus
}
#endif
diff --git a/include/grpc/impl/codegen/compression_types.h b/include/grpc/impl/codegen/compression_types.h
index 7cf68bfaf8904827142dc52b69f9fe631c6000c6..19c2cefcf4cdb92291372af4f84b0443c2f13f46 100644
--- a/include/grpc/impl/codegen/compression_types.h
+++ b/include/grpc/impl/codegen/compression_types.h
@@ -74,32 +74,6 @@ typedef enum {
GRPC_COMPRESS_LEVEL_COUNT
} grpc_compression_level;
-typedef struct grpc_compression_options {
- /** All algs are enabled by default. This option corresponds to the channel
- * argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET
- */
- uint32_t enabled_algorithms_bitset;
-
- /** The default channel compression level. It'll be used in the absence of
- * call specific settings. This option corresponds to the channel argument key
- * behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL. If present, takes
- * precedence over \a default_algorithm.
- * TODO(dgq): currently only available for server channels. */
- struct {
- bool is_set;
- grpc_compression_algorithm level;
- } default_level;
-
- /** The default channel compression algorithm. It'll be used in the absence of
- * call specific settings. This option corresponds to the channel argument key
- * behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM. */
- struct {
- bool is_set;
- grpc_compression_algorithm algorithm;
- } default_algorithm;
-
-} grpc_compression_options;
-
#ifdef __cplusplus
}
#endif
diff --git a/src/core/lib/compression/compression_algorithm.c b/src/core/lib/compression/compression_algorithm.c
index c7f834d9891e31f0280ed65a9ce5321fb0baaa93..6cbdbd81b0e3ede9eb7a189f7db5d688b5ae569e 100644
--- a/src/core/lib/compression/compression_algorithm.c
+++ b/src/core/lib/compression/compression_algorithm.c
@@ -124,25 +124,3 @@ grpc_mdelem *grpc_compression_encoding_mdelem(
}
return NULL;
}
-
-void grpc_compression_options_init(grpc_compression_options *opts) {
- opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
- opts->default_level.is_set = false;
- opts->default_algorithm.is_set = false;
-}
-
-void grpc_compression_options_enable_algorithm(
- grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
- GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
-}
-
-void grpc_compression_options_disable_algorithm(
- grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
- GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
-}
-
-int grpc_compression_options_is_algorithm_enabled(
- const grpc_compression_options *opts,
- grpc_compression_algorithm algorithm) {
- return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
-}
diff --git a/src/cpp/server/server_builder.cc b/src/cpp/server/server_builder.cc
index e6050c3b522061e0ba5899fb56cc39aca20aa7f5..bbea9355babcdcd743020ad5d8b2f88ff1399635 100644
--- a/src/cpp/server/server_builder.cc
+++ b/src/cpp/server/server_builder.cc
@@ -37,6 +37,8 @@
#include <grpc++/server.h>
#include <grpc/support/cpu.h>
#include <grpc/support/log.h>
+
+#include "include/grpc/support/useful.h"
#include "src/cpp/server/thread_pool_interface.h"
namespace grpc {
@@ -52,12 +54,18 @@ static void do_plugin_list_init(void) {
ServerBuilder::ServerBuilder()
: max_message_size_(-1), generic_service_(nullptr) {
- grpc_compression_options_init(&compression_options_);
gpr_once_init(&once_init_plugin_list, do_plugin_list_init);
for (auto factory : (*g_plugin_factory_list)) {
std::unique_ptr<ServerBuilderPlugin> plugin = factory();
plugins_[plugin->name()] = std::move(plugin);
}
+ // all compression algorithms enabled by default.
+ enabled_compression_algorithms_bitset_ =
+ (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
+ memset(&maybe_default_compression_level_, 0,
+ sizeof(maybe_default_compression_level_));
+ memset(&maybe_default_compression_algorithm_, 0,
+ sizeof(maybe_default_compression_algorithm_));
}
std::unique_ptr<ServerCompletionQueue> ServerBuilder::AddCompletionQueue() {
@@ -66,35 +74,65 @@ std::unique_ptr<ServerCompletionQueue> ServerBuilder::AddCompletionQueue() {
return std::unique_ptr<ServerCompletionQueue>(cq);
}
-void ServerBuilder::RegisterService(Service* service) {
+ServerBuilder& ServerBuilder::RegisterService(Service* service) {
services_.emplace_back(new NamedService(service));
+ return *this;
}
-void ServerBuilder::RegisterService(const grpc::string& addr,
- Service* service) {
+ServerBuilder& ServerBuilder::RegisterService(const grpc::string& addr,
+ Service* service) {
services_.emplace_back(new NamedService(addr, service));
+ return *this;
}
-void ServerBuilder::RegisterAsyncGenericService(AsyncGenericService* service) {
+ServerBuilder& ServerBuilder::RegisterAsyncGenericService(
+ AsyncGenericService* service) {
if (generic_service_) {
gpr_log(GPR_ERROR,
"Adding multiple AsyncGenericService is unsupported for now. "
"Dropping the service %p",
service);
- return;
+ } else {
+ generic_service_ = service;
}
- generic_service_ = service;
+ return *this;
}
-void ServerBuilder::SetOption(std::unique_ptr<ServerBuilderOption> option) {
+ServerBuilder& ServerBuilder::SetOption(
+ std::unique_ptr<ServerBuilderOption> option) {
options_.push_back(std::move(option));
+ return *this;
+}
+
+ServerBuilder& ServerBuilder::SetCompressionAlgorithmSupportStatus(
+ grpc_compression_algorithm algorithm, bool enabled) {
+ if (enabled) {
+ GPR_BITSET(&enabled_compression_algorithms_bitset_, algorithm);
+ } else {
+ GPR_BITCLEAR(&enabled_compression_algorithms_bitset_, algorithm);
+ }
+ return *this;
}
-void ServerBuilder::AddListeningPort(const grpc::string& addr,
- std::shared_ptr<ServerCredentials> creds,
- int* selected_port) {
+ServerBuilder& ServerBuilder::SetDefaultCompressionLevel(
+ grpc_compression_level level) {
+ maybe_default_compression_level_.level = level;
+ return *this;
+}
+
+ServerBuilder& ServerBuilder::SetDefaultCompressionAlgorithm(
+ grpc_compression_algorithm algorithm) {
+ maybe_default_compression_algorithm_.is_set = true;
+ maybe_default_compression_algorithm_.algorithm = algorithm;
+ return *this;
+}
+
+ServerBuilder& ServerBuilder::AddListeningPort(
+ const grpc::string& addr, std::shared_ptr<ServerCredentials> creds,
+ int* selected_port) {
Port port = {addr, creds, selected_port};
ports_.push_back(port);
+ return *this;
}
std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
@@ -124,13 +162,14 @@ std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
args.SetInt(GRPC_ARG_MAX_MESSAGE_LENGTH, max_message_size_);
}
args.SetInt(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
- compression_options_.enabled_algorithms_bitset);
- if (compression_options_.default_level.is_set) {
+ enabled_compression_algorithms_bitset_);
+ if (maybe_default_compression_level_.is_set) {
args.SetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL,
- compression_options_.default_level.level);
- } else if (compression_options_.default_algorithm.is_set) {
+ maybe_default_compression_level_.level);
+ }
+ if (maybe_default_compression_algorithm_.is_set) {
args.SetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
- compression_options_.default_algorithm.algorithm);
+ maybe_default_compression_algorithm_.algorithm);
}
std::unique_ptr<Server> server(
new Server(thread_pool.release(), true, max_message_size_, &args));
diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.c
index ed6f9e721425994d7344a30117d8a72036dff256..5ee1805222bbb96e0564aa21194c1619e7546ab3 100644
--- a/test/core/compression/compression_test.c
+++ b/test/core/compression/compression_test.c
@@ -92,40 +92,10 @@ static void test_compression_algorithm_name(void) {
/* the value of "name" is undefined upon failure */
}
-static void test_compression_enable_disable_algorithm(void) {
- grpc_compression_options options;
- grpc_compression_algorithm algorithm;
-
- gpr_log(GPR_DEBUG, "test_compression_enable_disable_algorithm");
-
- grpc_compression_options_init(&options);
- for (algorithm = GRPC_COMPRESS_NONE;
- algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
- /* all algorithms are enabled by default */
- GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
- algorithm) != 0);
- }
- /* disable one by one */
- for (algorithm = GRPC_COMPRESS_NONE;
- algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
- grpc_compression_options_disable_algorithm(&options, algorithm);
- GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
- algorithm) == 0);
- }
- /* re-enable one by one */
- for (algorithm = GRPC_COMPRESS_NONE;
- algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
- grpc_compression_options_enable_algorithm(&options, algorithm);
- GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
- algorithm) != 0);
- }
-}
-
int main(int argc, char **argv) {
grpc_init();
test_compression_algorithm_parse();
test_compression_algorithm_name();
- test_compression_enable_disable_algorithm();
grpc_shutdown();
return 0;