Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): replace the fabric8 kubernetes client with a plain REST client (#2919)
Priamo Germosen97ce09f22a8d
diff --git a/pom.xml b/pom.xmlindex 26fe874289..2553720e32 100644--- a/pom.xml+++ b/pom.xml@@ -147,12 +147,6 @@<artifactId>snappy-java</artifactId></dependency>- <!-- Kubernetes client for the Lambda kubernetes executor -->- <dependency>- <groupId>io.quarkus</groupId>- <artifactId>quarkus-kubernetes-client</artifactId>- </dependency>-<!-- Docker client for Lambda container lifecycle management --><dependency><groupId>com.github.docker-java</groupId>@@ -310,6 +304,15 @@<artifactId>kubernetes-server-mock</artifactId><scope>test</scope></dependency>+ <!-- kubernetes-server-mock declares this as optional, so it must be pulled in+ explicitly for the kubernetes Lambda executor's tests, which use it as a fake+ API server (never shipped: KubernetesApiClient is a plain HTTP client, not a+ Kubernetes SDK, see issue #2914). -->+ <dependency>+ <groupId>io.fabric8</groupId>+ <artifactId>kubernetes-client</artifactId>+ <scope>test</scope>+ </dependency><dependency><groupId>org.assertj</groupId><artifactId>assertj-core</artifactId>diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClient.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClient.javanew file mode 100644index 0000000000..e55a9408ae--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClient.java@@ -0,0 +1,557 @@+package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.JsonNodeFactory;+import com.fasterxml.jackson.databind.node.NullNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;+import jakarta.enterprise.context.ApplicationScoped;++import javax.net.ssl.KeyManager;+import javax.net.ssl.KeyManagerFactory;+import javax.net.ssl.SSLContext;+import javax.net.ssl.SSLParameters;+import javax.net.ssl.TrustManager;+import javax.net.ssl.TrustManagerFactory;+import javax.net.ssl.X509TrustManager;+import java.io.ByteArrayInputStream;+import java.io.IOException;+import java.io.InputStream;+import java.io.UncheckedIOException;+import java.net.URI;+import java.net.URLEncoder;+import java.net.http.HttpClient;+import java.net.http.HttpRequest;+import java.net.http.HttpResponse;+import java.nio.charset.StandardCharsets;+import java.nio.file.Files;+import java.nio.file.Path;+import java.security.GeneralSecurityException;+import java.security.KeyFactory;+import java.security.KeyStore;+import java.security.PrivateKey;+import java.security.cert.Certificate;+import java.security.cert.CertificateFactory;+import java.security.cert.X509Certificate;+import java.security.spec.PKCS8EncodedKeySpec;+import java.time.Duration;+import java.util.ArrayList;+import java.util.Base64;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.Optional;+import java.util.concurrent.TimeUnit;+import java.util.function.Predicate;+import java.util.function.Supplier;+import java.util.regex.Pattern;+import java.util.stream.Collectors;++/**+ * Thin REST client for the subset of the Kubernetes API the Lambda kubernetes executor needs:+ * create/get/list/delete pods, create-or-update a ConfigMap, and stream a pod's logs. Uses the+ * JDK {@link HttpClient} (as the rest of Floci does for outbound calls, e.g.+ * {@code FlinkRestClient}) instead of a Kubernetes SDK, so the executor adds no dependency+ * beyond what Floci already ships: see issue #2914, where the fabric8 client (unconditionally+ * on the classpath through {@code quarkus-kubernetes-client}) was reachable in every native+ * image regardless of whether the kubernetes executor was ever used.+ *+ * <p>Connection resolution mirrors kubectl's, minus exec/auth-provider credential plugins:+ * <ul>+ * <li>In-cluster: the mounted service account token and CA cert. The token is re-read on+ * every request since projected service account tokens rotate.</li>+ * <li>Otherwise, a kubeconfig ({@code $KUBECONFIG}, first entry if multiple; else+ * {@code ~/.kube/config}), current-context only, with a static bearer token or a+ * client-certificate/client-key credential (PKCS#8 only). {@code insecure-skip-tls-verify}+ * is honored (skips both chain and hostname validation, matching kubectl), which covers+ * most kind/minikube configs. exec/auth-provider plugins (e.g. {@code aws eks get-token})+ * are not supported and fail with a clear error.</li>+ * </ul>+ */+@ApplicationScoped+public class KubernetesApiClient {++ private static final Path SERVICE_ACCOUNT_DIR = Path.of("/var/run/secrets/kubernetes.io/serviceaccount");+ private static final Path SERVICE_ACCOUNT_TOKEN = SERVICE_ACCOUNT_DIR.resolve("token");+ private static final Path SERVICE_ACCOUNT_CA = SERVICE_ACCOUNT_DIR.resolve("ca.crt");+ private static final long POLL_INTERVAL_MS = 500;++ /** Backs kubeconfig's {@code insecure-skip-tls-verify: true} (kind/minikube dev configs). */+ private static final X509TrustManager INSECURE_TRUST_MANAGER = new X509TrustManager() {+ @Override+ public void checkClientTrusted(X509Certificate[] chain, String authType) {+ }++ @Override+ public void checkServerTrusted(X509Certificate[] chain, String authType) {+ }++ @Override+ public X509Certificate[] getAcceptedIssuers() {+ return new X509Certificate[0];+ }+ };++ private final ObjectMapper mapper = new ObjectMapper();+ private final Object lock = new Object();+ private volatile boolean initialized;+ private URI baseUri;+ private HttpClient http;+ private Supplier<String> tokenSupplier;++ public KubernetesApiClient() {+ }++ /** Test-only: points the client at an explicit, already-configured endpoint. */+ KubernetesApiClient(URI baseUri, HttpClient http, Supplier<String> tokenSupplier) {+ this.baseUri = baseUri;+ this.http = http;+ this.tokenSupplier = tokenSupplier;+ this.initialized = true;+ }++ /** Resolves the connection (in-cluster or kubeconfig) now, so bad config fails fast. */+ public void initialize() {+ ensureInitialized();+ }++ public JsonNode createPod(String namespace, JsonNode pod) {+ return send("POST", podsPath(namespace), pod, 201);+ }++ public Optional<JsonNode> getPod(String namespace, String name) {+ return getOptional(podPath(namespace, name));+ }++ public List<JsonNode> listPods(String namespace, Map<String, String> labelSelector) {+ var selector = labelSelector.entrySet().stream()+ .map(e -> e.getKey() + "=" + e.getValue())+ .collect(Collectors.joining(","));+ var path = podsPath(namespace) + "?labelSelector=" + URLEncoder.encode(selector, StandardCharsets.UTF_8);+ var items = new ArrayList<JsonNode>();+ send("GET", path, null, 200).path("items").forEach(items::add);+ return items;+ }++ /** No-op if the pod is already gone. */+ public void deletePod(String namespace, String name) {+ try {+ send("DELETE", podPath(namespace, name) + "?gracePeriodSeconds=0", null, 200);+ } catch (KubernetesApiException e) {+ if (e.getStatusCode() != 404) {+ throw e;+ }+ }+ }++ /**+ * Polls the pod every {@value #POLL_INTERVAL_MS}ms (a plain {@code GET}, not a watch) until+ * {@code condition} is true, passing {@code null} once the pod no longer exists. Returns the+ * value that satisfied the condition.+ *+ * @throws IllegalStateException if {@code condition} is not satisfied within {@code timeoutSeconds}+ */+ public JsonNode waitForPod(String namespace, String name, Predicate<JsonNode> condition, int timeoutSeconds) {+ var deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(timeoutSeconds);+ while (true) {+ var pod = getPod(namespace, name).orElse(null);+ if (condition.test(pod)) {+ return pod;+ }+ if (System.nanoTime() >= deadline) {+ throw new IllegalStateException("timed out after " + timeoutSeconds + "s waiting for pod " + name);+ }+ try {+ Thread.sleep(POLL_INTERVAL_MS);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("interrupted while waiting for pod " + name, e);+ }+ }+ }++ /**+ * Creates the ConfigMap, or replaces its data in place if one by that name already exists.+ * Never deletes, matching what {@code ensureCaConfigMap} needs: publish-once, refresh-on-restart.+ */+ public void createOrUpdateConfigMap(String namespace, ObjectNode configMap) {+ try {+ send("POST", configMapsPath(namespace), configMap, 201);+ } catch (KubernetesApiException e) {+ if (e.getStatusCode() != 409) {+ throw e;+ }+ var name = configMap.path("metadata").path("name").asText();+ var existing = getOptional(configMapPath(namespace, name)).orElseThrow(() -> e);+ ((ObjectNode) configMap.path("metadata"))+ .put("resourceVersion", existing.path("metadata").path("resourceVersion").asText());+ send("PUT", configMapPath(namespace, name), configMap, 200);+ }+ }++ /**+ * Opens a following log stream ({@code GET .../log?follow=true}), same shape as+ * {@code kubectl logs -f}. The caller reads and closes the stream; closing it ends the+ * underlying connection and the kubelet stops the follow.+ */+ public InputStream openPodLogStream(String namespace, String podName, String containerName) {+ ensureInitialized();+ var path = podPath(namespace, podName) + "/log?container="+ + URLEncoder.encode(containerName, StandardCharsets.UTF_8) + "&follow=true";+ try {+ var response = http.send(requestBuilder(path).GET().build(), HttpResponse.BodyHandlers.ofInputStream());+ if (response.statusCode() != 200) {+ var body = new String(response.body().readAllBytes(), StandardCharsets.UTF_8);+ throw new KubernetesApiException("GET", path, response.statusCode(), body);+ }+ return response.body();+ } catch (IOException e) {+ throw new UncheckedIOException("Could not open log stream for pod " + podName, e);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("Interrupted opening log stream for pod " + podName, e);+ }+ }++ private JsonNode send(String method, String path, JsonNode body, int expectedStatus) {+ ensureInitialized();+ try {+ var builder = requestBuilder(path);+ if (body != null) {+ builder.header("Content-Type", "application/json")+ .method(method, HttpRequest.BodyPublishers.ofByteArray(mapper.writeValueAsBytes(body)));+ } else {+ builder.method(method, HttpRequest.BodyPublishers.noBody());+ }+ var response = http.send(builder.build(), HttpResponse.BodyHandlers.ofByteArray());+ if (response.statusCode() != expectedStatus) {+ throw new KubernetesApiException(method, path, response.statusCode(),+ new String(response.body(), StandardCharsets.UTF_8));+ }+ return response.body().length == 0 ? NullNode.getInstance() : mapper.readTree(response.body());+ } catch (IOException e) {+ throw new UncheckedIOException("Kubernetes API " + method + " " + path + " failed: " + e.getMessage(), e);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("Interrupted calling Kubernetes API " + method + " " + path, e);+ }+ }++ private Optional<JsonNode> getOptional(String path) {+ ensureInitialized();+ try {+ var response = http.send(requestBuilder(path).GET().build(), HttpResponse.BodyHandlers.ofByteArray());+ if (response.statusCode() == 404) {+ return Optional.empty();+ }+ if (response.statusCode() != 200) {+ throw new KubernetesApiException("GET", path, response.statusCode(),+ new String(response.body(), StandardCharsets.UTF_8));+ }+ return Optional.of(mapper.readTree(response.body()));+ } catch (IOException e) {+ throw new UncheckedIOException("Kubernetes API GET " + path + " failed: " + e.getMessage(), e);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("Interrupted calling Kubernetes API GET " + path, e);+ }+ }++ private HttpRequest.Builder requestBuilder(String path) {+ var builder = HttpRequest.newBuilder(baseUri.resolve(path)).timeout(Duration.ofSeconds(30));+ if (tokenSupplier != null) {+ builder.header("Authorization", "Bearer " + tokenSupplier.get());+ }+ return builder;+ }++ private void ensureInitialized() {+ if (initialized) {+ return;+ }+ synchronized (lock) {+ if (initialized) {+ return;+ }+ if (isRunningInCluster()) {+ resolveInCluster();+ } else {+ resolveFromKubeconfig(kubeconfigPath());+ }+ initialized = true;+ }+ }++ private static boolean isRunningInCluster() {+ return System.getenv("KUBERNETES_SERVICE_HOST") != null || Files.exists(SERVICE_ACCOUNT_TOKEN);+ }++ /**+ * Test-only: resolves from an explicit kubeconfig and marks the client ready, bypassing the+ * in-cluster/{@code $KUBECONFIG} auto-detection {@link #ensureInitialized()} would otherwise do.+ */+ void initializeFromKubeconfigForTest(Path path) {+ resolveFromKubeconfig(path);+ this.initialized = true;+ }++ private void resolveInCluster() {+ var host = System.getenv("KUBERNETES_SERVICE_HOST");+ var port = System.getenv("KUBERNETES_SERVICE_PORT");+ var authority = (host != null && port != null) ? host + ":" + port : "kubernetes.default.svc";+ this.baseUri = URI.create("https://" + authority);+ this.http = HttpClient.newBuilder()+ .connectTimeout(Duration.ofSeconds(5))+ .sslContext(sslContext(trustManagerFromCaFile(SERVICE_ACCOUNT_CA), null))+ .build();+ this.tokenSupplier = () -> {+ try {+ return Files.readString(SERVICE_ACCOUNT_TOKEN, StandardCharsets.UTF_8).strip();+ } catch (IOException e) {+ throw new IllegalStateException(+ "Could not read in-cluster service account token at " + SERVICE_ACCOUNT_TOKEN+ + ": " + e.getMessage(), e);+ }+ };+ }++ private void resolveFromKubeconfig(Path path) {+ if (!Files.exists(path)) {+ throw new IllegalStateException(+ "The kubernetes Lambda executor needs either an in-cluster service account or a "+ + "kubeconfig, and found neither: no service account at " + SERVICE_ACCOUNT_DIR+ + " and no kubeconfig at " + path + ". Set KUBECONFIG or place one at ~/.kube/config.");+ }+ JsonNode root;+ try (var in = Files.newInputStream(path)) {+ root = new ObjectMapper(new YAMLFactory()).readTree(in);+ } catch (IOException e) {+ throw new IllegalStateException("Could not read kubeconfig at " + path + ": " + e.getMessage(), e);+ }++ var currentContextName = root.path("current-context").asText(null);+ if (currentContextName == null || currentContextName.isBlank()) {+ throw new IllegalStateException("kubeconfig at " + path + " has no current-context set");+ }+ var context = findNamed(root.path("contexts"), currentContextName, "context")+ .orElseThrow(() -> new IllegalStateException(+ "kubeconfig context '" + currentContextName + "' not found in " + path));+ var clusterName = context.path("cluster").asText(null);+ var cluster = findNamed(root.path("clusters"), clusterName, "cluster")+ .orElseThrow(() -> new IllegalStateException(+ "kubeconfig cluster '" + clusterName + "' not found in " + path));+ var userName = context.path("user").asText(null);+ var user = userName == null ? JsonNodeFactory.instance.objectNode()+ : findNamed(root.path("users"), userName, "user")+ .orElseGet(JsonNodeFactory.instance::objectNode);++ var server = cluster.path("server").asText(null);+ if (server == null || server.isBlank()) {+ throw new IllegalStateException("kubeconfig cluster '" + clusterName + "' has no server URL in " + path);+ }+ this.baseUri = URI.create(server);++ // Matches kubectl: when set, this wins over any certificate-authority (chain+ // validation is skipped either way, so a CA to validate against is moot).+ var insecureSkipTlsVerify = cluster.path("insecure-skip-tls-verify").asBoolean(false);+ X509TrustManager trustManager;+ if (insecureSkipTlsVerify) {+ trustManager = INSECURE_TRUST_MANAGER;+ } else {+ var caBytes = pemBytes(cluster, "certificate-authority", "certificate-authority-data", path);+ trustManager = caBytes != null ? trustManagerFromPem(caBytes) : defaultTrustManager();+ }++ var certBytes = pemBytes(user, "client-certificate", "client-certificate-data", path);+ var keyBytes = pemBytes(user, "client-key", "client-key-data", path);+ KeyManager[] keyManagers = null;+ if (certBytes != null && keyBytes != null) {+ keyManagers = keyManagersFromPem(certBytes, keyBytes);+ }++ var token = user.path("token").asText(null);+ if (token == null && keyManagers == null) {+ if (user.has("exec") || user.has("auth-provider")) {+ throw new IllegalStateException(+ "kubeconfig user '" + userName + "' uses an exec or auth-provider credential "+ + "plugin, which the kubernetes Lambda executor does not support. Use a "+ + "static token or client-certificate/client-key credential instead.");+ }+ throw new IllegalStateException("kubeconfig user '" + userName+ + "' has no supported credential (token or client-certificate/client-key) in " + path);+ }++ var httpBuilder = HttpClient.newBuilder()+ .connectTimeout(Duration.ofSeconds(5))+ .sslContext(sslContext(trustManager, keyManagers));+ if (insecureSkipTlsVerify) {+ // The trust manager above already skips chain validation; this additionally+ // skips hostname verification, matching kubectl's --insecure-skip-tls-verify+ // (otherwise a kind/minikube server cert with no matching SAN still fails).+ var sslParameters = new SSLParameters();+ sslParameters.setEndpointIdentificationAlgorithm("");+ httpBuilder.sslParameters(sslParameters);+ }+ this.http = httpBuilder.build();+ this.tokenSupplier = token == null ? null : () -> token;+ }++ private static Path kubeconfigPath() {+ var envValue = System.getenv("KUBECONFIG");+ if (envValue != null && !envValue.isBlank()) {+ var separator = System.getProperty("os.name", "").toLowerCase(Locale.ROOT).contains("win") ? ";" : ":";+ return Path.of(envValue.split(Pattern.quote(separator))[0]);+ }+ return Path.of(System.getProperty("user.home"), ".kube", "config");+ }++ private static Optional<JsonNode> findNamed(JsonNode array, String name, String childKey) {+ if (name == null) {+ return Optional.empty();+ }+ for (var entry : array) {+ if (name.equals(entry.path("name").asText(null))) {+ return Optional.of(entry.path(childKey));+ }+ }+ return Optional.empty();+ }++ /** Reads a `<field>` (a path, resolved relative to the kubeconfig) or `<field>-data` (base64) entry. */+ private static byte[] pemBytes(JsonNode node, String fileField, String dataField, Path kubeconfigPath) {+ var data = node.path(dataField).asText(null);+ if (data != null && !data.isBlank()) {+ return Base64.getDecoder().decode(data);+ }+ var file = node.path(fileField).asText(null);+ if (file == null || file.isBlank()) {+ return null;+ }+ var resolved = Path.of(file).isAbsolute() ? Path.of(file) : kubeconfigPath.getParent().resolve(file);+ try {+ return Files.readAllBytes(resolved);+ } catch (IOException e) {+ throw new IllegalStateException(+ "Could not read kubeconfig-referenced file " + resolved + ": " + e.getMessage(), e);+ }+ }++ private static X509TrustManager trustManagerFromCaFile(Path caFile) {+ try {+ return trustManagerFromPem(Files.readAllBytes(caFile));+ } catch (IOException e) {+ throw new IllegalStateException(+ "Could not read in-cluster CA certificate at " + caFile + ": " + e.getMessage(), e);+ }+ }++ private static X509TrustManager trustManagerFromPem(byte[] pem) {+ try {+ var certs = CertificateFactory.getInstance("X.509").generateCertificates(new ByteArrayInputStream(pem));+ var keyStore = KeyStore.getInstance(KeyStore.getDefaultType());+ keyStore.load(null, null);+ var i = 0;+ for (var cert : certs) {+ keyStore.setCertificateEntry("ca" + (i++), cert);+ }+ var trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());+ trustManagerFactory.init(keyStore);+ return firstX509(trustManagerFactory.getTrustManagers(),+ "No X509TrustManager produced from the supplied CA certificate(s)");+ } catch (GeneralSecurityException | IOException e) {+ throw new IllegalStateException(+ "Could not build a trust manager from the supplied CA certificate: " + e.getMessage(), e);+ }+ }++ private static X509TrustManager defaultTrustManager() {+ try {+ var trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());+ trustManagerFactory.init((KeyStore) null);+ return firstX509(trustManagerFactory.getTrustManagers(), "No default X509TrustManager available");+ } catch (GeneralSecurityException e) {+ throw new IllegalStateException("Could not load the default trust manager: " + e.getMessage(), e);+ }+ }++ private static X509TrustManager firstX509(TrustManager[] managers, String errorIfNone) {+ for (var manager : managers) {+ if (manager instanceof X509TrustManager x509) {+ return x509;+ }+ }+ throw new IllegalStateException(errorIfNone);+ }++ private static KeyManager[] keyManagersFromPem(byte[] certPem, byte[] keyPem) {+ try {+ var cert = CertificateFactory.getInstance("X.509").generateCertificate(new ByteArrayInputStream(certPem));+ var privateKey = privateKeyFromPem(keyPem);+ var keyStore = KeyStore.getInstance(KeyStore.getDefaultType());+ keyStore.load(null, null);+ keyStore.setKeyEntry("client", privateKey, new char[0], new Certificate[]{cert});+ var keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());+ keyManagerFactory.init(keyStore, new char[0]);+ return keyManagerFactory.getKeyManagers();+ } catch (GeneralSecurityException | IOException e) {+ throw new IllegalStateException(+ "Could not build a key manager from the kubeconfig client certificate/key: " + e.getMessage(), e);+ }+ }++ private static PrivateKey privateKeyFromPem(byte[] pem) {+ var text = new String(pem, StandardCharsets.US_ASCII);+ if (text.contains("BEGIN RSA PRIVATE KEY") || text.contains("BEGIN EC PRIVATE KEY")) {+ throw new IllegalStateException(+ "kubeconfig client-key is in PKCS#1 format (BEGIN RSA/EC PRIVATE KEY); only PKCS#8 "+ + "(BEGIN PRIVATE KEY) is supported. Convert it with: openssl pkcs8 -topk8 "+ + "-nocrypt -in key.pem -out key-pkcs8.pem");+ }+ var base64 = text.replaceAll("-----BEGIN [^-]+-----", "")+ .replaceAll("-----END [^-]+-----", "")+ .replaceAll("\\s", "");+ var keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(base64));+ GeneralSecurityException last = null;+ for (var algorithm : new String[]{"RSA", "EC"}) {+ try {+ return KeyFactory.getInstance(algorithm).generatePrivate(keySpec);+ } catch (GeneralSecurityException e) {+ last = e;+ }+ }+ throw new IllegalStateException("Could not parse kubeconfig client-key as an RSA or EC private key: "+ + (last == null ? "unknown format" : last.getMessage()));+ }++ private static SSLContext sslContext(X509TrustManager trustManager, KeyManager[] keyManagers) {+ try {+ var context = SSLContext.getInstance("TLS");+ context.init(keyManagers, new TrustManager[]{trustManager}, null);+ return context;+ } catch (GeneralSecurityException e) {+ throw new IllegalStateException("Could not initialize TLS for the Kubernetes API client: "+ + e.getMessage(), e);+ }+ }++ private static String podsPath(String namespace) {+ return "/api/v1/namespaces/" + encode(namespace) + "/pods";+ }++ private static String podPath(String namespace, String name) {+ return podsPath(namespace) + "/" + encode(name);+ }++ private static String configMapsPath(String namespace) {+ return "/api/v1/namespaces/" + encode(namespace) + "/configmaps";+ }++ private static String configMapPath(String namespace, String name) {+ return configMapsPath(namespace) + "/" + encode(name);+ }++ private static String encode(String segment) {+ return URLEncoder.encode(segment, StandardCharsets.UTF_8).replace("+", "%20");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiException.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiException.javanew file mode 100644index 0000000000..2f1706f0e2--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiException.java@@ -0,0 +1,17 @@+package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;++/** A Kubernetes API server response outside 2xx (and, for a get, other than a plain 404). */+public class KubernetesApiException extends RuntimeException {++ private final int statusCode;++ public KubernetesApiException(String method, String path, int statusCode, String body) {+ super("Kubernetes API " + method + " " + path + " failed: HTTP " + statusCode+ + (body == null || body.isBlank() ? "" : " " + body));+ this.statusCode = statusCode;+ }++ public int getStatusCode() {+ return statusCode;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncher.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncher.javaindex 4f4559c3e1..039da5f0b9 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncher.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncher.java@@ -1,11 +1,7 @@package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;-import io.fabric8.kubernetes.api.model.ConfigMapBuilder;-import io.fabric8.kubernetes.api.model.ContainerStatus;-import io.fabric8.kubernetes.api.model.Pod;-import io.fabric8.kubernetes.client.KubernetesClient;-import io.fabric8.kubernetes.client.KubernetesClientException;-import io.fabric8.kubernetes.client.dsl.NonDeletingOperation;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.node.JsonNodeFactory;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;@@ -82,7 +78,7 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {"ImagePullBackOff", "InvalidImageName", "CrashLoopBackOff","CreateContainerError", "CreateContainerConfigError", "RunContainerError");- private final KubernetesClient client;+ private final KubernetesApiClient client;private final EmulatorConfig config;private final RuntimeApiServerFactory runtimeApiServerFactory;private final ImageResolver imageResolver;@@ -101,7 +97,7 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {private final AtomicBoolean awsConfigPathWarned = new AtomicBoolean(false);@Inject- public KubernetesPodLauncher(KubernetesClient client,+ public KubernetesPodLauncher(KubernetesApiClient client,EmulatorConfig config,RuntimeApiServerFactory runtimeApiServerFactory,ImageResolver imageResolver,@@ -124,13 +120,12 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {}/**- * Forces the lazy client bean (and its underlying Vert.x HTTP client) to be- * built on the caller's thread. Called from the startup observer so the HTTP- * client is not born on a request's Vert.x context, whose close at shutdown- * would leave every later Kubernetes API call failing with "Client is closed".+ * Resolves the API client's connection (in-cluster or kubeconfig) on the caller's+ * thread. Called from the startup observer so a misconfigured cluster connection+ * fails startup instead of the first cold start.*/public void initializeClient() {- client.getConfiguration();+ client.initialize();// Resolve the address pods use to reach Floci now, so the most common// misconfiguration (running outside the cluster without a floci-address)// fails startup instead of every later cold start.@@ -218,7 +213,7 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {imagePackage ? null : fn.getHandler(), imageConfig, fn.getMemorySize(), caConfigMap);ownPodNames.add(podName);- client.pods().inNamespace(namespace).resource(pod).create();+ client.createPod(namespace, pod);LOG.infov("Created pod {0} for function {1}", podName, fn.getFunctionName());awaitRunning(namespace, podName, fn.getFunctionName());@@ -310,13 +305,12 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {@Overridepublic boolean isAlive(ContainerHandle handle) {try {- var pod = client.pods().inNamespace(namespace()).withName(handle.getContainerId()).get();+ var pod = client.getPod(namespace(), handle.getContainerId()).orElse(null);return pod != null- && pod.getStatus() != null- && "Running".equals(pod.getStatus().getPhase())- && pod.getMetadata().getDeletionTimestamp() == null;+ && "Running".equals(pod.path("status").path("phase").asText(null))+ && isAbsent(pod.path("metadata").path("deletionTimestamp"));} catch (Exception e) {- // A missing pod comes back as null above; reaching here means the API server+ // A missing pod comes back as empty above; reaching here means the API server// itself was unreachable. Unlike docker's local socket the API server is remote,// so a transient blip must not read as "dead" — that would cull the whole warm// pool at once. Assume alive; a genuinely dead pod fails the next invocation.@@ -350,24 +344,19 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {return;}try {- var orphans = client.pods().inNamespace(namespace)- .withLabels(LambdaPodSpecFactory.managedPodSelector())- .list().getItems().stream()- .filter(pod -> !ownPodNames.contains(pod.getMetadata().getName()))+ var orphans = client.listPods(namespace, LambdaPodSpecFactory.managedPodSelector()).stream()+ .filter(pod -> !ownPodNames.contains(pod.path("metadata").path("name").asText())).toList();if (!orphans.isEmpty()) {LOG.infov("Deleting {0} orphaned Lambda pod(s) from a previous run in namespace {1}",orphans.size(), namespace);for (var orphan : orphans) {- client.pods().inNamespace(namespace)- .withName(orphan.getMetadata().getName())- .withGracePeriod(0)- .delete();+ client.deletePod(namespace, orphan.path("metadata").path("name").asText());}}orphansSwept = true;- } catch (KubernetesClientException e) {- if (e.getCode() == 401 || e.getCode() == 403) {+ } catch (KubernetesApiException e) {+ if (e.getStatusCode() == 401 || e.getStatusCode() == 403) {// A permission gap never heals within this process, so stop retrying// it on every cold start; the ServiceAccount simply cannot sweep.LOG.warnv("Orphaned Lambda pod sweep is not permitted in namespace {0} "@@ -445,14 +434,12 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {private void awaitRunning(String namespace, String podName, String functionName) {var timeoutSeconds = POD_STARTUP_TIMEOUT_SECONDS;- Pod pod;+ JsonNode pod;try {- // A null pod (deleted out-of-band) is terminal too, otherwise the wait+ // A missing pod (deleted out-of-band) is terminal too, otherwise the wait// would block the invocation for the full timeout.- pod = client.pods().inNamespace(namespace).withName(podName)- .waitUntilCondition(p -> p == null- || (p.getStatus() != null && (isRunning(p) || hasTerminalFailure(p))),- timeoutSeconds, TimeUnit.SECONDS);+ pod = client.waitForPod(namespace, podName,+ p -> p == null || isRunning(p) || hasTerminalFailure(p), timeoutSeconds);} catch (Exception e) {throw new RuntimeException("Pod " + podName + " for function '" + functionName+ "' did not reach Running within " + timeoutSeconds + "s: " + e.getMessage(), e);@@ -463,12 +450,12 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {}}- private static boolean isRunning(Pod pod) {- return "Running".equals(pod.getStatus().getPhase());+ private static boolean isRunning(JsonNode pod) {+ return "Running".equals(pod.path("status").path("phase").asText(null));}- private static boolean hasTerminalFailure(Pod pod) {- var phase = pod.getStatus().getPhase();+ private static boolean hasTerminalFailure(JsonNode pod) {+ var phase = pod.path("status").path("phase").asText(null);// Succeeded means the runtime exited before serving — terminal for a server pod.if ("Failed".equals(phase) || "Succeeded".equals(phase)) {return true;@@ -476,61 +463,54 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {return unschedulableReason(pod) != null || describeTerminalReason(pod) != null;}- private static String unschedulableReason(Pod pod) {- if (pod.getStatus().getConditions() == null) {- return null;- }- for (var condition : pod.getStatus().getConditions()) {+ private static String unschedulableReason(JsonNode pod) {+ for (var condition : pod.path("status").path("conditions")) {// A pod the scheduler cannot place — e.g. a memory request above every node's// capacity — stays Pending with no container statuses; fail the cold start// instead of blocking the invoker for the full startup timeout.- if ("PodScheduled".equals(condition.getType()) && "False".equals(condition.getStatus())- && "Unschedulable".equals(condition.getReason())) {- return "Unschedulable: " + condition.getMessage();+ if ("PodScheduled".equals(condition.path("type").asText(null))+ && "False".equals(condition.path("status").asText(null))+ && "Unschedulable".equals(condition.path("reason").asText(null))) {+ return "Unschedulable: " + condition.path("message").asText("");}}return null;}- private static String describeTerminalReason(Pod pod) {- var statuses = new ArrayList<ContainerStatus>();- if (pod.getStatus().getInitContainerStatuses() != null) {- statuses.addAll(pod.getStatus().getInitContainerStatuses());- }- if (pod.getStatus().getContainerStatuses() != null) {- statuses.addAll(pod.getStatus().getContainerStatuses());- }- for (var status : statuses) {- if (status.getState() == null) {- continue;- }- var waiting = status.getState().getWaiting();- // getReason() is null while a reason is absent; Set.of(...).contains(null)- // throws, which would abort an otherwise healthy cold start.- if (waiting != null && waiting.getReason() != null- && TERMINAL_WAITING_REASONS.contains(waiting.getReason())) {- return status.getName() + ": " + waiting.getReason()- + " (" + waiting.getMessage() + ")";- }- if (status.getState().getTerminated() != null- && status.getState().getTerminated().getExitCode() != null- && status.getState().getTerminated().getExitCode() != 0) {- return status.getName() + ": exited with code "- + status.getState().getTerminated().getExitCode();+ private static String describeTerminalReason(JsonNode pod) {+ for (var statuses : List.of(pod.path("status").path("initContainerStatuses"),+ pod.path("status").path("containerStatuses"))) {+ for (var status : statuses) {+ var waiting = status.path("state").path("waiting");+ var waitingReason = waiting.path("reason").asText(null);+ // A missing reason must never match; Set.of(...).contains(null) throws,+ // which would abort an otherwise healthy cold start.+ if (waitingReason != null && TERMINAL_WAITING_REASONS.contains(waitingReason)) {+ return status.path("name").asText() + ": " + waitingReason+ + " (" + waiting.path("message").asText("") + ")";+ }+ var exitCode = status.path("state").path("terminated").path("exitCode");+ if (!exitCode.isMissingNode() && exitCode.asInt() != 0) {+ return status.path("name").asText() + ": exited with code " + exitCode.asInt();+ }}}return null;}- private static String describeFailure(Pod pod) {- if (pod == null || pod.getStatus() == null) {+ private static String describeFailure(JsonNode pod) {+ if (pod == null || pod.path("status").isMissingNode()) {return "pod no longer exists";}var reason = describeTerminalReason(pod);if (reason == null) {reason = unschedulableReason(pod);}- return reason != null ? reason : "phase=" + pod.getStatus().getPhase();+ return reason != null ? reason : "phase=" + pod.path("status").path("phase").asText("unknown");+ }++ private static boolean isAbsent(JsonNode node) {+ return node.isMissingNode() || node.isNull();}/**@@ -543,15 +523,15 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {}try {var pem = Files.readString(caCertPath);- var configMap = new ConfigMapBuilder()- .withNewMetadata()- .withName(CA_CONFIG_MAP_NAME)- .withLabels(LambdaPodSpecFactory.managedPodSelector())- .endMetadata()- .addToData(CA_CONFIG_MAP_KEY, pem)- .build();- client.configMaps().inNamespace(namespace).resource(configMap)- .createOr(NonDeletingOperation::update);+ var nodes = JsonNodeFactory.instance;+ var labels = nodes.objectNode();+ LambdaPodSpecFactory.managedPodSelector().forEach(labels::put);+ var metadata = nodes.objectNode().put("name", CA_CONFIG_MAP_NAME);+ metadata.set("labels", labels);+ var configMap = nodes.objectNode().put("apiVersion", "v1").put("kind", "ConfigMap");+ configMap.set("metadata", metadata);+ configMap.set("data", nodes.objectNode().put(CA_CONFIG_MAP_KEY, pem));+ client.createOrUpdateConfigMap(namespace, configMap);caConfigMapApplied.set(true);return CA_CONFIG_MAP_NAME;} catch (Exception e) {@@ -572,9 +552,8 @@ public class KubernetesPodLauncher implements LambdaRuntimeLauncher {// abandoned either way, and a retried orphan sweep may still collect it.ownPodNames.remove(podName);try {- client.pods().inNamespace(namespace).withName(podName).withGracePeriod(0).delete();- client.pods().inNamespace(namespace).withName(podName)- .waitUntilCondition(p -> p == null, POD_DELETE_TIMEOUT_SECONDS, TimeUnit.SECONDS);+ client.deletePod(namespace, podName);+ client.waitForPod(namespace, podName, pod -> pod == null, POD_DELETE_TIMEOUT_SECONDS);return true;} catch (Exception e) {LOG.warnv("Pod {0} was not confirmed deleted within {1}s: {2}",diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLogStreamer.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLogStreamer.javaindex 0539a61293..ebbeb30f73 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLogStreamer.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLogStreamer.java@@ -1,6 +1,5 @@package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;-import io.fabric8.kubernetes.client.KubernetesClient;import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -9,6 +8,7 @@ import org.jboss.logging.Logger;import java.io.BufferedReader;import java.io.Closeable;import java.io.IOException;+import java.io.InputStream;import java.io.InputStreamReader;import java.nio.charset.StandardCharsets;@@ -23,11 +23,11 @@ public class KubernetesPodLogStreamer {private static final Logger LOG = Logger.getLogger(KubernetesPodLogStreamer.class);- private final KubernetesClient client;+ private final KubernetesApiClient client;private final ContainerLogStreamer cloudWatchWriter;@Inject- public KubernetesPodLogStreamer(KubernetesClient client, ContainerLogStreamer cloudWatchWriter) {+ public KubernetesPodLogStreamer(KubernetesApiClient client, ContainerLogStreamer cloudWatchWriter) {this.client = client;this.cloudWatchWriter = cloudWatchWriter;}@@ -41,14 +41,11 @@ public class KubernetesPodLogStreamer {String logStream, String region, String logPrefix) {cloudWatchWriter.ensureLogGroupAndStream(logGroup, logStream, region);- var watch = client.pods().inNamespace(namespace).withName(podName)- .inContainer("runtime")- .watchLog();+ InputStream logStreamBody = client.openPodLogStream(namespace, podName, "runtime");// Virtual thread: one blocking reader per warm pod is near-free this way.var reader = Thread.ofVirtual().name("lambda-pod-logs-" + podName).start(() -> {- try (var lines = new BufferedReader(- new InputStreamReader(watch.getOutput(), StandardCharsets.UTF_8))) {+ try (var lines = new BufferedReader(new InputStreamReader(logStreamBody, StandardCharsets.UTF_8))) {String line;while ((line = lines.readLine()) != null) {// Match the docker log path: trim trailing whitespace and drop blank@@ -68,9 +65,9 @@ public class KubernetesPodLogStreamer {return () -> {try {- watch.close();+ logStreamBody.close();} catch (Exception e) {- LOG.debugv("Closing log watch for pod {0} failed: {1}", podName, e.getMessage());+ LOG.debugv("Closing log stream for pod {0} failed: {1}", podName, e.getMessage());}reader.interrupt();};diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactory.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactory.javaindex 16f8a7d2cd..5d848385d9 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactory.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactory.java@@ -1,22 +1,14 @@package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;-import io.fabric8.kubernetes.api.model.Container;-import io.fabric8.kubernetes.api.model.ContainerBuilder;-import io.fabric8.kubernetes.api.model.EnvVar;-import io.fabric8.kubernetes.api.model.Pod;-import io.fabric8.kubernetes.api.model.PodBuilder;-import io.fabric8.kubernetes.api.model.Quantity;-import io.fabric8.kubernetes.api.model.Volume;-import io.fabric8.kubernetes.api.model.VolumeBuilder;-import io.fabric8.kubernetes.api.model.VolumeMount;-import io.fabric8.kubernetes.api.model.VolumeMountBuilder;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.JsonNodeFactory;+import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.services.lambda.launcher.ContainerLauncher;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;-import java.util.ArrayList;import java.util.LinkedHashMap;import java.util.List;import java.util.Locale;@@ -24,10 +16,10 @@ import java.util.Map;import java.util.Optional;/**- * Builds the Pod manifest for one Lambda execution environment. Code cannot be- * copied into a pod before it starts (no docker-cp equivalent), so an init- * container downloads the deployment package (and layers) from Floci's S3 over- * HTTP into an emptyDir mounted at /var/task before the runtime starts.+ * Builds the Pod manifest for one Lambda execution environment, as a plain JSON tree (see+ * {@link KubernetesApiClient}). Code cannot be copied into a pod before it starts (no docker-cp+ * equivalent), so an init container downloads the deployment package (and layers) from Floci's+ * S3 over HTTP into an emptyDir mounted at /var/task before the runtime starts.*/@ApplicationScopedpublic class LambdaPodSpecFactory {@@ -70,7 +62,7 @@ public class LambdaPodSpecFactory {* @param imageConfig Image-package-type entrypoint/command/workingdir; empty lists/null when unset* @param caConfigMapName ConfigMap holding Floci's CA cert, mounted at /etc/floci-ca.crt when present*/- public Pod buildPod(String podName,+ public ObjectNode buildPod(String podName,String functionName,String image,List<String> env,@@ -83,94 +75,102 @@ public class LambdaPodSpecFactory {Optional<String> caConfigMapName) {var hasCode = codeDownloadUrl != null;var hasLayers = !layerDownloadUrls.isEmpty();+ var nodes = JsonNodeFactory.instance;- var volumes = new ArrayList<Volume>();- var runtimeMounts = new ArrayList<VolumeMount>();+ var volumes = nodes.arrayNode();+ var runtimeMounts = nodes.arrayNode();if (hasCode) {- volumes.add(new VolumeBuilder().withName("task").withNewEmptyDir().endEmptyDir().build());- runtimeMounts.add(mount("task", TASK_DIR));+ volumes.add(emptyDirVolume(nodes, "task"));+ runtimeMounts.add(mount(nodes, "task", TASK_DIR));}if (hasLayers) {- volumes.add(new VolumeBuilder().withName("opt").withNewEmptyDir().endEmptyDir().build());- runtimeMounts.add(mount("opt", OPT_DIR));+ volumes.add(emptyDirVolume(nodes, "opt"));+ runtimeMounts.add(mount(nodes, "opt", OPT_DIR));}// The provided.* base images exec /var/runtime/bootstrap with no /var/task// fallback, and their /var/runtime ships empty, so masking it with an emptyDir// that the init container copies bootstrap into is safe and required.var needsRuntimeDir = providedRuntime && hasCode;if (needsRuntimeDir) {- volumes.add(new VolumeBuilder().withName("runtime").withNewEmptyDir().endEmptyDir().build());- runtimeMounts.add(mount("runtime", RUNTIME_DIR));+ volumes.add(emptyDirVolume(nodes, "runtime"));+ runtimeMounts.add(mount(nodes, "runtime", RUNTIME_DIR));}caConfigMapName.ifPresent(cm -> {- volumes.add(new VolumeBuilder().withName("floci-ca")- .withNewConfigMap().withName(cm).endConfigMap().build());- runtimeMounts.add(new VolumeMountBuilder()- .withName("floci-ca")- .withMountPath(ContainerLauncher.FLOCI_CA_CONTAINER_PATH)- .withSubPath(KubernetesPodLauncher.CA_CONFIG_MAP_KEY)- .withReadOnly(true)- .build());+ volumes.add(nodes.objectNode().put("name", "floci-ca")+ .set("configMap", nodes.objectNode().put("name", cm)));+ runtimeMounts.add(nodes.objectNode()+ .put("name", "floci-ca")+ .put("mountPath", ContainerLauncher.FLOCI_CA_CONTAINER_PATH)+ .put("subPath", KubernetesPodLauncher.CA_CONFIG_MAP_KEY)+ .put("readOnly", true));});- var runtime = new ContainerBuilder()- .withName("runtime")- .withImage(image)+ var resources = nodes.objectNode();+ var memory = memoryMb + "Mi";+ resources.set("requests", nodes.objectNode().put("memory", memory));+ resources.set("limits", nodes.objectNode().put("memory", memory));++ var runtime = nodes.objectNode()+ .put("name", "runtime")+ .put("image", image)// Explicit IfNotPresent: the default for :latest/untagged is Always,// which breaks images pre-loaded onto nodes (kind load docker-image).- .withImagePullPolicy("IfNotPresent")- .withEnv(toEnvVars(env))- .withVolumeMounts(runtimeMounts)- .withNewResources()- .addToRequests("memory", new Quantity(memoryMb + "Mi"))- .addToLimits("memory", new Quantity(memoryMb + "Mi"))- .endResources();+ .put("imagePullPolicy", "IfNotPresent");+ runtime.set("env", toEnvVars(nodes, env));+ runtime.set("volumeMounts", runtimeMounts);+ runtime.set("resources", resources);if (imageConfig != null && !imageConfig.entryPoint().isEmpty()) {- runtime.withCommand(escapeDollars(imageConfig.entryPoint()));+ runtime.set("command", stringArray(nodes, escapeDollars(imageConfig.entryPoint())));}if (imageConfig != null && !imageConfig.command().isEmpty()) {- runtime.withArgs(escapeDollars(imageConfig.command()));+ runtime.set("args", stringArray(nodes, escapeDollars(imageConfig.command())));} else if (handlerOrNull != null && !handlerOrNull.isBlank()) {- runtime.withArgs(escapeDollar(handlerOrNull));+ runtime.set("args", stringArray(nodes, List.of(escapeDollar(handlerOrNull))));}if (imageConfig != null && imageConfig.workingDirectory() != null&& !imageConfig.workingDirectory().isBlank()) {- runtime.withWorkingDir(imageConfig.workingDirectory());+ runtime.put("workingDir", imageConfig.workingDirectory());}- var initContainers = new ArrayList<Container>();+ var initContainers = nodes.arrayNode();if (hasCode) {- var initMounts = new ArrayList<VolumeMount>();- initMounts.add(mount("task", TASK_DIR));+ var initMounts = nodes.arrayNode();+ initMounts.add(mount(nodes, "task", TASK_DIR));if (hasLayers) {- initMounts.add(mount("opt", OPT_DIR));+ initMounts.add(mount(nodes, "opt", OPT_DIR));}if (needsRuntimeDir) {- initMounts.add(mount("runtime", RUNTIME_DIR));+ initMounts.add(mount(nodes, "runtime", RUNTIME_DIR));}- initContainers.add(new ContainerBuilder()- .withName("code-download")- .withImage(config.services().lambda().kubernetes().initImage())- .withImagePullPolicy("IfNotPresent")- .withCommand("sh", "-c", initScript(codeDownloadUrl, layerDownloadUrls, providedRuntime))- .withVolumeMounts(initMounts)- .build());+ var init = nodes.objectNode()+ .put("name", "code-download")+ .put("image", config.services().lambda().kubernetes().initImage())+ .put("imagePullPolicy", "IfNotPresent");+ init.set("command", stringArray(nodes,+ List.of("sh", "-c", initScript(codeDownloadUrl, layerDownloadUrls, providedRuntime))));+ init.set("volumeMounts", initMounts);+ initContainers.add(init);}- return new PodBuilder()- .withNewMetadata()- .withName(podName)- .withLabels(podLabels(functionName))- .endMetadata()- .withNewSpec()- .withRestartPolicy("Never")- .withTerminationGracePeriodSeconds(5L)- .withInitContainers(initContainers)- .withContainers(runtime.build())- .withVolumes(volumes)- .endSpec()- .build();+ var metadata = nodes.objectNode().put("name", podName);+ var labels = nodes.objectNode();+ podLabels(functionName).forEach(labels::put);+ metadata.set("labels", labels);++ var spec = nodes.objectNode()+ .put("restartPolicy", "Never")+ .put("terminationGracePeriodSeconds", 5);+ spec.set("initContainers", initContainers);+ spec.set("containers", nodes.arrayNode().add(runtime));+ spec.set("volumes", volumes);++ var pod = nodes.objectNode()+ .put("apiVersion", "v1")+ .put("kind", "Pod");+ pod.set("metadata", metadata);+ pod.set("spec", spec);+ return pod;}/** Entrypoint/command/workingdir of an Image-package-type function. */@@ -262,8 +262,18 @@ public class LambdaPodSpecFactory {return sanitized;}- private static VolumeMount mount(String name, String path) {- return new VolumeMountBuilder().withName(name).withMountPath(path).build();+ private static ObjectNode emptyDirVolume(JsonNodeFactory nodes, String name) {+ return nodes.objectNode().put("name", name).set("emptyDir", nodes.objectNode());+ }++ private static ObjectNode mount(JsonNodeFactory nodes, String name, String path) {+ return nodes.objectNode().put("name", name).put("mountPath", path);+ }++ private static ArrayNode stringArray(JsonNodeFactory nodes, List<String> values) {+ var array = nodes.arrayNode();+ values.forEach(array::add);+ return array;}private static List<String> escapeDollars(List<String> values) {@@ -276,8 +286,8 @@ public class LambdaPodSpecFactory {return value.replace("$", "$$");}- private static List<EnvVar> toEnvVars(List<String> env) {- var vars = new ArrayList<EnvVar>(env.size());+ private static ArrayNode toEnvVars(JsonNodeFactory nodes, List<String> env) {+ var vars = nodes.arrayNode();for (var entry : env) {var eq = entry.indexOf('=');var key = eq >= 0 ? entry.substring(0, eq) : entry;@@ -289,7 +299,7 @@ public class LambdaPodSpecFactory {}// Kubernetes expands $(VAR) in env values and collapses $$ to $.// Escaping every $ delivers values byte-for-byte like the docker executor.- vars.add(new EnvVar(key, value.replace("$", "$$"), null));+ vars.add(nodes.objectNode().put("name", key).put("value", value.replace("$", "$$")));}return vars;}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 2a23b1b227..d9959d6875 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -17,11 +17,6 @@ quarkus:max-body-size: ${floci.protocols.max-request-size}Mdatasource:active: false- kubernetes-client:- devservices:- # Never auto-start a test API server; the kubernetes Lambda executor- # connects to a real cluster (in-cluster config or kubeconfig) only.- enabled: falsesecurity:security-providers: BCshutdown:diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClientKubeconfigTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClientKubeconfigTest.javanew file mode 100644index 0000000000..4f576e7963--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesApiClientKubeconfigTest.java@@ -0,0 +1,121 @@+package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;++import com.sun.net.httpserver.HttpsConfigurator;+import com.sun.net.httpserver.HttpsServer;+import io.github.hectorvent.floci.services.acm.CertificateGenerator;+import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import org.bouncycastle.jce.provider.BouncyCastleProvider;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import javax.net.ssl.KeyManagerFactory;+import javax.net.ssl.SSLContext;+import java.net.InetSocketAddress;+import java.nio.file.Files;+import java.nio.file.Path;+import java.security.KeyStore;+import java.security.Security;+import java.security.cert.Certificate;+import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++/**+ * Verifies kubeconfig's {@code insecure-skip-tls-verify} against a real self-signed HTTPS+ * server, not just that the flag parses: without it, a self-signed server cert must still fail+ * the handshake, or the flag would silently do nothing.+ */+class KubernetesApiClientKubeconfigTest {++ private HttpsServer server;++ @BeforeAll+ static void registerBouncyCastle() {+ if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {+ Security.addProvider(new BouncyCastleProvider());+ }+ }++ @AfterEach+ void tearDown() {+ if (server != null) {+ server.stop(0);+ }+ }++ @Test+ void insecureSkipTlsVerifyTrustsASelfSignedServerCert(@TempDir Path tempDir) throws Exception {+ startSelfSignedServer();+ var kubeconfig = writeKubeconfig(tempDir, true);++ var client = new KubernetesApiClient();+ client.initializeFromKubeconfigForTest(kubeconfig);++ assertThat(client.getPod("default", "whatever")).isEmpty();+ }++ @Test+ void withoutInsecureSkipTlsVerifyASelfSignedServerCertFailsTheHandshake(@TempDir Path tempDir) throws Exception {+ startSelfSignedServer();+ var kubeconfig = writeKubeconfig(tempDir, false);++ var client = new KubernetesApiClient();+ client.initializeFromKubeconfigForTest(kubeconfig);++ assertThatThrownBy(() -> client.getPod("default", "whatever"))+ .hasMessageContaining("Kubernetes API GET");+ }++ private void startSelfSignedServer() throws Exception {+ var generator = new CertificateGenerator();+ var generated = generator.generateSelfSignedCertificate(+ "127.0.0.1", List.of("127.0.0.1"), KeyAlgorithm.RSA_2048);+ var cert = generator.parseCertificate(generated.certificatePem());+ var privateKey = generator.parsePrivateKey(generated.privateKeyPem());++ var keyStore = KeyStore.getInstance(KeyStore.getDefaultType());+ keyStore.load(null, null);+ keyStore.setKeyEntry("server", privateKey, new char[0], new Certificate[]{cert});+ var keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());+ keyManagerFactory.init(keyStore, new char[0]);+ var sslContext = SSLContext.getInstance("TLS");+ sslContext.init(keyManagerFactory.getKeyManagers(), null, null);++ server = HttpsServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.setHttpsConfigurator(new HttpsConfigurator(sslContext));+ server.createContext("/", exchange -> {+ exchange.sendResponseHeaders(404, -1);+ exchange.close();+ });+ server.start();+ }++ private Path writeKubeconfig(Path tempDir, boolean insecureSkipTlsVerify) throws Exception {+ var port = server.getAddress().getPort();+ var config = """+ apiVersion: v1+ kind: Config+ current-context: test+ clusters:+ - name: c+ cluster:+ server: https://127.0.0.1:%d+ insecure-skip-tls-verify: %s+ contexts:+ - name: test+ context:+ cluster: c+ user: u+ users:+ - name: u+ user:+ token: test-token+ """.formatted(port, insecureSkipTlsVerify);+ var path = tempDir.resolve("config");+ Files.writeString(path, config);+ return path;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncherTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncherTest.javaindex 9d904beaea..3886a0beb5 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncherTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/KubernetesPodLauncherTest.java@@ -20,6 +20,13 @@ import org.awaitility.Awaitility;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import javax.net.ssl.SSLContext;+import javax.net.ssl.TrustManager;+import javax.net.ssl.X509TrustManager;+import java.net.URI;+import java.net.http.HttpClient;+import java.security.SecureRandom;+import java.security.cert.X509Certificate;import java.time.Duration;import java.util.List;import java.util.Map;@@ -31,6 +38,7 @@ import static org.assertj.core.api.Assertions.assertThat;import static org.assertj.core.api.Assertions.assertThatThrownBy;import static org.assertj.core.api.Assertions.tuple;import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyMap;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;import static org.mockito.Mockito.doAnswer;@@ -42,10 +50,19 @@ import static org.mockito.Mockito.spy;import static org.mockito.Mockito.verify;import static org.mockito.Mockito.when;+/**+ * {@code client} (the fabric8 mock server injected by {@code @EnableKubernetesMockClient}) plays+ * two roles here: it is the fake HTTPS API server {@link #apiClient} talks to (over a trust-all+ * {@link HttpClient}, since the mock's cert is self-signed and per-run), and it is used directly+ * to seed pods and play the kubelet (setting phases) exactly as a real cluster would. Reading+ * pods back through it after {@link #apiClient} creates them works because both talk to the same+ * backing store; only the mock's transport is fabric8, never Floci's own code.+ */@EnableKubernetesMockClient(crud = true)class KubernetesPodLauncherTest {KubernetesClient client;+ private KubernetesApiClient apiClient;private EmulatorConfig config;private RuntimeApiServerFactory runtimeApiServerFactory;private RuntimeApiServer runtimeApiServer;@@ -100,11 +117,31 @@ class KubernetesPodLauncherTest {lenient().when(logStreamer.logStreamName(anyString())).thenReturn("2026/07/25/[$LATEST]test");s3Service = mock(S3Service.class);- launcher = new KubernetesPodLauncher(client, config, runtimeApiServerFactory, imageResolver,+ apiClient = new KubernetesApiClient(+ URI.create(client.getConfiguration().getMasterUrl()), trustAllHttpClient(), null);+ launcher = new KubernetesPodLauncher(apiClient, config, runtimeApiServerFactory, imageResolver,addressResolver, awsEnv, layerService, new LambdaPodSpecFactory(config),logStreamer, s3Service);}+ /** The mock server's cert is self-signed and generated per run; trust it, not the JVM default. */+ private static HttpClient trustAllHttpClient() {+ try {+ var trustAll = new X509TrustManager() {+ public void checkClientTrusted(X509Certificate[] chain, String authType) { }+ public void checkServerTrusted(X509Certificate[] chain, String authType) { }+ public X509Certificate[] getAcceptedIssuers() {+ return new X509Certificate[0];+ }+ };+ var context = SSLContext.getInstance("TLS");+ context.init(null, new TrustManager[]{trustAll}, new SecureRandom());+ return HttpClient.newBuilder().sslContext(context).build();+ } catch (Exception e) {+ throw new IllegalStateException(e);+ }+ }+private LambdaFunction function() {var fn = new LambdaFunction();fn.setFunctionName("my-fn");@@ -231,16 +268,9 @@ class KubernetesPodLauncherTest {// the cleanup delete can never confirm the pod is gone. The pod could still reach// Running later and poll AWS_LAMBDA_RUNTIME_API, so the port must stay reserved// instead of going back to the pool for another environment.- var failingClient = spy(client);- doAnswer(invocation -> {- var failedPodExists = client.pods().inNamespace("default").list().getItems().stream()- .anyMatch(p -> p.getStatus() != null && "Failed".equals(p.getStatus().getPhase()));- if (failedPodExists) {- throw new RuntimeException("kube api down");- }- return invocation.callRealMethod();- }).when(failingClient).pods();- var failingLauncher = new KubernetesPodLauncher(failingClient, config,+ var failingApiClient = spy(apiClient);+ doThrow(new RuntimeException("kube api down")).when(failingApiClient).deletePod(anyString(), anyString());+ var failingLauncher = new KubernetesPodLauncher(failingApiClient, config,runtimeApiServerFactory, imageResolver, addressResolver, awsEnv, layerService,new LambdaPodSpecFactory(config), logStreamer, s3Service);markPodPhaseInBackground("floci-lambda-my-fn-", "Failed");@@ -383,14 +413,14 @@ class KubernetesPodLauncherTest {// First Kubernetes API access (the sweep's pod list) fails once.var failedOnce = new AtomicBoolean();- var flakyClient = spy(client);+ var flakyApiClient = spy(apiClient);doAnswer(invocation -> {if (failedOnce.compareAndSet(false, true)) {throw new RuntimeException("kube api down");}return invocation.callRealMethod();- }).when(flakyClient).pods();- var retryingLauncher = new KubernetesPodLauncher(flakyClient, config,+ }).when(flakyApiClient).listPods(anyString(), anyMap());+ var retryingLauncher = new KubernetesPodLauncher(flakyApiClient, config,runtimeApiServerFactory, imageResolver, addressResolver, awsEnv, layerService,new LambdaPodSpecFactory(config), logStreamer, s3Service);diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactoryTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactoryTest.javaindex 8e9d72ece2..ee5012fdea 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactoryTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/LambdaPodSpecFactoryTest.java@@ -1,9 +1,6 @@package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;-import io.fabric8.kubernetes.api.model.EnvVar;-import io.fabric8.kubernetes.api.model.Pod;-import io.fabric8.kubernetes.api.model.Volume;-import io.fabric8.kubernetes.api.model.VolumeMount;+import com.fasterxml.jackson.databind.JsonNode;import io.github.hectorvent.floci.config.EmulatorConfig;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;@@ -13,7 +10,10 @@ import org.mockito.junit.jupiter.MockitoExtension;import org.mockito.junit.jupiter.MockitoSettings;import org.mockito.quality.Strictness;+import java.util.ArrayList;+import java.util.LinkedHashMap;import java.util.List;+import java.util.Map;import java.util.Optional;import static org.assertj.core.api.Assertions.assertThat;@@ -48,7 +48,7 @@ class LambdaPodSpecFactoryTest {factory = new LambdaPodSpecFactory(config);}- private Pod buildZipPod() {+ private JsonNode buildZipPod() {return factory.buildPod("floci-lambda-my-fn-abc12345", "my-fn","public.ecr.aws/lambda/python:3.12",List.of("AWS_LAMBDA_RUNTIME_API=10.0.0.5:9200", "_HANDLER=index.handler"),@@ -56,42 +56,64 @@ class LambdaPodSpecFactoryTest {List.of(), false, "index.handler", null, 256, Optional.empty());}+ private static JsonNode spec(JsonNode pod) {+ return pod.path("spec");+ }++ private static List<JsonNode> elements(JsonNode array) {+ var list = new ArrayList<JsonNode>();+ array.forEach(list::add);+ return list;+ }++ private static List<String> texts(JsonNode array) {+ return elements(array).stream().map(JsonNode::asText).toList();+ }++ private static Map<String, String> stringMap(JsonNode object) {+ var map = new LinkedHashMap<String, String>();+ object.fields().forEachRemaining(entry -> map.put(entry.getKey(), entry.getValue().asText()));+ return map;+ }+@Testvoid zipFunctionPodHasInitContainerTaskVolumeAndEnv() {- var spec = buildZipPod().getSpec();+ var spec = spec(buildZipPod());- assertThat(spec.getRestartPolicy()).isEqualTo("Never");- assertThat(spec.getTerminationGracePeriodSeconds()).isEqualTo(5L);- assertThat(spec.getInitContainers()).hasSize(1);+ assertThat(spec.path("restartPolicy").asText()).isEqualTo("Never");+ assertThat(spec.path("terminationGracePeriodSeconds").asLong()).isEqualTo(5L);+ var initContainers = elements(spec.path("initContainers"));+ assertThat(initContainers).hasSize(1);- var init = spec.getInitContainers().getFirst();- assertThat(init.getImage()).isEqualTo("busybox:1.36");- assertThat(init.getCommand().get(2))+ var init = initContainers.getFirst();+ assertThat(init.path("image").asText()).isEqualTo("busybox:1.36");+ assertThat(texts(init.path("command")).get(2)).contains("wget -q -O /tmp/code.zip").contains("unzip -oq /tmp/code.zip -d /var/task").doesNotContain("--no-check-certificate");- assertThat(init.getVolumeMounts())- .extracting(VolumeMount::getName, VolumeMount::getMountPath)+ assertThat(elements(init.path("volumeMounts")))+ .extracting(n -> n.path("name").asText(), n -> n.path("mountPath").asText()).containsExactly(tuple("task", "/var/task"));- var runtime = spec.getContainers().getFirst();- assertThat(runtime.getName()).isEqualTo("runtime");- assertThat(runtime.getArgs()).containsExactly("index.handler");- assertThat(runtime.getResources().getLimits().get("memory")).hasToString("256Mi");- assertThat(runtime.getResources().getRequests().get("memory")).hasToString("256Mi");- assertThat(runtime.getVolumeMounts())- .extracting(VolumeMount::getName, VolumeMount::getMountPath)+ var runtime = elements(spec.path("containers")).getFirst();+ assertThat(runtime.path("name").asText()).isEqualTo("runtime");+ assertThat(texts(runtime.path("args"))).containsExactly("index.handler");+ assertThat(runtime.path("resources").path("limits").path("memory").asText()).isEqualTo("256Mi");+ assertThat(runtime.path("resources").path("requests").path("memory").asText()).isEqualTo("256Mi");+ assertThat(elements(runtime.path("volumeMounts")))+ .extracting(n -> n.path("name").asText(), n -> n.path("mountPath").asText()).contains(tuple("task", "/var/task"));- assertThat(runtime.getEnv())- .extracting(EnvVar::getName, EnvVar::getValue)+ assertThat(elements(runtime.path("env")))+ .extracting(n -> n.path("name").asText(), n -> n.path("value").asText()).contains(tuple("AWS_LAMBDA_RUNTIME_API", "10.0.0.5:9200"));- assertThat(spec.getVolumes()).extracting(Volume::getName).containsExactly("task");+ assertThat(elements(spec.path("volumes"))).extracting(n -> n.path("name").asText())+ .containsExactly("task");}@Testvoid standardLabelsAreApplied() {- var labels = buildZipPod().getMetadata().getLabels();+ var labels = stringMap(buildZipPod().path("metadata").path("labels"));assertThat(labels).containsEntry("app.kubernetes.io/managed-by", "floci").containsEntry("floci.io/service", "lambda")@@ -102,7 +124,7 @@ class LambdaPodSpecFactoryTest {void userLabelsAreParsedAndApplied() {when(kubernetes.labels()).thenReturn(Optional.of(List.of("team=platform", "floci.io/env=ci", "empty-ok=")));- var labels = buildZipPod().getMetadata().getLabels();+ var labels = stringMap(buildZipPod().path("metadata").path("labels"));assertThat(labels).containsEntry("team", "platform").containsEntry("floci.io/env", "ci")@@ -115,7 +137,7 @@ class LambdaPodSpecFactoryTest {// such entries must never reach the pod spec.when(kubernetes.labels()).thenReturn(Optional.of(List.of("malformed", "a=b=c", "bad key=x", "team=platform")));- var labels = buildZipPod().getMetadata().getLabels();+ var labels = stringMap(buildZipPod().path("metadata").path("labels"));assertThat(labels).containsEntry("team", "platform").doesNotContainKeys("malformed", "a", "bad key");@@ -130,16 +152,17 @@ class LambdaPodSpecFactoryTest {List.of("http://10.0.0.5:4566/b/layers/1", "http://10.0.0.5:4566/b/layers/2"),false, "index.handler", null, 128, Optional.empty());- var spec = pod.getSpec();- assertThat(spec.getVolumes()).extracting(Volume::getName).contains("opt");- assertThat(spec.getContainers().getFirst().getVolumeMounts())- .extracting(VolumeMount::getName, VolumeMount::getMountPath)+ var spec = spec(pod);+ assertThat(elements(spec.path("volumes"))).extracting(n -> n.path("name").asText()).contains("opt");+ assertThat(elements(elements(spec.path("containers")).getFirst().path("volumeMounts")))+ .extracting(n -> n.path("name").asText(), n -> n.path("mountPath").asText()).contains(tuple("opt", "/opt"));- assertThat(spec.getInitContainers().getFirst().getVolumeMounts())- .extracting(VolumeMount::getName, VolumeMount::getMountPath)+ var init = elements(spec.path("initContainers")).getFirst();+ assertThat(elements(init.path("volumeMounts")))+ .extracting(n -> n.path("name").asText(), n -> n.path("mountPath").asText()).contains(tuple("opt", "/opt"));- assertThat(spec.getInitContainers().getFirst().getCommand().get(2))+ assertThat(texts(init.path("command")).get(2)).contains("unzip -oq /tmp/layer0.zip -d /opt").containsSubsequence("wget -q -O /tmp/layer0.zip 'http://10.0.0.5:4566/b/layers/1'",@@ -156,15 +179,16 @@ class LambdaPodSpecFactoryTest {"http://10.0.0.5:4566/awslambda-us-east-1-tasks/snapshots/000000000000/custom",List.of(), true, "bootstrap", null, 128, Optional.empty());- var spec = pod.getSpec();- assertThat(spec.getVolumes()).extracting(Volume::getName).contains("runtime");- assertThat(spec.getContainers().getFirst().getVolumeMounts())- .extracting(VolumeMount::getName, VolumeMount::getMountPath)+ var spec = spec(pod);+ assertThat(elements(spec.path("volumes"))).extracting(n -> n.path("name").asText()).contains("runtime");+ assertThat(elements(elements(spec.path("containers")).getFirst().path("volumeMounts")))+ .extracting(n -> n.path("name").asText(), n -> n.path("mountPath").asText()).contains(tuple("runtime", "/var/runtime"));- assertThat(spec.getInitContainers().getFirst().getVolumeMounts())- .extracting(VolumeMount::getName)+ var init = elements(spec.path("initContainers")).getFirst();+ assertThat(elements(init.path("volumeMounts")))+ .extracting(n -> n.path("name").asText()).contains("runtime");- assertThat(spec.getInitContainers().getFirst().getCommand().get(2))+ assertThat(texts(init.path("command")).get(2)).contains("cp /var/task/bootstrap /var/runtime/bootstrap").contains("chmod +x /var/runtime/bootstrap");}@@ -172,8 +196,8 @@ class LambdaPodSpecFactoryTest {@Testvoid nonProvidedRuntimeDoesNotMaskVarRuntime() {// Masking /var/runtime on a normal runtime would delete the runtime interface client.- assertThat(buildZipPod().getSpec().getVolumes())- .extracting(Volume::getName)+ assertThat(elements(spec(buildZipPod()).path("volumes")))+ .extracting(n -> n.path("name").asText()).doesNotContain("runtime");}@@ -181,7 +205,7 @@ class LambdaPodSpecFactoryTest {void managedLabelsCannotBeOverriddenByUserLabels() {when(kubernetes.labels()).thenReturn(Optional.of(List.of("app.kubernetes.io/managed-by=evil", "floci.io/service=other")));- var labels = buildZipPod().getMetadata().getLabels();+ var labels = stringMap(buildZipPod().path("metadata").path("labels"));assertThat(labels).containsEntry("app.kubernetes.io/managed-by", "floci").containsEntry("floci.io/service", "lambda");@@ -193,8 +217,8 @@ class LambdaPodSpecFactoryTest {"public.ecr.aws/lambda/python:3.12",List.of("SECRET=pa$$word", "TEMPLATE=$(HOME)/x"),"http://10.0.0.5:4566/b/k", List.of(), false, "h", null, 128, Optional.empty());- assertThat(pod.getSpec().getContainers().getFirst().getEnv())- .extracting(EnvVar::getName, EnvVar::getValue)+ assertThat(elements(elements(spec(pod).path("containers")).getFirst().path("env")))+ .extracting(n -> n.path("name").asText(), n -> n.path("value").asText()).contains(tuple("SECRET", "pa$$$$word"),tuple("TEMPLATE", "$$(HOME)/x"));@@ -212,17 +236,20 @@ class LambdaPodSpecFactoryTest {List.of(), false, "index.handler", null, 128,Optional.of(KubernetesPodLauncher.CA_CONFIG_MAP_NAME));- var spec = pod.getSpec();- assertThat(spec.getVolumes()).anySatisfy(volume -> {- assertThat(volume.getName()).isEqualTo("floci-ca");- assertThat(volume.getConfigMap().getName()).isEqualTo(KubernetesPodLauncher.CA_CONFIG_MAP_NAME);- });- assertThat(spec.getContainers().getFirst().getVolumeMounts()).anySatisfy(volumeMount -> {- assertThat(volumeMount.getName()).isEqualTo("floci-ca");- assertThat(volumeMount.getMountPath()).isEqualTo("/etc/floci-ca.crt");- assertThat(volumeMount.getSubPath()).isEqualTo(KubernetesPodLauncher.CA_CONFIG_MAP_KEY);+ var spec = spec(pod);+ assertThat(elements(spec.path("volumes"))).anySatisfy(volume -> {+ assertThat(volume.path("name").asText()).isEqualTo("floci-ca");+ assertThat(volume.path("configMap").path("name").asText())+ .isEqualTo(KubernetesPodLauncher.CA_CONFIG_MAP_NAME);});- assertThat(spec.getInitContainers().getFirst().getCommand().get(2))+ assertThat(elements(elements(spec.path("containers")).getFirst().path("volumeMounts")))+ .anySatisfy(volumeMount -> {+ assertThat(volumeMount.path("name").asText()).isEqualTo("floci-ca");+ assertThat(volumeMount.path("mountPath").asText()).isEqualTo("/etc/floci-ca.crt");+ assertThat(volumeMount.path("subPath").asText())+ .isEqualTo(KubernetesPodLauncher.CA_CONFIG_MAP_KEY);+ });+ assertThat(texts(elements(spec.path("initContainers")).getFirst().path("command")).get(2)).contains("wget -q").doesNotContain("--no-check-certificate");}@@ -235,7 +262,7 @@ class LambdaPodSpecFactoryTest {new LambdaPodSpecFactory.ImageConfig(List.of("/entry.sh"), List.of("run('$(AWS_REGION)')", "pa$$word"), "/work"),512, Optional.empty());- assertThat(pod.getSpec().getContainers().getFirst().getArgs())+ assertThat(texts(elements(spec(pod).path("containers")).getFirst().path("args"))).containsExactly("run('$$(AWS_REGION)')", "pa$$$$word");}@@ -248,14 +275,14 @@ class LambdaPodSpecFactoryTest {List.of("/entry.sh"), List.of("arg1", "arg2"), "/work"),512, Optional.empty());- var spec = pod.getSpec();- assertThat(spec.getInitContainers()).isEmpty();- assertThat(spec.getVolumes()).isEmpty();+ var spec = spec(pod);+ assertThat(elements(spec.path("initContainers"))).isEmpty();+ assertThat(elements(spec.path("volumes"))).isEmpty();- var runtime = spec.getContainers().getFirst();- assertThat(runtime.getCommand()).containsExactly("/entry.sh");- assertThat(runtime.getArgs()).containsExactly("arg1", "arg2");- assertThat(runtime.getWorkingDir()).isEqualTo("/work");+ var runtime = elements(spec.path("containers")).getFirst();+ assertThat(texts(runtime.path("command"))).containsExactly("/entry.sh");+ assertThat(texts(runtime.path("args"))).containsExactly("arg1", "arg2");+ assertThat(runtime.path("workingDir").asText()).isEqualTo("/work");}@Test@@ -264,8 +291,8 @@ class LambdaPodSpecFactoryTest {"public.ecr.aws/lambda/python:3.12",List.of("KEY=a=b", "EMPTY="),"http://10.0.0.5:4566/b/k", List.of(), false, "h", null, 128, Optional.empty());- assertThat(pod.getSpec().getContainers().getFirst().getEnv())- .extracting(EnvVar::getName, EnvVar::getValue)+ assertThat(elements(elements(spec(pod).path("containers")).getFirst().path("env")))+ .extracting(n -> n.path("name").asText(), n -> n.path("value").asText()).contains(tuple("KEY", "a=b"),tuple("EMPTY", ""));@@ -278,8 +305,8 @@ class LambdaPodSpecFactoryTest {"public.ecr.aws/lambda/python:3.12",List.of("=oops", "KEY=1"),"http://10.0.0.5:4566/b/k", List.of(), false, "h", null, 128, Optional.empty());- assertThat(pod.getSpec().getContainers().getFirst().getEnv())- .extracting(EnvVar::getName)+ assertThat(elements(elements(spec(pod).path("containers")).getFirst().path("env")))+ .extracting(n -> n.path("name").asText()).containsExactly("KEY");}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex e9fa69ae08..856fee22c5 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -6,9 +6,6 @@ quarkus:max-body-size: ${floci.protocols.max-request-size}Mdatasource:active: false- kubernetes-client:- devservices:- enabled: false# Groovy (a REST Assured dependency) starts DFA-cache-cleaner threads that never stop.# Loaded parent-first they live in the shared system classloader, so they cannot pin a# per-profile application classloader across the many app restarts of a test run.