Merge github.com:grpc/grpc into bm_fullstack

pull/8503/head
Craig Tiller 8 years ago
commit 7a4ac73d5b
  1. 27
      BUILD
  2. 27
      CMakeLists.txt
  3. 78
      Makefile
  4. 24
      build.yaml
  5. 88
      doc/cpp-style-guide.md
  6. 2
      include/grpc++/alarm.h
  7. 20
      include/grpc++/channel.h
  8. 12
      include/grpc++/ext/proto_server_reflection_plugin.h
  9. 4
      include/grpc++/generic/async_generic_service.h
  10. 2
      include/grpc++/generic/generic_stub.h
  11. 64
      include/grpc++/impl/codegen/async_stream.h
  12. 9
      include/grpc++/impl/codegen/async_unary_call.h
  13. 14
      include/grpc++/impl/codegen/call.h
  14. 6
      include/grpc++/impl/codegen/client_context.h
  15. 83
      include/grpc++/impl/codegen/config.h
  16. 67
      include/grpc++/impl/codegen/core_codegen.h
  17. 45
      include/grpc++/impl/codegen/impl/sync.h
  18. 10
      include/grpc++/impl/codegen/method_handler_impl.h
  19. 22
      include/grpc++/impl/codegen/proto_utils.h
  20. 2
      include/grpc++/impl/codegen/server_context.h
  21. 10
      include/grpc++/impl/codegen/server_interface.h
  22. 45
      include/grpc++/impl/codegen/sync.h
  23. 49
      include/grpc++/impl/codegen/sync_cxx11.h
  24. 111
      include/grpc++/impl/codegen/sync_no_cxx11.h
  25. 76
      include/grpc++/impl/codegen/sync_stream.h
  26. 4
      include/grpc++/impl/codegen/time.h
  27. 8
      include/grpc++/impl/grpc_library.h
  28. 39
      include/grpc++/impl/sync.h
  29. 45
      include/grpc++/impl/thd.h
  30. 45
      include/grpc++/impl/thd_cxx11.h
  31. 117
      include/grpc++/impl/thd_no_cxx11.h
  32. 2
      include/grpc++/resource_quota.h
  33. 28
      include/grpc++/server.h
  34. 2
      include/grpc++/support/byte_buffer.h
  35. 5
      include/grpc++/support/channel_arguments.h
  36. 2
      include/grpc++/support/slice.h
  37. 2
      setup.py
  38. 67
      src/compiler/cpp_generator.cc
  39. 6
      src/core/ext/client_channel/lb_policy.h
  40. 679
      src/core/ext/lb_policy/grpclb/grpclb.c
  41. 4
      src/core/ext/lb_policy/grpclb/proto/grpc/lb/v1/load_balancer.pb.h
  42. 44
      src/core/ext/lb_policy/round_robin/round_robin.c
  43. 2
      src/core/ext/resolver/dns/native/dns_resolver.c
  44. 2
      src/core/ext/transport/chttp2/client/secure/secure_channel_create.c
  45. 26
      src/core/ext/transport/chttp2/transport/hpack_parser.c
  46. 7
      src/core/lib/iomgr/resource_quota.c
  47. 5
      src/core/lib/iomgr/resource_quota.h
  48. 36
      src/core/lib/iomgr/tcp_client_uv.c
  49. 45
      src/core/lib/iomgr/tcp_server_posix.c
  50. 24
      src/core/lib/iomgr/tcp_server_uv.c
  51. 71
      src/core/lib/iomgr/tcp_uv.c
  52. 4
      src/core/lib/iomgr/tcp_uv.h
  53. 4
      src/core/lib/security/transport/security_connector.c
  54. 6
      src/cpp/client/channel_cc.cc
  55. 12
      src/cpp/client/client_context.cc
  56. 8
      src/cpp/client/cronet_credentials.cc
  57. 8
      src/cpp/client/insecure_credentials.cc
  58. 14
      src/cpp/client/secure_credentials.h
  59. 5
      src/cpp/common/channel_arguments.cc
  60. 2
      src/cpp/common/channel_filter.h
  61. 21
      src/cpp/common/secure_auth_context.h
  62. 4
      src/cpp/ext/proto_server_reflection.h
  63. 18
      src/cpp/server/dynamic_thread_pool.cc
  64. 17
      src/cpp/server/dynamic_thread_pool.h
  65. 7
      src/cpp/server/insecure_server_credentials.cc
  66. 11
      src/cpp/server/secure_server_credentials.h
  67. 32
      src/cpp/server/server_cc.cc
  68. 17
      src/cpp/server/server_context.cc
  69. 29
      src/cpp/thread_manager/thread_manager.cc
  70. 13
      src/cpp/thread_manager/thread_manager.h
  71. 5
      src/cpp/util/time_cc.cc
  72. 3
      src/proto/grpc/lb/v1/load_balancer.options
  73. 8
      src/proto/grpc/lb/v1/load_balancer.proto
  74. 2
      src/ruby/ext/grpc/rb_compression_options.c
  75. 2
      templates/tools/dockerfile/test/cxx_ubuntu1604_x64/Dockerfile.template
  76. 2
      test/core/client_channel/set_initial_connect_string_test.c
  77. BIN
      test/core/end2end/fuzzers/client_fuzzer_corpus/server_hanging_response_1_header
  78. BIN
      test/core/end2end/fuzzers/client_fuzzer_corpus/server_hanging_response_2_header2
  79. 49
      test/core/end2end/fuzzers/generate_client_examples_of_bad_closing_streams.py
  80. 39
      test/core/end2end/tests/resource_quota_server.c
  81. 52
      test/cpp/codegen/compiler_test_golden
  82. 4
      test/cpp/common/auth_property_iterator_test.cc
  83. 10
      test/cpp/end2end/async_end2end_test.cc
  84. 9
      test/cpp/end2end/client_crash_test_server.cc
  85. 22
      test/cpp/end2end/end2end_test.cc
  86. 20
      test/cpp/end2end/filter_end2end_test.cc
  87. 4
      test/cpp/end2end/generic_end2end_test.cc
  88. 28
      test/cpp/end2end/hybrid_end2end_test.cc
  89. 62
      test/cpp/end2end/mock_test.cc
  90. 2
      test/cpp/end2end/proto_server_reflection_test.cc
  91. 211
      test/cpp/end2end/round_robin_end2end_test.cc
  92. 29
      test/cpp/end2end/server_builder_plugin_test.cc
  93. 11
      test/cpp/end2end/server_crash_test.cc
  94. 6
      test/cpp/end2end/shutdown_test.cc
  95. 10
      test/cpp/end2end/streaming_throughput_test.cc
  96. 12
      test/cpp/end2end/test_service_impl.h
  97. 52
      test/cpp/end2end/thread_stress_test.cc
  98. 18
      test/cpp/grpclb/grpclb_test.cc
  99. 5
      test/cpp/interop/stress_test.cc
  100. 2
      test/cpp/qps/client.h
  101. Some files were not shown because too many files have changed in this diff Show More

27
BUILD

@ -1402,12 +1402,6 @@ cc_library(
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -1455,9 +1449,6 @@ cc_library(
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h", "include/grpc++/impl/codegen/time.h",
"include/grpc/impl/codegen/byte_buffer_reader.h", "include/grpc/impl/codegen/byte_buffer_reader.h",
@ -1554,12 +1545,6 @@ cc_library(
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -1607,9 +1592,6 @@ cc_library(
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h", "include/grpc++/impl/codegen/time.h",
"include/grpc/impl/codegen/byte_buffer_reader.h", "include/grpc/impl/codegen/byte_buffer_reader.h",
@ -1727,12 +1709,6 @@ cc_library(
"include/grpc++/impl/server_builder_plugin.h", "include/grpc++/impl/server_builder_plugin.h",
"include/grpc++/impl/server_initializer.h", "include/grpc++/impl/server_initializer.h",
"include/grpc++/impl/service_type.h", "include/grpc++/impl/service_type.h",
"include/grpc++/impl/sync.h",
"include/grpc++/impl/sync_cxx11.h",
"include/grpc++/impl/sync_no_cxx11.h",
"include/grpc++/impl/thd.h",
"include/grpc++/impl/thd_cxx11.h",
"include/grpc++/impl/thd_no_cxx11.h",
"include/grpc++/resource_quota.h", "include/grpc++/resource_quota.h",
"include/grpc++/security/auth_context.h", "include/grpc++/security/auth_context.h",
"include/grpc++/security/auth_metadata_processor.h", "include/grpc++/security/auth_metadata_processor.h",
@ -1780,9 +1756,6 @@ cc_library(
"include/grpc++/impl/codegen/status_helper.h", "include/grpc++/impl/codegen/status_helper.h",
"include/grpc++/impl/codegen/string_ref.h", "include/grpc++/impl/codegen/string_ref.h",
"include/grpc++/impl/codegen/stub_options.h", "include/grpc++/impl/codegen/stub_options.h",
"include/grpc++/impl/codegen/sync.h",
"include/grpc++/impl/codegen/sync_cxx11.h",
"include/grpc++/impl/codegen/sync_no_cxx11.h",
"include/grpc++/impl/codegen/sync_stream.h", "include/grpc++/impl/codegen/sync_stream.h",
"include/grpc++/impl/codegen/time.h", "include/grpc++/impl/codegen/time.h",
"include/grpc/impl/codegen/byte_buffer_reader.h", "include/grpc/impl/codegen/byte_buffer_reader.h",

@ -1121,12 +1121,6 @@ foreach(_hdr
include/grpc++/impl/server_builder_plugin.h include/grpc++/impl/server_builder_plugin.h
include/grpc++/impl/server_initializer.h include/grpc++/impl/server_initializer.h
include/grpc++/impl/service_type.h include/grpc++/impl/service_type.h
include/grpc++/impl/sync.h
include/grpc++/impl/sync_cxx11.h
include/grpc++/impl/sync_no_cxx11.h
include/grpc++/impl/thd.h
include/grpc++/impl/thd_cxx11.h
include/grpc++/impl/thd_no_cxx11.h
include/grpc++/resource_quota.h include/grpc++/resource_quota.h
include/grpc++/security/auth_context.h include/grpc++/security/auth_context.h
include/grpc++/security/auth_metadata_processor.h include/grpc++/security/auth_metadata_processor.h
@ -1174,9 +1168,6 @@ foreach(_hdr
include/grpc++/impl/codegen/status_helper.h include/grpc++/impl/codegen/status_helper.h
include/grpc++/impl/codegen/string_ref.h include/grpc++/impl/codegen/string_ref.h
include/grpc++/impl/codegen/stub_options.h include/grpc++/impl/codegen/stub_options.h
include/grpc++/impl/codegen/sync.h
include/grpc++/impl/codegen/sync_cxx11.h
include/grpc++/impl/codegen/sync_no_cxx11.h
include/grpc++/impl/codegen/sync_stream.h include/grpc++/impl/codegen/sync_stream.h
include/grpc++/impl/codegen/time.h include/grpc++/impl/codegen/time.h
include/grpc/impl/codegen/byte_buffer_reader.h include/grpc/impl/codegen/byte_buffer_reader.h
@ -1287,12 +1278,6 @@ foreach(_hdr
include/grpc++/impl/server_builder_plugin.h include/grpc++/impl/server_builder_plugin.h
include/grpc++/impl/server_initializer.h include/grpc++/impl/server_initializer.h
include/grpc++/impl/service_type.h include/grpc++/impl/service_type.h
include/grpc++/impl/sync.h
include/grpc++/impl/sync_cxx11.h
include/grpc++/impl/sync_no_cxx11.h
include/grpc++/impl/thd.h
include/grpc++/impl/thd_cxx11.h
include/grpc++/impl/thd_no_cxx11.h
include/grpc++/resource_quota.h include/grpc++/resource_quota.h
include/grpc++/security/auth_context.h include/grpc++/security/auth_context.h
include/grpc++/security/auth_metadata_processor.h include/grpc++/security/auth_metadata_processor.h
@ -1340,9 +1325,6 @@ foreach(_hdr
include/grpc++/impl/codegen/status_helper.h include/grpc++/impl/codegen/status_helper.h
include/grpc++/impl/codegen/string_ref.h include/grpc++/impl/codegen/string_ref.h
include/grpc++/impl/codegen/stub_options.h include/grpc++/impl/codegen/stub_options.h
include/grpc++/impl/codegen/sync.h
include/grpc++/impl/codegen/sync_cxx11.h
include/grpc++/impl/codegen/sync_no_cxx11.h
include/grpc++/impl/codegen/sync_stream.h include/grpc++/impl/codegen/sync_stream.h
include/grpc++/impl/codegen/time.h include/grpc++/impl/codegen/time.h
include/grpc/impl/codegen/byte_buffer_reader.h include/grpc/impl/codegen/byte_buffer_reader.h
@ -1491,12 +1473,6 @@ foreach(_hdr
include/grpc++/impl/server_builder_plugin.h include/grpc++/impl/server_builder_plugin.h
include/grpc++/impl/server_initializer.h include/grpc++/impl/server_initializer.h
include/grpc++/impl/service_type.h include/grpc++/impl/service_type.h
include/grpc++/impl/sync.h
include/grpc++/impl/sync_cxx11.h
include/grpc++/impl/sync_no_cxx11.h
include/grpc++/impl/thd.h
include/grpc++/impl/thd_cxx11.h
include/grpc++/impl/thd_no_cxx11.h
include/grpc++/resource_quota.h include/grpc++/resource_quota.h
include/grpc++/security/auth_context.h include/grpc++/security/auth_context.h
include/grpc++/security/auth_metadata_processor.h include/grpc++/security/auth_metadata_processor.h
@ -1544,9 +1520,6 @@ foreach(_hdr
include/grpc++/impl/codegen/status_helper.h include/grpc++/impl/codegen/status_helper.h
include/grpc++/impl/codegen/string_ref.h include/grpc++/impl/codegen/string_ref.h
include/grpc++/impl/codegen/stub_options.h include/grpc++/impl/codegen/stub_options.h
include/grpc++/impl/codegen/sync.h
include/grpc++/impl/codegen/sync_cxx11.h
include/grpc++/impl/codegen/sync_no_cxx11.h
include/grpc++/impl/codegen/sync_stream.h include/grpc++/impl/codegen/sync_stream.h
include/grpc++/impl/codegen/time.h include/grpc++/impl/codegen/time.h
include/grpc/impl/codegen/byte_buffer_reader.h include/grpc/impl/codegen/byte_buffer_reader.h

@ -1078,6 +1078,7 @@ qps_openloop_test: $(BINDIR)/$(CONFIG)/qps_openloop_test
qps_worker: $(BINDIR)/$(CONFIG)/qps_worker qps_worker: $(BINDIR)/$(CONFIG)/qps_worker
reconnect_interop_client: $(BINDIR)/$(CONFIG)/reconnect_interop_client reconnect_interop_client: $(BINDIR)/$(CONFIG)/reconnect_interop_client
reconnect_interop_server: $(BINDIR)/$(CONFIG)/reconnect_interop_server reconnect_interop_server: $(BINDIR)/$(CONFIG)/reconnect_interop_server
round_robin_end2end_test: $(BINDIR)/$(CONFIG)/round_robin_end2end_test
secure_auth_context_test: $(BINDIR)/$(CONFIG)/secure_auth_context_test secure_auth_context_test: $(BINDIR)/$(CONFIG)/secure_auth_context_test
secure_sync_unary_ping_pong_test: $(BINDIR)/$(CONFIG)/secure_sync_unary_ping_pong_test secure_sync_unary_ping_pong_test: $(BINDIR)/$(CONFIG)/secure_sync_unary_ping_pong_test
server_builder_plugin_test: $(BINDIR)/$(CONFIG)/server_builder_plugin_test server_builder_plugin_test: $(BINDIR)/$(CONFIG)/server_builder_plugin_test
@ -1458,6 +1459,7 @@ buildtests_cxx: privatelibs_cxx \
$(BINDIR)/$(CONFIG)/qps_worker \ $(BINDIR)/$(CONFIG)/qps_worker \
$(BINDIR)/$(CONFIG)/reconnect_interop_client \ $(BINDIR)/$(CONFIG)/reconnect_interop_client \
$(BINDIR)/$(CONFIG)/reconnect_interop_server \ $(BINDIR)/$(CONFIG)/reconnect_interop_server \
$(BINDIR)/$(CONFIG)/round_robin_end2end_test \
$(BINDIR)/$(CONFIG)/secure_auth_context_test \ $(BINDIR)/$(CONFIG)/secure_auth_context_test \
$(BINDIR)/$(CONFIG)/secure_sync_unary_ping_pong_test \ $(BINDIR)/$(CONFIG)/secure_sync_unary_ping_pong_test \
$(BINDIR)/$(CONFIG)/server_builder_plugin_test \ $(BINDIR)/$(CONFIG)/server_builder_plugin_test \
@ -1549,6 +1551,7 @@ buildtests_cxx: privatelibs_cxx \
$(BINDIR)/$(CONFIG)/qps_worker \ $(BINDIR)/$(CONFIG)/qps_worker \
$(BINDIR)/$(CONFIG)/reconnect_interop_client \ $(BINDIR)/$(CONFIG)/reconnect_interop_client \
$(BINDIR)/$(CONFIG)/reconnect_interop_server \ $(BINDIR)/$(CONFIG)/reconnect_interop_server \
$(BINDIR)/$(CONFIG)/round_robin_end2end_test \
$(BINDIR)/$(CONFIG)/secure_auth_context_test \ $(BINDIR)/$(CONFIG)/secure_auth_context_test \
$(BINDIR)/$(CONFIG)/secure_sync_unary_ping_pong_test \ $(BINDIR)/$(CONFIG)/secure_sync_unary_ping_pong_test \
$(BINDIR)/$(CONFIG)/server_builder_plugin_test \ $(BINDIR)/$(CONFIG)/server_builder_plugin_test \
@ -1862,6 +1865,8 @@ test_cxx: buildtests_cxx
$(Q) $(BINDIR)/$(CONFIG)/proto_server_reflection_test || ( echo test proto_server_reflection_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/proto_server_reflection_test || ( echo test proto_server_reflection_test failed ; exit 1 )
$(E) "[RUN] Testing qps_openloop_test" $(E) "[RUN] Testing qps_openloop_test"
$(Q) $(BINDIR)/$(CONFIG)/qps_openloop_test || ( echo test qps_openloop_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/qps_openloop_test || ( echo test qps_openloop_test failed ; exit 1 )
$(E) "[RUN] Testing round_robin_end2end_test"
$(Q) $(BINDIR)/$(CONFIG)/round_robin_end2end_test || ( echo test round_robin_end2end_test failed ; exit 1 )
$(E) "[RUN] Testing secure_auth_context_test" $(E) "[RUN] Testing secure_auth_context_test"
$(Q) $(BINDIR)/$(CONFIG)/secure_auth_context_test || ( echo test secure_auth_context_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/secure_auth_context_test || ( echo test secure_auth_context_test failed ; exit 1 )
$(E) "[RUN] Testing secure_sync_unary_ping_pong_test" $(E) "[RUN] Testing secure_sync_unary_ping_pong_test"
@ -3756,12 +3761,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -3809,9 +3808,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \
@ -3951,12 +3947,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -4004,9 +3994,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \
@ -4352,9 +4339,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \
@ -4485,12 +4469,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/server_builder_plugin.h \ include/grpc++/impl/server_builder_plugin.h \
include/grpc++/impl/server_initializer.h \ include/grpc++/impl/server_initializer.h \
include/grpc++/impl/service_type.h \ include/grpc++/impl/service_type.h \
include/grpc++/impl/sync.h \
include/grpc++/impl/sync_cxx11.h \
include/grpc++/impl/sync_no_cxx11.h \
include/grpc++/impl/thd.h \
include/grpc++/impl/thd_cxx11.h \
include/grpc++/impl/thd_no_cxx11.h \
include/grpc++/resource_quota.h \ include/grpc++/resource_quota.h \
include/grpc++/security/auth_context.h \ include/grpc++/security/auth_context.h \
include/grpc++/security/auth_metadata_processor.h \ include/grpc++/security/auth_metadata_processor.h \
@ -4538,9 +4516,6 @@ PUBLIC_HEADERS_CXX += \
include/grpc++/impl/codegen/status_helper.h \ include/grpc++/impl/codegen/status_helper.h \
include/grpc++/impl/codegen/string_ref.h \ include/grpc++/impl/codegen/string_ref.h \
include/grpc++/impl/codegen/stub_options.h \ include/grpc++/impl/codegen/stub_options.h \
include/grpc++/impl/codegen/sync.h \
include/grpc++/impl/codegen/sync_cxx11.h \
include/grpc++/impl/codegen/sync_no_cxx11.h \
include/grpc++/impl/codegen/sync_stream.h \ include/grpc++/impl/codegen/sync_stream.h \
include/grpc++/impl/codegen/time.h \ include/grpc++/impl/codegen/time.h \
include/grpc/impl/codegen/byte_buffer_reader.h \ include/grpc/impl/codegen/byte_buffer_reader.h \
@ -13167,6 +13142,49 @@ endif
$(OBJDIR)/$(CONFIG)/test/cpp/interop/reconnect_interop_server.o: $(GENDIR)/src/proto/grpc/testing/empty.pb.cc $(GENDIR)/src/proto/grpc/testing/empty.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/messages.pb.cc $(GENDIR)/src/proto/grpc/testing/messages.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/test.pb.cc $(GENDIR)/src/proto/grpc/testing/test.grpc.pb.cc $(OBJDIR)/$(CONFIG)/test/cpp/interop/reconnect_interop_server.o: $(GENDIR)/src/proto/grpc/testing/empty.pb.cc $(GENDIR)/src/proto/grpc/testing/empty.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/messages.pb.cc $(GENDIR)/src/proto/grpc/testing/messages.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/test.pb.cc $(GENDIR)/src/proto/grpc/testing/test.grpc.pb.cc
ROUND_ROBIN_END2END_TEST_SRC = \
test/cpp/end2end/round_robin_end2end_test.cc \
ROUND_ROBIN_END2END_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(ROUND_ROBIN_END2END_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/round_robin_end2end_test: openssl_dep_error
else
ifeq ($(NO_PROTOBUF),true)
# You can't build the protoc plugins or protobuf-enabled targets if you don't have protobuf 3.0.0+.
$(BINDIR)/$(CONFIG)/round_robin_end2end_test: protobuf_dep_error
else
$(BINDIR)/$(CONFIG)/round_robin_end2end_test: $(PROTOBUF_DEP) $(ROUND_ROBIN_END2END_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
$(E) "[LD] Linking $@"
$(Q) mkdir -p `dirname $@`
$(Q) $(LDXX) $(LDFLAGS) $(ROUND_ROBIN_END2END_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/round_robin_end2end_test
endif
endif
$(OBJDIR)/$(CONFIG)/test/cpp/end2end/round_robin_end2end_test.o: $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
deps_round_robin_end2end_test: $(ROUND_ROBIN_END2END_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(ROUND_ROBIN_END2END_TEST_OBJS:.o=.dep)
endif
endif
SECURE_AUTH_CONTEXT_TEST_SRC = \ SECURE_AUTH_CONTEXT_TEST_SRC = \
test/cpp/common/secure_auth_context_test.cc \ test/cpp/common/secure_auth_context_test.cc \

@ -684,8 +684,6 @@ filegroups:
deps: deps:
- gpr - gpr
secure: true secure: true
uses:
- grpc_base
- name: grpc++_base - name: grpc++_base
language: c++ language: c++
public_headers: public_headers:
@ -710,12 +708,6 @@ filegroups:
- include/grpc++/impl/server_builder_plugin.h - include/grpc++/impl/server_builder_plugin.h
- include/grpc++/impl/server_initializer.h - include/grpc++/impl/server_initializer.h
- include/grpc++/impl/service_type.h - include/grpc++/impl/service_type.h
- include/grpc++/impl/sync.h
- include/grpc++/impl/sync_cxx11.h
- include/grpc++/impl/sync_no_cxx11.h
- include/grpc++/impl/thd.h
- include/grpc++/impl/thd_cxx11.h
- include/grpc++/impl/thd_no_cxx11.h
- include/grpc++/resource_quota.h - include/grpc++/resource_quota.h
- include/grpc++/security/auth_context.h - include/grpc++/security/auth_context.h
- include/grpc++/security/auth_metadata_processor.h - include/grpc++/security/auth_metadata_processor.h
@ -802,9 +794,6 @@ filegroups:
- include/grpc++/impl/codegen/status_helper.h - include/grpc++/impl/codegen/status_helper.h
- include/grpc++/impl/codegen/string_ref.h - include/grpc++/impl/codegen/string_ref.h
- include/grpc++/impl/codegen/stub_options.h - include/grpc++/impl/codegen/stub_options.h
- include/grpc++/impl/codegen/sync.h
- include/grpc++/impl/codegen/sync_cxx11.h
- include/grpc++/impl/codegen/sync_no_cxx11.h
- include/grpc++/impl/codegen/sync_stream.h - include/grpc++/impl/codegen/sync_stream.h
- include/grpc++/impl/codegen/time.h - include/grpc++/impl/codegen/time.h
uses: uses:
@ -3355,6 +3344,19 @@ targets:
- gpr_test_util - gpr_test_util
- gpr - gpr
- grpc++_test_config - grpc++_test_config
- name: round_robin_end2end_test
gtest: true
build: test
language: c++
src:
- test/cpp/end2end/round_robin_end2end_test.cc
deps:
- grpc++_test_util
- grpc_test_util
- grpc++
- grpc
- gpr_test_util
- gpr
- name: secure_auth_context_test - name: secure_auth_context_test
gtest: true gtest: true
build: test build: test

@ -1,91 +1,9 @@
GRPC C++ STYLE GUIDE GRPC C++ STYLE GUIDE
===================== =====================
Background The majority of gRPC's C++ requirements are drawn from the [Google C++ style
---------- guide] (https://google.github.io/styleguide/cppguide.html). Additionally,
as in C, layout rules are defined by clang-format, and all code
Here we document style rules for C++ usage in the gRPC C++ bindings
and tests.
General
-------
- The majority of gRPC's C++ requirements are drawn from the [Google C++ style
guide] (https://google.github.io/styleguide/cppguide.html)
- However, gRPC has some additional requirements to maintain
[portability] (#portability)
- As in C, layout rules are defined by clang-format, and all code
should be passed through clang-format. A (docker-based) script to do should be passed through clang-format. A (docker-based) script to do
so is included in [tools/distrib/clang\_format\_code.sh] so is included in [tools/distrib/clang\_format\_code.sh]
(../tools/distrib/clang_format_code.sh). (../tools/distrib/clang_format_code.sh).
<a name="portability"></a>
Portability Restrictions
-------------------
gRPC supports a large number of compilers, ranging from those that are
missing many key C++11 features to those that have quite detailed
analysis. As a result, gRPC compiles with a high level of warnings and
treat all warnings as errors. gRPC also forbids the use of some common
C++11 constructs. Here are some guidelines, to be extended as needed:
- Do not use range-based for. Expressions of the form
```c
for (auto& i: vec) {
// code
}
```
are not allowed and should be replaced with code such as
```c
for (auto it = vec.begin; it != vec.end(); it++) {
auto& i = *it;
// code
}
```
- Do not use lambda of any kind (no capture, explicit capture, or
default capture). Other C++ functional features such as
`std::function` or `std::bind` are allowed
- Do not use brace-list initializers.
- Do not compare a pointer to `nullptr` . This is because gcc 4.4
does not support `nullptr` directly and gRPC implements a subset of
its features in [include/grpc++/impl/codegen/config.h]
(../include/grpc++/impl/codegen/config.h). Instead, pointers should
be checked for validity using their implicit conversion to `bool`.
In other words, use `if (p)` rather than `if (p != nullptr)`
- Do not initialize global/static pointer variables to `nullptr`. Just let
the compiler implicitly initialize them to `nullptr` (which it will
definitely do). The reason is that `nullptr` is an actual object in
our implementation rather than just a constant pointer value, so
static/global constructors will be called in a potentially
undesirable sequence.
- Do not use `final` or `override` as these are not supported by some
compilers. Instead use `GRPC_FINAL` and `GRPC_OVERRIDE` . These
compile down to the traditional C++ forms for compilers that support
them but are just elided if the compiler does not support those features.
- In the [include] (../../../tree/master/include/grpc++) and [src]
(../../../tree/master/src/cpp) directory trees, you should also not
use certain STL objects like `std::mutex`, `std::lock_guard`,
`std::unique_lock`, `std::nullptr`, `std::thread` . Instead, use
`grpc::mutex`, `grpc::lock_guard`, etc., which are gRPC
implementations of the prominent features of these objects that are
not always available. You can use the `std` versions of those in [test]
(../../../tree/master/test/cpp)
- Similarly, in the same directories, do not use `std::chrono` unless
it is guarded by `#ifndef GRPC_CXX0X_NO_CHRONO` . For platforms that
lack`std::chrono,` there is a C-language timer called gpr_timespec that can
be used instead.
- `std::unique_ptr` must be used with extreme care in any kind of
collection. For example `vector<std::unique_ptr>` does not work in
gcc 4.4 if the vector is constructed to its full size at
initialization but does work if elements are added to the vector
using functions like `push_back`. `map` and other pair-based
collections do not work with `unique_ptr` under gcc 4.4. The issue
is that many of these collection implementations assume a copy
constructor
to be available.
- Don't use `std::this_thread` . Use `gpr_sleep_until` for sleeping a thread.
- [Some adjacent character combinations cause problems]
(https://en.wikipedia.org/wiki/Digraphs_and_trigraphs#C). If declaring a
template against some class relative to the global namespace,
`<::name` will be non-portable. Separate the `<` from the `:` and use `< ::name`.

@ -78,7 +78,7 @@ class Alarm : private GrpcLibraryCodegen {
class AlarmEntry : public CompletionQueueTag { class AlarmEntry : public CompletionQueueTag {
public: public:
AlarmEntry(void* tag) : tag_(tag) {} AlarmEntry(void* tag) : tag_(tag) {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
*tag = tag_; *tag = tag_;
return true; return true;
} }

@ -46,16 +46,16 @@ struct grpc_channel;
namespace grpc { namespace grpc {
/// Channels represent a connection to an endpoint. Created by \a CreateChannel. /// Channels represent a connection to an endpoint. Created by \a CreateChannel.
class Channel GRPC_FINAL : public ChannelInterface, class Channel final : public ChannelInterface,
public CallHook, public CallHook,
public std::enable_shared_from_this<Channel>, public std::enable_shared_from_this<Channel>,
private GrpcLibraryCodegen { private GrpcLibraryCodegen {
public: public:
~Channel(); ~Channel();
/// Get the current channel state. If the channel is in IDLE and /// Get the current channel state. If the channel is in IDLE and
/// \a try_to_connect is set to true, try to connect. /// \a try_to_connect is set to true, try to connect.
grpc_connectivity_state GetState(bool try_to_connect) GRPC_OVERRIDE; grpc_connectivity_state GetState(bool try_to_connect) override;
private: private:
template <class InputMessage, class OutputMessage> template <class InputMessage, class OutputMessage>
@ -69,15 +69,15 @@ class Channel GRPC_FINAL : public ChannelInterface,
Channel(const grpc::string& host, grpc_channel* c_channel); Channel(const grpc::string& host, grpc_channel* c_channel);
Call CreateCall(const RpcMethod& method, ClientContext* context, Call CreateCall(const RpcMethod& method, ClientContext* context,
CompletionQueue* cq) GRPC_OVERRIDE; CompletionQueue* cq) override;
void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) GRPC_OVERRIDE; void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override;
void* RegisterMethod(const char* method) GRPC_OVERRIDE; void* RegisterMethod(const char* method) override;
void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline, CompletionQueue* cq, gpr_timespec deadline, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE; void* tag) override;
bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline) GRPC_OVERRIDE; gpr_timespec deadline) override;
const grpc::string host_; const grpc::string host_;
grpc_channel* const c_channel_; // owned grpc_channel* const c_channel_; // owned

@ -48,12 +48,12 @@ namespace reflection {
class ProtoServerReflectionPlugin : public ::grpc::ServerBuilderPlugin { class ProtoServerReflectionPlugin : public ::grpc::ServerBuilderPlugin {
public: public:
ProtoServerReflectionPlugin(); ProtoServerReflectionPlugin();
::grpc::string name() GRPC_OVERRIDE; ::grpc::string name() override;
void InitServer(::grpc::ServerInitializer* si) GRPC_OVERRIDE; void InitServer(::grpc::ServerInitializer* si) override;
void Finish(::grpc::ServerInitializer* si) GRPC_OVERRIDE; void Finish(::grpc::ServerInitializer* si) override;
void ChangeArguments(const ::grpc::string& name, void* value) GRPC_OVERRIDE; void ChangeArguments(const ::grpc::string& name, void* value) override;
bool has_async_methods() const GRPC_OVERRIDE; bool has_async_methods() const override;
bool has_sync_methods() const GRPC_OVERRIDE; bool has_sync_methods() const override;
private: private:
std::shared_ptr<grpc::ProtoServerReflection> reflection_service_; std::shared_ptr<grpc::ProtoServerReflection> reflection_service_;

@ -44,7 +44,7 @@ namespace grpc {
typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer> typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
GenericServerAsyncReaderWriter; GenericServerAsyncReaderWriter;
class GenericServerContext GRPC_FINAL : public ServerContext { class GenericServerContext final : public ServerContext {
public: public:
const grpc::string& method() const { return method_; } const grpc::string& method() const { return method_; }
const grpc::string& host() const { return host_; } const grpc::string& host() const { return host_; }
@ -57,7 +57,7 @@ class GenericServerContext GRPC_FINAL : public ServerContext {
grpc::string host_; grpc::string host_;
}; };
class AsyncGenericService GRPC_FINAL { class AsyncGenericService final {
public: public:
AsyncGenericService() : server_(nullptr) {} AsyncGenericService() : server_(nullptr) {}

@ -45,7 +45,7 @@ typedef ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
// Generic stubs provide a type-unsafe interface to call gRPC methods // Generic stubs provide a type-unsafe interface to call gRPC methods
// by name. // by name.
class GenericStub GRPC_FINAL { class GenericStub final {
public: public:
explicit GenericStub(std::shared_ptr<ChannelInterface> channel) explicit GenericStub(std::shared_ptr<ChannelInterface> channel)
: channel_(channel) {} : channel_(channel) {}

@ -108,7 +108,7 @@ class ClientAsyncReaderInterface : public ClientAsyncStreamingInterface,
public AsyncReaderInterface<R> {}; public AsyncReaderInterface<R> {};
template <class R> template <class R>
class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> { class ClientAsyncReader final : public ClientAsyncReaderInterface<R> {
public: public:
/// Create a stream and write the first request out. /// Create a stream and write the first request out.
template <class W> template <class W>
@ -125,7 +125,7 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> {
call_.PerformOps(&init_ops_); call_.PerformOps(&init_ops_);
} }
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { void ReadInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -133,7 +133,7 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
read_ops_.RecvInitialMetadata(context_); read_ops_.RecvInitialMetadata(context_);
@ -142,7 +142,7 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface<R> {
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Finish(Status* status, void* tag) GRPC_OVERRIDE { void Finish(Status* status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -174,7 +174,7 @@ class ClientAsyncWriterInterface : public ClientAsyncStreamingInterface,
}; };
template <class W> template <class W>
class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface<W> { class ClientAsyncWriter final : public ClientAsyncWriterInterface<W> {
public: public:
template <class R> template <class R>
ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq, ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq,
@ -190,7 +190,7 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface<W> {
call_.PerformOps(&init_ops_); call_.PerformOps(&init_ops_);
} }
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { void ReadInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -198,20 +198,20 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface<W> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
// TODO(ctiller): don't assert // TODO(ctiller): don't assert
GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok()); GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void WritesDone(void* tag) GRPC_OVERRIDE { void WritesDone(void* tag) override {
writes_done_ops_.set_output_tag(tag); writes_done_ops_.set_output_tag(tag);
writes_done_ops_.ClientSendClose(); writes_done_ops_.ClientSendClose();
call_.PerformOps(&writes_done_ops_); call_.PerformOps(&writes_done_ops_);
} }
void Finish(Status* status, void* tag) GRPC_OVERRIDE { void Finish(Status* status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -246,7 +246,7 @@ class ClientAsyncReaderWriterInterface : public ClientAsyncStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ClientAsyncReaderWriter GRPC_FINAL class ClientAsyncReaderWriter final
: public ClientAsyncReaderWriterInterface<W, R> { : public ClientAsyncReaderWriterInterface<W, R> {
public: public:
ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq, ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq,
@ -259,7 +259,7 @@ class ClientAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&init_ops_); call_.PerformOps(&init_ops_);
} }
void ReadInitialMetadata(void* tag) GRPC_OVERRIDE { void ReadInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -267,7 +267,7 @@ class ClientAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
read_ops_.RecvInitialMetadata(context_); read_ops_.RecvInitialMetadata(context_);
@ -276,20 +276,20 @@ class ClientAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
// TODO(ctiller): don't assert // TODO(ctiller): don't assert
GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok()); GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void WritesDone(void* tag) GRPC_OVERRIDE { void WritesDone(void* tag) override {
writes_done_ops_.set_output_tag(tag); writes_done_ops_.set_output_tag(tag);
writes_done_ops_.ClientSendClose(); writes_done_ops_.ClientSendClose();
call_.PerformOps(&writes_done_ops_); call_.PerformOps(&writes_done_ops_);
} }
void Finish(Status* status, void* tag) GRPC_OVERRIDE { void Finish(Status* status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -319,12 +319,12 @@ class ServerAsyncReaderInterface : public ServerAsyncStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> { class ServerAsyncReader final : public ServerAsyncReaderInterface<W, R> {
public: public:
explicit ServerAsyncReader(ServerContext* ctx) explicit ServerAsyncReader(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -337,13 +337,13 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
read_ops_.RecvMessage(msg); read_ops_.RecvMessage(msg);
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Finish(const W& msg, const Status& status, void* tag) GRPC_OVERRIDE { void Finish(const W& msg, const Status& status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_, finish_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -363,7 +363,7 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> {
call_.PerformOps(&finish_ops_); call_.PerformOps(&finish_ops_);
} }
void FinishWithError(const Status& status, void* tag) GRPC_OVERRIDE { void FinishWithError(const Status& status, void* tag) override {
GPR_CODEGEN_ASSERT(!status.ok()); GPR_CODEGEN_ASSERT(!status.ok());
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
@ -379,7 +379,7 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncReaderInterface<W, R> {
} }
private: private:
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;
@ -398,12 +398,12 @@ class ServerAsyncWriterInterface : public ServerAsyncStreamingInterface,
}; };
template <class W> template <class W>
class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> { class ServerAsyncWriter final : public ServerAsyncWriterInterface<W> {
public: public:
explicit ServerAsyncWriter(ServerContext* ctx) explicit ServerAsyncWriter(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -416,7 +416,7 @@ class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> {
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
write_ops_.SendInitialMetadata(ctx_->initial_metadata_, write_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -431,7 +431,7 @@ class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> {
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void Finish(const Status& status, void* tag) GRPC_OVERRIDE { void Finish(const Status& status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_, finish_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -446,7 +446,7 @@ class ServerAsyncWriter GRPC_FINAL : public ServerAsyncWriterInterface<W> {
} }
private: private:
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;
@ -465,13 +465,13 @@ class ServerAsyncReaderWriterInterface : public ServerAsyncStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ServerAsyncReaderWriter GRPC_FINAL class ServerAsyncReaderWriter final
: public ServerAsyncReaderWriterInterface<W, R> { : public ServerAsyncReaderWriterInterface<W, R> {
public: public:
explicit ServerAsyncReaderWriter(ServerContext* ctx) explicit ServerAsyncReaderWriter(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_ops_.set_output_tag(tag); meta_ops_.set_output_tag(tag);
@ -484,13 +484,13 @@ class ServerAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&meta_ops_); call_.PerformOps(&meta_ops_);
} }
void Read(R* msg, void* tag) GRPC_OVERRIDE { void Read(R* msg, void* tag) override {
read_ops_.set_output_tag(tag); read_ops_.set_output_tag(tag);
read_ops_.RecvMessage(msg); read_ops_.RecvMessage(msg);
call_.PerformOps(&read_ops_); call_.PerformOps(&read_ops_);
} }
void Write(const W& msg, void* tag) GRPC_OVERRIDE { void Write(const W& msg, void* tag) override {
write_ops_.set_output_tag(tag); write_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
write_ops_.SendInitialMetadata(ctx_->initial_metadata_, write_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -505,7 +505,7 @@ class ServerAsyncReaderWriter GRPC_FINAL
call_.PerformOps(&write_ops_); call_.PerformOps(&write_ops_);
} }
void Finish(const Status& status, void* tag) GRPC_OVERRIDE { void Finish(const Status& status, void* tag) override {
finish_ops_.set_output_tag(tag); finish_ops_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) { if (!ctx_->sent_initial_metadata_) {
finish_ops_.SendInitialMetadata(ctx_->initial_metadata_, finish_ops_.SendInitialMetadata(ctx_->initial_metadata_,
@ -522,7 +522,7 @@ class ServerAsyncReaderWriter GRPC_FINAL
private: private:
friend class ::grpc::Server; friend class ::grpc::Server;
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;

@ -55,7 +55,7 @@ class ClientAsyncResponseReaderInterface {
}; };
template <class R> template <class R>
class ClientAsyncResponseReader GRPC_FINAL class ClientAsyncResponseReader final
: public ClientAsyncResponseReaderInterface<R> { : public ClientAsyncResponseReaderInterface<R> {
public: public:
template <class W> template <class W>
@ -113,13 +113,12 @@ class ClientAsyncResponseReader GRPC_FINAL
}; };
template <class W> template <class W>
class ServerAsyncResponseWriter GRPC_FINAL class ServerAsyncResponseWriter final : public ServerAsyncStreamingInterface {
: public ServerAsyncStreamingInterface {
public: public:
explicit ServerAsyncResponseWriter(ServerContext* ctx) explicit ServerAsyncResponseWriter(ServerContext* ctx)
: call_(nullptr, nullptr, nullptr), ctx_(ctx) {} : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
void SendInitialMetadata(void* tag) GRPC_OVERRIDE { void SendInitialMetadata(void* tag) override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
meta_buf_.set_output_tag(tag); meta_buf_.set_output_tag(tag);
@ -168,7 +167,7 @@ class ServerAsyncResponseWriter GRPC_FINAL
} }
private: private:
void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; } void BindCall(Call* call) override { call_ = *call; }
Call call_; Call call_;
ServerContext* ctx_; ServerContext* ctx_;

@ -337,16 +337,16 @@ class DeserializeFunc {
}; };
template <class R> template <class R>
class DeserializeFuncType GRPC_FINAL : public DeserializeFunc { class DeserializeFuncType final : public DeserializeFunc {
public: public:
DeserializeFuncType(R* message) : message_(message) {} DeserializeFuncType(R* message) : message_(message) {}
Status Deserialize(grpc_byte_buffer* buf, Status Deserialize(grpc_byte_buffer* buf,
int max_receive_message_size) GRPC_OVERRIDE { int max_receive_message_size) override {
return SerializationTraits<R>::Deserialize(buf, message_, return SerializationTraits<R>::Deserialize(buf, message_,
max_receive_message_size); max_receive_message_size);
} }
~DeserializeFuncType() GRPC_OVERRIDE {} ~DeserializeFuncType() override {}
private: private:
R* message_; // Not a managed pointer because management is external to this R* message_; // Not a managed pointer because management is external to this
@ -603,7 +603,7 @@ class CallOpSet : public CallOpSetInterface,
public Op6 { public Op6 {
public: public:
CallOpSet() : return_tag_(this) {} CallOpSet() : return_tag_(this) {}
void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE { void FillOps(grpc_op* ops, size_t* nops) override {
this->Op1::AddOp(ops, nops); this->Op1::AddOp(ops, nops);
this->Op2::AddOp(ops, nops); this->Op2::AddOp(ops, nops);
this->Op3::AddOp(ops, nops); this->Op3::AddOp(ops, nops);
@ -612,7 +612,7 @@ class CallOpSet : public CallOpSetInterface,
this->Op6::AddOp(ops, nops); this->Op6::AddOp(ops, nops);
} }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
this->Op1::FinishOp(status, max_receive_message_size_); this->Op1::FinishOp(status, max_receive_message_size_);
this->Op2::FinishOp(status, max_receive_message_size_); this->Op2::FinishOp(status, max_receive_message_size_);
this->Op3::FinishOp(status, max_receive_message_size_); this->Op3::FinishOp(status, max_receive_message_size_);
@ -639,14 +639,14 @@ template <class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>,
class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>> class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>>
class SneakyCallOpSet : public CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> { class SneakyCallOpSet : public CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> {
public: public:
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
typedef CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> Base; typedef CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> Base;
return Base::FinalizeResult(tag, status) && false; return Base::FinalizeResult(tag, status) && false;
} }
}; };
// Straightforward wrapping of the C call object // Straightforward wrapping of the C call object
class Call GRPC_FINAL { class Call final {
public: public:
/* call is owned by the caller */ /* call is owned by the caller */
Call(grpc_call* call, CallHook* call_hook, CompletionQueue* cq) Call(grpc_call* call, CallHook* call_hook, CompletionQueue* cq)

@ -51,6 +51,7 @@
#include <map> #include <map>
#include <memory> #include <memory>
#include <mutex>
#include <string> #include <string>
#include <grpc++/impl/codegen/config.h> #include <grpc++/impl/codegen/config.h>
@ -59,7 +60,6 @@
#include <grpc++/impl/codegen/security/auth_context.h> #include <grpc++/impl/codegen/security/auth_context.h>
#include <grpc++/impl/codegen/status.h> #include <grpc++/impl/codegen/status.h>
#include <grpc++/impl/codegen/string_ref.h> #include <grpc++/impl/codegen/string_ref.h>
#include <grpc++/impl/codegen/sync.h>
#include <grpc++/impl/codegen/time.h> #include <grpc++/impl/codegen/time.h>
#include <grpc/impl/codegen/compression_types.h> #include <grpc/impl/codegen/compression_types.h>
#include <grpc/impl/codegen/propagation_bits.h> #include <grpc/impl/codegen/propagation_bits.h>
@ -235,12 +235,10 @@ class ClientContext {
/// DEPRECATED: Use set_wait_for_ready() instead. /// DEPRECATED: Use set_wait_for_ready() instead.
void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); } void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); }
#ifndef GRPC_CXX0X_NO_CHRONO
/// Return the deadline for the client call. /// Return the deadline for the client call.
std::chrono::system_clock::time_point deadline() const { std::chrono::system_clock::time_point deadline() const {
return Timespec2Timepoint(deadline_); return Timespec2Timepoint(deadline_);
} }
#endif // !GRPC_CXX0X_NO_CHRONO
/// Return a \a gpr_timespec representation of the client call's deadline. /// Return a \a gpr_timespec representation of the client call's deadline.
gpr_timespec raw_deadline() const { return deadline_; } gpr_timespec raw_deadline() const { return deadline_; }
@ -368,7 +366,7 @@ class ClientContext {
bool idempotent_; bool idempotent_;
bool cacheable_; bool cacheable_;
std::shared_ptr<Channel> channel_; std::shared_ptr<Channel> channel_;
grpc::mutex mu_; std::mutex mu_;
grpc_call* call_; grpc_call* call_;
bool call_canceled_; bool call_canceled_;
gpr_timespec deadline_; gpr_timespec deadline_;

@ -34,80 +34,6 @@
#ifndef GRPCXX_IMPL_CODEGEN_CONFIG_H #ifndef GRPCXX_IMPL_CODEGEN_CONFIG_H
#define GRPCXX_IMPL_CODEGEN_CONFIG_H #define GRPCXX_IMPL_CODEGEN_CONFIG_H
#if !defined(GRPC_NO_AUTODETECT_PLATFORM)
#ifdef _MSC_VER
// Visual Studio 2010 is 1600.
#if _MSC_VER < 1600
#error "gRPC is only supported with Visual Studio starting at 2010"
// Visual Studio 2013 is 1800.
#elif _MSC_VER < 1800
#define GRPC_CXX0X_NO_FINAL 1
#define GRPC_CXX0X_NO_OVERRIDE 1
#define GRPC_CXX0X_NO_CHRONO 1
#define GRPC_CXX0X_NO_THREAD 1
#endif
#endif // Visual Studio
#ifndef __clang__
#ifdef __GNUC__
// nullptr was added in gcc 4.6
#if (__GNUC__ * 100 + __GNUC_MINOR__ < 406)
#define GRPC_CXX0X_NO_NULLPTR 1
#define GRPC_CXX0X_LIMITED_TOSTRING 1
#endif
// final and override were added in gcc 4.7
#if (__GNUC__ * 100 + __GNUC_MINOR__ < 407)
#define GRPC_CXX0X_NO_FINAL 1
#define GRPC_CXX0X_NO_OVERRIDE 1
#endif
#endif
#endif
#endif
#ifdef GRPC_CXX0X_NO_FINAL
#define GRPC_FINAL
#else
#define GRPC_FINAL final
#endif
#ifdef GRPC_CXX0X_NO_OVERRIDE
#define GRPC_OVERRIDE
#else
#define GRPC_OVERRIDE override
#endif
#ifdef GRPC_CXX0X_NO_NULLPTR
#include <functional>
#include <memory>
namespace grpc {
const class {
public:
template <class T>
operator T *() const {
return static_cast<T *>(0);
}
template <class T>
operator std::unique_ptr<T>() const {
return std::unique_ptr<T>(static_cast<T *>(0));
}
template <class T>
operator std::shared_ptr<T>() const {
return std::shared_ptr<T>(static_cast<T *>(0));
}
operator bool() const { return false; }
template <class F>
operator std::function<F>() const {
return std::function<F>();
}
private:
void operator&() const = delete;
} nullptr = {};
}
#endif
#ifndef GRPC_CUSTOM_STRING #ifndef GRPC_CUSTOM_STRING
#include <string> #include <string>
#define GRPC_CUSTOM_STRING std::string #define GRPC_CUSTOM_STRING std::string
@ -117,16 +43,7 @@ namespace grpc {
typedef GRPC_CUSTOM_STRING string; typedef GRPC_CUSTOM_STRING string;
#ifdef GRPC_CXX0X_LIMITED_TOSTRING
inline grpc::string to_string(const int x) {
return std::to_string(static_cast<const long long int>(x));
}
inline grpc::string to_string(const unsigned int x) {
return std::to_string(static_cast<const long long unsigned int>(x));
}
#else
using std::to_string; using std::to_string;
#endif
} // namespace grpc } // namespace grpc

@ -45,56 +45,53 @@ namespace grpc {
/// Implementation of the core codegen interface. /// Implementation of the core codegen interface.
class CoreCodegen : public CoreCodegenInterface { class CoreCodegen : public CoreCodegenInterface {
private: private:
grpc_completion_queue* grpc_completion_queue_create(void* reserved) grpc_completion_queue* grpc_completion_queue_create(void* reserved) override;
GRPC_OVERRIDE; void grpc_completion_queue_destroy(grpc_completion_queue* cq) override;
void grpc_completion_queue_destroy(grpc_completion_queue* cq) GRPC_OVERRIDE;
grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag, grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
gpr_timespec deadline, gpr_timespec deadline,
void* reserved) GRPC_OVERRIDE; void* reserved) override;
void* gpr_malloc(size_t size) GRPC_OVERRIDE; void* gpr_malloc(size_t size) override;
void gpr_free(void* p) GRPC_OVERRIDE; void gpr_free(void* p) override;
void gpr_mu_init(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_init(gpr_mu* mu) override;
void gpr_mu_destroy(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_destroy(gpr_mu* mu) override;
void gpr_mu_lock(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_lock(gpr_mu* mu) override;
void gpr_mu_unlock(gpr_mu* mu) GRPC_OVERRIDE; void gpr_mu_unlock(gpr_mu* mu) override;
void gpr_cv_init(gpr_cv* cv) GRPC_OVERRIDE; void gpr_cv_init(gpr_cv* cv) override;
void gpr_cv_destroy(gpr_cv* cv) GRPC_OVERRIDE; void gpr_cv_destroy(gpr_cv* cv) override;
int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) override;
gpr_timespec abs_deadline) GRPC_OVERRIDE; void gpr_cv_signal(gpr_cv* cv) override;
void gpr_cv_signal(gpr_cv* cv) GRPC_OVERRIDE; void gpr_cv_broadcast(gpr_cv* cv) override;
void gpr_cv_broadcast(gpr_cv* cv) GRPC_OVERRIDE;
void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) GRPC_OVERRIDE; void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) override;
int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader, int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
grpc_byte_buffer* buffer) GRPC_OVERRIDE; grpc_byte_buffer* buffer) override;
void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader) void grpc_byte_buffer_reader_destroy(
GRPC_OVERRIDE; grpc_byte_buffer_reader* reader) override;
int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader, int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
gpr_slice* slice) GRPC_OVERRIDE; gpr_slice* slice) override;
grpc_byte_buffer* grpc_raw_byte_buffer_create(gpr_slice* slice, grpc_byte_buffer* grpc_raw_byte_buffer_create(gpr_slice* slice,
size_t nslices) GRPC_OVERRIDE; size_t nslices) override;
gpr_slice gpr_slice_malloc(size_t length) GRPC_OVERRIDE; gpr_slice gpr_slice_malloc(size_t length) override;
void gpr_slice_unref(gpr_slice slice) GRPC_OVERRIDE; void gpr_slice_unref(gpr_slice slice) override;
gpr_slice gpr_slice_split_tail(gpr_slice* s, size_t split) GRPC_OVERRIDE; gpr_slice gpr_slice_split_tail(gpr_slice* s, size_t split) override;
void gpr_slice_buffer_add(gpr_slice_buffer* sb, void gpr_slice_buffer_add(gpr_slice_buffer* sb, gpr_slice slice) override;
gpr_slice slice) GRPC_OVERRIDE; void gpr_slice_buffer_pop(gpr_slice_buffer* sb) override;
void gpr_slice_buffer_pop(gpr_slice_buffer* sb) GRPC_OVERRIDE;
void grpc_metadata_array_init(grpc_metadata_array* array) GRPC_OVERRIDE; void grpc_metadata_array_init(grpc_metadata_array* array) override;
void grpc_metadata_array_destroy(grpc_metadata_array* array) GRPC_OVERRIDE; void grpc_metadata_array_destroy(grpc_metadata_array* array) override;
gpr_timespec gpr_inf_future(gpr_clock_type type) GRPC_OVERRIDE; gpr_timespec gpr_inf_future(gpr_clock_type type) override;
gpr_timespec gpr_time_0(gpr_clock_type type) GRPC_OVERRIDE; gpr_timespec gpr_time_0(gpr_clock_type type) override;
virtual const Status& ok() GRPC_OVERRIDE; virtual const Status& ok() override;
virtual const Status& cancelled() GRPC_OVERRIDE; virtual const Status& cancelled() override;
void assert_fail(const char* failed_assertion) GRPC_OVERRIDE; void assert_fail(const char* failed_assertion) override;
}; };
} // namespace grpc } // namespace grpc

@ -1,45 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_IMPL_SYNC_H
#define GRPCXX_IMPL_CODEGEN_IMPL_SYNC_H
#include <grpc++/impl/codegen/config.h>
#ifdef GRPC_CXX0X_NO_THREAD
#include <grpc++/impl/codegen/sync_no_cxx11.h>
#else
#include <grpc++/impl/codegen/sync_cxx11.h>
#endif
#endif // GRPCXX_IMPL_CODEGEN_IMPL_SYNC_H

@ -50,7 +50,7 @@ class RpcMethodHandler : public MethodHandler {
ServiceType* service) ServiceType* service)
: func_(func), service_(service) {} : func_(func), service_(service) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
RequestType req; RequestType req;
Status status = SerializationTraits<RequestType>::Deserialize( Status status = SerializationTraits<RequestType>::Deserialize(
param.request, &req, param.max_receive_message_size); param.request, &req, param.max_receive_message_size);
@ -96,7 +96,7 @@ class ClientStreamingHandler : public MethodHandler {
ServiceType* service) ServiceType* service)
: func_(func), service_(service) {} : func_(func), service_(service) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
ServerReader<RequestType> reader(param.call, param.server_context); ServerReader<RequestType> reader(param.call, param.server_context);
ResponseType rsp; ResponseType rsp;
Status status = func_(service_, param.server_context, &reader, &rsp); Status status = func_(service_, param.server_context, &reader, &rsp);
@ -136,7 +136,7 @@ class ServerStreamingHandler : public MethodHandler {
ServiceType* service) ServiceType* service)
: func_(func), service_(service) {} : func_(func), service_(service) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
RequestType req; RequestType req;
Status status = SerializationTraits<RequestType>::Deserialize( Status status = SerializationTraits<RequestType>::Deserialize(
param.request, &req, param.max_receive_message_size); param.request, &req, param.max_receive_message_size);
@ -180,7 +180,7 @@ class TemplatedBidiStreamingHandler : public MethodHandler {
std::function<Status(ServerContext*, Streamer*)> func) std::function<Status(ServerContext*, Streamer*)> func)
: func_(func), write_needed_(WriteNeeded) {} : func_(func), write_needed_(WriteNeeded) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
Streamer stream(param.call, param.server_context); Streamer stream(param.call, param.server_context);
Status status = func_(param.server_context, &stream); Status status = func_(param.server_context, &stream);
@ -266,7 +266,7 @@ class UnknownMethodHandler : public MethodHandler {
ops->ServerSendStatus(context->trailing_metadata_, status); ops->ServerSendStatus(context->trailing_metadata_, status);
} }
void RunHandler(const HandlerParameter& param) GRPC_FINAL { void RunHandler(const HandlerParameter& param) final {
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops; CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops;
FillOps(param.server_context, &ops); FillOps(param.server_context, &ops);
param.call->PerformOps(&ops); param.call->PerformOps(&ops);

@ -52,7 +52,7 @@ namespace internal {
const int kGrpcBufferWriterMaxBufferLength = 8192; const int kGrpcBufferWriterMaxBufferLength = 8192;
class GrpcBufferWriter GRPC_FINAL class GrpcBufferWriter final
: public ::grpc::protobuf::io::ZeroCopyOutputStream { : public ::grpc::protobuf::io::ZeroCopyOutputStream {
public: public:
explicit GrpcBufferWriter(grpc_byte_buffer** bp, int block_size) explicit GrpcBufferWriter(grpc_byte_buffer** bp, int block_size)
@ -61,13 +61,13 @@ class GrpcBufferWriter GRPC_FINAL
slice_buffer_ = &(*bp)->data.raw.slice_buffer; slice_buffer_ = &(*bp)->data.raw.slice_buffer;
} }
~GrpcBufferWriter() GRPC_OVERRIDE { ~GrpcBufferWriter() override {
if (have_backup_) { if (have_backup_) {
g_core_codegen_interface->gpr_slice_unref(backup_slice_); g_core_codegen_interface->gpr_slice_unref(backup_slice_);
} }
} }
bool Next(void** data, int* size) GRPC_OVERRIDE { bool Next(void** data, int* size) override {
if (have_backup_) { if (have_backup_) {
slice_ = backup_slice_; slice_ = backup_slice_;
have_backup_ = false; have_backup_ = false;
@ -82,7 +82,7 @@ class GrpcBufferWriter GRPC_FINAL
return true; return true;
} }
void BackUp(int count) GRPC_OVERRIDE { void BackUp(int count) override {
g_core_codegen_interface->gpr_slice_buffer_pop(slice_buffer_); g_core_codegen_interface->gpr_slice_buffer_pop(slice_buffer_);
if (count == block_size_) { if (count == block_size_) {
backup_slice_ = slice_; backup_slice_ = slice_;
@ -95,7 +95,7 @@ class GrpcBufferWriter GRPC_FINAL
byte_count_ -= count; byte_count_ -= count;
} }
grpc::protobuf::int64 ByteCount() const GRPC_OVERRIDE { return byte_count_; } grpc::protobuf::int64 ByteCount() const override { return byte_count_; }
private: private:
const int block_size_; const int block_size_;
@ -106,7 +106,7 @@ class GrpcBufferWriter GRPC_FINAL
gpr_slice slice_; gpr_slice slice_;
}; };
class GrpcBufferReader GRPC_FINAL class GrpcBufferReader final
: public ::grpc::protobuf::io::ZeroCopyInputStream { : public ::grpc::protobuf::io::ZeroCopyInputStream {
public: public:
explicit GrpcBufferReader(grpc_byte_buffer* buffer) explicit GrpcBufferReader(grpc_byte_buffer* buffer)
@ -117,11 +117,11 @@ class GrpcBufferReader GRPC_FINAL
"Couldn't initialize byte buffer reader"); "Couldn't initialize byte buffer reader");
} }
} }
~GrpcBufferReader() GRPC_OVERRIDE { ~GrpcBufferReader() override {
g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_); g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_);
} }
bool Next(const void** data, int* size) GRPC_OVERRIDE { bool Next(const void** data, int* size) override {
if (!status_.ok()) { if (!status_.ok()) {
return false; return false;
} }
@ -147,9 +147,9 @@ class GrpcBufferReader GRPC_FINAL
Status status() const { return status_; } Status status() const { return status_; }
void BackUp(int count) GRPC_OVERRIDE { backup_count_ = count; } void BackUp(int count) override { backup_count_ = count; }
bool Skip(int count) GRPC_OVERRIDE { bool Skip(int count) override {
const void* data; const void* data;
int size; int size;
while (Next(&data, &size)) { while (Next(&data, &size)) {
@ -164,7 +164,7 @@ class GrpcBufferReader GRPC_FINAL
return false; return false;
} }
grpc::protobuf::int64 ByteCount() const GRPC_OVERRIDE { grpc::protobuf::int64 ByteCount() const override {
return byte_count_ - backup_count_; return byte_count_ - backup_count_;
} }

@ -94,11 +94,9 @@ class ServerContext {
ServerContext(); // for async calls ServerContext(); // for async calls
~ServerContext(); ~ServerContext();
#ifndef GRPC_CXX0X_NO_CHRONO
std::chrono::system_clock::time_point deadline() const { std::chrono::system_clock::time_point deadline() const {
return Timespec2Timepoint(deadline_); return Timespec2Timepoint(deadline_);
} }
#endif // !GRPC_CXX0X_NO_CHRONO
gpr_timespec raw_deadline() const { return deadline_; } gpr_timespec raw_deadline() const { return deadline_; }

@ -142,7 +142,7 @@ class ServerInterface : public CallHook {
bool delete_on_finalize); bool delete_on_finalize);
virtual ~BaseAsyncRequest() {} virtual ~BaseAsyncRequest() {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
protected: protected:
ServerInterface* const server_; ServerInterface* const server_;
@ -168,7 +168,7 @@ class ServerInterface : public CallHook {
ServerCompletionQueue* notification_cq); ServerCompletionQueue* notification_cq);
}; };
class NoPayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { class NoPayloadAsyncRequest final : public RegisteredAsyncRequest {
public: public:
NoPayloadAsyncRequest(void* registered_method, ServerInterface* server, NoPayloadAsyncRequest(void* registered_method, ServerInterface* server,
ServerContext* context, ServerContext* context,
@ -183,7 +183,7 @@ class ServerInterface : public CallHook {
}; };
template <class Message> template <class Message>
class PayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { class PayloadAsyncRequest final : public RegisteredAsyncRequest {
public: public:
PayloadAsyncRequest(void* registered_method, ServerInterface* server, PayloadAsyncRequest(void* registered_method, ServerInterface* server,
ServerContext* context, ServerContext* context,
@ -196,7 +196,7 @@ class ServerInterface : public CallHook {
IssueRequest(registered_method, &payload_, notification_cq); IssueRequest(registered_method, &payload_, notification_cq);
} }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
bool serialization_status = bool serialization_status =
*status && payload_ && *status && payload_ &&
SerializationTraits<Message>::Deserialize( SerializationTraits<Message>::Deserialize(
@ -220,7 +220,7 @@ class ServerInterface : public CallHook {
ServerCompletionQueue* notification_cq, void* tag, ServerCompletionQueue* notification_cq, void* tag,
bool delete_on_finalize); bool delete_on_finalize);
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
private: private:
grpc_call_details call_details_; grpc_call_details call_details_;

@ -1,45 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_H
#define GRPCXX_IMPL_CODEGEN_SYNC_H
#include <grpc++/impl/codegen/config.h>
#ifdef GRPC_CXX0X_NO_THREAD
#include <grpc++/impl/codegen/sync_no_cxx11.h>
#else
#include <grpc++/impl/codegen/sync_cxx11.h>
#endif
#endif // GRPCXX_IMPL_CODEGEN_SYNC_H

@ -1,49 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H
#define GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H
#include <condition_variable>
#include <mutex>
namespace grpc {
using std::condition_variable;
using std::mutex;
using std::lock_guard;
using std::unique_lock;
} // namespace grpc
#endif // GRPCXX_IMPL_CODEGEN_SYNC_CXX11_H

@ -1,111 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H
#define GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H
#include <grpc++/impl/codegen/core_codegen_interface.h>
namespace grpc {
extern CoreCodegenInterface *g_core_codegen_interface;
template <class mutex>
class lock_guard;
class condition_variable;
class mutex {
public:
mutex() { g_core_codegen_interface->gpr_mu_init(&mu_); }
~mutex() { g_core_codegen_interface->gpr_mu_destroy(&mu_); }
private:
::gpr_mu mu_;
template <class mutex>
friend class lock_guard;
friend class condition_variable;
};
template <class mutex>
class lock_guard {
public:
lock_guard(mutex &mu) : mu_(mu), locked(true) {
g_core_codegen_interface->gpr_mu_lock(&mu.mu_);
}
~lock_guard() { unlock_internal(); }
protected:
void lock_internal() {
if (!locked) g_core_codegen_interface->gpr_mu_lock(&mu_.mu_);
locked = true;
}
void unlock_internal() {
if (locked) g_core_codegen_interface->gpr_mu_unlock(&mu_.mu_);
locked = false;
}
private:
mutex &mu_;
bool locked;
friend class condition_variable;
};
template <class mutex>
class unique_lock : public lock_guard<mutex> {
public:
unique_lock(mutex &mu) : lock_guard<mutex>(mu) {}
void lock() { this->lock_internal(); }
void unlock() { this->unlock_internal(); }
};
class condition_variable {
public:
condition_variable() { g_core_codegen_interface->gpr_cv_init(&cv_); }
~condition_variable() { g_core_codegen_interface->gpr_cv_destroy(&cv_); }
void wait(lock_guard<mutex> &mu) {
mu.locked = false;
g_core_codegen_interface->gpr_cv_wait(
&cv_, &mu.mu_.mu_,
g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME));
mu.locked = true;
}
void notify_one() { g_core_codegen_interface->gpr_cv_signal(&cv_); }
void notify_all() { g_core_codegen_interface->gpr_cv_broadcast(&cv_); }
private:
gpr_cv cv_;
};
} // namespace grpc
#endif // GRPCXX_IMPL_CODEGEN_SYNC_NO_CXX11_H

@ -131,7 +131,7 @@ class ClientReaderInterface : public ClientStreamingInterface,
}; };
template <class R> template <class R>
class ClientReader GRPC_FINAL : public ClientReaderInterface<R> { class ClientReader final : public ClientReaderInterface<R> {
public: public:
/// Blocking create a stream and write the first request out. /// Blocking create a stream and write the first request out.
template <class W> template <class W>
@ -150,7 +150,7 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface<R> {
cq_.Pluck(&ops); cq_.Pluck(&ops);
} }
void WaitForInitialMetadata() GRPC_OVERRIDE { void WaitForInitialMetadata() override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
CallOpSet<CallOpRecvInitialMetadata> ops; CallOpSet<CallOpRecvInitialMetadata> ops;
@ -159,12 +159,12 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface<R> {
cq_.Pluck(&ops); /// status ignored cq_.Pluck(&ops); /// status ignored
} }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = call_.max_receive_message_size(); *sz = call_.max_receive_message_size();
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { bool Read(R* msg) override {
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops; CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
ops.RecvInitialMetadata(context_); ops.RecvInitialMetadata(context_);
@ -174,7 +174,7 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface<R> {
return cq_.Pluck(&ops) && ops.got_message; return cq_.Pluck(&ops) && ops.got_message;
} }
Status Finish() GRPC_OVERRIDE { Status Finish() override {
CallOpSet<CallOpClientRecvStatus> ops; CallOpSet<CallOpClientRecvStatus> ops;
Status status; Status status;
ops.ClientRecvStatus(context_, &status); ops.ClientRecvStatus(context_, &status);
@ -230,7 +230,7 @@ class ClientWriter : public ClientWriterInterface<W> {
} }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
CallOpSet<CallOpSendMessage> ops; CallOpSet<CallOpSendMessage> ops;
if (!ops.SendMessage(msg, options).ok()) { if (!ops.SendMessage(msg, options).ok()) {
return false; return false;
@ -239,7 +239,7 @@ class ClientWriter : public ClientWriterInterface<W> {
return cq_.Pluck(&ops); return cq_.Pluck(&ops);
} }
bool WritesDone() GRPC_OVERRIDE { bool WritesDone() override {
CallOpSet<CallOpClientSendClose> ops; CallOpSet<CallOpClientSendClose> ops;
ops.ClientSendClose(); ops.ClientSendClose();
call_.PerformOps(&ops); call_.PerformOps(&ops);
@ -247,7 +247,7 @@ class ClientWriter : public ClientWriterInterface<W> {
} }
/// Read the final response and wait for the final status. /// Read the final response and wait for the final status.
Status Finish() GRPC_OVERRIDE { Status Finish() override {
Status status; Status status;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
finish_ops_.RecvInitialMetadata(context_); finish_ops_.RecvInitialMetadata(context_);
@ -287,7 +287,7 @@ class ClientReaderWriterInterface : public ClientStreamingInterface,
}; };
template <class W, class R> template <class W, class R>
class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> { class ClientReaderWriter final : public ClientReaderWriterInterface<W, R> {
public: public:
/// Blocking create a stream. /// Blocking create a stream.
ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method, ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method,
@ -300,7 +300,7 @@ class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> {
cq_.Pluck(&ops); cq_.Pluck(&ops);
} }
void WaitForInitialMetadata() GRPC_OVERRIDE { void WaitForInitialMetadata() override {
GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_); GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
CallOpSet<CallOpRecvInitialMetadata> ops; CallOpSet<CallOpRecvInitialMetadata> ops;
@ -309,12 +309,12 @@ class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> {
cq_.Pluck(&ops); // status ignored cq_.Pluck(&ops); // status ignored
} }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = call_.max_receive_message_size(); *sz = call_.max_receive_message_size();
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { bool Read(R* msg) override {
CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops; CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>> ops;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
ops.RecvInitialMetadata(context_); ops.RecvInitialMetadata(context_);
@ -325,21 +325,21 @@ class ClientReaderWriter GRPC_FINAL : public ClientReaderWriterInterface<W, R> {
} }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
CallOpSet<CallOpSendMessage> ops; CallOpSet<CallOpSendMessage> ops;
if (!ops.SendMessage(msg, options).ok()) return false; if (!ops.SendMessage(msg, options).ok()) return false;
call_.PerformOps(&ops); call_.PerformOps(&ops);
return cq_.Pluck(&ops); return cq_.Pluck(&ops);
} }
bool WritesDone() GRPC_OVERRIDE { bool WritesDone() override {
CallOpSet<CallOpClientSendClose> ops; CallOpSet<CallOpClientSendClose> ops;
ops.ClientSendClose(); ops.ClientSendClose();
call_.PerformOps(&ops); call_.PerformOps(&ops);
return cq_.Pluck(&ops); return cq_.Pluck(&ops);
} }
Status Finish() GRPC_OVERRIDE { Status Finish() override {
CallOpSet<CallOpRecvInitialMetadata, CallOpClientRecvStatus> ops; CallOpSet<CallOpRecvInitialMetadata, CallOpClientRecvStatus> ops;
if (!context_->initial_metadata_received_) { if (!context_->initial_metadata_received_) {
ops.RecvInitialMetadata(context_); ops.RecvInitialMetadata(context_);
@ -363,11 +363,11 @@ class ServerReaderInterface : public ServerStreamingInterface,
public ReaderInterface<R> {}; public ReaderInterface<R> {};
template <class R> template <class R>
class ServerReader GRPC_FINAL : public ServerReaderInterface<R> { class ServerReader final : public ServerReaderInterface<R> {
public: public:
ServerReader(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} ServerReader(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {}
void SendInitialMetadata() GRPC_OVERRIDE { void SendInitialMetadata() override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
CallOpSet<CallOpSendInitialMetadata> ops; CallOpSet<CallOpSendInitialMetadata> ops;
@ -381,12 +381,12 @@ class ServerReader GRPC_FINAL : public ServerReaderInterface<R> {
call_->cq()->Pluck(&ops); call_->cq()->Pluck(&ops);
} }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = call_->max_receive_message_size(); *sz = call_->max_receive_message_size();
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { bool Read(R* msg) override {
CallOpSet<CallOpRecvMessage<R>> ops; CallOpSet<CallOpRecvMessage<R>> ops;
ops.RecvMessage(msg); ops.RecvMessage(msg);
call_->PerformOps(&ops); call_->PerformOps(&ops);
@ -404,11 +404,11 @@ class ServerWriterInterface : public ServerStreamingInterface,
public WriterInterface<W> {}; public WriterInterface<W> {};
template <class W> template <class W>
class ServerWriter GRPC_FINAL : public ServerWriterInterface<W> { class ServerWriter final : public ServerWriterInterface<W> {
public: public:
ServerWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {} ServerWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {}
void SendInitialMetadata() GRPC_OVERRIDE { void SendInitialMetadata() override {
GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_); GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
CallOpSet<CallOpSendInitialMetadata> ops; CallOpSet<CallOpSendInitialMetadata> ops;
@ -423,7 +423,7 @@ class ServerWriter GRPC_FINAL : public ServerWriterInterface<W> {
} }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> ops; CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage> ops;
if (!ops.SendMessage(msg, options).ok()) { if (!ops.SendMessage(msg, options).ok()) {
return false; return false;
@ -454,7 +454,7 @@ class ServerReaderWriterInterface : public ServerStreamingInterface,
// Actual implementation of bi-directional streaming // Actual implementation of bi-directional streaming
namespace internal { namespace internal {
template <class W, class R> template <class W, class R>
class ServerReaderWriterBody GRPC_FINAL { class ServerReaderWriterBody final {
public: public:
ServerReaderWriterBody(Call* call, ServerContext* ctx) ServerReaderWriterBody(Call* call, ServerContext* ctx)
: call_(call), ctx_(ctx) {} : call_(call), ctx_(ctx) {}
@ -510,20 +510,20 @@ class ServerReaderWriterBody GRPC_FINAL {
// class to represent the user API for a bidirectional streaming call // class to represent the user API for a bidirectional streaming call
template <class W, class R> template <class W, class R>
class ServerReaderWriter GRPC_FINAL : public ServerReaderWriterInterface<W, R> { class ServerReaderWriter final : public ServerReaderWriterInterface<W, R> {
public: public:
ServerReaderWriter(Call* call, ServerContext* ctx) : body_(call, ctx) {} ServerReaderWriter(Call* call, ServerContext* ctx) : body_(call, ctx) {}
void SendInitialMetadata() GRPC_OVERRIDE { body_.SendInitialMetadata(); } void SendInitialMetadata() override { body_.SendInitialMetadata(); }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
return body_.NextMessageSize(sz); return body_.NextMessageSize(sz);
} }
bool Read(R* msg) GRPC_OVERRIDE { return body_.Read(msg); } bool Read(R* msg) override { return body_.Read(msg); }
using WriterInterface<W>::Write; using WriterInterface<W>::Write;
bool Write(const W& msg, const WriteOptions& options) GRPC_OVERRIDE { bool Write(const W& msg, const WriteOptions& options) override {
return body_.Write(msg, options); return body_.Write(msg, options);
} }
@ -541,19 +541,19 @@ class ServerReaderWriter GRPC_FINAL : public ServerReaderWriterInterface<W, R> {
/// must have exactly 1 Read and exactly 1 Write, in that order, to function /// must have exactly 1 Read and exactly 1 Write, in that order, to function
/// correctly. Otherwise, the RPC is in error. /// correctly. Otherwise, the RPC is in error.
template <class RequestType, class ResponseType> template <class RequestType, class ResponseType>
class ServerUnaryStreamer GRPC_FINAL class ServerUnaryStreamer final
: public ServerReaderWriterInterface<ResponseType, RequestType> { : public ServerReaderWriterInterface<ResponseType, RequestType> {
public: public:
ServerUnaryStreamer(Call* call, ServerContext* ctx) ServerUnaryStreamer(Call* call, ServerContext* ctx)
: body_(call, ctx), read_done_(false), write_done_(false) {} : body_(call, ctx), read_done_(false), write_done_(false) {}
void SendInitialMetadata() GRPC_OVERRIDE { body_.SendInitialMetadata(); } void SendInitialMetadata() override { body_.SendInitialMetadata(); }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
return body_.NextMessageSize(sz); return body_.NextMessageSize(sz);
} }
bool Read(RequestType* request) GRPC_OVERRIDE { bool Read(RequestType* request) override {
if (read_done_) { if (read_done_) {
return false; return false;
} }
@ -563,7 +563,7 @@ class ServerUnaryStreamer GRPC_FINAL
using WriterInterface<ResponseType>::Write; using WriterInterface<ResponseType>::Write;
bool Write(const ResponseType& response, bool Write(const ResponseType& response,
const WriteOptions& options) GRPC_OVERRIDE { const WriteOptions& options) override {
if (write_done_ || !read_done_) { if (write_done_ || !read_done_) {
return false; return false;
} }
@ -583,19 +583,19 @@ class ServerUnaryStreamer GRPC_FINAL
/// but the server responds to it as though it were a bidi streaming call that /// but the server responds to it as though it were a bidi streaming call that
/// must first have exactly 1 Read and then any number of Writes. /// must first have exactly 1 Read and then any number of Writes.
template <class RequestType, class ResponseType> template <class RequestType, class ResponseType>
class ServerSplitStreamer GRPC_FINAL class ServerSplitStreamer final
: public ServerReaderWriterInterface<ResponseType, RequestType> { : public ServerReaderWriterInterface<ResponseType, RequestType> {
public: public:
ServerSplitStreamer(Call* call, ServerContext* ctx) ServerSplitStreamer(Call* call, ServerContext* ctx)
: body_(call, ctx), read_done_(false) {} : body_(call, ctx), read_done_(false) {}
void SendInitialMetadata() GRPC_OVERRIDE { body_.SendInitialMetadata(); } void SendInitialMetadata() override { body_.SendInitialMetadata(); }
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
return body_.NextMessageSize(sz); return body_.NextMessageSize(sz);
} }
bool Read(RequestType* request) GRPC_OVERRIDE { bool Read(RequestType* request) override {
if (read_done_) { if (read_done_) {
return false; return false;
} }
@ -605,7 +605,7 @@ class ServerSplitStreamer GRPC_FINAL
using WriterInterface<ResponseType>::Write; using WriterInterface<ResponseType>::Write;
bool Write(const ResponseType& response, bool Write(const ResponseType& response,
const WriteOptions& options) GRPC_OVERRIDE { const WriteOptions& options) override {
return read_done_ && body_.Write(response, options); return read_done_ && body_.Write(response, options);
} }

@ -75,8 +75,6 @@ class TimePoint<gpr_timespec> {
} // namespace grpc } // namespace grpc
#ifndef GRPC_CXX0X_NO_CHRONO
#include <chrono> #include <chrono>
#include <grpc/impl/codegen/grpc_types.h> #include <grpc/impl/codegen/grpc_types.h>
@ -106,6 +104,4 @@ class TimePoint<std::chrono::system_clock::time_point> {
} // namespace grpc } // namespace grpc
#endif // !GRPC_CXX0X_NO_CHRONO
#endif // GRPCXX_IMPL_CODEGEN_TIME_H #endif // GRPCXX_IMPL_CODEGEN_TIME_H

@ -44,17 +44,17 @@
namespace grpc { namespace grpc {
namespace internal { namespace internal {
class GrpcLibrary GRPC_FINAL : public GrpcLibraryInterface { class GrpcLibrary final : public GrpcLibraryInterface {
public: public:
void init() GRPC_OVERRIDE { grpc_init(); } void init() override { grpc_init(); }
void shutdown() GRPC_OVERRIDE { grpc_shutdown(); } void shutdown() override { grpc_shutdown(); }
}; };
static GrpcLibrary g_gli; static GrpcLibrary g_gli;
static CoreCodegen g_core_codegen; static CoreCodegen g_core_codegen;
/// Instantiating this class ensures the proper initialization of gRPC. /// Instantiating this class ensures the proper initialization of gRPC.
class GrpcLibraryInitializer GRPC_FINAL { class GrpcLibraryInitializer final {
public: public:
GrpcLibraryInitializer() { GrpcLibraryInitializer() {
if (grpc::g_glip == nullptr) { if (grpc::g_glip == nullptr) {

@ -1,39 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_SYNC_H
#define GRPCXX_IMPL_SYNC_H
#include <grpc++/impl/codegen/sync.h>
#endif // GRPCXX_IMPL_SYNC_H

@ -1,45 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_THD_H
#define GRPCXX_IMPL_THD_H
#include <grpc++/support/config.h>
#ifdef GRPC_CXX0X_NO_THREAD
#include <grpc++/impl/thd_no_cxx11.h>
#else
#include <grpc++/impl/thd_cxx11.h>
#endif
#endif // GRPCXX_IMPL_THD_H

@ -1,45 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_THD_CXX11_H
#define GRPCXX_IMPL_THD_CXX11_H
#include <thread>
namespace grpc {
using std::thread;
} // namespace grpc
#endif // GRPCXX_IMPL_THD_CXX11_H

@ -1,117 +0,0 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPCXX_IMPL_THD_NO_CXX11_H
#define GRPCXX_IMPL_THD_NO_CXX11_H
#include <grpc/support/thd.h>
namespace grpc {
class thread {
public:
template <class T>
thread(void (T::*fptr)(), T *obj) {
func_ = new thread_function<T>(fptr, obj);
joined_ = false;
start();
}
template <class T, class U>
thread(void (T::*fptr)(U arg), T *obj, U arg) {
func_ = new thread_function_arg<T, U>(fptr, obj, arg);
joined_ = false;
start();
}
~thread() {
if (!joined_) std::terminate();
delete func_;
}
thread(thread &&other)
: func_(other.func_), thd_(other.thd_), joined_(other.joined_) {
other.joined_ = true;
other.func_ = NULL;
}
void join() {
gpr_thd_join(thd_);
joined_ = true;
}
private:
void start() {
gpr_thd_options options = gpr_thd_options_default();
gpr_thd_options_set_joinable(&options);
gpr_thd_new(&thd_, thread_func, (void *)func_, &options);
}
static void thread_func(void *arg) {
thread_function_base *func = (thread_function_base *)arg;
func->call();
}
class thread_function_base {
public:
virtual ~thread_function_base() {}
virtual void call() = 0;
};
template <class T>
class thread_function : public thread_function_base {
public:
thread_function(void (T::*fptr)(), T *obj) : fptr_(fptr), obj_(obj) {}
virtual void call() { (obj_->*fptr_)(); }
private:
void (T::*fptr_)();
T *obj_;
};
template <class T, class U>
class thread_function_arg : public thread_function_base {
public:
thread_function_arg(void (T::*fptr)(U arg), T *obj, U arg)
: fptr_(fptr), obj_(obj), arg_(arg) {}
virtual void call() { (obj_->*fptr_)(arg_); }
private:
void (T::*fptr_)(U arg);
T *obj_;
U arg_;
};
thread_function_base *func_;
gpr_thd_id thd_;
bool joined_;
// Disallow copy and assign.
thread(const thread &);
void operator=(const thread &);
};
} // namespace grpc
#endif // GRPCXX_IMPL_THD_NO_CXX11_H

@ -44,7 +44,7 @@ namespace grpc {
/// A ResourceQuota can be attached to a server (via ServerBuilder), or a client /// A ResourceQuota can be attached to a server (via ServerBuilder), or a client
/// channel (via ChannelArguments). gRPC will attempt to keep memory used by /// channel (via ChannelArguments). gRPC will attempt to keep memory used by
/// all attached entities below the ResourceQuota bound. /// all attached entities below the ResourceQuota bound.
class ResourceQuota GRPC_FINAL { class ResourceQuota final {
public: public:
explicit ResourceQuota(const grpc::string& name); explicit ResourceQuota(const grpc::string& name);
ResourceQuota(); ResourceQuota();

@ -34,8 +34,10 @@
#ifndef GRPCXX_SERVER_H #ifndef GRPCXX_SERVER_H
#define GRPCXX_SERVER_H #define GRPCXX_SERVER_H
#include <condition_variable>
#include <list> #include <list>
#include <memory> #include <memory>
#include <mutex>
#include <vector> #include <vector>
#include <grpc++/completion_queue.h> #include <grpc++/completion_queue.h>
@ -43,7 +45,6 @@
#include <grpc++/impl/codegen/grpc_library.h> #include <grpc++/impl/codegen/grpc_library.h>
#include <grpc++/impl/codegen/server_interface.h> #include <grpc++/impl/codegen/server_interface.h>
#include <grpc++/impl/rpc_service_method.h> #include <grpc++/impl/rpc_service_method.h>
#include <grpc++/impl/sync.h>
#include <grpc++/security/server_credentials.h> #include <grpc++/security/server_credentials.h>
#include <grpc++/support/channel_arguments.h> #include <grpc++/support/channel_arguments.h>
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
@ -64,7 +65,7 @@ class ThreadPoolInterface;
/// Models a gRPC server. /// Models a gRPC server.
/// ///
/// Servers are configured and started via \a grpc::ServerBuilder. /// Servers are configured and started via \a grpc::ServerBuilder.
class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen { class Server final : public ServerInterface, private GrpcLibraryCodegen {
public: public:
~Server(); ~Server();
@ -72,7 +73,7 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// ///
/// \warning The server must be either shutting down or some other thread must /// \warning The server must be either shutting down or some other thread must
/// call \a Shutdown for this function to ever return. /// call \a Shutdown for this function to ever return.
void Wait() GRPC_OVERRIDE; void Wait() override;
/// Global Callbacks /// Global Callbacks
/// ///
@ -143,12 +144,11 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// Register a service. This call does not take ownership of the service. /// Register a service. This call does not take ownership of the service.
/// The service must exist for the lifetime of the Server instance. /// The service must exist for the lifetime of the Server instance.
bool RegisterService(const grpc::string* host, bool RegisterService(const grpc::string* host, Service* service) override;
Service* service) GRPC_OVERRIDE;
/// Register a generic service. This call does not take ownership of the /// Register a generic service. This call does not take ownership of the
/// service. The service must exist for the lifetime of the Server instance. /// service. The service must exist for the lifetime of the Server instance.
void RegisterAsyncGenericService(AsyncGenericService* service) GRPC_OVERRIDE; void RegisterAsyncGenericService(AsyncGenericService* service) override;
/// Tries to bind \a server to the given \a addr. /// Tries to bind \a server to the given \a addr.
/// ///
@ -162,7 +162,7 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// ///
/// \warning It's an error to call this method on an already started server. /// \warning It's an error to call this method on an already started server.
int AddListeningPort(const grpc::string& addr, int AddListeningPort(const grpc::string& addr,
ServerCredentials* creds) GRPC_OVERRIDE; ServerCredentials* creds) override;
/// Start the server. /// Start the server.
/// ///
@ -172,17 +172,17 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
/// \param num_cqs How many completion queues does \a cqs hold. /// \param num_cqs How many completion queues does \a cqs hold.
/// ///
/// \return true on a successful shutdown. /// \return true on a successful shutdown.
bool Start(ServerCompletionQueue** cqs, size_t num_cqs) GRPC_OVERRIDE; bool Start(ServerCompletionQueue** cqs, size_t num_cqs) override;
void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) GRPC_OVERRIDE; void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override;
void ShutdownInternal(gpr_timespec deadline) GRPC_OVERRIDE; void ShutdownInternal(gpr_timespec deadline) override;
int max_receive_message_size() const GRPC_OVERRIDE { int max_receive_message_size() const override {
return max_receive_message_size_; return max_receive_message_size_;
}; };
grpc_server* server() GRPC_OVERRIDE { return server_; }; grpc_server* server() override { return server_; };
ServerInitializer* initializer(); ServerInitializer* initializer();
@ -198,12 +198,12 @@ class Server GRPC_FINAL : public ServerInterface, private GrpcLibraryCodegen {
std::vector<std::unique_ptr<SyncRequestThreadManager>> sync_req_mgrs_; std::vector<std::unique_ptr<SyncRequestThreadManager>> sync_req_mgrs_;
// Sever status // Sever status
grpc::mutex mu_; std::mutex mu_;
bool started_; bool started_;
bool shutdown_; bool shutdown_;
bool shutdown_notified_; // Was notify called on the shutdown_cv_ bool shutdown_notified_; // Was notify called on the shutdown_cv_
grpc::condition_variable shutdown_cv_; std::condition_variable shutdown_cv_;
std::shared_ptr<GlobalCallbacks> global_callbacks_; std::shared_ptr<GlobalCallbacks> global_callbacks_;

@ -47,7 +47,7 @@
namespace grpc { namespace grpc {
/// A sequence of bytes. /// A sequence of bytes.
class ByteBuffer GRPC_FINAL { class ByteBuffer final {
public: public:
/// Constuct an empty buffer. /// Constuct an empty buffer.
ByteBuffer() : buffer_(nullptr) {} ByteBuffer() : buffer_(nullptr) {}

@ -85,6 +85,11 @@ class ChannelArguments {
/// The given buffer pool will be attached to the constructed channel /// The given buffer pool will be attached to the constructed channel
void SetResourceQuota(const ResourceQuota& resource_quota); void SetResourceQuota(const ResourceQuota& resource_quota);
/// Set LB policy name.
/// Note that if the name resolver returns only balancer addresses, the
/// grpclb LB policy will be used, regardless of what is specified here.
void SetLoadBalancingPolicyName(const grpc::string& lb_policy_name);
// Generic channel argument setters. Only for advanced use cases. // Generic channel argument setters. Only for advanced use cases.
/// Set an integer argument \a value under \a key. /// Set an integer argument \a value under \a key.
void SetInt(const grpc::string& key, int value); void SetInt(const grpc::string& key, int value);

@ -44,7 +44,7 @@ namespace grpc {
/// A slice represents a contiguous reference counted array of bytes. /// A slice represents a contiguous reference counted array of bytes.
/// It is cheap to take references to a slice, and it is cheap to create a /// It is cheap to take references to a slice, and it is cheap to create a
/// slice pointing to a subset of another slice. /// slice pointing to a subset of another slice.
class Slice GRPC_FINAL { class Slice final {
public: public:
/// Construct an empty slice. /// Construct an empty slice.
Slice(); Slice();

@ -52,6 +52,7 @@ PYTHON_STEM = os.path.join('src', 'python', 'grpcio')
CORE_INCLUDE = ('include', '.',) CORE_INCLUDE = ('include', '.',)
BORINGSSL_INCLUDE = (os.path.join('third_party', 'boringssl', 'include'),) BORINGSSL_INCLUDE = (os.path.join('third_party', 'boringssl', 'include'),)
ZLIB_INCLUDE = (os.path.join('third_party', 'zlib'),) ZLIB_INCLUDE = (os.path.join('third_party', 'zlib'),)
README = os.path.join(PYTHON_STEM, 'README.rst')
# Ensure we're in the proper directory whether or not we're being used by pip. # Ensure we're in the proper directory whether or not we're being used by pip.
os.chdir(os.path.dirname(os.path.abspath(__file__))) os.chdir(os.path.dirname(os.path.abspath(__file__)))
@ -259,6 +260,7 @@ setuptools.setup(
name='grpcio', name='grpcio',
version=grpc_version.VERSION, version=grpc_version.VERSION,
license=LICENSE, license=LICENSE,
long_description=open(README).read(),
ext_modules=CYTHON_EXTENSION_MODULES, ext_modules=CYTHON_EXTENSION_MODULES,
packages=list(PACKAGES), packages=list(PACKAGES),
package_dir=PACKAGE_DIRECTORIES, package_dir=PACKAGE_DIRECTORIES,

@ -322,7 +322,7 @@ void PrintHeaderClientMethod(Printer *printer, const Method *method,
printer->Print( printer->Print(
*vars, *vars,
"::grpc::Status $Method$(::grpc::ClientContext* context, " "::grpc::Status $Method$(::grpc::ClientContext* context, "
"const $Request$& request, $Response$* response) GRPC_OVERRIDE;\n"); "const $Request$& request, $Response$* response) override;\n");
printer->Print( printer->Print(
*vars, *vars,
"std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> " "std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> "
@ -417,37 +417,34 @@ void PrintHeaderClientMethod(Printer *printer, const Method *method,
"::grpc::ClientAsyncResponseReader< $Response$>* " "::grpc::ClientAsyncResponseReader< $Response$>* "
"Async$Method$Raw(::grpc::ClientContext* context, " "Async$Method$Raw(::grpc::ClientContext* context, "
"const $Request$& request, " "const $Request$& request, "
"::grpc::CompletionQueue* cq) GRPC_OVERRIDE;\n"); "::grpc::CompletionQueue* cq) override;\n");
} else if (method->ClientOnlyStreaming()) { } else if (method->ClientOnlyStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientWriter< $Request$>* $Method$Raw(" "::grpc::ClientWriter< $Request$>* $Method$Raw("
"::grpc::ClientContext* context, $Response$* response) " "::grpc::ClientContext* context, $Response$* response) "
"GRPC_OVERRIDE;\n"); "override;\n");
printer->Print( printer->Print(*vars,
*vars, "::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw("
"::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw(" "::grpc::ClientContext* context, $Response$* response, "
"::grpc::ClientContext* context, $Response$* response, " "::grpc::CompletionQueue* cq, void* tag) override;\n");
"::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n");
} else if (method->ServerOnlyStreaming()) { } else if (method->ServerOnlyStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientReader< $Response$>* $Method$Raw(" "::grpc::ClientReader< $Response$>* $Method$Raw("
"::grpc::ClientContext* context, const $Request$& request)" "::grpc::ClientContext* context, const $Request$& request)"
" GRPC_OVERRIDE;\n"); " override;\n");
printer->Print( printer->Print(
*vars, *vars,
"::grpc::ClientAsyncReader< $Response$>* Async$Method$Raw(" "::grpc::ClientAsyncReader< $Response$>* Async$Method$Raw("
"::grpc::ClientContext* context, const $Request$& request, " "::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n"); "::grpc::CompletionQueue* cq, void* tag) override;\n");
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print( printer->Print(*vars,
*vars, "::grpc::ClientReaderWriter< $Request$, $Response$>* "
"::grpc::ClientReaderWriter< $Request$, $Response$>* " "$Method$Raw(::grpc::ClientContext* context) override;\n");
"$Method$Raw(::grpc::ClientContext* context) GRPC_OVERRIDE;\n"); printer->Print(*vars,
printer->Print( "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
*vars, "Async$Method$Raw(::grpc::ClientContext* context, "
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* " "::grpc::CompletionQueue* cq, void* tag) override;\n");
"Async$Method$Raw(::grpc::ClientContext* context, "
"::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n");
} }
} }
} }
@ -509,7 +506,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
" ::grpc::Service::MarkMethodAsync($Idx$);\n" " ::grpc::Service::MarkMethodAsync($Idx$);\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithAsyncMethod_$Method$() GRPC_OVERRIDE {\n" "~WithAsyncMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
if (method->NoStreaming()) { if (method->NoStreaming()) {
@ -518,7 +515,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -540,7 +537,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReader< $Request$>* reader, " "::grpc::ServerReader< $Request$>* reader, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -561,7 +558,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE " "::grpc::ServerWriter< $Response$>* writer) final override "
"{\n" "{\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -585,7 +582,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReaderWriter< $Response$, $Request$>* stream) " "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
"GRPC_FINAL GRPC_OVERRIDE {\n" "final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -632,7 +629,7 @@ void PrintHeaderServerMethodStreamedUnary(
"std::placeholders::_2)));\n" "std::placeholders::_2)));\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithStreamedUnaryMethod_$Method$() GRPC_OVERRIDE {\n" "~WithStreamedUnaryMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
printer->Print( printer->Print(
@ -640,7 +637,7 @@ void PrintHeaderServerMethodStreamedUnary(
"// disable regular version of this method\n" "// disable regular version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -683,7 +680,7 @@ void PrintHeaderServerMethodSplitStreaming(
"std::placeholders::_2)));\n" "std::placeholders::_2)));\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithSplitStreamingMethod_$Method$() GRPC_OVERRIDE {\n" "~WithSplitStreamingMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
printer->Print( printer->Print(
@ -691,7 +688,7 @@ void PrintHeaderServerMethodSplitStreaming(
"// disable regular version of this method\n" "// disable regular version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE " "::grpc::ServerWriter< $Response$>* writer) final override "
"{\n" "{\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -727,7 +724,7 @@ void PrintHeaderServerMethodGeneric(
" ::grpc::Service::MarkMethodGeneric($Idx$);\n" " ::grpc::Service::MarkMethodGeneric($Idx$);\n"
"}\n"); "}\n");
printer->Print(*vars, printer->Print(*vars,
"~WithGenericMethod_$Method$() GRPC_OVERRIDE {\n" "~WithGenericMethod_$Method$() override {\n"
" BaseClassMustBeDerivedFromService(this);\n" " BaseClassMustBeDerivedFromService(this);\n"
"}\n"); "}\n");
if (method->NoStreaming()) { if (method->NoStreaming()) {
@ -736,7 +733,7 @@ void PrintHeaderServerMethodGeneric(
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -747,7 +744,7 @@ void PrintHeaderServerMethodGeneric(
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReader< $Request$>* reader, " "::grpc::ServerReader< $Request$>* reader, "
"$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n" "$Response$* response) final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -757,7 +754,7 @@ void PrintHeaderServerMethodGeneric(
"// disable synchronous version of this method\n" "// disable synchronous version of this method\n"
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, const $Request$* request, " "::grpc::ServerContext* context, const $Request$* request, "
"::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE " "::grpc::ServerWriter< $Response$>* writer) final override "
"{\n" "{\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@ -769,7 +766,7 @@ void PrintHeaderServerMethodGeneric(
"::grpc::Status $Method$(" "::grpc::Status $Method$("
"::grpc::ServerContext* context, " "::grpc::ServerContext* context, "
"::grpc::ServerReaderWriter< $Response$, $Request$>* stream) " "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
"GRPC_FINAL GRPC_OVERRIDE {\n" "final override {\n"
" abort();\n" " abort();\n"
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n" " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n"); "}\n");
@ -784,7 +781,7 @@ void PrintHeaderService(Printer *printer, const Service *service,
printer->Print(service->GetLeadingComments().c_str()); printer->Print(service->GetLeadingComments().c_str());
printer->Print(*vars, printer->Print(*vars,
"class $Service$ GRPC_FINAL {\n" "class $Service$ final {\n"
" public:\n"); " public:\n");
printer->Indent(); printer->Indent();
@ -810,7 +807,7 @@ void PrintHeaderService(Printer *printer, const Service *service,
printer->Outdent(); printer->Outdent();
printer->Print("};\n"); printer->Print("};\n");
printer->Print( printer->Print(
"class Stub GRPC_FINAL : public StubInterface" "class Stub final : public StubInterface"
" {\n public:\n"); " {\n public:\n");
printer->Indent(); printer->Indent();
printer->Print( printer->Print(

@ -109,10 +109,16 @@ struct grpc_lb_policy_vtable {
/*#define GRPC_LB_POLICY_REFCOUNT_DEBUG*/ /*#define GRPC_LB_POLICY_REFCOUNT_DEBUG*/
#ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG #ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
/* Strong references: the policy will shutdown when they reach zero */
#define GRPC_LB_POLICY_REF(p, r) \ #define GRPC_LB_POLICY_REF(p, r) \
grpc_lb_policy_ref((p), __FILE__, __LINE__, (r)) grpc_lb_policy_ref((p), __FILE__, __LINE__, (r))
#define GRPC_LB_POLICY_UNREF(exec_ctx, p, r) \ #define GRPC_LB_POLICY_UNREF(exec_ctx, p, r) \
grpc_lb_policy_unref((exec_ctx), (p), __FILE__, __LINE__, (r)) grpc_lb_policy_unref((exec_ctx), (p), __FILE__, __LINE__, (r))
/* Weak references: they don't prevent the shutdown of the LB policy. When no
* strong references are left but there are still weak ones, shutdown is called.
* Once the weak reference also reaches zero, the LB policy is destroyed. */
#define GRPC_LB_POLICY_WEAK_REF(p, r) \ #define GRPC_LB_POLICY_WEAK_REF(p, r) \
grpc_lb_policy_weak_ref((p), __FILE__, __LINE__, (r)) grpc_lb_policy_weak_ref((p), __FILE__, __LINE__, (r))
#define GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, p, r) \ #define GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, p, r) \

File diff suppressed because it is too large Load Diff

@ -77,7 +77,7 @@ typedef struct _grpc_lb_v1_Server {
bool has_port; bool has_port;
int32_t port; int32_t port;
bool has_load_balance_token; bool has_load_balance_token;
char load_balance_token[65]; char load_balance_token[50];
bool has_drop_request; bool has_drop_request;
bool drop_request; bool drop_request;
/* @@protoc_insertion_point(struct:grpc_lb_v1_Server) */ /* @@protoc_insertion_point(struct:grpc_lb_v1_Server) */
@ -172,7 +172,7 @@ extern const pb_field_t grpc_lb_v1_Server_fields[5];
#define grpc_lb_v1_LoadBalanceResponse_size (98 + grpc_lb_v1_ServerList_size) #define grpc_lb_v1_LoadBalanceResponse_size (98 + grpc_lb_v1_ServerList_size)
#define grpc_lb_v1_InitialLoadBalanceResponse_size 90 #define grpc_lb_v1_InitialLoadBalanceResponse_size 90
/* grpc_lb_v1_ServerList_size depends on runtime parameters */ /* grpc_lb_v1_ServerList_size depends on runtime parameters */
#define grpc_lb_v1_Server_size 98 #define grpc_lb_v1_Server_size 83
/* Message IDs (where set with "msgid" option) */ /* Message IDs (where set with "msgid" option) */
#ifdef PB_MSGID #ifdef PB_MSGID

@ -120,6 +120,8 @@ typedef struct {
grpc_connectivity_state connectivity_state; grpc_connectivity_state connectivity_state;
/** the subchannel's target user data */ /** the subchannel's target user data */
void *user_data; void *user_data;
/** vtable to operate over \a user_data */
const grpc_lb_user_data_vtable *user_data_vtable;
} subchannel_data; } subchannel_data;
struct round_robin_lb_policy { struct round_robin_lb_policy {
@ -186,9 +188,13 @@ static void advance_last_picked_locked(round_robin_lb_policy *p) {
} }
if (grpc_lb_round_robin_trace) { if (grpc_lb_round_robin_trace) {
gpr_log(GPR_DEBUG, "[READYLIST] ADVANCED LAST PICK. NOW AT NODE %p (SC %p)", gpr_log(GPR_DEBUG,
(void *)p->ready_list_last_pick, "[READYLIST, RR: %p] ADVANCED LAST PICK. NOW AT NODE %p (SC %p, "
(void *)p->ready_list_last_pick->subchannel); "CSC %p)",
(void *)p, (void *)p->ready_list_last_pick,
(void *)p->ready_list_last_pick->subchannel,
(void *)grpc_subchannel_get_connected_subchannel(
p->ready_list_last_pick->subchannel));
} }
} }
@ -255,9 +261,18 @@ static void remove_disconnected_sc_locked(round_robin_lb_policy *p,
static void rr_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) { static void rr_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
round_robin_lb_policy *p = (round_robin_lb_policy *)pol; round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
ready_list *elem; ready_list *elem;
if (grpc_lb_round_robin_trace) {
gpr_log(GPR_DEBUG, "Destroying Round Robin policy at %p", (void *)pol);
}
for (size_t i = 0; i < p->num_subchannels; i++) { for (size_t i = 0; i < p->num_subchannels; i++) {
subchannel_data *sd = p->subchannels[i]; subchannel_data *sd = p->subchannels[i];
GRPC_SUBCHANNEL_UNREF(exec_ctx, sd->subchannel, "round_robin"); GRPC_SUBCHANNEL_UNREF(exec_ctx, sd->subchannel, "round_robin_destroy");
if (sd->user_data != NULL) {
GPR_ASSERT(sd->user_data_vtable != NULL);
sd->user_data_vtable->destroy(sd->user_data);
}
gpr_free(sd); gpr_free(sd);
} }
@ -285,6 +300,9 @@ static void rr_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
size_t i; size_t i;
gpr_mu_lock(&p->mu); gpr_mu_lock(&p->mu);
if (grpc_lb_round_robin_trace) {
gpr_log(GPR_DEBUG, "Shutting down Round Robin policy at %p", (void *)pol);
}
p->shutdown = 1; p->shutdown = 1;
while ((pp = p->pending_picks)) { while ((pp = p->pending_picks)) {
@ -296,7 +314,7 @@ static void rr_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
} }
grpc_connectivity_state_set( grpc_connectivity_state_set(
exec_ctx, &p->state_tracker, GRPC_CHANNEL_SHUTDOWN, exec_ctx, &p->state_tracker, GRPC_CHANNEL_SHUTDOWN,
GRPC_ERROR_CREATE("Channel Shutdown"), "shutdown"); GRPC_ERROR_CREATE("Channel Shutdown"), "rr_shutdown");
for (i = 0; i < p->num_subchannels; i++) { for (i = 0; i < p->num_subchannels; i++) {
subchannel_data *sd = p->subchannels[i]; subchannel_data *sd = p->subchannels[i];
grpc_subchannel_notify_on_state_change(exec_ctx, sd->subchannel, NULL, NULL, grpc_subchannel_notify_on_state_change(exec_ctx, sd->subchannel, NULL, NULL,
@ -395,6 +413,11 @@ static int rr_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
pending_pick *pp; pending_pick *pp;
ready_list *selected; ready_list *selected;
gpr_mu_lock(&p->mu); gpr_mu_lock(&p->mu);
if (grpc_lb_round_robin_trace) {
gpr_log(GPR_INFO, "Round Robin %p trying to pick", (void *)pol);
}
if ((selected = peek_next_connected_locked(p))) { if ((selected = peek_next_connected_locked(p))) {
/* readily available, report right away */ /* readily available, report right away */
*target = GRPC_CONNECTED_SUBCHANNEL_REF( *target = GRPC_CONNECTED_SUBCHANNEL_REF(
@ -435,7 +458,6 @@ static void rr_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg,
subchannel_data *sd = arg; subchannel_data *sd = arg;
round_robin_lb_policy *p = sd->policy; round_robin_lb_policy *p = sd->policy;
pending_pick *pp; pending_pick *pp;
ready_list *selected;
int unref = 0; int unref = 0;
@ -456,12 +478,14 @@ static void rr_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg,
/* at this point we know there's at least one suitable subchannel. Go /* at this point we know there's at least one suitable subchannel. Go
* ahead and pick one and notify the pending suitors in * ahead and pick one and notify the pending suitors in
* p->pending_picks. This preemtively replicates rr_pick()'s actions. */ * p->pending_picks. This preemtively replicates rr_pick()'s actions. */
selected = peek_next_connected_locked(p); ready_list *selected = peek_next_connected_locked(p);
GPR_ASSERT(selected != NULL);
if (p->pending_picks != NULL) { if (p->pending_picks != NULL) {
/* if the selected subchannel is going to be used for the pending /* if the selected subchannel is going to be used for the pending
* picks, update the last picked pointer */ * picks, update the last picked pointer */
advance_last_picked_locked(p); advance_last_picked_locked(p);
} }
while ((pp = p->pending_picks)) { while ((pp = p->pending_picks)) {
p->pending_picks = pp->next; p->pending_picks = pp->next;
@ -653,7 +677,11 @@ static grpc_lb_policy *round_robin_create(grpc_exec_ctx *exec_ctx,
sd->policy = p; sd->policy = p;
sd->index = subchannel_idx; sd->index = subchannel_idx;
sd->subchannel = subchannel; sd->subchannel = subchannel;
sd->user_data = addresses->addresses[i].user_data; sd->user_data_vtable = addresses->user_data_vtable;
if (sd->user_data_vtable != NULL) {
sd->user_data =
sd->user_data_vtable->copy(addresses->addresses[i].user_data);
}
++subchannel_idx; ++subchannel_idx;
grpc_closure_init(&sd->connectivity_changed_closure, grpc_closure_init(&sd->connectivity_changed_closure,
rr_connectivity_changed, sd); rr_connectivity_changed, sd);

@ -190,7 +190,7 @@ static void dns_on_resolved(grpc_exec_ctx *exec_ctx, void *arg,
GPR_ASSERT(!r->have_retry_timer); GPR_ASSERT(!r->have_retry_timer);
r->have_retry_timer = true; r->have_retry_timer = true;
GRPC_RESOLVER_REF(&r->base, "retry-timer"); GRPC_RESOLVER_REF(&r->base, "retry-timer");
if (gpr_time_cmp(timeout, gpr_time_0(timeout.clock_type)) <= 0) { if (gpr_time_cmp(timeout, gpr_time_0(timeout.clock_type)) > 0) {
gpr_log(GPR_DEBUG, "retrying in %" PRId64 ".%09d seconds", timeout.tv_sec, gpr_log(GPR_DEBUG, "retrying in %" PRId64 ".%09d seconds", timeout.tv_sec,
timeout.tv_nsec); timeout.tv_nsec);
} else { } else {

@ -347,7 +347,7 @@ grpc_channel *grpc_secure_channel_create(grpc_channel_credentials *creds,
&exec_ctx, &f->base, target, GRPC_CLIENT_CHANNEL_TYPE_REGULAR, new_args); &exec_ctx, &f->base, target, GRPC_CLIENT_CHANNEL_TYPE_REGULAR, new_args);
// Clean up. // Clean up.
GRPC_SECURITY_CONNECTOR_UNREF(&f->security_connector->base, GRPC_SECURITY_CONNECTOR_UNREF(&f->security_connector->base,
"client_channel_factory_create_channel"); "secure_client_channel_factory_create_channel");
grpc_channel_args_destroy(new_args); grpc_channel_args_destroy(new_args);
grpc_client_channel_factory_unref(&exec_ctx, &f->base); grpc_client_channel_factory_unref(&exec_ctx, &f->base);
grpc_exec_ctx_finish(&exec_ctx); grpc_exec_ctx_finish(&exec_ctx);

@ -50,6 +50,7 @@
#include <grpc/support/useful.h> #include <grpc/support/useful.h>
#include "src/core/ext/transport/chttp2/transport/bin_encoder.h" #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
#include "src/core/ext/transport/chttp2/transport/http2_errors.h"
#include "src/core/lib/profiling/timers.h" #include "src/core/lib/profiling/timers.h"
#include "src/core/lib/support/string.h" #include "src/core/lib/support/string.h"
@ -1578,6 +1579,20 @@ static const maybe_complete_func_type maybe_complete_funcs[] = {
grpc_chttp2_maybe_complete_recv_initial_metadata, grpc_chttp2_maybe_complete_recv_initial_metadata,
grpc_chttp2_maybe_complete_recv_trailing_metadata}; grpc_chttp2_maybe_complete_recv_trailing_metadata};
static void force_client_rst_stream(grpc_exec_ctx *exec_ctx, void *sp,
grpc_error *error) {
grpc_chttp2_stream *s = sp;
grpc_chttp2_transport *t = s->t;
if (!s->write_closed) {
gpr_slice_buffer_add(
&t->qbuf, grpc_chttp2_rst_stream_create(s->id, GRPC_CHTTP2_NO_ERROR,
&s->stats.outgoing));
grpc_chttp2_initiate_write(exec_ctx, t, false, "force_rst_stream");
grpc_chttp2_mark_stream_closed(exec_ctx, t, s, true, true, GRPC_ERROR_NONE);
}
GRPC_CHTTP2_STREAM_UNREF(exec_ctx, s, "final_rst");
}
grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx, grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx,
void *hpack_parser, void *hpack_parser,
grpc_chttp2_transport *t, grpc_chttp2_transport *t,
@ -1613,6 +1628,17 @@ grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx,
s->header_frames_received++; s->header_frames_received++;
} }
if (parser->is_eof) { if (parser->is_eof) {
if (t->is_client && !s->write_closed) {
/* server eof ==> complete closure; we may need to forcefully close
the stream. Wait until the combiner lock is ready to be released
however -- it might be that we receive a RST_STREAM following this
and can avoid the extra write */
GRPC_CHTTP2_STREAM_REF(s, "final_rst");
grpc_combiner_execute_finally(
exec_ctx, t->combiner,
grpc_closure_create(force_client_rst_stream, s), GRPC_ERROR_NONE,
false);
}
grpc_chttp2_mark_stream_closed(exec_ctx, t, s, true, false, grpc_chttp2_mark_stream_closed(exec_ctx, t, s, true, false,
GRPC_ERROR_NONE); GRPC_ERROR_NONE);
} }

@ -715,3 +715,10 @@ void grpc_resource_user_alloc_slices(
grpc_resource_user_alloc(exec_ctx, slice_allocator->resource_user, grpc_resource_user_alloc(exec_ctx, slice_allocator->resource_user,
count * length, &slice_allocator->on_allocated); count * length, &slice_allocator->on_allocated);
} }
gpr_slice grpc_resource_user_slice_malloc(grpc_exec_ctx *exec_ctx,
grpc_resource_user *resource_user,
size_t size) {
grpc_resource_user_alloc(exec_ctx, resource_user, size, NULL);
return ru_slice_create(resource_user, size);
}

@ -221,4 +221,9 @@ void grpc_resource_user_alloc_slices(
grpc_resource_user_slice_allocator *slice_allocator, size_t length, grpc_resource_user_slice_allocator *slice_allocator, size_t length,
size_t count, gpr_slice_buffer *dest); size_t count, gpr_slice_buffer *dest);
/* Allocate one slice of length \a size synchronously. */
gpr_slice grpc_resource_user_slice_malloc(grpc_exec_ctx *exec_ctx,
grpc_resource_user *resource_user,
size_t size);
#endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */ #endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */

@ -54,9 +54,12 @@ typedef struct grpc_uv_tcp_connect {
grpc_endpoint **endpoint; grpc_endpoint **endpoint;
int refs; int refs;
char *addr_name; char *addr_name;
grpc_resource_quota *resource_quota;
} grpc_uv_tcp_connect; } grpc_uv_tcp_connect;
static void uv_tcp_connect_cleanup(grpc_uv_tcp_connect *connect) { static void uv_tcp_connect_cleanup(grpc_exec_ctx *exec_ctx,
grpc_uv_tcp_connect *connect) {
grpc_resource_quota_internal_unref(exec_ctx, connect->resource_quota);
gpr_free(connect); gpr_free(connect);
} }
@ -74,7 +77,7 @@ static void uv_tc_on_alarm(grpc_exec_ctx *exec_ctx, void *acp,
} }
done = (--connect->refs == 0); done = (--connect->refs == 0);
if (done) { if (done) {
uv_tcp_connect_cleanup(connect); uv_tcp_connect_cleanup(exec_ctx, connect);
} }
} }
@ -86,8 +89,8 @@ static void uv_tc_on_connect(uv_connect_t *req, int status) {
grpc_closure *closure = connect->closure; grpc_closure *closure = connect->closure;
grpc_timer_cancel(&exec_ctx, &connect->alarm); grpc_timer_cancel(&exec_ctx, &connect->alarm);
if (status == 0) { if (status == 0) {
*connect->endpoint = *connect->endpoint = grpc_tcp_create(
grpc_tcp_create(connect->tcp_handle, connect->addr_name); connect->tcp_handle, connect->resource_quota, connect->addr_name);
} else { } else {
error = GRPC_ERROR_CREATE("Failed to connect to remote host"); error = GRPC_ERROR_CREATE("Failed to connect to remote host");
error = grpc_error_set_int(error, GRPC_ERROR_INT_ERRNO, -status); error = grpc_error_set_int(error, GRPC_ERROR_INT_ERRNO, -status);
@ -105,7 +108,7 @@ static void uv_tc_on_connect(uv_connect_t *req, int status) {
} }
done = (--connect->refs == 0); done = (--connect->refs == 0);
if (done) { if (done) {
uv_tcp_connect_cleanup(connect); uv_tcp_connect_cleanup(&exec_ctx, connect);
} }
grpc_exec_ctx_sched(&exec_ctx, closure, error, NULL); grpc_exec_ctx_sched(&exec_ctx, closure, error, NULL);
grpc_exec_ctx_finish(&exec_ctx); grpc_exec_ctx_finish(&exec_ctx);
@ -114,16 +117,31 @@ static void uv_tc_on_connect(uv_connect_t *req, int status) {
static void tcp_client_connect_impl(grpc_exec_ctx *exec_ctx, static void tcp_client_connect_impl(grpc_exec_ctx *exec_ctx,
grpc_closure *closure, grpc_endpoint **ep, grpc_closure *closure, grpc_endpoint **ep,
grpc_pollset_set *interested_parties, grpc_pollset_set *interested_parties,
const grpc_channel_args *channel_args,
const grpc_resolved_address *resolved_addr, const grpc_resolved_address *resolved_addr,
gpr_timespec deadline) { gpr_timespec deadline) {
grpc_uv_tcp_connect *connect; grpc_uv_tcp_connect *connect;
grpc_resource_quota *resource_quota = grpc_resource_quota_create(NULL);
(void)channel_args;
(void)interested_parties; (void)interested_parties;
if (channel_args != NULL) {
for (size_t i = 0; i < channel_args->num_args; i++) {
if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
grpc_resource_quota_internal_unref(exec_ctx, resource_quota);
resource_quota = grpc_resource_quota_internal_ref(
channel_args->args[i].value.pointer.p);
}
}
}
connect = gpr_malloc(sizeof(grpc_uv_tcp_connect)); connect = gpr_malloc(sizeof(grpc_uv_tcp_connect));
memset(connect, 0, sizeof(grpc_uv_tcp_connect)); memset(connect, 0, sizeof(grpc_uv_tcp_connect));
connect->closure = closure; connect->closure = closure;
connect->endpoint = ep; connect->endpoint = ep;
connect->tcp_handle = gpr_malloc(sizeof(uv_tcp_t)); connect->tcp_handle = gpr_malloc(sizeof(uv_tcp_t));
connect->addr_name = grpc_sockaddr_to_uri(resolved_addr); connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
connect->resource_quota = resource_quota;
uv_tcp_init(uv_default_loop(), connect->tcp_handle); uv_tcp_init(uv_default_loop(), connect->tcp_handle);
connect->connect_req.data = connect; connect->connect_req.data = connect;
// TODO(murgatroid99): figure out what the return value here means // TODO(murgatroid99): figure out what the return value here means
@ -138,16 +156,18 @@ static void tcp_client_connect_impl(grpc_exec_ctx *exec_ctx,
// overridden by api_fuzzer.c // overridden by api_fuzzer.c
void (*grpc_tcp_client_connect_impl)( void (*grpc_tcp_client_connect_impl)(
grpc_exec_ctx *exec_ctx, grpc_closure *closure, grpc_endpoint **ep, grpc_exec_ctx *exec_ctx, grpc_closure *closure, grpc_endpoint **ep,
grpc_pollset_set *interested_parties, const grpc_resolved_address *addr, grpc_pollset_set *interested_parties, const grpc_channel_args *channel_args,
const grpc_resolved_address *addr,
gpr_timespec deadline) = tcp_client_connect_impl; gpr_timespec deadline) = tcp_client_connect_impl;
void grpc_tcp_client_connect(grpc_exec_ctx *exec_ctx, grpc_closure *closure, void grpc_tcp_client_connect(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
grpc_endpoint **ep, grpc_endpoint **ep,
grpc_pollset_set *interested_parties, grpc_pollset_set *interested_parties,
const grpc_channel_args *channel_args,
const grpc_resolved_address *addr, const grpc_resolved_address *addr,
gpr_timespec deadline) { gpr_timespec deadline) {
grpc_tcp_client_connect_impl(exec_ctx, closure, ep, interested_parties, addr, grpc_tcp_client_connect_impl(exec_ctx, closure, ep, interested_parties,
deadline); channel_args, addr, deadline);
} }
#endif /* GRPC_UV */ #endif /* GRPC_UV */

@ -657,41 +657,46 @@ done:
} }
} }
/* Return listener at port_index or NULL. Should only be called with s->mu
locked. */
static grpc_tcp_listener *get_port_index(grpc_tcp_server *s,
unsigned port_index) {
unsigned num_ports = 0;
grpc_tcp_listener *sp;
for (sp = s->head; sp; sp = sp->next) {
if (!sp->is_sibling) {
if (++num_ports > port_index) {
return sp;
}
}
}
return NULL;
}
unsigned grpc_tcp_server_port_fd_count(grpc_tcp_server *s, unsigned grpc_tcp_server_port_fd_count(grpc_tcp_server *s,
unsigned port_index) { unsigned port_index) {
unsigned num_fds = 0; unsigned num_fds = 0;
grpc_tcp_listener *sp;
gpr_mu_lock(&s->mu); gpr_mu_lock(&s->mu);
for (sp = s->head; sp && port_index != 0; sp = sp->next) { grpc_tcp_listener *sp = get_port_index(s, port_index);
if (!sp->is_sibling) { for (; sp; sp = sp->sibling) {
--port_index; ++num_fds;
}
} }
for (; sp; sp = sp->sibling, ++num_fds)
;
gpr_mu_unlock(&s->mu); gpr_mu_unlock(&s->mu);
return num_fds; return num_fds;
} }
int grpc_tcp_server_port_fd(grpc_tcp_server *s, unsigned port_index, int grpc_tcp_server_port_fd(grpc_tcp_server *s, unsigned port_index,
unsigned fd_index) { unsigned fd_index) {
grpc_tcp_listener *sp;
int fd;
gpr_mu_lock(&s->mu); gpr_mu_lock(&s->mu);
for (sp = s->head; sp && port_index != 0; sp = sp->next) { grpc_tcp_listener *sp = get_port_index(s, port_index);
if (!sp->is_sibling) { for (; sp; sp = sp->sibling, --fd_index) {
--port_index; if (fd_index == 0) {
gpr_mu_unlock(&s->mu);
return sp->fd;
} }
} }
for (; sp && fd_index != 0; sp = sp->sibling, --fd_index)
;
if (sp) {
fd = sp->fd;
} else {
fd = -1;
}
gpr_mu_unlock(&s->mu); gpr_mu_unlock(&s->mu);
return fd; return -1;
} }
void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s, void grpc_tcp_server_start(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s,

@ -76,13 +76,30 @@ struct grpc_tcp_server {
/* shutdown callback */ /* shutdown callback */
grpc_closure *shutdown_complete; grpc_closure *shutdown_complete;
grpc_resource_quota *resource_quota;
}; };
grpc_error *grpc_tcp_server_create(grpc_closure *shutdown_complete, grpc_error *grpc_tcp_server_create(grpc_exec_ctx *exec_ctx,
grpc_closure *shutdown_complete,
const grpc_channel_args *args, const grpc_channel_args *args,
grpc_tcp_server **server) { grpc_tcp_server **server) {
grpc_tcp_server *s = gpr_malloc(sizeof(grpc_tcp_server)); grpc_tcp_server *s = gpr_malloc(sizeof(grpc_tcp_server));
(void)args; s->resource_quota = grpc_resource_quota_create(NULL);
for (size_t i = 0; i < (args == NULL ? 0 : args->num_args); i++) {
if (0 == strcmp(GRPC_ARG_RESOURCE_QUOTA, args->args[i].key)) {
if (args->args[i].type == GRPC_ARG_POINTER) {
grpc_resource_quota_internal_unref(exec_ctx, s->resource_quota);
s->resource_quota =
grpc_resource_quota_internal_ref(args->args[i].value.pointer.p);
} else {
grpc_resource_quota_internal_unref(exec_ctx, s->resource_quota);
gpr_free(s);
return GRPC_ERROR_CREATE(GRPC_ARG_RESOURCE_QUOTA
" must be a pointer to a buffer pool");
}
}
}
gpr_ref_init(&s->refs, 1); gpr_ref_init(&s->refs, 1);
s->on_accept_cb = NULL; s->on_accept_cb = NULL;
s->on_accept_cb_arg = NULL; s->on_accept_cb_arg = NULL;
@ -119,6 +136,7 @@ static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_tcp_server *s) {
gpr_free(sp->handle); gpr_free(sp->handle);
gpr_free(sp); gpr_free(sp);
} }
grpc_resource_quota_internal_unref(exec_ctx, s->resource_quota);
gpr_free(s); gpr_free(s);
} }
@ -201,7 +219,7 @@ static void on_connect(uv_stream_t *server, int status) {
} else { } else {
gpr_log(GPR_INFO, "uv_tcp_getpeername error: %s", uv_strerror(status)); gpr_log(GPR_INFO, "uv_tcp_getpeername error: %s", uv_strerror(status));
} }
ep = grpc_tcp_create(client, peer_name_string); ep = grpc_tcp_create(client, sp->server->resource_quota, peer_name_string);
sp->server->on_accept_cb(&exec_ctx, sp->server->on_accept_cb_arg, ep, NULL, sp->server->on_accept_cb(&exec_ctx, sp->server->on_accept_cb_arg, ep, NULL,
&acceptor); &acceptor);
grpc_exec_ctx_finish(&exec_ctx); grpc_exec_ctx_finish(&exec_ctx);

@ -54,6 +54,9 @@ typedef struct {
grpc_endpoint base; grpc_endpoint base;
gpr_refcount refcount; gpr_refcount refcount;
uv_write_t write_req;
uv_shutdown_t shutdown_req;
uv_tcp_t *handle; uv_tcp_t *handle;
grpc_closure *read_cb; grpc_closure *read_cb;
@ -64,14 +67,23 @@ typedef struct {
gpr_slice_buffer *write_slices; gpr_slice_buffer *write_slices;
uv_buf_t *write_buffers; uv_buf_t *write_buffers;
grpc_resource_user resource_user;
bool shutting_down; bool shutting_down;
bool resource_user_shutting_down;
char *peer_string; char *peer_string;
grpc_pollset *pollset; grpc_pollset *pollset;
} grpc_tcp; } grpc_tcp;
static void uv_close_callback(uv_handle_t *handle) { gpr_free(handle); } static void uv_close_callback(uv_handle_t *handle) { gpr_free(handle); }
static void tcp_free(grpc_tcp *tcp) { gpr_free(tcp); } static void tcp_free(grpc_tcp *tcp) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_resource_user_destroy(&exec_ctx, &tcp->resource_user);
gpr_free(tcp);
grpc_exec_ctx_finish(&exec_ctx);
}
/*#define GRPC_TCP_REFCOUNT_DEBUG*/ /*#define GRPC_TCP_REFCOUNT_DEBUG*/
#ifdef GRPC_TCP_REFCOUNT_DEBUG #ifdef GRPC_TCP_REFCOUNT_DEBUG
@ -106,11 +118,14 @@ static void tcp_ref(grpc_tcp *tcp) { gpr_ref(&tcp->refcount); }
static void alloc_uv_buf(uv_handle_t *handle, size_t suggested_size, static void alloc_uv_buf(uv_handle_t *handle, size_t suggested_size,
uv_buf_t *buf) { uv_buf_t *buf) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_tcp *tcp = handle->data; grpc_tcp *tcp = handle->data;
(void)suggested_size; (void)suggested_size;
tcp->read_slice = gpr_slice_malloc(GRPC_TCP_DEFAULT_READ_SLICE_SIZE); tcp->read_slice = grpc_resource_user_slice_malloc(
&exec_ctx, &tcp->resource_user, GRPC_TCP_DEFAULT_READ_SLICE_SIZE);
buf->base = (char *)GPR_SLICE_START_PTR(tcp->read_slice); buf->base = (char *)GPR_SLICE_START_PTR(tcp->read_slice);
buf->len = GPR_SLICE_LENGTH(tcp->read_slice); buf->len = GPR_SLICE_LENGTH(tcp->read_slice);
grpc_exec_ctx_finish(&exec_ctx);
} }
static void read_callback(uv_stream_t *stream, ssize_t nread, static void read_callback(uv_stream_t *stream, ssize_t nread,
@ -198,7 +213,8 @@ static void write_callback(uv_write_t *req, int status) {
gpr_log(GPR_DEBUG, "write complete on %p: error=%s", tcp, str); gpr_log(GPR_DEBUG, "write complete on %p: error=%s", tcp, str);
} }
gpr_free(tcp->write_buffers); gpr_free(tcp->write_buffers);
gpr_free(req); grpc_resource_user_free(&exec_ctx, &tcp->resource_user,
sizeof(uv_buf_t) * tcp->write_slices->count);
grpc_exec_ctx_sched(&exec_ctx, cb, error, NULL); grpc_exec_ctx_sched(&exec_ctx, cb, error, NULL);
grpc_exec_ctx_finish(&exec_ctx); grpc_exec_ctx_finish(&exec_ctx);
} }
@ -243,12 +259,15 @@ static void uv_endpoint_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
tcp->write_cb = cb; tcp->write_cb = cb;
buffer_count = (unsigned int)tcp->write_slices->count; buffer_count = (unsigned int)tcp->write_slices->count;
buffers = gpr_malloc(sizeof(uv_buf_t) * buffer_count); buffers = gpr_malloc(sizeof(uv_buf_t) * buffer_count);
grpc_resource_user_alloc(exec_ctx, &tcp->resource_user,
sizeof(uv_buf_t) * buffer_count, NULL);
for (i = 0; i < buffer_count; i++) { for (i = 0; i < buffer_count; i++) {
slice = &tcp->write_slices->slices[i]; slice = &tcp->write_slices->slices[i];
buffers[i].base = (char *)GPR_SLICE_START_PTR(*slice); buffers[i].base = (char *)GPR_SLICE_START_PTR(*slice);
buffers[i].len = GPR_SLICE_LENGTH(*slice); buffers[i].len = GPR_SLICE_LENGTH(*slice);
} }
write_req = gpr_malloc(sizeof(uv_write_t)); tcp->write_buffers = buffers;
write_req = &tcp->write_req;
write_req->data = tcp; write_req->data = tcp;
TCP_REF(tcp, "write"); TCP_REF(tcp, "write");
// TODO(murgatroid99): figure out what the return value here means // TODO(murgatroid99): figure out what the return value here means
@ -274,13 +293,29 @@ static void uv_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
(void)pollset; (void)pollset;
} }
static void shutdown_callback(uv_shutdown_t *req, int status) { gpr_free(req); } static void shutdown_callback(uv_shutdown_t *req, int status) {}
static void resource_user_shutdown_done(grpc_exec_ctx *exec_ctx, void *arg,
grpc_error *error) {
TCP_UNREF(arg, "resource_user");
}
static void uv_resource_user_maybe_shutdown(grpc_exec_ctx *exec_ctx,
grpc_tcp *tcp) {
if (!tcp->resource_user_shutting_down) {
tcp->resource_user_shutting_down = true;
TCP_REF(tcp, "resource_user");
grpc_resource_user_shutdown(
exec_ctx, &tcp->resource_user,
grpc_closure_create(resource_user_shutdown_done, tcp));
}
}
static void uv_endpoint_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) { static void uv_endpoint_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
grpc_tcp *tcp = (grpc_tcp *)ep; grpc_tcp *tcp = (grpc_tcp *)ep;
if (!tcp->shutting_down) { if (!tcp->shutting_down) {
tcp->shutting_down = true; tcp->shutting_down = true;
uv_shutdown_t *req = gpr_malloc(sizeof(uv_shutdown_t)); uv_shutdown_t *req = &tcp->shutdown_req;
uv_shutdown(req, (uv_stream_t *)tcp->handle, shutdown_callback); uv_shutdown(req, (uv_stream_t *)tcp->handle, shutdown_callback);
} }
} }
@ -289,6 +324,7 @@ static void uv_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
grpc_network_status_unregister_endpoint(ep); grpc_network_status_unregister_endpoint(ep);
grpc_tcp *tcp = (grpc_tcp *)ep; grpc_tcp *tcp = (grpc_tcp *)ep;
uv_close((uv_handle_t *)tcp->handle, uv_close_callback); uv_close((uv_handle_t *)tcp->handle, uv_close_callback);
uv_resource_user_maybe_shutdown(exec_ctx, tcp);
TCP_UNREF(tcp, "destroy"); TCP_UNREF(tcp, "destroy");
} }
@ -297,18 +333,21 @@ static char *uv_get_peer(grpc_endpoint *ep) {
return gpr_strdup(tcp->peer_string); return gpr_strdup(tcp->peer_string);
} }
static grpc_resource_user *uv_get_resource_user(grpc_endpoint *ep) {
grpc_tcp *tcp = (grpc_tcp *)ep;
return &tcp->resource_user;
}
static grpc_workqueue *uv_get_workqueue(grpc_endpoint *ep) { return NULL; } static grpc_workqueue *uv_get_workqueue(grpc_endpoint *ep) { return NULL; }
static grpc_endpoint_vtable vtable = {uv_endpoint_read, static grpc_endpoint_vtable vtable = {
uv_endpoint_write, uv_endpoint_read, uv_endpoint_write, uv_get_workqueue,
uv_get_workqueue, uv_add_to_pollset, uv_add_to_pollset_set, uv_endpoint_shutdown,
uv_add_to_pollset, uv_destroy, uv_get_resource_user, uv_get_peer};
uv_add_to_pollset_set,
uv_endpoint_shutdown,
uv_destroy,
uv_get_peer};
grpc_endpoint *grpc_tcp_create(uv_tcp_t *handle, char *peer_string) { grpc_endpoint *grpc_tcp_create(uv_tcp_t *handle,
grpc_resource_quota *resource_quota,
char *peer_string) {
grpc_tcp *tcp = (grpc_tcp *)gpr_malloc(sizeof(grpc_tcp)); grpc_tcp *tcp = (grpc_tcp *)gpr_malloc(sizeof(grpc_tcp));
if (grpc_tcp_trace) { if (grpc_tcp_trace) {
@ -325,6 +364,8 @@ grpc_endpoint *grpc_tcp_create(uv_tcp_t *handle, char *peer_string) {
gpr_ref_init(&tcp->refcount, 1); gpr_ref_init(&tcp->refcount, 1);
tcp->peer_string = gpr_strdup(peer_string); tcp->peer_string = gpr_strdup(peer_string);
tcp->shutting_down = false; tcp->shutting_down = false;
tcp->resource_user_shutting_down = false;
grpc_resource_user_init(&tcp->resource_user, resource_quota, peer_string);
/* Tell network status tracking code about the new endpoint */ /* Tell network status tracking code about the new endpoint */
grpc_network_status_register_endpoint(&tcp->base); grpc_network_status_register_endpoint(&tcp->base);

@ -52,6 +52,8 @@ extern int grpc_tcp_trace;
#define GRPC_TCP_DEFAULT_READ_SLICE_SIZE 8192 #define GRPC_TCP_DEFAULT_READ_SLICE_SIZE 8192
grpc_endpoint *grpc_tcp_create(uv_tcp_t *handle, char *peer_string); grpc_endpoint *grpc_tcp_create(uv_tcp_t *handle,
grpc_resource_quota *resource_quota,
char *peer_string);
#endif /* GRPC_CORE_LIB_IOMGR_TCP_UV_H */ #endif /* GRPC_CORE_LIB_IOMGR_TCP_UV_H */

@ -210,11 +210,11 @@ void grpc_security_connector_unref(grpc_security_connector *sc) {
} }
static void connector_pointer_arg_destroy(void *p) { static void connector_pointer_arg_destroy(void *p) {
GRPC_SECURITY_CONNECTOR_UNREF(p, "connector_pointer_arg"); GRPC_SECURITY_CONNECTOR_UNREF(p, "connector_pointer_arg_destroy");
} }
static void *connector_pointer_arg_copy(void *p) { static void *connector_pointer_arg_copy(void *p) {
return GRPC_SECURITY_CONNECTOR_REF(p, "connector_pointer_arg"); return GRPC_SECURITY_CONNECTOR_REF(p, "connector_pointer_arg_copy");
} }
static int connector_pointer_cmp(void *a, void *b) { return GPR_ICMP(a, b); } static int connector_pointer_cmp(void *a, void *b) { return GPR_ICMP(a, b); }

@ -106,11 +106,11 @@ grpc_connectivity_state Channel::GetState(bool try_to_connect) {
} }
namespace { namespace {
class TagSaver GRPC_FINAL : public CompletionQueueTag { class TagSaver final : public CompletionQueueTag {
public: public:
explicit TagSaver(void* tag) : tag_(tag) {} explicit TagSaver(void* tag) : tag_(tag) {}
~TagSaver() GRPC_OVERRIDE {} ~TagSaver() override {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
*tag = tag_; *tag = tag_;
delete this; delete this;
return true; return true;

@ -45,12 +45,12 @@
namespace grpc { namespace grpc {
class DefaultGlobalClientCallbacks GRPC_FINAL class DefaultGlobalClientCallbacks final
: public ClientContext::GlobalCallbacks { : public ClientContext::GlobalCallbacks {
public: public:
~DefaultGlobalClientCallbacks() GRPC_OVERRIDE {} ~DefaultGlobalClientCallbacks() override {}
void DefaultConstructor(ClientContext* context) GRPC_OVERRIDE {} void DefaultConstructor(ClientContext* context) override {}
void Destructor(ClientContext* context) GRPC_OVERRIDE {} void Destructor(ClientContext* context) override {}
}; };
static DefaultGlobalClientCallbacks g_default_client_callbacks; static DefaultGlobalClientCallbacks g_default_client_callbacks;
@ -93,7 +93,7 @@ void ClientContext::AddMetadata(const grpc::string& meta_key,
void ClientContext::set_call(grpc_call* call, void ClientContext::set_call(grpc_call* call,
const std::shared_ptr<Channel>& channel) { const std::shared_ptr<Channel>& channel) {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
GPR_ASSERT(call_ == nullptr); GPR_ASSERT(call_ == nullptr);
call_ = call; call_ = call;
channel_ = channel; channel_ = channel;
@ -119,7 +119,7 @@ void ClientContext::set_compression_algorithm(
} }
void ClientContext::TryCancel() { void ClientContext::TryCancel() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (call_) { if (call_) {
grpc_call_cancel(call_, nullptr); grpc_call_cancel(call_, nullptr);
} else { } else {

@ -40,12 +40,12 @@
namespace grpc { namespace grpc {
class CronetChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials { class CronetChannelCredentialsImpl final : public ChannelCredentials {
public: public:
CronetChannelCredentialsImpl(void* engine) : engine_(engine) {} CronetChannelCredentialsImpl(void* engine) : engine_(engine) {}
std::shared_ptr<grpc::Channel> CreateChannel( std::shared_ptr<grpc::Channel> CreateChannel(
const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE { const string& target, const grpc::ChannelArguments& args) override {
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return CreateChannelInternal( return CreateChannelInternal(
@ -53,9 +53,7 @@ class CronetChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials {
&channel_args, nullptr)); &channel_args, nullptr));
} }
SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE { SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
return nullptr;
}
private: private:
void* engine_; void* engine_;

@ -43,10 +43,10 @@
namespace grpc { namespace grpc {
namespace { namespace {
class InsecureChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials { class InsecureChannelCredentialsImpl final : public ChannelCredentials {
public: public:
std::shared_ptr<grpc::Channel> CreateChannel( std::shared_ptr<grpc::Channel> CreateChannel(
const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE { const string& target, const grpc::ChannelArguments& args) override {
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return CreateChannelInternal( return CreateChannelInternal(
@ -54,9 +54,7 @@ class InsecureChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials {
grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr)); grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr));
} }
SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE { SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
return nullptr;
}
}; };
} // namespace } // namespace

@ -43,34 +43,34 @@
namespace grpc { namespace grpc {
class SecureChannelCredentials GRPC_FINAL : public ChannelCredentials { class SecureChannelCredentials final : public ChannelCredentials {
public: public:
explicit SecureChannelCredentials(grpc_channel_credentials* c_creds); explicit SecureChannelCredentials(grpc_channel_credentials* c_creds);
~SecureChannelCredentials() { grpc_channel_credentials_release(c_creds_); } ~SecureChannelCredentials() { grpc_channel_credentials_release(c_creds_); }
grpc_channel_credentials* GetRawCreds() { return c_creds_; } grpc_channel_credentials* GetRawCreds() { return c_creds_; }
std::shared_ptr<grpc::Channel> CreateChannel( std::shared_ptr<grpc::Channel> CreateChannel(
const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE; const string& target, const grpc::ChannelArguments& args) override;
SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; } SecureChannelCredentials* AsSecureCredentials() override { return this; }
private: private:
grpc_channel_credentials* const c_creds_; grpc_channel_credentials* const c_creds_;
}; };
class SecureCallCredentials GRPC_FINAL : public CallCredentials { class SecureCallCredentials final : public CallCredentials {
public: public:
explicit SecureCallCredentials(grpc_call_credentials* c_creds); explicit SecureCallCredentials(grpc_call_credentials* c_creds);
~SecureCallCredentials() { grpc_call_credentials_release(c_creds_); } ~SecureCallCredentials() { grpc_call_credentials_release(c_creds_); }
grpc_call_credentials* GetRawCreds() { return c_creds_; } grpc_call_credentials* GetRawCreds() { return c_creds_; }
bool ApplyToCall(grpc_call* call) GRPC_OVERRIDE; bool ApplyToCall(grpc_call* call) override;
SecureCallCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; } SecureCallCredentials* AsSecureCredentials() override { return this; }
private: private:
grpc_call_credentials* const c_creds_; grpc_call_credentials* const c_creds_;
}; };
class MetadataCredentialsPluginWrapper GRPC_FINAL { class MetadataCredentialsPluginWrapper final {
public: public:
static void Destroy(void* wrapper); static void Destroy(void* wrapper);
static void GetMetadata(void* wrapper, grpc_auth_metadata_context context, static void GetMetadata(void* wrapper, grpc_auth_metadata_context context,

@ -121,6 +121,11 @@ void ChannelArguments::SetResourceQuota(
grpc_resource_quota_arg_vtable()); grpc_resource_quota_arg_vtable());
} }
void ChannelArguments::SetLoadBalancingPolicyName(
const grpc::string& lb_policy_name) {
SetString(GRPC_ARG_LB_POLICY_NAME, lb_policy_name);
}
void ChannelArguments::SetInt(const grpc::string& key, int value) { void ChannelArguments::SetInt(const grpc::string& key, int value) {
grpc_arg arg; grpc_arg arg;
arg.type = GRPC_ARG_INTEGER; arg.type = GRPC_ARG_INTEGER;

@ -268,7 +268,7 @@ namespace internal {
// Members of this class correspond to the members of the C // Members of this class correspond to the members of the C
// grpc_channel_filter struct. // grpc_channel_filter struct.
template <typename ChannelDataType, typename CallDataType> template <typename ChannelDataType, typename CallDataType>
class ChannelFilter GRPC_FINAL { class ChannelFilter final {
public: public:
static const size_t channel_data_size = sizeof(ChannelDataType); static const size_t channel_data_size = sizeof(ChannelDataType);

@ -40,30 +40,29 @@ struct grpc_auth_context;
namespace grpc { namespace grpc {
class SecureAuthContext GRPC_FINAL : public AuthContext { class SecureAuthContext final : public AuthContext {
public: public:
SecureAuthContext(grpc_auth_context* ctx, bool take_ownership); SecureAuthContext(grpc_auth_context* ctx, bool take_ownership);
~SecureAuthContext() GRPC_OVERRIDE; ~SecureAuthContext() override;
bool IsPeerAuthenticated() const GRPC_OVERRIDE; bool IsPeerAuthenticated() const override;
std::vector<grpc::string_ref> GetPeerIdentity() const GRPC_OVERRIDE; std::vector<grpc::string_ref> GetPeerIdentity() const override;
grpc::string GetPeerIdentityPropertyName() const GRPC_OVERRIDE; grpc::string GetPeerIdentityPropertyName() const override;
std::vector<grpc::string_ref> FindPropertyValues( std::vector<grpc::string_ref> FindPropertyValues(
const grpc::string& name) const GRPC_OVERRIDE; const grpc::string& name) const override;
AuthPropertyIterator begin() const GRPC_OVERRIDE; AuthPropertyIterator begin() const override;
AuthPropertyIterator end() const GRPC_OVERRIDE; AuthPropertyIterator end() const override;
void AddProperty(const grpc::string& key, void AddProperty(const grpc::string& key,
const grpc::string_ref& value) GRPC_OVERRIDE; const grpc::string_ref& value) override;
virtual bool SetPeerIdentityPropertyName(const grpc::string& name) virtual bool SetPeerIdentityPropertyName(const grpc::string& name) override;
GRPC_OVERRIDE;
private: private:
grpc_auth_context* ctx_; grpc_auth_context* ctx_;

@ -42,7 +42,7 @@
namespace grpc { namespace grpc {
class ProtoServerReflection GRPC_FINAL class ProtoServerReflection final
: public reflection::v1alpha::ServerReflection::Service { : public reflection::v1alpha::ServerReflection::Service {
public: public:
ProtoServerReflection(); ProtoServerReflection();
@ -56,7 +56,7 @@ class ProtoServerReflection GRPC_FINAL
ServerContext* context, ServerContext* context,
ServerReaderWriter<reflection::v1alpha::ServerReflectionResponse, ServerReaderWriter<reflection::v1alpha::ServerReflectionResponse,
reflection::v1alpha::ServerReflectionRequest>* stream) reflection::v1alpha::ServerReflectionRequest>* stream)
GRPC_OVERRIDE; override;
private: private:
Status ListService(ServerContext* context, Status ListService(ServerContext* context,

@ -31,16 +31,16 @@
* *
*/ */
#include <grpc++/impl/sync.h> #include <mutex>
#include <grpc++/impl/thd.h> #include <thread>
#include "src/cpp/server/dynamic_thread_pool.h" #include "src/cpp/server/dynamic_thread_pool.h"
namespace grpc { namespace grpc {
DynamicThreadPool::DynamicThread::DynamicThread(DynamicThreadPool* pool) DynamicThreadPool::DynamicThread::DynamicThread(DynamicThreadPool* pool)
: pool_(pool), : pool_(pool),
thd_(new grpc::thread(&DynamicThreadPool::DynamicThread::ThreadFunc, thd_(new std::thread(&DynamicThreadPool::DynamicThread::ThreadFunc,
this)) {} this)) {}
DynamicThreadPool::DynamicThread::~DynamicThread() { DynamicThreadPool::DynamicThread::~DynamicThread() {
thd_->join(); thd_->join();
thd_.reset(); thd_.reset();
@ -49,7 +49,7 @@ DynamicThreadPool::DynamicThread::~DynamicThread() {
void DynamicThreadPool::DynamicThread::ThreadFunc() { void DynamicThreadPool::DynamicThread::ThreadFunc() {
pool_->ThreadFunc(); pool_->ThreadFunc();
// Now that we have killed ourselves, we should reduce the thread count // Now that we have killed ourselves, we should reduce the thread count
grpc::unique_lock<grpc::mutex> lock(pool_->mu_); std::unique_lock<std::mutex> lock(pool_->mu_);
pool_->nthreads_--; pool_->nthreads_--;
// Move ourselves to dead list // Move ourselves to dead list
pool_->dead_threads_.push_back(this); pool_->dead_threads_.push_back(this);
@ -62,7 +62,7 @@ void DynamicThreadPool::DynamicThread::ThreadFunc() {
void DynamicThreadPool::ThreadFunc() { void DynamicThreadPool::ThreadFunc() {
for (;;) { for (;;) {
// Wait until work is available or we are shutting down. // Wait until work is available or we are shutting down.
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (!shutdown_ && callbacks_.empty()) { if (!shutdown_ && callbacks_.empty()) {
// If there are too many threads waiting, then quit this thread // If there are too many threads waiting, then quit this thread
if (threads_waiting_ >= reserve_threads_) { if (threads_waiting_ >= reserve_threads_) {
@ -91,7 +91,7 @@ DynamicThreadPool::DynamicThreadPool(int reserve_threads)
nthreads_(0), nthreads_(0),
threads_waiting_(0) { threads_waiting_(0) {
for (int i = 0; i < reserve_threads_; i++) { for (int i = 0; i < reserve_threads_; i++) {
grpc::lock_guard<grpc::mutex> lock(mu_); std::lock_guard<std::mutex> lock(mu_);
nthreads_++; nthreads_++;
new DynamicThread(this); new DynamicThread(this);
} }
@ -104,7 +104,7 @@ void DynamicThreadPool::ReapThreads(std::list<DynamicThread*>* tlist) {
} }
DynamicThreadPool::~DynamicThreadPool() { DynamicThreadPool::~DynamicThreadPool() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
shutdown_ = true; shutdown_ = true;
cv_.notify_all(); cv_.notify_all();
while (nthreads_ != 0) { while (nthreads_ != 0) {
@ -114,7 +114,7 @@ DynamicThreadPool::~DynamicThreadPool() {
} }
void DynamicThreadPool::Add(const std::function<void()>& callback) { void DynamicThreadPool::Add(const std::function<void()>& callback) {
grpc::lock_guard<grpc::mutex> lock(mu_); std::lock_guard<std::mutex> lock(mu_);
// Add works to the callbacks list // Add works to the callbacks list
callbacks_.push(callback); callbacks_.push(callback);
// Increase pool size or notify as needed // Increase pool size or notify as needed

@ -34,24 +34,25 @@
#ifndef GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H #ifndef GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H
#define GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H #define GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H
#include <condition_variable>
#include <list> #include <list>
#include <memory> #include <memory>
#include <mutex>
#include <queue> #include <queue>
#include <thread>
#include <grpc++/impl/sync.h>
#include <grpc++/impl/thd.h>
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
#include "src/cpp/server/thread_pool_interface.h" #include "src/cpp/server/thread_pool_interface.h"
namespace grpc { namespace grpc {
class DynamicThreadPool GRPC_FINAL : public ThreadPoolInterface { class DynamicThreadPool final : public ThreadPoolInterface {
public: public:
explicit DynamicThreadPool(int reserve_threads); explicit DynamicThreadPool(int reserve_threads);
~DynamicThreadPool(); ~DynamicThreadPool();
void Add(const std::function<void()>& callback) GRPC_OVERRIDE; void Add(const std::function<void()>& callback) override;
private: private:
class DynamicThread { class DynamicThread {
@ -61,12 +62,12 @@ class DynamicThreadPool GRPC_FINAL : public ThreadPoolInterface {
private: private:
DynamicThreadPool* pool_; DynamicThreadPool* pool_;
std::unique_ptr<grpc::thread> thd_; std::unique_ptr<std::thread> thd_;
void ThreadFunc(); void ThreadFunc();
}; };
grpc::mutex mu_; std::mutex mu_;
grpc::condition_variable cv_; std::condition_variable cv_;
grpc::condition_variable shutdown_cv_; std::condition_variable shutdown_cv_;
bool shutdown_; bool shutdown_;
std::queue<std::function<void()>> callbacks_; std::queue<std::function<void()>> callbacks_;
int reserve_threads_; int reserve_threads_;

@ -38,14 +38,13 @@
namespace grpc { namespace grpc {
namespace { namespace {
class InsecureServerCredentialsImpl GRPC_FINAL : public ServerCredentials { class InsecureServerCredentialsImpl final : public ServerCredentials {
public: public:
int AddPortToServer(const grpc::string& addr, int AddPortToServer(const grpc::string& addr, grpc_server* server) override {
grpc_server* server) GRPC_OVERRIDE {
return grpc_server_add_insecure_http2_port(server, addr.c_str()); return grpc_server_add_insecure_http2_port(server, addr.c_str());
} }
void SetAuthMetadataProcessor( void SetAuthMetadataProcessor(
const std::shared_ptr<AuthMetadataProcessor>& processor) GRPC_OVERRIDE { const std::shared_ptr<AuthMetadataProcessor>& processor) override {
(void)processor; (void)processor;
GPR_ASSERT(0); // Should not be called on InsecureServerCredentials. GPR_ASSERT(0); // Should not be called on InsecureServerCredentials.
} }

@ -44,7 +44,7 @@
namespace grpc { namespace grpc {
class AuthMetadataProcessorAyncWrapper GRPC_FINAL { class AuthMetadataProcessorAyncWrapper final {
public: public:
static void Destroy(void* wrapper); static void Destroy(void* wrapper);
@ -64,19 +64,18 @@ class AuthMetadataProcessorAyncWrapper GRPC_FINAL {
std::shared_ptr<AuthMetadataProcessor> processor_; std::shared_ptr<AuthMetadataProcessor> processor_;
}; };
class SecureServerCredentials GRPC_FINAL : public ServerCredentials { class SecureServerCredentials final : public ServerCredentials {
public: public:
explicit SecureServerCredentials(grpc_server_credentials* creds) explicit SecureServerCredentials(grpc_server_credentials* creds)
: creds_(creds) {} : creds_(creds) {}
~SecureServerCredentials() GRPC_OVERRIDE { ~SecureServerCredentials() override {
grpc_server_credentials_release(creds_); grpc_server_credentials_release(creds_);
} }
int AddPortToServer(const grpc::string& addr, int AddPortToServer(const grpc::string& addr, grpc_server* server) override;
grpc_server* server) GRPC_OVERRIDE;
void SetAuthMetadataProcessor( void SetAuthMetadataProcessor(
const std::shared_ptr<AuthMetadataProcessor>& processor) GRPC_OVERRIDE; const std::shared_ptr<AuthMetadataProcessor>& processor) override;
private: private:
grpc_server_credentials* creds_; grpc_server_credentials* creds_;

@ -55,11 +55,11 @@
namespace grpc { namespace grpc {
class DefaultGlobalCallbacks GRPC_FINAL : public Server::GlobalCallbacks { class DefaultGlobalCallbacks final : public Server::GlobalCallbacks {
public: public:
~DefaultGlobalCallbacks() GRPC_OVERRIDE {} ~DefaultGlobalCallbacks() override {}
void PreSynchronousRequest(ServerContext* context) GRPC_OVERRIDE {} void PreSynchronousRequest(ServerContext* context) override {}
void PostSynchronousRequest(ServerContext* context) GRPC_OVERRIDE {} void PostSynchronousRequest(ServerContext* context) override {}
}; };
static std::shared_ptr<Server::GlobalCallbacks> g_callbacks = nullptr; static std::shared_ptr<Server::GlobalCallbacks> g_callbacks = nullptr;
@ -79,7 +79,7 @@ class Server::UnimplementedAsyncRequestContext {
GenericServerAsyncReaderWriter generic_stream_; GenericServerAsyncReaderWriter generic_stream_;
}; };
class Server::UnimplementedAsyncRequest GRPC_FINAL class Server::UnimplementedAsyncRequest final
: public UnimplementedAsyncRequestContext, : public UnimplementedAsyncRequestContext,
public GenericAsyncRequest { public GenericAsyncRequest {
public: public:
@ -89,7 +89,7 @@ class Server::UnimplementedAsyncRequest GRPC_FINAL
server_(server), server_(server),
cq_(cq) {} cq_(cq) {}
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
ServerContext* context() { return &server_context_; } ServerContext* context() { return &server_context_; }
GenericServerAsyncReaderWriter* stream() { return &generic_stream_; } GenericServerAsyncReaderWriter* stream() { return &generic_stream_; }
@ -101,13 +101,13 @@ class Server::UnimplementedAsyncRequest GRPC_FINAL
typedef SneakyCallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> typedef SneakyCallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus>
UnimplementedAsyncResponseOp; UnimplementedAsyncResponseOp;
class Server::UnimplementedAsyncResponse GRPC_FINAL class Server::UnimplementedAsyncResponse final
: public UnimplementedAsyncResponseOp { : public UnimplementedAsyncResponseOp {
public: public:
UnimplementedAsyncResponse(UnimplementedAsyncRequest* request); UnimplementedAsyncResponse(UnimplementedAsyncRequest* request);
~UnimplementedAsyncResponse() { delete request_; } ~UnimplementedAsyncResponse() { delete request_; }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
bool r = UnimplementedAsyncResponseOp::FinalizeResult(tag, status); bool r = UnimplementedAsyncResponseOp::FinalizeResult(tag, status);
delete this; delete this;
return r; return r;
@ -122,7 +122,7 @@ class ShutdownTag : public CompletionQueueTag {
bool FinalizeResult(void** tag, bool* status) { return false; } bool FinalizeResult(void** tag, bool* status) { return false; }
}; };
class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { class Server::SyncRequest final : public CompletionQueueTag {
public: public:
SyncRequest(RpcServiceMethod* method, void* tag) SyncRequest(RpcServiceMethod* method, void* tag)
: method_(method), : method_(method),
@ -170,7 +170,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
} }
} }
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { bool FinalizeResult(void** tag, bool* status) override {
if (!*status) { if (!*status) {
grpc_completion_queue_destroy(cq_); grpc_completion_queue_destroy(cq_);
} }
@ -182,7 +182,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
return true; return true;
} }
class CallData GRPC_FINAL { class CallData final {
public: public:
explicit CallData(Server* server, SyncRequest* mrd) explicit CallData(Server* server, SyncRequest* mrd)
: cq_(mrd->cq_), : cq_(mrd->cq_),
@ -255,7 +255,7 @@ class Server::SyncRequestThreadManager : public ThreadManager {
cq_timeout_msec_(cq_timeout_msec), cq_timeout_msec_(cq_timeout_msec),
global_callbacks_(global_callbacks) {} global_callbacks_(global_callbacks) {}
WorkStatus PollForWork(void** tag, bool* ok) GRPC_OVERRIDE { WorkStatus PollForWork(void** tag, bool* ok) override {
*tag = nullptr; *tag = nullptr;
gpr_timespec deadline = gpr_timespec deadline =
gpr_time_from_millis(cq_timeout_msec_, GPR_TIMESPAN); gpr_time_from_millis(cq_timeout_msec_, GPR_TIMESPAN);
@ -272,7 +272,7 @@ class Server::SyncRequestThreadManager : public ThreadManager {
GPR_UNREACHABLE_CODE(return TIMEOUT); GPR_UNREACHABLE_CODE(return TIMEOUT);
} }
void DoWork(void* tag, bool ok) GRPC_OVERRIDE { void DoWork(void* tag, bool ok) override {
SyncRequest* sync_req = static_cast<SyncRequest*>(tag); SyncRequest* sync_req = static_cast<SyncRequest*>(tag);
if (!sync_req) { if (!sync_req) {
@ -379,7 +379,7 @@ Server::Server(
Server::~Server() { Server::~Server() {
{ {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (started_ && !shutdown_) { if (started_ && !shutdown_) {
lock.unlock(); lock.unlock();
Shutdown(); Shutdown();
@ -501,7 +501,7 @@ bool Server::Start(ServerCompletionQueue** cqs, size_t num_cqs) {
} }
void Server::ShutdownInternal(gpr_timespec deadline) { void Server::ShutdownInternal(gpr_timespec deadline) {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (started_ && !shutdown_) { if (started_ && !shutdown_) {
shutdown_ = true; shutdown_ = true;
@ -549,7 +549,7 @@ void Server::ShutdownInternal(gpr_timespec deadline) {
} }
void Server::Wait() { void Server::Wait() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
while (started_ && !shutdown_notified_) { while (started_ && !shutdown_notified_) {
shutdown_cv_.wait(lock); shutdown_cv_.wait(lock);
} }

@ -33,9 +33,10 @@
#include <grpc++/server_context.h> #include <grpc++/server_context.h>
#include <mutex>
#include <grpc++/completion_queue.h> #include <grpc++/completion_queue.h>
#include <grpc++/impl/call.h> #include <grpc++/impl/call.h>
#include <grpc++/impl/sync.h>
#include <grpc++/support/time.h> #include <grpc++/support/time.h>
#include <grpc/compression.h> #include <grpc/compression.h>
#include <grpc/grpc.h> #include <grpc/grpc.h>
@ -48,7 +49,7 @@ namespace grpc {
// CompletionOp // CompletionOp
class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface { class ServerContext::CompletionOp final : public CallOpSetInterface {
public: public:
// initial refs: one in the server context, one in the cq // initial refs: one in the server context, one in the cq
CompletionOp() CompletionOp()
@ -58,8 +59,8 @@ class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface {
finalized_(false), finalized_(false),
cancelled_(0) {} cancelled_(0) {}
void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE; void FillOps(grpc_op* ops, size_t* nops) override;
bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) override;
bool CheckCancelled(CompletionQueue* cq) { bool CheckCancelled(CompletionQueue* cq) {
cq->TryPluck(this); cq->TryPluck(this);
@ -76,20 +77,20 @@ class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface {
private: private:
bool CheckCancelledNoPluck() { bool CheckCancelledNoPluck() {
grpc::lock_guard<grpc::mutex> g(mu_); std::lock_guard<std::mutex> g(mu_);
return finalized_ ? (cancelled_ != 0) : false; return finalized_ ? (cancelled_ != 0) : false;
} }
bool has_tag_; bool has_tag_;
void* tag_; void* tag_;
grpc::mutex mu_; std::mutex mu_;
int refs_; int refs_;
bool finalized_; bool finalized_;
int cancelled_; int cancelled_;
}; };
void ServerContext::CompletionOp::Unref() { void ServerContext::CompletionOp::Unref() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (--refs_ == 0) { if (--refs_ == 0) {
lock.unlock(); lock.unlock();
delete this; delete this;
@ -105,7 +106,7 @@ void ServerContext::CompletionOp::FillOps(grpc_op* ops, size_t* nops) {
} }
bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) { bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
finalized_ = true; finalized_ = true;
bool ret = false; bool ret = false;
if (has_tag_) { if (has_tag_) {

@ -31,12 +31,13 @@
* *
*/ */
#include <grpc++/impl/sync.h> #include "src/cpp/thread_manager/thread_manager.h"
#include <grpc++/impl/thd.h>
#include <grpc/support/log.h>
#include <climits> #include <climits>
#include <mutex>
#include <thread>
#include "src/cpp/thread_manager/thread_manager.h" #include <grpc/support/log.h>
namespace grpc { namespace grpc {
@ -59,7 +60,7 @@ ThreadManager::ThreadManager(int min_pollers, int max_pollers)
ThreadManager::~ThreadManager() { ThreadManager::~ThreadManager() {
{ {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
GPR_ASSERT(num_threads_ == 0); GPR_ASSERT(num_threads_ == 0);
} }
@ -67,29 +68,29 @@ ThreadManager::~ThreadManager() {
} }
void ThreadManager::Wait() { void ThreadManager::Wait() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
while (num_threads_ != 0) { while (num_threads_ != 0) {
shutdown_cv_.wait(lock); shutdown_cv_.wait(lock);
} }
} }
void ThreadManager::Shutdown() { void ThreadManager::Shutdown() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
shutdown_ = true; shutdown_ = true;
} }
bool ThreadManager::IsShutdown() { bool ThreadManager::IsShutdown() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
return shutdown_; return shutdown_;
} }
void ThreadManager::MarkAsCompleted(WorkerThread* thd) { void ThreadManager::MarkAsCompleted(WorkerThread* thd) {
{ {
std::unique_lock<grpc::mutex> list_lock(list_mu_); std::unique_lock<std::mutex> list_lock(list_mu_);
completed_threads_.push_back(thd); completed_threads_.push_back(thd);
} }
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
num_threads_--; num_threads_--;
if (num_threads_ == 0) { if (num_threads_ == 0) {
shutdown_cv_.notify_one(); shutdown_cv_.notify_one();
@ -97,7 +98,7 @@ void ThreadManager::MarkAsCompleted(WorkerThread* thd) {
} }
void ThreadManager::CleanupCompletedThreads() { void ThreadManager::CleanupCompletedThreads() {
std::unique_lock<grpc::mutex> lock(list_mu_); std::unique_lock<std::mutex> lock(list_mu_);
for (auto thd = completed_threads_.begin(); thd != completed_threads_.end(); for (auto thd = completed_threads_.begin(); thd != completed_threads_.end();
thd = completed_threads_.erase(thd)) { thd = completed_threads_.erase(thd)) {
delete *thd; delete *thd;
@ -114,7 +115,7 @@ void ThreadManager::Initialize() {
// less than max threshold (i.e max_pollers_) and the total number of threads is // less than max threshold (i.e max_pollers_) and the total number of threads is
// below the maximum threshold, we can let the current thread continue as poller // below the maximum threshold, we can let the current thread continue as poller
bool ThreadManager::MaybeContinueAsPoller() { bool ThreadManager::MaybeContinueAsPoller() {
std::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (shutdown_ || num_pollers_ > max_pollers_) { if (shutdown_ || num_pollers_ > max_pollers_) {
return false; return false;
} }
@ -127,7 +128,7 @@ bool ThreadManager::MaybeContinueAsPoller() {
// threads currently blocked in PollForWork()) is below the threshold (i.e // threads currently blocked in PollForWork()) is below the threshold (i.e
// min_pollers_) and the total number of threads is below the maximum threshold // min_pollers_) and the total number of threads is below the maximum threshold
void ThreadManager::MaybeCreatePoller() { void ThreadManager::MaybeCreatePoller() {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
if (!shutdown_ && num_pollers_ < min_pollers_) { if (!shutdown_ && num_pollers_ < min_pollers_) {
num_pollers_++; num_pollers_++;
num_threads_++; num_threads_++;
@ -156,7 +157,7 @@ void ThreadManager::MainWorkLoop() {
WorkStatus work_status = PollForWork(&tag, &ok); WorkStatus work_status = PollForWork(&tag, &ok);
{ {
grpc::unique_lock<grpc::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
num_pollers_--; num_pollers_--;
if (work_status == TIMEOUT && num_pollers_ > min_pollers_) { if (work_status == TIMEOUT && num_pollers_ > min_pollers_) {

@ -34,11 +34,12 @@
#ifndef GRPC_INTERNAL_CPP_THREAD_MANAGER_H #ifndef GRPC_INTERNAL_CPP_THREAD_MANAGER_H
#define GRPC_INTERNAL_CPP_THREAD_MANAGER_H #define GRPC_INTERNAL_CPP_THREAD_MANAGER_H
#include <condition_variable>
#include <list> #include <list>
#include <memory> #include <memory>
#include <mutex>
#include <thread>
#include <grpc++/impl/sync.h>
#include <grpc++/impl/thd.h>
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
namespace grpc { namespace grpc {
@ -115,7 +116,7 @@ class ThreadManager {
void Run(); void Run();
ThreadManager* thd_mgr_; ThreadManager* thd_mgr_;
grpc::thread thd_; std::thread thd_;
}; };
// The main funtion in ThreadManager // The main funtion in ThreadManager
@ -134,10 +135,10 @@ class ThreadManager {
// Protects shutdown_, num_pollers_ and num_threads_ // Protects shutdown_, num_pollers_ and num_threads_
// TODO: sreek - Change num_pollers and num_threads_ to atomics // TODO: sreek - Change num_pollers and num_threads_ to atomics
grpc::mutex mu_; std::mutex mu_;
bool shutdown_; bool shutdown_;
grpc::condition_variable shutdown_cv_; std::condition_variable shutdown_cv_;
// Number of threads doing polling // Number of threads doing polling
int num_pollers_; int num_pollers_;
@ -150,7 +151,7 @@ class ThreadManager {
// currently polling i.e num_pollers_) // currently polling i.e num_pollers_)
int num_threads_; int num_threads_;
grpc::mutex list_mu_; std::mutex list_mu_;
std::list<WorkerThread*> completed_threads_; std::list<WorkerThread*> completed_threads_;
}; };

@ -32,9 +32,6 @@
*/ */
#include <grpc++/support/config.h> #include <grpc++/support/config.h>
#ifndef GRPC_CXX0X_NO_CHRONO
#include <grpc++/support/time.h> #include <grpc++/support/time.h>
#include <grpc/support/time.h> #include <grpc/support/time.h>
@ -91,5 +88,3 @@ system_clock::time_point Timespec2Timepoint(gpr_timespec t) {
} }
} // namespace grpc } // namespace grpc
#endif // !GRPC_CXX0X_NO_CHRONO

@ -1,6 +1,5 @@
grpc.lb.v1.InitialLoadBalanceRequest.name max_size:128 grpc.lb.v1.InitialLoadBalanceRequest.name max_size:128
grpc.lb.v1.InitialLoadBalanceResponse.client_config max_size:64
grpc.lb.v1.InitialLoadBalanceResponse.load_balancer_delegate max_size:64 grpc.lb.v1.InitialLoadBalanceResponse.load_balancer_delegate max_size:64
grpc.lb.v1.Server.ip_address max_size:16 grpc.lb.v1.Server.ip_address max_size:16
grpc.lb.v1.Server.load_balance_token max_size:65 grpc.lb.v1.Server.load_balance_token max_size:50
load_balancer.proto no_unions:true load_balancer.proto no_unions:true

@ -63,7 +63,8 @@ message LoadBalanceRequest {
} }
message InitialLoadBalanceRequest { message InitialLoadBalanceRequest {
// Name of load balanced service (IE, service.grpc.gslb.google.com) // Name of load balanced service (IE, service.grpc.gslb.google.com). Its
// length should be less than 256 bytes.
string name = 1; string name = 1;
} }
@ -95,7 +96,8 @@ message InitialLoadBalanceResponse {
// This is an application layer redirect that indicates the client should use // This is an application layer redirect that indicates the client should use
// the specified server for load balancing. When this field is non-empty in // the specified server for load balancing. When this field is non-empty in
// the response, the client should open a separate connection to the // the response, the client should open a separate connection to the
// load_balancer_delegate and call the BalanceLoad method. // load_balancer_delegate and call the BalanceLoad method. Its length should
// be less than 64 bytes.
string load_balancer_delegate = 1; string load_balancer_delegate = 1;
// This interval defines how often the client should send the client stats // This interval defines how often the client should send the client stats
@ -130,6 +132,8 @@ message Server {
// frontend requests for that pick must include the token in its initial // frontend requests for that pick must include the token in its initial
// metadata. The token is used by the backend to verify the request and to // metadata. The token is used by the backend to verify the request and to
// allow the backend to report load to the gRPC LB system. // allow the backend to report load to the gRPC LB system.
//
// Its length is variable but less than 50 bytes.
string load_balance_token = 3; string load_balance_token = 3;
// Indicates whether this particular request should be dropped by the client // Indicates whether this particular request should be dropped by the client

@ -283,6 +283,8 @@ VALUE grpc_rb_compression_options_level_value_to_name_internal(
rb_eArgError, rb_eArgError,
"Failed to convert compression level value to name for value: %d", "Failed to convert compression level value to name for value: %d",
(int)compression_value); (int)compression_value);
/* return something to avoid compiler error about no return */
return Qnil;
} }
} }

@ -39,7 +39,7 @@
# The clang-3.6 symlink for the default clang version was added # The clang-3.6 symlink for the default clang version was added
# to Ubuntu 16.04 recently, so make sure it's installed. # to Ubuntu 16.04 recently, so make sure it's installed.
# Also install clang3.7. # Also install clang3.7.
RUN apt-get update && apt-get -y install clang-3.6 clang-3.7 && apt-get clean RUN apt-get update && apt-get -y install gcc-4.8 gcc-4.8-multilib g++-4.8 g++-4.8-multilib clang-3.6 clang-3.7 && apt-get clean
# Define the default command. # Define the default command.
CMD ["bash"] CMD ["bash"]

@ -115,8 +115,8 @@ static void reset_addr_and_set_magic_string(grpc_resolved_address **addr,
target.sin_family = AF_INET; target.sin_family = AF_INET;
target.sin_addr.s_addr = htonl(INADDR_LOOPBACK); target.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
target.sin_port = htons((uint16_t)server_port); target.sin_port = htons((uint16_t)server_port);
(*addr)->len = sizeof(target);
*addr = (grpc_resolved_address *)gpr_malloc(sizeof(grpc_resolved_address)); *addr = (grpc_resolved_address *)gpr_malloc(sizeof(grpc_resolved_address));
(*addr)->len = sizeof(target);
memcpy((*addr)->addr, &target, sizeof(target)); memcpy((*addr)->addr, &target, sizeof(target));
} }

@ -0,0 +1,49 @@
#!/usr/bin/env python2.7
# Copyright 2015, Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import os
import sys
os.chdir(os.path.dirname(sys.argv[0]))
streams = {
'server_hanging_response_1_header': (
[0,0,0,4,0,0,0,0,0] + # settings frame
[0,0,0,1,5,0,0,0,1] # trailers
),
'server_hanging_response_2_header2': (
[0,0,0,4,0,0,0,0,0] + # settings frame
[0,0,0,1,4,0,0,0,1] + # headers
[0,0,0,1,5,0,0,0,1] # trailers
),
}
for name, stream in streams.items():
open('client_fuzzer_corpus/%s' % name, 'w').write(bytearray(stream))

@ -137,17 +137,22 @@ void resource_quota_server(grpc_end2end_test_config config) {
* will be verified on completion. */ * will be verified on completion. */
gpr_slice request_payload_slice = generate_random_slice(); gpr_slice request_payload_slice = generate_random_slice();
grpc_call *client_calls[NUM_CALLS]; grpc_call **client_calls = malloc(sizeof(grpc_call *) * NUM_CALLS);
grpc_call *server_calls[NUM_CALLS]; grpc_call **server_calls = malloc(sizeof(grpc_call *) * NUM_CALLS);
grpc_metadata_array initial_metadata_recv[NUM_CALLS]; grpc_metadata_array *initial_metadata_recv =
grpc_metadata_array trailing_metadata_recv[NUM_CALLS]; malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
grpc_metadata_array request_metadata_recv[NUM_CALLS]; grpc_metadata_array *trailing_metadata_recv =
grpc_call_details call_details[NUM_CALLS]; malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
grpc_status_code status[NUM_CALLS]; grpc_metadata_array *request_metadata_recv =
char *details[NUM_CALLS]; malloc(sizeof(grpc_metadata_array) * NUM_CALLS);
size_t details_capacity[NUM_CALLS]; grpc_call_details *call_details =
grpc_byte_buffer *request_payload_recv[NUM_CALLS]; malloc(sizeof(grpc_call_details) * NUM_CALLS);
int was_cancelled[NUM_CALLS]; grpc_status_code *status = malloc(sizeof(grpc_status_code) * NUM_CALLS);
char **details = malloc(sizeof(char *) * NUM_CALLS);
size_t *details_capacity = malloc(sizeof(size_t) * NUM_CALLS);
grpc_byte_buffer **request_payload_recv =
malloc(sizeof(grpc_byte_buffer *) * NUM_CALLS);
int *was_cancelled = malloc(sizeof(int) * NUM_CALLS);
grpc_call_error error; grpc_call_error error;
int pending_client_calls = 0; int pending_client_calls = 0;
int pending_server_start_calls = 0; int pending_server_start_calls = 0;
@ -356,6 +361,18 @@ void resource_quota_server(grpc_end2end_test_config config) {
gpr_slice_unref(request_payload_slice); gpr_slice_unref(request_payload_slice);
grpc_resource_quota_unref(resource_quota); grpc_resource_quota_unref(resource_quota);
free(client_calls);
free(server_calls);
free(initial_metadata_recv);
free(trailing_metadata_recv);
free(request_metadata_recv);
free(call_details);
free(status);
free(details);
free(details_capacity);
free(request_payload_recv);
free(was_cancelled);
end_test(&f); end_test(&f);
config.tear_down_data(&f); config.tear_down_data(&f);
} }

@ -67,7 +67,7 @@ namespace testing {
// ServiceA detached comment 2 // ServiceA detached comment 2
// //
// ServiceA leading comment 1 // ServiceA leading comment 1
class ServiceA GRPC_FINAL { class ServiceA final {
public: public:
class StubInterface { class StubInterface {
public: public:
@ -94,10 +94,10 @@ class ServiceA GRPC_FINAL {
virtual ::grpc::ClientWriterInterface< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) = 0; virtual ::grpc::ClientWriterInterface< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) = 0;
virtual ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncWriterInterface< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
}; };
class Stub GRPC_FINAL : public StubInterface { class Stub final : public StubInterface {
public: public:
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
::grpc::Status MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) GRPC_OVERRIDE; ::grpc::Status MethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) override;
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodA1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodA1Raw(context, request, cq)); return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodA1Raw(context, request, cq));
} }
@ -110,9 +110,9 @@ class ServiceA GRPC_FINAL {
private: private:
std::shared_ptr< ::grpc::ChannelInterface> channel_; std::shared_ptr< ::grpc::ChannelInterface> channel_;
::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) GRPC_OVERRIDE; ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodA1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientWriter< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) GRPC_OVERRIDE; ::grpc::ClientWriter< ::grpc::testing::Request>* MethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response) override;
::grpc::ClientAsyncWriter< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE; ::grpc::ClientAsyncWriter< ::grpc::testing::Request>* AsyncMethodA2Raw(::grpc::ClientContext* context, ::grpc::testing::Response* response, ::grpc::CompletionQueue* cq, void* tag) override;
const ::grpc::RpcMethod rpcmethod_MethodA1_; const ::grpc::RpcMethod rpcmethod_MethodA1_;
const ::grpc::RpcMethod rpcmethod_MethodA2_; const ::grpc::RpcMethod rpcmethod_MethodA2_;
}; };
@ -140,11 +140,11 @@ class ServiceA GRPC_FINAL {
WithAsyncMethod_MethodA1() { WithAsyncMethod_MethodA1() {
::grpc::Service::MarkMethodAsync(0); ::grpc::Service::MarkMethodAsync(0);
} }
~WithAsyncMethod_MethodA1() GRPC_OVERRIDE { ~WithAsyncMethod_MethodA1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -160,11 +160,11 @@ class ServiceA GRPC_FINAL {
WithAsyncMethod_MethodA2() { WithAsyncMethod_MethodA2() {
::grpc::Service::MarkMethodAsync(1); ::grpc::Service::MarkMethodAsync(1);
} }
~WithAsyncMethod_MethodA2() GRPC_OVERRIDE { ~WithAsyncMethod_MethodA2() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -181,11 +181,11 @@ class ServiceA GRPC_FINAL {
WithGenericMethod_MethodA1() { WithGenericMethod_MethodA1() {
::grpc::Service::MarkMethodGeneric(0); ::grpc::Service::MarkMethodGeneric(0);
} }
~WithGenericMethod_MethodA1() GRPC_OVERRIDE { ~WithGenericMethod_MethodA1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -198,11 +198,11 @@ class ServiceA GRPC_FINAL {
WithGenericMethod_MethodA2() { WithGenericMethod_MethodA2() {
::grpc::Service::MarkMethodGeneric(1); ::grpc::Service::MarkMethodGeneric(1);
} }
~WithGenericMethod_MethodA2() GRPC_OVERRIDE { ~WithGenericMethod_MethodA2() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA2(::grpc::ServerContext* context, ::grpc::ServerReader< ::grpc::testing::Request>* reader, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -216,11 +216,11 @@ class ServiceA GRPC_FINAL {
::grpc::Service::MarkMethodStreamed(0, ::grpc::Service::MarkMethodStreamed(0,
new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1, this, std::placeholders::_1, std::placeholders::_2))); new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodA1<BaseClass>::StreamedMethodA1, this, std::placeholders::_1, std::placeholders::_2)));
} }
~WithStreamedUnaryMethod_MethodA1() GRPC_OVERRIDE { ~WithStreamedUnaryMethod_MethodA1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable regular version of this method // disable regular version of this method
::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodA1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -233,7 +233,7 @@ class ServiceA GRPC_FINAL {
}; };
// ServiceB leading comment 1 // ServiceB leading comment 1
class ServiceB GRPC_FINAL { class ServiceB final {
public: public:
class StubInterface { class StubInterface {
public: public:
@ -247,17 +247,17 @@ class ServiceB GRPC_FINAL {
private: private:
virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) = 0;
}; };
class Stub GRPC_FINAL : public StubInterface { class Stub final : public StubInterface {
public: public:
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
::grpc::Status MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) GRPC_OVERRIDE; ::grpc::Status MethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::testing::Response* response) override;
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>> AsyncMethodB1(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodB1Raw(context, request, cq)); return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>>(AsyncMethodB1Raw(context, request, cq));
} }
private: private:
std::shared_ptr< ::grpc::ChannelInterface> channel_; std::shared_ptr< ::grpc::ChannelInterface> channel_;
::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) GRPC_OVERRIDE; ::grpc::ClientAsyncResponseReader< ::grpc::testing::Response>* AsyncMethodB1Raw(::grpc::ClientContext* context, const ::grpc::testing::Request& request, ::grpc::CompletionQueue* cq) override;
const ::grpc::RpcMethod rpcmethod_MethodB1_; const ::grpc::RpcMethod rpcmethod_MethodB1_;
}; };
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
@ -278,11 +278,11 @@ class ServiceB GRPC_FINAL {
WithAsyncMethod_MethodB1() { WithAsyncMethod_MethodB1() {
::grpc::Service::MarkMethodAsync(0); ::grpc::Service::MarkMethodAsync(0);
} }
~WithAsyncMethod_MethodB1() GRPC_OVERRIDE { ~WithAsyncMethod_MethodB1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -299,11 +299,11 @@ class ServiceB GRPC_FINAL {
WithGenericMethod_MethodB1() { WithGenericMethod_MethodB1() {
::grpc::Service::MarkMethodGeneric(0); ::grpc::Service::MarkMethodGeneric(0);
} }
~WithGenericMethod_MethodB1() GRPC_OVERRIDE { ~WithGenericMethod_MethodB1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable synchronous version of this method // disable synchronous version of this method
::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }
@ -317,11 +317,11 @@ class ServiceB GRPC_FINAL {
::grpc::Service::MarkMethodStreamed(0, ::grpc::Service::MarkMethodStreamed(0,
new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1, this, std::placeholders::_1, std::placeholders::_2))); new ::grpc::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>(std::bind(&WithStreamedUnaryMethod_MethodB1<BaseClass>::StreamedMethodB1, this, std::placeholders::_1, std::placeholders::_2)));
} }
~WithStreamedUnaryMethod_MethodB1() GRPC_OVERRIDE { ~WithStreamedUnaryMethod_MethodB1() override {
BaseClassMustBeDerivedFromService(this); BaseClassMustBeDerivedFromService(this);
} }
// disable regular version of this method // disable regular version of this method
::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) GRPC_FINAL GRPC_OVERRIDE { ::grpc::Status MethodB1(::grpc::ServerContext* context, const ::grpc::testing::Request* request, ::grpc::testing::Response* response) final override {
abort(); abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
} }

@ -56,7 +56,7 @@ class TestAuthPropertyIterator : public AuthPropertyIterator {
class AuthPropertyIteratorTest : public ::testing::Test { class AuthPropertyIteratorTest : public ::testing::Test {
protected: protected:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
ctx_ = grpc_auth_context_create(NULL); ctx_ = grpc_auth_context_create(NULL);
grpc_auth_context_add_cstring_property(ctx_, "name", "chapi"); grpc_auth_context_add_cstring_property(ctx_, "name", "chapi");
grpc_auth_context_add_cstring_property(ctx_, "name", "chapo"); grpc_auth_context_add_cstring_property(ctx_, "name", "chapo");
@ -64,7 +64,7 @@ class AuthPropertyIteratorTest : public ::testing::Test {
EXPECT_EQ(1, EXPECT_EQ(1,
grpc_auth_context_set_peer_identity_property_name(ctx_, "name")); grpc_auth_context_set_peer_identity_property_name(ctx_, "name"));
} }
void TearDown() GRPC_OVERRIDE { grpc_auth_context_release(ctx_); } void TearDown() override { grpc_auth_context_release(ctx_); }
grpc_auth_context* ctx_; grpc_auth_context* ctx_;
}; };

@ -211,10 +211,10 @@ bool plugin_has_sync_methods(std::unique_ptr<ServerBuilderPlugin>& plugin) {
// that needs to be tested here. // that needs to be tested here.
class ServerBuilderSyncPluginDisabler : public ::grpc::ServerBuilderOption { class ServerBuilderSyncPluginDisabler : public ::grpc::ServerBuilderOption {
public: public:
void UpdateArguments(ChannelArguments* arg) GRPC_OVERRIDE {} void UpdateArguments(ChannelArguments* arg) override {}
void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) void UpdatePlugins(
GRPC_OVERRIDE { std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override {
plugins->erase(std::remove_if(plugins->begin(), plugins->end(), plugins->erase(std::remove_if(plugins->begin(), plugins->end(),
plugin_has_sync_methods), plugin_has_sync_methods),
plugins->end()); plugins->end());
@ -246,7 +246,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> {
protected: protected:
AsyncEnd2endTest() { GetParam().Log(); } AsyncEnd2endTest() { GetParam().Log(); }
void SetUp() GRPC_OVERRIDE { void SetUp() override {
poll_overrider_.reset(new PollingOverrider(!GetParam().disable_blocking)); poll_overrider_.reset(new PollingOverrider(!GetParam().disable_blocking));
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
@ -269,7 +269,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> {
gpr_tls_set(&g_is_async_end2end_test, 1); gpr_tls_set(&g_is_async_end2end_test, 1);
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
server_->Shutdown(); server_->Shutdown();
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;

@ -58,11 +58,10 @@ using namespace gflags;
namespace grpc { namespace grpc {
namespace testing { namespace testing {
class ServiceImpl GRPC_FINAL class ServiceImpl final : public ::grpc::testing::EchoTestService::Service {
: public ::grpc::testing::EchoTestService::Service { Status BidiStream(
Status BidiStream(ServerContext* context, ServerContext* context,
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
GRPC_OVERRIDE {
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
while (stream->Read(&request)) { while (stream->Read(&request)) {

@ -92,12 +92,12 @@ class TestMetadataCredentialsPlugin : public MetadataCredentialsPlugin {
is_blocking_(is_blocking), is_blocking_(is_blocking),
is_successful_(is_successful) {} is_successful_(is_successful) {}
bool IsBlocking() const GRPC_OVERRIDE { return is_blocking_; } bool IsBlocking() const override { return is_blocking_; }
Status GetMetadata(grpc::string_ref service_url, grpc::string_ref method_name, Status GetMetadata(
const grpc::AuthContext& channel_auth_context, grpc::string_ref service_url, grpc::string_ref method_name,
std::multimap<grpc::string, grpc::string>* metadata) const grpc::AuthContext& channel_auth_context,
GRPC_OVERRIDE { std::multimap<grpc::string, grpc::string>* metadata) override {
EXPECT_GT(service_url.length(), 0UL); EXPECT_GT(service_url.length(), 0UL);
EXPECT_GT(method_name.length(), 0UL); EXPECT_GT(method_name.length(), 0UL);
EXPECT_TRUE(channel_auth_context.IsPeerAuthenticated()); EXPECT_TRUE(channel_auth_context.IsPeerAuthenticated());
@ -145,11 +145,11 @@ class TestAuthMetadataProcessor : public AuthMetadataProcessor {
} }
// Interface implementation // Interface implementation
bool IsBlocking() const GRPC_OVERRIDE { return is_blocking_; } bool IsBlocking() const override { return is_blocking_; }
Status Process(const InputMetadata& auth_metadata, AuthContext* context, Status Process(const InputMetadata& auth_metadata, AuthContext* context,
OutputMetadata* consumed_auth_metadata, OutputMetadata* consumed_auth_metadata,
OutputMetadata* response_metadata) GRPC_OVERRIDE { OutputMetadata* response_metadata) override {
EXPECT_TRUE(consumed_auth_metadata != nullptr); EXPECT_TRUE(consumed_auth_metadata != nullptr);
EXPECT_TRUE(context != nullptr); EXPECT_TRUE(context != nullptr);
EXPECT_TRUE(response_metadata != nullptr); EXPECT_TRUE(response_metadata != nullptr);
@ -185,7 +185,7 @@ class Proxy : public ::grpc::testing::EchoTestService::Service {
: stub_(grpc::testing::EchoTestService::NewStub(channel)) {} : stub_(grpc::testing::EchoTestService::NewStub(channel)) {}
Status Echo(ServerContext* server_context, const EchoRequest* request, Status Echo(ServerContext* server_context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
std::unique_ptr<ClientContext> client_context = std::unique_ptr<ClientContext> client_context =
ClientContext::FromServerContext(*server_context); ClientContext::FromServerContext(*server_context);
return stub_->Echo(client_context.get(), *request, response); return stub_->Echo(client_context.get(), *request, response);
@ -199,7 +199,7 @@ class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::EchoTestService::Service { : public ::grpc::testing::duplicate::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message("no package"); response->set_message("no package");
return Status::OK; return Status::OK;
} }
@ -229,7 +229,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> {
GetParam().Log(); GetParam().Log();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
if (is_server_started_) { if (is_server_started_) {
server_->Shutdown(); server_->Shutdown();
if (proxy_server_) proxy_server_->Shutdown(); if (proxy_server_) proxy_server_->Shutdown();
@ -1496,7 +1496,7 @@ class ResourceQuotaEnd2endTest : public End2endTest {
ResourceQuotaEnd2endTest() ResourceQuotaEnd2endTest()
: server_resource_quota_("server_resource_quota") {} : server_resource_quota_("server_resource_quota") {}
virtual void ConfigureServerBuilder(ServerBuilder* builder) GRPC_OVERRIDE { virtual void ConfigureServerBuilder(ServerBuilder* builder) override {
builder->SetResourceQuota(server_resource_quota_); builder->SetResourceQuota(server_resource_quota_);
} }

@ -78,35 +78,35 @@ namespace {
int global_num_connections = 0; int global_num_connections = 0;
int global_num_calls = 0; int global_num_calls = 0;
mutex global_mu; std::mutex global_mu;
void IncrementConnectionCounter() { void IncrementConnectionCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
++global_num_connections; ++global_num_connections;
} }
void ResetConnectionCounter() { void ResetConnectionCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
global_num_connections = 0; global_num_connections = 0;
} }
int GetConnectionCounterValue() { int GetConnectionCounterValue() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
return global_num_connections; return global_num_connections;
} }
void IncrementCallCounter() { void IncrementCallCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
++global_num_calls; ++global_num_calls;
} }
void ResetCallCounter() { void ResetCallCounter() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
global_num_calls = 0; global_num_calls = 0;
} }
int GetCallCounterValue() { int GetCallCounterValue() {
unique_lock<mutex> lock(global_mu); std::unique_lock<std::mutex> lock(global_mu);
return global_num_calls; return global_num_calls;
} }
@ -126,7 +126,7 @@ class CallDataImpl : public CallData {
: CallData(channel_data) {} : CallData(channel_data) {}
void StartTransportStreamOp(grpc_exec_ctx* exec_ctx, grpc_call_element* elem, void StartTransportStreamOp(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
TransportStreamOp* op) GRPC_OVERRIDE { TransportStreamOp* op) override {
// Incrementing the counter could be done from the ctor, but we want // Incrementing the counter could be done from the ctor, but we want
// to test that the individual methods are actually called correctly. // to test that the individual methods are actually called correctly.
if (op->recv_initial_metadata() != nullptr) IncrementCallCounter(); if (op->recv_initial_metadata() != nullptr) IncrementCallCounter();
@ -138,7 +138,7 @@ class FilterEnd2endTest : public ::testing::Test {
protected: protected:
FilterEnd2endTest() : server_host_("localhost") {} FilterEnd2endTest() : server_host_("localhost") {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << server_host_ << ":" << port; server_address_ << server_host_ << ":" << port;
// Setup server // Setup server
@ -150,7 +150,7 @@ class FilterEnd2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
server_->Shutdown(); server_->Shutdown();
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;

@ -75,7 +75,7 @@ class GenericEnd2endTest : public ::testing::Test {
protected: protected:
GenericEnd2endTest() : server_host_("localhost") {} GenericEnd2endTest() : server_host_("localhost") {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << server_host_ << ":" << port; server_address_ << server_host_ << ":" << port;
// Setup server // Setup server
@ -91,7 +91,7 @@ class GenericEnd2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
server_->Shutdown(); server_->Shutdown();
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;

@ -188,7 +188,7 @@ class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::EchoTestService::Service { : public ::grpc::testing::duplicate::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request->message() + "_dup"); response->set_message(request->message() + "_dup");
return Status::OK; return Status::OK;
} }
@ -230,7 +230,7 @@ class HybridEnd2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
if (server_) { if (server_) {
server_->Shutdown(); server_->Shutdown();
} }
@ -449,9 +449,9 @@ class StreamedUnaryDupPkg
: public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo< : public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo<
TestServiceImplDupPkg> { TestServiceImplDupPkg> {
public: public:
Status StreamedEcho(ServerContext* context, Status StreamedEcho(
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -487,9 +487,9 @@ TEST_F(HybridEnd2endTest,
class FullyStreamedUnaryDupPkg class FullyStreamedUnaryDupPkg
: public duplicate::EchoTestService::StreamedUnaryService { : public duplicate::EchoTestService::StreamedUnaryService {
public: public:
Status StreamedEcho(ServerContext* context, Status StreamedEcho(
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -528,7 +528,7 @@ class SplitResponseStreamDupPkg
public: public:
Status StreamedResponseStream( Status StreamedResponseStream(
ServerContext* context, ServerContext* context,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -568,7 +568,7 @@ class FullySplitStreamedDupPkg
public: public:
Status StreamedResponseStream( Status StreamedResponseStream(
ServerContext* context, ServerContext* context,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -605,9 +605,9 @@ TEST_F(HybridEnd2endTest,
// Add a second service that is fully server streamed // Add a second service that is fully server streamed
class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService { class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService {
public: public:
Status StreamedEcho(ServerContext* context, Status StreamedEcho(
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;
@ -620,7 +620,7 @@ class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService {
} }
Status StreamedResponseStream( Status StreamedResponseStream(
ServerContext* context, ServerContext* context,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) GRPC_OVERRIDE { ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req; EchoRequest req;
EchoResponse resp; EchoResponse resp;
uint32_t next_msg_sz; uint32_t next_msg_sz;

@ -61,46 +61,44 @@ namespace testing {
namespace { namespace {
template <class W, class R> template <class W, class R>
class MockClientReaderWriter GRPC_FINAL class MockClientReaderWriter final : public ClientReaderWriterInterface<W, R> {
: public ClientReaderWriterInterface<W, R> {
public: public:
void WaitForInitialMetadata() GRPC_OVERRIDE {} void WaitForInitialMetadata() override {}
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = UINT_MAX; *sz = UINT_MAX;
return true; return true;
} }
bool Read(R* msg) GRPC_OVERRIDE { return true; } bool Read(R* msg) override { return true; }
bool Write(const W& msg) GRPC_OVERRIDE { return true; } bool Write(const W& msg) override { return true; }
bool WritesDone() GRPC_OVERRIDE { return true; } bool WritesDone() override { return true; }
Status Finish() GRPC_OVERRIDE { return Status::OK; } Status Finish() override { return Status::OK; }
}; };
template <> template <>
class MockClientReaderWriter<EchoRequest, EchoResponse> GRPC_FINAL class MockClientReaderWriter<EchoRequest, EchoResponse> final
: public ClientReaderWriterInterface<EchoRequest, EchoResponse> { : public ClientReaderWriterInterface<EchoRequest, EchoResponse> {
public: public:
MockClientReaderWriter() : writes_done_(false) {} MockClientReaderWriter() : writes_done_(false) {}
void WaitForInitialMetadata() GRPC_OVERRIDE {} void WaitForInitialMetadata() override {}
bool NextMessageSize(uint32_t* sz) GRPC_OVERRIDE { bool NextMessageSize(uint32_t* sz) override {
*sz = UINT_MAX; *sz = UINT_MAX;
return true; return true;
} }
bool Read(EchoResponse* msg) GRPC_OVERRIDE { bool Read(EchoResponse* msg) override {
if (writes_done_) return false; if (writes_done_) return false;
msg->set_message(last_message_); msg->set_message(last_message_);
return true; return true;
} }
bool Write(const EchoRequest& msg, bool Write(const EchoRequest& msg, const WriteOptions& options) override {
const WriteOptions& options) GRPC_OVERRIDE {
gpr_log(GPR_INFO, "mock recv msg %s", msg.message().c_str()); gpr_log(GPR_INFO, "mock recv msg %s", msg.message().c_str());
last_message_ = msg.message(); last_message_ = msg.message();
return true; return true;
} }
bool WritesDone() GRPC_OVERRIDE { bool WritesDone() override {
writes_done_ = true; writes_done_ = true;
return true; return true;
} }
Status Finish() GRPC_OVERRIDE { return Status::OK; } Status Finish() override { return Status::OK; }
private: private:
bool writes_done_; bool writes_done_;
@ -113,51 +111,51 @@ class MockStub : public EchoTestService::StubInterface {
MockStub() {} MockStub() {}
~MockStub() {} ~MockStub() {}
Status Echo(ClientContext* context, const EchoRequest& request, Status Echo(ClientContext* context, const EchoRequest& request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request.message()); response->set_message(request.message());
return Status::OK; return Status::OK;
} }
Status Unimplemented(ClientContext* context, const EchoRequest& request, Status Unimplemented(ClientContext* context, const EchoRequest& request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
return Status::OK; return Status::OK;
} }
private: private:
ClientAsyncResponseReaderInterface<EchoResponse>* AsyncEchoRaw( ClientAsyncResponseReaderInterface<EchoResponse>* AsyncEchoRaw(
ClientContext* context, const EchoRequest& request, ClientContext* context, const EchoRequest& request,
CompletionQueue* cq) GRPC_OVERRIDE { CompletionQueue* cq) override {
return nullptr; return nullptr;
} }
ClientWriterInterface<EchoRequest>* RequestStreamRaw( ClientWriterInterface<EchoRequest>* RequestStreamRaw(
ClientContext* context, EchoResponse* response) GRPC_OVERRIDE { ClientContext* context, EchoResponse* response) override {
return nullptr; return nullptr;
} }
ClientAsyncWriterInterface<EchoRequest>* AsyncRequestStreamRaw( ClientAsyncWriterInterface<EchoRequest>* AsyncRequestStreamRaw(
ClientContext* context, EchoResponse* response, CompletionQueue* cq, ClientContext* context, EchoResponse* response, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE { void* tag) override {
return nullptr; return nullptr;
} }
ClientReaderInterface<EchoResponse>* ResponseStreamRaw( ClientReaderInterface<EchoResponse>* ResponseStreamRaw(
ClientContext* context, const EchoRequest& request) GRPC_OVERRIDE { ClientContext* context, const EchoRequest& request) override {
return nullptr; return nullptr;
} }
ClientAsyncReaderInterface<EchoResponse>* AsyncResponseStreamRaw( ClientAsyncReaderInterface<EchoResponse>* AsyncResponseStreamRaw(
ClientContext* context, const EchoRequest& request, CompletionQueue* cq, ClientContext* context, const EchoRequest& request, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE { void* tag) override {
return nullptr; return nullptr;
} }
ClientReaderWriterInterface<EchoRequest, EchoResponse>* BidiStreamRaw( ClientReaderWriterInterface<EchoRequest, EchoResponse>* BidiStreamRaw(
ClientContext* context) GRPC_OVERRIDE { ClientContext* context) override {
return new MockClientReaderWriter<EchoRequest, EchoResponse>(); return new MockClientReaderWriter<EchoRequest, EchoResponse>();
} }
ClientAsyncReaderWriterInterface<EchoRequest, EchoResponse>* ClientAsyncReaderWriterInterface<EchoRequest, EchoResponse>*
AsyncBidiStreamRaw(ClientContext* context, CompletionQueue* cq, AsyncBidiStreamRaw(ClientContext* context, CompletionQueue* cq,
void* tag) GRPC_OVERRIDE { void* tag) override {
return nullptr; return nullptr;
} }
ClientAsyncResponseReaderInterface<EchoResponse>* AsyncUnimplementedRaw( ClientAsyncResponseReaderInterface<EchoResponse>* AsyncUnimplementedRaw(
ClientContext* context, const EchoRequest& request, ClientContext* context, const EchoRequest& request,
CompletionQueue* cq) GRPC_OVERRIDE { CompletionQueue* cq) override {
return nullptr; return nullptr;
} }
}; };
@ -216,14 +214,14 @@ class FakeClient {
class TestServiceImpl : public EchoTestService::Service { class TestServiceImpl : public EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request->message()); response->set_message(request->message());
return Status::OK; return Status::OK;
} }
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
while (stream->Read(&request)) { while (stream->Read(&request)) {
@ -239,7 +237,7 @@ class MockTest : public ::testing::Test {
protected: protected:
MockTest() {} MockTest() {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << "localhost:" << port; server_address_ << "localhost:" << port;
// Setup server // Setup server
@ -250,7 +248,7 @@ class MockTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void TearDown() override { server_->Shutdown(); }
void ResetStub() { void ResetStub() {
std::shared_ptr<Channel> channel = std::shared_ptr<Channel> channel =

@ -56,7 +56,7 @@ class ProtoServerReflectionTest : public ::testing::Test {
public: public:
ProtoServerReflectionTest() {} ProtoServerReflectionTest() {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
ref_desc_pool_ = protobuf::DescriptorPool::generated_pool(); ref_desc_pool_ = protobuf::DescriptorPool::generated_pool();

@ -0,0 +1,211 @@
/*
*
* Copyright 2016, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <memory>
#include <mutex>
#include <thread>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "test/cpp/end2end/test_service_impl.h"
using grpc::testing::EchoRequest;
using grpc::testing::EchoResponse;
using std::chrono::system_clock;
namespace grpc {
namespace testing {
namespace {
// Subclass of TestServiceImpl that increments a request counter for
// every call to the Echo RPC.
class MyTestServiceImpl : public TestServiceImpl {
public:
MyTestServiceImpl() : request_count_(0) {}
Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) override {
{
std::unique_lock<std::mutex> lock(mu_);
++request_count_;
}
return TestServiceImpl::Echo(context, request, response);
}
int request_count() {
std::unique_lock<std::mutex> lock(mu_);
return request_count_;
}
private:
std::mutex mu_;
int request_count_;
};
class RoundRobinEnd2endTest : public ::testing::Test {
protected:
RoundRobinEnd2endTest() : server_host_("localhost") {}
void StartServers(int num_servers) {
for (int i = 0; i < num_servers; ++i) {
servers_.emplace_back(new ServerData(server_host_));
}
}
void TearDown() override {
for (size_t i = 0; i < servers_.size(); ++i) {
servers_[i]->Shutdown();
}
}
void ResetStub(bool round_robin) {
ChannelArguments args;
if (round_robin) args.SetLoadBalancingPolicyName("round_robin");
std::ostringstream uri;
uri << "ipv4:///";
for (size_t i = 0; i < servers_.size() - 1; ++i) {
uri << "127.0.0.1:" << servers_[i]->port_ << ",";
}
uri << "127.0.0.1:" << servers_[servers_.size() - 1]->port_;
std::shared_ptr<Channel> channel =
CreateCustomChannel(uri.str(), InsecureChannelCredentials(), args);
stub_ = grpc::testing::EchoTestService::NewStub(channel);
}
void SendRpc(int num_rpcs) {
EchoRequest request;
EchoResponse response;
request.set_message("Live long and prosper.");
for (int i = 0; i < num_rpcs; i++) {
ClientContext context;
Status status = stub_->Echo(&context, request, &response);
EXPECT_TRUE(status.ok());
EXPECT_EQ(response.message(), request.message());
}
}
struct ServerData {
int port_;
std::unique_ptr<Server> server_;
MyTestServiceImpl service_;
std::unique_ptr<std::thread> thread_;
explicit ServerData(const grpc::string& server_host) {
port_ = grpc_pick_unused_port_or_die();
gpr_log(GPR_INFO, "starting server on port %d", port_);
std::mutex mu;
std::condition_variable cond;
thread_.reset(new std::thread(
std::bind(&ServerData::Start, this, server_host, &mu, &cond)));
std::unique_lock<std::mutex> lock(mu);
cond.wait(lock);
gpr_log(GPR_INFO, "server startup complete");
}
void Start(const grpc::string& server_host, std::mutex* mu,
std::condition_variable* cond) {
std::ostringstream server_address;
server_address << server_host << ":" << port_;
ServerBuilder builder;
builder.AddListeningPort(server_address.str(),
InsecureServerCredentials());
builder.RegisterService(&service_);
server_ = builder.BuildAndStart();
std::lock_guard<std::mutex> lock(*mu);
cond->notify_one();
}
void Shutdown() {
server_->Shutdown();
thread_->join();
}
};
const grpc::string server_host_;
CompletionQueue cli_cq_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::vector<std::unique_ptr<ServerData>> servers_;
};
TEST_F(RoundRobinEnd2endTest, PickFirst) {
// Start servers and send one RPC per server.
const int kNumServers = 3;
StartServers(kNumServers);
ResetStub(false /* round_robin */);
SendRpc(kNumServers);
// All requests should have gone to a single server.
bool found = false;
for (size_t i = 0; i < servers_.size(); ++i) {
const int request_count = servers_[i]->service_.request_count();
if (request_count == kNumServers) {
found = true;
} else {
EXPECT_EQ(0, request_count);
}
}
EXPECT_TRUE(found);
}
TEST_F(RoundRobinEnd2endTest, RoundRobin) {
// Start servers and send one RPC per server.
const int kNumServers = 3;
StartServers(kNumServers);
ResetStub(true /* round_robin */);
SendRpc(kNumServers);
// One request should have gone to each server.
for (size_t i = 0; i < servers_.size(); ++i) {
EXPECT_EQ(1, servers_[i]->service_.request_count());
}
}
} // namespace
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc_test_init(argc, argv);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

@ -31,13 +31,14 @@
* *
*/ */
#include <thread>
#include <grpc++/channel.h> #include <grpc++/channel.h>
#include <grpc++/client_context.h> #include <grpc++/client_context.h>
#include <grpc++/create_channel.h> #include <grpc++/create_channel.h>
#include <grpc++/impl/server_builder_option.h> #include <grpc++/impl/server_builder_option.h>
#include <grpc++/impl/server_builder_plugin.h> #include <grpc++/impl/server_builder_plugin.h>
#include <grpc++/impl/server_initializer.h> #include <grpc++/impl/server_initializer.h>
#include <grpc++/impl/thd.h>
#include <grpc++/security/credentials.h> #include <grpc++/security/credentials.h>
#include <grpc++/security/server_credentials.h> #include <grpc++/security/server_credentials.h>
#include <grpc++/server.h> #include <grpc++/server.h>
@ -65,29 +66,29 @@ class TestServerBuilderPlugin : public ServerBuilderPlugin {
register_service_ = false; register_service_ = false;
} }
grpc::string name() GRPC_OVERRIDE { return PLUGIN_NAME; } grpc::string name() override { return PLUGIN_NAME; }
void InitServer(ServerInitializer* si) GRPC_OVERRIDE { void InitServer(ServerInitializer* si) override {
init_server_is_called_ = true; init_server_is_called_ = true;
if (register_service_) { if (register_service_) {
si->RegisterService(service_); si->RegisterService(service_);
} }
} }
void Finish(ServerInitializer* si) GRPC_OVERRIDE { finish_is_called_ = true; } void Finish(ServerInitializer* si) override { finish_is_called_ = true; }
void ChangeArguments(const grpc::string& name, void* value) GRPC_OVERRIDE { void ChangeArguments(const grpc::string& name, void* value) override {
change_arguments_is_called_ = true; change_arguments_is_called_ = true;
} }
bool has_async_methods() const GRPC_OVERRIDE { bool has_async_methods() const override {
if (register_service_) { if (register_service_) {
return service_->has_async_methods(); return service_->has_async_methods();
} }
return false; return false;
} }
bool has_sync_methods() const GRPC_OVERRIDE { bool has_sync_methods() const override {
if (register_service_) { if (register_service_) {
return service_->has_synchronous_methods(); return service_->has_synchronous_methods();
} }
@ -112,10 +113,10 @@ class InsertPluginServerBuilderOption : public ServerBuilderOption {
public: public:
InsertPluginServerBuilderOption() { register_service_ = false; } InsertPluginServerBuilderOption() { register_service_ = false; }
void UpdateArguments(ChannelArguments* arg) GRPC_OVERRIDE {} void UpdateArguments(ChannelArguments* arg) override {}
void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) void UpdatePlugins(
GRPC_OVERRIDE { std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override {
plugins->clear(); plugins->clear();
std::unique_ptr<TestServerBuilderPlugin> plugin( std::unique_ptr<TestServerBuilderPlugin> plugin(
@ -154,7 +155,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
public: public:
ServerBuilderPluginTest() {} ServerBuilderPluginTest() {}
void SetUp() GRPC_OVERRIDE { void SetUp() override {
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
builder_.reset(new ServerBuilder()); builder_.reset(new ServerBuilder());
} }
@ -191,7 +192,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
// we run some tests without a service, and for those we need to supply a // we run some tests without a service, and for those we need to supply a
// frequently polled completion queue // frequently polled completion queue
cq_ = builder_->AddCompletionQueue(); cq_ = builder_->AddCompletionQueue();
cq_thread_ = new grpc::thread(&ServerBuilderPluginTest::RunCQ, this); cq_thread_ = new std::thread(&ServerBuilderPluginTest::RunCQ, this);
server_ = builder_->BuildAndStart(); server_ = builder_->BuildAndStart();
EXPECT_TRUE(CheckPresent()); EXPECT_TRUE(CheckPresent());
} }
@ -202,7 +203,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
stub_ = grpc::testing::EchoTestService::NewStub(channel_); stub_ = grpc::testing::EchoTestService::NewStub(channel_);
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
auto plugin = CheckPresent(); auto plugin = CheckPresent();
EXPECT_TRUE(plugin); EXPECT_TRUE(plugin);
EXPECT_TRUE(plugin->init_server_is_called()); EXPECT_TRUE(plugin->init_server_is_called());
@ -225,7 +226,7 @@ class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<ServerCompletionQueue> cq_; std::unique_ptr<ServerCompletionQueue> cq_;
std::unique_ptr<Server> server_; std::unique_ptr<Server> server_;
grpc::thread* cq_thread_; std::thread* cq_thread_;
TestServiceImpl service_; TestServiceImpl service_;
int port_; int port_;

@ -60,14 +60,13 @@ namespace testing {
namespace { namespace {
class ServiceImpl GRPC_FINAL class ServiceImpl final : public ::grpc::testing::EchoTestService::Service {
: public ::grpc::testing::EchoTestService::Service {
public: public:
ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {} ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {}
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
bidi_stream_count_++; bidi_stream_count_++;
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
@ -82,7 +81,7 @@ class ServiceImpl GRPC_FINAL
} }
Status ResponseStream(ServerContext* context, const EchoRequest* request, Status ResponseStream(ServerContext* context, const EchoRequest* request,
ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE { ServerWriter<EchoResponse>* writer) override {
EchoResponse response; EchoResponse response;
response_stream_count_++; response_stream_count_++;
for (int i = 0;; i++) { for (int i = 0;; i++) {

@ -61,7 +61,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {} explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {}
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
gpr_event_set(ev_, (void*)1); gpr_event_set(ev_, (void*)1);
while (!context->IsCancelled()) { while (!context->IsCancelled()) {
} }
@ -76,7 +76,7 @@ class ShutdownTest : public ::testing::Test {
public: public:
ShutdownTest() : shutdown_(false), service_(&ev_) { gpr_event_init(&ev_); } ShutdownTest() : shutdown_(false), service_(&ev_) { gpr_event_init(&ev_); }
void SetUp() GRPC_OVERRIDE { void SetUp() override {
port_ = grpc_pick_unused_port_or_die(); port_ = grpc_pick_unused_port_or_die();
server_ = SetUpServer(port_); server_ = SetUpServer(port_);
} }
@ -91,7 +91,7 @@ class ShutdownTest : public ::testing::Test {
return server; return server;
} }
void TearDown() GRPC_OVERRIDE { GPR_ASSERT(shutdown_); } void TearDown() override { GPR_ASSERT(shutdown_); }
void ResetStub() { void ResetStub() {
string target = "dns:localhost:" + to_string(port_); string target = "dns:localhost:" + to_string(port_);

@ -121,9 +121,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
} }
// Only implement the one method we will be calling for brevity. // Only implement the one method we will be calling for brevity.
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
EchoRequest request; EchoRequest request;
gpr_atm should_exit; gpr_atm should_exit;
gpr_atm_rel_store(&should_exit, static_cast<gpr_atm>(0)); gpr_atm_rel_store(&should_exit, static_cast<gpr_atm>(0));
@ -147,7 +147,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
class End2endTest : public ::testing::Test { class End2endTest : public ::testing::Test {
protected: protected:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
int port = grpc_pick_unused_port_or_die(); int port = grpc_pick_unused_port_or_die();
server_address_ << "localhost:" << port; server_address_ << "localhost:" << port;
// Setup server // Setup server
@ -158,7 +158,7 @@ class End2endTest : public ::testing::Test {
server_ = builder.BuildAndStart(); server_ = builder.BuildAndStart();
} }
void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void TearDown() override { server_->Shutdown(); }
void ResetStub() { void ResetStub() {
std::shared_ptr<Channel> channel = std::shared_ptr<Channel> channel =

@ -63,20 +63,20 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
: signal_client_(false), host_(new grpc::string(host)) {} : signal_client_(false), host_(new grpc::string(host)) {}
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE; EchoResponse* response) override;
// Unimplemented is left unimplemented to test the returned error. // Unimplemented is left unimplemented to test the returned error.
Status RequestStream(ServerContext* context, Status RequestStream(ServerContext* context,
ServerReader<EchoRequest>* reader, ServerReader<EchoRequest>* reader,
EchoResponse* response) GRPC_OVERRIDE; EchoResponse* response) override;
Status ResponseStream(ServerContext* context, const EchoRequest* request, Status ResponseStream(ServerContext* context, const EchoRequest* request,
ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE; ServerWriter<EchoResponse>* writer) override;
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE; ServerReaderWriter<EchoResponse, EchoRequest>* stream) override;
bool signal_client() { bool signal_client() {
std::unique_lock<std::mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);

@ -86,12 +86,12 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
TestServiceImpl() : signal_client_(false) {} TestServiceImpl() : signal_client_(false) {}
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message(request->message()); response->set_message(request->message());
MaybeEchoDeadline(context, request, response); MaybeEchoDeadline(context, request, response);
if (request->has_param() && request->param().client_cancel_after_us()) { if (request->has_param() && request->param().client_cancel_after_us()) {
{ {
unique_lock<mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
signal_client_ = true; signal_client_ = true;
} }
while (!context->IsCancelled()) { while (!context->IsCancelled()) {
@ -118,7 +118,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
Status RequestStream(ServerContext* context, Status RequestStream(ServerContext* context,
ServerReader<EchoRequest>* reader, ServerReader<EchoRequest>* reader,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
EchoRequest request; EchoRequest request;
response->set_message(""); response->set_message("");
while (reader->Read(&request)) { while (reader->Read(&request)) {
@ -130,7 +130,7 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
// Return 3 messages. // Return 3 messages.
// TODO(yangg) make it generic by adding a parameter into EchoRequest // TODO(yangg) make it generic by adding a parameter into EchoRequest
Status ResponseStream(ServerContext* context, const EchoRequest* request, Status ResponseStream(ServerContext* context, const EchoRequest* request,
ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE { ServerWriter<EchoResponse>* writer) override {
EchoResponse response; EchoResponse response;
response.set_message(request->message() + "0"); response.set_message(request->message() + "0");
writer->Write(response); writer->Write(response);
@ -142,9 +142,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
return Status::OK; return Status::OK;
} }
Status BidiStream(ServerContext* context, Status BidiStream(
ServerReaderWriter<EchoResponse, EchoRequest>* stream) ServerContext* context,
GRPC_OVERRIDE { ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
EchoRequest request; EchoRequest request;
EchoResponse response; EchoResponse response;
while (stream->Read(&request)) { while (stream->Read(&request)) {
@ -156,20 +156,20 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
} }
bool signal_client() { bool signal_client() {
unique_lock<mutex> lock(mu_); std::unique_lock<std::mutex> lock(mu_);
return signal_client_; return signal_client_;
} }
private: private:
bool signal_client_; bool signal_client_;
mutex mu_; std::mutex mu_;
}; };
class TestServiceImplDupPkg class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::EchoTestService::Service { : public ::grpc::testing::duplicate::EchoTestService::Service {
public: public:
Status Echo(ServerContext* context, const EchoRequest* request, Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE { EchoResponse* response) override {
response->set_message("no package"); response->set_message("no package");
return Status::OK; return Status::OK;
} }
@ -215,12 +215,12 @@ class CommonStressTest {
class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> { class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> {
public: public:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
ServerBuilder builder; ServerBuilder builder;
SetUpStart(&builder, &service_); SetUpStart(&builder, &service_);
SetUpEnd(&builder); SetUpEnd(&builder);
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
TearDownStart(); TearDownStart();
TearDownEnd(); TearDownEnd();
} }
@ -232,7 +232,7 @@ class CommonStressTestSyncServer : public CommonStressTest<TestServiceImpl> {
class CommonStressTestAsyncServer class CommonStressTestAsyncServer
: public CommonStressTest<grpc::testing::EchoTestService::AsyncService> { : public CommonStressTest<grpc::testing::EchoTestService::AsyncService> {
public: public:
void SetUp() GRPC_OVERRIDE { void SetUp() override {
shutting_down_ = false; shutting_down_ = false;
ServerBuilder builder; ServerBuilder builder;
SetUpStart(&builder, &service_); SetUpStart(&builder, &service_);
@ -247,9 +247,9 @@ class CommonStressTestAsyncServer
new std::thread(&CommonStressTestAsyncServer::ProcessRpcs, this)); new std::thread(&CommonStressTestAsyncServer::ProcessRpcs, this));
} }
} }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
{ {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
TearDownStart(); TearDownStart();
shutting_down_ = true; shutting_down_ = true;
cq_->Shutdown(); cq_->Shutdown();
@ -292,7 +292,7 @@ class CommonStressTestAsyncServer
} }
} }
void RefreshContext(int i) { void RefreshContext(int i) {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
if (!shutting_down_) { if (!shutting_down_) {
contexts_[i].state = Context::READY; contexts_[i].state = Context::READY;
contexts_[i].srv_ctx.reset(new ServerContext); contexts_[i].srv_ctx.reset(new ServerContext);
@ -315,7 +315,7 @@ class CommonStressTestAsyncServer
::grpc::testing::EchoTestService::AsyncService service_; ::grpc::testing::EchoTestService::AsyncService service_;
std::unique_ptr<ServerCompletionQueue> cq_; std::unique_ptr<ServerCompletionQueue> cq_;
bool shutting_down_; bool shutting_down_;
mutex mu_; std::mutex mu_;
std::vector<std::thread*> server_threads_; std::vector<std::thread*> server_threads_;
}; };
@ -323,8 +323,8 @@ template <class Common>
class End2endTest : public ::testing::Test { class End2endTest : public ::testing::Test {
protected: protected:
End2endTest() {} End2endTest() {}
void SetUp() GRPC_OVERRIDE { common_.SetUp(); } void SetUp() override { common_.SetUp(); }
void TearDown() GRPC_OVERRIDE { common_.TearDown(); } void TearDown() override { common_.TearDown(); }
void ResetStub() { common_.ResetStub(); } void ResetStub() { common_.ResetStub(); }
Common common_; Common common_;
@ -369,8 +369,8 @@ class AsyncClientEnd2endTest : public ::testing::Test {
protected: protected:
AsyncClientEnd2endTest() : rpcs_outstanding_(0) {} AsyncClientEnd2endTest() : rpcs_outstanding_(0) {}
void SetUp() GRPC_OVERRIDE { common_.SetUp(); } void SetUp() override { common_.SetUp(); }
void TearDown() GRPC_OVERRIDE { void TearDown() override {
void* ignored_tag; void* ignored_tag;
bool ignored_ok; bool ignored_ok;
while (cq_.Next(&ignored_tag, &ignored_ok)) while (cq_.Next(&ignored_tag, &ignored_ok))
@ -379,7 +379,7 @@ class AsyncClientEnd2endTest : public ::testing::Test {
} }
void Wait() { void Wait() {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
while (rpcs_outstanding_ != 0) { while (rpcs_outstanding_ != 0) {
cv_.wait(l); cv_.wait(l);
} }
@ -404,7 +404,7 @@ class AsyncClientEnd2endTest : public ::testing::Test {
call->response_reader->Finish(&call->response, &call->status, call->response_reader->Finish(&call->response, &call->status,
(void*)call); (void*)call);
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
rpcs_outstanding_++; rpcs_outstanding_++;
} }
} }
@ -422,7 +422,7 @@ class AsyncClientEnd2endTest : public ::testing::Test {
bool notify; bool notify;
{ {
unique_lock<mutex> l(mu_); std::unique_lock<std::mutex> l(mu_);
rpcs_outstanding_--; rpcs_outstanding_--;
notify = (rpcs_outstanding_ == 0); notify = (rpcs_outstanding_ == 0);
} }
@ -434,8 +434,8 @@ class AsyncClientEnd2endTest : public ::testing::Test {
Common common_; Common common_;
CompletionQueue cq_; CompletionQueue cq_;
mutex mu_; std::mutex mu_;
condition_variable cv_; std::condition_variable cv_;
int rpcs_outstanding_; int rpcs_outstanding_;
}; };

@ -76,10 +76,22 @@ extern "C" {
// - Send a serverlist with faulty ip:port addresses (port > 2^16, etc). // - Send a serverlist with faulty ip:port addresses (port > 2^16, etc).
// - Test reception of invalid serverlist // - Test reception of invalid serverlist
// - Test pinging // - Test pinging
// - Test against a non-LB server. That server should return UNIMPLEMENTED and // - Test against a non-LB server.
// the call should fail.
// - Random LB server closing the stream unexpectedly. // - Random LB server closing the stream unexpectedly.
// - Test using DNS-resolvable names (localhost?) // - Test using DNS-resolvable names (localhost?)
//
// Findings from end to end testing to be covered here:
// - Handling of LB servers restart, including reconnection after backing-off
// retries.
// - Destruction of load balanced channel (and therefore of grpclb instance)
// while:
// 1) the internal LB call is still active. This should work by virtue
// of the weak reference the LB call holds. The call should be terminated as
// part of the grpclb shutdown process.
// 2) the retry timer is active. Again, the weak reference it holds should
// prevent a premature call to \a glb_destroy.
// - Restart of backend servers with no changes to serverlist. This exercises
// the RR handover mechanism.
namespace grpc { namespace grpc {
namespace { namespace {
@ -144,7 +156,6 @@ static gpr_slice build_response_payload_slice(
// disfunctional implementation of std::to_string in gcc 4.4, which doesn't // disfunctional implementation of std::to_string in gcc 4.4, which doesn't
// have a version for int but does have one for long long int. // have a version for int but does have one for long long int.
string token_data = "token" + std::to_string((long long int)ports[i]); string token_data = "token" + std::to_string((long long int)ports[i]);
token_data.resize(64, '-');
server->set_load_balance_token(token_data); server->set_load_balance_token(token_data);
} }
const grpc::string &enc_resp = response.SerializeAsString(); const grpc::string &enc_resp = response.SerializeAsString();
@ -333,7 +344,6 @@ static void start_backend_server(server_fixture *sf) {
// disfunctional implementation of std::to_string in gcc 4.4, which doesn't // disfunctional implementation of std::to_string in gcc 4.4, which doesn't
// have a version for int but does have one for long long int. // have a version for int but does have one for long long int.
string expected_token = "token" + std::to_string((long long int)sf->port); string expected_token = "token" + std::to_string((long long int)sf->port);
expected_token.resize(64, '-');
GPR_ASSERT(contains_metadata(&request_metadata_recv, "lb-token", GPR_ASSERT(contains_metadata(&request_metadata_recv, "lb-token",
expected_token.c_str())); expected_token.c_str()));

@ -40,7 +40,6 @@
#include <gflags/gflags.h> #include <gflags/gflags.h>
#include <grpc++/create_channel.h> #include <grpc++/create_channel.h>
#include <grpc++/grpc++.h> #include <grpc++/grpc++.h>
#include <grpc++/impl/thd.h>
#include <grpc/support/log.h> #include <grpc/support/log.h>
#include <grpc/support/time.h> #include <grpc/support/time.h>
@ -321,7 +320,7 @@ int main(int argc, char** argv) {
gpr_log(GPR_INFO, "Starting test(s).."); gpr_log(GPR_INFO, "Starting test(s)..");
std::vector<grpc::thread> test_threads; std::vector<std::thread> test_threads;
// Create and start the test threads. // Create and start the test threads.
// Note that: // Note that:
@ -361,7 +360,7 @@ int main(int argc, char** argv) {
"/stress_test/server_%d/channel_%d/stub_%d/qps", "/stress_test/server_%d/channel_%d/stub_%d/qps",
server_idx, channel_idx, stub_idx); server_idx, channel_idx, stub_idx);
test_threads.emplace_back(grpc::thread( test_threads.emplace_back(std::thread(
&StressTestInteropClient::MainLoop, client, &StressTestInteropClient::MainLoop, client,
metrics_service.CreateQpsGauge(buffer, &is_already_created))); metrics_service.CreateQpsGauge(buffer, &is_already_created)));

@ -113,7 +113,7 @@ class ClientRequestCreator<ByteBuffer> {
} }
}; };
class HistogramEntry GRPC_FINAL { class HistogramEntry final {
public: public:
HistogramEntry() : value_used_(false), status_used_(false) {} HistogramEntry() : value_used_(false), status_used_(false) {}
bool value_used() const { return value_used_; } bool value_used() const { return value_used_; }

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save