mirror of https://github.com/grpc/grpc.git
tanvi-jagtap
7 months ago
commit
4669996fd8
97 changed files with 668 additions and 2806 deletions
@ -1,62 +0,0 @@ |
||||
// Copyright 2024 The 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.
|
||||
#ifndef GRPC_PASSIVE_LISTENER_H |
||||
#define GRPC_PASSIVE_LISTENER_H |
||||
|
||||
#include <memory> |
||||
|
||||
#include <grpc/event_engine/event_engine.h> |
||||
#include <grpc/grpc.h> |
||||
// #include <grpc/support/port_platform.h>
|
||||
|
||||
namespace grpc_core { |
||||
class Server; |
||||
|
||||
namespace experimental { |
||||
class PassiveListenerImpl; |
||||
|
||||
/// -- EXPERIMENTAL API --
|
||||
/// Interface for used for Server Endpoint injection.
|
||||
class PassiveListener { |
||||
public: |
||||
virtual ~PassiveListener() = default; |
||||
/// -- EXPERIMENTAL API --
|
||||
///
|
||||
/// Takes an Endpoint for an established connection, and treats it as if the
|
||||
/// connection had been accepted by the server.
|
||||
///
|
||||
/// The server must be started before endpoints can be accepted.
|
||||
virtual absl::Status AcceptConnectedEndpoint( |
||||
std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint> |
||||
endpoint) = 0; |
||||
|
||||
/// -- EXPERIMENTAL API --
|
||||
///
|
||||
/// Takes a connected file descriptor, and treats it as if the server had
|
||||
/// accepted the connection itself.
|
||||
///
|
||||
/// Returns a failure status if the server's active EventEngine does not
|
||||
/// support Endpoint creation from fds.
|
||||
virtual absl::Status AcceptConnectedFd(int fd) = 0; |
||||
}; |
||||
|
||||
} // namespace experimental
|
||||
} // namespace grpc_core
|
||||
|
||||
absl::Status grpc_server_add_passive_listener( |
||||
grpc_core::Server* server, grpc_server_credentials* credentials, |
||||
std::shared_ptr<grpc_core::experimental::PassiveListenerImpl> |
||||
passive_listener); |
||||
|
||||
#endif /* GRPC_PASSIVE_LISTENER_H */ |
||||
@ -1,27 +0,0 @@ |
||||
// Copyright 2024 The 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.
|
||||
#ifndef GRPCPP_PASSIVE_LISTENER_H |
||||
#define GRPCPP_PASSIVE_LISTENER_H |
||||
|
||||
#include <grpc/passive_listener.h> |
||||
|
||||
namespace grpc { |
||||
namespace experimental { |
||||
|
||||
using grpc_core::experimental::PassiveListener; |
||||
|
||||
} // namespace experimental
|
||||
} // namespace grpc
|
||||
|
||||
#endif // GRPCPP_PASSIVE_LISTENER_H
|
||||
@ -1,425 +0,0 @@ |
||||
//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//
|
||||
|
||||
// Microbenchmarks around CHTTP2 transport operations
|
||||
|
||||
#include <string.h> |
||||
|
||||
#include <memory> |
||||
#include <queue> |
||||
#include <sstream> |
||||
|
||||
#include <benchmark/benchmark.h> |
||||
|
||||
#include "absl/log/check.h" |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/string_util.h> |
||||
#include <grpcpp/support/channel_arguments.h> |
||||
|
||||
#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h" |
||||
#include "src/core/ext/transport/chttp2/transport/internal.h" |
||||
#include "src/core/lib/gprpp/crash.h" |
||||
#include "src/core/lib/iomgr/closure.h" |
||||
#include "src/core/lib/resource_quota/api.h" |
||||
#include "src/core/lib/slice/slice_internal.h" |
||||
#include "test/core/test_util/test_config.h" |
||||
#include "test/cpp/microbenchmarks/helpers.h" |
||||
#include "test/cpp/util/test_config.h" |
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Helper classes
|
||||
//
|
||||
|
||||
class PhonyEndpoint : public grpc_endpoint { |
||||
public: |
||||
PhonyEndpoint() { |
||||
static const grpc_endpoint_vtable my_vtable = {read, |
||||
write, |
||||
add_to_pollset, |
||||
add_to_pollset_set, |
||||
delete_from_pollset_set, |
||||
shutdown, |
||||
destroy, |
||||
get_peer, |
||||
get_local_address, |
||||
get_fd, |
||||
can_track_err}; |
||||
grpc_endpoint::vtable = &my_vtable; |
||||
} |
||||
|
||||
void PushInput(grpc_slice slice) { |
||||
if (read_cb_ == nullptr) { |
||||
CHECK(!have_slice_); |
||||
buffered_slice_ = slice; |
||||
have_slice_ = true; |
||||
return; |
||||
} |
||||
grpc_slice_buffer_add(slices_, slice); |
||||
grpc_core::ExecCtx::Run(DEBUG_LOCATION, read_cb_, absl::OkStatus()); |
||||
read_cb_ = nullptr; |
||||
} |
||||
|
||||
private: |
||||
grpc_closure* read_cb_ = nullptr; |
||||
grpc_slice_buffer* slices_ = nullptr; |
||||
bool have_slice_ = false; |
||||
grpc_slice buffered_slice_; |
||||
|
||||
void QueueRead(grpc_slice_buffer* slices, grpc_closure* cb) { |
||||
CHECK_EQ(read_cb_, nullptr); |
||||
if (have_slice_) { |
||||
have_slice_ = false; |
||||
grpc_slice_buffer_add(slices, buffered_slice_); |
||||
grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, absl::OkStatus()); |
||||
return; |
||||
} |
||||
read_cb_ = cb; |
||||
slices_ = slices; |
||||
} |
||||
|
||||
static void read(grpc_endpoint* ep, grpc_slice_buffer* slices, |
||||
grpc_closure* cb, bool /*urgent*/, |
||||
int /*min_progress_size*/) { |
||||
static_cast<PhonyEndpoint*>(ep)->QueueRead(slices, cb); |
||||
} |
||||
|
||||
static void write(grpc_endpoint* /*ep*/, grpc_slice_buffer* /*slices*/, |
||||
grpc_closure* cb, void* /*arg*/, int /*max_frame_size*/) { |
||||
grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, absl::OkStatus()); |
||||
} |
||||
|
||||
static void add_to_pollset(grpc_endpoint* /*ep*/, grpc_pollset* /*pollset*/) { |
||||
} |
||||
|
||||
static void add_to_pollset_set(grpc_endpoint* /*ep*/, |
||||
grpc_pollset_set* /*pollset*/) {} |
||||
|
||||
static void delete_from_pollset_set(grpc_endpoint* /*ep*/, |
||||
grpc_pollset_set* /*pollset*/) {} |
||||
|
||||
static void shutdown(grpc_endpoint* ep, grpc_error_handle why) { |
||||
grpc_core::ExecCtx::Run(DEBUG_LOCATION, |
||||
static_cast<PhonyEndpoint*>(ep)->read_cb_, why); |
||||
} |
||||
|
||||
static void destroy(grpc_endpoint* ep) { |
||||
delete static_cast<PhonyEndpoint*>(ep); |
||||
} |
||||
|
||||
static absl::string_view get_peer(grpc_endpoint* /*ep*/) { return "test"; } |
||||
static absl::string_view get_local_address(grpc_endpoint* /*ep*/) { |
||||
return "test"; |
||||
} |
||||
static int get_fd(grpc_endpoint* /*ep*/) { return 0; } |
||||
static bool can_track_err(grpc_endpoint* /*ep*/) { return false; } |
||||
}; |
||||
|
||||
class Fixture { |
||||
public: |
||||
Fixture(const grpc::ChannelArguments& args, bool client) { |
||||
grpc_channel_args c_args = args.c_channel_args(); |
||||
ep_ = new PhonyEndpoint; |
||||
auto final_args = grpc_core::CoreConfiguration::Get() |
||||
.channel_args_preconditioning() |
||||
.PreconditionChannelArgs(&c_args); |
||||
t_ = grpc_create_chttp2_transport(final_args, ep_, client); |
||||
grpc_chttp2_transport_start_reading(t_, nullptr, nullptr, nullptr); |
||||
FlushExecCtx(); |
||||
} |
||||
|
||||
void FlushExecCtx() { grpc_core::ExecCtx::Get()->Flush(); } |
||||
|
||||
~Fixture() { t_->Orphan(); } |
||||
|
||||
grpc_chttp2_transport* chttp2_transport() { |
||||
return reinterpret_cast<grpc_chttp2_transport*>(t_); |
||||
} |
||||
grpc_core::Transport* transport() { return t_; } |
||||
|
||||
void PushInput(grpc_slice slice) { ep_->PushInput(slice); } |
||||
|
||||
private: |
||||
PhonyEndpoint* ep_; |
||||
grpc_core::Transport* t_; |
||||
}; |
||||
|
||||
class TestClosure : public grpc_closure { |
||||
public: |
||||
virtual ~TestClosure() {} |
||||
}; |
||||
|
||||
template <class F> |
||||
std::unique_ptr<TestClosure> MakeTestClosure(F f) { |
||||
struct C : public TestClosure { |
||||
explicit C(const F& f) : f_(f) { |
||||
GRPC_CLOSURE_INIT(this, Execute, this, nullptr); |
||||
} |
||||
F f_; |
||||
static void Execute(void* arg, grpc_error_handle error) { |
||||
static_cast<C*>(arg)->f_(error); |
||||
} |
||||
}; |
||||
return std::unique_ptr<TestClosure>(new C(f)); |
||||
} |
||||
|
||||
template <class F> |
||||
grpc_closure* MakeOnceClosure(F f) { |
||||
struct C : public grpc_closure { |
||||
explicit C(const F& f) : f_(f) {} |
||||
F f_; |
||||
static void Execute(void* arg, grpc_error_handle error) { |
||||
static_cast<C*>(arg)->f_(error); |
||||
delete static_cast<C*>(arg); |
||||
} |
||||
}; |
||||
auto* c = new C{f}; |
||||
return GRPC_CLOSURE_INIT(c, C::Execute, c, nullptr); |
||||
} |
||||
|
||||
class Stream { |
||||
public: |
||||
explicit Stream(Fixture* f) : f_(f) { |
||||
stream_size_ = f->transport()->filter_stack_transport()->SizeOfStream(); |
||||
stream_ = gpr_malloc(stream_size_); |
||||
arena_ = grpc_core::Arena::Create(4096, &memory_allocator_); |
||||
} |
||||
|
||||
~Stream() { |
||||
gpr_event_wait(&done_, gpr_inf_future(GPR_CLOCK_REALTIME)); |
||||
gpr_free(stream_); |
||||
arena_->Destroy(); |
||||
} |
||||
|
||||
void Init(benchmark::State& state) { |
||||
GRPC_STREAM_REF_INIT(&refcount_, 1, &Stream::FinishDestroy, this, |
||||
"test_stream"); |
||||
gpr_event_init(&done_); |
||||
memset(stream_, 0, stream_size_); |
||||
if ((state.iterations() & 0xffff) == 0) { |
||||
arena_->Destroy(); |
||||
arena_ = grpc_core::Arena::Create(4096, &memory_allocator_); |
||||
} |
||||
f_->transport()->filter_stack_transport()->InitStream( |
||||
static_cast<grpc_stream*>(stream_), &refcount_, nullptr, arena_); |
||||
} |
||||
|
||||
void DestroyThen(grpc_closure* closure) { |
||||
destroy_closure_ = closure; |
||||
#ifndef NDEBUG |
||||
grpc_stream_unref(&refcount_, "DestroyThen"); |
||||
#else |
||||
grpc_stream_unref(&refcount_); |
||||
#endif |
||||
} |
||||
|
||||
void Op(grpc_transport_stream_op_batch* op) { |
||||
f_->transport()->filter_stack_transport()->PerformStreamOp( |
||||
static_cast<grpc_stream*>(stream_), op); |
||||
} |
||||
|
||||
grpc_chttp2_stream* chttp2_stream() { |
||||
return static_cast<grpc_chttp2_stream*>(stream_); |
||||
} |
||||
|
||||
private: |
||||
static void FinishDestroy(void* arg, grpc_error_handle /*error*/) { |
||||
auto stream = static_cast<Stream*>(arg); |
||||
stream->f_->transport()->filter_stack_transport()->DestroyStream( |
||||
static_cast<grpc_stream*>(stream->stream_), stream->destroy_closure_); |
||||
gpr_event_set(&stream->done_, reinterpret_cast<void*>(1)); |
||||
} |
||||
|
||||
Fixture* f_; |
||||
grpc_stream_refcount refcount_; |
||||
grpc_core::MemoryAllocator memory_allocator_ = |
||||
grpc_core::MemoryAllocator(grpc_core::ResourceQuota::Default() |
||||
->memory_quota() |
||||
->CreateMemoryAllocator("test")); |
||||
grpc_core::Arena* arena_; |
||||
size_t stream_size_; |
||||
void* stream_; |
||||
grpc_closure* destroy_closure_ = nullptr; |
||||
gpr_event done_; |
||||
}; |
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Benchmarks
|
||||
//
|
||||
std::vector<std::unique_ptr<gpr_event>> done_events; |
||||
|
||||
static void BM_StreamCreateDestroy(benchmark::State& state) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
Fixture f(grpc::ChannelArguments(), true); |
||||
auto* s = new Stream(&f); |
||||
grpc_transport_stream_op_batch op; |
||||
grpc_transport_stream_op_batch_payload op_payload(nullptr); |
||||
op = {}; |
||||
op.cancel_stream = true; |
||||
op.payload = &op_payload; |
||||
op_payload.cancel_stream.cancel_error = absl::CancelledError(); |
||||
std::unique_ptr<TestClosure> next = |
||||
MakeTestClosure([&, s](grpc_error_handle /*error*/) { |
||||
if (!state.KeepRunning()) { |
||||
delete s; |
||||
return; |
||||
} |
||||
s->Init(state); |
||||
s->Op(&op); |
||||
s->DestroyThen(next.get()); |
||||
}); |
||||
grpc_core::Closure::Run(DEBUG_LOCATION, next.get(), absl::OkStatus()); |
||||
f.FlushExecCtx(); |
||||
} |
||||
BENCHMARK(BM_StreamCreateDestroy); |
||||
|
||||
class RepresentativeClientInitialMetadata { |
||||
public: |
||||
static void Prepare(grpc_metadata_batch* b) { |
||||
b->Set(grpc_core::HttpSchemeMetadata(), |
||||
grpc_core::HttpSchemeMetadata::kHttp); |
||||
b->Set(grpc_core::HttpMethodMetadata(), |
||||
grpc_core::HttpMethodMetadata::kPost); |
||||
b->Set(grpc_core::HttpPathMetadata(), |
||||
grpc_core::Slice(grpc_core::StaticSlice::FromStaticString( |
||||
"/foo/bar/bm_chttp2_transport"))); |
||||
b->Set(grpc_core::HttpAuthorityMetadata(), |
||||
grpc_core::Slice(grpc_core::StaticSlice::FromStaticString( |
||||
"foo.test.google.fr:1234"))); |
||||
b->Set( |
||||
grpc_core::GrpcAcceptEncodingMetadata(), |
||||
grpc_core::CompressionAlgorithmSet( |
||||
{GRPC_COMPRESS_NONE, GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_GZIP})); |
||||
b->Set(grpc_core::TeMetadata(), grpc_core::TeMetadata::kTrailers); |
||||
b->Set(grpc_core::ContentTypeMetadata(), |
||||
grpc_core::ContentTypeMetadata::kApplicationGrpc); |
||||
b->Set(grpc_core::UserAgentMetadata(), |
||||
grpc_core::Slice(grpc_core::StaticSlice::FromStaticString( |
||||
"grpc-c/3.0.0-dev (linux; chttp2; green)"))); |
||||
} |
||||
}; |
||||
|
||||
template <class Metadata> |
||||
static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State& state) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
Fixture f(grpc::ChannelArguments(), true); |
||||
auto* s = new Stream(&f); |
||||
grpc_transport_stream_op_batch op; |
||||
grpc_transport_stream_op_batch_payload op_payload(nullptr); |
||||
std::unique_ptr<TestClosure> start; |
||||
std::unique_ptr<TestClosure> done; |
||||
|
||||
auto reset_op = [&]() { |
||||
op = {}; |
||||
op.payload = &op_payload; |
||||
}; |
||||
|
||||
grpc_core::MemoryAllocator memory_allocator = |
||||
grpc_core::MemoryAllocator(grpc_core::ResourceQuota::Default() |
||||
->memory_quota() |
||||
->CreateMemoryAllocator("test")); |
||||
auto arena = grpc_core::MakeScopedArena(1024, &memory_allocator); |
||||
grpc_metadata_batch b; |
||||
Metadata::Prepare(&b); |
||||
|
||||
f.FlushExecCtx(); |
||||
gpr_event bm_done; |
||||
gpr_event_init(&bm_done); |
||||
start = MakeTestClosure([&, s](grpc_error_handle /*error*/) { |
||||
if (!state.KeepRunning()) { |
||||
delete s; |
||||
gpr_event_set(&bm_done, (void*)1); |
||||
return; |
||||
} |
||||
s->Init(state); |
||||
reset_op(); |
||||
op.on_complete = done.get(); |
||||
op.send_initial_metadata = true; |
||||
op.payload->send_initial_metadata.send_initial_metadata = &b; |
||||
s->Op(&op); |
||||
}); |
||||
done = MakeTestClosure([&](grpc_error_handle /*error*/) { |
||||
reset_op(); |
||||
op.cancel_stream = true; |
||||
op.payload->cancel_stream.cancel_error = absl::CancelledError(); |
||||
s->Op(&op); |
||||
s->DestroyThen(start.get()); |
||||
}); |
||||
grpc_core::ExecCtx::Run(DEBUG_LOCATION, start.get(), absl::OkStatus()); |
||||
f.FlushExecCtx(); |
||||
gpr_event_wait(&bm_done, gpr_inf_future(GPR_CLOCK_REALTIME)); |
||||
} |
||||
BENCHMARK_TEMPLATE(BM_StreamCreateSendInitialMetadataDestroy, |
||||
RepresentativeClientInitialMetadata); |
||||
|
||||
static void BM_TransportEmptyOp(benchmark::State& state) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
Fixture f(grpc::ChannelArguments(), true); |
||||
auto* s = new Stream(&f); |
||||
s->Init(state); |
||||
grpc_transport_stream_op_batch op; |
||||
grpc_transport_stream_op_batch_payload op_payload(nullptr); |
||||
auto reset_op = [&]() { |
||||
op = {}; |
||||
op.payload = &op_payload; |
||||
}; |
||||
std::unique_ptr<TestClosure> c = |
||||
MakeTestClosure([&](grpc_error_handle /*error*/) { |
||||
if (!state.KeepRunning()) return; |
||||
reset_op(); |
||||
op.on_complete = c.get(); |
||||
s->Op(&op); |
||||
}); |
||||
grpc_core::ExecCtx::Run(DEBUG_LOCATION, c.get(), absl::OkStatus()); |
||||
f.FlushExecCtx(); |
||||
reset_op(); |
||||
op.cancel_stream = true; |
||||
op_payload.cancel_stream.cancel_error = absl::CancelledError(); |
||||
gpr_event* stream_cancel_done = new gpr_event; |
||||
gpr_event_init(stream_cancel_done); |
||||
std::unique_ptr<TestClosure> stream_cancel_closure = |
||||
MakeTestClosure([&](grpc_error_handle error) { |
||||
CHECK_OK(error); |
||||
gpr_event_set(stream_cancel_done, reinterpret_cast<void*>(1)); |
||||
}); |
||||
op.on_complete = stream_cancel_closure.get(); |
||||
s->Op(&op); |
||||
f.FlushExecCtx(); |
||||
gpr_event_wait(stream_cancel_done, gpr_inf_future(GPR_CLOCK_REALTIME)); |
||||
done_events.emplace_back(stream_cancel_done); |
||||
s->DestroyThen( |
||||
MakeOnceClosure([s](grpc_error_handle /*error*/) { delete s; })); |
||||
f.FlushExecCtx(); |
||||
} |
||||
BENCHMARK(BM_TransportEmptyOp); |
||||
|
||||
// Some distros have RunSpecifiedBenchmarks under the benchmark namespace,
|
||||
// and others do not. This allows us to support both modes.
|
||||
namespace benchmark { |
||||
void RunTheBenchmarksNamespaced() { RunSpecifiedBenchmarks(); } |
||||
} // namespace benchmark
|
||||
|
||||
int main(int argc, char** argv) { |
||||
grpc::testing::TestEnvironment env(&argc, argv); |
||||
LibraryInitializer libInit; |
||||
::benchmark::Initialize(&argc, argv); |
||||
grpc::testing::InitTest(&argc, &argv, false); |
||||
benchmark::RunTheBenchmarksNamespaced(); |
||||
return 0; |
||||
} |
||||
@ -1,193 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2021 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly SERVER_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/cpp-server" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/cpp-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building C++ xDS interop test app Docker images" |
||||
docker build -f "${SRC_DIR}/tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_client" -t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" "${SRC_DIR}" |
||||
docker build -f "${SRC_DIR}/tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_server" -t "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" "${SRC_DIR}" |
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
docker push "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" |
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
tag_and_push_docker_image "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${server_tags:-Server image not found}" |
||||
|
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping C++ test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# SECONDARY_KUBE_CONTEXT: The name of kubectl context with secondary GKE cluster access, if any |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--secondary_kube_context="${SECONDARY_KUBE_CONTEXT}" \ |
||||
--server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--force_cleanup \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
${@:2} \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
} |
||||
|
||||
run_alpha_test() { |
||||
local test_name=$1 |
||||
run_test ${test_name} \ |
||||
--compute_api_version="v1alpha" |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# SECONDARY_KUBE_CONTEXT: Populated with name of kubectl context with secondary GKE cluster access, if any |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test captured from the master branch. |
||||
echo "Sourcing test driver install captured from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_LB |
||||
activate_secondary_gke_cluster GKE_CLUSTER_PSM_LB |
||||
|
||||
set -x |
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
|
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
local failed_tests=0 |
||||
run_alpha_test subsetting_test || (( ++failed_tests )) |
||||
test_suites=( |
||||
"app_net_test" |
||||
"affinity_test" |
||||
"api_listener_test" |
||||
"change_backend_service_test" |
||||
"custom_lb_test" |
||||
"failover_test" |
||||
"outlier_detection_test" |
||||
"remove_neg_test" |
||||
"round_robin_test" |
||||
) |
||||
if [[ "${TESTING_VERSION}" =~ "master" ]]; then |
||||
test_suites+=('bootstrap_generator_test') |
||||
fi |
||||
for test in "${test_suites[@]}"; do |
||||
run_test $test || (( ++failed_tests )) |
||||
done |
||||
echo "Failed test suites: ${failed_tests}" |
||||
} |
||||
|
||||
main "$@" |
||||
@ -1,196 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2021 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly SERVER_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/python-server" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/python-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
readonly LANGUAGE_NAME="Python" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building ${LANGUAGE_NAME} xDS interop test app Docker images" |
||||
|
||||
pushd "${SRC_DIR}" |
||||
docker build \ |
||||
-f src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.client \ |
||||
-t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
. |
||||
|
||||
docker build \ |
||||
-f src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.server \ |
||||
-t "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
. |
||||
|
||||
popd |
||||
|
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
|
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
docker push "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" |
||||
|
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
tag_and_push_docker_image "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${server_tags:-Server image not found}" |
||||
|
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping ${LANGUAGE_NAME} test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# SECONDARY_KUBE_CONTEXT: The name of kubectl context with secondary GKE cluster access, if any |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--secondary_kube_context="${SECONDARY_KUBE_CONTEXT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--force_cleanup \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# SECONDARY_KUBE_CONTEXT: Populated with name of kubectl context with secondary GKE cluster access, if any |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test driver from the master branch. |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_LB |
||||
activate_secondary_gke_cluster GKE_CLUSTER_PSM_LB |
||||
|
||||
set -x |
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
|
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
local failed_tests=0 |
||||
test_suites=( |
||||
"app_net_test" |
||||
"api_listener_test" |
||||
"change_backend_service_test" |
||||
"failover_test" |
||||
"outlier_detection_test" |
||||
"remove_neg_test" |
||||
"round_robin_test" |
||||
) |
||||
if [[ "${TESTING_VERSION}" =~ "master" ]]; then |
||||
test_suites+=('bootstrap_generator_test') |
||||
fi |
||||
for test in "${test_suites[@]}"; do |
||||
run_test $test || (( ++failed_tests )) |
||||
done |
||||
echo "Failed test suites: ${failed_tests}" |
||||
} |
||||
|
||||
main "$@" |
||||
@ -1,150 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2021 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/cpp-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building C++ xDS interop test app Docker images" |
||||
docker build -f "${SRC_DIR}/tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_client" -t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" "${SRC_DIR}" |
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping C++ test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--flagfile="config/url-map.cfg" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test driver from the master branch. |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_BASIC |
||||
|
||||
set -x |
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
run_test url_map || echo "Failed url_map test" |
||||
} |
||||
|
||||
main "$@" |
||||
@ -1,160 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2021 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/python-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
readonly LANGUAGE_NAME="Python" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building ${LANGUAGE_NAME} xDS interop test app Docker images" |
||||
|
||||
pushd "${SRC_DIR}" |
||||
docker build \ |
||||
-f src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.client \ |
||||
-t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
. |
||||
|
||||
popd |
||||
|
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
|
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping ${LANGUAGE_NAME} test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--flagfile="config/url-map.cfg" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test driver from the master branch. |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_BASIC |
||||
|
||||
set -x |
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
run_test url_map || echo "Failed url_map test" |
||||
} |
||||
|
||||
main "$@" |
||||
@ -1,190 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2024 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test server/client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly SERVER_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/python-server" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/python-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test, f.e. v1.42.x, master |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building Python xDS interop test app Docker images" |
||||
|
||||
pushd "${SRC_DIR}" |
||||
docker build \ |
||||
-f src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.client \ |
||||
-t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
. |
||||
|
||||
docker build \ |
||||
-f src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.server \ |
||||
-t "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
. |
||||
|
||||
popd |
||||
|
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
|
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
docker push "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" |
||||
|
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
tag_and_push_docker_image "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${server_tags:-Server image not found}" |
||||
|
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping Python test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--flagfile="config/common-csm.cfg" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--nocheck_local_certs \ |
||||
--force_cleanup \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
set +x |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test driver from the master branch. |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_CSM |
||||
|
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
local failed_tests=0 |
||||
test_suites=( |
||||
"gamma.gamma_baseline_test" |
||||
"gamma.affinity_session_drain_test" |
||||
"gamma.affinity_test" |
||||
"app_net_ssa_test" |
||||
) |
||||
for test in "${test_suites[@]}"; do |
||||
run_test $test || (( ++failed_tests )) |
||||
done |
||||
echo "Failed test suites: ${failed_tests}" |
||||
} |
||||
|
||||
|
||||
main "$@" |
||||
@ -1,175 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2023 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test server/client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly SERVER_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/cpp-server" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/cpp-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test, f.e. v1.42.x, master |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building C++ xDS interop test app Docker images" |
||||
docker build -f "${SRC_DIR}/tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_client" -t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" "${SRC_DIR}" |
||||
docker build -f "${SRC_DIR}/tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_server" -t "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" "${SRC_DIR}" |
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
docker push "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" |
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
tag_and_push_docker_image "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${server_tags:-Server image not found}" |
||||
|
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping C++ test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--flagfile="config/common-csm.cfg" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--force_cleanup \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test driver from the master branch. |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_CSM |
||||
|
||||
set -x |
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
local failed_tests=0 |
||||
test_suites=( |
||||
"gamma.gamma_baseline_test" |
||||
"gamma.affinity_test" |
||||
"gamma.affinity_session_drain_test" |
||||
"gamma.csm_observability_test" |
||||
"app_net_ssa_test" |
||||
) |
||||
for test in "${test_suites[@]}"; do |
||||
run_test $test || (( ++failed_tests )) |
||||
done |
||||
echo "Failed test suites: ${failed_tests}" |
||||
} |
||||
|
||||
main "$@" |
||||
@ -0,0 +1,34 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2024 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. |
||||
set -eo pipefail |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR. |
||||
# Called from psm_interop_kokoro_lib.sh. |
||||
# |
||||
# Globals: |
||||
# SRC_DIR: Absolute path to the source repo on Kokoro VM |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# DOCKER_REGISTRY: Docker registry to push to |
||||
# Outputs: |
||||
# Writes the output of docker image build stdout, stderr |
||||
####################################### |
||||
psm::lang::build_docker_images() { |
||||
local client_dockerfile="tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_client" |
||||
local server_dockerfile="tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_server" |
||||
psm::build::docker_images_generic "${client_dockerfile}" "${server_dockerfile}" |
||||
} |
||||
@ -0,0 +1,34 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2024 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. |
||||
set -eo pipefail |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR. |
||||
# Called from psm_interop_kokoro_lib.sh. |
||||
# |
||||
# Globals: |
||||
# SRC_DIR: Absolute path to the source repo on Kokoro VM |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# DOCKER_REGISTRY: Docker registry to push to |
||||
# Outputs: |
||||
# Writes the output of docker image build stdout, stderr |
||||
####################################### |
||||
psm::lang::build_docker_images() { |
||||
local client_dockerfile="src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.client" |
||||
local server_dockerfile="src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.server" |
||||
psm::build::docker_images_generic "${client_dockerfile}" "${server_dockerfile}" |
||||
} |
||||
@ -0,0 +1,32 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2024 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. |
||||
set -eo pipefail |
||||
|
||||
# Used locally. |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
|
||||
psm::lang::source_install_lib() { |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
local install_lib |
||||
# Download to a tmp file. |
||||
install_lib="$(mktemp -d)/psm_interop_kokoro_lib.sh" |
||||
curl -s --retry-connrefused --retry 5 -o "${install_lib}" "${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
# Checksum. |
||||
if command -v sha256sum &> /dev/null; then |
||||
echo "Install script checksum:" |
||||
sha256sum "${install_lib}" |
||||
fi |
||||
source "${install_lib}" |
||||
} |
||||
@ -0,0 +1,24 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2024 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. |
||||
set -eo pipefail |
||||
|
||||
# Input parameters to psm:: methods of the install script. |
||||
readonly GRPC_LANGUAGE="cpp" |
||||
readonly BUILD_SCRIPT_DIR="$(dirname "$0")" |
||||
|
||||
source "${BUILD_SCRIPT_DIR}/psm-interop-install-lib.sh" |
||||
psm::lang::source_install_lib |
||||
source "${BUILD_SCRIPT_DIR}/psm-interop-build-${GRPC_LANGUAGE}.sh" |
||||
psm::run "${PSM_TEST_SUITE}" |
||||
@ -0,0 +1,24 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2024 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. |
||||
set -eo pipefail |
||||
|
||||
# Input parameters to psm:: methods of the install script. |
||||
readonly GRPC_LANGUAGE="python" |
||||
readonly BUILD_SCRIPT_DIR="$(dirname "$0")" |
||||
|
||||
source "${BUILD_SCRIPT_DIR}/psm-interop-install-lib.sh" |
||||
psm::lang::source_install_lib |
||||
source "${BUILD_SCRIPT_DIR}/psm-interop-build-${GRPC_LANGUAGE}.sh" |
||||
psm::run "${PSM_TEST_SUITE}" |
||||
@ -1,185 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2021 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test server/client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly SERVER_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/python-server" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/python-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
readonly LANGUAGE_NAME="Python" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test, f.e. v1.42.x, master |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building ${LANGUAGE_NAME} xDS interop test app Docker images" |
||||
|
||||
pushd "${SRC_DIR}" |
||||
docker build \ |
||||
-f src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.client \ |
||||
-t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
. |
||||
|
||||
docker build \ |
||||
-f src/python/grpcio_tests/tests_py3_only/interop/Dockerfile.server \ |
||||
-t "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
. |
||||
|
||||
popd |
||||
|
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
|
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
docker push "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" |
||||
|
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
tag_and_push_docker_image "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${server_tags:-Server image not found}" |
||||
|
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping ${LANGUAGE_NAME} test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--nocheck_local_certs \ |
||||
--force_cleanup \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
set +x |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test driver from the master branch. |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_SECURITY |
||||
|
||||
set -x |
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
local failed_tests=0 |
||||
test_suites=("baseline_test" "security_test" "authz_test") |
||||
for test in "${test_suites[@]}"; do |
||||
run_test $test || (( ++failed_tests )) |
||||
done |
||||
echo "Failed test suites: ${failed_tests}" |
||||
} |
||||
|
||||
main "$@" |
||||
@ -1,169 +0,0 @@ |
||||
#!/usr/bin/env bash |
||||
# Copyright 2021 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. |
||||
|
||||
set -eo pipefail |
||||
|
||||
# Constants |
||||
readonly GITHUB_REPOSITORY_NAME="grpc" |
||||
readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh" |
||||
## xDS test server/client Docker images |
||||
readonly DOCKER_REGISTRY="us-docker.pkg.dev" |
||||
readonly SERVER_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/cpp-server" |
||||
readonly CLIENT_IMAGE_NAME="us-docker.pkg.dev/grpc-testing/psm-interop/cpp-client" |
||||
readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}" |
||||
readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing" |
||||
|
||||
####################################### |
||||
# Builds test app Docker images and pushes them to GCR |
||||
# Globals: |
||||
# BUILD_APP_PATH |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test, f.e. v1.42.x, master |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of `gcloud builds submit` to stdout, stderr |
||||
####################################### |
||||
build_test_app_docker_images() { |
||||
echo "Building C++ xDS interop test app Docker images" |
||||
docker build -f "${SRC_DIR}/tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_client" -t "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" "${SRC_DIR}" |
||||
docker build -f "${SRC_DIR}/tools/dockerfile/interoptest/grpc_interop_cxx_xds/Dockerfile.xds_server" -t "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" "${SRC_DIR}" |
||||
gcloud -q auth configure-docker "${DOCKER_REGISTRY}" |
||||
docker push "${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" |
||||
docker push "${SERVER_IMAGE_NAME}:${GIT_COMMIT}" |
||||
if is_version_branch "${TESTING_VERSION}"; then |
||||
tag_and_push_docker_image "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
tag_and_push_docker_image "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" "${TESTING_VERSION}" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Builds test app and its docker images unless they already exist |
||||
# Globals: |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# FORCE_IMAGE_BUILD |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output to stdout, stderr |
||||
####################################### |
||||
build_docker_images_if_needed() { |
||||
# Check if images already exist |
||||
server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${server_tags:-Server image not found}" |
||||
|
||||
client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")" |
||||
printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}" |
||||
echo "${client_tags:-Client image not found}" |
||||
|
||||
# Build if any of the images are missing, or FORCE_IMAGE_BUILD=1 |
||||
if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then |
||||
build_test_app_docker_images |
||||
else |
||||
echo "Skipping C++ test app build" |
||||
fi |
||||
} |
||||
|
||||
####################################### |
||||
# Executes the test case |
||||
# Globals: |
||||
# TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile |
||||
# KUBE_CONTEXT: The name of kubectl context with GKE cluster access |
||||
# TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report |
||||
# SERVER_IMAGE_NAME: Test server Docker image name |
||||
# CLIENT_IMAGE_NAME: Test client Docker image name |
||||
# GIT_COMMIT: SHA-1 of git commit being built |
||||
# TESTING_VERSION: version branch under test: used by the framework to determine the supported PSM |
||||
# features. |
||||
# Arguments: |
||||
# Test case name |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
# Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml |
||||
####################################### |
||||
run_test() { |
||||
# Test driver usage: |
||||
# https://github.com/grpc/psm-interop#basic-usage |
||||
local test_name="${1:?Usage: run_test test_name}" |
||||
local out_dir="${TEST_XML_OUTPUT_DIR}/${test_name}" |
||||
mkdir -pv "${out_dir}" |
||||
set -x |
||||
python3 -m "tests.${test_name}" \ |
||||
--flagfile="${TEST_DRIVER_FLAGFILE}" \ |
||||
--kube_context="${KUBE_CONTEXT}" \ |
||||
--server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \ |
||||
--testing_version="${TESTING_VERSION}" \ |
||||
--nocheck_local_certs \ |
||||
--force_cleanup \ |
||||
--collect_app_logs \ |
||||
--log_dir="${out_dir}" \ |
||||
--xml_output_file="${out_dir}/sponge_log.xml" \ |
||||
|& tee "${out_dir}/sponge_log.log" |
||||
} |
||||
|
||||
####################################### |
||||
# Main function: provision software necessary to execute tests, and run them |
||||
# Globals: |
||||
# KOKORO_ARTIFACTS_DIR |
||||
# GITHUB_REPOSITORY_NAME |
||||
# SRC_DIR: Populated with absolute path to the source repo |
||||
# TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing |
||||
# the test driver |
||||
# TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code |
||||
# TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile |
||||
# TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report |
||||
# GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build |
||||
# GIT_COMMIT: Populated with the SHA-1 of git commit being built |
||||
# GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built |
||||
# KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access |
||||
# Arguments: |
||||
# None |
||||
# Outputs: |
||||
# Writes the output of test execution to stdout, stderr |
||||
####################################### |
||||
main() { |
||||
local script_dir |
||||
script_dir="$(dirname "$0")" |
||||
|
||||
# Source the test driver from the master branch. |
||||
echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}" |
||||
source /dev/stdin <<< "$(curl -s "${TEST_DRIVER_INSTALL_SCRIPT_URL}")" |
||||
|
||||
activate_gke_cluster GKE_CLUSTER_PSM_SECURITY |
||||
|
||||
set -x |
||||
if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then |
||||
kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}" |
||||
else |
||||
local_setup_test_driver "${script_dir}" |
||||
fi |
||||
build_docker_images_if_needed |
||||
# Run tests |
||||
cd "${TEST_DRIVER_FULL_DIR}" |
||||
local failed_tests=0 |
||||
test_suites=("baseline_test" "security_test" "authz_test") |
||||
for test in "${test_suites[@]}"; do |
||||
run_test $test || (( ++failed_tests )) |
||||
done |
||||
echo "Failed test suites: ${failed_tests}" |
||||
} |
||||
|
||||
main "$@" |
||||
Loading…
Reference in new issue