The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

203 lines
5.8 KiB

//
//
// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// is % allowed in string
//
#include "test/cpp/interop/stress_interop_client.h"
#include <memory>
#include <string>
#include <vector>
#include "absl/log/check.h"
#include "absl/strings/str_format.h"
#include <grpc/support/log.h>
#include <grpcpp/create_channel.h>
#include "src/core/lib/gprpp/crash.h"
#include "test/cpp/interop/interop_client.h"
#include "test/cpp/util/metrics_server.h"
namespace grpc {
namespace testing {
using std::pair;
using std::vector;
WeightedRandomTestSelector::WeightedRandomTestSelector(
const vector<pair<TestCaseType, int>>& tests)
: tests_(tests) {
total_weight_ = 0;
for (auto it = tests.begin(); it != tests.end(); it++) {
total_weight_ += it->second;
}
}
// Returns a weighted-randomly selected test case based on the test weights
// passed in the constructror
TestCaseType WeightedRandomTestSelector::GetNextTest() const {
int random = 0;
TestCaseType selected_test = UNKNOWN_TEST;
// Get a random number from [0 to the total_weight - 1]
random = rand() % total_weight_;
int weight_sofar = 0;
for (auto it = tests_.begin(); it != tests_.end(); it++) {
weight_sofar += it->second;
if (random < weight_sofar) {
selected_test = it->first;
break;
}
}
// It is a bug in the logic if no test is selected at this point
CHECK(selected_test != UNKNOWN_TEST);
return selected_test;
}
StressTestInteropClient::StressTestInteropClient(
int test_id, const std::string& server_address,
ChannelCreationFunc channel_creation_func,
const WeightedRandomTestSelector& test_selector, long test_duration_secs,
long sleep_duration_ms, bool do_not_abort_on_transient_failures)
: test_id_(test_id),
server_address_(server_address),
channel_creation_func_(std::move(channel_creation_func)),
interop_client_(new InteropClient(channel_creation_func_, false,
do_not_abort_on_transient_failures)),
test_selector_(test_selector),
test_duration_secs_(test_duration_secs),
sleep_duration_ms_(sleep_duration_ms) {}
void StressTestInteropClient::MainLoop(
const std::shared_ptr<QpsGauge>& qps_gauge) {
gpr_log(GPR_INFO, "Running test %d. ServerAddr: %s", test_id_,
server_address_.c_str());
gpr_timespec test_end_time;
if (test_duration_secs_ < 0) {
test_end_time = gpr_inf_future(GPR_CLOCK_REALTIME);
} else {
test_end_time =
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_seconds(test_duration_secs_, GPR_TIMESPAN));
}
qps_gauge->Reset();
while (gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), test_end_time) < 0) {
// Select the test case to execute based on the weights and execute it
TestCaseType test_case = test_selector_.GetNextTest();
gpr_log(GPR_DEBUG, "%d - Executing the test case %d", test_id_, test_case);
RunTest(test_case);
qps_gauge->Incr();
// Sleep between successive calls if needed
if (sleep_duration_ms_ > 0) {
gpr_timespec sleep_time =
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_millis(sleep_duration_ms_, GPR_TIMESPAN));
gpr_sleep_until(sleep_time);
}
}
}
bool StressTestInteropClient::RunTest(TestCaseType test_case) {
bool is_success = false;
switch (test_case) {
case EMPTY_UNARY: {
is_success = interop_client_->DoEmpty();
break;
}
case LARGE_UNARY: {
is_success = interop_client_->DoLargeUnary();
break;
}
case CLIENT_COMPRESSED_UNARY: {
is_success = interop_client_->DoClientCompressedUnary();
break;
}
case CLIENT_COMPRESSED_STREAMING: {
is_success = interop_client_->DoClientCompressedStreaming();
break;
}
case CLIENT_STREAMING: {
is_success = interop_client_->DoRequestStreaming();
break;
}
case SERVER_STREAMING: {
is_success = interop_client_->DoResponseStreaming();
break;
}
case SERVER_COMPRESSED_UNARY: {
is_success = interop_client_->DoServerCompressedUnary();
break;
}
case SERVER_COMPRESSED_STREAMING: {
is_success = interop_client_->DoServerCompressedStreaming();
break;
}
case SLOW_CONSUMER: {
is_success = interop_client_->DoResponseStreamingWithSlowConsumer();
break;
}
case HALF_DUPLEX: {
is_success = interop_client_->DoHalfDuplex();
break;
}
case PING_PONG: {
is_success = interop_client_->DoPingPong();
break;
}
case CANCEL_AFTER_BEGIN: {
is_success = interop_client_->DoCancelAfterBegin();
break;
}
case CANCEL_AFTER_FIRST_RESPONSE: {
is_success = interop_client_->DoCancelAfterFirstResponse();
break;
}
case TIMEOUT_ON_SLEEPING_SERVER: {
is_success = interop_client_->DoTimeoutOnSleepingServer();
break;
}
case EMPTY_STREAM: {
is_success = interop_client_->DoEmptyStream();
break;
}
case STATUS_CODE_AND_MESSAGE: {
is_success = interop_client_->DoStatusWithMessage();
break;
}
case CUSTOM_METADATA: {
is_success = interop_client_->DoCustomMetadata();
break;
}
default: {
grpc_core::Crash(absl::StrFormat("Invalid test case (%d)", test_case));
break;
}
}
return is_success;
}
} // namespace testing
} // namespace grpc