Merge branch 'reuse_port' into reuse_affinity

pull/6645/head
Craig Tiller 9 years ago
commit 26246e5eb3
  1. 282
      Makefile
  2. 104
      build.yaml
  3. 2
      src/core/lib/iomgr/error.c
  4. 10
      src/core/lib/surface/server.c
  5. 5
      src/ruby/lib/grpc/errors.rb
  6. 65
      src/ruby/lib/grpc/generic/active_call.rb
  7. 85
      src/ruby/lib/grpc/generic/client_stub.rb
  8. 8
      src/ruby/lib/grpc/generic/rpc_desc.rb
  9. 19
      src/ruby/lib/grpc/generic/rpc_server.rb
  10. 16
      src/ruby/lib/grpc/generic/service.rb
  11. 7
      src/ruby/pb/test/client.rb
  12. 4
      src/ruby/qps/client.rb
  13. 5
      src/ruby/qps/server.rb
  14. 5
      src/ruby/spec/generic/active_call_spec.rb
  15. 51
      src/ruby/spec/generic/client_stub_spec.rb
  16. 22
      src/ruby/spec/generic/rpc_desc_spec.rb
  17. 103
      src/ruby/spec/generic/rpc_server_spec.rb
  18. 8
      src/ruby/spec/pb/health/checker_spec.rb
  19. 9
      templates/tools/dockerfile/test/sanity/Dockerfile.template
  20. 15
      test/core/client_config/set_initial_connect_string_test.c
  21. 2
      test/core/end2end/tests/request_with_flags.c
  22. 78
      test/cpp/qps/async_streaming_ping_pong_test.cc
  23. 77
      test/cpp/qps/async_unary_ping_pong_test.cc
  24. 3
      test/cpp/qps/gen_build_yaml.py
  25. 82
      test/cpp/qps/generic_async_streaming_ping_pong_test.cc
  26. 2
      test/cpp/qps/server_async.cc
  27. 76
      test/cpp/qps/sync_streaming_ping_pong_test.cc
  28. 77
      test/cpp/qps/sync_unary_ping_pong_test.cc
  29. 8
      tools/dockerfile/test/sanity/Dockerfile
  30. 33
      tools/run_tests/performance/scenario_config.py
  31. 115
      tools/run_tests/sources_and_headers.json
  32. 250
      tools/run_tests/tests.json

@ -1001,8 +1001,6 @@ uri_parser_test: $(BINDIR)/$(CONFIG)/uri_parser_test
workqueue_test: $(BINDIR)/$(CONFIG)/workqueue_test workqueue_test: $(BINDIR)/$(CONFIG)/workqueue_test
alarm_cpp_test: $(BINDIR)/$(CONFIG)/alarm_cpp_test alarm_cpp_test: $(BINDIR)/$(CONFIG)/alarm_cpp_test
async_end2end_test: $(BINDIR)/$(CONFIG)/async_end2end_test async_end2end_test: $(BINDIR)/$(CONFIG)/async_end2end_test
async_streaming_ping_pong_test: $(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test
async_unary_ping_pong_test: $(BINDIR)/$(CONFIG)/async_unary_ping_pong_test
auth_property_iterator_test: $(BINDIR)/$(CONFIG)/auth_property_iterator_test auth_property_iterator_test: $(BINDIR)/$(CONFIG)/auth_property_iterator_test
channel_arguments_test: $(BINDIR)/$(CONFIG)/channel_arguments_test channel_arguments_test: $(BINDIR)/$(CONFIG)/channel_arguments_test
cli_call_test: $(BINDIR)/$(CONFIG)/cli_call_test cli_call_test: $(BINDIR)/$(CONFIG)/cli_call_test
@ -1016,7 +1014,6 @@ cxx_slice_test: $(BINDIR)/$(CONFIG)/cxx_slice_test
cxx_string_ref_test: $(BINDIR)/$(CONFIG)/cxx_string_ref_test cxx_string_ref_test: $(BINDIR)/$(CONFIG)/cxx_string_ref_test
cxx_time_test: $(BINDIR)/$(CONFIG)/cxx_time_test cxx_time_test: $(BINDIR)/$(CONFIG)/cxx_time_test
end2end_test: $(BINDIR)/$(CONFIG)/end2end_test end2end_test: $(BINDIR)/$(CONFIG)/end2end_test
generic_async_streaming_ping_pong_test: $(BINDIR)/$(CONFIG)/generic_async_streaming_ping_pong_test
generic_end2end_test: $(BINDIR)/$(CONFIG)/generic_end2end_test generic_end2end_test: $(BINDIR)/$(CONFIG)/generic_end2end_test
golden_file_test: $(BINDIR)/$(CONFIG)/golden_file_test golden_file_test: $(BINDIR)/$(CONFIG)/golden_file_test
grpc_cli: $(BINDIR)/$(CONFIG)/grpc_cli grpc_cli: $(BINDIR)/$(CONFIG)/grpc_cli
@ -1037,7 +1034,6 @@ mock_test: $(BINDIR)/$(CONFIG)/mock_test
qps_interarrival_test: $(BINDIR)/$(CONFIG)/qps_interarrival_test qps_interarrival_test: $(BINDIR)/$(CONFIG)/qps_interarrival_test
qps_json_driver: $(BINDIR)/$(CONFIG)/qps_json_driver qps_json_driver: $(BINDIR)/$(CONFIG)/qps_json_driver
qps_openloop_test: $(BINDIR)/$(CONFIG)/qps_openloop_test qps_openloop_test: $(BINDIR)/$(CONFIG)/qps_openloop_test
qps_test: $(BINDIR)/$(CONFIG)/qps_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
@ -1050,8 +1046,6 @@ shutdown_test: $(BINDIR)/$(CONFIG)/shutdown_test
status_test: $(BINDIR)/$(CONFIG)/status_test status_test: $(BINDIR)/$(CONFIG)/status_test
streaming_throughput_test: $(BINDIR)/$(CONFIG)/streaming_throughput_test streaming_throughput_test: $(BINDIR)/$(CONFIG)/streaming_throughput_test
stress_test: $(BINDIR)/$(CONFIG)/stress_test stress_test: $(BINDIR)/$(CONFIG)/stress_test
sync_streaming_ping_pong_test: $(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test
sync_unary_ping_pong_test: $(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test
thread_stress_test: $(BINDIR)/$(CONFIG)/thread_stress_test thread_stress_test: $(BINDIR)/$(CONFIG)/thread_stress_test
public_headers_must_be_c89: $(BINDIR)/$(CONFIG)/public_headers_must_be_c89 public_headers_must_be_c89: $(BINDIR)/$(CONFIG)/public_headers_must_be_c89
boringssl_aes_test: $(BINDIR)/$(CONFIG)/boringssl_aes_test boringssl_aes_test: $(BINDIR)/$(CONFIG)/boringssl_aes_test
@ -1377,8 +1371,6 @@ buildtests_c: privatelibs_c \
buildtests_cxx: buildtests_zookeeper privatelibs_cxx \ buildtests_cxx: buildtests_zookeeper privatelibs_cxx \
$(BINDIR)/$(CONFIG)/alarm_cpp_test \ $(BINDIR)/$(CONFIG)/alarm_cpp_test \
$(BINDIR)/$(CONFIG)/async_end2end_test \ $(BINDIR)/$(CONFIG)/async_end2end_test \
$(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test \
$(BINDIR)/$(CONFIG)/async_unary_ping_pong_test \
$(BINDIR)/$(CONFIG)/auth_property_iterator_test \ $(BINDIR)/$(CONFIG)/auth_property_iterator_test \
$(BINDIR)/$(CONFIG)/channel_arguments_test \ $(BINDIR)/$(CONFIG)/channel_arguments_test \
$(BINDIR)/$(CONFIG)/cli_call_test \ $(BINDIR)/$(CONFIG)/cli_call_test \
@ -1392,7 +1384,6 @@ buildtests_cxx: buildtests_zookeeper privatelibs_cxx \
$(BINDIR)/$(CONFIG)/cxx_string_ref_test \ $(BINDIR)/$(CONFIG)/cxx_string_ref_test \
$(BINDIR)/$(CONFIG)/cxx_time_test \ $(BINDIR)/$(CONFIG)/cxx_time_test \
$(BINDIR)/$(CONFIG)/end2end_test \ $(BINDIR)/$(CONFIG)/end2end_test \
$(BINDIR)/$(CONFIG)/generic_async_streaming_ping_pong_test \
$(BINDIR)/$(CONFIG)/generic_end2end_test \ $(BINDIR)/$(CONFIG)/generic_end2end_test \
$(BINDIR)/$(CONFIG)/golden_file_test \ $(BINDIR)/$(CONFIG)/golden_file_test \
$(BINDIR)/$(CONFIG)/grpc_cli \ $(BINDIR)/$(CONFIG)/grpc_cli \
@ -1407,7 +1398,6 @@ buildtests_cxx: buildtests_zookeeper privatelibs_cxx \
$(BINDIR)/$(CONFIG)/qps_interarrival_test \ $(BINDIR)/$(CONFIG)/qps_interarrival_test \
$(BINDIR)/$(CONFIG)/qps_json_driver \ $(BINDIR)/$(CONFIG)/qps_json_driver \
$(BINDIR)/$(CONFIG)/qps_openloop_test \ $(BINDIR)/$(CONFIG)/qps_openloop_test \
$(BINDIR)/$(CONFIG)/qps_test \
$(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 \
@ -1420,8 +1410,6 @@ buildtests_cxx: buildtests_zookeeper privatelibs_cxx \
$(BINDIR)/$(CONFIG)/status_test \ $(BINDIR)/$(CONFIG)/status_test \
$(BINDIR)/$(CONFIG)/streaming_throughput_test \ $(BINDIR)/$(CONFIG)/streaming_throughput_test \
$(BINDIR)/$(CONFIG)/stress_test \ $(BINDIR)/$(CONFIG)/stress_test \
$(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test \
$(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test \
$(BINDIR)/$(CONFIG)/thread_stress_test \ $(BINDIR)/$(CONFIG)/thread_stress_test \
$(BINDIR)/$(CONFIG)/boringssl_aes_test \ $(BINDIR)/$(CONFIG)/boringssl_aes_test \
$(BINDIR)/$(CONFIG)/boringssl_asn1_test \ $(BINDIR)/$(CONFIG)/boringssl_asn1_test \
@ -1696,10 +1684,6 @@ test_cxx: test_zookeeper buildtests_cxx
$(Q) $(BINDIR)/$(CONFIG)/alarm_cpp_test || ( echo test alarm_cpp_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/alarm_cpp_test || ( echo test alarm_cpp_test failed ; exit 1 )
$(E) "[RUN] Testing async_end2end_test" $(E) "[RUN] Testing async_end2end_test"
$(Q) $(BINDIR)/$(CONFIG)/async_end2end_test || ( echo test async_end2end_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/async_end2end_test || ( echo test async_end2end_test failed ; exit 1 )
$(E) "[RUN] Testing async_streaming_ping_pong_test"
$(Q) $(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test || ( echo test async_streaming_ping_pong_test failed ; exit 1 )
$(E) "[RUN] Testing async_unary_ping_pong_test"
$(Q) $(BINDIR)/$(CONFIG)/async_unary_ping_pong_test || ( echo test async_unary_ping_pong_test failed ; exit 1 )
$(E) "[RUN] Testing auth_property_iterator_test" $(E) "[RUN] Testing auth_property_iterator_test"
$(Q) $(BINDIR)/$(CONFIG)/auth_property_iterator_test || ( echo test auth_property_iterator_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/auth_property_iterator_test || ( echo test auth_property_iterator_test failed ; exit 1 )
$(E) "[RUN] Testing channel_arguments_test" $(E) "[RUN] Testing channel_arguments_test"
@ -1724,8 +1708,6 @@ test_cxx: test_zookeeper buildtests_cxx
$(Q) $(BINDIR)/$(CONFIG)/cxx_time_test || ( echo test cxx_time_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/cxx_time_test || ( echo test cxx_time_test failed ; exit 1 )
$(E) "[RUN] Testing end2end_test" $(E) "[RUN] Testing end2end_test"
$(Q) $(BINDIR)/$(CONFIG)/end2end_test || ( echo test end2end_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/end2end_test || ( echo test end2end_test failed ; exit 1 )
$(E) "[RUN] Testing generic_async_streaming_ping_pong_test"
$(Q) $(BINDIR)/$(CONFIG)/generic_async_streaming_ping_pong_test || ( echo test generic_async_streaming_ping_pong_test failed ; exit 1 )
$(E) "[RUN] Testing generic_end2end_test" $(E) "[RUN] Testing generic_end2end_test"
$(Q) $(BINDIR)/$(CONFIG)/generic_end2end_test || ( echo test generic_end2end_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/generic_end2end_test || ( echo test generic_end2end_test failed ; exit 1 )
$(E) "[RUN] Testing golden_file_test" $(E) "[RUN] Testing golden_file_test"
@ -1740,8 +1722,6 @@ test_cxx: test_zookeeper buildtests_cxx
$(Q) $(BINDIR)/$(CONFIG)/mock_test || ( echo test mock_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/mock_test || ( echo test mock_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 qps_test"
$(Q) $(BINDIR)/$(CONFIG)/qps_test || ( echo test qps_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"
@ -1756,10 +1736,6 @@ test_cxx: test_zookeeper buildtests_cxx
$(Q) $(BINDIR)/$(CONFIG)/status_test || ( echo test status_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/status_test || ( echo test status_test failed ; exit 1 )
$(E) "[RUN] Testing streaming_throughput_test" $(E) "[RUN] Testing streaming_throughput_test"
$(Q) $(BINDIR)/$(CONFIG)/streaming_throughput_test || ( echo test streaming_throughput_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/streaming_throughput_test || ( echo test streaming_throughput_test failed ; exit 1 )
$(E) "[RUN] Testing sync_streaming_ping_pong_test"
$(Q) $(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test || ( echo test sync_streaming_ping_pong_test failed ; exit 1 )
$(E) "[RUN] Testing sync_unary_ping_pong_test"
$(Q) $(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test || ( echo test sync_unary_ping_pong_test failed ; exit 1 )
$(E) "[RUN] Testing thread_stress_test" $(E) "[RUN] Testing thread_stress_test"
$(Q) $(BINDIR)/$(CONFIG)/thread_stress_test || ( echo test thread_stress_test failed ; exit 1 ) $(Q) $(BINDIR)/$(CONFIG)/thread_stress_test || ( echo test thread_stress_test failed ; exit 1 )
@ -9701,92 +9677,6 @@ endif
endif endif
ASYNC_STREAMING_PING_PONG_TEST_SRC = \
test/cpp/qps/async_streaming_ping_pong_test.cc \
ASYNC_STREAMING_PING_PONG_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(ASYNC_STREAMING_PING_PONG_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/async_streaming_ping_pong_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)/async_streaming_ping_pong_test: protobuf_dep_error
else
$(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test: $(PROTOBUF_DEP) $(ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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) $(ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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)/async_streaming_ping_pong_test
endif
endif
$(OBJDIR)/$(CONFIG)/test/cpp/qps/async_streaming_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(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_async_streaming_ping_pong_test: $(ASYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(ASYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep)
endif
endif
ASYNC_UNARY_PING_PONG_TEST_SRC = \
test/cpp/qps/async_unary_ping_pong_test.cc \
ASYNC_UNARY_PING_PONG_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(ASYNC_UNARY_PING_PONG_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/async_unary_ping_pong_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)/async_unary_ping_pong_test: protobuf_dep_error
else
$(BINDIR)/$(CONFIG)/async_unary_ping_pong_test: $(PROTOBUF_DEP) $(ASYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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) $(ASYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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)/async_unary_ping_pong_test
endif
endif
$(OBJDIR)/$(CONFIG)/test/cpp/qps/async_unary_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(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_async_unary_ping_pong_test: $(ASYNC_UNARY_PING_PONG_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(ASYNC_UNARY_PING_PONG_TEST_OBJS:.o=.dep)
endif
endif
AUTH_PROPERTY_ITERATOR_TEST_SRC = \ AUTH_PROPERTY_ITERATOR_TEST_SRC = \
test/cpp/common/auth_property_iterator_test.cc \ test/cpp/common/auth_property_iterator_test.cc \
@ -10392,49 +10282,6 @@ endif
endif endif
GENERIC_ASYNC_STREAMING_PING_PONG_TEST_SRC = \
test/cpp/qps/generic_async_streaming_ping_pong_test.cc \
GENERIC_ASYNC_STREAMING_PING_PONG_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(GENERIC_ASYNC_STREAMING_PING_PONG_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/generic_async_streaming_ping_pong_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)/generic_async_streaming_ping_pong_test: protobuf_dep_error
else
$(BINDIR)/$(CONFIG)/generic_async_streaming_ping_pong_test: $(PROTOBUF_DEP) $(GENERIC_ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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) $(GENERIC_ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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)/generic_async_streaming_ping_pong_test
endif
endif
$(OBJDIR)/$(CONFIG)/test/cpp/qps/generic_async_streaming_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(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_generic_async_streaming_ping_pong_test: $(GENERIC_ASYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(GENERIC_ASYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep)
endif
endif
GENERIC_END2END_TEST_SRC = \ GENERIC_END2END_TEST_SRC = \
test/cpp/end2end/generic_end2end_test.cc \ test/cpp/end2end/generic_end2end_test.cc \
@ -11214,49 +11061,6 @@ endif
endif endif
QPS_TEST_SRC = \
test/cpp/qps/qps_test.cc \
QPS_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(QPS_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/qps_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)/qps_test: protobuf_dep_error
else
$(BINDIR)/$(CONFIG)/qps_test: $(PROTOBUF_DEP) $(QPS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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 $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a
$(E) "[LD] Linking $@"
$(Q) mkdir -p `dirname $@`
$(Q) $(LDXX) $(LDFLAGS) $(QPS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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 $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/qps_test
endif
endif
$(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(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 $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a
deps_qps_test: $(QPS_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(QPS_TEST_OBJS:.o=.dep)
endif
endif
QPS_WORKER_SRC = \ QPS_WORKER_SRC = \
test/cpp/qps/worker.cc \ test/cpp/qps/worker.cc \
@ -11818,92 +11622,6 @@ $(OBJDIR)/$(CONFIG)/test/cpp/interop/stress_test.o: $(GENDIR)/src/proto/grpc/tes
$(OBJDIR)/$(CONFIG)/test/cpp/util/metrics_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/metrics.pb.cc $(GENDIR)/src/proto/grpc/testing/metrics.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/test.pb.cc $(GENDIR)/src/proto/grpc/testing/test.grpc.pb.cc $(OBJDIR)/$(CONFIG)/test/cpp/util/metrics_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/metrics.pb.cc $(GENDIR)/src/proto/grpc/testing/metrics.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/test.pb.cc $(GENDIR)/src/proto/grpc/testing/test.grpc.pb.cc
SYNC_STREAMING_PING_PONG_TEST_SRC = \
test/cpp/qps/sync_streaming_ping_pong_test.cc \
SYNC_STREAMING_PING_PONG_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(SYNC_STREAMING_PING_PONG_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_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)/sync_streaming_ping_pong_test: protobuf_dep_error
else
$(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test: $(PROTOBUF_DEP) $(SYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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) $(SYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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)/sync_streaming_ping_pong_test
endif
endif
$(OBJDIR)/$(CONFIG)/test/cpp/qps/sync_streaming_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(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_sync_streaming_ping_pong_test: $(SYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(SYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep)
endif
endif
SYNC_UNARY_PING_PONG_TEST_SRC = \
test/cpp/qps/sync_unary_ping_pong_test.cc \
SYNC_UNARY_PING_PONG_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(SYNC_UNARY_PING_PONG_TEST_SRC))))
ifeq ($(NO_SECURE),true)
# You can't build secure targets if you don't have OpenSSL.
$(BINDIR)/$(CONFIG)/sync_unary_ping_pong_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)/sync_unary_ping_pong_test: protobuf_dep_error
else
$(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test: $(PROTOBUF_DEP) $(SYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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) $(SYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(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)/sync_unary_ping_pong_test
endif
endif
$(OBJDIR)/$(CONFIG)/test/cpp/qps/sync_unary_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(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_sync_unary_ping_pong_test: $(SYNC_UNARY_PING_PONG_TEST_OBJS:.o=.dep)
ifneq ($(NO_SECURE),true)
ifneq ($(NO_DEPS),true)
-include $(SYNC_UNARY_PING_PONG_TEST_OBJS:.o=.dep)
endif
endif
THREAD_STRESS_TEST_SRC = \ THREAD_STRESS_TEST_SRC = \
test/cpp/end2end/thread_stress_test.cc \ test/cpp/end2end/thread_stress_test.cc \

@ -2358,40 +2358,6 @@ targets:
- grpc - grpc
- gpr_test_util - gpr_test_util
- gpr - gpr
- name: async_streaming_ping_pong_test
build: test
language: c++
src:
- test/cpp/qps/async_streaming_ping_pong_test.cc
deps:
- qps
- grpc++_test_util
- grpc_test_util
- grpc++
- grpc
- gpr_test_util
- gpr
platforms:
- mac
- linux
- posix
- name: async_unary_ping_pong_test
build: test
language: c++
src:
- test/cpp/qps/async_unary_ping_pong_test.cc
deps:
- qps
- grpc++_test_util
- grpc_test_util
- grpc++
- grpc
- gpr_test_util
- gpr
platforms:
- mac
- linux
- posix
- name: auth_property_iterator_test - name: auth_property_iterator_test
gtest: true gtest: true
build: test build: test
@ -2559,23 +2525,6 @@ targets:
- grpc - grpc
- gpr_test_util - gpr_test_util
- gpr - gpr
- name: generic_async_streaming_ping_pong_test
build: test
language: c++
src:
- test/cpp/qps/generic_async_streaming_ping_pong_test.cc
deps:
- qps
- grpc++_test_util
- grpc_test_util
- grpc++
- grpc
- gpr_test_util
- gpr
platforms:
- mac
- linux
- posix
- name: generic_end2end_test - name: generic_end2end_test
gtest: true gtest: true
build: test build: test
@ -2847,25 +2796,6 @@ targets:
- mac - mac
- linux - linux
- posix - posix
- name: qps_test
cpu_cost: 10
build: test
language: c++
src:
- test/cpp/qps/qps_test.cc
deps:
- qps
- grpc++_test_util
- grpc_test_util
- grpc++
- grpc
- gpr_test_util
- gpr
- grpc++_test_config
platforms:
- mac
- linux
- posix
- name: qps_worker - name: qps_worker
build: test build: test
run: false run: false
@ -3061,40 +2991,6 @@ targets:
- gpr_test_util - gpr_test_util
- gpr - gpr
- grpc++_test_config - grpc++_test_config
- name: sync_streaming_ping_pong_test
build: test
language: c++
src:
- test/cpp/qps/sync_streaming_ping_pong_test.cc
deps:
- qps
- grpc++_test_util
- grpc_test_util
- grpc++
- grpc
- gpr_test_util
- gpr
platforms:
- mac
- linux
- posix
- name: sync_unary_ping_pong_test
build: test
language: c++
src:
- test/cpp/qps/sync_unary_ping_pong_test.cc
deps:
- qps
- grpc++_test_util
- grpc_test_util
- grpc++
- grpc
- gpr_test_util
- gpr
platforms:
- mac
- linux
- posix
- name: thread_stress_test - name: thread_stress_test
gtest: true gtest: true
cpu_cost: 100 cpu_cost: 100

@ -225,6 +225,7 @@ grpc_error *grpc_error_create(const char *file, int line, const char *desc,
(void *)(uintptr_t)GRPC_ERROR_STR_FILE, gpr_strdup(file)), (void *)(uintptr_t)GRPC_ERROR_STR_FILE, gpr_strdup(file)),
(void *)(uintptr_t)GRPC_ERROR_STR_DESCRIPTION, gpr_strdup(desc)); (void *)(uintptr_t)GRPC_ERROR_STR_DESCRIPTION, gpr_strdup(desc));
err->errs = gpr_avl_create(&avl_vtable_errs); err->errs = gpr_avl_create(&avl_vtable_errs);
err->next_err = 0;
for (size_t i = 0; i < num_referencing; i++) { for (size_t i = 0; i < num_referencing; i++) {
if (referencing[i] == GRPC_ERROR_NONE) continue; if (referencing[i] == GRPC_ERROR_NONE) continue;
err->errs = gpr_avl_add(err->errs, (void *)(err->next_err++), err->errs = gpr_avl_add(err->errs, (void *)(err->next_err++),
@ -233,7 +234,6 @@ grpc_error *grpc_error_create(const char *file, int line, const char *desc,
err->times = gpr_avl_add(gpr_avl_create(&avl_vtable_times), err->times = gpr_avl_add(gpr_avl_create(&avl_vtable_times),
(void *)(uintptr_t)GRPC_ERROR_TIME_CREATED, (void *)(uintptr_t)GRPC_ERROR_TIME_CREATED,
box_time(gpr_now(GPR_CLOCK_REALTIME))); box_time(gpr_now(GPR_CLOCK_REALTIME)));
err->next_err = 0;
gpr_ref_init(&err->refs, 1); gpr_ref_init(&err->refs, 1);
return err; return err;
} }

@ -234,7 +234,6 @@ static void publish_new_rpc(grpc_exec_ctx *exec_ctx, void *calld,
grpc_error *error); grpc_error *error);
static void fail_call(grpc_exec_ctx *exec_ctx, grpc_server *server, static void fail_call(grpc_exec_ctx *exec_ctx, grpc_server *server,
size_t cq_idx, requested_call *rc, grpc_error *error); size_t cq_idx, requested_call *rc, grpc_error *error);
/* Before calling maybe_finish_shutdown, we must hold mu_global and not /* Before calling maybe_finish_shutdown, we must hold mu_global and not
hold mu_call */ hold mu_call */
static void maybe_finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_server *server); static void maybe_finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_server *server);
@ -358,7 +357,8 @@ static void request_matcher_kill_requests(grpc_exec_ctx *exec_ctx,
for (size_t i = 0; i < server->cq_count; i++) { for (size_t i = 0; i < server->cq_count; i++) {
while ((request_id = gpr_stack_lockfree_pop(rm->requests_per_cq[i])) != while ((request_id = gpr_stack_lockfree_pop(rm->requests_per_cq[i])) !=
-1) { -1) {
fail_call(exec_ctx, server, i, &server->requested_calls[request_id], GRPC_ERROR_REF(error)); fail_call(exec_ctx, server, i, &server->requested_calls[request_id],
GRPC_ERROR_REF(error));
} }
} }
GRPC_ERROR_UNREF(error); GRPC_ERROR_UNREF(error);
@ -671,12 +671,14 @@ static void kill_pending_work_locked(grpc_exec_ctx *exec_ctx,
grpc_server *server, grpc_error *error) { grpc_server *server, grpc_error *error) {
if (server->started) { if (server->started) {
request_matcher_kill_requests(exec_ctx, server, request_matcher_kill_requests(exec_ctx, server,
&server->unregistered_request_matcher, GRPC_ERROR_REF(error)); &server->unregistered_request_matcher,
GRPC_ERROR_REF(error));
request_matcher_zombify_all_pending_calls( request_matcher_zombify_all_pending_calls(
exec_ctx, &server->unregistered_request_matcher); exec_ctx, &server->unregistered_request_matcher);
for (registered_method *rm = server->registered_methods; rm; for (registered_method *rm = server->registered_methods; rm;
rm = rm->next) { rm = rm->next) {
request_matcher_kill_requests(exec_ctx, server, &rm->request_matcher, GRPC_ERROR_REF(error)); request_matcher_kill_requests(exec_ctx, server, &rm->request_matcher,
GRPC_ERROR_REF(error));
request_matcher_zombify_all_pending_calls(exec_ctx, &rm->request_matcher); request_matcher_zombify_all_pending_calls(exec_ctx, &rm->request_matcher);
} }
} }

@ -40,11 +40,12 @@ module GRPC
# @param code [Numeric] the status code # @param code [Numeric] the status code
# @param details [String] the details of the exception # @param details [String] the details of the exception
def initialize(code, details = 'unknown cause', **kw) # @param metadata [Hash] the error's metadata
def initialize(code, details = 'unknown cause', metadata = {})
super("#{code}:#{details}") super("#{code}:#{details}")
@code = code @code = code
@details = details @details = details
@metadata = kw @metadata = metadata
end end
# Converts the exception to a GRPC::Status for use in the networking # Converts the exception to a GRPC::Status for use in the networking

@ -44,7 +44,7 @@ class Struct
# raise BadStatus, propagating the metadata if present. # raise BadStatus, propagating the metadata if present.
md = status.metadata md = status.metadata
with_sym_keys = Hash[md.each_pair.collect { |x, y| [x.to_sym, y] }] with_sym_keys = Hash[md.each_pair.collect { |x, y| [x.to_sym, y] }]
fail GRPC::BadStatus.new(status.code, status.details, **with_sym_keys) fail GRPC::BadStatus.new(status.code, status.details, with_sym_keys)
end end
status status
end end
@ -76,14 +76,15 @@ module GRPC
# #
# @param call [Call] a call on which to start and invocation # @param call [Call] a call on which to start and invocation
# @param q [CompletionQueue] the completion queue # @param q [CompletionQueue] the completion queue
def self.client_invoke(call, q, **kw) # @param metadata [Hash] the metadata
def self.client_invoke(call, q, metadata = {})
fail(TypeError, '!Core::Call') unless call.is_a? Core::Call fail(TypeError, '!Core::Call') unless call.is_a? Core::Call
unless q.is_a? Core::CompletionQueue unless q.is_a? Core::CompletionQueue
fail(TypeError, '!Core::CompletionQueue') fail(TypeError, '!Core::CompletionQueue')
end end
metadata_tag = Object.new metadata_tag = Object.new
call.run_batch(q, metadata_tag, INFINITE_FUTURE, call.run_batch(q, metadata_tag, INFINITE_FUTURE,
SEND_INITIAL_METADATA => kw) SEND_INITIAL_METADATA => metadata)
metadata_tag metadata_tag
end end
@ -211,13 +212,12 @@ module GRPC
# @param details [String] details # @param details [String] details
# @param assert_finished [true, false] when true(default), waits for # @param assert_finished [true, false] when true(default), waits for
# FINISHED. # FINISHED.
# # @param metadata [Hash] metadata to send to the server. If a value is a
# == Keyword Arguments == # list, mulitple metadata for its key are sent
# any keyword arguments are treated as metadata to be sent to the server def send_status(code = OK, details = '', assert_finished = false,
# if a keyword value is a list, multiple metadata for it's key are sent metadata: {})
def send_status(code = OK, details = '', assert_finished = false, **kw)
ops = { ops = {
SEND_STATUS_FROM_SERVER => Struct::Status.new(code, details, kw) SEND_STATUS_FROM_SERVER => Struct::Status.new(code, details, metadata)
} }
ops[RECV_CLOSE_ON_SERVER] = nil if assert_finished ops[RECV_CLOSE_ON_SERVER] = nil if assert_finished
@call.run_batch(@cq, self, INFINITE_FUTURE, ops) @call.run_batch(@cq, self, INFINITE_FUTURE, ops)
@ -311,14 +311,12 @@ module GRPC
# request_response sends a request to a GRPC server, and returns the # request_response sends a request to a GRPC server, and returns the
# response. # response.
# #
# == Keyword Arguments ==
# any keyword arguments are treated as metadata to be sent to the server
# if a keyword value is a list, multiple metadata for it's key are sent
#
# @param req [Object] the request sent to the server # @param req [Object] the request sent to the server
# @param metadata [Hash] metadata to be sent to the server. If a value is
# a list, multiple metadata for its key are sent
# @return [Object] the response received from the server # @return [Object] the response received from the server
def request_response(req, **kw) def request_response(req, metadata: {})
start_call(**kw) unless @started start_call(metadata) unless @started
remote_send(req) remote_send(req)
writes_done(false) writes_done(false)
response = remote_read response = remote_read
@ -337,14 +335,12 @@ module GRPC
# array of marshallable objects; in typical case it will be an Enumerable # array of marshallable objects; in typical case it will be an Enumerable
# that allows dynamic construction of the marshallable objects. # that allows dynamic construction of the marshallable objects.
# #
# == Keyword Arguments ==
# any keyword arguments are treated as metadata to be sent to the server
# if a keyword value is a list, multiple metadata for it's key are sent
#
# @param requests [Object] an Enumerable of requests to send # @param requests [Object] an Enumerable of requests to send
# @param metadata [Hash] metadata to be sent to the server. If a value is
# a list, multiple metadata for its key are sent
# @return [Object] the response received from the server # @return [Object] the response received from the server
def client_streamer(requests, **kw) def client_streamer(requests, metadata: {})
start_call(**kw) unless @started start_call(metadata) unless @started
requests.each { |r| remote_send(r) } requests.each { |r| remote_send(r) }
writes_done(false) writes_done(false)
response = remote_read response = remote_read
@ -365,15 +361,12 @@ module GRPC
# it is executed with each response as the argument and no result is # it is executed with each response as the argument and no result is
# returned. # returned.
# #
# == Keyword Arguments ==
# any keyword arguments are treated as metadata to be sent to the server
# if a keyword value is a list, multiple metadata for it's key are sent
# any keyword arguments are treated as metadata to be sent to the server.
#
# @param req [Object] the request sent to the server # @param req [Object] the request sent to the server
# @param metadata [Hash] metadata to be sent to the server. If a value is
# a list, multiple metadata for its key are sent
# @return [Enumerator|nil] a response Enumerator # @return [Enumerator|nil] a response Enumerator
def server_streamer(req, **kw) def server_streamer(req, metadata: {})
start_call(**kw) unless @started start_call(metadata) unless @started
remote_send(req) remote_send(req)
writes_done(false) writes_done(false)
replies = enum_for(:each_remote_read_then_finish) replies = enum_for(:each_remote_read_then_finish)
@ -407,14 +400,12 @@ module GRPC
# the_call#writes_done has been called, otherwise the block will loop # the_call#writes_done has been called, otherwise the block will loop
# forever. # forever.
# #
# == Keyword Arguments ==
# any keyword arguments are treated as metadata to be sent to the server
# if a keyword value is a list, multiple metadata for it's key are sent
#
# @param requests [Object] an Enumerable of requests to send # @param requests [Object] an Enumerable of requests to send
# @param metadata [Hash] metadata to be sent to the server. If a value is
# a list, multiple metadata for its key are sent
# @return [Enumerator, nil] a response Enumerator # @return [Enumerator, nil] a response Enumerator
def bidi_streamer(requests, **kw, &blk) def bidi_streamer(requests, metadata: {}, &blk)
start_call(**kw) unless @started start_call(metadata) unless @started
bd = BidiCall.new(@call, @cq, @marshal, @unmarshal, bd = BidiCall.new(@call, @cq, @marshal, @unmarshal,
metadata_tag: @metadata_tag) metadata_tag: @metadata_tag)
@metadata_tag = nil # run_on_client ensures metadata is read @metadata_tag = nil # run_on_client ensures metadata is read
@ -453,9 +444,11 @@ module GRPC
private private
# Starts the call if not already started # Starts the call if not already started
def start_call(**kw) # @param metadata [Hash] metadata to be sent to the server. If a value is
# a list, multiple metadata for its key are sent
def start_call(metadata = {})
return if @started return if @started
@metadata_tag = ActiveCall.client_invoke(@call, @cq, **kw) @metadata_tag = ActiveCall.client_invoke(@call, @cq, metadata)
@started = true @started = true
end end

@ -44,21 +44,21 @@ module GRPC
# setup_channel is used by #initialize to constuct a channel from its # setup_channel is used by #initialize to constuct a channel from its
# arguments. # arguments.
def self.setup_channel(alt_chan, host, creds, **kw) def self.setup_channel(alt_chan, host, creds, channel_args = {})
unless alt_chan.nil? unless alt_chan.nil?
fail(TypeError, '!Channel') unless alt_chan.is_a?(Core::Channel) fail(TypeError, '!Channel') unless alt_chan.is_a?(Core::Channel)
return alt_chan return alt_chan
end end
if kw['grpc.primary_user_agent'].nil? if channel_args['grpc.primary_user_agent'].nil?
kw['grpc.primary_user_agent'] = '' channel_args['grpc.primary_user_agent'] = ''
else else
kw['grpc.primary_user_agent'] += ' ' channel_args['grpc.primary_user_agent'] += ' '
end end
kw['grpc.primary_user_agent'] += "grpc-ruby/#{VERSION}" channel_args['grpc.primary_user_agent'] += "grpc-ruby/#{VERSION}"
unless creds.is_a?(Core::ChannelCredentials) || creds.is_a?(Symbol) unless creds.is_a?(Core::ChannelCredentials) || creds.is_a?(Symbol)
fail(TypeError, '!ChannelCredentials or Symbol') fail(TypeError, '!ChannelCredentials or Symbol')
end end
Core::Channel.new(host, kw, creds) Core::Channel.new(host, channel_args, creds)
end end
# Allows users of the stub to modify the propagate mask. # Allows users of the stub to modify the propagate mask.
@ -96,15 +96,16 @@ module GRPC
# :this_channel_is_insecure # :this_channel_is_insecure
# @param channel_override [Core::Channel] a pre-created channel # @param channel_override [Core::Channel] a pre-created channel
# @param timeout [Number] the default timeout to use in requests # @param timeout [Number] the default timeout to use in requests
# @param kw [KeywordArgs]the channel arguments # @param channel_args [Hash] the channel arguments
def initialize(host, q, creds, def initialize(host, q, creds,
channel_override: nil, channel_override: nil,
timeout: nil, timeout: nil,
propagate_mask: nil, propagate_mask: nil,
**kw) channel_args: {})
fail(TypeError, '!CompletionQueue') unless q.is_a?(Core::CompletionQueue) fail(TypeError, '!CompletionQueue') unless q.is_a?(Core::CompletionQueue)
@ch = ClientStub.setup_channel(channel_override, host, creds, **kw) @ch = ClientStub.setup_channel(channel_override, host, creds,
alt_host = kw[Core::Channel::SSL_TARGET] channel_args)
alt_host = channel_args[Core::Channel::SSL_TARGET]
@host = alt_host.nil? ? host : alt_host @host = alt_host.nil? ? host : alt_host
@propagate_mask = propagate_mask @propagate_mask = propagate_mask
@timeout = timeout.nil? ? DEFAULT_TIMEOUT : timeout @timeout = timeout.nil? ? DEFAULT_TIMEOUT : timeout
@ -135,42 +136,35 @@ module GRPC
# If return_op is true, the call returns an Operation, calling execute # If return_op is true, the call returns an Operation, calling execute
# on the Operation returns the response. # on the Operation returns the response.
# #
# == Keyword Args ==
#
# Unspecified keyword arguments are treated as metadata to be sent to the
# server.
#
# @param method [String] the RPC method to call on the GRPC server # @param method [String] the RPC method to call on the GRPC server
# @param req [Object] the request sent to the server # @param req [Object] the request sent to the server
# @param marshal [Function] f(obj)->string that marshals requests # @param marshal [Function] f(obj)->string that marshals requests
# @param unmarshal [Function] f(string)->obj that unmarshals responses # @param unmarshal [Function] f(string)->obj that unmarshals responses
# @param timeout [Numeric] (optional) the max completion time in seconds
# @param deadline [Time] (optional) the time the request should complete # @param deadline [Time] (optional) the time the request should complete
# @param return_op [true|false] return an Operation if true
# @param parent [Core::Call] a prior call whose reserved metadata # @param parent [Core::Call] a prior call whose reserved metadata
# will be propagated by this one. # will be propagated by this one.
# @param credentials [Core::CallCredentials] credentials to use when making # @param credentials [Core::CallCredentials] credentials to use when making
# the call # the call
# @param return_op [true|false] return an Operation if true # @param metadata [Hash] metadata to be sent to the server
# @return [Object] the response received from the server # @return [Object] the response received from the server
def request_response(method, req, marshal, unmarshal, def request_response(method, req, marshal, unmarshal,
deadline: nil, deadline: nil,
timeout: nil,
return_op: false, return_op: false,
parent: nil, parent: nil,
credentials: nil, credentials: nil,
**kw) metadata: {})
c = new_active_call(method, marshal, unmarshal, c = new_active_call(method, marshal, unmarshal,
deadline: deadline, deadline: deadline,
timeout: timeout,
parent: parent, parent: parent,
credentials: credentials) credentials: credentials)
return c.request_response(req, **kw) unless return_op return c.request_response(req, metadata: metadata) unless return_op
# return the operation view of the active_call; define #execute as a # return the operation view of the active_call; define #execute as a
# new method for this instance that invokes #request_response. # new method for this instance that invokes #request_response.
op = c.operation op = c.operation
op.define_singleton_method(:execute) do op.define_singleton_method(:execute) do
c.request_response(req, **kw) c.request_response(req, metadata: metadata)
end end
op op
end end
@ -205,42 +199,35 @@ module GRPC
# #
# If return_op is true, the call returns the response. # If return_op is true, the call returns the response.
# #
# == Keyword Args ==
#
# Unspecified keyword arguments are treated as metadata to be sent to the
# server.
#
# @param method [String] the RPC method to call on the GRPC server # @param method [String] the RPC method to call on the GRPC server
# @param requests [Object] an Enumerable of requests to send # @param requests [Object] an Enumerable of requests to send
# @param marshal [Function] f(obj)->string that marshals requests # @param marshal [Function] f(obj)->string that marshals requests
# @param unmarshal [Function] f(string)->obj that unmarshals responses # @param unmarshal [Function] f(string)->obj that unmarshals responses
# @param timeout [Numeric] (optional) the max completion time in seconds
# @param deadline [Time] (optional) the time the request should complete # @param deadline [Time] (optional) the time the request should complete
# @param return_op [true|false] return an Operation if true # @param return_op [true|false] return an Operation if true
# @param parent [Core::Call] a prior call whose reserved metadata # @param parent [Core::Call] a prior call whose reserved metadata
# will be propagated by this one. # will be propagated by this one.
# @param credentials [Core::CallCredentials] credentials to use when making # @param credentials [Core::CallCredentials] credentials to use when making
# the call # the call
# @param metadata [Hash] metadata to be sent to the server
# @return [Object|Operation] the response received from the server # @return [Object|Operation] the response received from the server
def client_streamer(method, requests, marshal, unmarshal, def client_streamer(method, requests, marshal, unmarshal,
deadline: nil, deadline: nil,
timeout: nil,
return_op: false, return_op: false,
parent: nil, parent: nil,
credentials: nil, credentials: nil,
**kw) metadata: {})
c = new_active_call(method, marshal, unmarshal, c = new_active_call(method, marshal, unmarshal,
deadline: deadline, deadline: deadline,
timeout: timeout,
parent: parent, parent: parent,
credentials: credentials) credentials: credentials)
return c.client_streamer(requests, **kw) unless return_op return c.client_streamer(requests, metadata: metadata) unless return_op
# return the operation view of the active_call; define #execute as a # return the operation view of the active_call; define #execute as a
# new method for this instance that invokes #client_streamer. # new method for this instance that invokes #client_streamer.
op = c.operation op = c.operation
op.define_singleton_method(:execute) do op.define_singleton_method(:execute) do
c.client_streamer(requests, **kw) c.client_streamer(requests, metadata: metadata)
end end
op op
end end
@ -292,35 +279,33 @@ module GRPC
# @param req [Object] the request sent to the server # @param req [Object] the request sent to the server
# @param marshal [Function] f(obj)->string that marshals requests # @param marshal [Function] f(obj)->string that marshals requests
# @param unmarshal [Function] f(string)->obj that unmarshals responses # @param unmarshal [Function] f(string)->obj that unmarshals responses
# @param timeout [Numeric] (optional) the max completion time in seconds
# @param deadline [Time] (optional) the time the request should complete # @param deadline [Time] (optional) the time the request should complete
# @param return_op [true|false]return an Operation if true # @param return_op [true|false]return an Operation if true
# @param parent [Core::Call] a prior call whose reserved metadata # @param parent [Core::Call] a prior call whose reserved metadata
# will be propagated by this one. # will be propagated by this one.
# @param credentials [Core::CallCredentials] credentials to use when making # @param credentials [Core::CallCredentials] credentials to use when making
# the call # the call
# @param metadata [Hash] metadata to be sent to the server
# @param blk [Block] when provided, is executed for each response # @param blk [Block] when provided, is executed for each response
# @return [Enumerator|Operation|nil] as discussed above # @return [Enumerator|Operation|nil] as discussed above
def server_streamer(method, req, marshal, unmarshal, def server_streamer(method, req, marshal, unmarshal,
deadline: nil, deadline: nil,
timeout: nil,
return_op: false, return_op: false,
parent: nil, parent: nil,
credentials: nil, credentials: nil,
**kw, metadata: {},
&blk) &blk)
c = new_active_call(method, marshal, unmarshal, c = new_active_call(method, marshal, unmarshal,
deadline: deadline, deadline: deadline,
timeout: timeout,
parent: parent, parent: parent,
credentials: credentials) credentials: credentials)
return c.server_streamer(req, **kw, &blk) unless return_op return c.server_streamer(req, metadata: metadata, &blk) unless return_op
# return the operation view of the active_call; define #execute # return the operation view of the active_call; define #execute
# as a new method for this instance that invokes #server_streamer # as a new method for this instance that invokes #server_streamer
op = c.operation op = c.operation
op.define_singleton_method(:execute) do op.define_singleton_method(:execute) do
c.server_streamer(req, **kw, &blk) c.server_streamer(req, metadata: metadata, &blk)
end end
op op
end end
@ -391,11 +376,6 @@ module GRPC
# * the deadline is exceeded # * the deadline is exceeded
# #
# #
# == Keyword Args ==
#
# Unspecified keyword arguments are treated as metadata to be sent to the
# server.
#
# == Return Value == # == Return Value ==
# #
# if the return_op is false, the return value is an Enumerator of the # if the return_op is false, the return value is an Enumerator of the
@ -411,36 +391,35 @@ module GRPC
# @param requests [Object] an Enumerable of requests to send # @param requests [Object] an Enumerable of requests to send
# @param marshal [Function] f(obj)->string that marshals requests # @param marshal [Function] f(obj)->string that marshals requests
# @param unmarshal [Function] f(string)->obj that unmarshals responses # @param unmarshal [Function] f(string)->obj that unmarshals responses
# @param timeout [Numeric] (optional) the max completion time in seconds
# @param deadline [Time] (optional) the time the request should complete # @param deadline [Time] (optional) the time the request should complete
# @param parent [Core::Call] a prior call whose reserved metadata # @param parent [Core::Call] a prior call whose reserved metadata
# will be propagated by this one. # will be propagated by this one.
# @param credentials [Core::CallCredentials] credentials to use when making # @param credentials [Core::CallCredentials] credentials to use when making
# the call # the call
# @param return_op [true|false] return an Operation if true # @param return_op [true|false] return an Operation if true
# @param metadata [Hash] metadata to be sent to the server
# @param blk [Block] when provided, is executed for each response # @param blk [Block] when provided, is executed for each response
# @return [Enumerator|nil|Operation] as discussed above # @return [Enumerator|nil|Operation] as discussed above
def bidi_streamer(method, requests, marshal, unmarshal, def bidi_streamer(method, requests, marshal, unmarshal,
deadline: nil, deadline: nil,
timeout: nil,
return_op: false, return_op: false,
parent: nil, parent: nil,
credentials: nil, credentials: nil,
**kw, metadata: {},
&blk) &blk)
c = new_active_call(method, marshal, unmarshal, c = new_active_call(method, marshal, unmarshal,
deadline: deadline, deadline: deadline,
timeout: timeout,
parent: parent, parent: parent,
credentials: credentials) credentials: credentials)
return c.bidi_streamer(requests, **kw, &blk) unless return_op return c.bidi_streamer(requests, metadata: metadata,
&blk) unless return_op
# return the operation view of the active_call; define #execute # return the operation view of the active_call; define #execute
# as a new method for this instance that invokes #bidi_streamer # as a new method for this instance that invokes #bidi_streamer
op = c.operation op = c.operation
op.define_singleton_method(:execute) do op.define_singleton_method(:execute) do
c.bidi_streamer(requests, **kw, &blk) c.bidi_streamer(requests, metadata: metadata, &blk)
end end
op op
end end
@ -457,12 +436,10 @@ module GRPC
# @param timeout [TimeConst] # @param timeout [TimeConst]
def new_active_call(method, marshal, unmarshal, def new_active_call(method, marshal, unmarshal,
deadline: nil, deadline: nil,
timeout: nil,
parent: nil, parent: nil,
credentials: nil) credentials: nil)
if deadline.nil?
deadline = from_relative_time(timeout.nil? ? @timeout : timeout) deadline = from_relative_time(@timeout) if deadline.nil?
end
# Provide each new client call with its own completion queue # Provide each new client call with its own completion queue
call_queue = Core::CompletionQueue.new call_queue = Core::CompletionQueue.new
call = @ch.create_call(call_queue, call = @ch.create_call(call_queue,

@ -80,12 +80,12 @@ module GRPC
else # is a bidi_stream else # is a bidi_stream
active_call.run_server_bidi(mth) active_call.run_server_bidi(mth)
end end
send_status(active_call, OK, 'OK', **active_call.output_metadata) send_status(active_call, OK, 'OK', active_call.output_metadata)
rescue BadStatus => e rescue BadStatus => e
# this is raised by handlers that want GRPC to send an application error # this is raised by handlers that want GRPC to send an application error
# code and detail message and some additional app-specific metadata. # code and detail message and some additional app-specific metadata.
GRPC.logger.debug("app err:#{active_call}, status:#{e.code}:#{e.details}") GRPC.logger.debug("app err:#{active_call}, status:#{e.code}:#{e.details}")
send_status(active_call, e.code, e.details, **e.metadata) send_status(active_call, e.code, e.details, e.metadata)
rescue Core::CallError => e rescue Core::CallError => e
# This is raised by GRPC internals but should rarely, if ever happen. # This is raised by GRPC internals but should rarely, if ever happen.
# Log it, but don't notify the other endpoint.. # Log it, but don't notify the other endpoint..
@ -135,10 +135,10 @@ module GRPC
"##{mth.name}: bad arg count; got:#{mth.arity}, want:#{want}, #{msg}" "##{mth.name}: bad arg count; got:#{mth.arity}, want:#{want}, #{msg}"
end end
def send_status(active_client, code, details, **kw) def send_status(active_client, code, details, metadata = {})
details = 'Not sure why' if details.nil? details = 'Not sure why' if details.nil?
GRPC.logger.debug("Sending status #{code}:#{details}") GRPC.logger.debug("Sending status #{code}:#{details}")
active_client.send_status(code, details, code == OK, **kw) active_client.send_status(code, details, code == OK, metadata: metadata)
rescue StandardError => e rescue StandardError => e
GRPC.logger.warn("Could not send status #{code}:#{details}") GRPC.logger.warn("Could not send status #{code}:#{details}")
GRPC.logger.warn(e) GRPC.logger.warn(e)

@ -169,14 +169,6 @@ module GRPC
alt_cq alt_cq
end end
# setup_srv is used by #initialize to constuct a Core::Server from its
# arguments.
def self.setup_srv(alt_srv, cq, **kw)
return Core::Server.new(cq, kw) if alt_srv.nil?
fail(TypeError, '!Server') unless alt_srv.is_a? Core::Server
alt_srv
end
# setup_connect_md_proc is used by #initialize to validate the # setup_connect_md_proc is used by #initialize to validate the
# connect_md_proc. # connect_md_proc.
def self.setup_connect_md_proc(a_proc) def self.setup_connect_md_proc(a_proc)
@ -193,9 +185,6 @@ module GRPC
# instance, however other arbitrary are allowed and when present are used # instance, however other arbitrary are allowed and when present are used
# to configure the listeninng connection set up by the RpcServer. # to configure the listeninng connection set up by the RpcServer.
# #
# * server_override: which if passed must be a [GRPC::Core::Server]. When
# present.
#
# * poll_period: when present, the server polls for new events with this # * poll_period: when present, the server polls for new events with this
# period # period
# #
@ -217,13 +206,15 @@ module GRPC
# when non-nil is a proc for determining metadata to to send back the client # when non-nil is a proc for determining metadata to to send back the client
# on receiving an invocation req. The proc signature is: # on receiving an invocation req. The proc signature is:
# {key: val, ..} func(method_name, {key: val, ...}) # {key: val, ..} func(method_name, {key: val, ...})
#
# * server_args:
# A server arguments hash to be passed down to the underlying core server
def initialize(pool_size:DEFAULT_POOL_SIZE, def initialize(pool_size:DEFAULT_POOL_SIZE,
max_waiting_requests:DEFAULT_MAX_WAITING_REQUESTS, max_waiting_requests:DEFAULT_MAX_WAITING_REQUESTS,
poll_period:DEFAULT_POLL_PERIOD, poll_period:DEFAULT_POLL_PERIOD,
completion_queue_override:nil, completion_queue_override:nil,
server_override:nil,
connect_md_proc:nil, connect_md_proc:nil,
**kw) server_args:{})
@connect_md_proc = RpcServer.setup_connect_md_proc(connect_md_proc) @connect_md_proc = RpcServer.setup_connect_md_proc(connect_md_proc)
@cq = RpcServer.setup_cq(completion_queue_override) @cq = RpcServer.setup_cq(completion_queue_override)
@max_waiting_requests = max_waiting_requests @max_waiting_requests = max_waiting_requests
@ -235,7 +226,7 @@ module GRPC
# running_state can take 4 values: :not_started, :running, :stopping, and # running_state can take 4 values: :not_started, :running, :stopping, and
# :stopped. State transitions can only proceed in that order. # :stopped. State transitions can only proceed in that order.
@running_state = :not_started @running_state = :not_started
@server = RpcServer.setup_srv(server_override, @cq, **kw) @server = Core::Server.new(@cq, server_args)
end end
# stops a running server # stops a running server

@ -179,24 +179,24 @@ module GRPC
unmarshal = desc.unmarshal_proc(:output) unmarshal = desc.unmarshal_proc(:output)
route = "/#{route_prefix}/#{name}" route = "/#{route_prefix}/#{name}"
if desc.request_response? if desc.request_response?
define_method(mth_name) do |req, **kw| define_method(mth_name) do |req, metadata = {}|
GRPC.logger.debug("calling #{@host}:#{route}") GRPC.logger.debug("calling #{@host}:#{route}")
request_response(route, req, marshal, unmarshal, **kw) request_response(route, req, marshal, unmarshal, metadata)
end end
elsif desc.client_streamer? elsif desc.client_streamer?
define_method(mth_name) do |reqs, **kw| define_method(mth_name) do |reqs, metadata = {}|
GRPC.logger.debug("calling #{@host}:#{route}") GRPC.logger.debug("calling #{@host}:#{route}")
client_streamer(route, reqs, marshal, unmarshal, **kw) client_streamer(route, reqs, marshal, unmarshal, metadata)
end end
elsif desc.server_streamer? elsif desc.server_streamer?
define_method(mth_name) do |req, **kw, &blk| define_method(mth_name) do |req, metadata = {}, &blk|
GRPC.logger.debug("calling #{@host}:#{route}") GRPC.logger.debug("calling #{@host}:#{route}")
server_streamer(route, req, marshal, unmarshal, **kw, &blk) server_streamer(route, req, marshal, unmarshal, metadata, &blk)
end end
else # is a bidi_stream else # is a bidi_stream
define_method(mth_name) do |reqs, **kw, &blk| define_method(mth_name) do |reqs, metadata = {}, &blk|
GRPC.logger.debug("calling #{@host}:#{route}") GRPC.logger.debug("calling #{@host}:#{route}")
bidi_streamer(route, reqs, marshal, unmarshal, **kw, &blk) bidi_streamer(route, reqs, marshal, unmarshal, metadata, &blk)
end end
end end
end end

@ -114,7 +114,9 @@ def create_stub(opts)
if opts.secure if opts.secure
creds = ssl_creds(opts.use_test_ca) creds = ssl_creds(opts.use_test_ca)
stub_opts = { stub_opts = {
GRPC::Core::Channel::SSL_TARGET => opts.host_override channel_args: {
GRPC::Core::Channel::SSL_TARGET => opts.host_override
}
} }
# Add service account creds if specified # Add service account creds if specified
@ -315,7 +317,8 @@ class NamedTests
def timeout_on_sleeping_server def timeout_on_sleeping_server
msg_sizes = [[27_182, 31_415]] msg_sizes = [[27_182, 31_415]]
ppp = PingPongPlayer.new(msg_sizes) ppp = PingPongPlayer.new(msg_sizes)
resps = @stub.full_duplex_call(ppp.each_item, timeout: 0.001) deadline = GRPC::Core::TimeConsts::from_relative_time(0.001)
resps = @stub.full_duplex_call(ppp.each_item, deadline: deadline)
resps.each { |r| ppp.queue.push(r) } resps.each { |r| ppp.queue.push(r) }
fail 'Should have raised GRPC::BadStatus(DEADLINE_EXCEEDED)' fail 'Should have raised GRPC::BadStatus(DEADLINE_EXCEEDED)'
rescue GRPC::BadStatus => e rescue GRPC::BadStatus => e

@ -66,8 +66,10 @@ class BenchmarkClient
cred = GRPC::Core::ChannelCredentials.new() cred = GRPC::Core::ChannelCredentials.new()
end end
if config.security_params.server_host_override if config.security_params.server_host_override
opts[GRPC::Core::Channel::SSL_TARGET] = channel_args = {}
channel_args[GRPC::Core::Channel::SSL_TARGET] =
config.security_params.server_host_override config.security_params.server_host_override
opts[:channel_args] = channel_args
end end
else else
cred = :this_channel_is_insecure cred = :this_channel_is_insecure

@ -75,13 +75,14 @@ class BenchmarkServer
@port = @server.add_http2_port("0.0.0.0:" + port.to_s, cred) @port = @server.add_http2_port("0.0.0.0:" + port.to_s, cred)
@server.handle(BenchmarkServiceImpl.new) @server.handle(BenchmarkServiceImpl.new)
@start_time = Time.now @start_time = Time.now
Thread.new { t = Thread.new {
@server.run @server.run
} }
t.abort_on_exception
end end
def mark(reset) def mark(reset)
s = Grpc::Testing::ServerStats.new(time_elapsed: s = Grpc::Testing::ServerStats.new(time_elapsed:
(Time.now-@start_time).to_f) (Time.now-@start_time).to_f)
@start_time = Time.now if reset @start_time = Time.now if reset
s s
end end

@ -159,9 +159,10 @@ describe GRPC::ActiveCall do
end end
describe '#client_invoke' do describe '#client_invoke' do
it 'sends keywords as metadata to the server when the are present' do it 'sends metadata to the server when present' do
call = make_test_call call = make_test_call
ActiveCall.client_invoke(call, @client_queue, k1: 'v1', k2: 'v2') metadata = { k1: 'v1', k2: 'v2' }
ActiveCall.client_invoke(call, @client_queue, metadata)
recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline) recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
recvd_call = recvd_rpc.call recvd_call = recvd_rpc.call
expect(recvd_call).to_not be_nil expect(recvd_call).to_not be_nil

@ -68,15 +68,7 @@ describe 'ClientStub' do
describe '#new' do describe '#new' do
let(:fake_host) { 'localhost:0' } let(:fake_host) { 'localhost:0' }
it 'can be created from a host and args' do it 'can be created from a host and args' do
opts = { a_channel_arg: 'an_arg' } opts = { channel_args: { a_channel_arg: 'an_arg' } }
blk = proc do
GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
end
expect(&blk).not_to raise_error
end
it 'can be created with a default deadline' do
opts = { a_channel_arg: 'an_arg', deadline: 5 }
blk = proc do blk = proc do
GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts) GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
end end
@ -84,7 +76,10 @@ describe 'ClientStub' do
end end
it 'can be created with an channel override' do it 'can be created with an channel override' do
opts = { a_channel_arg: 'an_arg', channel_override: @ch } opts = {
channel_args: { a_channel_arg: 'an_arg' },
channel_override: @ch
}
blk = proc do blk = proc do
GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts) GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
end end
@ -93,7 +88,10 @@ describe 'ClientStub' do
it 'cannot be created with a bad channel override' do it 'cannot be created with a bad channel override' do
blk = proc do blk = proc do
opts = { a_channel_arg: 'an_arg', channel_override: Object.new } opts = {
channel_args: { a_channel_arg: 'an_arg' },
channel_override: Object.new
}
GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts) GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
end end
expect(&blk).to raise_error expect(&blk).to raise_error
@ -101,7 +99,7 @@ describe 'ClientStub' do
it 'cannot be created with bad credentials' do it 'cannot be created with bad credentials' do
blk = proc do blk = proc do
opts = { a_channel_arg: 'an_arg' } opts = { channel_args: { a_channel_arg: 'an_arg' } }
GRPC::ClientStub.new(fake_host, @cq, Object.new, **opts) GRPC::ClientStub.new(fake_host, @cq, Object.new, **opts)
end end
expect(&blk).to raise_error expect(&blk).to raise_error
@ -111,8 +109,10 @@ describe 'ClientStub' do
certs = load_test_certs certs = load_test_certs
blk = proc do blk = proc do
opts = { opts = {
GRPC::Core::Channel::SSL_TARGET => 'foo.test.google.fr', channel_args: {
a_channel_arg: 'an_arg' GRPC::Core::Channel::SSL_TARGET => 'foo.test.google.fr',
a_channel_arg: 'an_arg'
}
} }
creds = GRPC::Core::ChannelCredentials.new(certs[0], nil, nil) creds = GRPC::Core::ChannelCredentials.new(certs[0], nil, nil)
GRPC::ClientStub.new(fake_host, @cq, creds, **opts) GRPC::ClientStub.new(fake_host, @cq, creds, **opts)
@ -172,7 +172,7 @@ describe 'ClientStub' do
describe 'without a call operation' do describe 'without a call operation' do
def get_response(stub) def get_response(stub)
stub.request_response(@method, @sent_msg, noop, noop, stub.request_response(@method, @sent_msg, noop, noop,
k1: 'v1', k2: 'v2') metadata: { k1: 'v1', k2: 'v2' })
end end
it_behaves_like 'request response' it_behaves_like 'request response'
@ -181,7 +181,8 @@ describe 'ClientStub' do
describe 'via a call operation' do describe 'via a call operation' do
def get_response(stub) def get_response(stub)
op = stub.request_response(@method, @sent_msg, noop, noop, op = stub.request_response(@method, @sent_msg, noop, noop,
return_op: true, k1: 'v1', k2: 'v2') return_op: true,
metadata: { k1: 'v1', k2: 'v2' })
expect(op).to be_a(GRPC::ActiveCall::Operation) expect(op).to be_a(GRPC::ActiveCall::Operation)
op.execute op.execute
end end
@ -196,7 +197,7 @@ describe 'ClientStub' do
server_port = create_test_server server_port = create_test_server
host = "localhost:#{server_port}" host = "localhost:#{server_port}"
@stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure) @stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
@options = { k1: 'v1', k2: 'v2' } @metadata = { k1: 'v1', k2: 'v2' }
@sent_msgs = Array.new(3) { |i| 'msg_' + (i + 1).to_s } @sent_msgs = Array.new(3) { |i| 'msg_' + (i + 1).to_s }
@resp = 'a_reply' @resp = 'a_reply'
end end
@ -208,7 +209,7 @@ describe 'ClientStub' do
end end
it 'should send metadata to the server ok' do it 'should send metadata to the server ok' do
th = run_client_streamer(@sent_msgs, @resp, @pass, @options) th = run_client_streamer(@sent_msgs, @resp, @pass, **@metadata)
expect(get_response(@stub)).to eq(@resp) expect(get_response(@stub)).to eq(@resp)
th.join th.join
end end
@ -221,7 +222,7 @@ describe 'ClientStub' do
end end
it 'should raise ArgumentError if metadata contains invalid values' do it 'should raise ArgumentError if metadata contains invalid values' do
@options.merge!(k3: 3) @metadata.merge!(k3: 3)
expect do expect do
get_response(@stub) get_response(@stub)
end.to raise_error(ArgumentError, end.to raise_error(ArgumentError,
@ -231,7 +232,8 @@ describe 'ClientStub' do
describe 'without a call operation' do describe 'without a call operation' do
def get_response(stub) def get_response(stub)
stub.client_streamer(@method, @sent_msgs, noop, noop, @options) stub.client_streamer(@method, @sent_msgs, noop, noop,
metadata: @metadata)
end end
it_behaves_like 'client streaming' it_behaves_like 'client streaming'
@ -240,7 +242,7 @@ describe 'ClientStub' do
describe 'via a call operation' do describe 'via a call operation' do
def get_response(stub) def get_response(stub)
op = stub.client_streamer(@method, @sent_msgs, noop, noop, op = stub.client_streamer(@method, @sent_msgs, noop, noop,
@options.merge(return_op: true)) return_op: true, metadata: @metadata)
expect(op).to be_a(GRPC::ActiveCall::Operation) expect(op).to be_a(GRPC::ActiveCall::Operation)
op.execute op.execute
end end
@ -290,7 +292,7 @@ describe 'ClientStub' do
describe 'without a call operation' do describe 'without a call operation' do
def get_responses(stub) def get_responses(stub)
e = stub.server_streamer(@method, @sent_msg, noop, noop, e = stub.server_streamer(@method, @sent_msg, noop, noop,
k1: 'v1', k2: 'v2') metadata: { k1: 'v1', k2: 'v2' })
expect(e).to be_a(Enumerator) expect(e).to be_a(Enumerator)
e e
end end
@ -301,7 +303,8 @@ describe 'ClientStub' do
describe 'via a call operation' do describe 'via a call operation' do
def get_responses(stub) def get_responses(stub)
op = stub.server_streamer(@method, @sent_msg, noop, noop, op = stub.server_streamer(@method, @sent_msg, noop, noop,
return_op: true, k1: 'v1', k2: 'v2') return_op: true,
metadata: { k1: 'v1', k2: 'v2' })
expect(op).to be_a(GRPC::ActiveCall::Operation) expect(op).to be_a(GRPC::ActiveCall::Operation)
e = op.execute e = op.execute
expect(e).to be_a(Enumerator) expect(e).to be_a(Enumerator)
@ -383,7 +386,7 @@ describe 'ClientStub' do
stub = GRPC::ClientStub.new(@host, @cq, :this_channel_is_insecure) stub = GRPC::ClientStub.new(@host, @cq, :this_channel_is_insecure)
blk = proc do blk = proc do
e = stub.bidi_streamer(@method, @sent_msgs, noop, noop, e = stub.bidi_streamer(@method, @sent_msgs, noop, noop,
timeout: 0.001) deadline: from_relative_time(0.001))
e.collect { |r| r } e.collect { |r| r }
end end
expect(&blk).to raise_error GRPC::BadStatus, /Deadline Exceeded/ expect(&blk).to raise_error GRPC::BadStatus, /Deadline Exceeded/

@ -56,14 +56,14 @@ describe GRPC::RpcDesc do
it 'sends the specified status if BadStatus is raised' do it 'sends the specified status if BadStatus is raised' do
expect(@call).to receive(:remote_read).once.and_return(Object.new) expect(@call).to receive(:remote_read).once.and_return(Object.new)
expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false, expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false,
{}) metadata: {})
this_desc.run_server_method(@call, method(:bad_status)) this_desc.run_server_method(@call, method(:bad_status))
end end
it 'sends status UNKNOWN if other StandardErrors are raised' do it 'sends status UNKNOWN if other StandardErrors are raised' do
expect(@call).to receive(:remote_read).once.and_return(Object.new) expect(@call).to receive(:remote_read).once.and_return(Object.new)
expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason, expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason,
false, {}) false, metadata: {})
this_desc.run_server_method(@call, method(:other_error)) this_desc.run_server_method(@call, method(:other_error))
end end
@ -93,7 +93,7 @@ describe GRPC::RpcDesc do
expect(@call).to receive(:remote_send).once.with(@ok_response) expect(@call).to receive(:remote_send).once.with(@ok_response)
expect(@call).to receive(:output_metadata).and_return(fake_md) expect(@call).to receive(:output_metadata).and_return(fake_md)
expect(@call).to receive(:send_status).once.with(OK, 'OK', true, expect(@call).to receive(:send_status).once.with(OK, 'OK', true,
**fake_md) metadata: fake_md)
this_desc.run_server_method(@call, method(:fake_reqresp)) this_desc.run_server_method(@call, method(:fake_reqresp))
end end
end end
@ -106,13 +106,13 @@ describe GRPC::RpcDesc do
it 'sends the specified status if BadStatus is raised' do it 'sends the specified status if BadStatus is raised' do
expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false, expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false,
{}) metadata: {})
@client_streamer.run_server_method(@call, method(:bad_status_alt)) @client_streamer.run_server_method(@call, method(:bad_status_alt))
end end
it 'sends status UNKNOWN if other StandardErrors are raised' do it 'sends status UNKNOWN if other StandardErrors are raised' do
expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason, expect(@call).to receive(:send_status).once.with(UNKNOWN, @no_reason,
false, {}) false, metadata: {})
@client_streamer.run_server_method(@call, method(:other_error_alt)) @client_streamer.run_server_method(@call, method(:other_error_alt))
end end
@ -128,7 +128,7 @@ describe GRPC::RpcDesc do
expect(@call).to receive(:remote_send).once.with(@ok_response) expect(@call).to receive(:remote_send).once.with(@ok_response)
expect(@call).to receive(:output_metadata).and_return(fake_md) expect(@call).to receive(:output_metadata).and_return(fake_md)
expect(@call).to receive(:send_status).once.with(OK, 'OK', true, expect(@call).to receive(:send_status).once.with(OK, 'OK', true,
**fake_md) metadata: fake_md)
@client_streamer.run_server_method(@call, method(:fake_clstream)) @client_streamer.run_server_method(@call, method(:fake_clstream))
end end
end end
@ -148,7 +148,7 @@ describe GRPC::RpcDesc do
expect(@call).to receive(:remote_send).twice.with(@ok_response) expect(@call).to receive(:remote_send).twice.with(@ok_response)
expect(@call).to receive(:output_metadata).and_return(fake_md) expect(@call).to receive(:output_metadata).and_return(fake_md)
expect(@call).to receive(:send_status).once.with(OK, 'OK', true, expect(@call).to receive(:send_status).once.with(OK, 'OK', true,
**fake_md) metadata: fake_md)
@server_streamer.run_server_method(@call, method(:fake_svstream)) @server_streamer.run_server_method(@call, method(:fake_svstream))
end end
end end
@ -165,14 +165,14 @@ describe GRPC::RpcDesc do
e = GRPC::BadStatus.new(@bs_code, 'NOK') e = GRPC::BadStatus.new(@bs_code, 'NOK')
expect(@call).to receive(:run_server_bidi).and_raise(e) expect(@call).to receive(:run_server_bidi).and_raise(e)
expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false, expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false,
{}) metadata: {})
@bidi_streamer.run_server_method(@call, method(:bad_status_alt)) @bidi_streamer.run_server_method(@call, method(:bad_status_alt))
end end
it 'sends status UNKNOWN if other StandardErrors are raised' do it 'sends status UNKNOWN if other StandardErrors are raised' do
expect(@call).to receive(:run_server_bidi).and_raise(StandardError) expect(@call).to receive(:run_server_bidi).and_raise(StandardError)
expect(@call).to receive(:send_status).once.with(UNKNOWN, @no_reason, expect(@call).to receive(:send_status).once.with(UNKNOWN, @no_reason,
false, {}) false, metadata: {})
@bidi_streamer.run_server_method(@call, method(:other_error_alt)) @bidi_streamer.run_server_method(@call, method(:other_error_alt))
end end
@ -180,7 +180,7 @@ describe GRPC::RpcDesc do
expect(@call).to receive(:run_server_bidi) expect(@call).to receive(:run_server_bidi)
expect(@call).to receive(:output_metadata).and_return(fake_md) expect(@call).to receive(:output_metadata).and_return(fake_md)
expect(@call).to receive(:send_status).once.with(OK, 'OK', true, expect(@call).to receive(:send_status).once.with(OK, 'OK', true,
**fake_md) metadata: fake_md)
@bidi_streamer.run_server_method(@call, method(:fake_bidistream)) @bidi_streamer.run_server_method(@call, method(:fake_bidistream))
end end
end end

@ -99,7 +99,7 @@ class FailingService
end end
def an_rpc(_req, _call) def an_rpc(_req, _call)
fail GRPC::BadStatus.new(@code, @details, **@md) fail GRPC::BadStatus.new(@code, @details, @md)
end end
end end
@ -137,24 +137,11 @@ describe GRPC::RpcServer do
@noop = proc { |x| x } @noop = proc { |x| x }
@server_queue = GRPC::Core::CompletionQueue.new @server_queue = GRPC::Core::CompletionQueue.new
server_host = '0.0.0.0:0'
@server = GRPC::Core::Server.new(@server_queue, nil)
server_port = @server.add_http2_port(server_host, :this_port_is_insecure)
@host = "localhost:#{server_port}"
@ch = GRPC::Core::Channel.new(@host, nil, :this_channel_is_insecure)
end end
describe '#new' do describe '#new' do
it 'can be created with just some args' do it 'can be created with just some args' do
opts = { a_channel_arg: 'an_arg' } opts = { server_args: { a_channel_arg: 'an_arg' } }
blk = proc do
RpcServer.new(**opts)
end
expect(&blk).not_to raise_error
end
it 'can be created with a default deadline' do
opts = { a_channel_arg: 'an_arg', deadline: 5 }
blk = proc do blk = proc do
RpcServer.new(**opts) RpcServer.new(**opts)
end end
@ -163,7 +150,7 @@ describe GRPC::RpcServer do
it 'can be created with a completion queue override' do it 'can be created with a completion queue override' do
opts = { opts = {
a_channel_arg: 'an_arg', server_args: { a_channel_arg: 'an_arg' },
completion_queue_override: @server_queue completion_queue_override: @server_queue
} }
blk = proc do blk = proc do
@ -175,7 +162,7 @@ describe GRPC::RpcServer do
it 'cannot be created with a bad completion queue override' do it 'cannot be created with a bad completion queue override' do
blk = proc do blk = proc do
opts = { opts = {
a_channel_arg: 'an_arg', server_args: { a_channel_arg: 'an_arg' },
completion_queue_override: Object.new completion_queue_override: Object.new
} }
RpcServer.new(**opts) RpcServer.new(**opts)
@ -186,38 +173,20 @@ describe GRPC::RpcServer do
it 'cannot be created with invalid ServerCredentials' do it 'cannot be created with invalid ServerCredentials' do
blk = proc do blk = proc do
opts = { opts = {
a_channel_arg: 'an_arg', server_args: { a_channel_arg: 'an_arg' },
creds: Object.new creds: Object.new
} }
RpcServer.new(**opts) RpcServer.new(**opts)
end end
expect(&blk).to raise_error expect(&blk).to raise_error
end end
it 'can be created with a server override' do
opts = { a_channel_arg: 'an_arg', server_override: @server }
blk = proc do
RpcServer.new(**opts)
end
expect(&blk).not_to raise_error
end
it 'cannot be created with a bad server override' do
blk = proc do
opts = {
a_channel_arg: 'an_arg',
server_override: Object.new
}
RpcServer.new(**opts)
end
expect(&blk).to raise_error
end
end end
describe '#stopped?' do describe '#stopped?' do
before(:each) do before(:each) do
opts = { a_channel_arg: 'an_arg', poll_period: 1.5 } opts = { server_args: { a_channel_arg: 'an_arg' }, poll_period: 1.5 }
@srv = RpcServer.new(**opts) @srv = RpcServer.new(**opts)
@srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
end end
it 'starts out false' do it 'starts out false' do
@ -245,28 +214,30 @@ describe GRPC::RpcServer do
describe '#running?' do describe '#running?' do
it 'starts out false' do it 'starts out false' do
opts = { a_channel_arg: 'an_arg', server_override: @server } opts = {
server_args: { a_channel_arg: 'an_arg' }
}
r = RpcServer.new(**opts) r = RpcServer.new(**opts)
expect(r.running?).to be(false) expect(r.running?).to be(false)
end end
it 'is false if run is called with no services registered', server: true do it 'is false if run is called with no services registered', server: true do
opts = { opts = {
a_channel_arg: 'an_arg', server_args: { a_channel_arg: 'an_arg' },
poll_period: 2, poll_period: 2
server_override: @server
} }
r = RpcServer.new(**opts) r = RpcServer.new(**opts)
r.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
expect { r.run }.to raise_error(RuntimeError) expect { r.run }.to raise_error(RuntimeError)
end end
it 'is true after run is called with a registered service' do it 'is true after run is called with a registered service' do
opts = { opts = {
a_channel_arg: 'an_arg', server_args: { a_channel_arg: 'an_arg' },
poll_period: 2.5, poll_period: 2.5
server_override: @server
} }
r = RpcServer.new(**opts) r = RpcServer.new(**opts)
r.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
r.handle(EchoService) r.handle(EchoService)
t = Thread.new { r.run } t = Thread.new { r.run }
r.wait_till_running r.wait_till_running
@ -278,8 +249,9 @@ describe GRPC::RpcServer do
describe '#handle' do describe '#handle' do
before(:each) do before(:each) do
@opts = { a_channel_arg: 'an_arg', poll_period: 1 } @opts = { server_args: { a_channel_arg: 'an_arg' }, poll_period: 1 }
@srv = RpcServer.new(**@opts) @srv = RpcServer.new(**@opts)
@srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
end end
it 'raises if #run has already been called' do it 'raises if #run has already been called' do
@ -322,11 +294,13 @@ describe GRPC::RpcServer do
context 'with no connect_metadata' do context 'with no connect_metadata' do
before(:each) do before(:each) do
server_opts = { server_opts = {
server_override: @server,
completion_queue_override: @server_queue, completion_queue_override: @server_queue,
poll_period: 1 poll_period: 1
} }
@srv = RpcServer.new(**server_opts) @srv = RpcServer.new(**server_opts)
server_port = @srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
@host = "localhost:#{server_port}"
@ch = GRPC::Core::Channel.new(@host, nil, :this_channel_is_insecure)
end end
it 'should return NOT_FOUND status on unknown methods', server: true do it 'should return NOT_FOUND status on unknown methods', server: true do
@ -383,7 +357,8 @@ describe GRPC::RpcServer do
@srv.wait_till_running @srv.wait_till_running
req = EchoMsg.new req = EchoMsg.new
stub = EchoStub.new(@host, :this_channel_is_insecure, **client_opts) stub = EchoStub.new(@host, :this_channel_is_insecure, **client_opts)
expect(stub.an_rpc(req, k1: 'v1', k2: 'v2')).to be_a(EchoMsg) expect(stub.an_rpc(req, metadata: { k1: 'v1', k2: 'v2' }))
.to be_a(EchoMsg)
wanted_md = [{ 'k1' => 'v1', 'k2' => 'v2' }] wanted_md = [{ 'k1' => 'v1', 'k2' => 'v2' }]
check_md(wanted_md, service.received_md) check_md(wanted_md, service.received_md)
@srv.stop @srv.stop
@ -397,8 +372,11 @@ describe GRPC::RpcServer do
@srv.wait_till_running @srv.wait_till_running
req = EchoMsg.new req = EchoMsg.new
stub = SlowStub.new(@host, :this_channel_is_insecure, **client_opts) stub = SlowStub.new(@host, :this_channel_is_insecure, **client_opts)
timeout = service.delay + 1.0 # wait for long enough timeout = service.delay + 1.0
resp = stub.an_rpc(req, timeout: timeout, k1: 'v1', k2: 'v2') deadline = GRPC::Core::TimeConsts.from_relative_time(timeout)
resp = stub.an_rpc(req,
deadline: deadline,
metadata: { k1: 'v1', k2: 'v2' })
expect(resp).to be_a(EchoMsg) expect(resp).to be_a(EchoMsg)
wanted_md = [{ 'k1' => 'v1', 'k2' => 'v2' }] wanted_md = [{ 'k1' => 'v1', 'k2' => 'v2' }]
check_md(wanted_md, service.received_md) check_md(wanted_md, service.received_md)
@ -413,7 +391,7 @@ describe GRPC::RpcServer do
@srv.wait_till_running @srv.wait_till_running
req = EchoMsg.new req = EchoMsg.new
stub = SlowStub.new(@host, :this_channel_is_insecure, **client_opts) stub = SlowStub.new(@host, :this_channel_is_insecure, **client_opts)
op = stub.an_rpc(req, k1: 'v1', k2: 'v2', return_op: true) op = stub.an_rpc(req, metadata: { k1: 'v1', k2: 'v2' }, return_op: true)
Thread.new do # cancel the call Thread.new do # cancel the call
sleep 0.1 sleep 0.1
op.cancel op.cancel
@ -443,8 +421,7 @@ describe GRPC::RpcServer do
it 'should return RESOURCE_EXHAUSTED on too many jobs', server: true do it 'should return RESOURCE_EXHAUSTED on too many jobs', server: true do
opts = { opts = {
a_channel_arg: 'an_arg', server_args: { a_channel_arg: 'an_arg' },
server_override: @server,
completion_queue_override: @server_queue, completion_queue_override: @server_queue,
pool_size: 1, pool_size: 1,
poll_period: 1, poll_period: 1,
@ -452,6 +429,8 @@ describe GRPC::RpcServer do
} }
alt_srv = RpcServer.new(**opts) alt_srv = RpcServer.new(**opts)
alt_srv.handle(SlowService) alt_srv.handle(SlowService)
alt_port = alt_srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
alt_host = "0.0.0.0:#{alt_port}"
t = Thread.new { alt_srv.run } t = Thread.new { alt_srv.run }
alt_srv.wait_till_running alt_srv.wait_till_running
req = EchoMsg.new req = EchoMsg.new
@ -460,7 +439,7 @@ describe GRPC::RpcServer do
one_failed_as_unavailable = false one_failed_as_unavailable = false
n.times do n.times do
threads << Thread.new do threads << Thread.new do
stub = SlowStub.new(@host, :this_channel_is_insecure, **client_opts) stub = SlowStub.new(alt_host, :this_channel_is_insecure)
begin begin
stub.an_rpc(req) stub.an_rpc(req)
rescue GRPC::BadStatus => e rescue GRPC::BadStatus => e
@ -487,12 +466,13 @@ describe GRPC::RpcServer do
end end
before(:each) do before(:each) do
server_opts = { server_opts = {
server_override: @server,
completion_queue_override: @server_queue, completion_queue_override: @server_queue,
poll_period: 1, poll_period: 1,
connect_md_proc: test_md_proc connect_md_proc: test_md_proc
} }
@srv = RpcServer.new(**server_opts) @srv = RpcServer.new(**server_opts)
alt_port = @srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
@alt_host = "0.0.0.0:#{alt_port}"
end end
it 'should send connect metadata to the client', server: true do it 'should send connect metadata to the client', server: true do
@ -501,8 +481,8 @@ describe GRPC::RpcServer do
t = Thread.new { @srv.run } t = Thread.new { @srv.run }
@srv.wait_till_running @srv.wait_till_running
req = EchoMsg.new req = EchoMsg.new
stub = EchoStub.new(@host, :this_channel_is_insecure, **client_opts) stub = EchoStub.new(@alt_host, :this_channel_is_insecure)
op = stub.an_rpc(req, k1: 'v1', k2: 'v2', return_op: true) op = stub.an_rpc(req, metadata: { k1: 'v1', k2: 'v2' }, return_op: true)
expect(op.metadata).to be nil expect(op.metadata).to be nil
expect(op.execute).to be_a(EchoMsg) expect(op.execute).to be_a(EchoMsg)
wanted_md = { wanted_md = {
@ -522,11 +502,12 @@ describe GRPC::RpcServer do
context 'with trailing metadata' do context 'with trailing metadata' do
before(:each) do before(:each) do
server_opts = { server_opts = {
server_override: @server,
completion_queue_override: @server_queue, completion_queue_override: @server_queue,
poll_period: 1 poll_period: 1
} }
@srv = RpcServer.new(**server_opts) @srv = RpcServer.new(**server_opts)
alt_port = @srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
@alt_host = "0.0.0.0:#{alt_port}"
end end
it 'should be added to BadStatus when requests fail', server: true do it 'should be added to BadStatus when requests fail', server: true do
@ -535,7 +516,7 @@ describe GRPC::RpcServer do
t = Thread.new { @srv.run } t = Thread.new { @srv.run }
@srv.wait_till_running @srv.wait_till_running
req = EchoMsg.new req = EchoMsg.new
stub = FailingStub.new(@host, :this_channel_is_insecure, **client_opts) stub = FailingStub.new(@alt_host, :this_channel_is_insecure)
blk = proc { stub.an_rpc(req) } blk = proc { stub.an_rpc(req) }
# confirm it raise the expected error # confirm it raise the expected error
@ -560,8 +541,8 @@ describe GRPC::RpcServer do
t = Thread.new { @srv.run } t = Thread.new { @srv.run }
@srv.wait_till_running @srv.wait_till_running
req = EchoMsg.new req = EchoMsg.new
stub = EchoStub.new(@host, :this_channel_is_insecure, **client_opts) stub = EchoStub.new(@alt_host, :this_channel_is_insecure)
op = stub.an_rpc(req, k1: 'v1', k2: 'v2', return_op: true) op = stub.an_rpc(req, return_op: true, metadata: { k1: 'v1', k2: 'v2' })
expect(op.metadata).to be nil expect(op.metadata).to be nil
expect(op.execute).to be_a(EchoMsg) expect(op.execute).to be_a(EchoMsg)
expect(op.metadata).to eq(wanted_trailers) expect(op.metadata).to eq(wanted_trailers)

@ -170,17 +170,15 @@ describe Grpc::Health::Checker do
before(:each) do before(:each) do
@server_queue = GRPC::Core::CompletionQueue.new @server_queue = GRPC::Core::CompletionQueue.new
server_host = '0.0.0.0:0' server_host = '0.0.0.0:0'
@server = GRPC::Core::Server.new(@server_queue, nil)
server_port = @server.add_http2_port(server_host, :this_port_is_insecure)
@host = "localhost:#{server_port}"
@ch = GRPC::Core::Channel.new(@host, nil, :this_channel_is_insecure)
@client_opts = { channel_override: @ch } @client_opts = { channel_override: @ch }
server_opts = { server_opts = {
server_override: @server,
completion_queue_override: @server_queue, completion_queue_override: @server_queue,
poll_period: 1 poll_period: 1
} }
@srv = RpcServer.new(**server_opts) @srv = RpcServer.new(**server_opts)
server_port = @srv.add_http2_port(server_host, :this_port_is_insecure)
@host = "localhost:#{server_port}"
@ch = GRPC::Core::Channel.new(@host, nil, :this_channel_is_insecure)
end end
after(:each) do after(:each) do

@ -29,7 +29,7 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
FROM debian:jessie FROM ubuntu:15.10
<%include file="../../apt_get_basic.include"/> <%include file="../../apt_get_basic.include"/>
#======================== #========================
@ -46,10 +46,8 @@
#====================================== #======================================
# More sanity test dependencies (bazel) # More sanity test dependencies (bazel)
RUN echo "deb http://httpredir.debian.org/debian jessie-backports main" > \ RUN apt-get install -y openjdk-8-jdk
/etc/apt/sources.list.d/backports.list # TOOD(jtattermusch): pin the bazel version
RUN apt-get update
RUN apt-get -t jessie-backports install -y openjdk-8-jdk
RUN git clone https://github.com/bazelbuild/bazel.git /bazel RUN git clone https://github.com/bazelbuild/bazel.git /bazel
RUN cd /bazel && ./compile.sh RUN cd /bazel && ./compile.sh
RUN ln -s /bazel/output/bazel /bin/ RUN ln -s /bazel/output/bazel /bin/
@ -58,7 +56,6 @@
# Docker "inception" # Docker "inception"
# Note this is quite the ugly hack. # Note this is quite the ugly hack.
# This makes sure that the docker binary we inject has its dependencies. # This makes sure that the docker binary we inject has its dependencies.
RUN apt-get install libsystemd-journal0
RUN curl https://get.docker.com/ | sh RUN curl https://get.docker.com/ | sh
RUN apt-get remove --purge -y docker-engine RUN apt-get remove --purge -y docker-engine

@ -69,6 +69,8 @@ static void handle_read(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(error == GRPC_ERROR_NONE);
gpr_slice_buffer_move_into(&state.temp_incoming_buffer, gpr_slice_buffer_move_into(&state.temp_incoming_buffer,
&state.incoming_buffer); &state.incoming_buffer);
gpr_log(GPR_DEBUG, "got %d bytes, magic is %d bytes",
state.incoming_buffer.length, strlen(magic_connect_string));
if (state.incoming_buffer.length > strlen(magic_connect_string)) { if (state.incoming_buffer.length > strlen(magic_connect_string)) {
gpr_atm_rel_store(&state.done_atm, 1); gpr_atm_rel_store(&state.done_atm, 1);
grpc_endpoint_shutdown(exec_ctx, state.tcp); grpc_endpoint_shutdown(exec_ctx, state.tcp);
@ -118,7 +120,6 @@ static gpr_timespec n_sec_deadline(int seconds) {
} }
static void start_rpc(int use_creds, int target_port) { static void start_rpc(int use_creds, int target_port) {
gpr_atm_rel_store(&state.done_atm, 0);
state.cq = grpc_completion_queue_create(NULL); state.cq = grpc_completion_queue_create(NULL);
if (use_creds) { if (use_creds) {
state.creds = grpc_fake_transport_security_credentials_create(); state.creds = grpc_fake_transport_security_credentials_create();
@ -167,8 +168,15 @@ typedef struct {
static void actually_poll_server(void *arg) { static void actually_poll_server(void *arg) {
poll_args *pa = arg; poll_args *pa = arg;
gpr_timespec deadline = n_sec_deadline(10); gpr_timespec deadline = n_sec_deadline(10);
while (gpr_atm_acq_load(&state.done_atm) == 0 && while (true) {
gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), deadline) < 0) { bool done = gpr_atm_acq_load(&state.done_atm) != 0;
gpr_timespec time_left =
gpr_time_sub(deadline, gpr_now(GPR_CLOCK_REALTIME));
gpr_log(GPR_DEBUG, "done=%d, time_left=%d.%09d", done, time_left.tv_sec,
time_left.tv_nsec);
if (done || gpr_time_cmp(time_left, gpr_time_0(GPR_TIMESPAN)) < 0) {
break;
}
test_tcp_server_poll(pa->server, 1); test_tcp_server_poll(pa->server, 1);
} }
gpr_event_set(pa->signal_when_done, (void *)1); gpr_event_set(pa->signal_when_done, (void *)1);
@ -177,6 +185,7 @@ static void actually_poll_server(void *arg) {
static void poll_server_until_read_done(test_tcp_server *server, static void poll_server_until_read_done(test_tcp_server *server,
gpr_event *signal_when_done) { gpr_event *signal_when_done) {
gpr_atm_rel_store(&state.done_atm, 0);
gpr_thd_id id; gpr_thd_id id;
poll_args *pa = gpr_malloc(sizeof(*pa)); poll_args *pa = gpr_malloc(sizeof(*pa));
pa->server = server; pa->server = server;

@ -105,7 +105,7 @@ static void test_invoke_request_with_flags(
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
grpc_byte_buffer *request_payload = grpc_byte_buffer *request_payload =
grpc_raw_byte_buffer_create(&request_payload_slice, 1); grpc_raw_byte_buffer_create(&request_payload_slice, 1);
gpr_timespec deadline = GRPC_TIMEOUT_MILLIS_TO_DEADLINE(10); gpr_timespec deadline = five_seconds_time();
grpc_end2end_test_fixture f = grpc_end2end_test_fixture f =
begin_test(config, "test_invoke_request_with_flags", NULL, NULL); begin_test(config, "test_invoke_request_with_flags", NULL, NULL);
cq_verifier *cqv = cq_verifier_create(f.cq); cq_verifier *cqv = cq_verifier_create(f.cq);

@ -1,78 +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.
*
*/
#include <set>
#include <grpc/support/log.h>
#include "test/cpp/qps/driver.h"
#include "test/cpp/qps/report.h"
#include "test/cpp/util/benchmark_config.h"
namespace grpc {
namespace testing {
static const int WARMUP = 5;
static const int BENCHMARK = 5;
static void RunAsyncStreamingPingPong() {
gpr_log(GPR_INFO, "Running Async Streaming Ping Pong");
ClientConfig client_config;
client_config.set_client_type(ASYNC_CLIENT);
client_config.set_outstanding_rpcs_per_channel(1);
client_config.set_client_channels(1);
client_config.set_async_client_threads(1);
client_config.set_rpc_type(STREAMING);
client_config.mutable_load_params()->mutable_closed_loop();
ServerConfig server_config;
server_config.set_server_type(ASYNC_SERVER);
server_config.set_async_server_threads(1);
const auto result =
RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2);
GetReporter()->ReportQPS(*result);
GetReporter()->ReportLatency(*result);
}
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc::testing::InitBenchmark(&argc, &argv, true);
grpc::testing::RunAsyncStreamingPingPong();
return 0;
}

@ -1,77 +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.
*
*/
#include <set>
#include <grpc/support/log.h>
#include "test/cpp/qps/driver.h"
#include "test/cpp/qps/report.h"
#include "test/cpp/util/benchmark_config.h"
namespace grpc {
namespace testing {
static const int WARMUP = 5;
static const int BENCHMARK = 5;
static void RunAsyncUnaryPingPong() {
gpr_log(GPR_INFO, "Running Async Unary Ping Pong");
ClientConfig client_config;
client_config.set_client_type(ASYNC_CLIENT);
client_config.set_outstanding_rpcs_per_channel(1);
client_config.set_client_channels(1);
client_config.set_async_client_threads(1);
client_config.set_rpc_type(UNARY);
client_config.mutable_load_params()->mutable_closed_loop();
ServerConfig server_config;
server_config.set_server_type(ASYNC_SERVER);
server_config.set_async_server_threads(1);
const auto result =
RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2);
GetReporter()->ReportQPS(*result);
GetReporter()->ReportLatency(*result);
}
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc::testing::InitBenchmark(&argc, &argv, true);
grpc::testing::RunAsyncUnaryPingPong();
return 0;
}

@ -44,6 +44,9 @@ sys.path.append(run_tests_root)
import performance.scenario_config as scenario_config import performance.scenario_config as scenario_config
def _scenario_json_string(scenario_json): def _scenario_json_string(scenario_json):
# tweak parameters to get fast test times
scenario_json['warmup_seconds'] = 1
scenario_json['benchmark_seconds'] = 1
return json.dumps(scenario_config.remove_nonproto_fields(scenario_json)) return json.dumps(scenario_config.remove_nonproto_fields(scenario_json))
def threads_of_type(scenario_json, path): def threads_of_type(scenario_json, path):

@ -1,82 +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.
*
*/
#include <set>
#include <grpc/support/log.h>
#include "test/cpp/qps/driver.h"
#include "test/cpp/qps/report.h"
#include "test/cpp/util/benchmark_config.h"
namespace grpc {
namespace testing {
static const int WARMUP = 5;
static const int BENCHMARK = 5;
static void RunGenericAsyncStreamingPingPong() {
gpr_log(GPR_INFO, "Running Generic Async Streaming Ping Pong");
ClientConfig client_config;
client_config.set_client_type(ASYNC_CLIENT);
client_config.set_outstanding_rpcs_per_channel(1);
client_config.set_client_channels(1);
client_config.set_async_client_threads(1);
client_config.set_rpc_type(STREAMING);
client_config.mutable_load_params()->mutable_closed_loop();
auto bbuf = client_config.mutable_payload_config()->mutable_bytebuf_params();
bbuf->set_resp_size(0);
bbuf->set_req_size(0);
ServerConfig server_config;
server_config.set_server_type(ASYNC_GENERIC_SERVER);
server_config.set_async_server_threads(1);
*server_config.mutable_payload_config() = client_config.payload_config();
const auto result =
RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2);
GetReporter()->ReportQPS(*result);
GetReporter()->ReportLatency(*result);
}
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc::testing::InitBenchmark(&argc, &argv, true);
grpc::testing::RunGenericAsyncStreamingPingPong();
return 0;
}

@ -131,10 +131,10 @@ class AsyncQpsServerTest : public Server {
} }
} }
~AsyncQpsServerTest() { ~AsyncQpsServerTest() {
server_->Shutdown();
for (auto ss = shutdown_state_.begin(); ss != shutdown_state_.end(); ++ss) { for (auto ss = shutdown_state_.begin(); ss != shutdown_state_.end(); ++ss) {
(*ss)->set_shutdown(); (*ss)->set_shutdown();
} }
server_->Shutdown();
for (auto thr = threads_.begin(); thr != threads_.end(); thr++) { for (auto thr = threads_.begin(); thr != threads_.end(); thr++) {
thr->join(); thr->join();
} }

@ -1,76 +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.
*
*/
#include <set>
#include <grpc/support/log.h>
#include "test/cpp/qps/driver.h"
#include "test/cpp/qps/report.h"
#include "test/cpp/util/benchmark_config.h"
namespace grpc {
namespace testing {
static const int WARMUP = 5;
static const int BENCHMARK = 5;
static void RunSynchronousStreamingPingPong() {
gpr_log(GPR_INFO, "Running Synchronous Streaming Ping Pong");
ClientConfig client_config;
client_config.set_client_type(SYNC_CLIENT);
client_config.set_outstanding_rpcs_per_channel(1);
client_config.set_client_channels(1);
client_config.set_rpc_type(STREAMING);
client_config.mutable_load_params()->mutable_closed_loop();
ServerConfig server_config;
server_config.set_server_type(SYNC_SERVER);
const auto result =
RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2);
GetReporter()->ReportQPS(*result);
GetReporter()->ReportLatency(*result);
}
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc::testing::InitBenchmark(&argc, &argv, true);
grpc::testing::RunSynchronousStreamingPingPong();
return 0;
}

@ -1,77 +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.
*
*/
#include <set>
#include <grpc/support/log.h>
#include "test/cpp/qps/driver.h"
#include "test/cpp/qps/report.h"
#include "test/cpp/util/benchmark_config.h"
namespace grpc {
namespace testing {
static const int WARMUP = 5;
static const int BENCHMARK = 5;
static void RunSynchronousUnaryPingPong() {
gpr_log(GPR_INFO, "Running Synchronous Unary Ping Pong");
ClientConfig client_config;
client_config.set_client_type(SYNC_CLIENT);
client_config.set_outstanding_rpcs_per_channel(1);
client_config.set_client_channels(1);
client_config.set_rpc_type(UNARY);
client_config.mutable_load_params()->mutable_closed_loop();
ServerConfig server_config;
server_config.set_server_type(SYNC_SERVER);
const auto result =
RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2);
GetReporter()->ReportQPS(*result);
GetReporter()->ReportLatency(*result);
}
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc::testing::InitBenchmark(&argc, &argv, true);
grpc::testing::RunSynchronousUnaryPingPong();
return 0;
}

@ -27,7 +27,7 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
FROM debian:jessie FROM ubuntu:15.10
# Install Git and basic packages. # Install Git and basic packages.
RUN apt-get update && apt-get install -y \ RUN apt-get update && apt-get install -y \
@ -77,9 +77,8 @@ RUN pip install simplejson mako
#====================================== #======================================
# More sanity test dependencies (bazel) # More sanity test dependencies (bazel)
RUN echo "deb http://httpredir.debian.org/debian jessie-backports main" > /etc/apt/sources.list.d/backports.list RUN apt-get install -y openjdk-8-jdk
RUN apt-get update # TOOD(jtattermusch): pin the bazel version
RUN apt-get -t jessie-backports install -y openjdk-8-jdk
RUN git clone https://github.com/bazelbuild/bazel.git /bazel RUN git clone https://github.com/bazelbuild/bazel.git /bazel
RUN cd /bazel && ./compile.sh RUN cd /bazel && ./compile.sh
RUN ln -s /bazel/output/bazel /bin/ RUN ln -s /bazel/output/bazel /bin/
@ -88,7 +87,6 @@ RUN ln -s /bazel/output/bazel /bin/
# Docker "inception" # Docker "inception"
# Note this is quite the ugly hack. # Note this is quite the ugly hack.
# This makes sure that the docker binary we inject has its dependencies. # This makes sure that the docker binary we inject has its dependencies.
RUN apt-get install libsystemd-journal0
RUN curl https://get.docker.com/ | sh RUN curl https://get.docker.com/ | sh
RUN apt-get remove --purge -y docker-engine RUN apt-get remove --purge -y docker-engine

@ -94,7 +94,6 @@ def remove_nonproto_fields(scenario):
def _ping_pong_scenario(name, rpc_type, def _ping_pong_scenario(name, rpc_type,
client_type, server_type, client_type, server_type,
secure=True, secure=True,
use_big_generic_payload=False,
use_generic_payload=False, use_generic_payload=False,
unconstrained_client=None, unconstrained_client=None,
client_language=None, client_language=None,
@ -129,12 +128,7 @@ def _ping_pong_scenario(name, rpc_type,
'warmup_seconds': warmup_seconds, 'warmup_seconds': warmup_seconds,
'benchmark_seconds': BENCHMARK_SECONDS 'benchmark_seconds': BENCHMARK_SECONDS
} }
if use_big_generic_payload: if use_generic_payload:
if server_type != 'ASYNC_GENERIC_SERVER':
raise Exception('Use ASYNC_GENERIC_SERVER for big generic payload.')
scenario['client_config']['payload_config'] = BIG_GENERIC_PAYLOAD
scenario['server_config']['payload_config'] = BIG_GENERIC_PAYLOAD
elif use_generic_payload:
if server_type != 'ASYNC_GENERIC_SERVER': if server_type != 'ASYNC_GENERIC_SERVER':
raise Exception('Use ASYNC_GENERIC_SERVER for generic payload.') raise Exception('Use ASYNC_GENERIC_SERVER for generic payload.')
scenario['client_config']['payload_config'] = EMPTY_GENERIC_PAYLOAD scenario['client_config']['payload_config'] = EMPTY_GENERIC_PAYLOAD
@ -147,23 +141,13 @@ def _ping_pong_scenario(name, rpc_type,
if unconstrained_client == 'async': if unconstrained_client == 'async':
deep = DEEP deep = DEEP
wide = WIDE wide = WIDE
num_clients = 0 # use as many clients as available
elif unconstrained_client == 'sync': elif unconstrained_client == 'sync':
deep = SYNC_DEEP deep = SYNC_DEEP
wide = SYNC_WIDE wide = SYNC_WIDE
num_clients = 0 # use as many clients as available
elif unconstrained_client == '1chan_bw':
deep = DEEP
wide = 1
num_clients = 1 # limit to 1 for a single channel
elif unconstrained_client == 'Nchan_bw':
deep = DEEP
wide = WIDE
num_clients = 0 # use as many clients as available
else: else:
raise Exception('Illegal value of unconstrained_client option.') raise Exception('Illegal value of unconstrained_client option.')
scenario['num_clients'] = num_clients scenario['num_clients'] = 0 # use as many client as available.
scenario['client_config']['outstanding_rpcs_per_channel'] = deep scenario['client_config']['outstanding_rpcs_per_channel'] = deep
scenario['client_config']['client_channels'] = wide scenario['client_config']['client_channels'] = wide
scenario['client_config']['async_client_threads'] = 0 scenario['client_config']['async_client_threads'] = 0
@ -254,19 +238,6 @@ class CXXLanguage:
server_core_limit=1, async_server_threads=1, server_core_limit=1, async_server_threads=1,
secure=secure) secure=secure)
yield _ping_pong_scenario(
'cpp_generic_async_streaming_single_channel_throughput_%s' % secstr, rpc_type='STREAMING',
client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
unconstrained_client='1chan_bw', use_big_generic_payload=True,
secure=secure,
categories=smoketest_categories)
yield _ping_pong_scenario(
'cpp_generic_async_streaming_multi_channel_throughput_%s' % secstr, rpc_type='STREAMING',
client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
unconstrained_client='Nchan_bw', use_big_generic_payload=True,
secure=secure)
def __str__(self): def __str__(self):
return 'c++' return 'c++'

@ -1829,44 +1829,6 @@
"third_party": false, "third_party": false,
"type": "target" "type": "target"
}, },
{
"deps": [
"gpr",
"gpr_test_util",
"grpc",
"grpc++",
"grpc++_test_util",
"grpc_test_util",
"qps"
],
"headers": [],
"language": "c++",
"name": "async_streaming_ping_pong_test",
"src": [
"test/cpp/qps/async_streaming_ping_pong_test.cc"
],
"third_party": false,
"type": "target"
},
{
"deps": [
"gpr",
"gpr_test_util",
"grpc",
"grpc++",
"grpc++_test_util",
"grpc_test_util",
"qps"
],
"headers": [],
"language": "c++",
"name": "async_unary_ping_pong_test",
"src": [
"test/cpp/qps/async_unary_ping_pong_test.cc"
],
"third_party": false,
"type": "target"
},
{ {
"deps": [ "deps": [
"gpr", "gpr",
@ -2106,25 +2068,6 @@
"third_party": false, "third_party": false,
"type": "target" "type": "target"
}, },
{
"deps": [
"gpr",
"gpr_test_util",
"grpc",
"grpc++",
"grpc++_test_util",
"grpc_test_util",
"qps"
],
"headers": [],
"language": "c++",
"name": "generic_async_streaming_ping_pong_test",
"src": [
"test/cpp/qps/generic_async_streaming_ping_pong_test.cc"
],
"third_party": false,
"type": "target"
},
{ {
"deps": [ "deps": [
"gpr", "gpr",
@ -2470,26 +2413,6 @@
"third_party": false, "third_party": false,
"type": "target" "type": "target"
}, },
{
"deps": [
"gpr",
"gpr_test_util",
"grpc",
"grpc++",
"grpc++_test_config",
"grpc++_test_util",
"grpc_test_util",
"qps"
],
"headers": [],
"language": "c++",
"name": "qps_test",
"src": [
"test/cpp/qps/qps_test.cc"
],
"third_party": false,
"type": "target"
},
{ {
"deps": [ "deps": [
"gpr", "gpr",
@ -2752,44 +2675,6 @@
"third_party": false, "third_party": false,
"type": "target" "type": "target"
}, },
{
"deps": [
"gpr",
"gpr_test_util",
"grpc",
"grpc++",
"grpc++_test_util",
"grpc_test_util",
"qps"
],
"headers": [],
"language": "c++",
"name": "sync_streaming_ping_pong_test",
"src": [
"test/cpp/qps/sync_streaming_ping_pong_test.cc"
],
"third_party": false,
"type": "target"
},
{
"deps": [
"gpr",
"gpr_test_util",
"grpc",
"grpc++",
"grpc++_test_util",
"grpc_test_util",
"qps"
],
"headers": [],
"language": "c++",
"name": "sync_unary_ping_pong_test",
"src": [
"test/cpp/qps/sync_unary_ping_pong_test.cc"
],
"third_party": false,
"type": "target"
},
{ {
"deps": [ "deps": [
"gpr", "gpr",

@ -1939,44 +1939,6 @@
"windows" "windows"
] ]
}, },
{
"args": [],
"ci_platforms": [
"linux",
"mac",
"posix"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"flaky": false,
"gtest": false,
"language": "c++",
"name": "async_streaming_ping_pong_test",
"platforms": [
"linux",
"mac",
"posix"
]
},
{
"args": [],
"ci_platforms": [
"linux",
"mac",
"posix"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"flaky": false,
"gtest": false,
"language": "c++",
"name": "async_unary_ping_pong_test",
"platforms": [
"linux",
"mac",
"posix"
]
},
{ {
"args": [], "args": [],
"ci_platforms": [ "ci_platforms": [
@ -2227,25 +2189,6 @@
"windows" "windows"
] ]
}, },
{
"args": [],
"ci_platforms": [
"linux",
"mac",
"posix"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"flaky": false,
"gtest": false,
"language": "c++",
"name": "generic_async_streaming_ping_pong_test",
"platforms": [
"linux",
"mac",
"posix"
]
},
{ {
"args": [], "args": [],
"ci_platforms": [ "ci_platforms": [
@ -2389,25 +2332,6 @@
"posix" "posix"
] ]
}, },
{
"args": [],
"ci_platforms": [
"linux",
"mac",
"posix"
],
"cpu_cost": 10,
"exclude_configs": [],
"flaky": false,
"gtest": false,
"language": "c++",
"name": "qps_test",
"platforms": [
"linux",
"mac",
"posix"
]
},
{ {
"args": [], "args": [],
"ci_platforms": [ "ci_platforms": [
@ -2549,44 +2473,6 @@
"posix" "posix"
] ]
}, },
{
"args": [],
"ci_platforms": [
"linux",
"mac",
"posix"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"flaky": false,
"gtest": false,
"language": "c++",
"name": "sync_streaming_ping_pong_test",
"platforms": [
"linux",
"mac",
"posix"
]
},
{
"args": [],
"ci_platforms": [
"linux",
"mac",
"posix"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"flaky": false,
"gtest": false,
"language": "c++",
"name": "sync_unary_ping_pong_test",
"platforms": [
"linux",
"mac",
"posix"
]
},
{ {
"args": [], "args": [],
"ci_platforms": [ "ci_platforms": [
@ -23022,7 +22908,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_ping_pong_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_generic_async_streaming_ping_pong_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23048,7 +22934,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_streaming_ping_pong_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_protobuf_async_streaming_ping_pong_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23074,7 +22960,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_unary_ping_pong_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_protobuf_async_unary_ping_pong_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23100,7 +22986,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_sync_unary_ping_pong_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"SYNC_SERVER\"}, \"client_config\": {\"client_type\": \"SYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_protobuf_sync_unary_ping_pong_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"SYNC_SERVER\"}, \"client_config\": {\"client_type\": \"SYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23126,7 +23012,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_unary_qps_unconstrained_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_protobuf_async_unary_qps_unconstrained_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23152,7 +23038,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_streaming_qps_unconstrained_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_protobuf_async_streaming_qps_unconstrained_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23178,7 +23064,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_qps_unconstrained_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_generic_async_streaming_qps_unconstrained_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23204,7 +23090,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_qps_one_server_core_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_generic_async_streaming_qps_one_server_core_secure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23230,59 +23116,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_single_channel_throughput_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"client_channels\": 1, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_generic_async_streaming_ping_pong_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
],
"boringssl": true,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1000.0,
"defaults": "boringssl",
"exclude_configs": [],
"flaky": false,
"language": "c++",
"name": "json_run_localhost",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"shortname": "json_run_localhost:cpp_generic_async_streaming_single_channel_throughput_secure"
},
{
"args": [
"--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_multi_channel_throughput_secure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": {\"use_test_ca\": true, \"server_host_override\": \"foo.test.google.fr\"}, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
],
"boringssl": true,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1000.0,
"defaults": "boringssl",
"exclude_configs": [],
"flaky": false,
"language": "c++",
"name": "json_run_localhost",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"shortname": "json_run_localhost:cpp_generic_async_streaming_multi_channel_throughput_secure"
},
{
"args": [
"--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_ping_pong_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23308,7 +23142,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_streaming_ping_pong_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_protobuf_async_streaming_ping_pong_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23334,7 +23168,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_unary_ping_pong_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_protobuf_async_unary_ping_pong_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23360,7 +23194,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_sync_unary_ping_pong_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"server_type\": \"SYNC_SERVER\"}, \"client_config\": {\"client_type\": \"SYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'" "'{\"name\": \"cpp_protobuf_sync_unary_ping_pong_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"server_type\": \"SYNC_SERVER\"}, \"client_config\": {\"client_type\": \"SYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 1, \"async_client_threads\": 1, \"outstanding_rpcs_per_channel\": 1, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23386,7 +23220,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_unary_qps_unconstrained_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_protobuf_async_unary_qps_unconstrained_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"UNARY\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23412,7 +23246,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_protobuf_async_streaming_qps_unconstrained_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_protobuf_async_streaming_qps_unconstrained_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"server_type\": \"ASYNC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"simple_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23438,7 +23272,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_qps_unconstrained_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_generic_async_streaming_qps_unconstrained_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23464,7 +23298,7 @@
{ {
"args": [ "args": [
"--scenario_json", "--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_qps_one_server_core_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'" "'{\"name\": \"cpp_generic_async_streaming_qps_one_server_core_insecure\", \"warmup_seconds\": 1, \"benchmark_seconds\": 1, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 1, \"core_limit\": 1, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 0, \"req_size\": 0}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
], ],
"boringssl": true, "boringssl": true,
"ci_platforms": [ "ci_platforms": [
@ -23487,58 +23321,6 @@
], ],
"shortname": "json_run_localhost:cpp_generic_async_streaming_qps_one_server_core_insecure" "shortname": "json_run_localhost:cpp_generic_async_streaming_qps_one_server_core_insecure"
}, },
{
"args": [
"--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_single_channel_throughput_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"client_channels\": 1, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 1}'"
],
"boringssl": true,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1000.0,
"defaults": "boringssl",
"exclude_configs": [],
"flaky": false,
"language": "c++",
"name": "json_run_localhost",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"shortname": "json_run_localhost:cpp_generic_async_streaming_single_channel_throughput_insecure"
},
{
"args": [
"--scenario_json",
"'{\"name\": \"cpp_generic_async_streaming_multi_channel_throughput_insecure\", \"warmup_seconds\": 5, \"benchmark_seconds\": 30, \"num_servers\": 1, \"server_config\": {\"async_server_threads\": 0, \"core_limit\": 0, \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"server_type\": \"ASYNC_GENERIC_SERVER\"}, \"client_config\": {\"client_type\": \"ASYNC_CLIENT\", \"security_params\": null, \"payload_config\": {\"bytebuf_params\": {\"resp_size\": 65536, \"req_size\": 65536}}, \"client_channels\": 64, \"async_client_threads\": 0, \"outstanding_rpcs_per_channel\": 100, \"rpc_type\": \"STREAMING\", \"load_params\": {\"closed_loop\": {}}, \"histogram_params\": {\"max_possible\": 60000000000.0, \"resolution\": 0.01}}, \"num_clients\": 0}'"
],
"boringssl": true,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1000.0,
"defaults": "boringssl",
"exclude_configs": [],
"flaky": false,
"language": "c++",
"name": "json_run_localhost",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"shortname": "json_run_localhost:cpp_generic_async_streaming_multi_channel_throughput_insecure"
},
{ {
"args": [ "args": [
"test/core/end2end/fuzzers/api_fuzzer_corpus/00.bin" "test/core/end2end/fuzzers/api_fuzzer_corpus/00.bin"

Loading…
Cancel
Save