Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ecs): renew task role credentials at the published URI (#6728)
Aniket Shuklaa4ef9eaa6a78
diff --git a/docs/services/ecs.md b/docs/services/ecs.mdindex 0ca3eb5f7d..c222118a11 100644--- a/docs/services/ecs.md+++ b/docs/services/ecs.md@@ -899,6 +899,11 @@ them: Flociwrites `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` into every container in the task, pointing at one`/v2/credentials/{id}` path per task, and the AWS SDKs pick it up with no code change.+The published path stays the same when credentials renew, including when a task first reads it+after the previous credentials expire. Reads near expiry return a fresh session. Credentials+already cached by another client remain valid until their original expiry; stopping the task+revokes every generation. A deleted or recreated task role invalidates the endpoint.+**A user-defined Docker network is required.** Set `FLOCI_SERVICES_ECS_DOCKER_NETWORK` to a networkyou created; the default bridge will not work. The SDKs hardcode `169.254.170.2` for this endpoint,so Floci runs a small proxy container that holds that address on the task's network and forwards todiff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentials.java b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentials.javaindex f5b4f47437..e42cc40fec 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentials.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentials.java@@ -10,8 +10,11 @@ import jakarta.inject.Inject;import java.security.SecureRandom;import java.time.Instant;+import java.util.ArrayList;import java.util.Base64;+import java.util.List;import java.util.Map;+import java.util.Objects;import java.util.Optional;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;@@ -55,20 +58,36 @@ public class EcsTaskRoleCredentials {* created the task by the time containers are started.*/public synchronized Optional<String> issue(String taskArn, String roleArn, String accountId, Instant now) {+ Issued current = taskArn == null ? null : byTaskArn.get(taskArn);+ if (current != null && (!current.session.getRoleArn().equals(roleArn)+ || !current.session.getOriginAccountId().equals(accountId))) {+ revoke(current);+ current = null;+ }if (taskArn == null || taskArn.isBlank() || roleArn == null || roleArn.isBlank()|| accountId == null || accountId.isBlank()) {return Optional.empty();}- Issued current = byTaskArn.get(taskArn);- if (current != null && current.session.getRoleArn().equals(roleArn)- && current.session.getExpiration().isAfter(now.plusSeconds(ROTATE_WITHIN_SECONDS))) {- return Optional.of(current.path);- }-Optional<IamRole> role = resolveRole(roleArn, accountId);- if (role.isEmpty()) {+ if (role.isEmpty() || (current != null && !Objects.equals(current.roleId, role.get().getRoleId()))) {+ if (current != null) {+ revoke(current);+ }return Optional.empty();}+ if (current != null) {+ current.previous.removeIf(session -> {+ if (!session.getExpiration().isAfter(now)) {+ iamService.unregisterSession(accountId, session.getAccessKeyId());+ return true;+ }+ return false;+ });+ long rotationWindow = Math.min(ROTATE_WITHIN_SECONDS, ttlSeconds / 10);+ if (current.session.getExpiration().isAfter(now.plusSeconds(rotationWindow))) {+ return Optional.of(current.path);+ }+ }SessionCredential session = new SessionCredential("ASIA" + random(UPPER_ALPHANUMERIC, 16), randomBase64(30), randomBase64(48),@@ -81,14 +100,18 @@ public class EcsTaskRoleCredentials {}iamService.registerEcsTaskRoleSession(session);- String path = "/v2/credentials/" + UUID.randomUUID();- Issued issued = new Issued(session, path);- byPath.put(path, issued);- byTaskArn.put(taskArn, issued);+ String path = current == null ? "/v2/credentials/" + UUID.randomUUID() : current.path;+ List<SessionCredential> previous = current == null ? new ArrayList<>() : current.previous;if (current != null) {- byPath.remove(current.path, current);- iamService.unregisterSession(accountId, current.session.getAccessKeyId());+ if (current.session.getExpiration().isAfter(now)) {+ previous.add(current.session);+ } else {+ iamService.unregisterSession(accountId, current.session.getAccessKeyId());+ }}+ Issued issued = new Issued(session, path, role.get().getRoleId(), previous);+ byPath.put(path, issued);+ byTaskArn.put(taskArn, issued);return Optional.of(path);}@@ -98,11 +121,8 @@ public class EcsTaskRoleCredentials {if (issued == null) {return Optional.empty();}- if (!issued.session.getExpiration().isAfter(now)) {- revoke(issued);- return Optional.empty();- }- return Optional.of(issued.session);+ return issue(issued.session.getEcsTaskArn(), issued.session.getRoleArn(),+ issued.session.getOriginAccountId(), now).map(renewedPath -> byPath.get(renewedPath).session);}/** Revokes the task's credentials on task stop, exit, or a launch that failed part way through. */@@ -117,6 +137,9 @@ public class EcsTaskRoleCredentials {byTaskArn.remove(issued.session.getEcsTaskArn(), issued);byPath.remove(issued.path, issued);iamService.unregisterSession(issued.session.getOriginAccountId(), issued.session.getAccessKeyId());+ for (SessionCredential previous : issued.previous) {+ iamService.unregisterSession(previous.getOriginAccountId(), previous.getAccessKeyId());+ }}private Optional<IamRole> resolveRole(String roleArn, String accountId) {@@ -126,7 +149,8 @@ public class EcsTaskRoleCredentials {} catch (IllegalArgumentException e) {return Optional.empty();}- if (!"iam".equals(parsed.service()) || !parsed.resource().startsWith("role/")) {+ if (!"iam".equals(parsed.service()) || !parsed.accountId().equals(accountId)+ || !parsed.resource().startsWith("role/")) {return Optional.empty();}String roleName = parsed.resource().substring(parsed.resource().lastIndexOf('/') + 1);@@ -150,5 +174,5 @@ public class EcsTaskRoleCredentials {return Base64.getEncoder().encodeToString(bytes);}- private record Issued(SessionCredential session, String path) {}+ private record Issued(SessionCredential session, String path, String roleId, List<SessionCredential> previous) {}}diff --git a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServer.java b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServer.javaindex 4ae30217b7..88212f995c 100644--- a/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServer.java+++ b/src/main/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServer.java@@ -57,7 +57,7 @@ public class EcsTaskRoleCredentialsServer {int port = config.services().ecs().taskRoleCredentials().port();Router router = Router.router(vertx);- router.get("/v2/credentials/:id").handler(this::handleCredentials);+ router.get("/v2/credentials/:id").blockingHandler(this::handleCredentials);httpServer = vertx.createHttpServer();httpServer.requestHandler(router).listen(port, result -> {diff --git a/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServerIntegrationTest.javaindex 84161f96c4..3062dbdce8 100644--- a/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ecs/container/EcsTaskRoleCredentialsServerIntegrationTest.java@@ -4,10 +4,12 @@ import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.services.iam.IamService;import io.github.hectorvent.floci.testutil.FreePorts;import io.quarkus.test.junit.QuarkusTest;+import io.vertx.core.Context;import io.vertx.core.Vertx;import io.vertx.core.json.JsonObject;import jakarta.inject.Inject;-import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;import java.net.URI;import java.net.http.HttpClient;@@ -17,13 +19,18 @@ import java.time.Duration;import java.time.Instant;import java.util.UUID;import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicBoolean;import static io.restassured.RestAssured.given;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.Mockito.RETURNS_DEEP_STUBS;+import static org.mockito.Mockito.doAnswer;import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.spy;import static org.mockito.Mockito.when;/**@@ -38,8 +45,9 @@ class EcsTaskRoleCredentialsServerIntegrationTest {@InjectIamService iam;- @Test- void credentialsEndpointServesAnIssuedSessionAndStopsAfterRevoke() throws Exception {+ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void credentialsEndpointServesAndRenewsThePublishedPathThenStopsAfterRevoke(boolean expired) throws Exception {String account = "356813579012";String suffix = UUID.randomUUID().toString().substring(0, 8);String role = "ecs-task-role-" + suffix;@@ -60,25 +68,32 @@ class EcsTaskRoleCredentialsServerIntegrationTest {when(config.services().ecs().taskRoleCredentials().ttlSeconds()).thenReturn(21600L);Vertx vertx = Vertx.vertx();- EcsTaskRoleCredentials credentials = new EcsTaskRoleCredentials(iam, config);+ EcsTaskRoleCredentials credentials = spy(new EcsTaskRoleCredentials(iam, config));+ AtomicBoolean workerLookup = new AtomicBoolean();+ doAnswer(invocation -> {+ workerLookup.set(Context.isOnWorkerThread());+ return invocation.callRealMethod();+ }).when(credentials).resolveByPath(anyString(), any(Instant.class));EcsTaskRoleCredentialsServer server = new EcsTaskRoleCredentialsServer(vertx, config, credentials);String endpoint = "http://127.0.0.1:" + port;try (HttpClient client = HttpClient.newHttpClient()) {server.start().get(10, TimeUnit.SECONDS);- String path = credentials.issue(taskArn, roleArn, account, Instant.now()).orElseThrow();+ Instant issuedAt = Instant.now().minusSeconds(expired ? 21601 : 0);+ String path = credentials.issue(taskArn, roleArn, account, issuedAt).orElseThrow();assertTrue(path.matches("^/v2/credentials/[0-9a-f-]{36}$"), path);assertEquals(404, get(client, endpoint + "/v2/credentials/" + UUID.randomUUID()).statusCode());HttpResponse<String> response = get(client, endpoint + path);assertEquals(200, response.statusCode());+ assertTrue(workerLookup.get(), "Credential storage must run on a worker thread");JsonObject body = new JsonObject(response.body());assertEquals(roleArn, body.getString("RoleArn"));assertTrue(Instant.parse(body.getString("Expiration")).isAfter(Instant.now()));String key = body.getString("AccessKeyId");String token = body.getString("Token");assertTrue(key.startsWith("ASIA"));- assertEquals(body.getString("SecretAccessKey"), iam.findSecretKey(key, token).orElseThrow());+ assertTrue(iam.findSecretKey(key, token).filter(body.getString("SecretAccessKey")::equals).isPresent());assertEquals(account, iam.resolveAccountId(key).orElseThrow());credentials.revoke(taskArn);diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/EcsTaskRoleCredentialsTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/EcsTaskRoleCredentialsTest.javaindex d2f47885d8..a5b4ad019a 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/EcsTaskRoleCredentialsTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/EcsTaskRoleCredentialsTest.java@@ -8,10 +8,12 @@ import io.github.hectorvent.floci.services.iam.model.SessionCredential;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import java.time.Clock;import java.time.Instant;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.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.Mockito.RETURNS_DEEP_STUBS;@@ -31,13 +33,17 @@ class EcsTaskRoleCredentialsTest {private IamService iamService;private EcsTaskRoleCredentials credentials;private String roleArn;+ private final Clock clock = mock(Clock.class);+ private InMemoryStorage<String, SessionCredential> sessions;@BeforeEachvoid setUp() {+ when(clock.instant()).thenReturn(Instant.parse("2030-01-01T00:00:00Z"));+ sessions = new InMemoryStorage<>();iamService = new IamService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),- new InMemoryStorage<>(), new RegionResolver("us-east-1", "000000000000"), false);+ sessions, new RegionResolver("us-east-1", "000000000000"), false, clock);roleArn = iamService.createRole("ecsTaskRole", "/", "{}", null, 3600, null).getArn();EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);@@ -47,7 +53,7 @@ class EcsTaskRoleCredentialsTest {@Testvoid issueMintsAResolvableSessionScopedToTheTask() {- Instant now = Instant.now();+ Instant now = clock.instant();String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();assertTrue(path.matches("^/v2/credentials/[0-9a-f-]{36}$"), path);@@ -64,12 +70,12 @@ class EcsTaskRoleCredentialsTest {@Testvoid issueForUnknownRoleMintsNothing() {assertTrue(credentials.issue(TASK_ARN, "arn:aws:iam::000000000000:role/does-not-exist",- "000000000000", Instant.now()).isEmpty());+ "000000000000", clock.instant()).isEmpty());}@Testvoid reissuingWellBeforeExpiryReturnsTheSamePath() {- Instant now = Instant.now();+ Instant now = clock.instant();String first = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();String second = credentials.issue(TASK_ARN, roleArn, "000000000000", now.plusSeconds(10)).orElseThrow();@@ -77,25 +83,26 @@ class EcsTaskRoleCredentialsTest {}@Test- void reissuingInsideTheRotationWindowMintsAFreshGenerationAndRetiresTheOld() {- Instant now = Instant.now();+ void reissuingInsideTheRotationWindowKeepsThePathAndUnexpiredCachedSession() {+ Instant now = clock.instant();String first = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();SessionCredential firstSession = credentials.resolveByPath(first, now).orElseThrow();// Inside the 300-second rotation window, so a fresh generation is minted.Instant nearExpiry = firstSession.getExpiration().minusSeconds(60);+ at(nearExpiry);String second = credentials.issue(TASK_ARN, roleArn, "000000000000", nearExpiry).orElseThrow();- assertNotEquals(first, second);- assertTrue(credentials.resolveByPath(first, nearExpiry).isEmpty(), "retired generation must stop resolving");- assertTrue(credentials.resolveByPath(second, nearExpiry).isPresent());- assertTrue(iamService.findSecretKey(firstSession.getAccessKeyId(), firstSession.getSessionToken()).isEmpty(),- "the retired generation's access key must stop authenticating");+ assertEquals(first, second);+ SessionCredential refreshed = credentials.resolveByPath(first, nearExpiry).orElseThrow();+ assertFalse(firstSession.getAccessKeyId().equals(refreshed.getAccessKeyId()));+ assertTrue(iamService.findSecretKey(firstSession.getAccessKeyId(), firstSession.getSessionToken()).isPresent());+ assertEquals(now.plusSeconds(21600), firstSession.getExpiration());}@Testvoid separateTasksGetIndependentSessions() {- Instant now = Instant.now();+ Instant now = clock.instant();String taskAPath = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();String taskBPath = credentials.issue(OTHER_TASK_ARN, roleArn, "000000000000", now).orElseThrow();@@ -110,7 +117,7 @@ class EcsTaskRoleCredentialsTest {@Testvoid revokeStopsTheAccessKeyFromAuthenticating() {- Instant now = Instant.now();+ Instant now = clock.instant();String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();SessionCredential session = credentials.resolveByPath(path, now).orElseThrow();@@ -126,19 +133,161 @@ class EcsTaskRoleCredentialsTest {}@Test- void resolveByPathExpiresAndRevokesOnceThePastExpirationIsSeen() {- Instant now = Instant.now();+ void expiredCredentialsAreRenewedAtThePublishedPath() {+ Instant now = clock.instant();String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ SessionCredential original = credentials.resolveByPath(path, now).orElseThrow();+ Instant later = at(now.plusSeconds(21601));- Optional<SessionCredential> pastExpiry = credentials.resolveByPath(path, now.plusSeconds(21601));+ Optional<SessionCredential> pastExpiry = credentials.resolveByPath(path, later);- assertTrue(pastExpiry.isEmpty());- assertTrue(credentials.resolveByPath(path, now).isEmpty(), "an expired path must not come back");+ assertTrue(pastExpiry.isPresent());+ assertEquals(later.plusSeconds(21600), pastExpiry.orElseThrow().getExpiration());+ assertTrue(iamService.findSecretKey(original.getAccessKeyId(), original.getSessionToken()).isEmpty());+ assertTrue(sessions.get(original.getAccessKeyId()).isEmpty());}@Testvoid resolveByPathForUnknownPathIsEmpty() {- assertTrue(credentials.resolveByPath("/v2/credentials/does-not-exist", Instant.now()).isEmpty());- assertTrue(credentials.resolveByPath(null, Instant.now()).isEmpty());+ assertTrue(credentials.resolveByPath("/v2/credentials/does-not-exist", clock.instant()).isEmpty());+ assertTrue(credentials.resolveByPath(null, clock.instant()).isEmpty());+ }++ @Test+ void endpointReadsRenewBeforeExpiryAndStopRevokesAllLiveGenerations() {+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ SessionCredential first = credentials.resolveByPath(path, now).orElseThrow();+ Instant nearExpiry = at(first.getExpiration().minusSeconds(60));+ SessionCredential second = credentials.resolveByPath(path, nearExpiry).orElseThrow();+ assertFalse(first.getAccessKeyId().equals(second.getAccessKeyId()));+ assertTrue(iamService.findSecretKey(first.getAccessKeyId(), first.getSessionToken()).isPresent());+ assertTrue(iamService.findSecretKey(second.getAccessKeyId(), second.getSessionToken()).isPresent());+ credentials.revoke(TASK_ARN);+ assertTrue(credentials.resolveByPath(path, nearExpiry).isEmpty());+ assertTrue(iamService.findSecretKey(first.getAccessKeyId(), first.getSessionToken()).isEmpty());+ assertTrue(iamService.findSecretKey(second.getAccessKeyId(), second.getSessionToken()).isEmpty());+ }++ @Test+ void successiveRenewalsDiscardExpiredGenerationsWithoutExtendingTheirLifetime() {+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ SessionCredential current = credentials.resolveByPath(path, now).orElseThrow();+ for (int i = 0; i < 3; i++) {+ SessionCredential previous = current;+ current = credentials.resolveByPath(path, at(previous.getExpiration().minusSeconds(60))).orElseThrow();+ assertFalse(previous.getAccessKeyId().equals(current.getAccessKeyId()));+ assertEquals(2, sessions.scan(key -> true).size());+ credentials.resolveByPath(path, at(previous.getExpiration().plusSeconds(1))).orElseThrow();+ assertTrue(iamService.findSecretKey(previous.getAccessKeyId(), previous.getSessionToken()).isEmpty());+ assertTrue(iamService.findSecretKey(current.getAccessKeyId(), current.getSessionToken()).isPresent());+ assertEquals(1, sessions.scan(key -> true).size());+ }+ credentials.revoke(TASK_ARN);+ assertTrue(sessions.scan(key -> true).isEmpty());+ }++ @Test+ void shortTtlDoesNotRotateEveryRead() {+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.services().ecs().taskRoleCredentials().ttlSeconds()).thenReturn(60L);+ credentials = new EcsTaskRoleCredentials(iamService, config);+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ SessionCredential first = credentials.resolveByPath(path, now).orElseThrow();+ assertEquals(path, credentials.issue(TASK_ARN, roleArn, "000000000000", at(now.plusSeconds(10))).orElseThrow());+ assertTrue(first.getAccessKeyId().equals(+ credentials.resolveByPath(path, clock.instant()).orElseThrow().getAccessKeyId()));+ SessionCredential second = credentials.resolveByPath(path, at(now.plusSeconds(59))).orElseThrow();+ assertFalse(first.getAccessKeyId().equals(second.getAccessKeyId()));+ assertTrue(iamService.findSecretKey(first.getAccessKeyId(), first.getSessionToken()).isPresent());+ assertTrue(second.getAccessKeyId().equals(+ credentials.resolveByPath(path, at(now.plusSeconds(61))).orElseThrow().getAccessKeyId()));+ assertTrue(iamService.findSecretKey(first.getAccessKeyId(), first.getSessionToken()).isEmpty());+ }++ @Test+ void oneSecondTtlReusesTheSessionUntilItExpires() {+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.services().ecs().taskRoleCredentials().ttlSeconds()).thenReturn(1L);+ credentials = new EcsTaskRoleCredentials(iamService, config);+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ SessionCredential first = sessions.scan(key -> true).getFirst();+ for (int i = 0; i < 10; i++) {+ SessionCredential current = credentials.resolveByPath(path, at(now.plusMillis(i * 90))).orElseThrow();+ assertTrue(first.getAccessKeyId().equals(current.getAccessKeyId()));+ assertEquals(1, sessions.scan(key -> true).size());+ }+ SessionCredential renewed = credentials.resolveByPath(path, at(now.plusSeconds(1))).orElseThrow();+ assertFalse(first.getAccessKeyId().equals(renewed.getAccessKeyId()));+ assertTrue(iamService.findSecretKey(first.getAccessKeyId(), first.getSessionToken()).isEmpty());+ assertEquals(1, sessions.scan(key -> true).size());+ }++ @Test+ void deletingTheRoleRevokesThePathAndEveryCachedGeneration() {+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ SessionCredential first = credentials.resolveByPath(path, now).orElseThrow();+ credentials.issue(TASK_ARN, roleArn, "000000000000", at(first.getExpiration().minusSeconds(60))).orElseThrow();+ iamService.deleteRole("ecsTaskRole");+ assertTrue(credentials.resolveByPath(path, clock.instant()).isEmpty());+ assertTrue(sessions.scan(key -> true).isEmpty());+ }++ @Test+ void recreatingTheRoleCannotRenewAnOldTasksCredentials() {+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ iamService.deleteRole("ecsTaskRole");+ iamService.createRole("ecsTaskRole", "/", "{}", null, 3600, null);+ assertTrue(credentials.resolveByPath(path, now).isEmpty());+ assertTrue(sessions.scan(key -> true).isEmpty());+ }++ @Test+ void wrongAccountRoleDoesNotMintASession() {+ assertTrue(credentials.issue(TASK_ARN, roleArn, "111111111111", clock.instant()).isEmpty());+ assertTrue(sessions.scan(key -> true).isEmpty());+ }++ @Test+ void changingToAnUnknownRoleRevokesTheOldAssignment() {+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ assertTrue(credentials.issue(TASK_ARN, "arn:aws:iam::000000000000:role/missing", "000000000000", now).isEmpty());+ assertTrue(credentials.resolveByPath(path, now).isEmpty());+ assertTrue(sessions.scan(key -> true).isEmpty());+ }++ @Test+ void changingTheAccountRevokesTheOldAssignment() {+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ assertTrue(credentials.issue(TASK_ARN, roleArn, "111111111111", now).isEmpty());+ assertTrue(credentials.resolveByPath(path, now).isEmpty());+ assertTrue(sessions.scan(key -> true).isEmpty());+ }++ @Test+ void changingToAnotherRoleReplacesThePathAndRevokesCachedGenerations() {+ Instant now = clock.instant();+ String path = credentials.issue(TASK_ARN, roleArn, "000000000000", now).orElseThrow();+ SessionCredential first = credentials.resolveByPath(path, now).orElseThrow();+ Instant nearExpiry = at(first.getExpiration().minusSeconds(60));+ credentials.resolveByPath(path, nearExpiry).orElseThrow();+ String nextRole = iamService.createRole("nextRole", "/", "{}", null, 3600, null).getArn();+ String nextPath = credentials.issue(TASK_ARN, nextRole, "000000000000", nearExpiry).orElseThrow();+ assertNotEquals(path, nextPath);+ assertTrue(credentials.resolveByPath(path, nearExpiry).isEmpty());+ assertEquals(nextRole, credentials.resolveByPath(nextPath, nearExpiry).orElseThrow().getRoleArn());+ assertEquals(1, sessions.scan(key -> true).size());+ }++ private Instant at(Instant now) {+ when(clock.instant()).thenReturn(now);+ return now;}}