Merge branch 'master' into gpr_assert_mm_tjagtap

pull/36657/head
tanvi-jagtap 6 months ago
commit d8a7f0262a
  1. 28
      test/cpp/interop/interop_server.cc
  2. 8
      test/cpp/interop/interop_test.cc
  3. 29
      test/cpp/interop/observability_client.cc
  4. 8
      test/cpp/interop/reconnect_interop_client.cc
  5. 57
      test/cpp/interop/stress_test.cc
  6. 20
      test/cpp/interop/xds_federation_client.cc
  7. 21
      test/cpp/interop/xds_interop_client.cc
  8. 3
      test/cpp/interop/xds_interop_server.cc
  9. 4
      test/cpp/microbenchmarks/bm_cq_multiple_threads.cc
  10. 5
      test/cpp/microbenchmarks/callback_streaming_ping_pong.h
  11. 3
      test/cpp/microbenchmarks/callback_test_service.cc
  12. 25
      test/cpp/qps/client.h
  13. 8
      test/cpp/qps/client_callback.cc
  14. 4
      test/cpp/qps/inproc_sync_unary_ping_pong_test.cc
  15. 22
      test/cpp/qps/qps_json_driver.cc
  16. 4
      test/cpp/qps/qps_openloop_test.cc
  17. 62
      test/cpp/qps/qps_worker.cc
  18. 4
      test/cpp/qps/secure_sync_unary_ping_pong_test.cc
  19. 5
      test/cpp/qps/usage_timer.cc
  20. 10
      test/cpp/server/load_reporter/load_reporter_test.cc
  21. 19
      test/cpp/server/server_request_call_test.cc
  22. 11
      tools/interop_matrix/client_matrix.py

@ -23,9 +23,9 @@
#include "absl/flags/flag.h"
#include "absl/log/check.h"
#include "absl/log/log.h"
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/time.h>
#include <grpcpp/ext/call_metric_recorder.h>
#include <grpcpp/ext/orca_service.h>
@ -119,22 +119,20 @@ bool CheckExpectedCompression(const ServerContext& context,
if (compression_expected) {
if (received_compression == GRPC_COMPRESS_NONE) {
// Expected some compression, got NONE. This is an error.
gpr_log(GPR_ERROR,
"Expected compression but got uncompressed request from client.");
LOG(ERROR)
<< "Expected compression but got uncompressed request from client.";
return false;
}
if (!(inspector.WasCompressed())) {
gpr_log(GPR_ERROR,
"Failure: Requested compression in a compressable request, but "
"compression bit in message flags not set.");
LOG(ERROR) << "Failure: Requested compression in a compressable request, "
"but compression bit in message flags not set.";
return false;
}
} else {
// Didn't expect compression -> make sure the request is uncompressed
if (inspector.WasCompressed()) {
gpr_log(GPR_ERROR,
"Failure: Didn't requested compression, but compression bit in "
"message flags set.");
LOG(ERROR) << "Failure: Didn't requested compression, but compression "
"bit in message flags set.";
return false;
}
}
@ -197,8 +195,9 @@ class TestServiceImpl : public TestService::Service {
MaybeEchoMetadata(context);
if (request->has_response_compressed()) {
const bool compression_requested = request->response_compressed().value();
gpr_log(GPR_DEBUG, "Request for compression (%s) present for %s",
compression_requested ? "enabled" : "disabled", __func__);
VLOG(2) << "Request for compression ("
<< (compression_requested ? "enabled" : "disabled")
<< ") present for " << __func__;
if (compression_requested) {
// Any level would do, let's go for HIGH because we are overachievers.
context->set_compression_level(GRPC_COMPRESS_LEVEL_HIGH);
@ -247,8 +246,9 @@ class TestServiceImpl : public TestService::Service {
context->set_compression_level(GRPC_COMPRESS_LEVEL_HIGH);
const bool compression_requested =
request->response_parameters(i).compressed().value();
gpr_log(GPR_DEBUG, "Request for compression (%s) present for %s",
compression_requested ? "enabled" : "disabled", __func__);
VLOG(2) << "Request for compression ("
<< (compression_requested ? "enabled" : "disabled")
<< ") present for " << __func__;
if (!compression_requested) {
wopts.set_no_compression();
} // else, compression is already enabled via the context.
@ -445,7 +445,7 @@ void grpc::testing::interop::RunServer(
grpc::ServerBuilder::experimental_type(&builder).EnableCallMetricRecording(
nullptr);
std::unique_ptr<Server> server(builder.BuildAndStart());
gpr_log(GPR_INFO, "Server listening on %s", server_address.str().c_str());
LOG(INFO) << "Server listening on " << server_address.str();
// Signal that the server has started.
if (server_started_condition) {

@ -29,10 +29,10 @@
#include <vector>
#include "absl/flags/flag.h"
#include "absl/log/log.h"
#include "absl/strings/str_cat.h"
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include "src/core/lib/gprpp/crash.h"
#include "src/core/lib/iomgr/socket_utils_posix.h"
@ -65,7 +65,7 @@ int test_client(const char* root, const char* host, int port) {
return 1;
}
// wait for client
gpr_log(GPR_INFO, "Waiting for client: %s", host);
LOG(INFO) << "Waiting for client: " << host;
if (waitpid(cli, &status, 0) == -1) return 2;
if (!WIFEXITED(status)) return 4;
if (WEXITSTATUS(status)) return WEXITSTATUS(status);
@ -86,7 +86,7 @@ int main(int argc, char** argv) {
// concurrently running test binary
srand(getpid());
if (!grpc_ipv6_loopback_available()) {
gpr_log(GPR_INFO, "Can't bind to ::1. Skipping IPv6 tests.");
LOG(INFO) << "Can't bind to ::1. Skipping IPv6 tests.";
do_ipv6 = 0;
}
// figure out where we are
@ -126,7 +126,7 @@ int main(int argc, char** argv) {
if (ret != 0) return ret;
}
// wait for server
gpr_log(GPR_INFO, "Waiting for server");
LOG(INFO) << "Waiting for server";
kill(svr, SIGINT);
if (waitpid(svr, &status, 0) == -1) return 2;
if (!WIFEXITED(status)) return 4;

@ -20,13 +20,13 @@
#include <unordered_map>
#include "absl/flags/flag.h"
#include "absl/log/log.h"
#include "opentelemetry/exporters/prometheus/exporter_factory.h"
#include "opentelemetry/exporters/prometheus/exporter_options.h"
#include "opentelemetry/sdk/metrics/meter_provider.h"
#include <grpc/grpc.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpcpp/channel.h>
#include <grpcpp/client_context.h>
#include <grpcpp/ext/gcp_observability.h>
@ -160,8 +160,8 @@ bool ParseAdditionalMetadataFlag(
while (start_pos < flag.length()) {
size_t colon_pos = flag.find(':', start_pos);
if (colon_pos == std::string::npos) {
gpr_log(GPR_ERROR,
"Couldn't parse metadata flag: extra characters at end of flag");
LOG(ERROR)
<< "Couldn't parse metadata flag: extra characters at end of flag";
return false;
}
size_t semicolon_pos = flag.find(';', colon_pos);
@ -175,10 +175,9 @@ bool ParseAdditionalMetadataFlag(
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (key.find_first_not_of(alphanum_and_hyphen) != std::string::npos) {
gpr_log(GPR_ERROR,
"Couldn't parse metadata flag: key contains characters other "
"than alphanumeric and hyphens: %s",
key.c_str());
LOG(ERROR) << "Couldn't parse metadata flag: key contains characters "
"other than alphanumeric and hyphens: "
<< key;
return false;
}
@ -189,8 +188,8 @@ bool ParseAdditionalMetadataFlag(
}
}
gpr_log(GPR_INFO, "Adding additional metadata with key %s and value %s",
key.c_str(), value.c_str());
LOG(INFO) << "Adding additional metadata with key " << key << " and value "
<< value;
additional_metadata->insert({key, value});
if (semicolon_pos == std::string::npos) {
@ -208,15 +207,14 @@ bool ParseAdditionalMetadataFlag(
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
grpc::testing::InitTest(&argc, &argv, true);
gpr_log(GPR_INFO, "Testing these cases: %s",
absl::GetFlag(FLAGS_test_case).c_str());
LOG(INFO) << "Testing these cases: " << absl::GetFlag(FLAGS_test_case);
int ret = 0;
if (absl::GetFlag(FLAGS_enable_observability)) {
// TODO(someone): remove deprecated usage
// NOLINTNEXTLINE(clang-diagnostic-deprecated-declarations)
auto status = grpc::experimental::GcpObservabilityInit();
gpr_log(GPR_DEBUG, "GcpObservabilityInit() status_code: %d", status.code());
VLOG(2) << "GcpObservabilityInit() status_code: " << status.code();
if (!status.ok()) {
return 1;
}
@ -225,7 +223,7 @@ int main(int argc, char** argv) {
// TODO(stanleycheung): switch to CsmObservabilityBuilder once xds setup is
// ready
if (absl::GetFlag(FLAGS_enable_otel_plugin)) {
gpr_log(GPR_DEBUG, "Registering Prometheus exporter");
VLOG(2) << "Registering Prometheus exporter";
opentelemetry::exporter::metrics::PrometheusExporterOptions opts;
// default was "localhost:9464" which causes connection issue across GKE
// pods
@ -389,8 +387,9 @@ int main(int argc, char** argv) {
if (!test_cases.empty()) test_cases += "\n";
test_cases += action.first;
}
gpr_log(GPR_ERROR, "Unsupported test case %s. Valid options are\n%s",
absl::GetFlag(FLAGS_test_case).c_str(), test_cases.c_str());
LOG(ERROR) << "Unsupported test case " << absl::GetFlag(FLAGS_test_case)
<< ". Valid options are\n"
<< test_cases;
ret = 1;
}

@ -21,9 +21,9 @@
#include "absl/flags/flag.h"
#include "absl/log/check.h"
#include "absl/log/log.h"
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpcpp/channel.h>
#include <grpcpp/client_context.h>
#include <grpcpp/support/channel_arguments.h>
@ -76,7 +76,7 @@ int main(int argc, char** argv) {
control_stub->Start(&start_context, reconnect_params, &empty_response);
CHECK(start_status.ok());
gpr_log(GPR_INFO, "Starting connections with retries.");
LOG(INFO) << "Starting connections with retries.";
server_address.str("");
server_address << absl::GetFlag(FLAGS_server_host) << ':'
<< absl::GetFlag(FLAGS_server_retry_port);
@ -100,13 +100,13 @@ int main(int argc, char** argv) {
Status retry_status =
retry_stub->Start(&retry_context, reconnect_params, &empty_response);
CHECK(retry_status.error_code() == grpc::StatusCode::DEADLINE_EXCEEDED);
gpr_log(GPR_INFO, "Done retrying, getting final data from server");
LOG(INFO) << "Done retrying, getting final data from server";
ClientContext stop_context;
ReconnectInfo response;
Status stop_status = control_stub->Stop(&stop_context, Empty(), &response);
CHECK(stop_status.ok());
CHECK(response.passed() == true);
gpr_log(GPR_INFO, "Passed");
LOG(INFO) << "Passed";
return 0;
}

@ -24,8 +24,8 @@
#include "absl/flags/flag.h"
#include "absl/log/check.h"
#include "absl/log/log.h"
#include <grpc/support/log.h>
#include <grpc/support/time.h>
#include <grpcpp/create_channel.h>
#include <grpcpp/grpcpp.h>
@ -176,7 +176,7 @@ bool ParseTestCasesString(const std::string& test_cases,
// Token is in the form <test_name>:<test_weight>
size_t colon_pos = it->find(':');
if (colon_pos == std::string::npos) {
gpr_log(GPR_ERROR, "Error in parsing test case string: %s", it->c_str());
LOG(ERROR) << "Error in parsing test case string: " << it->c_str();
is_success = false;
break;
}
@ -185,7 +185,7 @@ bool ParseTestCasesString(const std::string& test_cases,
int weight = std::stoi(it->substr(colon_pos + 1));
TestCaseType test_case = GetTestTypeFromName(test_name);
if (test_case == UNKNOWN_TEST) {
gpr_log(GPR_ERROR, "Unknown test case: %s", test_name.c_str());
LOG(ERROR) << "Unknown test case: " << test_name;
is_success = false;
break;
}
@ -199,33 +199,32 @@ bool ParseTestCasesString(const std::string& test_cases,
// For debugging purposes
void LogParameterInfo(const std::vector<std::string>& addresses,
const std::vector<std::pair<TestCaseType, int>>& tests) {
gpr_log(GPR_INFO, "server_addresses: %s",
absl::GetFlag(FLAGS_server_addresses).c_str());
gpr_log(GPR_INFO, "test_cases : %s", absl::GetFlag(FLAGS_test_cases).c_str());
gpr_log(GPR_INFO, "sleep_duration_ms: %d",
absl::GetFlag(FLAGS_sleep_duration_ms));
gpr_log(GPR_INFO, "test_duration_secs: %d",
absl::GetFlag(FLAGS_test_duration_secs));
gpr_log(GPR_INFO, "num_channels_per_server: %d",
absl::GetFlag(FLAGS_num_channels_per_server));
gpr_log(GPR_INFO, "num_stubs_per_channel: %d",
absl::GetFlag(FLAGS_num_stubs_per_channel));
gpr_log(GPR_INFO, "log_level: %d", absl::GetFlag(FLAGS_log_level));
gpr_log(GPR_INFO, "do_not_abort_on_transient_failures: %s",
absl::GetFlag(FLAGS_do_not_abort_on_transient_failures) ? "true"
: "false");
LOG(INFO) << "server_addresses: " << absl::GetFlag(FLAGS_server_addresses);
LOG(INFO) << "test_cases : " << absl::GetFlag(FLAGS_test_cases);
LOG(INFO) << "sleep_duration_ms: " << absl::GetFlag(FLAGS_sleep_duration_ms);
LOG(INFO) << "test_duration_secs: "
<< absl::GetFlag(FLAGS_test_duration_secs);
LOG(INFO) << "num_channels_per_server: "
<< absl::GetFlag(FLAGS_num_channels_per_server);
LOG(INFO) << "num_stubs_per_channel: "
<< absl::GetFlag(FLAGS_num_stubs_per_channel);
LOG(INFO) << "log_level: " << absl::GetFlag(FLAGS_log_level);
LOG(INFO) << "do_not_abort_on_transient_failures: "
<< (absl::GetFlag(FLAGS_do_not_abort_on_transient_failures)
? "true"
: "false");
int num = 0;
for (auto it = addresses.begin(); it != addresses.end(); it++) {
gpr_log(GPR_INFO, "%d:%s", ++num, it->c_str());
LOG(INFO) << ++num << ":" << it->c_str();
}
num = 0;
for (auto it = tests.begin(); it != tests.end(); it++) {
TestCaseType test_case = it->first;
int weight = it->second;
gpr_log(GPR_INFO, "%d. TestCaseType: %d, Weight: %d", ++num, test_case,
weight);
LOG(INFO) << ++num << ". TestCaseType: " << test_case
<< ", Weight: " << weight;
}
}
@ -234,8 +233,8 @@ int main(int argc, char** argv) {
if (absl::GetFlag(FLAGS_log_level) > GPR_LOG_SEVERITY_ERROR ||
absl::GetFlag(FLAGS_log_level) < GPR_LOG_SEVERITY_DEBUG) {
gpr_log(GPR_ERROR, "log_level should be an integer between %d and %d",
GPR_LOG_SEVERITY_DEBUG, GPR_LOG_SEVERITY_ERROR);
LOG(ERROR) << "log_level should be an integer between "
<< GPR_LOG_SEVERITY_DEBUG << " and " << GPR_LOG_SEVERITY_ERROR;
return 1;
}
@ -253,14 +252,14 @@ int main(int argc, char** argv) {
// Parse test cases and weights
if (absl::GetFlag(FLAGS_test_cases).length() == 0) {
gpr_log(GPR_ERROR, "No test cases supplied");
LOG(ERROR) << "No test cases supplied";
return 1;
}
std::vector<std::pair<TestCaseType, int>> tests;
if (!ParseTestCasesString(absl::GetFlag(FLAGS_test_cases), tests)) {
gpr_log(GPR_ERROR, "Error in parsing test cases string %s ",
absl::GetFlag(FLAGS_test_cases).c_str());
LOG(ERROR) << "Error in parsing test cases string "
<< absl::GetFlag(FLAGS_test_cases);
return 1;
}
@ -269,7 +268,7 @@ int main(int argc, char** argv) {
WeightedRandomTestSelector test_selector(tests);
MetricsServiceImpl metrics_service;
gpr_log(GPR_INFO, "Starting test(s)..");
LOG(INFO) << "Starting test(s)..";
std::vector<std::thread> test_threads;
std::vector<std::unique_ptr<StressTestInteropClient>> clients;
@ -295,8 +294,8 @@ int main(int argc, char** argv) {
for (int channel_idx = 0;
channel_idx < absl::GetFlag(FLAGS_num_channels_per_server);
channel_idx++) {
gpr_log(GPR_INFO, "Starting test with %s channel_idx=%d..", it->c_str(),
channel_idx);
LOG(INFO) << "Starting test with " << it->c_str()
<< " channel_idx=" << channel_idx << "..";
grpc::testing::ChannelCreationFunc channel_creation_func =
std::bind(static_cast<std::shared_ptr<grpc::Channel> (*)(
const std::string&, const std::string&,

@ -21,11 +21,11 @@
#include "absl/flags/flag.h"
#include "absl/log/check.h"
#include "absl/log/log.h"
#include "absl/strings/str_split.h"
#include <grpc/grpc.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include "src/core/util/string.h"
#include "test/core/test_util/test_config.h"
@ -74,8 +74,7 @@ ABSL_FLAG(std::string, test_case, "rpc_soak",
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
grpc::testing::InitTest(&argc, &argv, true);
gpr_log(GPR_INFO, "Testing these cases: %s",
absl::GetFlag(FLAGS_test_case).c_str());
LOG(INFO) << "Testing these cases: " << absl::GetFlag(FLAGS_test_case);
std::string test_case = absl::GetFlag(FLAGS_test_case);
// validate flags
std::vector<std::string> uris =
@ -83,14 +82,13 @@ int main(int argc, char** argv) {
std::vector<std::string> creds =
absl::StrSplit(absl::GetFlag(FLAGS_credentials_types), ',');
if (uris.size() != creds.size()) {
gpr_log(GPR_ERROR,
"Number of entries in --server_uris %ld != number of entries in "
"--credentials_types %ld",
uris.size(), creds.size());
LOG(ERROR) << "Number of entries in --server_uris " << uris.size()
<< " != number of entries in --credentials_types "
<< creds.size();
CHECK(0);
}
if (uris.empty()) {
gpr_log(GPR_ERROR, "--server_uris has zero entries");
LOG(ERROR) << "--server_uris has zero entries";
CHECK(0);
}
// construct and start clients
@ -121,8 +119,8 @@ int main(int argc, char** argv) {
absl::GetFlag(FLAGS_soak_request_size),
absl::GetFlag(FLAGS_soak_response_size));
} else {
gpr_log(GPR_ERROR,
"Invalid test case, must be either rpc_soak or channel_soak");
LOG(ERROR)
<< "Invalid test case, must be either rpc_soak or channel_soak";
CHECK(0);
}
}));
@ -130,6 +128,6 @@ int main(int argc, char** argv) {
for (auto& thd : threads) {
thd.join();
}
gpr_log(GPR_INFO, "All clients done!");
LOG(INFO) << "All clients done!";
return 0;
}

@ -33,6 +33,7 @@
#include "absl/algorithm/container.h"
#include "absl/flags/flag.h"
#include "absl/log/check.h"
#include "absl/log/log.h"
#include "absl/strings/str_split.h"
#include "opentelemetry/exporters/prometheus/exporter_factory.h"
#include "opentelemetry/exporters/prometheus/exporter_options.h"
@ -354,15 +355,11 @@ class XdsUpdateClientConfigureServiceImpl
}
if (request_payload_size > 0 &&
config.type == ClientConfigureRequest::EMPTY_CALL) {
gpr_log(GPR_ERROR,
"request_payload_size should not be set "
"for EMPTY_CALL");
LOG(ERROR) << "request_payload_size should not be set for EMPTY_CALL";
}
if (response_payload_size > 0 &&
config.type == ClientConfigureRequest::EMPTY_CALL) {
gpr_log(GPR_ERROR,
"response_payload_size should not be set "
"for EMPTY_CALL");
LOG(ERROR) << "response_payload_size should not be set for EMPTY_CALL";
}
config.request_payload_size = request_payload_size;
std::string payload(config.request_payload_size, '0');
@ -429,7 +426,7 @@ void RunTestLoop(std::chrono::duration<double> duration_per_query,
}
grpc::CsmObservability EnableCsmObservability() {
gpr_log(GPR_DEBUG, "Registering Prometheus exporter");
VLOG(2) << "Registering Prometheus exporter";
opentelemetry::exporter::metrics::PrometheusExporterOptions opts;
// default was "localhost:9464" which causes connection issue across GKE
// pods
@ -463,7 +460,7 @@ void RunServer(const int port, StatsWatchers* stats_watchers,
builder.AddListeningPort(server_address.str(),
grpc::InsecureServerCredentials());
std::unique_ptr<Server> server(builder.BuildAndStart());
gpr_log(GPR_DEBUG, "Server listening on %s", server_address.str().c_str());
VLOG(2) << "Server listening on " << server_address.str();
server->Wait();
}
@ -513,15 +510,11 @@ void BuildRpcConfigsFromFlags(RpcConfigurationsQueue* rpc_configs_queue) {
}
if (request_payload_size > 0 &&
config.type == ClientConfigureRequest::EMPTY_CALL) {
gpr_log(GPR_ERROR,
"request_payload_size should not be set "
"for EMPTY_CALL");
LOG(ERROR) << "request_payload_size should not be set for EMPTY_CALL";
}
if (response_payload_size > 0 &&
config.type == ClientConfigureRequest::EMPTY_CALL) {
gpr_log(GPR_ERROR,
"response_payload_size should not be set "
"for EMPTY_CALL");
LOG(ERROR) << "response_payload_size should not be set for EMPTY_CALL";
}
config.request_payload_size = request_payload_size;
std::string payload(config.request_payload_size, '0');

@ -19,6 +19,7 @@
#include <iostream>
#include "absl/flags/flag.h"
#include "absl/log/log.h"
#include "opentelemetry/exporters/prometheus/exporter_factory.h"
#include "opentelemetry/exporters/prometheus/exporter_options.h"
#include "opentelemetry/sdk/metrics/meter_provider.h"
@ -44,7 +45,7 @@ ABSL_FLAG(bool, enable_csm_observability, false,
"Whether to enable CSM Observability");
grpc::CsmObservability EnableCsmObservability() {
gpr_log(GPR_DEBUG, "Registering Prometheus exporter");
VLOG(2) << "Registering Prometheus exporter";
opentelemetry::exporter::metrics::PrometheusExporterOptions opts;
// default was "localhost:9464" which causes connection issue across GKE
// pods

@ -23,10 +23,10 @@
#include <benchmark/benchmark.h>
#include "absl/log/check.h"
#include "absl/log/log.h"
#include <grpc/grpc.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include "src/core/lib/gprpp/crash.h"
#include "src/core/lib/gprpp/time.h"
@ -77,7 +77,7 @@ static grpc_error_handle pollset_work(grpc_pollset* ps,
grpc_pollset_worker** /*worker*/,
grpc_core::Timestamp deadline) {
if (deadline == grpc_core::Timestamp::ProcessEpoch()) {
gpr_log(GPR_DEBUG, "no-op");
VLOG(2) << "no-op";
return absl::OkStatus();
}

@ -24,6 +24,7 @@
#include <benchmark/benchmark.h>
#include "absl/log/check.h"
#include "absl/log/log.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/cpp/microbenchmarks/callback_test_service.h"
@ -54,7 +55,7 @@ class BidiClient : public grpc::ClientBidiReactor<EchoRequest, EchoResponse> {
void OnReadDone(bool ok) override {
if (!ok) {
gpr_log(GPR_ERROR, "Client read failed");
LOG(ERROR) << "Client read failed";
return;
}
MaybeWrite();
@ -62,7 +63,7 @@ class BidiClient : public grpc::ClientBidiReactor<EchoRequest, EchoResponse> {
void OnWriteDone(bool ok) override {
if (!ok) {
gpr_log(GPR_ERROR, "Client write failed");
LOG(ERROR) << "Client write failed";
return;
}
writes_complete_++;

@ -19,6 +19,7 @@
#include "test/cpp/microbenchmarks/callback_test_service.h"
#include "absl/log/check.h"
#include "absl/log/log.h"
namespace grpc {
namespace testing {
@ -93,7 +94,7 @@ CallbackStreamingTestService::BidiStream(CallbackServerContext* context) {
}
void OnWriteDone(bool ok) override {
if (!ok) {
gpr_log(GPR_ERROR, "Server write failed");
LOG(ERROR) << "Server write failed";
return;
}
StartRead(&request_);

@ -29,11 +29,11 @@
#include <unordered_map>
#include <vector>
#include "absl/log/log.h"
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
#include <grpc/support/log.h>
#include <grpc/support/time.h>
#include <grpcpp/channel.h>
#include <grpcpp/support/byte_buffer.h>
@ -203,10 +203,10 @@ class Client {
if (median_latency_collection_interval_seconds_ > 0) {
std::vector<double> medians_per_interval =
threads_[0]->GetMedianPerIntervalList();
gpr_log(GPR_INFO, "Num threads: %zu", threads_.size());
gpr_log(GPR_INFO, "Number of medians: %zu", medians_per_interval.size());
LOG(INFO) << "Num threads: " << threads_.size();
LOG(INFO) << "Number of medians: " << medians_per_interval.size();
for (size_t j = 0; j < medians_per_interval.size(); j++) {
gpr_log(GPR_INFO, "%f", medians_per_interval[j]);
LOG(INFO) << medians_per_interval[j];
}
}
@ -318,8 +318,8 @@ class Client {
&client_->start_requests_,
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_seconds(20, GPR_TIMESPAN)))) {
gpr_log(GPR_INFO, "%" PRIdPTR ": Waiting for benchmark to start (%d)",
idx_, wait_loop);
LOG(INFO) << idx_ << ": Waiting for benchmark to start (" << wait_loop
<< ")";
wait_loop++;
}
@ -463,9 +463,8 @@ class ClientImpl : public Client {
!channel_connect_timeout_str->empty()) {
connect_deadline_seconds = atoi(channel_connect_timeout_str->c_str());
}
gpr_log(GPR_INFO,
"Waiting for up to %d seconds for all channels to connect",
connect_deadline_seconds);
LOG(INFO) << "Waiting for up to " << connect_deadline_seconds
<< " seconds for all channels to connect";
gpr_timespec connect_deadline = gpr_time_add(
gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_seconds(connect_deadline_seconds, GPR_TIMESPAN));
@ -476,7 +475,7 @@ class ClientImpl : public Client {
Channel* channel = c.get_channel();
grpc_connectivity_state last_observed = channel->GetState(true);
if (last_observed == GRPC_CHANNEL_READY) {
gpr_log(GPR_INFO, "Channel %p connected!", channel);
LOG(INFO) << "Channel " << channel << " connected!";
} else {
num_remaining++;
channel->NotifyOnStateChange(last_observed, connect_deadline, &cq,
@ -495,7 +494,7 @@ class ClientImpl : public Client {
} else {
grpc_connectivity_state last_observed = channel->GetState(true);
if (last_observed == GRPC_CHANNEL_READY) {
gpr_log(GPR_INFO, "Channel %p connected!", channel);
LOG(INFO) << "Channel " << channel << " connected!";
num_remaining--;
} else {
channel->NotifyOnStateChange(last_observed, connect_deadline, &cq,
@ -534,7 +533,7 @@ class ClientImpl : public Client {
target, type, config.security_params().server_host_override(),
!config.security_params().use_test_ca(),
std::shared_ptr<CallCredentials>(), args);
gpr_log(GPR_INFO, "Connecting to %s", target.c_str());
LOG(INFO) << "Connecting to " << target;
is_inproc_ = false;
} else {
std::string tgt = target;
@ -557,7 +556,7 @@ class ClientImpl : public Client {
} else if (channel_arg.value_case() == ChannelArg::kIntValue) {
args->SetInt(channel_arg.name(), channel_arg.int_value());
} else {
gpr_log(GPR_ERROR, "Empty channel arg value.");
LOG(ERROR) << "Empty channel arg value.";
}
}
}

@ -25,11 +25,11 @@
#include <utility>
#include <vector>
#include "absl/log/log.h"
#include "absl/memory/memory.h"
#include <grpc/grpc.h>
#include <grpc/support/cpu.h>
#include <grpc/support/log.h>
#include <grpcpp/alarm.h>
#include <grpcpp/channel.h>
#include <grpcpp/client_context.h>
@ -126,7 +126,7 @@ class CallbackClient
int num_threads = config.async_client_threads();
if (num_threads <= 0) { // Use dynamic sizing
num_threads = cores_;
gpr_log(GPR_INFO, "Sizing callback client to %d threads", num_threads);
LOG(INFO) << "Sizing callback client to " << num_threads << " threads";
}
return num_threads;
}
@ -268,7 +268,7 @@ class CallbackStreamingPingPongReactor final
void OnWriteDone(bool ok) override {
if (!ok) {
gpr_log(GPR_ERROR, "Error writing RPC");
LOG(ERROR) << "Error writing RPC";
}
if ((!ok || client_->ThreadCompleted()) &&
!writes_done_started_.test_and_set()) {
@ -284,7 +284,7 @@ class CallbackStreamingPingPongReactor final
(client_->messages_per_stream() != 0 &&
++messages_issued_ >= client_->messages_per_stream())) {
if (!ok) {
gpr_log(GPR_ERROR, "Error reading RPC");
LOG(ERROR) << "Error reading RPC";
}
if (!writes_done_started_.test_and_set()) {
StartWritesDone();

@ -18,7 +18,7 @@
#include <set>
#include <grpc/support/log.h>
#include "absl/log/log.h"
#include "src/core/lib/gprpp/crash.h"
#include "test/core/test_util/test_config.h"
@ -36,7 +36,7 @@ static const int WARMUP = 1;
static const int BENCHMARK = 3;
static void RunSynchronousUnaryPingPong() {
gpr_log(GPR_INFO, "Running Synchronous Unary Ping Pong");
LOG(INFO) << "Running Synchronous Unary Ping Pong";
ClientConfig client_config;
client_config.set_client_type(SYNC_CLIENT);

@ -23,8 +23,8 @@
#include "absl/flags/flag.h"
#include "absl/log/check.h"
#include "absl/log/log.h"
#include <grpc/support/log.h>
#include <grpcpp/impl/codegen/config_protobuf.h>
#include "src/core/lib/gprpp/crash.h"
@ -104,10 +104,8 @@ ConstructPerWorkerCredentialTypesMap() {
}
size_t comma = next_entry.find(',');
if (comma == std::string::npos) {
gpr_log(GPR_ERROR,
"Expectd --per_worker_credential_types to be a list "
"of the form: 'addr1,cred_type1;addr2,cred_type2;...' "
"into.");
LOG(ERROR) << "Expectd --per_worker_credential_types to be a list of the "
"form: 'addr1,cred_type1;addr2,cred_type2;...' into.";
abort();
}
std::string addr = next_entry.substr(0, comma);
@ -185,9 +183,9 @@ static double BinarySearch(
double mid = low + (high - low) / 2;
double current_cpu_load =
GetCpuLoad(scenario, mid, per_worker_credential_types, success);
gpr_log(GPR_DEBUG, "Binary Search: current_offered_load %.0f", mid);
VLOG(2) << absl::StrFormat("Binary Search: current_offered_load %.0f", mid);
if (!*success) {
gpr_log(GPR_ERROR, "Client/Server Failure");
LOG(ERROR) << "Client/Server Failure";
break;
}
if (targeted_cpu_load <= current_cpu_load) {
@ -209,7 +207,7 @@ static double SearchOfferedLoad(
double current_cpu_load = GetCpuLoad(scenario, current_offered_load,
per_worker_credential_types, success);
if (current_cpu_load > targeted_cpu_load) {
gpr_log(GPR_ERROR, "Initial offered load too high");
LOG(ERROR) << "Initial offered load too high";
return -1;
}
@ -217,8 +215,8 @@ static double SearchOfferedLoad(
current_offered_load *= 2;
current_cpu_load = GetCpuLoad(scenario, current_offered_load,
per_worker_credential_types, success);
gpr_log(GPR_DEBUG, "Binary Search: current_offered_load %.0f",
current_offered_load);
VLOG(2) << absl::StrFormat("Binary Search: current_offered_load %.0f",
current_offered_load);
}
double targeted_offered_load =
@ -280,11 +278,11 @@ static bool QpsDriver() {
SearchOfferedLoad(absl::GetFlag(FLAGS_initial_search_value),
absl::GetFlag(FLAGS_targeted_cpu_load), scenario,
per_worker_credential_types, &success);
gpr_log(GPR_INFO, "targeted_offered_load %f", targeted_offered_load);
LOG(INFO) << "targeted_offered_load " << targeted_offered_load;
GetCpuLoad(scenario, targeted_offered_load, per_worker_credential_types,
&success);
} else {
gpr_log(GPR_ERROR, "Unimplemented search param");
LOG(ERROR) << "Unimplemented search param";
}
}
}

@ -18,7 +18,7 @@
#include <set>
#include <grpc/support/log.h>
#include "absl/log/log.h"
#include "src/core/lib/gprpp/crash.h"
#include "test/core/test_util/test_config.h"
@ -36,7 +36,7 @@ static const int WARMUP = 1;
static const int BENCHMARK = 3;
static void RunQPS() {
gpr_log(GPR_INFO, "Running QPS test, open-loop");
LOG(INFO) << "Running QPS test, open-loop";
ClientConfig client_config;
client_config.set_client_type(ASYNC_CLIENT);

@ -26,12 +26,12 @@
#include <vector>
#include "absl/log/check.h"
#include "absl/log/log.h"
#include "absl/memory/memory.h"
#include <grpc/grpc.h>
#include <grpc/support/alloc.h>
#include <grpc/support/cpu.h>
#include <grpc/support/log.h>
#include <grpcpp/client_context.h>
#include <grpcpp/security/server_credentials.h>
#include <grpcpp/server.h>
@ -52,10 +52,10 @@ namespace grpc {
namespace testing {
static std::unique_ptr<Client> CreateClient(const ClientConfig& config) {
gpr_log(GPR_INFO, "Starting client of type %s %s %d",
ClientType_Name(config.client_type()).c_str(),
RpcType_Name(config.rpc_type()).c_str(),
config.payload_config().has_bytebuf_params());
LOG(INFO) << "Starting client of type "
<< ClientType_Name(config.client_type()) << " "
<< RpcType_Name(config.rpc_type()) << " "
<< config.payload_config().has_bytebuf_params();
switch (config.client_type()) {
case ClientType::SYNC_CLIENT:
@ -72,8 +72,8 @@ static std::unique_ptr<Client> CreateClient(const ClientConfig& config) {
}
static std::unique_ptr<Server> CreateServer(const ServerConfig& config) {
gpr_log(GPR_INFO, "Starting server of type %s",
ServerType_Name(config.server_type()).c_str());
LOG(INFO) << "Starting server of type "
<< ServerType_Name(config.server_type());
switch (config.server_type()) {
case ServerType::SYNC_SERVER:
@ -110,7 +110,7 @@ class WorkerServiceImpl final : public WorkerService::Service {
Status RunClient(
ServerContext* ctx,
ServerReaderWriter<ClientStatus, ClientArgs>* stream) override {
gpr_log(GPR_INFO, "RunClient: Entering");
LOG(INFO) << "RunClient: Entering";
InstanceGuard g(this);
if (!g.Acquired()) {
return Status(StatusCode::RESOURCE_EXHAUSTED, "Client worker busy");
@ -118,14 +118,14 @@ class WorkerServiceImpl final : public WorkerService::Service {
ScopedProfile profile("qps_client.prof", false);
Status ret = RunClientBody(ctx, stream);
gpr_log(GPR_INFO, "RunClient: Returning");
LOG(INFO) << "RunClient: Returning";
return ret;
}
Status RunServer(
ServerContext* ctx,
ServerReaderWriter<ServerStatus, ServerArgs>* stream) override {
gpr_log(GPR_INFO, "RunServer: Entering");
LOG(INFO) << "RunServer: Entering";
InstanceGuard g(this);
if (!g.Acquired()) {
return Status(StatusCode::RESOURCE_EXHAUSTED, "Server worker busy");
@ -133,7 +133,7 @@ class WorkerServiceImpl final : public WorkerService::Service {
ScopedProfile profile("qps_server.prof", false);
Status ret = RunServerBody(ctx, stream);
gpr_log(GPR_INFO, "RunServer: Returning");
LOG(INFO) << "RunServer: Returning";
return ret;
}
@ -194,34 +194,34 @@ class WorkerServiceImpl final : public WorkerService::Service {
if (!args.has_setup()) {
return Status(StatusCode::INVALID_ARGUMENT, "Invalid setup arg");
}
gpr_log(GPR_INFO, "RunClientBody: about to create client");
LOG(INFO) << "RunClientBody: about to create client";
std::unique_ptr<Client> client = CreateClient(args.setup());
if (!client) {
return Status(StatusCode::INVALID_ARGUMENT, "Couldn't create client");
}
gpr_log(GPR_INFO, "RunClientBody: client created");
LOG(INFO) << "RunClientBody: client created";
ClientStatus status;
if (!stream->Write(status)) {
return Status(StatusCode::UNKNOWN, "Client couldn't report init status");
}
gpr_log(GPR_INFO, "RunClientBody: creation status reported");
LOG(INFO) << "RunClientBody: creation status reported";
while (stream->Read(&args)) {
gpr_log(GPR_INFO, "RunClientBody: Message read");
LOG(INFO) << "RunClientBody: Message read";
if (!args.has_mark()) {
gpr_log(GPR_INFO, "RunClientBody: Message is not a mark!");
LOG(INFO) << "RunClientBody: Message is not a mark!";
return Status(StatusCode::INVALID_ARGUMENT, "Invalid mark");
}
*status.mutable_stats() = client->Mark(args.mark().reset());
if (!stream->Write(status)) {
return Status(StatusCode::UNKNOWN, "Client couldn't respond to mark");
}
gpr_log(GPR_INFO, "RunClientBody: Mark response given");
LOG(INFO) << "RunClientBody: Mark response given";
}
gpr_log(GPR_INFO, "RunClientBody: Awaiting Threads Completion");
LOG(INFO) << "RunClientBody: Awaiting Threads Completion";
client->AwaitThreadsCompletion();
gpr_log(GPR_INFO, "RunClientBody: Returning");
LOG(INFO) << "RunClientBody: Returning";
return Status::OK;
}
@ -237,7 +237,7 @@ class WorkerServiceImpl final : public WorkerService::Service {
if (server_port_ > 0 && args.setup().port() == 0) {
args.mutable_setup()->set_port(server_port_);
}
gpr_log(GPR_INFO, "RunServerBody: about to create server");
LOG(INFO) << "RunServerBody: about to create server";
std::unique_ptr<Server> server = CreateServer(args.setup());
if (g_inproc_servers != nullptr) {
g_inproc_servers->push_back(server.get());
@ -245,28 +245,28 @@ class WorkerServiceImpl final : public WorkerService::Service {
if (!server) {
return Status(StatusCode::INVALID_ARGUMENT, "Couldn't create server");
}
gpr_log(GPR_INFO, "RunServerBody: server created");
LOG(INFO) << "RunServerBody: server created";
ServerStatus status;
status.set_port(server->port());
status.set_cores(server->cores());
if (!stream->Write(status)) {
return Status(StatusCode::UNKNOWN, "Server couldn't report init status");
}
gpr_log(GPR_INFO, "RunServerBody: creation status reported");
LOG(INFO) << "RunServerBody: creation status reported";
while (stream->Read(&args)) {
gpr_log(GPR_INFO, "RunServerBody: Message read");
LOG(INFO) << "RunServerBody: Message read";
if (!args.has_mark()) {
gpr_log(GPR_INFO, "RunServerBody: Message not a mark!");
LOG(INFO) << "RunServerBody: Message not a mark!";
return Status(StatusCode::INVALID_ARGUMENT, "Invalid mark");
}
*status.mutable_stats() = server->Mark(args.mark().reset());
if (!stream->Write(status)) {
return Status(StatusCode::UNKNOWN, "Server couldn't respond to mark");
}
gpr_log(GPR_INFO, "RunServerBody: Mark response given");
LOG(INFO) << "RunServerBody: Mark response given";
}
gpr_log(GPR_INFO, "RunServerBody: Returning");
LOG(INFO) << "RunServerBody: Returning";
return Status::OK;
}
@ -293,13 +293,11 @@ QpsWorker::QpsWorker(int driver_port, int server_port,
server_ = builder->BuildAndStart();
if (server_ == nullptr) {
gpr_log(GPR_ERROR,
"QpsWorker: Fail to BuildAndStart(driver_port=%d, server_port=%d)",
driver_port, server_port);
LOG(ERROR) << "QpsWorker: Fail to BuildAndStart(driver_port=" << driver_port
<< ", server_port=" << server_port << ")";
} else {
gpr_log(GPR_INFO,
"QpsWorker: BuildAndStart(driver_port=%d, server_port=%d) done",
driver_port, server_port);
LOG(INFO) << "QpsWorker: BuildAndStart(driver_port=" << driver_port
<< ", server_port=" << server_port << ") done";
}
}

@ -18,7 +18,7 @@
#include <set>
#include <grpc/support/log.h>
#include "absl/log/log.h"
#include "src/core/lib/gprpp/crash.h"
#include "test/core/test_util/test_config.h"
@ -36,7 +36,7 @@ static const int WARMUP = 1;
static const int BENCHMARK = 3;
static void RunSynchronousUnaryPingPong() {
gpr_log(GPR_INFO, "Running Synchronous Unary Ping Pong");
LOG(INFO) << "Running Synchronous Unary Ping Pong";
ClientConfig client_config;
client_config.set_client_type(SYNC_CLIENT);

@ -22,7 +22,8 @@
#include <sstream>
#include <string>
#include <grpc/support/log.h>
#include "absl/log/log.h"
#include <grpc/support/time.h>
#include "src/core/lib/gprpp/crash.h"
@ -74,7 +75,7 @@ static void get_cpu_usage(unsigned long long* total_cpu_time,
// Use the parameters to avoid unused-parameter warning
(void)total_cpu_time;
(void)idle_cpu_time;
gpr_log(GPR_INFO, "get_cpu_usage(): Non-linux platform is not supported.");
LOG(INFO) << "get_cpu_usage(): Non-linux platform is not supported.";
#endif
}

@ -25,6 +25,7 @@
#include <gtest/gtest.h>
#include "absl/log/check.h"
#include "absl/log/log.h"
#include "absl/memory/memory.h"
#include "opencensus/stats/testing/test_utils.h"
@ -174,9 +175,8 @@ class LbFeedbackTest : public LoadReporterTest {
DoubleNear(expected_qps, expected_qps * 0.3));
ASSERT_THAT(static_cast<double>(lb_feedback.errors_per_second()),
DoubleNear(expected_eps, expected_eps * 0.3));
gpr_log(GPR_INFO,
"Verified LB feedback matches the samples of index [%zu, %zu).",
start, start + count);
LOG(INFO) << "Verified LB feedback matches the samples of index [" << start
<< ", " << start + count << ").";
}
const std::vector<std::pair<double, double>> kQpsEpsSamples = {
@ -487,11 +487,11 @@ TEST_F(LoadReportTest, BasicReport) {
// First fetch.
load_reporter_->FetchAndSample();
load_reporter_->GenerateLoads(kHostname1, kLbId1);
gpr_log(GPR_INFO, "First load generated.");
LOG(INFO) << "First load generated.";
// Second fetch.
load_reporter_->FetchAndSample();
load_reporter_->GenerateLoads(kHostname2, kLbId2);
gpr_log(GPR_INFO, "Second load generated.");
LOG(INFO) << "Second load generated.";
// TODO(juanlishen): Verify the data.
}

@ -20,9 +20,9 @@
#include <gtest/gtest.h>
#include "absl/log/log.h"
#include "absl/strings/str_format.h"
#include <grpc/support/log.h>
#include <grpcpp/create_channel.h>
#include <grpcpp/security/credentials.h>
#include <grpcpp/server.h>
@ -90,7 +90,7 @@ TEST(ServerRequestCallTest, ShortDeadlineDoesNotCauseOkayFalse) {
// Send a simple response after a small delay that would ensure the client
// deadline is exceeded.
gpr_log(GPR_INFO, "Got request %d", n);
LOG(INFO) << "Got request " << n;
testing::EchoResponse response;
response.set_message("foobar");
// A bit of sleep to make sure the deadline elapses.
@ -99,12 +99,11 @@ TEST(ServerRequestCallTest, ShortDeadlineDoesNotCauseOkayFalse) {
{
std::lock_guard<std::mutex> lock(mu);
if (shutting_down) {
gpr_log(GPR_INFO,
"shut down while processing call, not calling Finish()");
LOG(INFO) << "shut down while processing call, not calling Finish()";
// Continue flushing the CQ.
continue;
}
gpr_log(GPR_INFO, "Finishing request %d", n);
LOG(INFO) << "Finishing request " << n;
responder.Finish(response, grpc::Status::OK,
reinterpret_cast<void*>(2));
if (!cq->Next(&tag, &ok)) {
@ -119,7 +118,7 @@ TEST(ServerRequestCallTest, ShortDeadlineDoesNotCauseOkayFalse) {
grpc::CreateChannel(address, InsecureChannelCredentials()));
for (int i = 0; i < 100; i++) {
gpr_log(GPR_INFO, "Sending %d.", i);
LOG(INFO) << "Sending " << i;
testing::EchoRequest request;
/////////
@ -138,12 +137,12 @@ TEST(ServerRequestCallTest, ShortDeadlineDoesNotCauseOkayFalse) {
std::chrono::milliseconds(1));
grpc::Status status = stub->Echo(&ctx, request, &response);
EXPECT_EQ(StatusCode::DEADLINE_EXCEEDED, status.error_code());
gpr_log(GPR_INFO, "Success.");
LOG(INFO) << "Success.";
}
gpr_log(GPR_INFO, "Done sending RPCs.");
LOG(INFO) << "Done sending RPCs.";
// Shut down everything properly.
gpr_log(GPR_INFO, "Shutting down.");
LOG(INFO) << "Shutting down.";
{
std::lock_guard<std::mutex> lock(mu);
shutting_down = true;
@ -226,7 +225,7 @@ TEST(ServerRequestCallTest, MultithreadedUnimplementedService) {
}
// Shut down everything properly.
gpr_log(GPR_INFO, "Shutting down.");
LOG(INFO) << "Shutting down.";
shutdown.store(true);
server->Shutdown();
cq->Shutdown();

@ -133,6 +133,7 @@ LANG_RELEASE_MATRIX = {
("v1.61.0", ReleaseInfo()),
("v1.62.0", ReleaseInfo()),
("v1.63.0", ReleaseInfo()),
("v1.64.0", ReleaseInfo()),
]
),
"go": OrderedDict(
@ -441,7 +442,7 @@ LANG_RELEASE_MATRIX = {
("v1.59.1", ReleaseInfo()),
("v1.60.1", ReleaseInfo()),
("v1.61.0", ReleaseInfo()),
("v1.63.0", ReleaseInfo()),
("v1.63.1", ReleaseInfo()),
("v1.64.0", ReleaseInfo()),
]
),
@ -789,6 +790,12 @@ LANG_RELEASE_MATRIX = {
runtimes=["python"], testcases_file="python__master"
),
),
(
"v1.64.0",
ReleaseInfo(
runtimes=["python"], testcases_file="python__master"
),
),
]
),
"node": OrderedDict(
@ -886,6 +893,7 @@ LANG_RELEASE_MATRIX = {
("v1.61.0", ReleaseInfo()),
("v1.62.0", ReleaseInfo()),
("v1.63.0", ReleaseInfo()),
("v1.64.0", ReleaseInfo()),
]
),
"php": OrderedDict(
@ -947,6 +955,7 @@ LANG_RELEASE_MATRIX = {
("v1.61.0", ReleaseInfo()),
("v1.62.0", ReleaseInfo()),
("v1.63.0", ReleaseInfo()),
("v1.64.0", ReleaseInfo()),
]
),
"csharp": OrderedDict(

Loading…
Cancel
Save