Cloned QuicTestServer

bazel/kotlin_lib.bzl

@@ -46,12 +46,13 @@ def envoy_mobile_kt_library(name, visibility = None, srcs = [], deps = []):
 #     name = "java_jni_lib.jnilib",
 #     native_dep = "libjava_jni_lib.so",
 # )
-def envoy_mobile_so_to_jni_lib(name, native_dep):
+def envoy_mobile_so_to_jni_lib(name, native_dep, testonly = False):
     lib_name = native_lib_name(native_dep)
     output = "{}.jnilib".format(lib_name)
 
     return native.genrule(
         name = name,
+        testonly = testonly,
         outs = [output],
         srcs = [native_dep],
         cmd = """

bazel/kotlin_test.bzl

@@ -74,6 +74,7 @@ def envoy_mobile_android_test(name, srcs, deps = [], native_deps = [], repositor
         visibility = ["//visibility:public"],
         data = native_deps,
         exports = deps,
+        testonly = True,
     )
 
     native.android_local_test(

test/common/integration/BUILD

@@ -1,4 +1,4 @@
-load("@envoy//bazel:envoy_build_system.bzl", "envoy_cc_test", "envoy_package")
+load("@envoy//bazel:envoy_build_system.bzl", "envoy_cc_test", "envoy_cc_test_library", "envoy_package")
 
 licenses(["notice"])  # Apache 2
 
@@ -21,5 +21,35 @@ envoy_cc_test(
         "@envoy//test/common/http:common_lib",
         "@envoy//test/integration:http_integration_lib",
         "@envoy//test/server:utility_lib",
+        "@envoy//test/test_common:environment_lib",
     ],
 )
+
+# interface libs for quic test server's jni implementation
+envoy_cc_test_library(
+    name = "quic_test_server_interface_lib",
+    srcs = [
+        "quic_test_server.cc",
+        "quic_test_server_interface.cc",
+    ],
+    hdrs = [
+        "quic_test_server.h",
+        "quic_test_server_interface.h",
+    ],
+    data = [
+        "@envoy//test/config/integration/certs",
+    ],
+    repository = "@envoy",
+    deps = [
+        "@envoy//source/exe:process_wide_lib",
+        "@envoy//test/config:utility_lib",
+        "@envoy//test/integration:autonomous_upstream_lib",
+        "@envoy//test/mocks/server:transport_socket_factory_context_mocks",
+        "@envoy//test/test_common:environment_lib",
+    ] + select({
+        "@envoy//bazel:disable_signal_trace": [],
+        "//conditions:default": [
+            "@envoy//source/common/signal:sigaction_lib",
+        ],
+    }),
+)

test/common/integration/quic_test_server.cc

@@ -0,0 +1,68 @@
+#include "quic_test_server.h"
+
+#include "test/test_common/environment.h"
+
+namespace Envoy {
+
+Network::TransportSocketFactoryPtr QuicTestServer::createUpstreamTlsContext(
+    testing::NiceMock<Server::Configuration::MockTransportSocketFactoryContext>& factory_context) {
+  envoy::extensions::transport_sockets::tls::v3::DownstreamTlsContext tls_context;
+  Extensions::TransportSockets::Tls::ContextManagerImpl context_manager{time_system_};
+  const std::string yaml = absl::StrFormat(
+      R"EOF(
+common_tls_context:
+  alpn_protocols: h3
+  tls_certificates:
+  - certificate_chain:
+      filename: ../envoy/test/config/integration/certs/upstreamcert.pem
+    private_key:
+      filename: ../envoy/test/config/integration/certs/upstreamkey.pem
+)EOF");
+  TestUtility::loadFromYaml(yaml, tls_context);
+  envoy::extensions::transport_sockets::quic::v3::QuicDownstreamTransport quic_config;
+  quic_config.mutable_downstream_tls_context()->MergeFrom(tls_context);
+
+  std::vector<std::string> server_names;
+  auto& config_factory = Config::Utility::getAndCheckFactoryByName<
+      Server::Configuration::DownstreamTransportSocketConfigFactory>(
+      "envoy.transport_sockets.quic");
+
+  return config_factory.createTransportSocketFactory(quic_config, factory_context, server_names);
+}
+
+QuicTestServer::QuicTestServer()
+    : api_(Api::createApiForTest(stats_store_, time_system_)),
+      version_(Network::Address::IpVersion::v4), upstream_config_(time_system_), port_(0) {
+  ON_CALL(factory_context_, api()).WillByDefault(testing::ReturnRef(*api_));
+  ON_CALL(factory_context_, scope()).WillByDefault(testing::ReturnRef(stats_store_));
+  upstream_config_.udp_fake_upstream_ = FakeUpstreamConfig::UdpConfig();
+}
+
+void QuicTestServer::startQuicTestServer() {
+  ASSERT(!upstream_);
+  // pre-setup: see https://github.com/envoyproxy/envoy/blob/main/test/test_runner.cc
+  Logger::Context logging_state(spdlog::level::level_enum::err,
+                                "[%Y-%m-%d %T.%e][%t][%l][%n] [%g:%#] %v", lock, false, false);
+  // end pre-setup
+
+  upstream_config_.upstream_protocol_ = Http::CodecType::HTTP3;
+
+  Network::TransportSocketFactoryPtr factory = createUpstreamTlsContext(factory_context_);
+
+  upstream_ = std::make_unique<AutonomousUpstream>(std::move(factory), port_, version_,
+                                                   upstream_config_, false);
+
+  // see upstream address
+  ENVOY_LOG_MISC(debug, "Upstream now listening on {}", upstream_->localAddress()->asString());
+}
+
+void QuicTestServer::shutdownQuicTestServer() {
+  ASSERT(upstream_);
+  upstream_.reset();
+}
+
+int QuicTestServer::getServerPort() {
+  ASSERT(upstream_);
+  return upstream_->localAddress()->ip()->port();
+}
+} // namespace Envoy

test/common/integration/quic_test_server.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "source/extensions/transport_sockets/tls/ssl_socket.h"
+
+// test_runner setups
+#include "source/exe/process_wide.h"
+
+#include "envoy/extensions/transport_sockets/quic/v3/quic_transport.pb.h"
+#include "test/mocks/server/transport_socket_factory_context.h"
+#include "test/integration/autonomous_upstream.h"
+#include "test/config/utility.h"
+
+namespace Envoy {
+class QuicTestServer {
+private:
+  testing::NiceMock<Server::Configuration::MockTransportSocketFactoryContext> factory_context_;
+  Stats::IsolatedStoreImpl stats_store_;
+  Event::GlobalTimeSystem time_system_;
+  Api::ApiPtr api_;
+  Network::Address::IpVersion version_;
+  std::unique_ptr<AutonomousUpstream> upstream_;
+  FakeUpstreamConfig upstream_config_;
+  int port_;
+  Thread::SkipAsserts skip_asserts_;
+  ProcessWide process_wide;
+  Thread::MutexBasicLockable lock;
+
+  Network::TransportSocketFactoryPtr createUpstreamTlsContext(
+      testing::NiceMock<Server::Configuration::MockTransportSocketFactoryContext>&);
+
+public:
+  QuicTestServer();
+
+  /**
+   * Starts the server. Can only have one server active per JVM. This is blocking until the port can
+   * start accepting requests.
+   */
+  void startQuicTestServer();
+
+  /**
+   * Shutdowns the server. Can be restarted later. This is blocking until the server has freed all
+   * resources.
+   */
+  void shutdownQuicTestServer();
+
+  /**
+   * Returns the port that got attributed. Can only be called once the server has been started.
+   */
+  int getServerPort();
+};
+
+} // namespace Envoy

test/common/integration/quic_test_server_interface.cc

@@ -0,0 +1,34 @@
+#include "test/common/integration/quic_test_server_interface.h"
+
+// NOLINT(namespace-envoy)
+
+static std::shared_ptr<Envoy::QuicTestServer> strong_quic_test_server_;
+static std::weak_ptr<Envoy::QuicTestServer> weak_quic_test_server_;
+
+static std::shared_ptr<Envoy::QuicTestServer> quic_test_server() {
+  return weak_quic_test_server_.lock();
+}
+
+void start_server() {
+  strong_quic_test_server_ = std::make_shared<Envoy::QuicTestServer>();
+  weak_quic_test_server_ = strong_quic_test_server_;
+
+  if (auto e = quic_test_server()) {
+    e->startQuicTestServer();
+  }
+}
+
+void shutdown_server() {
+  // Reset the primary handle to the test_server,
+  // but retain it long enough to synchronously shutdown.
+  auto e = strong_quic_test_server_;
+  strong_quic_test_server_.reset();
+  e->shutdownQuicTestServer();
+}
+
+int get_server_port() {
+  if (auto e = quic_test_server()) {
+    return e->getServerPort();
+  }
+  return -1; // failure
+}

test/common/integration/quic_test_server_interface.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "test/common/integration/quic_test_server.h"
+
+// NOLINT(namespace-envoy)
+
+#ifdef __cplusplus
+extern "C" { // functions
+#endif
+
+/**
+ * Starts the server. Can only have one server active per JVM. This is blocking until the port can
+ * start accepting requests.
+ */
+void start_server();
+
+/**
+ * Shutdowns the server. Can be restarted later. This is blocking until the server has freed all
+ * resources.
+ */
+void shutdown_server();
+
+/**
+ * Returns the port that got attributed. Can only be called once the server has been started.
+ */
+int get_server_port();
+
+#ifdef __cplusplus
+} // functions
+#endif

test/common/jni/BUILD

@@ -0,0 +1,32 @@
+load("@envoy//bazel:envoy_build_system.bzl", "envoy_package")
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+load("//bazel:kotlin_lib.bzl", "envoy_mobile_so_to_jni_lib")
+
+licenses(["notice"])  # Apache 2
+
+envoy_package()
+
+# OS X binary (.jnilib) for Quic Test Server
+envoy_mobile_so_to_jni_lib(
+    name = "libquic_test_server_jni.jnilib",
+    testonly = True,
+    native_dep = "libquic_test_server_jni.so",
+)
+
+# Binary for Quic Test Server
+cc_binary(
+    name = "libquic_test_server_jni.so",
+    testonly = True,
+    srcs = [
+        "quic_test_server_jni_interface.cc",
+        "//library/common/jni:android_test_jni_interface.cc",
+        "//library/common/jni:jni_interface.cc",
+        "@local_jdk//:jni_header",
+    ],
+    copts = ["-std=c++17"],
+    linkshared = True,
+    deps = [
+        "//library/common/jni:base_java_jni_lib",
+        "//test/common/integration:quic_test_server_interface_lib",
+    ],
+)

test/common/jni/quic_test_server_jni_interface.cc

@@ -0,0 +1,32 @@
+#include <jni.h>
+
+#include "test/common/integration/quic_test_server_interface.h"
+
+#include "library/common/jni/jni_support.h"
+#include "library/common/jni/jni_utility.h"
+#include "library/common/jni/jni_version.h"
+
+// NOLINT(namespace-envoy)
+
+// Quic Test ServerJniLibrary
+
+extern "C" JNIEXPORT void JNICALL
+Java_io_envoyproxy_envoymobile_engine_testing_QuicTestServer_nativeStartQuicTestServer(
+    JNIEnv* env, jclass clazz) {
+  jni_log("[QTS]", "starting server");
+  start_server();
+}
+
+extern "C" JNIEXPORT jint JNICALL
+Java_io_envoyproxy_envoymobile_engine_testing_QuicTestServer_nativeGetServerPort(JNIEnv* env,
+                                                                                 jclass clazz) {
+  jni_log("[QTS]", "getting server port");
+  return get_server_port();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_io_envoyproxy_envoymobile_engine_testing_QuicTestServer_nativeShutdownQuicTestServer(
+    JNIEnv* env, jclass clazz) {
+  jni_log("[QTS]", "shutting down server");
+  shutdown_server();
+}

test/java/io/envoyproxy/envoymobile/engine/testing/BUILD

@@ -0,0 +1,35 @@
+load("@envoy//bazel:envoy_build_system.bzl", "envoy_package")
+load("@envoy_mobile//bazel:kotlin_test.bzl", "envoy_mobile_android_test")
+
+licenses(["notice"])  # Apache 2
+
+envoy_package()
+
+android_library(
+    name = "testing",
+    testonly = True,
+    srcs = [
+        "QuicTestServer.java",
+    ],
+    visibility = ["//test:__subpackages__"],
+)
+
+envoy_mobile_android_test(
+    name = "quic_test_server_test",
+    srcs = [
+        "QuicTestServerTest.java",
+    ],
+    exec_properties = {
+        # TODO(lfpino): Remove this once the sandboxNetwork=off works for ipv4 localhost addresses.
+        "sandboxNetwork": "standard",
+    },
+    library_path = "test/common/jni",
+    native_deps = [
+        "//test/common/jni:libquic_test_server_jni.so",
+        "//test/common/jni:libquic_test_server_jni.jnilib",
+    ],
+    deps = [
+        ":testing",
+        "//library/kotlin/io/envoyproxy/envoymobile:envoy_lib",
+    ],
+)