Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(kinesisanalytics): emit MSF-style JSON CloudWatch logs from Flink (#2656)

Priamo Germosenaaae99282f8e
diff --git a/docs/services/kinesisanalytics.md b/docs/services/kinesisanalytics.md
index 5e4cf83ff3..b42795c3ec 100644
--- a/docs/services/kinesisanalytics.md
+++ b/docs/services/kinesisanalytics.md
@@ -161,6 +161,31 @@ Pass `ApplicationConfiguration.ApplicationSnapshotConfiguration.SnapshotsEnabled
`UpdateApplication`) to disable snapshots for an application — real AWS defaults this to `true`.
`CreateApplicationSnapshot` rejects the request with `InvalidRequestException` while disabled.
+### CloudWatch Logs format
+
+The JobManager and TaskManager are started with a `log4j-console.properties` that makes every log
+line a single JSON object, matching the shape real Managed Service for Apache Flink writes to
+CloudWatch Logs: `applicationARN`, `applicationVersionId`, `locationInformation`, `logger`,
+`message`, `messageSchemaVersion`, `messageType`, `threadName`, `throwableInformation`. This applies
+to Flink's own framework logs as well as anything a deployed JAR logs through SLF4J/Log4j2 — a JAR
+whose own tests assert on this exact schema (or that simply expects its logs to reach CloudWatch
+rather than being swallowed by a competing logging framework it bundles) sees the same thing here as
+on real MSF. The config is written into the container before the JVM starts (config placed at
+creation time, before `StartApplication`'s container start), overwriting the stock image's default,
+non-JSON config entirely. `throwableInformation` is always present (an empty string when the log
+event has no exception), unlike real AWS which omits the key entirely in that case. Not re-applied
+on `UpdateApplication` — `applicationVersionId` in already-emitted log lines does not advance across
+an in-place code update, since the JobManager/TaskManager JVMs (and therefore log4j2) are not
+restarted for that, matching how real MSF also keeps the same processes running across an
+`UpdateApplication`.
+
+`applicationARN` and `applicationVersionId` are baked into the generated config as literal text, so
+`CreateApplication` validates `ApplicationName` against AWS's own constraints (`[a-zA-Z0-9_.-]+`,
+1-128 characters) rather than only requiring it non-blank — matching real AWS, and also keeping a
+name containing `%`, `"`, `\`, or `$` out of the log4j2 pattern in the first place. `StartApplication`
+re-checks the same pattern, so an application persisted by an older Floci build (before this
+validation existed) fails loudly there rather than getting a corrupted `applicationARN` in its logs.
+
### Flink Dashboard access
`CreateApplicationPresignedUrl` (with `UrlType: FLINK_DASHBOARD_URL`) returns a URL to the running
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.java
index 0d09c98a64..6b19f0d8c6 100644
--- a/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2Service.java
+++ b/src/main/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2Service.java
@@ -27,6 +27,7 @@ import java.util.Objects;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
/**
* Control plane for Managed Service for Apache Flink (Kinesis Analytics V2). Holds the
@@ -43,6 +44,9 @@ public class KinesisAnalyticsV2Service {
private static final Logger LOG = Logger.getLogger(KinesisAnalyticsV2Service.class);
+ // AWS: ApplicationName Length Constraints: 1-128, Pattern: [a-zA-Z0-9_.-]+
+ private static final Pattern APPLICATION_NAME = Pattern.compile("[a-zA-Z0-9_.-]{1,128}");
+
// 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;
@@ -137,6 +141,11 @@ public class KinesisAnalyticsV2Service {
if (applicationName == null || applicationName.isBlank()) {
throw new AwsException("InvalidArgumentException", "ApplicationName is required", 400);
}
+ if (!APPLICATION_NAME.matcher(applicationName).matches()) {
+ throw new AwsException("InvalidArgumentException",
+ "ApplicationName '" + applicationName
+ + "' does not match the required pattern [a-zA-Z0-9_.-]{1,128}", 400);
+ }
if (runtimeEnvironment == null || runtimeEnvironment.isBlank()) {
throw new AwsException("InvalidArgumentException", "RuntimeEnvironment is required", 400);
}
@@ -197,6 +206,20 @@ public class KinesisAnalyticsV2Service {
public FlinkApplication startApplication(String applicationName) {
FlinkApplication app = describeApplication(applicationName);
+ // Defends state persisted by a floci build older than the ApplicationName check in
+ // createApplication: applicationARN is baked as literal text into the CloudWatch-log-format
+ // config FlinkContainerManager writes on startup, and a name outside AWS's charset (most
+ // notably '$', which can't be escaped to a safe literal there -- see
+ // FlinkContainerManager#literalForLog4j2Pattern) either gets dropped from every emitted
+ // applicationARN (breaking correlation with the real ApplicationARN) or, if ever un-dropped,
+ // risks leaking an environment variable/system property via a log4j2 Lookup. Failing loudly
+ // here beats either outcome, and real AWS could never have had this state to begin with.
+ if (!APPLICATION_NAME.matcher(applicationName).matches()) {
+ throw new AwsException("InvalidArgumentException",
+ "ApplicationName '" + applicationName + "' does not match the required pattern "
+ + "[a-zA-Z0-9_.-]{1,128}; this application predates that validation and "
+ + "must be deleted and recreated with a valid name", 400);
+ }
if (app.getApplicationStatus() != ApplicationStatus.READY) {
throw new AwsException("ResourceInUseException",
"Application " + applicationName + " cannot be started while in state "
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.java
index 251a132921..56dd3e502c 100644
--- 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.java
@@ -170,9 +170,17 @@ public class FlinkContainerManager {
jmSpec.withExposedPort(JOBMANAGER_REST_PORT);
}
+ ContainerSpec jmBuiltSpec = jmSpec.build();
ContainerInfo jm;
try {
- jm = lifecycleManager.createAndStart(jmSpec.build());
+ String jmContainerId = lifecycleManager.create(jmBuiltSpec);
+ // Written before start (not via the post-start copyFileIntoContainer used for
+ // application_properties.json below) because log4j2 reads its config file at JVM
+ // startup -- copying it in after the process is already running would be too late for
+ // anything the JobManager logs from its own boot onward.
+ copyFileIntoContainer(jmContainerId, "/opt/flink/conf", "log4j-console.properties",
+ msfStyleLog4j2Config(app), true);
+ jm = lifecycleManager.startCreated(jmContainerId, jmBuiltSpec);
} catch (RuntimeException e) {
lifecycleManager.removeIfExists(jmName);
throw e;
@@ -202,7 +210,10 @@ public class FlinkContainerManager {
regionResolver.getDefaultRegion()))
.build();
try {
- ContainerInfo tm = lifecycleManager.createAndStart(tmSpec);
+ String tmContainerId = lifecycleManager.create(tmSpec);
+ copyFileIntoContainer(tmContainerId, "/opt/flink/conf", "log4j-console.properties",
+ msfStyleLog4j2Config(app), true);
+ ContainerInfo tm = lifecycleManager.startCreated(tmContainerId, tmSpec);
app.setTaskManagerContainerId(tm.containerId());
taskManagerIds.put(app.getApplicationName(), tm.containerId());
} catch (RuntimeException e) {
@@ -249,7 +260,88 @@ public class FlinkContainerManager {
}
}
+ /** Builds a log4j2 {@code log4j-console.properties} that makes the JobManager/TaskManager emit
+ * one JSON object per log line, matching the schema real Managed Service for Apache Flink
+ * writes to CloudWatch Logs (applicationARN/applicationVersionId/locationInformation/logger/
+ * message/messageSchemaVersion/messageType/threadName/throwableInformation) -- so a JAR relying
+ * on that shape for its own log-based tests sees the same thing here as on real MSF. Overwrites
+ * the stock image's default (non-JSON) config entirely; not re-applied on {@link #redeployCode},
+ * so applicationVersionId in already-emitted log lines does not advance across an in-place code
+ * update (the JobManager/TaskManager JVMs, and therefore log4j2, are not restarted for that --
+ * matching real MSF, which also keeps the same processes running across an UpdateApplication).
+ * Package-private (not private) so FlinkContainerManagerTest can assert on the pattern shape
+ * directly. */
+ byte[] msfStyleLog4j2Config(FlinkApplication app) {
+ String pattern = "{"
+ + "\"applicationARN\":\"%enc{"
+ + literalForLog4j2Pattern(String.valueOf(app.getApplicationArn())) + "}{JSON}\","
+ + "\"applicationVersionId\":\"%enc{"
+ + literalForLog4j2Pattern(String.valueOf(app.getApplicationVersionId())) + "}{JSON}\","
+ + "\"locationInformation\":\"%C.%M(%F:%L)\","
+ + "\"logger\":\"%logger\","
+ + "\"message\":\"%enc{%message}{JSON}\","
+ + "\"messageSchemaVersion\":\"1\","
+ + "\"messageType\":\"%level\","
+ + "\"threadName\":\"%enc{%thread}{JSON}\","
+ + "\"throwableInformation\":\"%enc{%ex}{JSON}\""
+ + "}%n";
+ String properties = "rootLogger.level = INFO\n"
+ + "rootLogger.appenderRef.console.ref = ConsoleAppender\n"
+ + "appender.console.type = Console\n"
+ + "appender.console.name = ConsoleAppender\n"
+ + "appender.console.layout.type = PatternLayout\n"
+ + "appender.console.layout.pattern = " + pattern + "\n";
+ return properties.getBytes(StandardCharsets.UTF_8);
+ }
+
+ /** Escapes an application-supplied value (e.g. the ARN, built from the caller's ApplicationName --
+ * {@link io.github.hectorvent.floci.services.kinesisanalytics.KinesisAnalyticsV2Service} restricts
+ * that to AWS's own {@code [a-zA-Z0-9_.-]} charset, but this stays defensive in case some other
+ * caller ever feeds it something else) so it can be embedded as literal text inside a log4j2
+ * {@code PatternLayout} pattern written to a {@code .properties} file: doubles {@code %} so
+ * log4j2's pattern parser can't interpret it as the start of a conversion specifier, drops
+ * {@code $} so it can't start a {@code ${...}} Lookup (log4j2 resolves those against config
+ * values -- including this pattern -- at config-load time, so an unescaped one could leak an
+ * environment variable or system property into every log line; doubling it like {@code %} only
+ * defers the lookup to render time rather than neutralizing it, so it isn't a safe escape here),
+ * then backslash-escapes control characters so the value survives
+ * {@code java.util.Properties}-style parsing of the config file intact. The surrounding
+ * {@code %enc{...}{JSON}} wrapper (already used for %message/%thread/%ex above) then JSON-escapes
+ * the resulting literal at log time, so quotes/backslashes in the original value can't break the
+ * emitted JSON. */
+ private static String literalForLog4j2Pattern(String value) {
+ String percentEscaped = value.replace("%", "%%");
+ StringBuilder escaped = new StringBuilder(percentEscaped.length());
+ for (int i = 0; i < percentEscaped.length(); i++) {
+ char c = percentEscaped.charAt(i);
+ switch (c) {
+ case '\\' -> escaped.append("\\\\");
+ case '$' -> { /* dropped: see method Javadoc -- can't be escaped to a safe literal */ }
+ case '\n' -> escaped.append("\\n");
+ case '\r' -> escaped.append("\\r");
+ case '\t' -> escaped.append("\\t");
+ default -> {
+ if (c < 0x20) {
+ escaped.append(String.format("\\u%04x", (int) c));
+ } else {
+ escaped.append(c);
+ }
+ }
+ }
+ }
+ return escaped.toString();
+ }
+
private void copyFileIntoContainer(String containerId, String remoteDir, String relativePath, byte[] content) {
+ copyFileIntoContainer(containerId, remoteDir, relativePath, content, false);
+ }
+
+ /** @param required when {@code true}, a failed copy is rethrown instead of only logged, so a
+ * caller for whom the file is not optional (e.g. the log4j2 config that this cluster's whole
+ * CloudWatch-log-shape guarantee depends on) fails the start instead of silently running with
+ * the stock config. */
+ private void copyFileIntoContainer(String containerId, String remoteDir, String relativePath, byte[] content,
+ boolean required) {
if (containerId == null) {
return;
}
@@ -260,6 +352,10 @@ public class FlinkContainerManager {
.withRemotePath(remoteDir)
.exec();
} catch (Exception e) {
+ if (required) {
+ throw new IllegalStateException(
+ "Could not copy " + relativePath + " into Flink container " + containerId, e);
+ }
LOG.warnv("Could not copy {0} into Flink container {1}: {2}", relativePath, containerId, e.getMessage());
}
}
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.java
index 7b974e8b94..9ec7ba825d 100644
--- a/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2ServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/kinesisanalytics/KinesisAnalyticsV2ServiceTest.java
@@ -57,6 +57,55 @@ class KinesisAnalyticsV2ServiceTest {
() -> service.createApplication(" ", "FLINK-1_18", ROLE, null, null));
}
+ @Test
+ void createApplicationRejectsNamesOutsideAwsCharsetAndLength() {
+ // AWS ApplicationName Pattern: [a-zA-Z0-9_.-]+, 1-128 chars. Rejecting this at the API
+ // boundary (matching real AWS) is also what keeps a name containing '%', '"', '\', or '$'
+ // from ever reaching FlinkContainerManager's generated log4j2 CloudWatch-log-format pattern,
+ // where those characters would otherwise be a log4j2 conversion-specifier/Lookup or JSON
+ // injection risk.
+ for (String badName : List.of("has spaces", "quote\"here", "percent%here", "dollar${x}",
+ "back\\slash", "a".repeat(129))) {
+ AwsException ex = assertThrows(AwsException.class,
+ () -> service.createApplication(badName, "FLINK-1_18", ROLE, null, null));
+ assertEquals("InvalidArgumentException", ex.getErrorCode());
+ }
+ }
+
+ @Test
+ void startApplicationRejectsLegacyStatePersistedBeforeNameValidationExisted() {
+ // Simulates an application created by a floci build older than
+ // createApplicationRejectsNamesOutsideAwsCharsetAndLength's check, by writing directly to
+ // storage (bypassing createApplication). startApplication must still reject it rather than
+ // silently generating a CloudWatch-log applicationARN that either drops the '$' (mismatching
+ // the real ApplicationARN) or, if some future change stopped dropping it, resolves it as a
+ // log4j2 Lookup.
+ AccountAwareStorageBackend<FlinkApplication> store =
+ AccountAwareStorageBackend.inMemory("000000000000");
+ StorageFactory storageFactory = Mockito.mock(StorageFactory.class);
+ Mockito.doReturn(store).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(true);
+ when(config.defaultRegion()).thenReturn("us-east-1");
+ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");
+
+ KinesisAnalyticsV2Service legacyState = new KinesisAnalyticsV2Service(
+ storageFactory, config, regionResolver, Mockito.mock(FlinkContainerManager.class));
+ FlinkApplication legacyApp = new FlinkApplication("dollar${x}",
+ "arn:aws:kinesisanalytics:us-east-1:000000000000:application/dollar${x}",
+ "FLINK-1_18", ROLE, "STREAMING");
+ store.putForAccount("000000000000", "dollar${x}", legacyApp);
+
+ AwsException ex = assertThrows(AwsException.class, () -> legacyState.startApplication("dollar${x}"));
+ assertEquals("InvalidArgumentException", ex.getErrorCode());
+ }
+
@Test
void createApplicationRequiresRuntimeEnvironment() {
assertThrows(AwsException.class,
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.java
index 1b01ce449d..d6ce2a9cd1 100644
--- 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.java
@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.kinesisanalytics.container;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.github.dockerjava.api.DockerClient;
import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.core.common.RegionResolver;
import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;
@@ -28,12 +29,14 @@ import java.util.Map;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -97,6 +100,11 @@ class FlinkContainerManagerTest {
ContainerBuilder containerBuilder = new ContainerBuilder(config, dockerHostResolver, embeddedDnsServer);
lifecycleManager = mock(ContainerLifecycleManager.class);
+ // The log4j-console.properties copy is now required (a failure fails cluster startup, see
+ // log4jConfigCopyFailureRollsBackTheClusterInsteadOfStartingWithTheStockLogFormat below), so
+ // every test that gets as far as create() succeeding needs a working docker client for that
+ // copy to land on by default.
+ when(lifecycleManager.getDockerClient()).thenReturn(mock(DockerClient.class, RETURNS_DEEP_STUBS));
ContainerLogStreamer logStreamer = mock(ContainerLogStreamer.class);
ContainerDetector containerDetector = mock(ContainerDetector.class);
RegionResolver regionResolver = mock(RegionResolver.class);
@@ -142,7 +150,9 @@ class FlinkContainerManagerTest {
when(storage.hostPersistentPath()).thenReturn("floci-data");
ContainerLifecycleManager lifecycleManager = Mockito.mock(ContainerLifecycleManager.class);
- when(lifecycleManager.createAndStart(any())).thenReturn(
+ when(lifecycleManager.create(any())).thenReturn("jm-container-id");
+ when(lifecycleManager.getDockerClient()).thenReturn(mock(DockerClient.class, RETURNS_DEEP_STUBS));
+ when(lifecycleManager.startCreated(any(), any())).thenReturn(
new ContainerLifecycleManager.ContainerInfo("jm-container-id", Map.of(8081,
new ContainerLifecycleManager.EndpointInfo("localhost", 8081))));
@@ -207,10 +217,54 @@ class FlinkContainerManagerTest {
assertEquals(0, root.size());
}
+ @Test
+ void msfStyleLog4j2ConfigBakesInTheApplicationArnAndVersion() throws Exception {
+ FlinkApplication app = new FlinkApplication("demo",
+ "arn:aws:kinesisanalytics:us-east-1:000000000000:application/demo",
+ "FLINK-2_3", "arn:aws:iam::000000000000:role/x", "STREAMING");
+ app.setApplicationVersionId(2L);
+
+ String config = new String(manager.msfStyleLog4j2Config(app), java.nio.charset.StandardCharsets.UTF_8);
+
+ assertTrue(config.contains(
+ "\"applicationARN\":\"%enc{arn:aws:kinesisanalytics:us-east-1:000000000000:application/demo}{JSON}\""));
+ assertTrue(config.contains("\"applicationVersionId\":\"%enc{2}{JSON}\""));
+ assertTrue(config.contains("\"messageSchemaVersion\":\"1\""));
+ assertTrue(config.contains("appender.console.layout.type = PatternLayout"));
+ }
+
+ @Test
+ void msfStyleLog4j2ConfigEscapesLog4jAndPropertiesSyntaxInTheApplicationName() throws Exception {
+ // KinesisAnalyticsV2Service now rejects an ApplicationName outside AWS's own
+ // [a-zA-Z0-9_.-] charset, but this stays defensive in case some other caller ever builds a
+ // FlinkApplication directly: '%' would be a log4j2 conversion-specifier marker, '\' is a
+ // java.util.Properties escape character (Flink loads this file with Properties-style
+ // parsing), and '$' could start a log4j2 '${...}' Lookup that leaks an env var/system
+ // property into every log line -- none of that may reach the pattern unescaped.
+ FlinkApplication app = new FlinkApplication("100%-\\-${env:PATH}-owned",
+ "arn:aws:kinesisanalytics:us-east-1:000000000000:application/100%-\\-${env:PATH}-owned",
+ "FLINK-2_3", "arn:aws:iam::000000000000:role/x", "STREAMING");
+ app.setApplicationVersionId(1L);
+
+ String config = new String(manager.msfStyleLog4j2Config(app), java.nio.charset.StandardCharsets.UTF_8);
+
+ assertTrue(config.contains(
+ "\"applicationARN\":\"%enc{arn:aws:kinesisanalytics:us-east-1:000000000000:application/100%%-\\\\-{env:PATH}-owned}{JSON}\""));
+
+ java.util.Properties parsed = new java.util.Properties();
+ parsed.load(new java.io.ByteArrayInputStream(config.getBytes(java.nio.charset.StandardCharsets.UTF_8)));
+ String loadedPattern = parsed.getProperty("appender.console.layout.pattern");
+ assertTrue(loadedPattern.contains(
+ "\"applicationARN\":\"%enc{arn:aws:kinesisanalytics:us-east-1:000000000000:application/100%%-\\-{env:PATH}-owned}{JSON}\""));
+ assertFalse(loadedPattern.contains("${env:PATH}"), "the $ must not survive, or log4j2 would treat "
+ + "this as a Lookup and resolve it against the environment at config-load time");
+ }
+
@Test
void bareClusterInjectsAwsSdkEnvironmentAndContainerReachability() {
FlinkApplication app = application("bare");
- when(lifecycleManager.createAndStart(any())).thenReturn(new ContainerInfo(
+ when(lifecycleManager.create(any())).thenReturn("jm-id");
+ when(lifecycleManager.startCreated(any(), any())).thenReturn(new ContainerInfo(
"jm-id", Map.of(8081, new EndpointInfo("localhost", 49152))));
manager.startCluster(app);
@@ -234,7 +288,8 @@ class FlinkContainerManagerTest {
app.setParallelism(3);
when(s3Service.getObject("code-bucket", "jobs/demo.jar", null))
.thenReturn(new S3Object("code-bucket", "jobs/demo.jar", new byte[]{1}, "application/java-archive"));
- when(lifecycleManager.createAndStart(any()))
+ when(lifecycleManager.create(any())).thenReturn("jm-id").thenReturn("tm-id");
+ when(lifecycleManager.startCreated(any(), any()))
.thenReturn(new ContainerInfo("jm-id", Map.of(8081, new EndpointInfo("localhost", 49152))))
.thenReturn(new ContainerInfo("tm-id", Map.of()));
@@ -257,7 +312,7 @@ class FlinkContainerManagerTest {
@Test
void jobManagerStartFailureRemovesThePartialCluster() {
FlinkApplication app = application("jm-failure");
- when(lifecycleManager.createAndStart(any())).thenThrow(new RuntimeException("jobmanager failed"));
+ when(lifecycleManager.create(any())).thenThrow(new RuntimeException("jobmanager failed"));
assertThrows(RuntimeException.class, () -> manager.startCluster(app));
@@ -274,9 +329,10 @@ class FlinkContainerManagerTest {
app.setCodeS3Key("jobs/demo.jar");
when(s3Service.getObject("code-bucket", "jobs/demo.jar", null))
.thenReturn(new S3Object("code-bucket", "jobs/demo.jar", new byte[]{1}, "application/java-archive"));
- when(lifecycleManager.createAndStart(any()))
- .thenReturn(new ContainerInfo("jm-id", Map.of(8081, new EndpointInfo("localhost", 49152))))
+ when(lifecycleManager.create(any())).thenReturn("jm-id")
.thenThrow(new RuntimeException("taskmanager failed"));
+ when(lifecycleManager.startCreated(any(), any()))
+ .thenReturn(new ContainerInfo("jm-id", Map.of(8081, new EndpointInfo("localhost", 49152))));
assertThrows(RuntimeException.class, () -> manager.startCluster(app));
@@ -287,9 +343,28 @@ class FlinkContainerManagerTest {
assertNull(app.getTaskManagerContainerId());
}
+ @Test
+ void log4jConfigCopyFailureRollsBackTheClusterInsteadOfStartingWithTheStockLogFormat() {
+ // Before this test, a failed copy of log4j-console.properties was only logged: startCreated()
+ // still ran and startCluster() reported success, so the cluster silently kept the stock
+ // (non-JSON) log format instead of the MSF-style CloudWatch schema this whole feature exists
+ // to provide. copyFileIntoContainer(..., required=true) now rethrows instead, so this failure
+ // takes the same create()-failure rollback path already covered above.
+ FlinkApplication app = application("log4j-copy-failure");
+ when(lifecycleManager.create(any())).thenReturn("jm-id");
+ when(lifecycleManager.getDockerClient()).thenThrow(new RuntimeException("docker copy unavailable"));
+
+ assertThrows(RuntimeException.class, () -> manager.startCluster(app));
+
+ verify(lifecycleManager, times(2)).removeIfExists("floci-kinesisanalytics-log4j-copy-failure");
+ verify(lifecycleManager, atLeastOnce()).removeIfExists("floci-kinesisanalytics-log4j-copy-failure-tm");
+ verify(lifecycleManager, Mockito.never()).startCreated(any(), any());
+ assertNull(app.getContainerId());
+ }
+
private List<ContainerSpec> captureCreatedSpecs() {
ArgumentCaptor<ContainerSpec> captor = ArgumentCaptor.forClass(ContainerSpec.class);
- verify(lifecycleManager, atLeastOnce()).createAndStart(captor.capture());
+ verify(lifecycleManager, atLeastOnce()).create(captor.capture());
return captor.getAllValues();
}
}