Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): DescribeDBLogFiles and DownloadDBLogFilePortion (#5741)
David4353e4232b19
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.javaindex 33592de3a6..f649c1598c 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java@@ -34,14 +34,17 @@ import software.amazon.awssdk.services.rds.model.DbClusterRoleNotFoundException;import software.amazon.awssdk.services.rds.model.DbClusterSnapshotNotFoundException;import software.amazon.awssdk.services.rds.model.DbInstanceRoleAlreadyExistsException;import software.amazon.awssdk.services.rds.model.DbInstanceRoleNotFoundException;+import software.amazon.awssdk.services.rds.model.DbLogFileNotFoundException;import software.amazon.awssdk.services.rds.model.DbSnapshotAlreadyExistsException;import software.amazon.awssdk.services.rds.model.DbSnapshotNotFoundException;+import software.amazon.awssdk.services.rds.model.DescribeDBLogFilesDetails;import software.amazon.awssdk.services.rds.model.DescribeDbProxiesResponse;import software.amazon.awssdk.services.rds.model.DescribeDbProxyTargetGroupsResponse;import software.amazon.awssdk.services.rds.model.DescribeDbProxyTargetsResponse;import software.amazon.awssdk.services.rds.model.DescribeDbSubnetGroupsResponse;import software.amazon.awssdk.services.rds.model.DescribeOptionGroupsResponse;import software.amazon.awssdk.services.rds.model.DescribeOrderableDbInstanceOptionsResponse;+import software.amazon.awssdk.services.rds.model.DownloadDbLogFilePortionResponse;import software.amazon.awssdk.services.rds.model.EngineDefaults;import software.amazon.awssdk.services.rds.model.InvalidDbInstanceStateException;import software.amazon.awssdk.services.rds.model.InvalidOptionGroupStateException;@@ -791,6 +794,33 @@ class RdsControlPlaneTest {}}+ @Test+ @DisplayName("Log files: list an instance's log files and download a block")+ void sdkReadsInstanceLogFiles() {+ String instanceName = TestFixtures.uniqueName("rds-log-files");+ try {+ createDbInstance(rds, instanceName, "log-files-secret");+ List<DescribeDBLogFilesDetails> files =+ rds.describeDBLogFiles(b -> b.dbInstanceIdentifier(instanceName)).describeDBLogFiles();+ assertThat(files).isNotEmpty();+ assertThat(files).allSatisfy(f -> {+ assertThat(f.logFileName()).startsWith("error/postgresql.log.");+ assertThat(f.size()).isPositive();+ assertThat(f.lastWritten()).isPositive();+ });+ String name = files.get(0).logFileName();+ DownloadDbLogFilePortionResponse portion = rds.downloadDBLogFilePortion(b -> b+ .dbInstanceIdentifier(instanceName).logFileName(name).marker("0").numberOfLines(1));+ assertThat(portion.logFileData()).isNotEmpty();+ assertThat(portion.marker()).isEqualTo("1");+ assertThatThrownBy(() -> rds.downloadDBLogFilePortion(b -> b+ .dbInstanceIdentifier(instanceName).logFileName("error/no-such.log")))+ .isInstanceOf(DbLogFileNotFoundException.class);+ } finally {+ deleteDbInstance(rds, instanceName);+ }+ }+@Test@DisplayName("IAM role associations: add, describe and remove for a cluster and an instance")void sdkRoundTripsIamRoleAssociations() {diff --git a/docs/services/index.md b/docs/services/index.mdindex ae7e0918ae..879ee3e9c1 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -63,7 +63,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Amazon Data Lifecycle Manager](dlm.md) | `/policies`, `/policies/{policyId}`, `/tags/{resourceArn}` | REST JSON | 8 || [ElastiCache](elasticache.md) | `POST /` with `Action=` param + TCP proxy | Query + RESP | 30 || [MemoryDB](memorydb.md) | `POST /` + `X-Amz-Target: AmazonMemoryDB.*` + TCP proxy | JSON 1.1 + RESP | 13 |-| [RDS](rds.md) | `POST /` with `Action=` param + TCP proxy | Query + wire | 100 |+| [RDS](rds.md) | `POST /` with `Action=` param + TCP proxy | Query + wire | 102 || [RDS Data API](rds-data.md) | `/Execute`, `/BeginTransaction`, `/CommitTransaction`, `/RollbackTransaction` | REST JSON | 4 || [Timestream for InfluxDB](timestream-influxdb.md) | `POST /` + `X-Amz-Target: AmazonTimestreamInfluxDB.*` + InfluxDB container | JSON 1.0 + InfluxDB HTTP | 24 || [MSK](msk.md) | `/v1/clusters/...`, `/api/v2/clusters/...` + Redpanda broker | REST JSON + Kafka | 8 |diff --git a/docs/services/rds.md b/docs/services/rds.mdindex 35fb26bbf3..91bd66a613 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -73,6 +73,8 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `DeleteDBClusterEndpoint` | Delete a custom endpoint || `EnableHttpEndpoint` | Turn on an Aurora cluster's Data API endpoint by ARN; see [Data API endpoint](#data-api-endpoint) || `DisableHttpEndpoint` | Turn off a cluster's Data API endpoint by ARN |+| `DescribeDBLogFiles` | List an instance's log files, read from its database container; see [Log files](#log-files) |+| `DownloadDBLogFilePortion` | Read a block of a log file, from the start or the most recent lines || `AddRoleToDBCluster` | Associate an IAM role with a cluster, optionally for a feature; see [IAM role associations](#iam-role-associations) || `RemoveRoleFromDBCluster` | Remove a role from a cluster || `AddRoleToDBInstance` | Associate an IAM role with an instance for a feature |@@ -631,6 +633,26 @@ it off is always accepted. An ARN that names no cluster in the caller's account`ResourceNotFoundFault`, and a cluster that is not available is `InvalidResourceStateFault`. The flagis recorded and reported only: the Data API (`rds-data`) does not refuse a cluster with it off.+## Log files++`DescribeDBLogFiles` and `DownloadDBLogFilePortion` read an instance's log from its database+container (`docker logs`, the most recent 100,000 lines), cut into files the way RDS names them: PostgreSQL rotates hourly into+`error/postgresql.log.YYYY-MM-DD-HH` (UTC), MySQL and MariaDB keep `error/mysql-error.log`, and SQL+Server keeps `log/ERROR`. An Aurora member reads its cluster's container. `LastWritten` is the time+Docker recorded for the file's last line, and `Size` the bytes of its lines.++`DescribeDBLogFiles` takes `FilenameContains`, `FileLastWritten` (files written at or after it) and+`FileSize` (files larger than it), and pages by `MaxRecords` / `Marker`. `DownloadDBLogFilePortion`+follows the API reference: without a `Marker` it returns the most recent `NumberOfLines` lines (the+whole file, up to 10000 lines, without either), `Marker` `0` starts at the first line, and the+returned `Marker` continues until `AdditionalDataPending` is false. A block stops at 1 MB, and a+single line longer than that is cut at 1 MB, as the API reference says the block is truncated.+Control characters XML cannot carry (a terminal colour code) come back as U+FFFD.++An instance that is not available, or whose database container cannot be found or started, is+`DBInstanceNotReady`, and an unknown file name `DBLogFileNotFoundFault`. Negative `FileSize`,+`FileLastWritten` or `Marker` values are `InvalidParameterValue`. In mock RDS mode there is no container, so an instance has no log files.+## IAM role associations`AddRoleToDBCluster` and `AddRoleToDBInstance` associate an IAM role with an available cluster ordiff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex 3458ddbbd2..e951a6af0d 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -567,6 +567,7 @@ public class AwsQueryController {"CreateDBCluster", "DescribeDBClusters", "DeleteDBCluster", "ModifyDBCluster","AddRoleToDBCluster", "RemoveRoleFromDBCluster", "AddRoleToDBInstance", "RemoveRoleFromDBInstance","EnableHttpEndpoint", "DisableHttpEndpoint",+ "DescribeDBLogFiles", "DownloadDBLogFilePortion","DescribeGlobalClusters","CreateDBParameterGroup", "DescribeDBParameterGroups","DeleteDBParameterGroup", "ModifyDBParameterGroup", "DescribeDBParameters",diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsLogFiles.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsLogFiles.javanew file mode 100644index 0000000000..0118bc4e3a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsLogFiles.java@@ -0,0 +1,197 @@+package io.github.hectorvent.floci.services.rds;++import io.github.hectorvent.floci.core.common.AwsException;++import java.nio.charset.StandardCharsets;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.time.format.DateTimeParseException;+import java.util.ArrayList;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.TreeMap;++/**+ * An instance's log files, cut from its database container's log as RDS names and rotates them,+ * and the paging {@code DownloadDBLogFilePortion} applies to one file.+ */+final class RdsLogFiles {++ /** One line of the container's log, with the time Docker recorded for it. */+ record LogLine(Instant time, String text) {}++ /** A log file: its name, its last line's time, its size in bytes and its lines in order. */+ record LogFile(String name, Instant lastWritten, long size, List<String> lines) {}++ /** What one {@code DownloadDBLogFilePortion} call returns. */+ record Portion(String data, String marker, boolean additionalDataPending) {}++ /** The most lines a download returns, and its size cap, as the API reference gives them. */+ static final int MAX_LINES = 10_000;+ static final int MAX_BYTES = 1024 * 1024;++ private static final DateTimeFormatter HOUR =+ DateTimeFormatter.ofPattern("yyyy-MM-dd-HH").withZone(ZoneOffset.UTC);++ private RdsLogFiles() {+ }++ /**+ * Docker's timestamped lines as {@link LogLine}s. A line whose timestamp does not parse (a+ * continuation Docker split) takes the previous line's time.+ */+ static List<LogLine> parseDockerLines(List<String> raw) {+ List<LogLine> lines = new ArrayList<>(raw.size());+ Instant last = Instant.EPOCH;+ for (String line : raw) {+ int space = line.indexOf(' ');+ Instant time = null;+ if (space > 0) {+ try {+ time = Instant.parse(line.substring(0, space));+ } catch (DateTimeParseException ignored) {+ // not a timestamp: the whole line is text+ }+ }+ if (time != null) {+ last = time;+ lines.add(new LogLine(time, xmlSafe(line.substring(space + 1))));+ } else {+ lines.add(new LogLine(last, xmlSafe(line)));+ }+ }+ return lines;+ }++ /**+ * Replaces the control characters XML 1.0 cannot carry (a terminal colour code, a stray NUL)+ * with U+FFFD, so {@code LogFileData} always parses; tabs stay.+ */+ static String xmlSafe(String text) {+ StringBuilder out = null;+ for (int i = 0; i < text.length(); i++) {+ char c = text.charAt(i);+ boolean bad = (c < 0x20 && c != '\t') || c == 0xFFFE || c == 0xFFFF;+ if (bad && out == null) {+ out = new StringBuilder(text.length());+ out.append(text, 0, i);+ }+ if (out != null) {+ out.append(bad ? '\uFFFD' : c);+ }+ }+ return out != null ? out.toString() : text;+ }++ /**+ * The files an engine's log is cut into. PostgreSQL rotates hourly into+ * {@code error/postgresql.log.YYYY-MM-DD-HH} (UTC); MySQL and MariaDB keep+ * {@code error/mysql-error.log}; SQL Server keeps {@code log/ERROR}.+ */+ static List<LogFile> files(String engine, List<LogLine> lines) {+ Map<String, List<LogLine>> byName = new TreeMap<>();+ for (LogLine line : lines) {+ byName.computeIfAbsent(fileName(engine, line.time()), name -> new ArrayList<>()).add(line);+ }+ List<LogFile> files = new ArrayList<>();+ byName.forEach((name, fileLines) -> {+ long size = 0;+ List<String> texts = new ArrayList<>(fileLines.size());+ for (LogLine line : fileLines) {+ texts.add(line.text());+ size += line.text().getBytes(StandardCharsets.UTF_8).length + 1;+ }+ files.add(new LogFile(name, fileLines.get(fileLines.size() - 1).time(), size, List.copyOf(texts)));+ });+ return files;+ }++ private static String fileName(String engine, Instant time) {+ String name = engine == null ? "postgres" : engine.toLowerCase(Locale.ROOT);+ if (name.contains("postgres")) {+ return "error/postgresql.log." + HOUR.format(time);+ }+ if (name.startsWith("sqlserver")) {+ return "log/ERROR";+ }+ return "error/mysql-error.log";+ }++ /**+ * The files {@code DescribeDBLogFiles} lists: names containing {@code filenameContains}, written+ * at or after {@code fileLastWritten} (epoch milliseconds), larger than {@code fileSize} bytes.+ */+ static List<LogFile> matching(List<LogFile> files, String filenameContains, Long fileLastWritten, Long fileSize) {+ return files.stream()+ .filter(f -> filenameContains == null || filenameContains.isEmpty()+ || f.name().contains(filenameContains))+ .filter(f -> fileLastWritten == null || f.lastWritten().toEpochMilli() >= fileLastWritten)+ .filter(f -> fileSize == null || f.size() > fileSize)+ .toList();+ }++ /**+ * One block of a file, by the API reference's rules. Without a marker the most recent lines+ * come back (all of them, up to {@link #MAX_LINES}, without {@code numberOfLines}); marker+ * {@code 0} starts at the first line, and any other marker is the line to continue from, as a+ * previous call returned it. A block stops at 1 MB.+ */+ static Portion portion(LogFile file, String marker, Integer numberOfLines) {+ if (numberOfLines != null && numberOfLines < 1) {+ throw new AwsException("InvalidParameterValue", "NumberOfLines must be greater than 0.", 400);+ }+ int wanted = numberOfLines == null ? MAX_LINES : Math.min(numberOfLines, MAX_LINES);+ List<String> lines = file.lines();+ int start;+ if (marker == null || marker.isEmpty()) {+ start = Math.max(0, lines.size() - wanted);+ } else {+ try {+ start = Integer.parseInt(marker);+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidParameterValue", "Invalid marker: " + marker, 400);+ }+ if (start < 0) {+ throw new AwsException("InvalidParameterValue", "Invalid marker: " + marker, 400);+ }+ start = Math.min(start, lines.size());+ }+ StringBuilder data = new StringBuilder();+ int bytes = 0;+ int end = start;+ while (end < lines.size() && end - start < wanted) {+ String line = lines.get(end) + "\n";+ int lineBytes = line.getBytes(StandardCharsets.UTF_8).length;+ if (end > start && bytes + lineBytes > MAX_BYTES) {+ break;+ }+ if (lineBytes > MAX_BYTES) {+ // A single line over 1 MB is cut there, as the API reference says the block is.+ line = truncateUtf8(lines.get(end), MAX_BYTES - 1) + "\n";+ lineBytes = line.getBytes(StandardCharsets.UTF_8).length;+ }+ data.append(line);+ bytes += lineBytes;+ end++;+ }+ return new Portion(data.toString(), Integer.toString(end), end < lines.size());+ }++ /** The longest prefix of {@code text} that is at most {@code maxBytes} in UTF-8, cut between characters. */+ static String truncateUtf8(String text, int maxBytes) {+ int bytes = 0;+ int i = 0;+ while (i < text.length()) {+ int codePoint = text.codePointAt(i);+ int size = codePoint < 0x80 ? 1 : codePoint < 0x800 ? 2 : codePoint < 0x10000 ? 3 : 4;+ if (bytes + size > maxBytes) {+ break;+ }+ bytes += size;+ i += Character.charCount(codePoint);+ }+ return text.substring(0, i);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.javaindex 27a8aba9e7..a857be2cb2 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java@@ -115,6 +115,8 @@ public class RdsQueryHandler {case "DeleteDBClusterEndpoint" -> handleDeleteDbClusterEndpoint(params, region);case "EnableHttpEndpoint" -> handleSetHttpEndpoint("EnableHttpEndpoint", params, region, true);case "DisableHttpEndpoint" -> handleSetHttpEndpoint("DisableHttpEndpoint", params, region, false);+ case "DescribeDBLogFiles" -> handleDescribeDbLogFiles(params, region);+ case "DownloadDBLogFilePortion" -> handleDownloadDbLogFilePortion(params, region);case "AddRoleToDBCluster" -> handleAddRoleToDbCluster(params, region);case "RemoveRoleFromDBCluster" -> handleRemoveRoleFromDbCluster(params, region);case "AddRoleToDBInstance" -> handleAddRoleToDbInstance(params, region);@@ -380,6 +382,55 @@ public class RdsQueryHandler {return Response.ok(AwsQueryResponse.envelope(action, AwsNamespaces.RDS, result)).build();}+ private Response handleDescribeDbLogFiles(MultivaluedMap<String, String> params, String region) {+ RdsService.LogFilePage page = service.describeDbLogFiles(region,+ params.getFirst("DBInstanceIdentifier"),+ params.getFirst("FilenameContains"),+ optionalLong(params, "FileLastWritten"),+ optionalLong(params, "FileSize"),+ optionalInt(params.getFirst("MaxRecords")),+ params.getFirst("Marker"));+ XmlBuilder xml = new XmlBuilder().start("DescribeDBLogFiles");+ for (RdsLogFiles.LogFile file : page.files()) {+ xml.start("DescribeDBLogFilesDetails")+ .elem("LogFileName", file.name())+ .elem("LastWritten", file.lastWritten().toEpochMilli())+ .elem("Size", file.size())+ .end("DescribeDBLogFilesDetails");+ }+ xml.end("DescribeDBLogFiles");+ if (page.marker() != null) {+ xml.elem("Marker", page.marker());+ }+ return Response.ok(AwsQueryResponse.envelope("DescribeDBLogFiles", AwsNamespaces.RDS, xml.build())).build();+ }++ private Response handleDownloadDbLogFilePortion(MultivaluedMap<String, String> params, String region) {+ RdsLogFiles.Portion portion = service.downloadDbLogFilePortion(region,+ params.getFirst("DBInstanceIdentifier"),+ params.getFirst("LogFileName"),+ params.getFirst("Marker"),+ optionalInt(params.getFirst("NumberOfLines")));+ String result = new XmlBuilder()+ .elem("LogFileData", portion.data())+ .elem("Marker", portion.marker())+ .elem("AdditionalDataPending", portion.additionalDataPending())+ .build();+ return Response.ok(AwsQueryResponse.envelope("DownloadDBLogFilePortion", AwsNamespaces.RDS, result)).build();+ }++ private static Long optionalLong(MultivaluedMap<String, String> params, String name) {+ String value = params.getFirst(name);+ if (value == null || value.isBlank()) {+ return null;+ }+ try {+ return Long.parseLong(value.trim());+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidParameterValue", name + " must be a number: " + value, 400);+ }+ }+private Response handleAddRoleToDbCluster(MultivaluedMap<String, String> params, String region) {service.addRoleToDbCluster(region, params.getFirst("DBClusterIdentifier"),params.getFirst("RoleArn"), params.getFirst("FeatureName"));diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.javaindex 38b0c7f6ce..843d7063c8 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java@@ -9550,9 +9550,12 @@ public class RdsService implements Resettable, ResourceProvider {} catch (NumberFormatException e) {throw new AwsException("InvalidParameterValue", "Invalid marker: " + marker, 400);}+ if (from < 0) {+ throw new AwsException("InvalidParameterValue", "Invalid marker: " + marker, 400);+ }}int limit = maxRecords == null ? DEFAULT_MAX_RECORDS : maxRecords;- int start = Math.min(Math.max(from, 0), matching.size());+ int start = Math.min(from, matching.size());int to = Math.min(matching.size(), start + limit);return new OffsetPage<>(matching.subList(start, to), to < matching.size() ? Integer.toString(to) : null);}@@ -9826,6 +9829,79 @@ public class RdsService implements Resettable, ResourceProvider {return cluster;}+ // ── Log files ─────────────────────────────────────────────────────────────++ /** One page of an instance's log files, plus the marker to continue from. */+ public record LogFilePage(List<RdsLogFiles.LogFile> files, String marker) {}++ /**+ * The instance's log files, read from its database container's log and named as RDS names them.+ * An instance without a container (mock RDS) has none.+ */+ public LogFilePage describeDbLogFiles(String region, String instanceId, String filenameContains,+ Long fileLastWritten, Long fileSize, Integer maxRecords, String marker) {+ requireParameter(instanceId, "DBInstanceIdentifier");+ requireValidMaxRecords(maxRecords);+ if (fileLastWritten != null && fileLastWritten < 0) {+ throw new AwsException("InvalidParameterValue", "FileLastWritten must not be negative.", 400);+ }+ if (fileSize != null && fileSize < 0) {+ throw new AwsException("InvalidParameterValue", "FileSize must not be negative.", 400);+ }+ List<RdsLogFiles.LogFile> files = RdsLogFiles.matching(logFiles(region, instanceId),+ filenameContains, fileLastWritten, fileSize);+ OffsetPage<RdsLogFiles.LogFile> page = offsetPage(files, maxRecords, marker);+ return new LogFilePage(page.items(), page.marker());+ }++ /** One block of a log file; see {@link RdsLogFiles#portion}. */+ public RdsLogFiles.Portion downloadDbLogFilePortion(String region, String instanceId, String logFileName,+ String marker, Integer numberOfLines) {+ requireParameter(instanceId, "DBInstanceIdentifier");+ requireParameter(logFileName, "LogFileName");+ RdsLogFiles.LogFile file = logFiles(region, instanceId).stream()+ .filter(f -> f.name().equals(logFileName))+ .findFirst()+ .orElseThrow(() -> new AwsException("DBLogFileNotFoundFault",+ "DBLogFile " + logFileName + " not found for DB instance " + instanceId + ".", 404));+ return RdsLogFiles.portion(file, marker, numberOfLines);+ }++ private List<RdsLogFiles.LogFile> logFiles(String region, String instanceId) {+ String effectiveRegion = effectiveRegion(region);+ DbInstance instance = getDbInstance(instanceId, effectiveRegion);+ if (instance.getStatus() != null && instance.getStatus() != DbInstanceStatus.AVAILABLE) {+ throw new AwsException("DBInstanceNotReady",+ "DB instance " + instanceId + " is not in available state.", 400);+ }+ if (config.services().rds().mock()) {+ return List.of();+ }+ // Container ids are not persisted, and a container can be removed outside Floci: when there is+ // no id, or Docker no longer knows it, the backend is found or started once before giving up.+ String containerId = instance.getContainerId();+ List<String> raw = containerId != null ? readContainerLog(containerId) : null;+ if (raw == null) {+ containerId = ensureInstanceBackend(instanceId, effectiveRegion).getContainerId();+ raw = containerId != null ? readContainerLog(containerId) : null;+ }+ if (raw == null) {+ throw new AwsException("DBInstanceNotReady",+ "DB instance " + instanceId + " has no running database container.", 400);+ }+ String engine = !isBlank(instance.getEngineIdentifier()) ? instance.getEngineIdentifier()+ : instance.getEngine() != null ? instance.getEngine().name() : null;+ return RdsLogFiles.files(engine, RdsLogFiles.parseDockerLines(raw));+ }++ private List<String> readContainerLog(String containerId) {+ try {+ return containerManager.readLog(containerId);+ } catch (IllegalStateException e) {+ throw new AwsException("InternalFailure", e.getMessage(), 500);+ }+ }+// ── IAM role associations ─────────────────────────────────────────────────/**diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.javaindex 4cba52b0ac..9ff2c130dc 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManager.java@@ -1,6 +1,9 @@package io.github.hectorvent.floci.services.rds.container;+import com.github.dockerjava.api.async.ResultCallback;import com.github.dockerjava.api.command.InspectContainerResponse;+import com.github.dockerjava.api.exception.NotFoundException;+import com.github.dockerjava.api.model.Frame;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.RegionResolver;@@ -885,6 +888,57 @@ public class RdsContainerManager implements RdsBackendGate, Resettable {throw new IllegalStateException("Timed out initializing " + description + " in " + containerName + ": " + lastOutput);}+ /** The most recent lines {@link #readLog} reads, so one call never holds an unbounded history. */+ public static final int MAX_LOG_LINES = 100_000;++ /**+ * The container's log as Docker keeps it, stdout and stderr, at most the last+ * {@link #MAX_LOG_LINES} lines, each with Docker's RFC 3339 timestamp in front. Null when Docker+ * no longer knows the container, so the caller can tell a missing backend from an empty log. A+ * read that does not finish in time fails rather than returning part of the log.+ */+ public List<String> readLog(String containerId) {+ return readLog(containerId, Duration.ofSeconds(10));+ }++ List<String> readLog(String containerId, Duration timeout) {+ ByteArrayOutputStream raw = new ByteArrayOutputStream();+ ResultCallback.Adapter<Frame> callback = new ResultCallback.Adapter<>() {+ @Override+ public void onNext(Frame frame) {+ synchronized (raw) {+ raw.writeBytes(frame.getPayload());+ }+ }+ };+ try (callback) {+ boolean completed = lifecycleManager.getDockerClient().logContainerCmd(containerId)+ .withStdOut(true).withStdErr(true).withTimestamps(true).withTail(MAX_LOG_LINES)+ .exec(callback)+ .awaitCompletion(timeout.toMillis(), TimeUnit.MILLISECONDS);+ if (!completed) {+ // Closing the callback (try-with-resources) stops the stream, so nothing writes into+ // the buffer after this read gives up.+ throw new IllegalStateException("Timed out reading the log of container " + containerId);+ }+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("Interrupted while reading the log of container " + containerId, e);+ } catch (NotFoundException e) {+ return null;+ } catch (IOException e) {+ throw new IllegalStateException("Could not close the log stream of container " + containerId, e);+ }+ String text;+ synchronized (raw) {+ text = raw.toString(StandardCharsets.UTF_8);+ }+ if (text.isEmpty()) {+ return List.of();+ }+ return List.of(text.split("\r?\n"));+ }+public String createPostgresSnapshot(String containerId, String masterUsername) {String effectiveUser = (masterUsername != null && !masterUsername.isBlank()) ? masterUsername : "postgres";String[] cmd = {diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesDockerIntegrationTest.javanew file mode 100644index 0000000000..4271eba47f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesDockerIntegrationTest.java@@ -0,0 +1,88 @@+package io.github.hectorvent.floci.services.rds;++import com.github.dockerjava.api.DockerClient;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.xml.XmlPath;+import io.restassured.specification.RequestSpecification;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Tag;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.restassured.RestAssured.given;+import static io.restassured.http.ContentType.URLENC;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.junit.jupiter.api.Assumptions.assumeTrue;++/**+ * A real PostgreSQL instance's log, read through {@code DescribeDBLogFiles} and+ * {@code DownloadDBLogFilePortion}: the container's startup line lands in an hourly+ * {@code error/postgresql.log.*} file. Skipped without Docker.+ */+@QuarkusTest+@Tag("docker")+class RdsLogFilesDockerIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20261015/us-east-1/rds/aws4_request, "+ + "SignedHeaders=content-type;host, Signature=test";++ @Inject+ DockerClient dockerClient;++ @BeforeEach+ void checkDocker() {+ try {+ dockerClient.pingCmd().exec();+ } catch (Exception e) {+ assumeTrue(false, "Docker is not available: " + e.getMessage());+ }+ }++ private static RequestSpecification query(String action) {+ return given().header("Authorization", AUTH)+ .contentType(URLENC)+ .formParam("Action", action)+ .formParam("Version", "2014-10-31");+ }++ @Test+ void aPostgresInstancesLogIsListedAndDownloaded() {+ String id = "log-files-pg-" + Long.toString(System.nanoTime(), 36);+ try {+ query("CreateDBInstance")+ .formParam("DBInstanceIdentifier", id)+ .formParam("Engine", "postgres")+ .formParam("DBInstanceClass", "db.t3.micro")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("AllocatedStorage", "20")+ .when().post("/").then().statusCode(200);++ // CreateDBInstance returns once the database accepts connections, so its startup log is+ // already in the container's output: the first call must see it.+ List<String> names = query("DescribeDBLogFiles").formParam("DBInstanceIdentifier", id)+ .when().post("/").then().statusCode(200).extract().xmlPath()+ .getList("**.findAll { it.name() == 'LogFileName' }", String.class);+ assertFalse(names.isEmpty(), "the instance should have a log file");+ assertTrue(names.stream().allMatch(n -> n.matches("error/postgresql\\.log\\.\\d{4}-\\d{2}-\\d{2}-\\d{2}")),+ names.toString());++ StringBuilder all = new StringBuilder();+ for (String name : names) {+ all.append(query("DownloadDBLogFilePortion").formParam("DBInstanceIdentifier", id)+ .formParam("LogFileName", name).formParam("Marker", "0")+ .when().post("/").then().statusCode(200).extract().xmlPath()+ .getString("DownloadDBLogFilePortionResponse.DownloadDBLogFilePortionResult.LogFileData"));+ }+ String data = all.toString();+ assertTrue(data.contains("ready to accept connections"), data);+ } finally {+ query("DeleteDBInstance").formParam("DBInstanceIdentifier", id).formParam("SkipFinalSnapshot", "true")+ .when().post("/");+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesIntegrationTest.javanew file mode 100644index 0000000000..48ce5da7c0--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesIntegrationTest.java@@ -0,0 +1,93 @@+package io.github.hectorvent.floci.services.rds;++import io.github.hectorvent.floci.testing.RdsMockProfile;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static io.restassured.http.ContentType.URLENC;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;++/**+ * {@code DescribeDBLogFiles} and {@code DownloadDBLogFilePortion} over the Query protocol in mock+ * RDS mode, where an instance has no container and so no log files, and the errors the API+ * reference lists. {@code RdsLogFilesDockerIntegrationTest} reads a real container's log.+ */+@QuarkusTest+@TestProfile(RdsMockProfile.class)+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class RdsLogFilesIntegrationTest {++ private static final String INSTANCE = "log-files-db";++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20261015/us-east-1/rds/aws4_request, "+ + "SignedHeaders=content-type;host, Signature=test";++ private static RequestSpecification query(String action) {+ return given().header("Authorization", AUTH)+ .contentType(URLENC)+ .formParam("Action", action)+ .formParam("Version", "2014-10-31");+ }++ @Test+ @Order(1)+ void anInstanceWithoutAContainerHasNoLogFiles() {+ query("CreateDBInstance")+ .formParam("DBInstanceIdentifier", INSTANCE)+ .formParam("Engine", "postgres")+ .formParam("DBInstanceClass", "db.t3.micro")+ .formParam("MasterUsername", "admin")+ .formParam("MasterUserPassword", "password123")+ .formParam("AllocatedStorage", "20")+ .when().post("/").then().statusCode(200);++ query("DescribeDBLogFiles").formParam("DBInstanceIdentifier", INSTANCE)+ .when().post("/").then().statusCode(200)+ .body(containsString("<DescribeDBLogFilesResult><DescribeDBLogFiles></DescribeDBLogFiles>"));+ query("DownloadDBLogFilePortion").formParam("DBInstanceIdentifier", INSTANCE)+ .formParam("LogFileName", "error/postgresql.log.2026-10-15-10")+ .when().post("/").then().statusCode(404)+ .body("ErrorResponse.Error.Code", equalTo("DBLogFileNotFoundFault"));+ }++ @Test+ @Order(2)+ void theApiReferencesErrors() {+ query("DescribeDBLogFiles").formParam("DBInstanceIdentifier", "no-such-db")+ .when().post("/").then().statusCode(404)+ .body("ErrorResponse.Error.Code", equalTo("DBInstanceNotFound"));+ query("DescribeDBLogFiles")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("MissingParameter"));+ query("DownloadDBLogFilePortion").formParam("DBInstanceIdentifier", INSTANCE)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("MissingParameter"));+ query("DescribeDBLogFiles").formParam("DBInstanceIdentifier", INSTANCE).formParam("MaxRecords", "5")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterValue"));+ query("DescribeDBLogFiles").formParam("DBInstanceIdentifier", INSTANCE).formParam("FileSize", "big")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterValue"));+ for (String[] bad : new String[][] {{"FileSize", "-1"}, {"FileLastWritten", "-1"}, {"Marker", "-1"}}) {+ query("DescribeDBLogFiles").formParam("DBInstanceIdentifier", INSTANCE).formParam(bad[0], bad[1])+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterValue"));+ }++ query("StopDBInstance").formParam("DBInstanceIdentifier", INSTANCE)+ .when().post("/").then().statusCode(200);+ query("DescribeDBLogFiles").formParam("DBInstanceIdentifier", INSTANCE)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("DBInstanceNotReady"));+ query("StartDBInstance").formParam("DBInstanceIdentifier", INSTANCE)+ .when().post("/").then().statusCode(200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesTest.javanew file mode 100644index 0000000000..0a9d64966f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsLogFilesTest.java@@ -0,0 +1,134 @@+package io.github.hectorvent.floci.services.rds;++import io.github.hectorvent.floci.core.common.AwsException;+import org.junit.jupiter.api.Test;++import java.nio.charset.StandardCharsets;+import java.time.Instant;+import java.util.ArrayList;+import java.util.List;++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;++class RdsLogFilesTest {++ private static List<String> docker(String... lines) {+ return List.of(lines);+ }++ @Test+ void postgresRotatesHourlyAndMysqlKeepsOneErrorLog() {+ List<RdsLogFiles.LogLine> lines = RdsLogFiles.parseDockerLines(docker(+ "2026-10-15T09:59:59.000000001Z LOG: database system is ready",+ "2026-10-15T10:00:00.5Z LOG: checkpoint starting",+ "2026-10-15T10:30:00Z ERROR: relation \"t\" does not exist"));++ List<RdsLogFiles.LogFile> postgres = RdsLogFiles.files("postgres", lines);+ assertEquals(List.of("error/postgresql.log.2026-10-15-09", "error/postgresql.log.2026-10-15-10"),+ postgres.stream().map(RdsLogFiles.LogFile::name).toList());+ RdsLogFiles.LogFile tenOClock = postgres.get(1);+ assertEquals(Instant.parse("2026-10-15T10:30:00Z"), tenOClock.lastWritten());+ assertEquals(List.of("LOG: checkpoint starting", "ERROR: relation \"t\" does not exist"), tenOClock.lines());+ assertEquals("LOG: checkpoint starting\n".length() + "ERROR: relation \"t\" does not exist\n".length(),+ tenOClock.size());++ assertEquals(List.of("error/mysql-error.log"),+ RdsLogFiles.files("mariadb", lines).stream().map(RdsLogFiles.LogFile::name).toList());+ assertEquals(List.of("log/ERROR"),+ RdsLogFiles.files("sqlserver-se", lines).stream().map(RdsLogFiles.LogFile::name).toList());+ assertEquals(2, RdsLogFiles.files("aurora-postgresql", lines).size());+ }++ @Test+ void aLineWithoutATimestampTakesThePreviousOnesTimeAndControlCharactersAreReplaced() {+ List<RdsLogFiles.LogLine> lines = RdsLogFiles.parseDockerLines(docker(+ "2026-10-15T10:00:00Z first",+ "continued\u001b[0m\ttab"));+ assertEquals(Instant.parse("2026-10-15T10:00:00Z"), lines.get(1).time());+ assertEquals("continued�[0m\ttab", lines.get(1).text());+ }++ @Test+ void describeFiltersByNameTimeAndSize() {+ List<RdsLogFiles.LogFile> files = RdsLogFiles.files("postgres", RdsLogFiles.parseDockerLines(docker(+ "2026-10-15T09:00:00Z a",+ "2026-10-15T10:00:00Z bbbbbbbbbb")));+ assertEquals(1, RdsLogFiles.matching(files, "-09", null, null).size());+ long tenOClock = Instant.parse("2026-10-15T10:00:00Z").toEpochMilli();+ assertEquals("error/postgresql.log.2026-10-15-10",+ RdsLogFiles.matching(files, null, tenOClock, null).get(0).name());+ // Larger than the size given: "a\n" is 2 bytes, "bbbbbbbbbb\n" 11.+ assertEquals(1, RdsLogFiles.matching(files, null, null, 2L).size());+ assertEquals(2, RdsLogFiles.matching(files, "", null, null).size());+ }++ private static RdsLogFiles.LogFile fileOf(int lines) {+ List<String> texts = new ArrayList<>();+ for (int i = 0; i < lines; i++) {+ texts.add("line " + i);+ }+ return new RdsLogFiles.LogFile("error/mysql-error.log", Instant.EPOCH, 0, texts);+ }++ @Test+ void downloadFollowsTheApiReferencesMarkerRules() {+ RdsLogFiles.LogFile file = fileOf(5);++ // No marker: the most recent lines.+ RdsLogFiles.Portion tail = RdsLogFiles.portion(file, null, 2);+ assertEquals("line 3\nline 4\n", tail.data());+ assertFalse(tail.additionalDataPending());+ assertEquals("5", tail.marker());++ // Marker "0": from the start, in blocks, until nothing is pending.+ RdsLogFiles.Portion first = RdsLogFiles.portion(file, "0", 2);+ assertEquals("line 0\nline 1\n", first.data());+ assertTrue(first.additionalDataPending());+ RdsLogFiles.Portion second = RdsLogFiles.portion(file, first.marker(), 2);+ assertEquals("line 2\nline 3\n", second.data());+ RdsLogFiles.Portion last = RdsLogFiles.portion(file, second.marker(), 2);+ assertEquals("line 4\n", last.data());+ assertFalse(last.additionalDataPending());++ // Neither: the whole file (up to 10000 lines).+ assertEquals(5, RdsLogFiles.portion(file, null, null).data().split("\n").length);+ // A marker past the end is an empty block.+ assertEquals("", RdsLogFiles.portion(file, "99", 2).data());++ assertThrows(AwsException.class, () -> RdsLogFiles.portion(file, "next", 2));+ assertThrows(AwsException.class, () -> RdsLogFiles.portion(file, "-1", 2));+ assertThrows(AwsException.class, () -> RdsLogFiles.portion(file, "0", 0));+ }++ @Test+ void aBlockStopsAtOneMegabyteAndAtTenThousandLines() {+ List<String> big = new ArrayList<>();+ String kb = "x".repeat(1023);+ for (int i = 0; i < 2000; i++) {+ big.add(kb);+ }+ RdsLogFiles.LogFile file = new RdsLogFiles.LogFile("log/ERROR", Instant.EPOCH, 0, big);+ RdsLogFiles.Portion portion = RdsLogFiles.portion(file, "0", 5000);+ assertEquals(1024, portion.data().split("\n").length);+ assertTrue(portion.additionalDataPending());+ assertEquals("1024", portion.marker());++ assertEquals("10000", RdsLogFiles.portion(fileOf(12_000), "0", 50_000).marker());+ }++ @Test+ void aSingleLineOverOneMegabyteIsCutAtOneMegabyte() {+ String huge = "\u00e9".repeat(RdsLogFiles.MAX_BYTES);+ RdsLogFiles.LogFile file = new RdsLogFiles.LogFile("log/ERROR", Instant.EPOCH, 0, List.of(huge, "next"));+ RdsLogFiles.Portion portion = RdsLogFiles.portion(file, "0", 10);+ int bytes = portion.data().getBytes(StandardCharsets.UTF_8).length;+ assertTrue(bytes <= RdsLogFiles.MAX_BYTES, Integer.toString(bytes));+ assertTrue(portion.data().endsWith("\u00e9\n"), "cut between characters");+ assertEquals("1", portion.marker());+ assertTrue(portion.additionalDataPending());+ assertEquals("next\n", RdsLogFiles.portion(file, portion.marker(), 10).data());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.javaindex 95064fe529..a8ec8c1017 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java@@ -510,6 +510,37 @@ class RdsServiceTest {}}+ @Test+ void logFilesRecoverAMissingContainerOnceThenReportTheInstanceNotReady() {+ when(rdsConfig.mock()).thenReturn(true);+ rdsService.createDbInstance("logs-db", "postgres", "16.3", "admin", "password", "appdb",+ "db.t3.micro", 20, false, null, null, null, null, false, false, null,+ Map.of(), List.of(), null, null, true, DbInstanceSettings.defaults());+ when(rdsConfig.mock()).thenReturn(false);+ RdsService service = spy(rdsService);+ DbInstance recovered = new DbInstance();+ recovered.setContainerId("fresh-container");+ doReturn(recovered).when(service).ensureInstanceBackend(eq("logs-db"), any());++ // No container id on file: the backend is found once and its log read.+ when(containerManager.readLog("fresh-container"))+ .thenReturn(List.of("2026-10-15T10:00:00Z LOG: database system is ready to accept connections"));+ assertEquals(List.of("error/postgresql.log.2026-10-15-10"),+ service.describeDbLogFiles(null, "logs-db", null, null, null, null, null).files().stream()+ .map(RdsLogFiles.LogFile::name).toList());++ // Docker does not know the recovered container either: the instance is not ready.+ when(containerManager.readLog("fresh-container")).thenReturn(null);+ AwsException notReady = assertThrows(AwsException.class,+ () -> service.describeDbLogFiles(null, "logs-db", null, null, null, null, null));+ assertEquals("DBInstanceNotReady", notReady.getErrorCode());++ // A read that times out is a failure, not a short log.+ when(containerManager.readLog("fresh-container")).thenThrow(new IllegalStateException("Timed out"));+ assertEquals("InternalFailure", assertThrows(AwsException.class,+ () -> service.describeDbLogFiles(null, "logs-db", null, null, null, null, null)).getErrorCode());+ }+@Testvoid replacedClusterCannotReceiveAnOldMemberPublicationAndRetryReusesThePort() throws Exception {when(rdsConfig.mock()).thenReturn(false);diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.javaindex 862f1265fb..de7f99a5ef 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/container/RdsContainerManagerTest.java@@ -1,10 +1,14 @@package io.github.hectorvent.floci.services.rds.container;import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.async.ResultCallback;import com.github.dockerjava.api.command.CopyArchiveToContainerCmd;+import com.github.dockerjava.api.command.LogContainerCmd;import com.github.dockerjava.api.command.PauseContainerCmd;import com.github.dockerjava.api.command.UnpauseContainerCmd;import com.github.dockerjava.api.model.Bind;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.StreamType;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.ServiceConfigAccess;@@ -24,9 +28,12 @@ import org.mockito.ArgumentCaptor;import org.mockito.InOrder;import org.mockito.Mockito;+import java.io.Closeable;import java.io.InputStream;+import java.nio.charset.StandardCharsets;import java.nio.file.Files;import java.nio.file.Path;+import java.time.Duration;import java.time.Instant;import java.util.List;import java.util.Map;@@ -240,6 +247,40 @@ class RdsContainerManagerTest {verify(lifecycleManager, never()).getDockerClient();}+ @Test+ void aLogReadThatTimesOutFailsAndClosesTheStream() throws Exception {+ EmulatorConfig config = config(tempDir.resolve("host-root"));+ ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);+ DockerClient dockerClient = mock(DockerClient.class);+ when(lifecycleManager.getDockerClient()).thenReturn(dockerClient);+ LogContainerCmd logCmd = mock(LogContainerCmd.class);+ when(dockerClient.logContainerCmd("slow")).thenReturn(logCmd);+ when(logCmd.withStdOut(true)).thenReturn(logCmd);+ when(logCmd.withStdErr(true)).thenReturn(logCmd);+ when(logCmd.withTimestamps(true)).thenReturn(logCmd);+ when(logCmd.withTail(RdsContainerManager.MAX_LOG_LINES)).thenReturn(logCmd);+ Closeable stream = mock(Closeable.class);+ // Docker starts the stream and sends one frame, then never completes.+ when(logCmd.exec(any())).thenAnswer(invocation -> {+ ResultCallback.Adapter<Frame> callback = invocation.getArgument(0);+ callback.onStart(stream);+ callback.onNext(new Frame(StreamType.STDOUT,+ "2026-10-15T10:00:00Z partial\n".getBytes(StandardCharsets.UTF_8)));+ return callback;+ });++ RdsContainerManager manager = new RdsContainerManager(+ new ContainerBuilder(config, mock(DockerHostResolver.class), mock(EmbeddedDnsServer.class)),+ lifecycleManager, mock(ContainerLogStreamer.class), mock(ContainerDetector.class), config,+ new RegionResolver("us-east-1", "000000000000"),+ mock(ServiceConfigAccess.class));++ IllegalStateException timedOut = assertThrows(IllegalStateException.class,+ () -> manager.readLog("slow", Duration.ofMillis(50)));+ assertTrue(timedOut.getMessage().contains("Timed out"), timedOut.getMessage());+ verify(stream).close();+ }+@Testvoid mysqlNonRootMasterStartInstallsGrantInitScriptBeforeStart() throws Exception {EmulatorConfig config = config(tempDir.resolve("host-root"));