chore: POC for PQC in gax-grpc

[diegomarquezp]

No description provided.

[diegomarquezp]

this must be evaluated

[gemini-code-assist]

Code Review

This pull request introduces a new pqc-test module to validate Post-Quantum Cryptography (PQC) transport enforcement in the Google Cloud Java SDK, including a test server (PqcTestServer) and connectivity tests (PqcConnectivityTest). It also updates InstantiatingGrpcChannelProvider to configure PQC on gRPC channels. The review feedback highlights two resource leak opportunities: first, a potential leak of the background server process in PqcConnectivityTest if initialization fails before @AfterAll can run; second, a potential leak of partially started servers in PqcTestServer.main if startup fails, along with a recommendation to avoid swallowing InterruptedException.

[gemini-code-assist]

If an exception or timeout occurs during the initialization phase in @BeforeAll (for example, if the server fails to print the expected ports within 10 seconds), the background serverProcess will be left running. Since @AfterAll is not executed when @BeforeAll fails in JUnit 5, this results in a leaked background process. Wrap the initialization logic in a try-catch block and forcibly destroy the process if setup fails.

    try {
      // Read server's stdout to dynamically capture the allocated ephemeral ports
      java.io.BufferedReader reader =
          new java.io.BufferedReader(
              new java.io.InputStreamReader(
                  serverProcess.getInputStream(), java.nio.charset.StandardCharsets.UTF_8));

      String line;
      boolean grpcPqcFound = false;
      boolean grpcClassicalFound = false;

      // Wait for the server process to output its HTTP and gRPC ports
      long startTime = System.currentTimeMillis();
      while ((line = reader.readLine()) != null) {
        System.out.println("[SERVER-OUT] " + line);
        if (line.startsWith("GRPC_PQC_PORT: ")) {
          grpcPqcPort = Integer.parseInt(line.substring(15).trim());
          grpcPqcFound = true;
        } else if (line.startsWith("GRPC_CLASSICAL_PORT: ")) {
          grpcClassicalPort = Integer.parseInt(line.substring(21).trim());
          grpcClassicalFound = true;
        }

        if (grpcPqcFound && grpcClassicalFound) {
          break;
        }

        // Ephemeral port detection timeout (10 seconds) to fail-fast on server startup
        // errors
        if (System.currentTimeMillis() - startTime > 10000) {
          throw new RuntimeException(
              "Timeout waiting for PqcTestServer ephemeral ports to be printed!");
        }
      }

      if (!grpcPqcFound || !grpcClassicalFound) {
        throw new RuntimeException("PqcTestServer failed to initialize ephemeral ports!");
      }

      // Start a background thread to continuously drain the server's stdout
      Thread drainThread =
          new Thread(
              () -> {
                try {
                  String l;
                  while ((l = reader.readLine()) != null) {
                    System.out.println("[SERVER-OUT] " + l);
                  }
                } catch (java.io.IOException e) {
                  // Ignore stream closed
                }
              });
      drainThread.setDaemon(true);
      drainThread.start();
    } catch (Throwable t) {
      serverProcess.destroyForcibly();
      throw t;
    }

[gemini-code-assist]

If server.start() throws an exception during startup (e.g., due to a port binding failure or keystore issue), the exception is thrown before entering the try-finally block. As a result, server.stop() is never called, leaving any partially started HTTP or gRPC servers running. Wrap the entire startup and execution in a single try-finally block to ensure server.stop() is always executed. Additionally, make sure that InterruptedException is not swallowed when catching exceptions; restore the thread's interrupted status appropriately.

  public static void main(String[] args) throws Exception {
    PqcTestServer server = new PqcTestServer();
    try {
      server.start();

      System.out.println("HTTP_PQC_PORT: " + server.getHttpPqcPort());
      System.out.println("HTTP_CLASSICAL_PORT: " + server.getHttpClassicalPort());
      System.out.println("GRPC_PQC_PORT: " + server.getGrpcPqcPort());
      System.out.println("GRPC_CLASSICAL_PORT: " + server.getGrpcClassicalPort());
      System.out.flush();

      while (System.in.read() != -1) {
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      System.err.println("Server interrupted: " + e.getMessage());
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      server.stop();
    }
  }

References

1. In Java, do not swallow InterruptedException. When catching it, restore the thread's interrupted status by calling Thread.currentThread().interrupt() and handle the interruption appropriately, such as by throwing a relevant exception (e.g., SpannerException) to signal that the operation cannot proceed.