Light, fluffy, and always free - The AWS Local Emulator alternative
feat(kinesisanalytics): add Managed Service for Apache Flink (Kinesis Analytics V2) (#1914)
Priamo Germosend78520d5cbba
diff --git a/README.md b/README.mdindex f4cb2cd47a..d498ad162e 100644--- a/README.md+++ b/README.md@@ -132,7 +132,7 @@ Run AWS-compatible services locally without an AWS account, auth token, or paid<details><summary><strong>Real Docker where fidelity matters</strong></summary>-Lambda, RDS, Neptune, ElastiCache, MSK, ECS, EC2, EKS, OpenSearch, and CodeBuild use real Docker-backed execution instead of shallow mocks.+Lambda, RDS, Neptune, ElastiCache, MSK, ECS, EC2, EKS, OpenSearch, CodeBuild, and Managed Service for Apache Flink use real Docker-backed execution instead of shallow mocks.</details>@@ -198,7 +198,7 @@ flowchart LRendsubgraph Containers ["Container Services"]- C["Lambda\nElastiCache\nRDS\nNeptune\nECS\nEC2\nMSK\nEKS\nOpenSearch\nCodeBuild"]+ C["Lambda\nElastiCache\nRDS\nNeptune\nECS\nEC2\nMSK\nEKS\nOpenSearch\nCodeBuild\nManaged Flink"]D["Athena -> floci-duck\nDuckDB sidecar"]end@@ -223,7 +223,7 @@ Floci supports local emulation for application services, data services, eventing| Events and workflows | EventBridge, EventBridge Pipes, EventBridge Scheduler, Step Functions, CloudWatch Logs, CloudWatch Metrics || API and identity | API Gateway REST, API Gateway v2, AppSync, Cognito, ACM, Route53, Cloud Map || Containers and compute | ECS, EC2, Lightsail, EKS, MWAA, ECR, CodeBuild, CodeDeploy, CodePipeline, AWS Batch, Auto Scaling, Application Auto Scaling, Elastic Beanstalk, ELB v2 |-| Data, analytics, and AI | Athena, Glue, EMR, Firehose, OpenSearch, S3 Vectors, Textract, Transcribe, Bedrock Runtime |+| Data, analytics, and AI | Athena, Glue, EMR, Firehose, Managed Service for Apache Flink, OpenSearch, S3 Vectors, Textract, Transcribe, Bedrock Runtime || Databases and caching | RDS, RDS Data API, Neptune, DocumentDB, MemoryDB, ElastiCache || Messaging and transfer | SES, Kinesis, MSK, Amazon MQ, Transfer Family, IoT Core || Security and governance | WAF v2, CloudTrail, CloudFront, Resource Groups Tagging API |@@ -271,6 +271,7 @@ For operation-level compatibility, see the [Services Overview](https://floci.io/| Glue | In-process | Data Catalog, Schema Registry, tables consumed by Athena || EMR | In-process | Cluster (job flow) lifecycle, instance groups and fleets, steps, security configurations, tagging || Data Firehose | In-process | Streaming delivery, NDJSON flush to S3 |+| Managed Service for Apache Flink | Real Docker | Kinesis Analytics V2 control plane; StartApplication runs a real Flink cluster (JobManager + TaskManager, image per RuntimeEnvironment), pulls the application JAR from local S3, and submits the job || ECS | Real Docker | Clusters, task definitions, tasks, services, capacity providers, task sets || EC2 | Real Docker | RunInstances launches containers, SSH key injection, UserData, IMDS, VPC resources || Lightsail | In-process | Instances, disks, static IPs, key pairs, ports, tags, regions, blueprints, bundles, operations |@@ -325,6 +326,7 @@ Floci uses real Docker containers when in-process emulation would reduce fidelit| DocumentDB | `mongo:7.0` | MongoDB engine; MongoDB wire protocol on port 27017 || MSK | `redpandadata/redpanda:latest` | Kafka-compatible broker via Redpanda || Amazon MQ | `rabbitmq:3-management` | RabbitMQ broker; AMQP on port 5672, management console on 15672 |+| Managed Service for Apache Flink | `apache/flink:<version>` | Apache Flink JobManager; image chosen per RuntimeEnvironment (FLINK-1_15 … FLINK-1_20, FLINK-2_0 … FLINK-2_3) || EC2 | AMI-mapped Linux images | Linux containers, SSH key injection, UserData, IMDS, IAM credentials || ECS | User-specified task image | Container lifecycle, start, stop, health checks || EKS | `rancher/k3s:latest` | Kubernetes API server via k3s |@@ -353,6 +355,7 @@ docker run -d --name floci \| `FLOCI_SERVICES_RDS_DEFAULT_MARIADB_IMAGE` | `mariadb:11` || `FLOCI_SERVICES_MSK_DEFAULT_IMAGE` | `redpandadata/redpanda:latest` || `FLOCI_SERVICES_OPENSEARCH_DEFAULT_IMAGE` | `opensearchproject/opensearch:2` |+| `FLOCI_SERVICES_KINESIS_ANALYTICS_DEFAULT_IMAGE` | _(unset; chosen per RuntimeEnvironment)_ || `FLOCI_SERVICES_NEPTUNE_DEFAULT_IMAGE` | `tinkerpop/gremlin-server:3.7.3` || `FLOCI_SERVICES_NEPTUNE_DEFAULT_NEO4J_IMAGE` | `neo4j:5-community` || `FLOCI_SERVICES_DOCDB_DEFAULT_IMAGE` | `mongo:7.0` |diff --git a/compatibility-tests/sdk-test-java/pom.xml b/compatibility-tests/sdk-test-java/pom.xmlindex 01402a4657..b91b7c3e7f 100644--- a/compatibility-tests/sdk-test-java/pom.xml+++ b/compatibility-tests/sdk-test-java/pom.xml@@ -144,6 +144,10 @@<groupId>software.amazon.awssdk</groupId><artifactId>mq</artifactId></dependency>+ <dependency>+ <groupId>software.amazon.awssdk</groupId>+ <artifactId>kinesisanalyticsv2</artifactId>+ </dependency><dependency><groupId>software.amazon.awssdk</groupId><artifactId>athena</artifactId>diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.javaindex 3e49bbcf44..c894a2406c 100644--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java@@ -39,6 +39,7 @@ import software.amazon.awssdk.services.ssm.SsmClient;import software.amazon.awssdk.services.sts.StsClient;import software.amazon.awssdk.services.kafka.KafkaClient;import software.amazon.awssdk.services.mq.MqClient;+import software.amazon.awssdk.services.kinesisanalyticsv2.KinesisAnalyticsV2Client;import software.amazon.awssdk.services.athena.AthenaClient;import software.amazon.awssdk.services.athena.model.GetQueryExecutionRequest;import software.amazon.awssdk.services.athena.model.QueryExecutionState;@@ -397,6 +398,14 @@ public final class TestFixtures {.build();}+ public static KinesisAnalyticsV2Client kinesisAnalyticsV2Client() {+ return KinesisAnalyticsV2Client.builder()+ .endpointOverride(ENDPOINT)+ .region(REGION)+ .credentialsProvider(CREDENTIALS)+ .build();+ }+public static AthenaClient athenaClient() {return AthenaClient.builder().endpointOverride(ENDPOINT)diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AbstractKinesisAnalyticsV2LifecycleTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AbstractKinesisAnalyticsV2LifecycleTest.javanew file mode 100644index 0000000000..0a4246a42d--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AbstractKinesisAnalyticsV2LifecycleTest.java@@ -0,0 +1,227 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestInstance;+import org.junit.jupiter.api.TestMethodOrder;+import software.amazon.awssdk.services.kinesisanalyticsv2.KinesisAnalyticsV2Client;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.ApplicationDetail;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.ApplicationStatus;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.CreateApplicationRequest;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.CreateApplicationResponse;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.DeleteApplicationRequest;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.DescribeApplicationRequest;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.KinesisAnalyticsV2Exception;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.ListApplicationsRequest;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.RuntimeEnvironment;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.StartApplicationRequest;+import software.amazon.awssdk.services.kinesisanalyticsv2.model.StopApplicationRequest;++import java.time.Duration;+import java.time.Instant;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++/**+ * Ordered lifecycle for Managed Service for Apache Flink (Kinesis Analytics V2), exercised against a+ * specific Flink runtime supplied by {@link #runtime()}. Concrete subclasses pin a runtime so the suite+ * guards both the Flink 1.x and 2.x lines (Flink 2.0 changed the config system and boots slower):+ * CreateApplication → READY, StartApplication provisions a real {@code apache/flink} cluster and the+ * application transitions to RUNNING, ListApplications, StopApplication → READY, unsupported-runtime+ * rejection, DeleteApplication.+ *+ * <p>Uses {@code PER_CLASS} instance lifecycle so each concrete subclass gets its own state (static+ * fields would collide across subclasses). Requires a running Floci with+ * {@code kinesis-analytics.mock=false} and a working Docker daemon; when the application never reaches+ * RUNNING (Docker/Flink unavailable in CI), the dependent assertions skip rather than fail, mirroring+ * {@code AmazonMqTest} / {@code MskTest}.+ */+@TestInstance(TestInstance.Lifecycle.PER_CLASS)+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+abstract class AbstractKinesisAnalyticsV2LifecycleTest {++ private static final String ROLE = "arn:aws:iam::000000000000:role/flink-exec";++ /** The Flink {@code RuntimeEnvironment} under test, e.g. {@code FLINK-1_18} or {@code FLINK-2_3}. */+ protected abstract String runtime();++ private KinesisAnalyticsV2Client kda;+ private String applicationName = TestFixtures.uniqueName("flink-app");+ private Instant createTimestamp;+ private boolean reachedRunning;++ @BeforeAll+ void setup() {+ kda = TestFixtures.kinesisAnalyticsV2Client();+ }++ @AfterAll+ void cleanup() {+ if (kda != null) {+ if (applicationName != null && createTimestamp != null) {+ try {+ ensureStopped();+ kda.deleteApplication(DeleteApplicationRequest.builder()+ .applicationName(applicationName)+ .createTimestamp(createTimestamp)+ .build());+ } catch (Exception e) {+ // Tolerated (best-effort teardown) but logged with context per AGENTS.md.+ System.err.println("[WARN] AfterAll cleanup failed for application "+ + applicationName + ": " + e.getMessage());+ }+ }+ kda.close();+ }+ }++ @Test+ @Order(1)+ void createApplicationLandsReady() {+ // runtime() is passed as a String: FLINK-2_3 is newer than this SDK's RuntimeEnvironment enum+ // (2.44.14). The generated builder supports the String overload; assert via+ // runtimeEnvironmentAsString() so both the enum-known (1.18) and newer (2.3) values work.+ CreateApplicationResponse response = kda.createApplication(CreateApplicationRequest.builder()+ .applicationName(applicationName)+ .runtimeEnvironment(runtime())+ .serviceExecutionRole(ROLE)+ .build());++ ApplicationDetail detail = response.applicationDetail();+ assertThat(detail.applicationName()).isEqualTo(applicationName);+ assertThat(detail.applicationARN()).contains(":kinesisanalytics:");+ // AWS-faithful: a freshly created application is READY, not RUNNING.+ assertThat(detail.applicationStatus()).isEqualTo(ApplicationStatus.READY);+ assertThat(detail.runtimeEnvironmentAsString()).isEqualTo(runtime());+ createTimestamp = detail.createTimestamp();+ }++ @Test+ @Order(2)+ void startApplicationReachesRunning() {+ requireApp();++ boolean started;+ try {+ kda.startApplication(StartApplicationRequest.builder()+ .applicationName(applicationName)+ .build());+ started = true;+ } catch (KinesisAnalyticsV2Exception e) {+ // Container provisioning failed (Docker likely unavailable) — skip rather than fail.+ started = false;+ }+ Assumptions.assumeTrue(started,+ "StartApplication failed (Docker likely unavailable); skipping RUNNING checks");++ // Flink 2.x boots noticeably slower than 1.x (multi-pass JVM config parser), so allow more time.+ ApplicationDetail detail = waitForStatus(ApplicationStatus.RUNNING, Duration.ofSeconds(300));+ Assumptions.assumeTrue(detail != null,+ "Application did not reach RUNNING (Docker/Flink likely unavailable); skipping");++ reachedRunning = true;+ assertThat(detail.applicationStatus()).isEqualTo(ApplicationStatus.RUNNING);+ assertThat(detail.runtimeEnvironmentAsString()).isEqualTo(runtime());+ }++ @Test+ @Order(3)+ void listApplicationsIncludesCreated() {+ requireApp();++ var response = kda.listApplications(ListApplicationsRequest.builder().build());+ assertThat(response.applicationSummaries())+ .anyMatch(s -> s.applicationName().equals(applicationName));+ }++ @Test+ @Order(4)+ void stopApplicationReturnsToReady() {+ requireApp();+ Assumptions.assumeTrue(reachedRunning,+ "Application never reached RUNNING; skipping stop");++ kda.stopApplication(StopApplicationRequest.builder()+ .applicationName(applicationName)+ .build());++ ApplicationDetail detail = waitForStatus(ApplicationStatus.READY, Duration.ofSeconds(60));+ assertThat(detail).isNotNull();+ assertThat(detail.applicationStatus()).isEqualTo(ApplicationStatus.READY);+ }++ @Test+ @Order(5)+ void unsupportedRuntimeRejected() {+ // Floci only backs FLINK-x_y runtimes with a plain Flink image; the SQL and Studio (Zeppelin)+ // runtimes are rejected with InvalidArgumentException.+ assertThatThrownBy(() -> kda.createApplication(CreateApplicationRequest.builder()+ .applicationName(TestFixtures.uniqueName("flink-bad"))+ .runtimeEnvironment(RuntimeEnvironment.ZEPPELIN_FLINK_3_0)+ .serviceExecutionRole(ROLE)+ .build()))+ .isInstanceOf(KinesisAnalyticsV2Exception.class);+ }++ @Test+ @Order(6)+ void deleteApplication() {+ requireApp();++ // AWS rejects DeleteApplication on a non-stopped application (ResourceInUseException), so+ // ensure it is READY first (it may still be STARTING if it never reached RUNNING in time).+ ensureStopped();+ kda.deleteApplication(DeleteApplicationRequest.builder()+ .applicationName(applicationName)+ .createTimestamp(createTimestamp)+ .build());+ applicationName = null;+ }++ /** Best-effort: stop the application if it is RUNNING/STARTING so it can be deleted from READY. */+ private void ensureStopped() {+ try {+ ApplicationStatus status = kda.describeApplication(DescribeApplicationRequest.builder()+ .applicationName(applicationName)+ .build()).applicationDetail().applicationStatus();+ if (status == ApplicationStatus.RUNNING || status == ApplicationStatus.STARTING) {+ kda.stopApplication(StopApplicationRequest.builder()+ .applicationName(applicationName)+ .build());+ waitForStatus(ApplicationStatus.READY, Duration.ofSeconds(60));+ }+ } catch (Exception e) {+ System.err.println("[WARN] ensureStopped failed for application "+ + applicationName + ": " + e.getMessage());+ }+ }++ private ApplicationDetail waitForStatus(ApplicationStatus target, Duration timeout) {+ Instant deadline = Instant.now().plus(timeout);+ while (Instant.now().isBefore(deadline)) {+ ApplicationDetail detail = kda.describeApplication(DescribeApplicationRequest.builder()+ .applicationName(applicationName)+ .build()).applicationDetail();+ if (detail.applicationStatus() == target) {+ return detail;+ }+ try {+ Thread.sleep(2000);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ break;+ }+ }+ return null;+ }++ private void requireApp() {+ Assumptions.assumeTrue(applicationName != null,+ "Application must exist from earlier ordered test");+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KinesisAnalyticsV2Flink118Test.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KinesisAnalyticsV2Flink118Test.javanew file mode 100644index 0000000000..b8aeeab145--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KinesisAnalyticsV2Flink118Test.java@@ -0,0 +1,13 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;++/** Runs the Managed Flink lifecycle against the Flink 1.x line (FLINK-1_18). */+@DisplayName("Managed Service for Apache Flink — Flink 1.18")+class KinesisAnalyticsV2Flink118Test extends AbstractKinesisAnalyticsV2LifecycleTest {++ @Override+ protected String runtime() {+ return "FLINK-1_18";+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KinesisAnalyticsV2Flink23Test.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KinesisAnalyticsV2Flink23Test.javanew file mode 100644index 0000000000..83a58084b2--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/KinesisAnalyticsV2Flink23Test.java@@ -0,0 +1,13 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;++/** Runs the Managed Flink lifecycle against the Flink 2.x line (FLINK-2_3). */+@DisplayName("Managed Service for Apache Flink — Flink 2.3")+class KinesisAnalyticsV2Flink23Test extends AbstractKinesisAnalyticsV2LifecycleTest {++ @Override+ protected String runtime() {+ return "FLINK-2_3";+ }+}diff --git a/docs/configuration/environment-variables.md b/docs/configuration/environment-variables.mdindex 708fc5e0b1..1d63f6a1bf 100644--- a/docs/configuration/environment-variables.md+++ b/docs/configuration/environment-variables.md@@ -360,6 +360,14 @@ These services spawn Docker containers. They require access to the Docker socket| `FLOCI_SERVICES_MSK_MOCK` | `false` | When `true`, clusters are created instantly without a real Redpanda container || `FLOCI_SERVICES_MSK_DEFAULT_IMAGE` | `redpandadata/redpanda:latest` | Docker image for Kafka/Redpanda brokers |+### Managed Service for Apache Flink (Kinesis Analytics V2)++| Variable | Default | Description |+|---|---|---|+| `FLOCI_SERVICES_KINESIS_ANALYTICS_ENABLED` | `true` | Enable the Managed Flink (Kinesis Analytics V2) service |+| `FLOCI_SERVICES_KINESIS_ANALYTICS_MOCK` | `false` | When `true`, applications start instantly without a real Flink container |+| `FLOCI_SERVICES_KINESIS_ANALYTICS_DEFAULT_IMAGE` | _(unset)_ | Optional image override; when unset, the image is chosen from the requested `RuntimeEnvironment` (e.g. `FLINK-1_19` → `apache/flink:1.19`) |+### ECR (Elastic Container Registry)| Variable | Default | Description |diff --git a/docs/index.md b/docs/index.mdindex b40ab49ce9..9bd266b971 100644--- a/docs/index.md+++ b/docs/index.md@@ -44,6 +44,7 @@ Floci emulates 69 AWS services. See the [Services Overview](services/index.md) f| Athena | JSON 1.1 || Glue Data Catalog + Schema Registry | JSON 1.1 || Data Firehose | JSON 1.1 |+| Managed Service for Apache Flink | JSON 1.1 || ECS | JSON 1.1 || EC2 | EC2 Query || Lightsail | JSON 1.1 |diff --git a/docs/services/index.md b/docs/services/index.mdindex f8b6969bfc..00d8e489a8 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -25,6 +25,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Cognito](cognito.md) | `POST /` + `X-Amz-Target: AWSCognitoIdentityProviderService.*` | JSON 1.1 | 43 || [KMS](kms.md) | `POST /` + `X-Amz-Target: TrentService.*` | JSON 1.1 | 34 || [Kinesis](kinesis.md) | `POST /` + `X-Amz-Target: Kinesis_20131202.*` | JSON 1.1 | 24 |+| [Managed Service for Apache Flink](kinesisanalytics.md) | `POST /` + `X-Amz-Target: KinesisAnalytics_20180523.*` | JSON 1.1 | 7 || [Secrets Manager](secrets-manager.md) | `POST /` + `X-Amz-Target: secretsmanager.*` | JSON 1.1 | 16 || [Step Functions](step-functions.md) | `POST /` + `X-Amz-Target: AmazonStatesService.*` | JSON 1.1 | 19 || [CloudFormation](cloudformation.md) | `POST /` with `Action=` param | Query | 19 |diff --git a/docs/services/kinesisanalytics.md b/docs/services/kinesisanalytics.mdnew file mode 100644index 0000000000..5e4cf83ff3--- /dev/null+++ b/docs/services/kinesisanalytics.md@@ -0,0 +1,227 @@+# Managed Service for Apache Flink++**Protocol:** JSON 1.1+**Endpoint:** `http://localhost:4566/`++Floci emulates Amazon Managed Service for Apache Flink (the Kinesis Analytics V2 API). Unlike a+pure mock, Floci runs a **real Apache Flink cluster** as Docker sidecars when an application is+started and **submits the application's JAR** to it, so the application reaches a genuine `RUNNING`+state backed by a live Flink job on Floci's Docker network.++## Supported Actions++<!-- floci:actions:start -->+| Action | Description |+| --- | --- |+| `CreateApplication` | Creates a Flink application in the READY state |+| `CreateApplicationPresignedUrl` | Returns a URL to the application's Flink Dashboard |+| `DescribeApplication` | Returns details about an application |+| `ListApplications` | Lists all applications |+| `StartApplication` | Starts an application, provisioning a Flink JobManager container |+| `StopApplication` | Stops a running application and tears down its container |+| `UpdateApplication` | Updates an application (code, parallelism, execution role) and bumps its version; redeploys code in place on a running job |+| `DeleteApplication` | Deletes an application |+| `TagResource` | Assigns one or more tags to an application |+| `UntagResource` | Removes one or more tags from an application |+| `ListTagsForResource` | Lists the tags assigned to an application |+| `CreateApplicationSnapshot` | Triggers a Flink savepoint of the application's running job |+| `DescribeApplicationSnapshot` | Returns details about an application snapshot |+| `ListApplicationSnapshots` | Lists the snapshots for an application |+| `DeleteApplicationSnapshot` | Deletes an application snapshot |+<!-- floci:actions:end -->++## How it works++1. **CreateApplication**: registers the application in the `READY` state and stores its+ `ApplicationConfiguration` (the S3 location of the Flink JAR and the parallelism). No container is+ started yet — this mirrors AWS, where a freshly created application is not running.+2. **StartApplication**: reads the application JAR from Floci's local S3, launches an `apache/flink`+ **JobManager** container (plus a **TaskManager** for task slots) on Floci's Docker network, uploads+ the JAR to the cluster and runs it. The application transitions `STARTING → RUNNING` once the Flink+ job itself is `RUNNING`. An application created **without** code comes up `RUNNING` as a bare+ cluster (no job).+3. **StopApplication**: cancels the Flink job, tears down the JobManager and TaskManager, and returns+ the application to `READY`.+4. **DeleteApplication**: requires the application be stopped (`READY`); tears down any cluster and+ removes the application.++Because the Flink containers join Floci's Docker network, the job can reach `http://floci:4566` to+consume local Kinesis or MSK data streams.++### Deploying application code (a Flink JAR)++Pass an `ApplicationConfiguration` with an `ApplicationCodeConfiguration` pointing at a JAR in Floci's+local S3, exactly as with real AWS:++```bash+export AWS_ENDPOINT_URL=http://localhost:4566++# 1. Upload your Flink job JAR to (local) S3+aws s3 mb s3://flink-code+aws s3 cp my-flink-app.jar s3://flink-code/app.jar++# 2. Create the application pointing at that JAR+aws kinesisanalyticsv2 create-application \+ --application-name jobdemo --runtime-environment FLINK-1_18 \+ --service-execution-role arn:aws:iam::000000000000:role/x \+ --application-configuration '{+ "ApplicationCodeConfiguration": {+ "CodeContent": { "S3ContentLocation": {+ "BucketARN": "arn:aws:s3:::flink-code", "FileKey": "app.jar" } },+ "CodeContentType": "ZIPFILE" },+ "FlinkApplicationConfiguration": {+ "ParallelismConfiguration": { "ConfigurationType": "CUSTOM", "Parallelism": 1 } }+ }'++# 3. Start it — Floci pulls the JAR, runs it on the cluster, and reaches RUNNING+aws kinesisanalyticsv2 start-application --application-name jobdemo --run-configuration '{}'+aws kinesisanalyticsv2 describe-application --application-name jobdemo # ApplicationStatus: RUNNING+```++The job's main class is taken from the JAR's manifest (as in AWS Managed Flink).++### Updating application code in place++`UpdateApplication` with a new `ApplicationConfigurationUpdate.ApplicationCodeConfigurationUpdate`+redeploys a new JAR onto an **already-running** application without tearing down its JobManager/+TaskManager containers: the current Flink job is cancelled and the new JAR is uploaded and run on the+same cluster, exactly the way `StartApplication` submits a job — the application briefly transitions+`RUNNING → STARTING → RUNNING` while the new job comes up. Calling `UpdateApplication` on a `READY`+application just stores the new code location for the next `StartApplication`.+`FlinkApplicationConfigurationUpdate.ParallelismConfigurationUpdate.ParallelismUpdate` is also applied.++```bash+aws kinesisanalyticsv2 update-application \+ --application-name jobdemo --current-application-version-id 1 \+ --application-configuration-update '{+ "ApplicationCodeConfigurationUpdate": { "CodeContentUpdate": { "S3ContentLocationUpdate": {+ "BucketARNUpdate": "arn:aws:s3:::flink-code", "FileKeyUpdate": "app-v2.jar" } } } }'+```++Not yet emulated: attaching code to a **bare** running cluster (one started without code) via+`UpdateApplication` — stop and start the application instead.++### Runtime properties (`EnvironmentProperties`)++Pass `ApplicationConfiguration.EnvironmentProperties.PropertyGroups` on `CreateApplication` to configure+your application without recompiling it — exactly as with real AWS. Floci writes them to+`/etc/flink/application_properties.json` inside **both** the JobManager and TaskManager containers+before the job runs, the same well-known path real Managed Service for Apache Flink uses, so a JAR+written against `KinesisAnalyticsRuntime.getApplicationProperties()` picks them up unmodified:++```bash+aws kinesisanalyticsv2 create-application \+ --application-name jobdemo --runtime-environment FLINK-1_18 \+ --service-execution-role arn:aws:iam::000000000000:role/x \+ --application-configuration '{+ "ApplicationCodeConfiguration": {+ "CodeContent": { "S3ContentLocation": {+ "BucketARN": "arn:aws:s3:::flink-code", "FileKey": "app.jar" } },+ "CodeContentType": "ZIPFILE" },+ "EnvironmentProperties": {+ "PropertyGroups": [+ { "PropertyGroupId": "ProducerConfigProperties",+ "PropertyMap": { "aws.region": "us-west-2", "flink.stream.initpos": "LATEST" } }+ ] }+ }'+```++`DescribeApplication` echoes them back under+`ApplicationConfigurationDescription.EnvironmentPropertyDescriptions.PropertyGroupDescriptions`.++### Snapshots (savepoints)++`CreateApplicationSnapshot` triggers a real Flink [savepoint](https://nightlies.apache.org/flink/flink-docs-stable/docs/ops/state/savepoints/)+of the application's running job — the application must be `RUNNING` with a deployed job. The+snapshot starts `CREATING` and transitions to `READY` (or `FAILED`) once Flink's savepoint completes,+polled the same way `StartApplication` polls job readiness. Snapshot files land on a **named Docker+volume** mounted at `/opt/flink/savepoints` in the JobManager container, not the container's ephemeral+filesystem, so they survive a `StopApplication`/`StartApplication` cycle; the volume itself is only+removed on `DeleteApplication`.++```bash+aws kinesisanalyticsv2 create-application-snapshot \+ --application-name jobdemo --snapshot-name before-upgrade++aws kinesisanalyticsv2 describe-application-snapshot \+ --application-name jobdemo --snapshot-name before-upgrade # SnapshotStatus: CREATING -> READY++aws kinesisanalyticsv2 list-application-snapshots --application-name jobdemo++aws kinesisanalyticsv2 delete-application-snapshot \+ --application-name jobdemo --snapshot-name before-upgrade \+ --snapshot-creation-timestamp <SnapshotCreationTimestamp from describe>+```++Restoring a job *from* a snapshot (`CreateApplication`/`UpdateApplication` with a+`RestoreConfiguration` pointing at one) is not yet emulated.++Pass `ApplicationConfiguration.ApplicationSnapshotConfiguration.SnapshotsEnabled: false` on+`CreateApplication` (or `ApplicationSnapshotConfigurationUpdate.SnapshotsEnabledUpdate` on+`UpdateApplication`) to disable snapshots for an application — real AWS defaults this to `true`.+`CreateApplicationSnapshot` rejects the request with `InvalidRequestException` while disabled.++### Flink Dashboard access++`CreateApplicationPresignedUrl` (with `UrlType: FLINK_DASHBOARD_URL`) returns a URL to the running+application's Flink Dashboard — the application must be `RUNNING`:++```bash+aws kinesisanalyticsv2 create-application-presigned-url \+ --application-name jobdemo --url-type FLINK_DASHBOARD_URL+```++Real AWS returns a session-authorized, time-limited URL through its own proxy; Floci has no+equivalent session/proxy layer, so it returns the JobManager container's own REST/dashboard URL+directly — genuinely live and browsable, but not actually session-scoped or time-limited the way+`SessionExpirationDurationInSeconds` implies (the parameter is still validated to AWS's documented+1800–43200 second range). `UrlType: ZEPPELIN_UI_URL` is rejected, since Zeppelin/Studio applications+aren't supported at all (see below).++## Supported runtimes++The `RuntimeEnvironment` requested on `CreateApplication` selects the Flink image, so the running+container matches the requested version:++| RuntimeEnvironment | Image |+|---|---|+| `FLINK-2_3` | `apache/flink:2.3` |+| `FLINK-2_2` | `apache/flink:2.2` |+| `FLINK-2_1` | `apache/flink:2.1` |+| `FLINK-2_0` | `apache/flink:2.0` |+| `FLINK-1_20` | `apache/flink:1.20` |+| `FLINK-1_19` | `apache/flink:1.19` |+| `FLINK-1_18` | `apache/flink:1.18` |+| `FLINK-1_15` | `apache/flink:1.15` |++The set mirrors the runtimes AWS Managed Service for Apache Flink offers; `FLINK-1_16` and `FLINK-1_17`+are not offered by AWS and are rejected. The SQL (`SQL-1_0`) and Studio (`ZEPPELIN-FLINK-*`) runtimes+have no plain Flink image and are also rejected with `InvalidArgumentException`.++## Configuration++| Variable | Default | Description |+|---|---|---|+| `FLOCI_SERVICES_KINESIS_ANALYTICS_ENABLED` | `true` | Enable or disable the service |+| `FLOCI_SERVICES_KINESIS_ANALYTICS_MOCK` | `false` | Skip the Flink container; `StartApplication` comes up `RUNNING` immediately (useful without a Docker daemon) |+| `FLOCI_SERVICES_KINESIS_ANALYTICS_DEFAULT_IMAGE` | _(unset)_ | Optional override pinning **every** application to one image regardless of `RuntimeEnvironment`. When unset, the image is chosen from the runtime (see above) |++## Example++```bash+export AWS_ENDPOINT_URL=http://localhost:4566++# Create an application (lands in READY)+aws kinesisanalyticsv2 create-application \+ --application-name demo \+ --runtime-environment FLINK-1_18 \+ --service-execution-role arn:aws:iam::000000000000:role/x \+ --endpoint-url $AWS_ENDPOINT_URL++# Start it — spins up a real Flink JobManager container (STARTING -> RUNNING)+aws kinesisanalyticsv2 start-application --application-name demo \+ --run-configuration '{}' --endpoint-url $AWS_ENDPOINT_URL++# Check status+aws kinesisanalyticsv2 describe-application --application-name demo --endpoint-url $AWS_ENDPOINT_URL+```diff --git a/mkdocs.yml b/mkdocs.ymlindex 0a7d377b01..1b78a0e8c9 100644--- a/mkdocs.yml+++ b/mkdocs.yml@@ -85,6 +85,7 @@ nav:- Cognito: services/cognito.md- KMS: services/kms.md- Kinesis: services/kinesis.md+ - Managed Service for Apache Flink: services/kinesisanalytics.md- Secrets Manager: services/secrets-manager.md- CloudFormation: services/cloudformation.md- Step Functions: services/step-functions.mddiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex d1c7771781..3409b2cd21 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -531,6 +531,7 @@ public interface EmulatorConfig {IamServiceConfig iam();MskServiceConfig msk();AmazonMqServiceConfig amazonmq();+ KinesisAnalyticsServiceConfig kinesisAnalytics();ElastiCacheServiceConfig elasticache();MemoryDbServiceConfig memorydb();RdsServiceConfig rds();@@ -818,6 +819,23 @@ public interface EmulatorConfig {String defaultImage();}+ interface KinesisAnalyticsServiceConfig {+ @WithDefault("true")+ boolean enabled();++ /** When true, StartApplication comes up RUNNING immediately with no backing Flink+ * container. Useful for tests and hosts without a Docker daemon. */+ @WithDefault("false")+ boolean mock();++ /**+ * Optional fixed image used for every application regardless of the requested+ * {@code RuntimeEnvironment} (private registry mirror, pinned patch). When unset, the image+ * is chosen from the runtime via {@code KinesisAnalyticsRuntimes.imageFor(runtimeEnvironment)}.+ */+ Optional<String> defaultImage();+ }+interface ElastiCacheServiceConfig {@WithDefault("true")boolean enabled();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.javaindex 2bc6ffbcb5..598f0fb018 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java@@ -36,6 +36,7 @@ import io.github.hectorvent.floci.services.emr.EmrHandler;import io.github.hectorvent.floci.services.memorydb.MemoryDbHandler;import io.github.hectorvent.floci.services.wafv2.WafV2Handler;import io.github.hectorvent.floci.services.kinesis.KinesisJsonHandler;+import io.github.hectorvent.floci.services.kinesisanalytics.KinesisAnalyticsV2JsonHandler;import io.github.hectorvent.floci.services.kms.KmsJsonHandler;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerJsonHandler;import io.github.hectorvent.floci.services.ssm.Ec2MessagesJsonHandler;@@ -75,6 +76,7 @@ public class AwsJson11Controller {private final CloudWatchLogsHandler cloudWatchLogsHandler;private final SecretsManagerJsonHandler secretsManagerJsonHandler;private final KinesisJsonHandler kinesisJsonHandler;+ private final KinesisAnalyticsV2JsonHandler kinesisAnalyticsV2JsonHandler;private final ApiGatewayV2JsonHandler apigwV2JsonHandler;private final KmsJsonHandler kmsJsonHandler;private final CognitoJsonHandler cognitoJsonHandler;@@ -113,6 +115,7 @@ public class AwsJson11Controller {CloudWatchLogsHandler cloudWatchLogsHandler,SecretsManagerJsonHandler secretsManagerJsonHandler,KinesisJsonHandler kinesisJsonHandler,+ KinesisAnalyticsV2JsonHandler kinesisAnalyticsV2JsonHandler,ApiGatewayV2JsonHandler apigwV2JsonHandler,KmsJsonHandler kmsJsonHandler, CognitoJsonHandler cognitoJsonHandler,AcmJsonHandler acmJsonHandler, EcsJsonHandler ecsJsonHandler,@@ -149,6 +152,7 @@ public class AwsJson11Controller {this.cloudWatchLogsHandler = cloudWatchLogsHandler;this.secretsManagerJsonHandler = secretsManagerJsonHandler;this.kinesisJsonHandler = kinesisJsonHandler;+ this.kinesisAnalyticsV2JsonHandler = kinesisAnalyticsV2JsonHandler;this.apigwV2JsonHandler = apigwV2JsonHandler;this.kmsJsonHandler = kmsJsonHandler;this.cognitoJsonHandler = cognitoJsonHandler;@@ -218,6 +222,7 @@ public class AwsJson11Controller {case "logs" -> cloudWatchLogsHandler.handle(action, request, region);case "secretsmanager" -> secretsManagerJsonHandler.handle(action, request, region);case "kinesis" -> kinesisJsonHandler.handle(action, request, region);+ case "kinesisanalytics" -> kinesisAnalyticsV2JsonHandler.handle(action, request, region);case "apigatewayv2" -> apigwV2JsonHandler.handle(action, request, region);case "kms" -> kmsJsonHandler.handle(action, request, region);case "cognito-idp" -> cognitoJsonHandler.handle(action, request, region);diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.javaindex 0bf6858f9b..d2fd226ee7 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java@@ -178,6 +178,11 @@ public class ResolvedServiceCatalog {"kinesis", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,protocols(ServiceProtocol.JSON, ServiceProtocol.CBOR),Set.of("Kinesis_20131202."), Set.of("kinesis"), Set.of(), Set.of()),+ descriptor("kinesisanalytics", "kinesisanalytics",+ config.services().kinesisAnalytics().enabled(), true,+ "kinesisanalytics", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,+ protocols(ServiceProtocol.JSON),+ Set.of("KinesisAnalytics_20180523."), Set.of("kinesisanalytics"), Set.of(), Set.of()),descriptor("kms", "kms", config.services().kms().enabled(), true,"kms", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,protocols(ServiceProtocol.JSON),diff --git a/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java b/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.javaindex 58af767a5c..5580dc0b26 100644--- a/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java+++ b/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java@@ -11,6 +11,7 @@ import io.github.hectorvent.floci.services.ec2.Ec2MetadataServer;import io.github.hectorvent.floci.services.ecr.registry.EcrRegistryManager;import io.github.hectorvent.floci.services.floci.ui.FlociUiManager;import io.github.hectorvent.floci.services.amazonmq.container.RabbitMqManager;+import io.github.hectorvent.floci.services.kinesisanalytics.container.FlinkContainerManager;import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheContainerManager;import io.github.hectorvent.floci.services.elasticache.container.ElastiCacheMemcachedContainerManager;import io.github.hectorvent.floci.services.elasticache.proxy.ElastiCacheProxyManager;@@ -75,6 +76,7 @@ public class EmulatorLifecycle {private final NeptuneContainerManager neptuneContainerManager;private final NeptuneProxyManager neptuneProxyManager;private final RabbitMqManager rabbitMqManager;+ private final FlinkContainerManager flinkContainerManager;private final RdsService rdsService;private final ElbV2Service elbV2Service;private final InitializationHooksRunner initializationHooksRunner;@@ -104,6 +106,7 @@ public class EmulatorLifecycle {NeptuneContainerManager neptuneContainerManager,NeptuneProxyManager neptuneProxyManager,RabbitMqManager rabbitMqManager,+ FlinkContainerManager flinkContainerManager,RdsService rdsService,ElbV2Service elbV2Service,InitializationHooksRunner initializationHooksRunner,@@ -132,6 +135,7 @@ public class EmulatorLifecycle {this.neptuneContainerManager = neptuneContainerManager;this.neptuneProxyManager = neptuneProxyManager;this.rabbitMqManager = rabbitMqManager;+ this.flinkContainerManager = flinkContainerManager;this.rdsService = rdsService;this.elbV2Service = elbV2Service;this.initializationHooksRunner = initializationHooksRunner;@@ -279,6 +283,7 @@ public class EmulatorLifecycle {docDbContainerManager.stopAll();neptuneContainerManager.stopAll();rabbitMqManager.stopAll();+ flinkContainerManager.stopAll();ecrRegistryManager.shutdown();flociUiManager.shutdown();// Centralized teardown for process-bound containers (Lambda warm pool, ECS tasks,diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsRuntimes.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsRuntimes.javanew file mode 100644index 0000000000..f63db509d0--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsRuntimes.java@@ -0,0 +1,97 @@+package io.github.hectorvent.floci.services.kinesisanalytics;++import io.github.hectorvent.floci.core.common.AwsException;++import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Optional;++/**+ * Catalog of Managed Service for Apache Flink runtime environments Floci supports, mapping each+ * AWS-shaped {@code RuntimeEnvironment} (e.g. {@code FLINK-1_18}) to the Docker image tag that+ * {@link container.FlinkContainerManager} launches for the JobManager.+ *+ * <p>Modelled on {@code services/opensearch/OpenSearchVersions}: without this map every application+ * would boot whatever {@code apache/flink:1.18} resolved to regardless of the requested+ * {@code RuntimeEnvironment} — a footgun for anyone testing version-specific Flink behaviour. Images+ * are pinned to the {@code major.minor} tag (guaranteed to exist on Docker Hub; e.g.+ * {@code apache/flink:1.18} resolves to a concrete 1.18.x).+ *+ * <p>Only the {@code FLINK-1_x} runtimes are in scope — they map to a plain Flink JobManager image.+ * The {@code SQL-1_0} and {@code ZEPPELIN-FLINK-*} (Studio) runtimes have no equivalent stock image+ * and are rejected by {@link #validate(String)}.+ */+public final class KinesisAnalyticsRuntimes {++ /** Default runtime when {@code CreateApplication} omits {@code RuntimeEnvironment}. AWS actually+ * requires the field, so this is only a defensive fallback for {@link #imageFor(String)}. */+ public static final String DEFAULT_RUNTIME = "FLINK-1_20";++ private static final Map<String, String> RUNTIME_TO_IMAGE = new LinkedHashMap<>();++ static {+ // Pinned to major.minor tags — reproducible and guaranteed present on Docker Hub. The set+ // mirrors the runtimes AWS Managed Service for Apache Flink offers: the 2.x line, plus the+ // supported 1.x versions. AWS does not offer FLINK-1_16 / FLINK-1_17, so they are omitted.+ RUNTIME_TO_IMAGE.put("FLINK-2_3", "apache/flink:2.3");+ RUNTIME_TO_IMAGE.put("FLINK-2_2", "apache/flink:2.2");+ RUNTIME_TO_IMAGE.put("FLINK-2_1", "apache/flink:2.1");+ RUNTIME_TO_IMAGE.put("FLINK-2_0", "apache/flink:2.0");+ RUNTIME_TO_IMAGE.put("FLINK-1_20", "apache/flink:1.20");+ RUNTIME_TO_IMAGE.put("FLINK-1_19", "apache/flink:1.19");+ RUNTIME_TO_IMAGE.put("FLINK-1_18", "apache/flink:1.18");+ RUNTIME_TO_IMAGE.put("FLINK-1_15", "apache/flink:1.15");+ }++ private KinesisAnalyticsRuntimes() {+ }++ /** Runtimes Floci supports, newest-first. */+ public static List<String> supportedRuntimes() {+ return List.copyOf(RUNTIME_TO_IMAGE.keySet());+ }++ /**+ * Pick the image for an application, honouring an optional operator-supplied override that+ * applies to every application regardless of {@code runtimeEnvironment} (private registry mirror,+ * pinned patch). When the override is absent this delegates to {@link #imageFor(String)}.+ */+ public static String resolveImage(Optional<String> override, String runtimeEnvironment) {+ return override.filter(o -> !o.isBlank()).orElseGet(() -> imageFor(runtimeEnvironment));+ }++ /**+ * Docker image to launch for {@code runtimeEnvironment}. Falls back to the default-runtime image+ * only when {@code runtimeEnvironment} is null/blank; unsupported runtimes throw — call+ * {@link #validate(String)} first.+ */+ public static String imageFor(String runtimeEnvironment) {+ if (runtimeEnvironment == null || runtimeEnvironment.isBlank()) {+ return RUNTIME_TO_IMAGE.get(DEFAULT_RUNTIME);+ }+ String image = RUNTIME_TO_IMAGE.get(runtimeEnvironment);+ if (image == null) {+ throw new AwsException("InvalidArgumentException",+ "Unsupported RuntimeEnvironment: " + runtimeEnvironment+ + ". Supported: " + RUNTIME_TO_IMAGE.keySet(), 400);+ }+ return image;+ }++ /**+ * Throws {@code InvalidArgumentException} when {@code runtimeEnvironment} is set but not supported.+ * A null/blank value is allowed — callers that accept an omitted value fall back to+ * {@link #DEFAULT_RUNTIME}. (Floci's service requires the field, so blanks are rejected upstream.)+ */+ public static void validate(String runtimeEnvironment) {+ if (runtimeEnvironment == null || runtimeEnvironment.isBlank()) {+ return;+ }+ if (!RUNTIME_TO_IMAGE.containsKey(runtimeEnvironment)) {+ throw new AwsException("InvalidArgumentException",+ "Unsupported RuntimeEnvironment: " + runtimeEnvironment+ + ". Supported: " + RUNTIME_TO_IMAGE.keySet(), 400);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2JsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2JsonHandler.javanew file mode 100644index 0000000000..fa25a245a9--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2JsonHandler.java@@ -0,0 +1,379 @@+package io.github.hectorvent.floci.services.kinesisanalytics;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsErrorResponse;+import io.github.hectorvent.floci.services.kinesisanalytics.model.FlinkApplication;+import io.github.hectorvent.floci.services.kinesisanalytics.model.Snapshot;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import jakarta.ws.rs.core.Response;++import java.time.Instant;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * Dispatches Kinesis Analytics V2 (Managed Service for Apache Flink) actions for the+ * {@code application/x-amz-json-1.1} protocol, routed here by {@code AwsJson11Controller}+ * on the {@code KinesisAnalytics_20180523.} target prefix.+ */+@ApplicationScoped+public class KinesisAnalyticsV2JsonHandler {++ private final KinesisAnalyticsV2Service service;+ private final ObjectMapper objectMapper;++ @Inject+ public KinesisAnalyticsV2JsonHandler(KinesisAnalyticsV2Service service, ObjectMapper objectMapper) {+ this.service = service;+ this.objectMapper = objectMapper;+ }++ public Response handle(String action, JsonNode request, String region) {+ return switch (action) {+ case "CreateApplication" -> handleCreateApplication(request);+ case "CreateApplicationPresignedUrl" -> handleCreateApplicationPresignedUrl(request);+ case "DescribeApplication" -> handleDescribeApplication(request);+ case "ListApplications" -> handleListApplications(request);+ case "StartApplication" -> handleStartApplication(request);+ case "StopApplication" -> handleStopApplication(request);+ case "UpdateApplication" -> handleUpdateApplication(request);+ case "DeleteApplication" -> handleDeleteApplication(request);+ case "TagResource" -> handleTagResource(request);+ case "UntagResource" -> handleUntagResource(request);+ case "ListTagsForResource" -> handleListTagsForResource(request);+ case "CreateApplicationSnapshot" -> handleCreateApplicationSnapshot(request);+ case "DescribeApplicationSnapshot" -> handleDescribeApplicationSnapshot(request);+ case "ListApplicationSnapshots" -> handleListApplicationSnapshots(request);+ case "DeleteApplicationSnapshot" -> handleDeleteApplicationSnapshot(request);+ default -> Response.status(400)+ .entity(new AwsErrorResponse("UnsupportedOperation",+ "Operation " + action + " is not supported."))+ .build();+ };+ }++ private Response handleCreateApplication(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ String runtimeEnvironment = request.path("RuntimeEnvironment").asText(null);+ String serviceExecutionRole = request.path("ServiceExecutionRole").asText(null);+ String applicationDescription = request.path("ApplicationDescription").asText(null);+ String applicationMode = request.path("ApplicationMode").asText(null);++ // Application code (the Flink JAR in S3) + parallelism, from ApplicationConfiguration.+ JsonNode appConfig = request.path("ApplicationConfiguration");+ JsonNode s3 = appConfig.path("ApplicationCodeConfiguration").path("CodeContent")+ .path("S3ContentLocation");+ String codeBucket = bucketFromArn(s3.path("BucketARN").asText(null));+ String codeKey = s3.path("FileKey").asText(null);+ String codeVersion = s3.path("ObjectVersion").asText(null);+ int parallelism = appConfig.path("FlinkApplicationConfiguration")+ .path("ParallelismConfiguration").path("Parallelism").asInt(1);+ Map<String, Map<String, String>> environmentProperties =+ parsePropertyGroups(appConfig.path("EnvironmentProperties").path("PropertyGroups"));+ JsonNode snapshotsEnabledNode = appConfig.path("ApplicationSnapshotConfiguration").path("SnapshotsEnabled");+ Boolean snapshotsEnabled = snapshotsEnabledNode.isMissingNode() || snapshotsEnabledNode.isNull()+ ? null : snapshotsEnabledNode.asBoolean();++ FlinkApplication app = service.createApplication(applicationName, runtimeEnvironment,+ serviceExecutionRole, applicationDescription, applicationMode,+ codeBucket, codeKey, codeVersion, parallelism, parseTags(request.path("Tags")),+ environmentProperties, snapshotsEnabled);+ return applicationDetailResponse(app);+ }++ private Response handleCreateApplicationPresignedUrl(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ String urlType = request.path("UrlType").asText(null);+ Long sessionExpirationDurationInSeconds = request.hasNonNull("SessionExpirationDurationInSeconds")+ ? request.path("SessionExpirationDurationInSeconds").asLong() : null;+ String url = service.createApplicationPresignedUrl(applicationName, urlType,+ sessionExpirationDurationInSeconds);+ ObjectNode response = objectMapper.createObjectNode();+ response.put("AuthorizedUrl", url);+ return Response.ok(response).build();+ }++ /** Extracts the bucket name from an S3 bucket ARN ({@code arn:aws:s3:::bucket}). */+ private static String bucketFromArn(String bucketArn) {+ if (bucketArn == null) {+ return null;+ }+ String prefix = "arn:aws:s3:::";+ return bucketArn.startsWith(prefix) ? bucketArn.substring(prefix.length()) : bucketArn;+ }++ private Response handleDescribeApplication(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ return applicationDetailResponse(service.describeApplication(applicationName));+ }++ private Response handleListApplications(JsonNode request) {+ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode summaries = response.putArray("ApplicationSummaries");+ for (FlinkApplication app : service.listApplications()) {+ ObjectNode summary = summaries.addObject();+ summary.put("ApplicationName", app.getApplicationName());+ summary.put("ApplicationARN", app.getApplicationArn());+ summary.put("ApplicationStatus", app.getApplicationStatus().name());+ summary.put("ApplicationVersionId", app.getApplicationVersionId());+ summary.put("RuntimeEnvironment", app.getRuntimeEnvironment());+ if (app.getApplicationMode() != null) {+ summary.put("ApplicationMode", app.getApplicationMode());+ }+ }+ return Response.ok(response).build();+ }++ private Response handleStartApplication(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ service.startApplication(applicationName);+ // AWS StartApplication returns an empty body.+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleStopApplication(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ service.stopApplication(applicationName);+ // AWS StopApplication returns an empty body.+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleUpdateApplication(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ // CurrentApplicationVersionId gates the update (optimistic concurrency); the service rejects a+ // stale or missing value.+ Long currentVersionId = request.hasNonNull("CurrentApplicationVersionId")+ ? request.path("CurrentApplicationVersionId").asLong()+ : null;+ String serviceExecutionRole = request.path("ServiceExecutionRoleUpdate").asText(null);++ // ApplicationConfigurationUpdate.ApplicationCodeConfigurationUpdate.CodeContentUpdate+ // .S3ContentLocationUpdate: a new JAR location to redeploy in place.+ JsonNode appCfgUpdate = request.path("ApplicationConfigurationUpdate");+ JsonNode s3Update = appCfgUpdate.path("ApplicationCodeConfigurationUpdate")+ .path("CodeContentUpdate").path("S3ContentLocationUpdate");+ String codeBucket = bucketFromArn(s3Update.path("BucketARNUpdate").asText(null));+ String codeKey = s3Update.path("FileKeyUpdate").asText(null);+ String codeVersion = s3Update.path("ObjectVersionUpdate").asText(null);+ JsonNode parallelismUpdate = appCfgUpdate.path("FlinkApplicationConfigurationUpdate")+ .path("ParallelismConfigurationUpdate").path("ParallelismUpdate");+ Integer parallelism = parallelismUpdate.isMissingNode() || parallelismUpdate.isNull()+ ? null : parallelismUpdate.asInt();+ JsonNode snapshotsEnabledUpdate = appCfgUpdate.path("ApplicationSnapshotConfigurationUpdate")+ .path("SnapshotsEnabledUpdate");+ Boolean snapshotsEnabled = snapshotsEnabledUpdate.isMissingNode() || snapshotsEnabledUpdate.isNull()+ ? null : snapshotsEnabledUpdate.asBoolean();++ return applicationDetailResponse(service.updateApplication(applicationName, currentVersionId,+ serviceExecutionRole, codeBucket, codeKey, codeVersion, parallelism, snapshotsEnabled));+ }++ private Response handleDeleteApplication(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ // CreateTimestamp is epoch seconds on the wire (possibly fractional); the service validates it+ // against the stored value.+ Instant createTimestamp = request.hasNonNull("CreateTimestamp")+ ? Instant.ofEpochMilli(Math.round(request.path("CreateTimestamp").asDouble() * 1000))+ : null;+ service.deleteApplication(applicationName, createTimestamp);+ // AWS DeleteApplication returns an empty body.+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleCreateApplicationSnapshot(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ String snapshotName = request.path("SnapshotName").asText(null);+ service.createApplicationSnapshot(applicationName, snapshotName);+ // AWS CreateApplicationSnapshot returns an empty body.+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleDescribeApplicationSnapshot(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ String snapshotName = request.path("SnapshotName").asText(null);+ Snapshot snapshot = service.describeApplicationSnapshot(applicationName, snapshotName);+ ObjectNode response = objectMapper.createObjectNode();+ response.set("SnapshotDetails", snapshotDetailNode(snapshot));+ return Response.ok(response).build();+ }++ private Response handleListApplicationSnapshots(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode summaries = response.putArray("SnapshotSummaries");+ for (Snapshot snapshot : service.listApplicationSnapshots(applicationName)) {+ summaries.add(snapshotDetailNode(snapshot));+ }+ return Response.ok(response).build();+ }++ private Response handleDeleteApplicationSnapshot(JsonNode request) {+ String applicationName = request.path("ApplicationName").asText(null);+ String snapshotName = request.path("SnapshotName").asText(null);+ Instant snapshotCreationTimestamp = request.hasNonNull("SnapshotCreationTimestamp")+ ? Instant.ofEpochMilli(Math.round(request.path("SnapshotCreationTimestamp").asDouble() * 1000))+ : null;+ service.deleteApplicationSnapshot(applicationName, snapshotName, snapshotCreationTimestamp);+ // AWS DeleteApplicationSnapshot returns an empty body.+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private ObjectNode snapshotDetailNode(Snapshot snapshot) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("SnapshotName", snapshot.getSnapshotName());+ node.put("SnapshotStatus", snapshot.getSnapshotStatus().name());+ node.put("ApplicationVersionId", snapshot.getApplicationVersionId());+ if (snapshot.getSnapshotCreationTimestamp() != null) {+ node.put("SnapshotCreationTimestamp", snapshot.getSnapshotCreationTimestamp().toEpochMilli() / 1000.0);+ }+ if (snapshot.getRuntimeEnvironment() != null) {+ node.put("RuntimeEnvironment", snapshot.getRuntimeEnvironment());+ }+ return node;+ }++ private Response handleTagResource(JsonNode request) {+ String resourceArn = request.path("ResourceARN").asText(null);+ service.tagResource(resourceArn, parseTags(request.path("Tags")));+ // AWS TagResource returns an empty body.+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleUntagResource(JsonNode request) {+ String resourceArn = request.path("ResourceARN").asText(null);+ List<String> tagKeys = new ArrayList<>();+ request.path("TagKeys").forEach(k -> tagKeys.add(k.asText()));+ service.untagResource(resourceArn, tagKeys);+ // AWS UntagResource returns an empty body.+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ private Response handleListTagsForResource(JsonNode request) {+ String resourceArn = request.path("ResourceARN").asText(null);+ Map<String, String> tags = service.listTagsForResource(resourceArn);+ ObjectNode response = objectMapper.createObjectNode();+ response.set("Tags", tagsNode(tags));+ return Response.ok(response).build();+ }++ /** {@code Tags} is a list of {@code {Key, Value}} objects on this API, not a string map. */+ private Map<String, String> parseTags(JsonNode tagsNode) {+ Map<String, String> tags = new LinkedHashMap<>();+ if (tagsNode != null && tagsNode.isArray()) {+ for (JsonNode tag : tagsNode) {+ String key = tag.path("Key").asText(null);+ if (key != null) {+ tags.put(key, tag.path("Value").asText(null));+ }+ }+ }+ return tags;+ }++ private ArrayNode tagsNode(Map<String, String> tags) {+ ArrayNode arr = objectMapper.createArrayNode();+ tags.forEach((k, v) -> {+ ObjectNode tag = arr.addObject();+ tag.put("Key", k);+ if (v != null) {+ tag.put("Value", v);+ }+ });+ return arr;+ }++ private Response applicationDetailResponse(FlinkApplication app) {+ ObjectNode response = objectMapper.createObjectNode();+ response.set("ApplicationDetail", applicationDetailNode(app));+ return Response.ok(response).build();+ }++ private ObjectNode applicationDetailNode(FlinkApplication app) {+ ObjectNode detail = objectMapper.createObjectNode();+ detail.put("ApplicationARN", app.getApplicationArn());+ detail.put("ApplicationName", app.getApplicationName());+ if (app.getApplicationDescription() != null) {+ detail.put("ApplicationDescription", app.getApplicationDescription());+ }+ detail.put("RuntimeEnvironment", app.getRuntimeEnvironment());+ if (app.getServiceExecutionRole() != null) {+ detail.put("ServiceExecutionRole", app.getServiceExecutionRole());+ }+ detail.put("ApplicationStatus", app.getApplicationStatus().name());+ detail.put("ApplicationVersionId", app.getApplicationVersionId());+ if (app.getApplicationMode() != null) {+ detail.put("ApplicationMode", app.getApplicationMode());+ }+ if (app.getCreateTimestamp() != null) {+ detail.put("CreateTimestamp", app.getCreateTimestamp().toEpochMilli() / 1000.0);+ }+ if (app.getLastUpdateTimestamp() != null) {+ detail.put("LastUpdateTimestamp", app.getLastUpdateTimestamp().toEpochMilli() / 1000.0);+ }+ if (app.hasCode()) {+ detail.set("ApplicationConfigurationDescription", applicationConfigurationNode(app));+ }+ return detail;+ }++ private ObjectNode applicationConfigurationNode(FlinkApplication app) {+ ObjectNode config = objectMapper.createObjectNode();++ ObjectNode codeDesc = config.putObject("ApplicationCodeConfigurationDescription");+ codeDesc.put("CodeContentType", "ZIPFILE");+ ObjectNode s3Desc = codeDesc.putObject("CodeContentDescription")+ .putObject("S3ApplicationCodeLocationDescription");+ s3Desc.put("BucketARN", "arn:aws:s3:::" + app.getCodeS3Bucket());+ s3Desc.put("FileKey", app.getCodeS3Key());+ if (app.getCodeS3ObjectVersion() != null) {+ s3Desc.put("ObjectVersion", app.getCodeS3ObjectVersion());+ }++ config.putObject("FlinkApplicationConfigurationDescription")+ .putObject("ParallelismConfigurationDescription")+ .put("Parallelism", app.getParallelism())+ .put("CurrentParallelism", app.getParallelism());++ if (!app.getEnvironmentProperties().isEmpty()) {+ ArrayNode groups = config.putObject("EnvironmentPropertyDescriptions")+ .putArray("PropertyGroupDescriptions");+ app.getEnvironmentProperties().forEach((groupId, properties) -> {+ ObjectNode group = groups.addObject();+ group.put("PropertyGroupId", groupId);+ ObjectNode map = group.putObject("PropertyMap");+ properties.forEach(map::put);+ });+ }++ config.putObject("ApplicationSnapshotConfigurationDescription")+ .put("SnapshotsEnabled", app.isSnapshotsEnabled());++ return config;+ }++ /** {@code ApplicationConfiguration.EnvironmentProperties.PropertyGroups}: a list of+ * {@code {PropertyGroupId, PropertyMap}} objects, keyed by PropertyGroupId internally since+ * that's how a Flink app looks a group up via {@code KinesisAnalyticsRuntime.getApplicationProperties()}. */+ private Map<String, Map<String, String>> parsePropertyGroups(JsonNode propertyGroupsNode) {+ Map<String, Map<String, String>> groups = new LinkedHashMap<>();+ if (propertyGroupsNode != null && propertyGroupsNode.isArray()) {+ for (JsonNode group : propertyGroupsNode) {+ String groupId = group.path("PropertyGroupId").asText(null);+ if (groupId == null) {+ continue;+ }+ Map<String, String> properties = new LinkedHashMap<>();+ group.path("PropertyMap").fields().forEachRemaining(+ entry -> properties.put(entry.getKey(), entry.getValue().asText(null)));+ groups.put(groupId, properties);+ }+ }+ return groups;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2Service.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2Service.javanew file mode 100644index 0000000000..0d09c98a64--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2Service.java@@ -0,0 +1,579 @@+package io.github.hectorvent.floci.services.kinesisanalytics;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.kinesisanalytics.container.FlinkContainerManager;+import io.github.hectorvent.floci.services.kinesisanalytics.model.ApplicationStatus;+import io.github.hectorvent.floci.services.kinesisanalytics.model.FlinkApplication;+import io.github.hectorvent.floci.services.kinesisanalytics.model.Snapshot;+import io.github.hectorvent.floci.services.kinesisanalytics.model.SnapshotStatus;+import jakarta.annotation.PostConstruct;+import jakarta.annotation.PreDestroy;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.time.Instant;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Objects;+import java.util.concurrent.Executors;+import java.util.concurrent.ScheduledExecutorService;+import java.util.concurrent.TimeUnit;++/**+ * Control plane for Managed Service for Apache Flink (Kinesis Analytics V2). Holds the+ * application state machine and delegates the real Flink cluster to {@link FlinkContainerManager}.+ *+ * <p>Modelled on {@code AmazonMqService}: {@code CreateApplication} lands in {@code READY} with no+ * container (AWS-faithful — a created application is not running); {@code StartApplication} spins up+ * a Flink JobManager container and the readiness poller flips {@code STARTING → RUNNING} once the+ * JobManager REST API answers; {@code StopApplication} tears the container down and returns to+ * {@code READY}.+ */+@ApplicationScoped+public class KinesisAnalyticsV2Service {++ private static final Logger LOG = Logger.getLogger(KinesisAnalyticsV2Service.class);++ // AWS: "the maximum number of user-defined application tags is 50" (the stated 200-tag ceiling+ // on the Tags/TagKeys shapes includes AWS-managed system tags, which floci does not model).+ private static final int MAX_USER_TAGS = 50;++ // CreateApplicationPresignedUrl's SessionExpirationDurationInSeconds valid range (30 min - 12 hr).+ private static final long MIN_SESSION_EXPIRATION_SECONDS = 1800;+ private static final long MAX_SESSION_EXPIRATION_SECONDS = 43200;++ private final StorageBackend<String, FlinkApplication> storage;+ private final EmulatorConfig config;+ private final RegionResolver regionResolver;+ private final FlinkContainerManager containerManager;+ private final ScheduledExecutorService poller = Executors.newSingleThreadScheduledExecutor();++ @Inject+ public KinesisAnalyticsV2Service(StorageFactory storageFactory, EmulatorConfig config,+ RegionResolver regionResolver,+ FlinkContainerManager containerManager) {+ this.storage = storageFactory.create("kinesisanalytics", "kinesisanalytics-applications.json",+ new TypeReference<Map<String, FlinkApplication>>() {});+ this.config = config;+ this.regionResolver = regionResolver;+ this.containerManager = containerManager;+ }++ @PostConstruct+ public void init() {+ startReadinessPoller();+ }++ @PreDestroy+ public void shutdown() {+ // Container teardown is wired into EmulatorLifecycle.onStop() via+ // FlinkContainerManager.stopAll() (ordered with the other container managers);+ // here we only stop the readiness poller. Wait briefly for an in-flight tick so a+ // mid-flight putApplication cannot race the storage flush in onStop().+ poller.shutdown();+ try {+ if (!poller.awaitTermination(5, TimeUnit.SECONDS)) {+ poller.shutdownNow();+ }+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ poller.shutdownNow();+ }+ }++ public FlinkApplication createApplication(String applicationName, String runtimeEnvironment,+ String serviceExecutionRole, String applicationDescription,+ String applicationMode) {+ return createApplication(applicationName, runtimeEnvironment, serviceExecutionRole,+ applicationDescription, applicationMode, null, null, null, 1);+ }++ public FlinkApplication createApplication(String applicationName, String runtimeEnvironment,+ String serviceExecutionRole, String applicationDescription,+ String applicationMode, String codeS3Bucket, String codeS3Key,+ String codeS3ObjectVersion, int parallelism) {+ return createApplication(applicationName, runtimeEnvironment, serviceExecutionRole,+ applicationDescription, applicationMode, codeS3Bucket, codeS3Key, codeS3ObjectVersion,+ parallelism, null);+ }++ public FlinkApplication createApplication(String applicationName, String runtimeEnvironment,+ String serviceExecutionRole, String applicationDescription,+ String applicationMode, String codeS3Bucket, String codeS3Key,+ String codeS3ObjectVersion, int parallelism,+ Map<String, String> tags) {+ return createApplication(applicationName, runtimeEnvironment, serviceExecutionRole,+ applicationDescription, applicationMode, codeS3Bucket, codeS3Key, codeS3ObjectVersion,+ parallelism, tags, null);+ }++ public FlinkApplication createApplication(String applicationName, String runtimeEnvironment,+ String serviceExecutionRole, String applicationDescription,+ String applicationMode, String codeS3Bucket, String codeS3Key,+ String codeS3ObjectVersion, int parallelism,+ Map<String, String> tags,+ Map<String, Map<String, String>> environmentProperties) {+ return createApplication(applicationName, runtimeEnvironment, serviceExecutionRole,+ applicationDescription, applicationMode, codeS3Bucket, codeS3Key, codeS3ObjectVersion,+ parallelism, tags, environmentProperties, null);+ }++ public FlinkApplication createApplication(String applicationName, String runtimeEnvironment,+ String serviceExecutionRole, String applicationDescription,+ String applicationMode, String codeS3Bucket, String codeS3Key,+ String codeS3ObjectVersion, int parallelism,+ Map<String, String> tags,+ Map<String, Map<String, String>> environmentProperties,+ Boolean snapshotsEnabled) {+ if (applicationName == null || applicationName.isBlank()) {+ throw new AwsException("InvalidArgumentException", "ApplicationName is required", 400);+ }+ if (runtimeEnvironment == null || runtimeEnvironment.isBlank()) {+ throw new AwsException("InvalidArgumentException", "RuntimeEnvironment is required", 400);+ }+ // Reject a runtime we cannot back with a Flink image up front (AWS-faithful+ // InvalidArgumentException), rather than failing later at StartApplication.+ KinesisAnalyticsRuntimes.validate(runtimeEnvironment);+ if (serviceExecutionRole == null || serviceExecutionRole.isBlank()) {+ throw new AwsException("InvalidArgumentException", "ServiceExecutionRole is required", 400);+ }+ if (storage.get(applicationName).isPresent()) {+ throw new AwsException("ResourceInUseException",+ "Application already exists: " + applicationName, 400);+ }+ if (tags != null && tags.size() > MAX_USER_TAGS) {+ throw new AwsException("TooManyTagsException",+ "The maximum number of user-defined application tags is " + MAX_USER_TAGS, 400);+ }++ String accountId = regionResolver.getAccountId();+ String arn = AwsArnUtils.Arn.of("kinesisanalytics", config.defaultRegion(), accountId,+ "application/" + applicationName).toString();+ String mode = (applicationMode == null || applicationMode.isBlank()) ? "STREAMING" : applicationMode;++ FlinkApplication app = new FlinkApplication(applicationName, arn, runtimeEnvironment,+ serviceExecutionRole, mode);+ app.setAccountId(accountId);+ app.setApplicationDescription(applicationDescription);+ // AWS-faithful: a freshly created application is READY (not RUNNING); no container yet.+ app.setApplicationStatus(ApplicationStatus.READY);+ app.setCodeS3Bucket(codeS3Bucket);+ app.setCodeS3Key(codeS3Key);+ app.setCodeS3ObjectVersion(codeS3ObjectVersion);+ app.setParallelism(parallelism < 1 ? 1 : parallelism);+ if (tags != null) {+ app.setTags(new LinkedHashMap<>(tags));+ }+ if (environmentProperties != null) {+ app.setEnvironmentProperties(new LinkedHashMap<>(environmentProperties));+ }+ if (snapshotsEnabled != null) {+ app.setSnapshotsEnabled(snapshotsEnabled);+ }++ storage.put(applicationName, app);+ LOG.infov("Created Kinesis Analytics V2 application {0}", applicationName);+ return app;+ }++ public FlinkApplication describeApplication(String applicationName) {+ return storage.get(applicationName)+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "Application not found: " + applicationName, 400));+ }++ public List<FlinkApplication> listApplications() {+ return storage.scan(k -> true);+ }++ public FlinkApplication startApplication(String applicationName) {+ FlinkApplication app = describeApplication(applicationName);+ if (app.getApplicationStatus() != ApplicationStatus.READY) {+ throw new AwsException("ResourceInUseException",+ "Application " + applicationName + " cannot be started while in state "+ + app.getApplicationStatus() + "; it must be READY", 400);+ }++ if (config.services().kinesisAnalytics().mock()) {+ // No backing container: come up immediately.+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ } else {+ try {+ // Start the container; the application stays STARTING until the readiness poller+ // observes the JobManager REST API answering.+ containerManager.startCluster(app);+ app.setApplicationStatus(ApplicationStatus.STARTING);+ } catch (AwsException e) {+ // Already an AWS-shaped client error (e.g. a missing/empty/unreadable application-code+ // S3 object from readJar); preserve its error code and message rather than masking it+ // as a 500.+ throw e;+ } catch (RuntimeException e) {+ // Unexpected provisioning failure (e.g. Docker unavailable). Keep the cause in the logs;+ // don't leak internal details into the AWS envelope. "InternalFailure" (no "Exception"+ // suffix, HTTP 500) is AWS's documented generic error common to every service's API+ // (e.g. https://docs.aws.amazon.com/comprehend/latest/APIReference/CommonErrors.html) —+ // it isn't declared per-operation in kinesisanalyticsv2's model (no operation here+ // declares any 5xx shape at all), so this isn't a code this specific API's model dictates,+ // it's the AWS-wide platform fallback, same as JsonErrorResponseUtils' own default.+ LOG.errorv(e, "Failed to start application {0}", applicationName);+ throw new AwsException("InternalFailure",+ "Failed to start application " + applicationName, 500);+ }+ }+ app.setLastUpdateTimestamp(Instant.now());+ putApplication(app);+ LOG.infov("Starting Kinesis Analytics V2 application {0}", applicationName);+ return app;+ }++ public FlinkApplication stopApplication(String applicationName) {+ FlinkApplication app = describeApplication(applicationName);+ if (app.getApplicationStatus() != ApplicationStatus.RUNNING+ && app.getApplicationStatus() != ApplicationStatus.STARTING) {+ throw new AwsException("ResourceInUseException",+ "Application " + applicationName + " cannot be stopped while in state "+ + app.getApplicationStatus() + "; it must be RUNNING or STARTING", 400);+ }+ if (!config.services().kinesisAnalytics().mock()) {+ containerManager.stopCluster(app);+ }+ // Stopping the JobManager is synchronous, so the application returns to READY directly.+ app.setApplicationStatus(ApplicationStatus.READY);+ app.setLastUpdateTimestamp(Instant.now());+ putApplication(app);+ LOG.infov("Stopped Kinesis Analytics V2 application {0}", applicationName);+ return app;+ }++ public FlinkApplication updateApplication(String applicationName, Long currentApplicationVersionId,+ String serviceExecutionRole) {+ return updateApplication(applicationName, currentApplicationVersionId, serviceExecutionRole,+ null, null, null, null);+ }++ public FlinkApplication updateApplication(String applicationName, Long currentApplicationVersionId,+ String serviceExecutionRole, String codeS3Bucket,+ String codeS3Key, String codeS3ObjectVersion,+ Integer parallelism) {+ return updateApplication(applicationName, currentApplicationVersionId, serviceExecutionRole,+ codeS3Bucket, codeS3Key, codeS3ObjectVersion, parallelism, null);+ }++ public FlinkApplication updateApplication(String applicationName, Long currentApplicationVersionId,+ String serviceExecutionRole, String codeS3Bucket,+ String codeS3Key, String codeS3ObjectVersion,+ Integer parallelism, Boolean snapshotsEnabled) {+ FlinkApplication app = describeApplication(applicationName);+ // AWS requires CurrentApplicationVersionId and rejects a stale value with+ // ConcurrentModificationException (optimistic concurrency on the application version).+ if (currentApplicationVersionId == null) {+ throw new AwsException("InvalidArgumentException",+ "CurrentApplicationVersionId is required", 400);+ }+ if (currentApplicationVersionId != app.getApplicationVersionId()) {+ throw new AwsException("ConcurrentModificationException",+ "Provided CurrentApplicationVersionId " + currentApplicationVersionId+ + " does not match the current version " + app.getApplicationVersionId(), 400);+ }+ if (serviceExecutionRole != null && !serviceExecutionRole.isBlank()) {+ app.setServiceExecutionRole(serviceExecutionRole);+ }+ boolean codeChanged = codeS3Bucket != null && !codeS3Bucket.isBlank()+ && codeS3Key != null && !codeS3Key.isBlank();+ if (codeChanged) {+ app.setCodeS3Bucket(codeS3Bucket);+ app.setCodeS3Key(codeS3Key);+ app.setCodeS3ObjectVersion(codeS3ObjectVersion);+ }+ if (parallelism != null && parallelism > 0) {+ app.setParallelism(parallelism);+ }+ if (snapshotsEnabled != null) {+ app.setSnapshotsEnabled(snapshotsEnabled);+ }++ if (codeChanged && app.getApplicationStatus() == ApplicationStatus.RUNNING+ && !config.services().kinesisAnalytics().mock()) {+ if (app.getTaskManagerContainerId() == null) {+ // The application is running as a bare cluster (no code yet); attaching code to an+ // already-running cluster for the first time is not yet emulated.+ throw new AwsException("InvalidRequestException",+ "Adding code to a running bare-cluster application is not supported; "+ + "stop and start " + applicationName + " instead", 400);+ }+ try {+ // In-place redeploy: cancel the current job and swap in the new JAR without tearing+ // down the JobManager/TaskManager containers. The readiness poller resubmits it, the+ // same way it submits a fresh job on StartApplication.+ containerManager.redeployCode(app);+ app.setApplicationStatus(ApplicationStatus.STARTING);+ } catch (AwsException e) {+ throw e;+ } catch (RuntimeException e) {+ // Same AWS-wide "InternalFailure" generic 500 as startApplication's catch above.+ LOG.errorv(e, "Failed to redeploy code for application {0}", applicationName);+ throw new AwsException("InternalFailure",+ "Failed to redeploy application code for " + applicationName, 500);+ }+ }++ app.setApplicationVersionId(app.getApplicationVersionId() + 1);+ app.setLastUpdateTimestamp(Instant.now());+ putApplication(app);+ LOG.infov("Updated Kinesis Analytics V2 application {0} to version {1}",+ applicationName, app.getApplicationVersionId());+ return app;+ }++ public void deleteApplication(String applicationName, Instant createTimestamp) {+ FlinkApplication app = describeApplication(applicationName);+ // AWS requires CreateTimestamp and rejects a value that does not match the stored one. The+ // wire value is epoch seconds, so compare at second granularity.+ if (createTimestamp == null) {+ throw new AwsException("InvalidArgumentException", "CreateTimestamp is required", 400);+ }+ if (app.getCreateTimestamp() == null+ || app.getCreateTimestamp().getEpochSecond() != createTimestamp.getEpochSecond()) {+ throw new AwsException("InvalidArgumentException",+ "Provided CreateTimestamp does not match application " + applicationName, 400);+ }+ // AWS rejects deletion of a non-stopped application (RUNNING/STARTING) with+ // ResourceInUseException; the caller must StopApplication first.+ if (app.getApplicationStatus() != ApplicationStatus.READY) {+ throw new AwsException("ResourceInUseException",+ "Application " + applicationName + " cannot be deleted while in state "+ + app.getApplicationStatus() + "; stop the application first", 400);+ }+ if (!config.services().kinesisAnalytics().mock()) {+ // No-op for a READY app with no container; also clears any stale container left from a+ // previous run (containerId is not persisted across an emulator restart).+ containerManager.stopCluster(app);+ // Only on delete, never on a plain StopApplication (stopCluster above) — the savepoints+ // volume must survive a stop/restart cycle so snapshots remain describable/listable.+ containerManager.removeSavepointsVolume(app);+ }+ storage.delete(applicationName);+ LOG.infov("Deleted Kinesis Analytics V2 application {0}", applicationName);+ }++ public Map<String, String> listTagsForResource(String resourceArn) {+ return findByArn(resourceArn).getTags();+ }++ public Map<String, String> tagResource(String resourceArn, Map<String, String> tags) {+ FlinkApplication app = findByArn(resourceArn);+ Map<String, String> merged = new LinkedHashMap<>(app.getTags());+ if (tags != null) {+ merged.putAll(tags);+ }+ if (merged.size() > MAX_USER_TAGS) {+ throw new AwsException("TooManyTagsException",+ "The maximum number of user-defined application tags is " + MAX_USER_TAGS, 400);+ }+ app.setTags(merged);+ putApplication(app);+ return app.getTags();+ }++ public Map<String, String> untagResource(String resourceArn, List<String> tagKeys) {+ FlinkApplication app = findByArn(resourceArn);+ if (tagKeys != null) {+ tagKeys.forEach(app.getTags()::remove);+ }+ putApplication(app);+ return app.getTags();+ }++ public Snapshot createApplicationSnapshot(String applicationName, String snapshotName) {+ FlinkApplication app = describeApplication(applicationName);+ if (snapshotName == null || snapshotName.isBlank()) {+ throw new AwsException("InvalidArgumentException", "SnapshotName is required", 400);+ }+ // Real AWS requires a live, running job to snapshot — a bare cluster (no code) never has one.+ if (app.getApplicationStatus() != ApplicationStatus.RUNNING || !app.hasCode()) {+ throw new AwsException("InvalidRequestException",+ "Application " + applicationName + " must be RUNNING with a deployed job to "+ + "create a snapshot", 400);+ }+ if (!app.isSnapshotsEnabled()) {+ throw new AwsException("InvalidRequestException",+ "Snapshots are not enabled for application " + applicationName, 400);+ }+ if (app.getSnapshots().containsKey(snapshotName)) {+ throw new AwsException("ResourceInUseException",+ "Snapshot already exists: " + snapshotName, 400);+ }++ Snapshot snapshot = new Snapshot(snapshotName, app.getApplicationVersionId(), app.getRuntimeEnvironment());+ if (config.services().kinesisAnalytics().mock()) {+ // No backing job to snapshot: come up READY immediately, same as StartApplication's+ // mock-mode shortcut.+ snapshot.setSnapshotStatus(SnapshotStatus.READY);+ } else {+ try {+ containerManager.createSnapshot(app, snapshot);+ } catch (RuntimeException e) {+ LOG.errorv(e, "Failed to trigger snapshot {0} for application {1}",+ snapshotName, applicationName);+ snapshot.setSnapshotStatus(SnapshotStatus.FAILED);+ }+ }+ app.getSnapshots().put(snapshotName, snapshot);+ putApplication(app);+ LOG.infov("Creating Kinesis Analytics V2 snapshot {0} for application {1}",+ snapshotName, applicationName);+ return snapshot;+ }++ public Snapshot describeApplicationSnapshot(String applicationName, String snapshotName) {+ FlinkApplication app = describeApplication(applicationName);+ Snapshot snapshot = app.getSnapshots().get(snapshotName);+ if (snapshot == null) {+ throw new AwsException("ResourceNotFoundException",+ "Snapshot not found: " + snapshotName, 400);+ }+ return snapshot;+ }++ public List<Snapshot> listApplicationSnapshots(String applicationName) {+ return List.copyOf(describeApplication(applicationName).getSnapshots().values());+ }++ public void deleteApplicationSnapshot(String applicationName, String snapshotName,+ Instant snapshotCreationTimestamp) {+ FlinkApplication app = describeApplication(applicationName);+ Snapshot snapshot = app.getSnapshots().get(snapshotName);+ if (snapshot == null) {+ throw new AwsException("ResourceNotFoundException",+ "Snapshot not found: " + snapshotName, 400);+ }+ if (snapshotCreationTimestamp == null || snapshot.getSnapshotCreationTimestamp() == null+ || snapshot.getSnapshotCreationTimestamp().getEpochSecond()+ != snapshotCreationTimestamp.getEpochSecond()) {+ throw new AwsException("InvalidArgumentException",+ "Provided SnapshotCreationTimestamp does not match snapshot " + snapshotName, 400);+ }+ if (snapshot.getSnapshotStatus() == SnapshotStatus.CREATING) {+ throw new AwsException("ResourceInUseException",+ "Snapshot " + snapshotName + " cannot be deleted while still being created", 400);+ }+ if (!config.services().kinesisAnalytics().mock()) {+ containerManager.deleteSnapshotFiles(app, snapshot);+ }+ app.getSnapshots().remove(snapshotName);+ putApplication(app);+ LOG.infov("Deleted Kinesis Analytics V2 snapshot {0} for application {1}",+ snapshotName, applicationName);+ }++ /**+ * Real AWS returns a session-authorized URL to the application's Flink Dashboard (or, for a+ * Zeppelin Studio notebook, its UI — not supported here since floci already rejects Zeppelin+ * runtimes at CreateApplication). Since floci has no real IAM-backed session/proxy layer for this,+ * it returns the JobManager's own REST/dashboard URL directly rather than a genuinely time-limited,+ * signed one — the same "real behavior, stubbed authorization" tradeoff MWAA's CreateWebLoginToken+ * makes for its own SSO handshake.+ */+ public String createApplicationPresignedUrl(String applicationName, String urlType,+ Long sessionExpirationDurationInSeconds) {+ FlinkApplication app = describeApplication(applicationName);+ if (!"FLINK_DASHBOARD_URL".equals(urlType)) {+ throw new AwsException("InvalidArgumentException",+ "Unsupported UrlType: " + urlType + "; only FLINK_DASHBOARD_URL is supported", 400);+ }+ if (sessionExpirationDurationInSeconds != null+ && (sessionExpirationDurationInSeconds < MIN_SESSION_EXPIRATION_SECONDS+ || sessionExpirationDurationInSeconds > MAX_SESSION_EXPIRATION_SECONDS)) {+ throw new AwsException("InvalidArgumentException",+ "SessionExpirationDurationInSeconds must be between " + MIN_SESSION_EXPIRATION_SECONDS+ + " and " + MAX_SESSION_EXPIRATION_SECONDS, 400);+ }+ if (app.getApplicationStatus() != ApplicationStatus.RUNNING || app.getRestEndpoint() == null) {+ throw new AwsException("ResourceInUseException",+ "Application " + applicationName + " is not available for this operation", 400);+ }+ return app.getRestEndpoint();+ }++ private FlinkApplication findByArn(String resourceArn) {+ if (resourceArn == null || resourceArn.isBlank()) {+ throw new AwsException("InvalidArgumentException", "ResourceARN is required", 400);+ }+ // Resource format is "application/<name>"; application names never contain '/'.+ int slash = resourceArn.lastIndexOf('/');+ if (slash < 0 || slash == resourceArn.length() - 1) {+ throw new AwsException("InvalidArgumentException", "Invalid resource ARN: " + resourceArn, 400);+ }+ String applicationName = resourceArn.substring(slash + 1);+ return storage.get(applicationName)+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "No application found for ARN: " + resourceArn, 400));+ }++ private void startReadinessPoller() {+ poller.scheduleAtFixedRate(() -> {+ try {+ if (config.services().kinesisAnalytics().mock()) {+ return;+ }+ for (FlinkApplication app : allApplications()) {+ boolean changed = false;+ if (app.getApplicationStatus() == ApplicationStatus.STARTING) {+ String previousJobId = app.getFlinkJobId();+ if (containerManager.advanceToRunning(app)) {+ LOG.infov("Kinesis Analytics V2 application {0} is now RUNNING",+ app.getApplicationName());+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ app.setLastUpdateTimestamp(Instant.now());+ changed = true;+ } else if (!Objects.equals(previousJobId, app.getFlinkJobId())) {+ // The Flink job was just submitted (flinkJobId newly assigned) but hasn't+ // reached RUNNING yet. Persist now rather than waiting for that: pendingJars+ // (an in-process-only cache) is already cleared at this point, so if the+ // emulator restarts before the next RUNNING-triggered persist, an unpersisted+ // flinkJobId would leave the application stuck — it could never re-fetch the+ // JAR to resubmit, nor know a job was already running to poll instead.+ changed = true;+ }+ }+ for (Snapshot snapshot : app.getSnapshots().values()) {+ if (snapshot.getSnapshotStatus() == SnapshotStatus.CREATING+ && containerManager.advanceSnapshot(app, snapshot)) {+ changed = true;+ }+ }+ if (changed) {+ putApplication(app);+ }+ }+ } catch (Exception e) {+ LOG.error("Error in Kinesis Analytics V2 readiness poller", e);+ }+ }, 1, 2, TimeUnit.SECONDS);+ }++ private List<FlinkApplication> allApplications() {+ if (storage instanceof AccountAwareStorageBackend<FlinkApplication> aware) {+ return aware.scanAllAccounts();+ }+ return storage.scan(k -> true);+ }++ private void putApplication(FlinkApplication app) {+ if (app.getAccountId() != null && storage instanceof AccountAwareStorageBackend<FlinkApplication> aware) {+ aware.putForAccount(app.getAccountId(), app.getApplicationName(), app);+ } else {+ storage.put(app.getApplicationName(), app);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkContainerManager.javanew file mode 100644index 0000000000..b873e5e52a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkContainerManager.java@@ -0,0 +1,526 @@+package io.github.hectorvent.floci.services.kinesisanalytics.container;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.ContainerInfo;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;+import io.github.hectorvent.floci.core.common.docker.ContainerSpec;+import io.github.hectorvent.floci.core.common.docker.ContainerStorageHelper;+import io.github.hectorvent.floci.services.kinesisanalytics.KinesisAnalyticsRuntimes;+import io.github.hectorvent.floci.services.kinesisanalytics.model.FlinkApplication;+import io.github.hectorvent.floci.services.kinesisanalytics.model.Snapshot;+import io.github.hectorvent.floci.services.kinesisanalytics.model.SnapshotStatus;+import io.github.hectorvent.floci.services.s3.S3Service;+import io.github.hectorvent.floci.services.s3.model.S3Object;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import com.github.dockerjava.api.async.ResultCallback;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.StreamType;+import org.apache.commons.compress.archivers.tar.TarArchiveEntry;+import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;+import org.jboss.logging.Logger;++import java.io.ByteArrayInputStream;+import java.io.ByteArrayOutputStream;+import java.io.Closeable;+import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.util.ArrayList;+import java.util.Map;+import java.util.Set;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.TimeUnit;++/**+ * Manages the backing Apache Flink cluster for a Managed Service for Apache Flink application.+ *+ * <p>The cluster is a standalone session cluster: a **JobManager** container (REST/UI on 8081) plus,+ * when the application has a code artifact to run, a **TaskManager** container that shares the+ * JobManager's network namespace ({@code --network container:<jobmanager>}) so the two communicate over+ * {@code localhost} without a dedicated Docker network. The container joins Floci's Docker network so+ * the JobManager can look up {@code http://floci:4566} to consume local Kinesis or MSK streams.+ *+ * <p>Job deployment: {@code StartApplication} reads the application JAR from Floci's local S3 (on the+ * request thread, so account context is available) and stashes the bytes; the readiness poller then+ * uploads and runs it against the cluster via {@link FlinkRestClient} once task slots are available, and+ * flips the application to RUNNING when the Flink job reaches {@code RUNNING}. An application without a+ * code artifact comes up RUNNING as a bare cluster (no job).+ */+@ApplicationScoped+public class FlinkContainerManager {++ private static final Logger LOG = Logger.getLogger(FlinkContainerManager.class);+ private static final int JOBMANAGER_REST_PORT = 8081;+ private static final String SAVEPOINTS_MOUNT = "/opt/flink/savepoints";++ private final ContainerBuilder containerBuilder;+ private final ContainerLifecycleManager lifecycleManager;+ private final ContainerLogStreamer logStreamer;+ private final ContainerDetector containerDetector;+ private final EmulatorConfig config;+ private final RegionResolver regionResolver;+ private final S3Service s3Service;+ private final FlinkRestClient flinkRest;+ private final ObjectMapper objectMapper;++ private final Map<String, Closeable> logStreams = new ConcurrentHashMap<>();+ private final Map<String, String> containerIds = new ConcurrentHashMap<>();+ private final Map<String, String> taskManagerIds = new ConcurrentHashMap<>();+ // Application JAR bytes read from S3 at StartApplication, pending upload by the readiness poller.+ private final Map<String, byte[]> pendingJars = new ConcurrentHashMap<>();+ // Applications whose job submission hard-failed (e.g. a bad JAR) — not retried by the poller.+ private final Set<String> submissionFailed = ConcurrentHashMap.newKeySet();++ @Inject+ public FlinkContainerManager(ContainerBuilder containerBuilder,+ ContainerLifecycleManager lifecycleManager,+ ContainerLogStreamer logStreamer,+ ContainerDetector containerDetector,+ EmulatorConfig config,+ RegionResolver regionResolver,+ S3Service s3Service,+ FlinkRestClient flinkRest,+ ObjectMapper objectMapper) {+ this.containerBuilder = containerBuilder;+ this.lifecycleManager = lifecycleManager;+ this.logStreamer = logStreamer;+ this.containerDetector = containerDetector;+ this.config = config;+ this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;+ this.s3Service = s3Service;+ this.flinkRest = flinkRest;+ }++ /**+ * Deterministic JobManager container name for an application, stable across emulator restarts.+ * Follows the shared {@code floci-<service>-<name>} convention via+ * {@link ContainerStorageHelper#resourceName} so a configured {@code resourceNamespace} scopes the+ * name (letting multiple Floci instances share a Docker host without collisions).+ *+ * <p>Like OpenSearch's domain names, the name is scoped by application name, not by account — two+ * accounts using the same application name would map to the same container. This mirrors AWS, where+ * an application name is account-and-region unique, and matches the accepted OpenSearch trade-off.+ */+ private String containerName(String applicationName) {+ return ContainerStorageHelper.resourceName(config, "kinesisanalytics", null, applicationName);+ }++ /**+ * Starts the JobManager (and, when the application has a code artifact, a TaskManager) for the+ * application. Reads the JAR from S3 up front (on the request thread) so a missing artifact fails+ * StartApplication fast; the JAR is uploaded/run asynchronously by the readiness poller.+ */+ public void startCluster(FlinkApplication app) {+ String image = KinesisAnalyticsRuntimes.resolveImage(+ config.services().kinesisAnalytics().defaultImage(), app.getRuntimeEnvironment());+ String jmName = containerName(app.getApplicationName());+ String tmName = jmName + "-tm";++ // Read the JAR before starting anything so a missing/empty artifact fails fast, before any+ // container is created. (S3 read runs on the request thread → account context is available.)+ byte[] jarBytes = app.hasCode() ? readJar(app) : null;++ LOG.infov("Starting Flink cluster for application {0} using image {1}{2}",+ app.getApplicationName(), image, app.hasCode() ? " (with TaskManager)" : "");+ lifecycleManager.removeIfExists(jmName);+ lifecycleManager.removeIfExists(tmName);++ // rpc.address=localhost so a same-netns TaskManager reaches the JobManager over loopback;+ // rest.bind-address=0.0.0.0 so the REST/UI is reachable via the mapped host port / container IP.+ String jmProps = "jobmanager.rpc.address: localhost\nrest.bind-address: 0.0.0.0";+ ContainerBuilder.Builder jmSpec = containerBuilder.newContainer(image)+ .withName(jmName)+ .withCmd("jobmanager")+ .withEnv("FLINK_PROPERTIES", jmProps)+ .withDockerNetwork(config.services().dockerNetwork())+ .withLogRotation();+ // Named volume (not the container's ephemeral filesystem) so snapshots survive a+ // Stop/StartApplication cycle — stopCluster() removes the JobManager container, but this+ // volume is only removed on DeleteApplication (removeSavepointsVolume), mirroring how other+ // Docker-backed services keep persistent data outside the container lifecycle.+ ContainerStorageHelper.applyStorage(jmSpec, lifecycleManager, config, "kinesisanalytics",+ app.getApplicationName() + "-savepoints", app.getApplicationName() + "-savepoints",+ SAVEPOINTS_MOUNT);+ if (!containerDetector.isRunningInContainer()) {+ jmSpec.withDynamicPort(JOBMANAGER_REST_PORT);+ } else {+ jmSpec.withExposedPort(JOBMANAGER_REST_PORT);+ }++ ContainerInfo jm;+ try {+ jm = lifecycleManager.createAndStart(jmSpec.build());+ } catch (RuntimeException e) {+ lifecycleManager.removeIfExists(jmName);+ throw e;+ }+ app.setContainerId(jm.containerId());+ containerIds.put(app.getApplicationName(), jm.containerId());+ EndpointInfo rest = jm.getEndpoint(JOBMANAGER_REST_PORT);+ app.setRestEndpoint("http://" + rest.host() + ":" + rest.port());+ attachLogs(app, jm.containerId());+ LOG.infov("Flink JobManager {0} started for application {1}: rest={2}",+ jm.containerId(), app.getApplicationName(), app.getRestEndpoint());++ if (app.hasCode()) {+ // TaskManager shares the JobManager's network namespace so it registers over localhost and+ // provides the task slots the job needs to run.+ String tmProps = "jobmanager.rpc.address: localhost\n"+ + "taskmanager.numberOfTaskSlots: " + Math.max(1, app.getParallelism());+ ContainerSpec tmSpec = containerBuilder.newContainer(image)+ .withName(tmName)+ .withCmd("taskmanager")+ .withEnv("FLINK_PROPERTIES", tmProps)+ .withNetworkMode("container:" + jm.containerId())+ .withLogRotation()+ .build();+ try {+ ContainerInfo tm = lifecycleManager.createAndStart(tmSpec);+ app.setTaskManagerContainerId(tm.containerId());+ taskManagerIds.put(app.getApplicationName(), tm.containerId());+ } catch (RuntimeException e) {+ // Roll back the whole cluster so a failed start leaves nothing behind.+ lifecycleManager.removeIfExists(tmName);+ stopCluster(app);+ throw e;+ }+ // A real MSF environment always provides this file to every Flink process (JobManager and+ // TaskManager) so KinesisAnalyticsRuntime.getApplicationProperties() never has to handle a+ // missing file, even when no EnvironmentProperties were configured (then it's an empty+ // array). User code's main() runs on the JobManager during job submission; a sink/source's+ // open() can run on either, so both containers get it.+ // /etc/flink does not exist in the stock apache/flink image (confirmed against the real+ // image) and the container's non-root "flink" user can't create it — but naming the tar+ // entry "flink/application_properties.json" and extracting into the existing /etc lets the+ // archive extraction itself create the subdirectory, which the daemon-level copy API can do+ // even though the in-container user couldn't (verified live: root:root 775, world-readable).+ byte[] propertiesJson = applicationPropertiesJson(app);+ copyFileIntoContainer(jm.containerId(), "/etc", "flink/application_properties.json", propertiesJson);+ copyFileIntoContainer(app.getTaskManagerContainerId(), "/etc", "flink/application_properties.json",+ propertiesJson);+ pendingJars.put(app.getApplicationName(), jarBytes);+ submissionFailed.remove(app.getApplicationName());+ }+ }++ /** Builds {@code /etc/flink/application_properties.json} exactly matching the real MSF/KDA runtime+ * file shape: a JSON array of {@code {PropertyGroupId, PropertyMap}} objects, the same shape as+ * the AWS API's own {@code EnvironmentProperties.PropertyGroups}. Package-private (not private)+ * so FlinkContainerManagerTest can assert on the JSON shape directly. */+ byte[] applicationPropertiesJson(FlinkApplication app) {+ ArrayNode root = objectMapper.createArrayNode();+ app.getEnvironmentProperties().forEach((groupId, properties) -> {+ ObjectNode group = root.addObject();+ group.put("PropertyGroupId", groupId);+ ObjectNode map = group.putObject("PropertyMap");+ properties.forEach(map::put);+ });+ try {+ return objectMapper.writeValueAsBytes(root);+ } catch (IOException e) {+ throw new IllegalStateException("Could not serialize application_properties.json", e);+ }+ }++ private void copyFileIntoContainer(String containerId, String remoteDir, String relativePath, byte[] content) {+ if (containerId == null) {+ return;+ }+ try {+ lifecycleManager.getDockerClient()+ .copyArchiveToContainerCmd(containerId)+ .withTarInputStream(new ByteArrayInputStream(tarSingleFile(relativePath, content)))+ .withRemotePath(remoteDir)+ .exec();+ } catch (Exception e) {+ LOG.warnv("Could not copy {0} into Flink container {1}: {2}", relativePath, containerId, e.getMessage());+ }+ }++ private static byte[] tarSingleFile(String entryName, byte[] content) {+ try {+ ByteArrayOutputStream out = new ByteArrayOutputStream();+ try (TarArchiveOutputStream tar = new TarArchiveOutputStream(out)) {+ TarArchiveEntry entry = new TarArchiveEntry(entryName);+ entry.setSize(content.length);+ entry.setMode(0644);+ tar.putArchiveEntry(entry);+ tar.write(content);+ tar.closeArchiveEntry();+ }+ return out.toByteArray();+ } catch (IOException e) {+ throw new IllegalStateException("Could not build in-memory tar for " + entryName, e);+ }+ }++ private byte[] readJar(FlinkApplication app) {+ try {+ S3Object obj = s3Service.getObject(app.getCodeS3Bucket(), app.getCodeS3Key(),+ app.getCodeS3ObjectVersion());+ byte[] data = obj != null ? obj.getData() : null;+ if (data == null || data.length == 0) {+ throw new AwsException("InvalidArgumentException",+ "Application code object is empty: s3://" + app.getCodeS3Bucket() + "/"+ + app.getCodeS3Key(), 400);+ }+ return data;+ } catch (AwsException e) {+ throw e;+ } catch (Exception e) {+ throw new AwsException("InvalidArgumentException",+ "Unable to fetch application code from s3://" + app.getCodeS3Bucket() + "/"+ + app.getCodeS3Key() + ": " + e.getMessage(), 400);+ }+ }++ /**+ * Drives the application toward RUNNING and reports whether it has reached it. For a bare cluster+ * (no code), RUNNING once the JobManager REST answers. For an application with code, this uploads+ * and runs the stashed JAR once task slots are available, then reports RUNNING when the Flink job+ * reaches {@code RUNNING}. Safe to call repeatedly from the readiness poller.+ */+ public boolean advanceToRunning(FlinkApplication app) {+ String rest = app.getRestEndpoint();+ if (rest == null || !flinkRest.isRestUp(rest)) {+ return false;+ }+ if (!app.hasCode()) {+ return true;+ }+ if (app.getFlinkJobId() == null) {+ if (submissionFailed.contains(app.getApplicationName())) {+ return false;+ }+ if (flinkRest.totalSlots(rest) < Math.max(1, app.getParallelism())) {+ return false; // TaskManager not registered yet+ }+ byte[] jar = pendingJars.get(app.getApplicationName());+ if (jar == null) {+ return false; // stashed at StartApplication; absent only after an emulator restart+ }+ try {+ String jarId = flinkRest.uploadJar(rest, jar);+ String jobId = flinkRest.runJob(rest, jarId, app.getParallelism());+ app.setFlinkJobId(jobId);+ pendingJars.remove(app.getApplicationName());+ LOG.infov("Submitted Flink job {0} for application {1}", jobId, app.getApplicationName());+ } catch (Exception e) {+ // Hard failure (e.g. a JAR with no main class) — do not resubmit every tick.+ submissionFailed.add(app.getApplicationName());+ LOG.errorv(e, "Failed to submit Flink job for application {0}", app.getApplicationName());+ }+ return false;+ }+ return "RUNNING".equals(flinkRest.jobState(rest, app.getFlinkJobId()));+ }++ /**+ * Swaps in a new application JAR on an already-running cluster ({@code UpdateApplication} with a+ * new {@code ApplicationCodeConfigurationUpdate}), without tearing down the JobManager/TaskManager+ * containers: cancels the current job (if any) and refreshes {@code application_properties.json},+ * then stashes the new JAR the same way {@link #startCluster} does so the readiness poller+ * ({@link #advanceToRunning}) picks it up and resubmits it as soon as task slots free up. Callers+ * must only invoke this when the application already has a TaskManager (a running job) — attaching+ * code to a bare cluster for the first time is not supported here.+ */+ public void redeployCode(FlinkApplication app) {+ String rest = app.getRestEndpoint();+ if (rest != null && app.getFlinkJobId() != null) {+ flinkRest.cancelJob(rest, app.getFlinkJobId());+ app.setFlinkJobId(null);+ }+ byte[] propertiesJson = applicationPropertiesJson(app);+ copyFileIntoContainer(app.getContainerId(), "/etc", "flink/application_properties.json", propertiesJson);+ copyFileIntoContainer(app.getTaskManagerContainerId(), "/etc", "flink/application_properties.json",+ propertiesJson);+ pendingJars.put(app.getApplicationName(), readJar(app));+ submissionFailed.remove(app.getApplicationName());+ LOG.infov("Redeployed code for Kinesis Analytics V2 application {0}", app.getApplicationName());+ }++ public void stopCluster(FlinkApplication app) {+ String rest = app.getRestEndpoint();+ if (rest != null && app.getFlinkJobId() != null) {+ flinkRest.cancelJob(rest, app.getFlinkJobId());+ }+ pendingJars.remove(app.getApplicationName());+ submissionFailed.remove(app.getApplicationName());++ // Stop the TaskManager first, then the JobManager (whose netns it shares).+ String tmId = taskManagerIds.remove(app.getApplicationName());+ if (tmId == null) {+ tmId = app.getTaskManagerContainerId();+ }+ if (tmId != null) {+ lifecycleManager.stopAndRemove(tmId, null);+ } else {+ lifecycleManager.removeIfExists(containerName(app.getApplicationName()) + "-tm");+ }++ containerIds.remove(app.getApplicationName());+ Closeable logHandle = logStreams.remove(app.getApplicationName());+ String jmId = app.getContainerId();+ if (jmId != null) {+ lifecycleManager.stopAndRemove(jmId, logHandle);+ LOG.infov("Flink cluster for application {0} stopped and removed", app.getApplicationName());+ } else {+ lifecycleManager.removeIfExists(containerName(app.getApplicationName()));+ }+ app.setContainerId(null);+ app.setRestEndpoint(null);+ app.setTaskManagerContainerId(null);+ app.setFlinkJobId(null);+ }++ /**+ * Triggers a Flink savepoint for the application's running job. Requires the application to+ * actually be RUNNING (a live {@code flinkJobId} and REST endpoint) — the caller+ * ({@link io.github.hectorvent.floci.services.kinesisanalytics.KinesisAnalyticsV2Service}) is+ * responsible for that AWS-shaped precondition check. Stores the async operation's+ * {@code request-id} on the snapshot for {@link #advanceSnapshot} to poll; throws on a failure to+ * even start the trigger (e.g. JobManager unreachable) so the caller can mark the snapshot FAILED.+ */+ public void createSnapshot(FlinkApplication app, Snapshot snapshot) {+ try {+ String requestId = flinkRest.triggerSavepoint(app.getRestEndpoint(), app.getFlinkJobId(),+ SAVEPOINTS_MOUNT);+ snapshot.setFlinkRequestId(requestId);+ LOG.infov("Triggered Flink savepoint for application {0} snapshot {1}: request {2}",+ app.getApplicationName(), snapshot.getSnapshotName(), requestId);+ } catch (Exception e) {+ throw new RuntimeException("Failed to trigger Flink savepoint: " + e.getMessage(), e);+ }+ }++ /**+ * Polls a CREATING snapshot toward a terminal state, mutating {@code snapshot}'s status in place.+ * Returns {@code true} once terminal (READY or FAILED) so the caller stops polling; {@code false}+ * while still in progress, including when the JobManager probe itself fails (transient — the+ * caller should keep retrying, same as {@code advanceToRunning}'s job-state polling).+ */+ public boolean advanceSnapshot(FlinkApplication app, Snapshot snapshot) {+ String rest = app.getRestEndpoint();+ if (rest == null || snapshot.getFlinkRequestId() == null) {+ return false;+ }+ FlinkRestClient.SavepointStatus status = flinkRest.savepointStatus(rest, app.getFlinkJobId(),+ snapshot.getFlinkRequestId());+ if (status == null || !"COMPLETED".equals(status.statusId())) {+ return false; // still IN_PROGRESS, or a transient probe failure — keep polling+ }+ if (status.failed()) {+ snapshot.setSnapshotStatus(SnapshotStatus.FAILED);+ LOG.warnv("Flink savepoint failed for application {0} snapshot {1}",+ app.getApplicationName(), snapshot.getSnapshotName());+ } else {+ snapshot.setSnapshotStatus(SnapshotStatus.READY);+ snapshot.setFlinkLocation(status.location());+ LOG.infov("Flink savepoint ready for application {0} snapshot {1}: {2}",+ app.getApplicationName(), snapshot.getSnapshotName(), status.location());+ }+ return true;+ }++ /** Best-effort removal of a snapshot's files. A no-op if the JobManager isn't currently running —+ * the files remain in the savepoints volume until {@link #removeSavepointsVolume} on delete. */+ public void deleteSnapshotFiles(FlinkApplication app, Snapshot snapshot) {+ String containerId = app.getContainerId();+ if (containerId == null || snapshot.getFlinkLocation() == null) {+ return;+ }+ try {+ execInContainer(containerId, new String[]{"rm", "-rf", snapshot.getFlinkLocation()});+ } catch (Exception e) {+ LOG.warnv("Could not remove savepoint files at {0} for application {1}: {2}",+ snapshot.getFlinkLocation(), app.getApplicationName(), e.getMessage());+ }+ }++ /** Removes the persistent savepoints volume. Called only on DeleteApplication, never on a plain+ * StopApplication (stopCluster), so snapshots survive a stop/restart cycle. */+ public void removeSavepointsVolume(FlinkApplication app) {+ ContainerStorageHelper.removeStorage(config, lifecycleManager, "kinesisanalytics",+ app.getApplicationName() + "-savepoints", app.getApplicationName() + "-savepoints");+ }++ /**+ * Stops and removes every running Flink container (JobManagers and TaskManagers). Wired into+ * {@code EmulatorLifecycle.onStop()} so containers are torn down on shutdown alongside the other+ * container managers.+ */+ public void stopAll() {+ if (!containerIds.isEmpty()) {+ LOG.infov("Stopping {0} Flink cluster(s) on shutdown", containerIds.size());+ }+ for (String applicationName : new ArrayList<>(taskManagerIds.keySet())) {+ String tmId = taskManagerIds.remove(applicationName);+ if (tmId != null) {+ lifecycleManager.stopAndRemove(tmId, null);+ }+ }+ for (String applicationName : new ArrayList<>(containerIds.keySet())) {+ String jmId = containerIds.remove(applicationName);+ if (jmId == null) {+ continue;+ }+ Closeable logHandle = logStreams.remove(applicationName);+ lifecycleManager.stopAndRemove(jmId, logHandle);+ }+ }++ private void attachLogs(FlinkApplication app, String containerId) {+ String shortId = containerId.length() >= 8 ? containerId.substring(0, 8) : containerId;+ String logGroup = "/aws/kinesis-analytics/" + app.getApplicationName();+ String logStream = logStreamer.generateLogStreamName(shortId);+ String region = regionResolver.getDefaultRegion();+ Closeable logHandle = logStreamer.attach(containerId, logGroup, logStream, region,+ "kinesisanalytics:" + app.getApplicationName());+ if (logHandle != null) {+ logStreams.put(app.getApplicationName(), logHandle);+ }+ }++ private ExecResult execInContainer(String containerId, String[] cmd) throws Exception {+ var dockerClient = lifecycleManager.getDockerClient();+ var exec = dockerClient.execCreateCmd(containerId)+ .withCmd(cmd)+ .withAttachStdout(true)+ .withAttachStderr(true)+ .exec();++ ByteArrayOutputStream stdout = new ByteArrayOutputStream();+ ByteArrayOutputStream stderr = new ByteArrayOutputStream();+ boolean completed = dockerClient.execStartCmd(exec.getId())+ .exec(new ResultCallback.Adapter<Frame>() {+ @Override+ public void onNext(Frame frame) {+ if (frame.getStreamType() == StreamType.STDERR) {+ stderr.writeBytes(frame.getPayload());+ } else {+ stdout.writeBytes(frame.getPayload());+ }+ }+ })+ .awaitCompletion(15, TimeUnit.SECONDS);++ if (!completed) {+ throw new RuntimeException("exec timed out in container " + containerId);+ }+ Long exitCode = dockerClient.inspectExecCmd(exec.getId()).exec().getExitCodeLong();+ return new ExecResult(exitCode != null ? exitCode : -1,+ stdout.toString(StandardCharsets.UTF_8), stderr.toString(StandardCharsets.UTF_8));+ }++ private record ExecResult(long exitCode, String stdout, String stderr) {}+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkRestClient.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkRestClient.javanew file mode 100644index 0000000000..ca0de4e169--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkRestClient.java@@ -0,0 +1,197 @@+package io.github.hectorvent.floci.services.kinesisanalytics.container;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import jakarta.enterprise.context.ApplicationScoped;+import org.jboss.logging.Logger;++import java.io.ByteArrayOutputStream;+import java.io.IOException;+import java.net.URI;+import java.net.http.HttpClient;+import java.net.http.HttpRequest;+import java.net.http.HttpResponse;+import java.nio.charset.StandardCharsets;+import java.time.Duration;++/**+ * Thin client for the Apache Flink JobManager REST API, used to deploy an application's JAR and drive+ * its job lifecycle: upload the JAR ({@code POST /jars/upload}), run it ({@code POST /jars/:id/run}),+ * poll job state ({@code GET /jobs/:id}) and cancel it ({@code PATCH /jobs/:id?mode=cancel}).+ *+ * <p>Uses the JDK {@link HttpClient} (as the rest of Floci does). Read-only probes swallow errors and+ * degrade to "not ready" so the readiness poller can retry; the deploy calls surface failures.+ */+@ApplicationScoped+public class FlinkRestClient {++ private static final Logger LOG = Logger.getLogger(FlinkRestClient.class);++ private final HttpClient http = HttpClient.newBuilder()+ .connectTimeout(Duration.ofSeconds(3))+ .build();+ private final ObjectMapper mapper = new ObjectMapper();++ /** True once the JobManager REST API answers on {@code /config} (the cluster is up). */+ public boolean isRestUp(String restBase) {+ try {+ HttpResponse<Void> resp = http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/config"))+ .timeout(Duration.ofSeconds(2)).GET().build(),+ HttpResponse.BodyHandlers.discarding());+ return resp.statusCode() == 200;+ } catch (Exception e) {+ // Expected while the JobManager is still booting.+ LOG.debugf("Flink REST %s not up yet: %s", restBase, e.toString());+ return false;+ }+ }++ /** Total task slots the cluster advertises (TaskManagers registered); 0 if the probe fails. */+ public int totalSlots(String restBase) {+ try {+ HttpResponse<String> resp = http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/overview"))+ .timeout(Duration.ofSeconds(3)).GET().build(),+ HttpResponse.BodyHandlers.ofString());+ if (resp.statusCode() != 200) {+ return 0;+ }+ return mapper.readTree(resp.body()).path("slots-total").asInt(0);+ } catch (Exception e) {+ LOG.debugf("Flink /overview probe on %s failed: %s", restBase, e.toString());+ return 0;+ }+ }++ /**+ * Uploads a JAR via {@code POST /jars/upload} (multipart form field {@code jarfile}) and returns+ * the jar id (the basename of the returned {@code filename}), used by {@link #runJob}.+ */+ public String uploadJar(String restBase, byte[] jar) throws IOException, InterruptedException {+ String boundary = "flociFlinkBoundary" + System.nanoTime();+ String head = "--" + boundary + "\r\n"+ + "Content-Disposition: form-data; name=\"jarfile\"; filename=\"application.jar\"\r\n"+ + "Content-Type: application/x-java-archive\r\n\r\n";+ String tail = "\r\n--" + boundary + "--\r\n";+ ByteArrayOutputStream body = new ByteArrayOutputStream();+ body.write(head.getBytes(StandardCharsets.UTF_8));+ body.write(jar);+ body.write(tail.getBytes(StandardCharsets.UTF_8));++ HttpResponse<String> resp = http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/jars/upload"))+ .timeout(Duration.ofSeconds(60))+ .header("Content-Type", "multipart/form-data; boundary=" + boundary)+ .POST(HttpRequest.BodyPublishers.ofByteArray(body.toByteArray()))+ .build(),+ HttpResponse.BodyHandlers.ofString());+ if (resp.statusCode() != 200) {+ throw new IOException("Flink /jars/upload failed: HTTP " + resp.statusCode() + " " + resp.body());+ }+ String filename = mapper.readTree(resp.body()).path("filename").asText("");+ int slash = filename.lastIndexOf('/');+ return slash >= 0 ? filename.substring(slash + 1) : filename;+ }++ /** Runs an uploaded jar via {@code POST /jars/:id/run} and returns the assigned Flink job id. */+ public String runJob(String restBase, String jarId, int parallelism) throws IOException, InterruptedException {+ String requestBody = "{\"parallelism\":" + Math.max(1, parallelism) + "}";+ HttpResponse<String> resp = http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/jars/" + jarId + "/run"))+ .timeout(Duration.ofSeconds(30))+ .header("Content-Type", "application/json")+ .POST(HttpRequest.BodyPublishers.ofString(requestBody))+ .build(),+ HttpResponse.BodyHandlers.ofString());+ if (resp.statusCode() != 200) {+ throw new IOException("Flink /jars/" + jarId + "/run failed: HTTP " + resp.statusCode()+ + " " + resp.body());+ }+ return mapper.readTree(resp.body()).path("jobid").asText(null);+ }++ /** Current job state (e.g. {@code RUNNING}, {@code FINISHED}, {@code FAILED}); null if unknown. */+ public String jobState(String restBase, String jobId) {+ try {+ HttpResponse<String> resp = http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/jobs/" + jobId))+ .timeout(Duration.ofSeconds(5)).GET().build(),+ HttpResponse.BodyHandlers.ofString());+ if (resp.statusCode() != 200) {+ return null;+ }+ return mapper.readTree(resp.body()).path("state").asText(null);+ } catch (Exception e) {+ LOG.debugf("Flink /jobs/%s probe on %s failed: %s", jobId, restBase, e.toString());+ return null;+ }+ }++ /** Best-effort cancel via {@code PATCH /jobs/:id?mode=cancel}. */+ public void cancelJob(String restBase, String jobId) {+ try {+ http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/jobs/" + jobId + "?mode=cancel"))+ .timeout(Duration.ofSeconds(10))+ .method("PATCH", HttpRequest.BodyPublishers.noBody()).build(),+ HttpResponse.BodyHandlers.discarding());+ } catch (Exception e) {+ // Best-effort: the container is about to be removed anyway.+ LOG.debugf("Flink cancel of job %s on %s failed: %s", jobId, restBase, e.toString());+ }+ }++ /**+ * Triggers a savepoint via {@code POST /jobs/:id/savepoints} and returns the async operation's+ * {@code request-id}, used to poll completion via {@link #savepointStatus}.+ */+ public String triggerSavepoint(String restBase, String jobId, String targetDirectory)+ throws IOException, InterruptedException {+ String requestBody = "{\"target-directory\":\"" + targetDirectory + "\",\"cancel-job\":false}";+ HttpResponse<String> resp = http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/jobs/" + jobId + "/savepoints"))+ .timeout(Duration.ofSeconds(10))+ .header("Content-Type", "application/json")+ .POST(HttpRequest.BodyPublishers.ofString(requestBody))+ .build(),+ HttpResponse.BodyHandlers.ofString());+ if (resp.statusCode() != 202 && resp.statusCode() != 200) {+ throw new IOException("Flink /jobs/" + jobId + "/savepoints trigger failed: HTTP "+ + resp.statusCode() + " " + resp.body());+ }+ return mapper.readTree(resp.body()).path("request-id").asText(null);+ }++ /**+ * Polls {@code GET /jobs/:id/savepoints/:requestId}. {@code statusId} is Flink's async-operation+ * status ({@code IN_PROGRESS}/{@code COMPLETED}); null if the probe itself failed (network/parse+ * error, e.g. the JobManager isn't reachable — different from a Flink-reported failure).+ */+ public SavepointStatus savepointStatus(String restBase, String jobId, String requestId) {+ try {+ HttpResponse<String> resp = http.send(+ HttpRequest.newBuilder(URI.create(restBase + "/jobs/" + jobId + "/savepoints/" + requestId))+ .timeout(Duration.ofSeconds(5)).GET().build(),+ HttpResponse.BodyHandlers.ofString());+ if (resp.statusCode() != 200) {+ return null;+ }+ var root = mapper.readTree(resp.body());+ String statusId = root.path("status").path("id").asText(null);+ var operation = root.path("operation");+ boolean failed = operation.has("failure-cause");+ String location = operation.path("location").asText(null);+ return new SavepointStatus(statusId, location, failed);+ } catch (Exception e) {+ LOG.debugf("Flink savepoint status probe (job %s, request %s) on %s failed: %s",+ jobId, requestId, restBase, e.toString());+ return null;+ }+ }++ /** {@code statusId}: Flink's async-operation status ({@code IN_PROGRESS}/{@code COMPLETED}).+ * {@code location}: the savepoint's path once completed successfully. {@code failed}: true when+ * Flink reports a {@code failure-cause} (the savepoint itself failed, as opposed to still running). */+ public record SavepointStatus(String statusId, String location, boolean failed) {}+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/ApplicationStatus.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/ApplicationStatus.javanew file mode 100644index 0000000000..e27eac3d7d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/ApplicationStatus.java@@ -0,0 +1,24 @@+package io.github.hectorvent.floci.services.kinesisanalytics.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * Lifecycle states for a Managed Service for Apache Flink application, mirroring the+ * {@code ApplicationStatus} enum of the AWS Kinesis Analytics V2 API. Serialized by name+ * (e.g. {@code "READY"}) to match the wire shape.+ *+ * <p>Only the states this emulator transitions through are modelled:+ * {@code CreateApplication} lands in {@link #READY}; {@code StartApplication} moves+ * {@link #STARTING} → {@link #RUNNING} (the backing Flink container coming up);+ * {@code StopApplication} returns to {@link #READY}; {@code DeleteApplication} passes+ * through {@link #DELETING}.+ */+@RegisterForReflection+public enum ApplicationStatus {+ READY,+ STARTING,+ RUNNING,+ STOPPING,+ UPDATING,+ DELETING+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/FlinkApplication.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/FlinkApplication.javanew file mode 100644index 0000000000..7480b4518f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/FlinkApplication.java@@ -0,0 +1,197 @@+package io.github.hectorvent.floci.services.kinesisanalytics.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.LinkedHashMap;+import java.util.Map;++/**+ * In-memory representation of a Managed Service for Apache Flink application+ * (Kinesis Analytics V2). Mirrors the {@code amazonmq/model/Broker} shape: a mutable+ * POJO whose {@link ApplicationStatus} transitions in place (READY → STARTING → RUNNING)+ * as the backing Flink container comes up.+ *+ * <p>Wire keys are PascalCase to match the Kinesis Analytics V2 (application/x-amz-json-1.1)+ * protocol (e.g. {@code ApplicationName}, {@code ApplicationARN}).+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class FlinkApplication {++ @JsonProperty("ApplicationName")+ private String applicationName;++ @JsonProperty("ApplicationARN")+ private String applicationArn;++ @JsonProperty("ApplicationDescription")+ private String applicationDescription;++ @JsonProperty("RuntimeEnvironment")+ private String runtimeEnvironment;++ @JsonProperty("ServiceExecutionRole")+ private String serviceExecutionRole;++ @JsonProperty("ApplicationStatus")+ private ApplicationStatus applicationStatus;++ @JsonProperty("ApplicationVersionId")+ private long applicationVersionId;++ @JsonProperty("ApplicationMode")+ private String applicationMode;++ @JsonProperty("CreateTimestamp")+ private Instant createTimestamp;++ @JsonProperty("LastUpdateTimestamp")+ private Instant lastUpdateTimestamp;++ // Internal bookkeeping — NOT part of the AWS response shape, but persisted so the+ // application stays manageable after an emulator restart in persistent mode (container+ // teardown, account-aware storage routing). The handler builds the ApplicationDetail+ // response explicitly, so these are never exposed to clients despite being stored.+ private String containerId;++ private String accountId;++ // JobManager REST endpoint (host:port) resolved when the container starts; used by the+ // readiness probe. Re-resolved on every StartApplication, so it is transient bookkeeping.+ private String restEndpoint;++ // TaskManager container id (only present when a job is deployed; the JobManager alone has no+ // task slots). Bookkeeping, not part of the AWS shape.+ private String taskManagerContainerId;++ // Flink job id assigned once the application JAR is submitted to the cluster; used to poll job+ // state and to cancel on stop. Bookkeeping, not part of the AWS shape.+ private String flinkJobId;++ // ApplicationCodeConfiguration.CodeContent.S3ContentLocation — the S3 object holding the Flink+ // application JAR. These ARE echoed back on DescribeApplication (built explicitly by the handler).+ private String codeS3Bucket;+ private String codeS3Key;+ private String codeS3ObjectVersion;++ // FlinkApplicationConfiguration.ParallelismConfiguration.Parallelism (defaults to 1).+ private int parallelism = 1;++ // ApplicationSnapshotConfiguration.SnapshotsEnabled — real AWS defaults this to true when the+ // application is created without specifying it.+ private boolean snapshotsEnabled = true;++ // Resource tags. Real AWS never echoes these in ApplicationDetail (CreateApplication /+ // DescribeApplication) — only ListTagsForResource returns them — so this is bookkeeping only,+ // like containerId/accountId above, not part of the wire response the handler builds.+ private Map<String, String> tags = new LinkedHashMap<>();++ // ApplicationConfiguration.EnvironmentProperties.PropertyGroups, keyed by PropertyGroupId (the+ // key a Flink app looks it up by via KinesisAnalyticsRuntime.getApplicationProperties()). Echoed+ // back on DescribeApplication (unlike tags) as ApplicationConfigurationDescription+ // .EnvironmentPropertyDescriptions.PropertyGroupDescriptions, built explicitly by the handler.+ private Map<String, Map<String, String>> environmentProperties = new LinkedHashMap<>();++ // Application snapshots (Flink savepoints), keyed by SnapshotName. Bookkeeping — snapshots are+ // only ever returned via CreateApplicationSnapshot/DescribeApplicationSnapshot/+ // ListApplicationSnapshots, never embedded in ApplicationDetail.+ private Map<String, Snapshot> snapshots = new LinkedHashMap<>();++ public FlinkApplication() {}++ public FlinkApplication(String applicationName, String applicationArn,+ String runtimeEnvironment, String serviceExecutionRole,+ String applicationMode) {+ this.applicationName = applicationName;+ this.applicationArn = applicationArn;+ this.runtimeEnvironment = runtimeEnvironment;+ this.serviceExecutionRole = serviceExecutionRole;+ this.applicationMode = applicationMode;+ this.applicationStatus = ApplicationStatus.READY;+ this.applicationVersionId = 1L;+ this.createTimestamp = Instant.now();+ this.lastUpdateTimestamp = this.createTimestamp;+ }++ public String getApplicationName() { return applicationName; }+ public void setApplicationName(String applicationName) { this.applicationName = applicationName; }++ public String getApplicationArn() { return applicationArn; }+ public void setApplicationArn(String applicationArn) { this.applicationArn = applicationArn; }++ public String getApplicationDescription() { return applicationDescription; }+ public void setApplicationDescription(String applicationDescription) { this.applicationDescription = applicationDescription; }++ public String getRuntimeEnvironment() { return runtimeEnvironment; }+ public void setRuntimeEnvironment(String runtimeEnvironment) { this.runtimeEnvironment = runtimeEnvironment; }++ public String getServiceExecutionRole() { return serviceExecutionRole; }+ public void setServiceExecutionRole(String serviceExecutionRole) { this.serviceExecutionRole = serviceExecutionRole; }++ public ApplicationStatus getApplicationStatus() { return applicationStatus; }+ public void setApplicationStatus(ApplicationStatus applicationStatus) { this.applicationStatus = applicationStatus; }++ public long getApplicationVersionId() { return applicationVersionId; }+ public void setApplicationVersionId(long applicationVersionId) { this.applicationVersionId = applicationVersionId; }++ public String getApplicationMode() { return applicationMode; }+ public void setApplicationMode(String applicationMode) { this.applicationMode = applicationMode; }++ public Instant getCreateTimestamp() { return createTimestamp; }+ public void setCreateTimestamp(Instant createTimestamp) { this.createTimestamp = createTimestamp; }++ public Instant getLastUpdateTimestamp() { return lastUpdateTimestamp; }+ public void setLastUpdateTimestamp(Instant lastUpdateTimestamp) { this.lastUpdateTimestamp = lastUpdateTimestamp; }++ public String getContainerId() { return containerId; }+ public void setContainerId(String containerId) { this.containerId = containerId; }++ public String getAccountId() { return accountId; }+ public void setAccountId(String accountId) { this.accountId = accountId; }++ public String getRestEndpoint() { return restEndpoint; }+ public void setRestEndpoint(String restEndpoint) { this.restEndpoint = restEndpoint; }++ public String getTaskManagerContainerId() { return taskManagerContainerId; }+ public void setTaskManagerContainerId(String taskManagerContainerId) { this.taskManagerContainerId = taskManagerContainerId; }++ public String getFlinkJobId() { return flinkJobId; }+ public void setFlinkJobId(String flinkJobId) { this.flinkJobId = flinkJobId; }++ public String getCodeS3Bucket() { return codeS3Bucket; }+ public void setCodeS3Bucket(String codeS3Bucket) { this.codeS3Bucket = codeS3Bucket; }++ public String getCodeS3Key() { return codeS3Key; }+ public void setCodeS3Key(String codeS3Key) { this.codeS3Key = codeS3Key; }++ public String getCodeS3ObjectVersion() { return codeS3ObjectVersion; }+ public void setCodeS3ObjectVersion(String codeS3ObjectVersion) { this.codeS3ObjectVersion = codeS3ObjectVersion; }++ public int getParallelism() { return parallelism; }+ public void setParallelism(int parallelism) { this.parallelism = parallelism; }++ public boolean isSnapshotsEnabled() { return snapshotsEnabled; }+ public void setSnapshotsEnabled(boolean snapshotsEnabled) { this.snapshotsEnabled = snapshotsEnabled; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags != null ? tags : new LinkedHashMap<>(); }++ public Map<String, Map<String, String>> getEnvironmentProperties() { return environmentProperties; }+ public void setEnvironmentProperties(Map<String, Map<String, String>> environmentProperties) {+ this.environmentProperties = environmentProperties != null ? environmentProperties : new LinkedHashMap<>();+ }++ public Map<String, Snapshot> getSnapshots() { return snapshots; }+ public void setSnapshots(Map<String, Snapshot> snapshots) {+ this.snapshots = snapshots != null ? snapshots : new LinkedHashMap<>();+ }++ /** True when the application has a code artifact to deploy (S3 JAR), i.e. a job should run. */+ public boolean hasCode() {+ return codeS3Bucket != null && !codeS3Bucket.isBlank()+ && codeS3Key != null && !codeS3Key.isBlank();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/Snapshot.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/Snapshot.javanew file mode 100644index 0000000000..1d4b9d9a80--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/Snapshot.java@@ -0,0 +1,74 @@+package io.github.hectorvent.floci.services.kinesisanalytics.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++/**+ * An application snapshot (a Flink savepoint under the covers), mirroring AWS's+ * {@code SnapshotDetails} shape. Stored embedded on {@link FlinkApplication}, not in its own+ * top-level storage — mirrors how tags/environment properties are embedded rather than tracked+ * separately, since a snapshot has no independent lifecycle outside its owning application.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class Snapshot {++ @JsonProperty("SnapshotName")+ private String snapshotName;++ @JsonProperty("SnapshotStatus")+ private SnapshotStatus snapshotStatus;++ @JsonProperty("ApplicationVersionId")+ private long applicationVersionId;++ @JsonProperty("SnapshotCreationTimestamp")+ private Instant snapshotCreationTimestamp;++ @JsonProperty("RuntimeEnvironment")+ private String runtimeEnvironment;++ // Internal bookkeeping — NOT part of the AWS response shape, mirroring how FlinkApplication keeps+ // containerId/restEndpoint/flinkJobId out of its own wire-facing fields.++ // The Flink REST /jobs/:id/savepoints trigger's request-id, used to poll completion status.+ private String flinkRequestId;++ // The savepoint's location once Flink reports COMPLETED (e.g.+ // /opt/flink/savepoints/savepoint-<short-job-id>-<random>), used to remove the files on delete.+ private String flinkLocation;++ public Snapshot() {}++ public Snapshot(String snapshotName, long applicationVersionId, String runtimeEnvironment) {+ this.snapshotName = snapshotName;+ this.snapshotStatus = SnapshotStatus.CREATING;+ this.applicationVersionId = applicationVersionId;+ this.snapshotCreationTimestamp = Instant.now();+ this.runtimeEnvironment = runtimeEnvironment;+ }++ public String getSnapshotName() { return snapshotName; }+ public void setSnapshotName(String snapshotName) { this.snapshotName = snapshotName; }++ public SnapshotStatus getSnapshotStatus() { return snapshotStatus; }+ public void setSnapshotStatus(SnapshotStatus snapshotStatus) { this.snapshotStatus = snapshotStatus; }++ public long getApplicationVersionId() { return applicationVersionId; }+ public void setApplicationVersionId(long applicationVersionId) { this.applicationVersionId = applicationVersionId; }++ public Instant getSnapshotCreationTimestamp() { return snapshotCreationTimestamp; }+ public void setSnapshotCreationTimestamp(Instant snapshotCreationTimestamp) { this.snapshotCreationTimestamp = snapshotCreationTimestamp; }++ public String getRuntimeEnvironment() { return runtimeEnvironment; }+ public void setRuntimeEnvironment(String runtimeEnvironment) { this.runtimeEnvironment = runtimeEnvironment; }++ public String getFlinkRequestId() { return flinkRequestId; }+ public void setFlinkRequestId(String flinkRequestId) { this.flinkRequestId = flinkRequestId; }++ public String getFlinkLocation() { return flinkLocation; }+ public void setFlinkLocation(String flinkLocation) { this.flinkLocation = flinkLocation; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/SnapshotStatus.java b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/SnapshotStatus.javanew file mode 100644index 0000000000..1cb3d8d6e3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/model/SnapshotStatus.java@@ -0,0 +1,16 @@+package io.github.hectorvent.floci.services.kinesisanalytics.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * Lifecycle states for an application snapshot, mirroring the {@code SnapshotStatus} enum of the AWS+ * Kinesis Analytics V2 API exactly ({@code CREATING}, {@code READY}, {@code DELETING}, {@code FAILED}).+ * Serialized by name to match the wire shape.+ */+@RegisterForReflection+public enum SnapshotStatus {+ CREATING,+ READY,+ DELETING,+ FAILED+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex ae57efdc76..8e1819fe96 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -241,6 +241,13 @@ floci:enabled: truemock: falsedefault-image: "rabbitmq:3-management"+ kinesis-analytics:+ enabled: true+ mock: false+ # default-image: optional override; uncomment to pin every application to a single image+ # (e.g. a private registry mirror). When unset, the image is chosen from the requested+ # RuntimeEnvironment (KinesisAnalyticsRuntimes.imageFor, e.g. FLINK-1_19 -> apache/flink:1.19).+ # default-image: "apache/flink:1.18"elasticache:enabled: trueproxy-base-port: 6379diff --git a/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java b/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.javaindex 9193228408..6386460862 100644--- a/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java+++ b/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java@@ -69,6 +69,7 @@ class EmulatorLifecycleTest {@Mock private NeptuneContainerManager neptuneContainerManager;@Mock private NeptuneProxyManager neptuneProxyManager;@Mock private io.github.hectorvent.floci.services.amazonmq.container.RabbitMqManager rabbitMqManager;+ @Mock private io.github.hectorvent.floci.services.kinesisanalytics.container.FlinkContainerManager flinkContainerManager;@Mock private RdsService rdsService;@Mock private io.github.hectorvent.floci.services.elbv2.ElbV2Service elbV2Service;@Mock private InitializationHooksRunner initializationHooksRunner;@@ -103,7 +104,7 @@ class EmulatorLifecycleTest {elastiCacheProxyManager, rdsContainerManager, rdsProxyManager,memoryDbContainerManager, memoryDbProxyManager,docDbContainerManager, neptuneContainerManager, neptuneProxyManager,- rabbitMqManager, rdsService, elbV2Service,+ rabbitMqManager, flinkContainerManager, rdsService, elbV2Service,initializationHooksRunner, sqsPoller, kinesisPoller, dynamodbStreamsPoller,pipesService, ec2MetadataServer, ecrRegistryManager, flociUiManager, initLifecycleState,schemaCreationWorker, containerTeardowns, persistentPathValidator);diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsRuntimesTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsRuntimesTest.javanew file mode 100644index 0000000000..484cd5b1b9--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsRuntimesTest.java@@ -0,0 +1,67 @@+package io.github.hectorvent.floci.services.kinesisanalytics;++import io.github.hectorvent.floci.core.common.AwsException;+import org.junit.jupiter.api.Test;++import java.util.Optional;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class KinesisAnalyticsRuntimesTest {++ @Test+ void imageForMapsRuntimeToFlinkTag() {+ assertEquals("apache/flink:1.18", KinesisAnalyticsRuntimes.imageFor("FLINK-1_18"));+ assertEquals("apache/flink:1.19", KinesisAnalyticsRuntimes.imageFor("FLINK-1_19"));+ assertEquals("apache/flink:1.20", KinesisAnalyticsRuntimes.imageFor("FLINK-1_20"));+ // Flink 2.x line+ assertEquals("apache/flink:2.0", KinesisAnalyticsRuntimes.imageFor("FLINK-2_0"));+ assertEquals("apache/flink:2.2", KinesisAnalyticsRuntimes.imageFor("FLINK-2_2"));+ assertEquals("apache/flink:2.3", KinesisAnalyticsRuntimes.imageFor("FLINK-2_3"));+ }++ @Test+ void imageForFallsBackToDefaultWhenBlank() {+ assertEquals(KinesisAnalyticsRuntimes.imageFor(KinesisAnalyticsRuntimes.DEFAULT_RUNTIME),+ KinesisAnalyticsRuntimes.imageFor(null));+ assertEquals(KinesisAnalyticsRuntimes.imageFor(KinesisAnalyticsRuntimes.DEFAULT_RUNTIME),+ KinesisAnalyticsRuntimes.imageFor(" "));+ }++ @Test+ void imageForRejectsUnsupportedRuntime() {+ // SQL / ZEPPELIN studio runtimes and bogus values have no plain Flink image.+ assertThrows(AwsException.class, () -> KinesisAnalyticsRuntimes.imageFor("SQL-1_0"));+ assertThrows(AwsException.class, () -> KinesisAnalyticsRuntimes.imageFor("FLINK-9_9"));+ // AWS does not offer 1.16 / 1.17, so Floci rejects them too.+ assertThrows(AwsException.class, () -> KinesisAnalyticsRuntimes.imageFor("FLINK-1_16"));+ assertThrows(AwsException.class, () -> KinesisAnalyticsRuntimes.imageFor("FLINK-1_17"));+ }++ @Test+ void validateAllowsSupportedAndBlankButRejectsUnknown() {+ KinesisAnalyticsRuntimes.validate("FLINK-1_20");+ KinesisAnalyticsRuntimes.validate(null);+ assertThrows(AwsException.class, () -> KinesisAnalyticsRuntimes.validate("ZEPPELIN-FLINK-3_0"));+ }++ @Test+ void resolveImageHonoursOperatorOverride() {+ // A configured override wins regardless of the requested runtime.+ assertEquals("registry.example.com/flink:pinned",+ KinesisAnalyticsRuntimes.resolveImage(+ Optional.of("registry.example.com/flink:pinned"), "FLINK-1_18"));+ // Blank/absent override falls back to the runtime map.+ assertEquals("apache/flink:1.19",+ KinesisAnalyticsRuntimes.resolveImage(Optional.empty(), "FLINK-1_19"));+ assertEquals("apache/flink:1.19",+ KinesisAnalyticsRuntimes.resolveImage(Optional.of(" "), "FLINK-1_19"));+ }++ @Test+ void supportedRuntimesListsFlinkVersions() {+ assertTrue(KinesisAnalyticsRuntimes.supportedRuntimes().contains("FLINK-1_18"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2IntegrationTest.javanew file mode 100644index 0000000000..e43d341649--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2IntegrationTest.java@@ -0,0 +1,399 @@+package io.github.hectorvent.floci.services.kinesisanalytics;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.json.config.JsonPathConfig;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItem;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.startsWith;++/**+ * Drives the full JSON-1.1 dispatch path (AwsJson11Controller → ResolvedServiceCatalog →+ * KinesisAnalyticsV2JsonHandler) via the {@code KinesisAnalytics_20180523.} target prefix.+ * Runs with {@code kinesis-analytics.mock=true} (see src/test/resources/application.yml), so no+ * Docker daemon is needed — StartApplication comes up RUNNING immediately.+ */+@QuarkusTest+class KinesisAnalyticsV2IntegrationTest {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.1";+ private static final String ROLE = "arn:aws:iam::000000000000:role/x";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private void createApplication(String name) {+ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "%s", "RuntimeEnvironment": "FLINK-1_18",+ "ServiceExecutionRole": "%s"}+ """.formatted(name, ROLE))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ApplicationDetail.ApplicationName", equalTo(name))+ .body("ApplicationDetail.ApplicationStatus", equalTo("READY"))+ .body("ApplicationDetail.ApplicationARN", startsWith("arn:aws:kinesisanalytics:"));+ }++ @Test+ void createThenDescribeApplication() {+ createApplication("it-describe");++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.DescribeApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-describe"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ApplicationDetail.ApplicationName", equalTo("it-describe"))+ .body("ApplicationDetail.RuntimeEnvironment", equalTo("FLINK-1_18"));+ }++ @Test+ void startApplicationTransitionsToRunning() {+ createApplication("it-start");++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.StartApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-start", "RunConfiguration": {}}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.DescribeApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-start"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ // mock mode: RUNNING immediately+ .body("ApplicationDetail.ApplicationStatus", equalTo("RUNNING"));+ }++ @Test+ void listApplicationsIncludesCreated() {+ createApplication("it-list");++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.ListApplications")+ .contentType(CONTENT_TYPE)+ .body("{}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ApplicationSummaries.ApplicationName", hasItem("it-list"));+ }++ @Test+ void deleteApplicationSucceeds() {+ createApplication("it-delete");++ // DeleteApplication validates CreateTimestamp against the stored value — fetch the real one+ // (epoch seconds). Use BigDecimal number handling: the default float extraction truncates the+ // ~10-digit epoch to ~7 significant figures, which would shift it by seconds and fail the match.+ String createTimestamp = given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.DescribeApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-delete"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().jsonPath(new JsonPathConfig(JsonPathConfig.NumberReturnType.BIG_DECIMAL))+ .getString("ApplicationDetail.CreateTimestamp");++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.DeleteApplication")+ .contentType(CONTENT_TYPE)+ .body("{\"ApplicationName\": \"it-delete\", \"CreateTimestamp\": " + createTimestamp + "}")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ @Test+ void tagLifecycleRoundTripsThroughTheWireProtocol() {+ String arn = given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-tags", "RuntimeEnvironment": "FLINK-1_18",+ "ServiceExecutionRole": "%s",+ "Tags": [{"Key": "env", "Value": "dev"}]}+ """.formatted(ROLE))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ // Tags is a list of {Key, Value} objects on this API, never echoed on ApplicationDetail.+ .body("ApplicationDetail.Tags", equalTo(null))+ .extract().path("ApplicationDetail.ApplicationARN");++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.ListTagsForResource")+ .contentType(CONTENT_TYPE)+ .body("{\"ResourceARN\": \"" + arn + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags.Key", hasItem("env"))+ .body("Tags.Value", hasItem("dev"));++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.TagResource")+ .contentType(CONTENT_TYPE)+ .body("{\"ResourceARN\": \"" + arn + "\", \"Tags\": [{\"Key\": \"team\", \"Value\": \"platform\"}]}")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.UntagResource")+ .contentType(CONTENT_TYPE)+ .body("{\"ResourceARN\": \"" + arn + "\", \"TagKeys\": [\"env\"]}")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.ListTagsForResource")+ .contentType(CONTENT_TYPE)+ .body("{\"ResourceARN\": \"" + arn + "\"}")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Tags.Key", hasItem("team"))+ .body("Tags.Key", not(hasItem("env")));+ }++ @Test+ void updateApplicationWithNewCodeLocationRoundTripsThroughTheWireProtocol() {+ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-update-code", "RuntimeEnvironment": "FLINK-1_18",+ "ServiceExecutionRole": "%s",+ "ApplicationConfiguration": {"ApplicationCodeConfiguration": {+ "CodeContent": {"S3ContentLocation": {+ "BucketARN": "arn:aws:s3:::flink-code", "FileKey": "app.jar"}},+ "CodeContentType": "ZIPFILE"}}}+ """.formatted(ROLE))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.UpdateApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-update-code", "CurrentApplicationVersionId": 1,+ "ApplicationConfigurationUpdate": {"ApplicationCodeConfigurationUpdate": {+ "CodeContentUpdate": {"S3ContentLocationUpdate": {+ "BucketARNUpdate": "arn:aws:s3:::flink-code-v2",+ "FileKeyUpdate": "app-v2.jar"}}}}}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ApplicationDetail.ApplicationVersionId", equalTo(2))+ .body("ApplicationDetail.ApplicationConfigurationDescription"+ + ".ApplicationCodeConfigurationDescription.CodeContentDescription"+ + ".S3ApplicationCodeLocationDescription.BucketARN", equalTo("arn:aws:s3:::flink-code-v2"))+ .body("ApplicationDetail.ApplicationConfigurationDescription"+ + ".ApplicationCodeConfigurationDescription.CodeContentDescription"+ + ".S3ApplicationCodeLocationDescription.FileKey", equalTo("app-v2.jar"));+ }++ @Test+ void snapshotLifecycleRoundTripsThroughTheWireProtocol() {+ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-snapshot", "RuntimeEnvironment": "FLINK-1_18",+ "ServiceExecutionRole": "%s",+ "ApplicationConfiguration": {"ApplicationCodeConfiguration": {+ "CodeContent": {"S3ContentLocation": {+ "BucketARN": "arn:aws:s3:::flink-code", "FileKey": "app.jar"}},+ "CodeContentType": "ZIPFILE"}}}+ """.formatted(ROLE))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.StartApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-snapshot", "RunConfiguration": {}}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplicationSnapshot")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-snapshot", "SnapshotName": "before-upgrade"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ String creationTimestamp = given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.DescribeApplicationSnapshot")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-snapshot", "SnapshotName": "before-upgrade"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("SnapshotDetails.SnapshotName", equalTo("before-upgrade"))+ // mock mode: the snapshot completes immediately, same as the application itself.+ .body("SnapshotDetails.SnapshotStatus", equalTo("READY"))+ .extract().jsonPath(new JsonPathConfig(JsonPathConfig.NumberReturnType.BIG_DECIMAL))+ .getString("SnapshotDetails.SnapshotCreationTimestamp");++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.ListApplicationSnapshots")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-snapshot"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("SnapshotSummaries.SnapshotName", hasItem("before-upgrade"));++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.DeleteApplicationSnapshot")+ .contentType(CONTENT_TYPE)+ .body("{\"ApplicationName\": \"it-snapshot\", \"SnapshotName\": \"before-upgrade\", "+ + "\"SnapshotCreationTimestamp\": " + creationTimestamp + "}")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.ListApplicationSnapshots")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-snapshot"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("SnapshotSummaries", equalTo(java.util.List.of()));+ }++ @Test+ void createApplicationWithSnapshotsDisabledRejectsCreateApplicationSnapshot() {+ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-nosnaps", "RuntimeEnvironment": "FLINK-1_18",+ "ServiceExecutionRole": "%s",+ "ApplicationConfiguration": {"ApplicationCodeConfiguration": {+ "CodeContent": {"S3ContentLocation": {+ "BucketARN": "arn:aws:s3:::flink-code", "FileKey": "app.jar"}},+ "CodeContentType": "ZIPFILE"},+ "ApplicationSnapshotConfiguration": {"SnapshotsEnabled": false}}}+ """.formatted(ROLE))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.StartApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-nosnaps", "RunConfiguration": {}}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplicationSnapshot")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-nosnaps", "SnapshotName": "attempt"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400);+ }++ @Test+ void createApplicationPresignedUrlRejectsWhenNotRunning() {+ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplication")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-presigned", "RuntimeEnvironment": "FLINK-1_18",+ "ServiceExecutionRole": "%s"}+ """.formatted(ROLE))+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .header("X-Amz-Target", "KinesisAnalytics_20180523.CreateApplicationPresignedUrl")+ .contentType(CONTENT_TYPE)+ .body("""+ {"ApplicationName": "it-presigned", "UrlType": "FLINK_DASHBOARD_URL"}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2JsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2JsonHandlerTest.javanew file mode 100644index 0000000000..96fd91540f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2JsonHandlerTest.java@@ -0,0 +1,430 @@+package io.github.hectorvent.floci.services.kinesisanalytics;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.kinesisanalytics.container.FlinkContainerManager;+import jakarta.ws.rs.core.Response;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.mockito.Mockito;++import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.is;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.mockito.Mockito.when;++class KinesisAnalyticsV2JsonHandlerTest {++ private static final String REGION = "us-east-1";+ private static final String ROLE = "arn:aws:iam::000000000000:role/x";+ private static final ObjectMapper MAPPER = new ObjectMapper();++ private KinesisAnalyticsV2JsonHandler handler;++ @BeforeEach+ void setUp() {+ handler = new KinesisAnalyticsV2JsonHandler(mockModeService(), MAPPER);+ }++ private ObjectNode entity(Response response) {+ return (ObjectNode) response.getEntity();+ }++ private void createApplication(String name) {+ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", name);+ req.put("RuntimeEnvironment", "FLINK-1_18");+ req.put("ServiceExecutionRole", ROLE);+ assertThat(handler.handle("CreateApplication", req, REGION).getStatus(), is(200));+ }++ @Test+ void createApplicationReturnsReadyDetail() {+ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "demo");+ req.put("RuntimeEnvironment", "FLINK-1_18");+ req.put("ServiceExecutionRole", ROLE);++ Response resp = handler.handle("CreateApplication", req, REGION);+ assertThat(resp.getStatus(), is(200));+ ObjectNode detail = (ObjectNode) entity(resp).get("ApplicationDetail");+ assertEquals("demo", detail.get("ApplicationName").asText());+ assertEquals("READY", detail.get("ApplicationStatus").asText());+ assertEquals(1, detail.get("ApplicationVersionId").asLong());+ assertThat(detail.get("ApplicationARN").asText().contains(":kinesisanalytics:"), is(true));+ }++ @Test+ void describeApplicationReturnsDetail() {+ createApplication("demo");++ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "demo");+ Response resp = handler.handle("DescribeApplication", req, REGION);+ assertThat(resp.getStatus(), is(200));+ ObjectNode detail = (ObjectNode) entity(resp).get("ApplicationDetail");+ assertEquals("demo", detail.get("ApplicationName").asText());+ }++ @Test+ void startThenDescribeShowsRunning() {+ createApplication("demo");++ ObjectNode start = MAPPER.createObjectNode();+ start.put("ApplicationName", "demo");+ assertThat(handler.handle("StartApplication", start, REGION).getStatus(), is(200));++ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("ApplicationName", "demo");+ ObjectNode detail = (ObjectNode) entity(handler.handle("DescribeApplication", describe, REGION))+ .get("ApplicationDetail");+ // Mock mode: the application comes up RUNNING immediately.+ assertEquals("RUNNING", detail.get("ApplicationStatus").asText());+ }++ @Test+ void listApplicationsIncludesCreated() {+ createApplication("demo-a");+ createApplication("demo-b");++ Response resp = handler.handle("ListApplications", MAPPER.createObjectNode(), REGION);+ assertThat(resp.getStatus(), is(200));+ var summaries = entity(resp).get("ApplicationSummaries");+ assertEquals(2, summaries.size());+ }++ @Test+ void deleteApplicationRemovesIt() {+ createApplication("demo");++ // DeleteApplication requires the app's CreateTimestamp (epoch seconds).+ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("ApplicationName", "demo");+ double createTs = ((ObjectNode) entity(handler.handle("DescribeApplication", describe, REGION))+ .get("ApplicationDetail")).get("CreateTimestamp").asDouble();++ ObjectNode del = MAPPER.createObjectNode();+ del.put("ApplicationName", "demo");+ del.put("CreateTimestamp", createTs);+ assertThat(handler.handle("DeleteApplication", del, REGION).getStatus(), is(200));++ var summaries = entity(handler.handle("ListApplications", MAPPER.createObjectNode(), REGION))+ .get("ApplicationSummaries");+ assertEquals(0, summaries.size());+ }++ @Test+ void createWithCodeConfigEchoesItOnDescribe() {+ ObjectNode s3 = MAPPER.createObjectNode();+ s3.put("BucketARN", "arn:aws:s3:::flink-code");+ s3.put("FileKey", "app.jar");+ ObjectNode codeCfg = MAPPER.createObjectNode();+ codeCfg.set("CodeContent", MAPPER.createObjectNode().set("S3ContentLocation", s3));+ codeCfg.put("CodeContentType", "ZIPFILE");+ ObjectNode flinkCfg = MAPPER.createObjectNode();+ flinkCfg.set("ParallelismConfiguration", MAPPER.createObjectNode().put("Parallelism", 3));+ ObjectNode appCfg = MAPPER.createObjectNode();+ appCfg.set("ApplicationCodeConfiguration", codeCfg);+ appCfg.set("FlinkApplicationConfiguration", flinkCfg);++ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "coded");+ req.put("RuntimeEnvironment", "FLINK-1_18");+ req.put("ServiceExecutionRole", ROLE);+ req.set("ApplicationConfiguration", appCfg);+ assertThat(handler.handle("CreateApplication", req, REGION).getStatus(), is(200));++ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("ApplicationName", "coded");+ ObjectNode detail = (ObjectNode) entity(handler.handle("DescribeApplication", describe, REGION))+ .get("ApplicationDetail");+ var loc = detail.get("ApplicationConfigurationDescription")+ .get("ApplicationCodeConfigurationDescription")+ .get("CodeContentDescription").get("S3ApplicationCodeLocationDescription");+ assertEquals("arn:aws:s3:::flink-code", loc.get("BucketARN").asText());+ assertEquals("app.jar", loc.get("FileKey").asText());+ assertEquals(3, detail.get("ApplicationConfigurationDescription")+ .get("FlinkApplicationConfigurationDescription")+ .get("ParallelismConfigurationDescription").get("Parallelism").asInt());+ }++ @Test+ void createWithEnvironmentPropertiesEchoesThemOnDescribe() {+ ObjectNode s3 = MAPPER.createObjectNode();+ s3.put("BucketARN", "arn:aws:s3:::flink-code");+ s3.put("FileKey", "app.jar");+ ObjectNode codeCfg = MAPPER.createObjectNode();+ codeCfg.set("CodeContent", MAPPER.createObjectNode().set("S3ContentLocation", s3));+ ObjectNode propertyGroup = MAPPER.createObjectNode();+ propertyGroup.put("PropertyGroupId", "ProducerConfigProperties");+ propertyGroup.set("PropertyMap", MAPPER.createObjectNode().put("aws.region", "us-west-2"));+ ObjectNode envProps = MAPPER.createObjectNode();+ envProps.putArray("PropertyGroups").add(propertyGroup);+ ObjectNode appCfg = MAPPER.createObjectNode();+ appCfg.set("ApplicationCodeConfiguration", codeCfg);+ appCfg.set("EnvironmentProperties", envProps);++ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "envprops");+ req.put("RuntimeEnvironment", "FLINK-1_18");+ req.put("ServiceExecutionRole", ROLE);+ req.set("ApplicationConfiguration", appCfg);+ assertThat(handler.handle("CreateApplication", req, REGION).getStatus(), is(200));++ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("ApplicationName", "envprops");+ ObjectNode detail = (ObjectNode) entity(handler.handle("DescribeApplication", describe, REGION))+ .get("ApplicationDetail");+ var groups = detail.get("ApplicationConfigurationDescription")+ .get("EnvironmentPropertyDescriptions").get("PropertyGroupDescriptions");+ assertEquals(1, groups.size());+ assertEquals("ProducerConfigProperties", groups.get(0).get("PropertyGroupId").asText());+ assertEquals("us-west-2", groups.get(0).get("PropertyMap").get("aws.region").asText());+ }++ @Test+ void createApplicationDefaultsSnapshotsEnabledToTrueOnDescribe() {+ createApplication("demo");++ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("ApplicationName", "demo");+ ObjectNode detail = (ObjectNode) entity(handler.handle("DescribeApplication", describe, REGION))+ .get("ApplicationDetail");+ // No code configured, so ApplicationConfigurationDescription isn't built at all — matches how+ // EnvironmentPropertyDescriptions is also only ever echoed when the app has code.+ assertThat(detail.has("ApplicationConfigurationDescription"), is(false));+ }++ @Test+ void createApplicationWithSnapshotsDisabledEchoesItOnDescribe() {+ ObjectNode s3 = MAPPER.createObjectNode();+ s3.put("BucketARN", "arn:aws:s3:::flink-code");+ s3.put("FileKey", "app.jar");+ ObjectNode codeCfg = MAPPER.createObjectNode();+ codeCfg.set("CodeContent", MAPPER.createObjectNode().set("S3ContentLocation", s3));+ ObjectNode appCfg = MAPPER.createObjectNode();+ appCfg.set("ApplicationCodeConfiguration", codeCfg);+ appCfg.set("ApplicationSnapshotConfiguration",+ MAPPER.createObjectNode().put("SnapshotsEnabled", false));++ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "nosnaps");+ req.put("RuntimeEnvironment", "FLINK-1_18");+ req.put("ServiceExecutionRole", ROLE);+ req.set("ApplicationConfiguration", appCfg);+ assertThat(handler.handle("CreateApplication", req, REGION).getStatus(), is(200));++ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("ApplicationName", "nosnaps");+ ObjectNode detail = (ObjectNode) entity(handler.handle("DescribeApplication", describe, REGION))+ .get("ApplicationDetail");+ assertThat(detail.get("ApplicationConfigurationDescription")+ .get("ApplicationSnapshotConfigurationDescription").get("SnapshotsEnabled").asBoolean(), is(false));++ ObjectNode createSnap = MAPPER.createObjectNode();+ createSnap.put("ApplicationName", "nosnaps");+ createSnap.put("SnapshotName", "attempt");+ assertThrows(AwsException.class, () -> handler.handle("CreateApplicationSnapshot", createSnap, REGION));+ }++ @Test+ void createApplicationPresignedUrlRejectsUnsupportedUrlType() {+ createApplication("demo");++ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "demo");+ req.put("UrlType", "ZEPPELIN_UI_URL");+ assertThrows(AwsException.class, () -> handler.handle("CreateApplicationPresignedUrl", req, REGION));+ }++ @Test+ void createApplicationPresignedUrlRejectsWhenNotRunning() {+ createApplication("demo"); // READY, never started++ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "demo");+ req.put("UrlType", "FLINK_DASHBOARD_URL");+ assertThrows(AwsException.class, () -> handler.handle("CreateApplicationPresignedUrl", req, REGION));+ }++ @Test+ void updateApplicationWithNewCodeLocationEchoesItOnDescribe() {+ createRunningCodedApplication("redeploy-target");++ ObjectNode s3Update = MAPPER.createObjectNode();+ s3Update.put("BucketARNUpdate", "arn:aws:s3:::flink-code-v2");+ s3Update.put("FileKeyUpdate", "app-v2.jar");+ ObjectNode codeCfgUpdate = MAPPER.createObjectNode();+ codeCfgUpdate.set("CodeContentUpdate", MAPPER.createObjectNode().set("S3ContentLocationUpdate", s3Update));+ ObjectNode appCfgUpdate = MAPPER.createObjectNode();+ appCfgUpdate.set("ApplicationCodeConfigurationUpdate", codeCfgUpdate);++ ObjectNode updateReq = MAPPER.createObjectNode();+ updateReq.put("ApplicationName", "redeploy-target");+ updateReq.put("CurrentApplicationVersionId", 1L);+ updateReq.set("ApplicationConfigurationUpdate", appCfgUpdate);+ Response updated = handler.handle("UpdateApplication", updateReq, REGION);+ assertThat(updated.getStatus(), is(200));+ ObjectNode detail = (ObjectNode) entity(updated).get("ApplicationDetail");+ assertEquals(2L, detail.get("ApplicationVersionId").asLong());++ var loc = detail.get("ApplicationConfigurationDescription")+ .get("ApplicationCodeConfigurationDescription")+ .get("CodeContentDescription").get("S3ApplicationCodeLocationDescription");+ assertEquals("arn:aws:s3:::flink-code-v2", loc.get("BucketARN").asText());+ assertEquals("app-v2.jar", loc.get("FileKey").asText());+ }++ @Test+ void unsupportedActionReturns400() {+ Response resp = handler.handle("BogusAction", MAPPER.createObjectNode(), REGION);+ assertThat(resp.getStatus(), is(400));+ }++ @Test+ void createApplicationWithTagsThenListTagsForResourceRoundTrips() {+ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", "tagged");+ req.put("RuntimeEnvironment", "FLINK-1_18");+ req.put("ServiceExecutionRole", ROLE);+ req.putArray("Tags")+ .addObject().put("Key", "env").put("Value", "dev");+ Response created = handler.handle("CreateApplication", req, REGION);+ assertThat(created.getStatus(), is(200));+ // Tags is a list of {Key, Value} objects on this API, never echoed on ApplicationDetail.+ assertThat(entity(created).get("ApplicationDetail").has("Tags"), is(false));++ String arn = entity(created).get("ApplicationDetail").get("ApplicationARN").asText();+ ObjectNode listReq = MAPPER.createObjectNode();+ listReq.put("ResourceARN", arn);+ Response listed = handler.handle("ListTagsForResource", listReq, REGION);+ assertThat(listed.getStatus(), is(200));+ var tags = entity(listed).get("Tags");+ assertEquals(1, tags.size());+ assertEquals("env", tags.get(0).get("Key").asText());+ assertEquals("dev", tags.get(0).get("Value").asText());+ }++ @Test+ void tagResourceThenUntagResourceRoundTrips() {+ createApplication("demo");+ String arn = describeArn("demo");++ ObjectNode tagReq = MAPPER.createObjectNode();+ tagReq.put("ResourceARN", arn);+ tagReq.putArray("Tags").addObject().put("Key", "team").put("Value", "platform");+ assertThat(handler.handle("TagResource", tagReq, REGION).getStatus(), is(200));++ ObjectNode listReq = MAPPER.createObjectNode();+ listReq.put("ResourceARN", arn);+ assertEquals(1, entity(handler.handle("ListTagsForResource", listReq, REGION)).get("Tags").size());++ ObjectNode untagReq = MAPPER.createObjectNode();+ untagReq.put("ResourceARN", arn);+ untagReq.putArray("TagKeys").add("team");+ assertThat(handler.handle("UntagResource", untagReq, REGION).getStatus(), is(200));++ assertEquals(0, entity(handler.handle("ListTagsForResource", listReq, REGION)).get("Tags").size());+ }++ @Test+ void createApplicationSnapshotThenDescribeAndListThenDeleteRoundTrips() {+ createRunningCodedApplication("streaming");++ ObjectNode createSnap = MAPPER.createObjectNode();+ createSnap.put("ApplicationName", "streaming");+ createSnap.put("SnapshotName", "before-upgrade");+ assertThat(handler.handle("CreateApplicationSnapshot", createSnap, REGION).getStatus(), is(200));++ ObjectNode describeSnap = MAPPER.createObjectNode();+ describeSnap.put("ApplicationName", "streaming");+ describeSnap.put("SnapshotName", "before-upgrade");+ Response described = handler.handle("DescribeApplicationSnapshot", describeSnap, REGION);+ assertThat(described.getStatus(), is(200));+ ObjectNode details = (ObjectNode) entity(described).get("SnapshotDetails");+ assertEquals("before-upgrade", details.get("SnapshotName").asText());+ // Mock mode: the snapshot completes immediately, same as the application itself.+ assertEquals("READY", details.get("SnapshotStatus").asText());+ double creationTimestamp = details.get("SnapshotCreationTimestamp").asDouble();++ Response listed = handler.handle("ListApplicationSnapshots",+ MAPPER.createObjectNode().put("ApplicationName", "streaming"), REGION);+ assertThat(listed.getStatus(), is(200));+ var summaries = entity(listed).get("SnapshotSummaries");+ assertEquals(1, summaries.size());+ assertEquals("before-upgrade", summaries.get(0).get("SnapshotName").asText());++ ObjectNode deleteSnap = MAPPER.createObjectNode();+ deleteSnap.put("ApplicationName", "streaming");+ deleteSnap.put("SnapshotName", "before-upgrade");+ deleteSnap.put("SnapshotCreationTimestamp", creationTimestamp);+ assertThat(handler.handle("DeleteApplicationSnapshot", deleteSnap, REGION).getStatus(), is(200));++ var afterDelete = entity(handler.handle("ListApplicationSnapshots",+ MAPPER.createObjectNode().put("ApplicationName", "streaming"), REGION)).get("SnapshotSummaries");+ assertEquals(0, afterDelete.size());+ }++ @Test+ void createApplicationSnapshotFailsWhenApplicationNotRunning() {+ createApplication("demo");++ ObjectNode createSnap = MAPPER.createObjectNode();+ createSnap.put("ApplicationName", "demo");+ createSnap.put("SnapshotName", "before-upgrade");+ assertThrows(AwsException.class, () -> handler.handle("CreateApplicationSnapshot", createSnap, REGION));+ }++ private void createRunningCodedApplication(String name) {+ ObjectNode s3 = MAPPER.createObjectNode();+ s3.put("BucketARN", "arn:aws:s3:::flink-code");+ s3.put("FileKey", "app.jar");+ ObjectNode codeCfg = MAPPER.createObjectNode();+ codeCfg.set("CodeContent", MAPPER.createObjectNode().set("S3ContentLocation", s3));+ codeCfg.put("CodeContentType", "ZIPFILE");+ ObjectNode appCfg = MAPPER.createObjectNode();+ appCfg.set("ApplicationCodeConfiguration", codeCfg);++ ObjectNode req = MAPPER.createObjectNode();+ req.put("ApplicationName", name);+ req.put("RuntimeEnvironment", "FLINK-1_18");+ req.put("ServiceExecutionRole", ROLE);+ req.set("ApplicationConfiguration", appCfg);+ assertThat(handler.handle("CreateApplication", req, REGION).getStatus(), is(200));++ ObjectNode start = MAPPER.createObjectNode();+ start.put("ApplicationName", name);+ assertThat(handler.handle("StartApplication", start, REGION).getStatus(), is(200));+ }++ private String describeArn(String name) {+ ObjectNode describe = MAPPER.createObjectNode();+ describe.put("ApplicationName", name);+ return entity(handler.handle("DescribeApplication", describe, REGION))+ .get("ApplicationDetail").get("ApplicationARN").asText();+ }++ private KinesisAnalyticsV2Service mockModeService() {+ StorageFactory storageFactory = Mockito.mock(StorageFactory.class);+ when(storageFactory.create(Mockito.anyString(), Mockito.anyString(), Mockito.any()))+ .thenReturn(new InMemoryStorage<>());++ EmulatorConfig config = Mockito.mock(EmulatorConfig.class);+ var servicesConfig = Mockito.mock(EmulatorConfig.ServicesConfig.class);+ var kaConfig = Mockito.mock(EmulatorConfig.KinesisAnalyticsServiceConfig.class);+ when(config.services()).thenReturn(servicesConfig);+ when(servicesConfig.kinesisAnalytics()).thenReturn(kaConfig);+ when(kaConfig.mock()).thenReturn(true);+ when(config.defaultRegion()).thenReturn("us-east-1");++ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");+ return new KinesisAnalyticsV2Service(storageFactory, config, regionResolver,+ Mockito.mock(FlinkContainerManager.class));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2ServiceTest.javanew file mode 100644index 0000000000..bf620c094d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2ServiceTest.java@@ -0,0 +1,625 @@+package io.github.hectorvent.floci.services.kinesisanalytics;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.kinesisanalytics.container.FlinkContainerManager;+import io.github.hectorvent.floci.services.kinesisanalytics.model.ApplicationStatus;+import io.github.hectorvent.floci.services.kinesisanalytics.model.FlinkApplication;+import io.github.hectorvent.floci.services.kinesisanalytics.model.Snapshot;+import io.github.hectorvent.floci.services.kinesisanalytics.model.SnapshotStatus;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.mockito.Mockito;++import java.util.HashMap;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.when;++class KinesisAnalyticsV2ServiceTest {++ private static final String ROLE = "arn:aws:iam::000000000000:role/x";++ private KinesisAnalyticsV2Service service;++ @BeforeEach+ void setUp() {+ service = mockModeService();+ }++ private FlinkApplication create(String name) {+ return service.createApplication(name, "FLINK-1_18", ROLE, "desc", "STREAMING");+ }++ @Test+ void createApplicationLandsInReady() {+ // AWS-faithful: a freshly created application is READY, not RUNNING.+ FlinkApplication app = create("demo");+ assertEquals("demo", app.getApplicationName());+ assertEquals("FLINK-1_18", app.getRuntimeEnvironment());+ assertEquals(ApplicationStatus.READY, app.getApplicationStatus());+ assertEquals(1L, app.getApplicationVersionId());+ assertTrue(app.getApplicationArn().contains(":kinesisanalytics:"));+ assertTrue(app.getApplicationArn().contains("application/demo"));+ }++ @Test+ void createApplicationRequiresName() {+ assertThrows(AwsException.class,+ () -> service.createApplication(" ", "FLINK-1_18", ROLE, null, null));+ }++ @Test+ void createApplicationRequiresRuntimeEnvironment() {+ assertThrows(AwsException.class,+ () -> service.createApplication("demo", null, ROLE, null, null));+ }++ @Test+ void createApplicationRequiresServiceExecutionRole() {+ assertThrows(AwsException.class,+ () -> service.createApplication("demo", "FLINK-1_18", null, null, null));+ }++ @Test+ void createApplicationRejectsUnsupportedRuntime() {+ // SQL/ZEPPELIN studio runtimes and bogus values are not backable with a Flink image.+ assertThrows(AwsException.class,+ () -> service.createApplication("demo", "ZEPPELIN-FLINK-3_0", ROLE, null, null));+ }++ @Test+ void createApplicationRejectsDuplicateName() {+ create("demo");+ assertThrows(AwsException.class, () -> create("demo"));+ }++ @Test+ void describeApplicationThrowsWhenMissing() {+ assertThrows(AwsException.class, () -> service.describeApplication("nope"));+ }++ @Test+ void startApplicationRunsInMockMode() {+ create("demo");+ FlinkApplication started = service.startApplication("demo");+ // In mock mode there is no container: the application comes up RUNNING immediately.+ assertEquals(ApplicationStatus.RUNNING, started.getApplicationStatus());+ }++ @Test+ void startApplicationRejectedWhenNotReady() {+ create("demo");+ service.startApplication("demo");+ // Already RUNNING → cannot start again.+ assertThrows(AwsException.class, () -> service.startApplication("demo"));+ }++ @Test+ void stopApplicationReturnsToReady() {+ create("demo");+ service.startApplication("demo");+ FlinkApplication stopped = service.stopApplication("demo");+ assertEquals(ApplicationStatus.READY, stopped.getApplicationStatus());+ }++ @Test+ void stopApplicationRejectedWhenNotRunning() {+ create("demo");+ // Still READY (never started) → cannot stop.+ assertThrows(AwsException.class, () -> service.stopApplication("demo"));+ }++ @Test+ void updateApplicationBumpsVersion() {+ create("demo");+ FlinkApplication updated = service.updateApplication("demo", 1L, "arn:aws:iam::000000000000:role/y");+ assertEquals(2L, updated.getApplicationVersionId());+ assertEquals("arn:aws:iam::000000000000:role/y", updated.getServiceExecutionRole());+ }++ @Test+ void updateApplicationRejectsStaleVersion() {+ create("demo"); // version 1+ // Optimistic concurrency: a mismatched CurrentApplicationVersionId is rejected.+ assertThrows(AwsException.class, () -> service.updateApplication("demo", 5L, null));+ }++ @Test+ void deleteApplicationRemovesIt() {+ FlinkApplication app = create("demo");+ service.deleteApplication("demo", app.getCreateTimestamp());+ assertTrue(service.listApplications().isEmpty());+ }++ @Test+ void deleteApplicationRejectsWrongTimestamp() {+ create("demo");+ assertThrows(AwsException.class,+ () -> service.deleteApplication("demo", java.time.Instant.ofEpochSecond(1)));+ }++ @Test+ void deleteApplicationRejectedWhileRunning() {+ FlinkApplication app = create("demo");+ service.startApplication("demo"); // mock mode → RUNNING+ // AWS rejects delete of a running application; it must be stopped first.+ assertThrows(AwsException.class,+ () -> service.deleteApplication("demo", app.getCreateTimestamp()));+ }++ @Test+ void startApplicationWrapsProvisioningFailure() {+ // Real mode with a container manager that fails: the AWS envelope must not leak the+ // internal cause, but the operation must throw. "InternalFailure" (no "Exception" suffix) is+ // AWS's documented generic 500 common to every service's API, not a kinesisanalyticsv2-specific+ // shape (this service's model declares no 5xx shape at all).+ KinesisAnalyticsV2Service realMode = realModeServiceWithFailingManager();+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null);+ AwsException ex = assertThrows(AwsException.class, () -> realMode.startApplication("demo"));+ assertEquals("InternalFailure", ex.getErrorCode());+ assertEquals(500, ex.getHttpStatus());+ }++ @Test+ void startApplicationPreservesAwsExceptionFromCodeFetch() {+ // A bad application-code S3 location makes startCluster throw AwsException(InvalidArgumentException).+ // It must propagate as-is (400 client error), not be masked as InternalFailure (500).+ FlinkContainerManager failing = Mockito.mock(FlinkContainerManager.class);+ Mockito.doThrow(new AwsException("InvalidArgumentException",+ "Unable to fetch application code from s3://b/missing.jar", 400))+ .when(failing).startCluster(Mockito.any());+ KinesisAnalyticsV2Service realMode = buildService(false, failing);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null);++ AwsException ex = assertThrows(AwsException.class, () -> realMode.startApplication("demo"));+ assertEquals("InvalidArgumentException", ex.getErrorCode());+ }++ @Test+ void createApplicationStoresCodeConfig() {+ FlinkApplication app = service.createApplication("coded", "FLINK-1_18", ROLE, null, null,+ "flink-code", "app.jar", "v2", 4);+ assertTrue(app.hasCode());+ assertEquals("flink-code", app.getCodeS3Bucket());+ assertEquals("app.jar", app.getCodeS3Key());+ assertEquals("v2", app.getCodeS3ObjectVersion());+ assertEquals(4, app.getParallelism());+ }++ @Test+ void createApplicationWithoutCodeHasNoCode() {+ FlinkApplication app = create("bare");+ assertFalse(app.hasCode());+ assertEquals(1, app.getParallelism());+ }++ @Test+ void createApplicationStoresTags() {+ FlinkApplication app = service.createApplication("tagged", "FLINK-1_18", ROLE, null, null,+ null, null, null, 1, Map.of("env", "dev"));+ assertEquals("dev", app.getTags().get("env"));+ }++ @Test+ void createApplicationStoresEnvironmentProperties() {+ Map<String, Map<String, String>> groups = Map.of(+ "ProducerConfigProperties", Map.of("aws.region", "us-west-2"));+ FlinkApplication app = service.createApplication("props", "FLINK-1_18", ROLE, null, null,+ null, null, null, 1, null, groups);+ assertEquals("us-west-2",+ app.getEnvironmentProperties().get("ProducerConfigProperties").get("aws.region"));+ }++ @Test+ void createApplicationDefaultsSnapshotsEnabledToTrue() {+ FlinkApplication app = create("demo");+ assertTrue(app.isSnapshotsEnabled());+ }++ @Test+ void createApplicationWithSnapshotsDisabled() {+ FlinkApplication app = service.createApplication("demo", "FLINK-1_18", ROLE, null, null,+ null, null, null, 1, null, null, false);+ assertFalse(app.isSnapshotsEnabled());+ }++ @Test+ void createApplicationRejectsTooManyTags() {+ Map<String, String> tooMany = new HashMap<>();+ for (int i = 0; i < 51; i++) {+ tooMany.put("k" + i, "v");+ }+ AwsException ex = assertThrows(AwsException.class, () -> service.createApplication(+ "tagged", "FLINK-1_18", ROLE, null, null, null, null, null, 1, tooMany));+ assertEquals("TooManyTagsException", ex.getErrorCode());+ }++ @Test+ void tagResourceThenListTagsForResourceRoundTrips() {+ FlinkApplication app = create("demo");++ Map<String, String> after = service.tagResource(app.getApplicationArn(), Map.of("team", "platform"));+ assertEquals("platform", after.get("team"));+ assertEquals("platform", service.listTagsForResource(app.getApplicationArn()).get("team"));+ }++ @Test+ void untagResourceRemovesKeys() {+ FlinkApplication app = create("demo");+ service.tagResource(app.getApplicationArn(), Map.of("team", "platform", "env", "dev"));++ Map<String, String> after = service.untagResource(app.getApplicationArn(), List.of("team"));+ assertFalse(after.containsKey("team"));+ assertEquals("dev", after.get("env"));+ }++ @Test+ void tagResourceRejectsUnknownArn() {+ assertThrows(AwsException.class, () -> service.tagResource(+ "arn:aws:kinesisanalytics:us-east-1:000000000000:application/nope", Map.of("k", "v")));+ }++ @Test+ void tagResourceRejectsExceedingMaxTags() {+ FlinkApplication app = create("demo");+ Map<String, String> tooMany = new HashMap<>();+ for (int i = 0; i < 51; i++) {+ tooMany.put("k" + i, "v");+ }+ AwsException ex = assertThrows(AwsException.class,+ () -> service.tagResource(app.getApplicationArn(), tooMany));+ assertEquals("TooManyTagsException", ex.getErrorCode());+ }++ private FlinkApplication createRunningWithCode(String name) {+ service.createApplication(name, "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);+ return service.startApplication(name); // mock mode: RUNNING immediately+ }++ @Test+ void createApplicationSnapshotRequiresRunningApplication() {+ create("demo"); // READY, never started+ AwsException ex = assertThrows(AwsException.class,+ () -> service.createApplicationSnapshot("demo", "snap1"));+ assertEquals("InvalidRequestException", ex.getErrorCode());+ }++ @Test+ void createApplicationSnapshotRejectsWhenSnapshotsDisabled() {+ service.createApplication("demo", "FLINK-1_18", ROLE, null, null,+ "bucket", "app.jar", null, 1, null, null, false);+ service.startApplication("demo"); // mock mode: RUNNING immediately++ AwsException ex = assertThrows(AwsException.class,+ () -> service.createApplicationSnapshot("demo", "snap1"));+ assertEquals("InvalidRequestException", ex.getErrorCode());+ }++ @Test+ void updateApplicationTogglesSnapshotsEnabled() {+ FlinkApplication app = createRunningWithCode("demo");+ assertTrue(app.isSnapshotsEnabled());++ service.updateApplication("demo", 1L, null, null, null, null, null, false);++ AwsException ex = assertThrows(AwsException.class,+ () -> service.createApplicationSnapshot("demo", "snap1"));+ assertEquals("InvalidRequestException", ex.getErrorCode());+ }++ @Test+ void createApplicationSnapshotRequiresCode() {+ create("demo");+ service.startApplication("demo"); // mock mode: RUNNING even with no code+ AwsException ex = assertThrows(AwsException.class,+ () -> service.createApplicationSnapshot("demo", "snap1"));+ assertEquals("InvalidRequestException", ex.getErrorCode());+ }++ @Test+ void createApplicationSnapshotSucceedsInMockMode() {+ createRunningWithCode("demo");+ Snapshot snapshot = service.createApplicationSnapshot("demo", "snap1");+ assertEquals(SnapshotStatus.READY, snapshot.getSnapshotStatus());+ assertEquals(1L, snapshot.getApplicationVersionId());+ }++ @Test+ void createApplicationSnapshotRejectsDuplicateName() {+ createRunningWithCode("demo");+ service.createApplicationSnapshot("demo", "snap1");+ AwsException ex = assertThrows(AwsException.class,+ () -> service.createApplicationSnapshot("demo", "snap1"));+ assertEquals("ResourceInUseException", ex.getErrorCode());+ }++ @Test+ void describeApplicationSnapshotThrowsWhenMissing() {+ createRunningWithCode("demo");+ assertThrows(AwsException.class, () -> service.describeApplicationSnapshot("demo", "nope"));+ }++ @Test+ void listApplicationSnapshotsIncludesCreated() {+ createRunningWithCode("demo");+ service.createApplicationSnapshot("demo", "snap1");+ service.createApplicationSnapshot("demo", "snap2");+ assertEquals(2, service.listApplicationSnapshots("demo").size());+ }++ @Test+ void deleteApplicationSnapshotRemovesIt() {+ createRunningWithCode("demo");+ Snapshot snapshot = service.createApplicationSnapshot("demo", "snap1");+ service.deleteApplicationSnapshot("demo", "snap1", snapshot.getSnapshotCreationTimestamp());+ assertTrue(service.listApplicationSnapshots("demo").isEmpty());+ }++ @Test+ void deleteApplicationSnapshotRejectsWrongTimestamp() {+ createRunningWithCode("demo");+ service.createApplicationSnapshot("demo", "snap1");+ assertThrows(AwsException.class, () -> service.deleteApplicationSnapshot(+ "demo", "snap1", java.time.Instant.ofEpochSecond(1)));+ }++ @Test+ void deleteApplicationSnapshotRejectsWhileStillCreating() {+ // Real mode, but the mocked FlinkContainerManager.createSnapshot never actually advances the+ // snapshot to READY/FAILED, so it stays CREATING — matching a real Flink savepoint still+ // in flight when a delete is attempted.+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);+ // Real mode's startApplication only marks STARTING; force RUNNING directly to isolate the+ // snapshot precondition from the readiness-poller mechanics already covered elsewhere.+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ Snapshot snapshot = realMode.createApplicationSnapshot("demo", "snap1");+ assertEquals(SnapshotStatus.CREATING, snapshot.getSnapshotStatus());++ AwsException ex = assertThrows(AwsException.class, () -> realMode.deleteApplicationSnapshot(+ "demo", "snap1", snapshot.getSnapshotCreationTimestamp()));+ assertEquals("ResourceInUseException", ex.getErrorCode());+ }++ @Test+ void createApplicationSnapshotMarksFailedWhenTriggerThrows() {+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ Mockito.doThrow(new RuntimeException("jobmanager unreachable"))+ .when(manager).createSnapshot(Mockito.any(), Mockito.any());+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);++ // The trigger failure marks the snapshot FAILED rather than failing CreateApplicationSnapshot+ // itself, the same async-follow-up-failure shape job submission already uses.+ Snapshot snapshot = realMode.createApplicationSnapshot("demo", "snap1");+ assertEquals(SnapshotStatus.FAILED, snapshot.getSnapshotStatus());+ }++ @Test+ void updateApplicationWithNewCodeWhileReadyJustUpdatesStoredCode() {+ service.createApplication("demo", "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);++ FlinkApplication updated = service.updateApplication("demo", 1L, null,+ "flink-code", "v2.jar", null, null);++ assertEquals("flink-code", updated.getCodeS3Bucket());+ assertEquals("v2.jar", updated.getCodeS3Key());+ assertEquals(ApplicationStatus.READY, updated.getApplicationStatus());+ assertEquals(2L, updated.getApplicationVersionId());+ }++ @Test+ void updateApplicationUpdatesParallelism() {+ create("demo");+ FlinkApplication updated = service.updateApplication("demo", 1L, null, null, null, null, 5);+ assertEquals(5, updated.getParallelism());+ }++ @Test+ void updateApplicationRedeploysCodeInPlaceWhenRunningInRealMode() {+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ app.setTaskManagerContainerId("tm-1");+ app.setFlinkJobId("job-1");++ FlinkApplication updated = realMode.updateApplication("demo", 1L, null,+ "bucket", "v2.jar", null, null);++ Mockito.verify(manager).redeployCode(app);+ assertEquals("v2.jar", updated.getCodeS3Key());+ assertEquals(ApplicationStatus.STARTING, updated.getApplicationStatus());+ }++ @Test+ void updateApplicationWrapsRedeployFailureAsInternalFailure() {+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ Mockito.doThrow(new RuntimeException("docker unavailable"))+ .when(manager).redeployCode(Mockito.any());+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ app.setTaskManagerContainerId("tm-1");++ AwsException ex = assertThrows(AwsException.class, () -> realMode.updateApplication(+ "demo", 1L, null, "bucket", "v2.jar", null, null));+ assertEquals("InternalFailure", ex.getErrorCode());+ assertEquals(500, ex.getHttpStatus());+ }++ @Test+ void updateApplicationRejectsCodeChangeOnRunningBareCluster() {+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);++ AwsException ex = assertThrows(AwsException.class, () -> realMode.updateApplication(+ "demo", 1L, null, "bucket", "app.jar", null, null));+ assertEquals("InvalidRequestException", ex.getErrorCode());+ Mockito.verify(manager, Mockito.never()).redeployCode(Mockito.any());+ }++ @Test+ void updateApplicationWithCodeChangeInMockModeSkipsContainerRedeploy() {+ service.createApplication("demo", "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);+ service.startApplication("demo"); // mock mode: RUNNING immediately, no container++ FlinkApplication updated = service.updateApplication("demo", 1L, null,+ "bucket", "v2.jar", null, null);++ assertEquals("v2.jar", updated.getCodeS3Key());+ // Mock mode has no container to redeploy against, so the application simply stays RUNNING.+ assertEquals(ApplicationStatus.RUNNING, updated.getApplicationStatus());+ }++ @Test+ void createApplicationPresignedUrlReturnsRestEndpointWhenRunning() {+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ app.setRestEndpoint("http://localhost:41000");++ String url = realMode.createApplicationPresignedUrl("demo", "FLINK_DASHBOARD_URL", 1800L);+ assertEquals("http://localhost:41000", url);+ }++ @Test+ void createApplicationPresignedUrlRejectsWhenNotRunning() {+ create("demo"); // READY, never started+ AwsException ex = assertThrows(AwsException.class,+ () -> service.createApplicationPresignedUrl("demo", "FLINK_DASHBOARD_URL", null));+ assertEquals("ResourceInUseException", ex.getErrorCode());+ }++ @Test+ void createApplicationPresignedUrlRejectsUnsupportedUrlType() {+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ app.setRestEndpoint("http://localhost:41000");++ AwsException ex = assertThrows(AwsException.class,+ () -> realMode.createApplicationPresignedUrl("demo", "ZEPPELIN_UI_URL", null));+ assertEquals("InvalidArgumentException", ex.getErrorCode());+ }++ @Test+ void createApplicationPresignedUrlRejectsOutOfRangeExpiration() {+ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ KinesisAnalyticsV2Service realMode = buildService(false, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.RUNNING);+ app.setRestEndpoint("http://localhost:41000");++ AwsException ex = assertThrows(AwsException.class,+ () -> realMode.createApplicationPresignedUrl("demo", "FLINK_DASHBOARD_URL", 100L));+ assertEquals("InvalidArgumentException", ex.getErrorCode());+ }++ @Test+ void createApplicationPresignedUrlRejectsUnknownApplication() {+ assertThrows(AwsException.class,+ () -> service.createApplicationPresignedUrl("nope", "FLINK_DASHBOARD_URL", null));+ }++ @Test+ void readinessPollerPersistsFlinkJobIdAssignedBeforeReachingRunning() throws InterruptedException {+ // Regression test: advanceToRunning can assign flinkJobId on a tick where the Flink job has+ // been submitted but hasn't reached RUNNING yet (it returns false in that case). That+ // intermediate state must still be persisted — not just the final RUNNING transition — since+ // pendingJars (a separate in-process-only cache) is already cleared by then; an emulator+ // restart before the next persist would otherwise leave the application permanently stuck.+ InMemoryStorage<String, FlinkApplication> backing = Mockito.spy(new InMemoryStorage<>());+ StorageFactory storageFactory = Mockito.mock(StorageFactory.class);+ Mockito.doReturn(backing).when(storageFactory)+ .create(Mockito.anyString(), Mockito.anyString(), Mockito.any());++ EmulatorConfig config = Mockito.mock(EmulatorConfig.class);+ var servicesConfig = Mockito.mock(EmulatorConfig.ServicesConfig.class);+ var kaConfig = Mockito.mock(EmulatorConfig.KinesisAnalyticsServiceConfig.class);+ when(config.services()).thenReturn(servicesConfig);+ when(servicesConfig.kinesisAnalytics()).thenReturn(kaConfig);+ when(kaConfig.mock()).thenReturn(false);+ when(config.defaultRegion()).thenReturn("us-east-1");++ FlinkContainerManager manager = Mockito.mock(FlinkContainerManager.class);+ when(manager.advanceToRunning(Mockito.any())).thenAnswer(invocation -> {+ FlinkApplication app = invocation.getArgument(0);+ if (app.getFlinkJobId() == null) {+ app.setFlinkJobId("job-1"); // job just submitted; not yet RUNNING+ }+ return false;+ });++ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");+ KinesisAnalyticsV2Service realMode =+ new KinesisAnalyticsV2Service(storageFactory, config, regionResolver, manager);+ realMode.createApplication("demo", "FLINK-1_18", ROLE, null, null, "bucket", "app.jar", null, 1);+ FlinkApplication app = realMode.describeApplication("demo");+ app.setApplicationStatus(ApplicationStatus.STARTING);+ Mockito.clearInvocations(backing); // ignore createApplication's own put()++ try {+ // @PostConstruct isn't wired by a plain `new` in this unit test; start the poller manually.+ realMode.init();+ // The poller's first tick fires ~1s after scheduling; give it margin.+ Thread.sleep(1500);++ Mockito.verify(backing, Mockito.atLeastOnce()).put(Mockito.eq("demo"), Mockito.any());+ assertEquals("job-1", realMode.describeApplication("demo").getFlinkJobId());+ } finally {+ realMode.shutdown();+ }+ }++ private KinesisAnalyticsV2Service mockModeService() {+ return buildService(true, Mockito.mock(FlinkContainerManager.class));+ }++ private KinesisAnalyticsV2Service realModeServiceWithFailingManager() {+ FlinkContainerManager failing = Mockito.mock(FlinkContainerManager.class);+ Mockito.doThrow(new RuntimeException("docker unavailable"))+ .when(failing).startCluster(Mockito.any());+ return buildService(false, failing);+ }++ private KinesisAnalyticsV2Service buildService(boolean mock, FlinkContainerManager manager) {+ StorageFactory storageFactory = Mockito.mock(StorageFactory.class);+ when(storageFactory.create(Mockito.anyString(), Mockito.anyString(), Mockito.any()))+ .thenReturn(new InMemoryStorage<>());++ EmulatorConfig config = Mockito.mock(EmulatorConfig.class);+ var servicesConfig = Mockito.mock(EmulatorConfig.ServicesConfig.class);+ var kaConfig = Mockito.mock(EmulatorConfig.KinesisAnalyticsServiceConfig.class);+ when(config.services()).thenReturn(servicesConfig);+ when(servicesConfig.kinesisAnalytics()).thenReturn(kaConfig);+ when(kaConfig.mock()).thenReturn(mock);+ when(config.defaultRegion()).thenReturn("us-east-1");++ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");+ return new KinesisAnalyticsV2Service(storageFactory, config, regionResolver, manager);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkContainerManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkContainerManagerTest.javanew file mode 100644index 0000000000..99c1d5093d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/container/FlinkContainerManagerTest.java@@ -0,0 +1,81 @@+package io.github.hectorvent.floci.services.kinesisanalytics.container;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;+import io.github.hectorvent.floci.services.kinesisanalytics.model.FlinkApplication;+import io.github.hectorvent.floci.services.s3.S3Service;+import org.junit.jupiter.api.Test;+import org.mockito.Mockito;++import java.util.LinkedHashMap;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Unit coverage for {@link FlinkContainerManager}'s {@code application_properties.json} construction —+ * the JSON shape must exactly match real MSF/KDA's runtime file so a real+ * {@code KinesisAnalyticsRuntime.getApplicationProperties()} call in a user's JAR finds it. The+ * container-injection path itself (tar-entry-prefix trick to create the non-existent {@code /etc/flink}+ * directory via the daemon-level copy) was verified live against a real {@code apache/flink} image+ * rather than re-implemented here with a mocked DockerClient — see the design notes on the injection+ * call sites for what was checked and why.+ */+class FlinkContainerManagerTest {++ private static final ObjectMapper MAPPER = new ObjectMapper();++ private FlinkContainerManager manager() {+ return new FlinkContainerManager(+ Mockito.mock(ContainerBuilder.class),+ Mockito.mock(ContainerLifecycleManager.class),+ Mockito.mock(ContainerLogStreamer.class),+ Mockito.mock(ContainerDetector.class),+ Mockito.mock(EmulatorConfig.class),+ Mockito.mock(RegionResolver.class),+ Mockito.mock(S3Service.class),+ Mockito.mock(FlinkRestClient.class),+ MAPPER);+ }++ @Test+ void applicationPropertiesJsonMatchesTheRealMsfFileShape() throws Exception {+ FlinkApplication app = new FlinkApplication("demo", "arn:aws:kinesisanalytics:us-east-1:000000000000:application/demo",+ "FLINK-1_18", "arn:aws:iam::000000000000:role/x", "STREAMING");+ Map<String, Map<String, String>> groups = new LinkedHashMap<>();+ groups.put("ProducerConfigProperties", Map.of("flink.stream.initpos", "LATEST", "aws.region", "us-west-2"));+ groups.put("ConsumerConfigProperties", Map.of("aws.region", "us-west-2"));+ app.setEnvironmentProperties(groups);++ byte[] json = manager().applicationPropertiesJson(app);+ JsonNode root = MAPPER.readTree(json);++ assertTrue(root.isArray());+ assertEquals(2, root.size());+ assertEquals("ProducerConfigProperties", root.get(0).get("PropertyGroupId").asText());+ assertEquals("LATEST", root.get(0).get("PropertyMap").get("flink.stream.initpos").asText());+ assertEquals("us-west-2", root.get(0).get("PropertyMap").get("aws.region").asText());+ assertEquals("ConsumerConfigProperties", root.get(1).get("PropertyGroupId").asText());+ }++ @Test+ void applicationPropertiesJsonIsAnEmptyArrayWhenNoPropertiesConfigured() throws Exception {+ FlinkApplication app = new FlinkApplication("bare", "arn:aws:kinesisanalytics:us-east-1:000000000000:application/bare",+ "FLINK-1_18", "arn:aws:iam::000000000000:role/x", "STREAMING");++ byte[] json = manager().applicationPropertiesJson(app);+ JsonNode root = MAPPER.readTree(json);++ // Real MSF always provides the file, even with zero property groups configured, so+ // KinesisAnalyticsRuntime.getApplicationProperties() never has to handle a missing file.+ assertTrue(root.isArray());+ assertEquals(0, root.size());+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex ca5359a04d..eb2664beb4 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -125,6 +125,9 @@ floci:amazonmq:enabled: truemock: true+ kinesis-analytics:+ enabled: true+ mock: trueelasticache:enabled: trueproxy-base-port: 6379diff --git a/tools/docs/services.yaml b/tools/docs/services.yamlindex 7ff1db5f34..3054bdcae5 100644--- a/tools/docs/services.yaml+++ b/tools/docs/services.yaml@@ -54,6 +54,10 @@ services:doc: docs/services/kinesis.mdsources:- { path: src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java, mode: switch }+ - service: kinesisanalytics+ doc: docs/services/kinesisanalytics.md+ sources:+ - { path: src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2JsonHandler.java, mode: switch }- service: kmsdoc: docs/services/kms.mdsources: