Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cognito): serialize attribute verification updates (#2535)
Daniel Zwicker530717e8e0f3
diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.javaindex 4203b8654f..b8c7f0d868 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java@@ -86,6 +86,8 @@ public class CognitoService implements ResourceProvider {private static final int DEFAULT_REFRESH_TOKEN_VALIDITY_DAYS = 30;private static final String COGNITO_PASSWORD_SYMBOLS ="^$*.[]{}()?\"!@#%&/\\,><':;|_~`=+-";+ // JVM-local stripes bound lock memory without retaining one lock for every user key.+ private static final int USER_LOCK_STRIPES = 512;private static final Logger LOG = Logger.getLogger(CognitoService.class);private static final ObjectMapper MAPPER = new ObjectMapper();@@ -132,10 +134,24 @@ public class CognitoService implements ResourceProvider {private final VerificationCodeService verificationCodeService;private final CognitoMessageDispatcher messageDispatcher;private final TlsCertificateManager certificateManager;+ private final Object[] userLocks = newUserLockStripes();// Keyed by session token; contains SRP ephemeral state (bPrivate, B, A, secretBlock)private final CognitoAuthFlowHandler authFlowHandler;+ private static Object[] newUserLockStripes() {+ Object[] stripes = new Object[USER_LOCK_STRIPES];+ for (int i = 0; i < stripes.length; i++) {+ stripes[i] = new Object();+ }+ return stripes;+ }++ private Object userLock(String poolId, String username) {+ String key = userKey(poolId, username);+ return userLocks[Math.floorMod(key.hashCode(), USER_LOCK_STRIPES)];+ }+@Injectpublic CognitoService(StorageFactory storageFactory, EmulatorConfig emulatorConfig,RegionResolver regionResolver, LambdaService lambdaService, AcmService acmService,@@ -579,7 +595,11 @@ public class CognitoService implements ResourceProvider {groupStore.scan(k -> k.startsWith(prefix)).forEach(g -> groupStore.delete(groupKey(id, g.getGroupName())));userStore.scan(k -> k.startsWith(prefix))- .forEach(u -> userStore.delete(userKey(id, u.getUsername())));+ .forEach(u -> {+ synchronized (userLock(id, u.getUsername())) {+ userStore.delete(userKey(id, u.getUsername()));+ }+ });resourceServerStore.scan(k -> k.startsWith(prefix)).forEach(r -> resourceServerStore.delete(resourceServerKey(id, r.getIdentifier())));// Clients are keyed by client id alone, so they are found by their userPoolId field.@@ -1577,6 +1597,21 @@ public class CognitoService implements ResourceProvider {String temporaryPassword,String messageAction,boolean forceAliasCreation) {+ // Locked on the requested username/alias (not yet resolved to a canonical id, since+ // an alias pool doesn't have one until creation), so two concurrent requests for the+ // same identifier can't both pass the existence/alias check and create duplicates.+ synchronized (userLock(userPoolId, username)) {+ return adminCreateUserUnderUserLock(userPoolId, username, attributes,+ temporaryPassword, messageAction, forceAliasCreation);+ }+ }++ private CognitoUser adminCreateUserUnderUserLock(String userPoolId,+ String username,+ Map<String, String> attributes,+ String temporaryPassword,+ String messageAction,+ boolean forceAliasCreation) {UserPool pool = describeUserPool(userPoolId);boolean resend = "RESEND".equalsIgnoreCase(messageAction);boolean aliasPool = usesAliasUsernames(pool);@@ -1654,6 +1689,13 @@ public class CognitoService implements ResourceProvider {void adminCreateMigratedUser(String userPoolId, String username, String password,Map<String, String> attributes, String finalUserStatus) {+ synchronized (userLock(userPoolId, username)) {+ adminCreateMigratedUserUnderUserLock(userPoolId, username, password, attributes, finalUserStatus);+ }+ }++ private void adminCreateMigratedUserUnderUserLock(String userPoolId, String username, String password,+ Map<String, String> attributes, String finalUserStatus) {UserPool pool = describeUserPool(userPoolId);boolean aliasPool = usesAliasUsernames(pool);@@ -1754,6 +1796,13 @@ public class CognitoService implements ResourceProvider {}public void adminDeleteUser(String userPoolId, String username) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminDeleteUserUnderUserLock(userPoolId, resolvedUser.getUsername());+ }+ }++ private void adminDeleteUserUnderUserLock(String userPoolId, String username) {CognitoUser user = adminGetUser(userPoolId, username);for (String groupName : new ArrayList<>(user.getGroupNames())) {groupStore.get(groupKey(userPoolId, groupName)).ifPresent(group -> {@@ -1766,6 +1815,14 @@ public class CognitoService implements ResourceProvider {}public void adminSetUserPassword(String userPoolId, String username, String password, boolean permanent) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminSetUserPasswordUnderUserLock(userPoolId, resolvedUser.getUsername(), password, permanent);+ }+ }++ private void adminSetUserPasswordUnderUserLock(String userPoolId, String username, String password,+ boolean permanent) {CognitoUser user = adminGetUser(userPoolId, username);updateUserPassword(user, password);user.setTemporaryPassword(!permanent);@@ -1776,6 +1833,15 @@ public class CognitoService implements ResourceProvider {}public void adminUpdateUserAttributes(String userPoolId, String username, Map<String, String> attributes) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminUpdateUserAttributesUnderUserLock(+ userPoolId, resolvedUser.getUsername(), attributes);+ }+ }++ private void adminUpdateUserAttributesUnderUserLock(+ String userPoolId, String username, Map<String, String> attributes) {CognitoUser user = adminGetUser(userPoolId, username);UserPool pool = describeUserPool(userPoolId);if (usesAliasUsernames(pool)) {@@ -1799,6 +1865,15 @@ public class CognitoService implements ResourceProvider {}public void adminDeleteUserAttributes(String userPoolId, String username, List<String> attributeNames) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminDeleteUserAttributesUnderUserLock(+ userPoolId, resolvedUser.getUsername(), attributeNames);+ }+ }++ private void adminDeleteUserAttributesUnderUserLock(+ String userPoolId, String username, List<String> attributeNames) {CognitoUser user = adminGetUser(userPoolId, username);for (String attrName : attributeNames) {user.getAttributes().remove(attrName);@@ -1810,6 +1885,13 @@ public class CognitoService implements ResourceProvider {}public void adminEnableUser(String userPoolId, String username) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminEnableUserUnderUserLock(userPoolId, resolvedUser.getUsername());+ }+ }++ private void adminEnableUserUnderUserLock(String userPoolId, String username) {CognitoUser user = adminGetUser(userPoolId, username);user.setEnabled(true);user.setLastModifiedDate(System.currentTimeMillis() / 1000L);@@ -1818,6 +1900,13 @@ public class CognitoService implements ResourceProvider {}public void adminDisableUser(String userPoolId, String username) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminDisableUserUnderUserLock(userPoolId, resolvedUser.getUsername());+ }+ }++ private void adminDisableUserUnderUserLock(String userPoolId, String username) {CognitoUser user = adminGetUser(userPoolId, username);user.setEnabled(false);user.setLastModifiedDate(System.currentTimeMillis() / 1000L);@@ -1826,6 +1915,13 @@ public class CognitoService implements ResourceProvider {}public void adminResetUserPassword(String userPoolId, String username) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminResetUserPasswordUnderUserLock(userPoolId, resolvedUser.getUsername());+ }+ }++ private void adminResetUserPasswordUnderUserLock(String userPoolId, String username) {CognitoUser user = adminGetUser(userPoolId, username);UserPool pool = describeUserPool(userPoolId);String outgoingPasswordHash = user.getPasswordHash();@@ -1870,10 +1966,20 @@ public class CognitoService implements ResourceProvider {"SourceUser.ProviderAttributeValue is required.", 400);}+ CognitoUser resolvedUser = adminGetUser(userPoolId, destinationUsername);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminLinkProviderForUserUnderUserLock(userPoolId, resolvedUser.getUsername(),+ sourceProviderName, sourceUserId);+ }+ }++ private void adminLinkProviderForUserUnderUserLock(String userPoolId, String destinationUsername,+ String sourceProviderName, String sourceUserId) {// The uniqueness check and the write must not interleave with another// link of the same source identity. The UserPool object cannot serve as// the monitor — updateUserPool replaces the stored instance — so links- // serialize on a dedicated lock.+ // serialize on a dedicated lock in addition to the per-user lock above,+ // since the uniqueness check spans every user in the pool, not just this one.synchronized (identityLinkLock) {CognitoUser user = adminGetUser(userPoolId, destinationUsername);String prefix = userPoolId + "::";@@ -2191,13 +2297,19 @@ public class CognitoService implements ResourceProvider {public void deleteGroup(String userPoolId, String groupName) {CognitoGroup group = getGroup(userPoolId, groupName);long now = System.currentTimeMillis() / 1000L;+ // Each member is locked individually, one at a time, rather than holding every+ // member's lock for the duration of the loop: this method never needs more than one+ // user's invariant held at once, and locking them one at a time avoids having to+ // reason about lock ordering across members.for (String username : new ArrayList<>(group.getUserNames())) {- userStore.get(userKey(userPoolId, username)).ifPresent(user -> {- if (user.getGroupNames().remove(groupName)) {- user.setLastModifiedDate(now);- userStore.put(userKey(userPoolId, user.getUsername()), user);- }- });+ synchronized (userLock(userPoolId, username)) {+ userStore.get(userKey(userPoolId, username)).ifPresent(user -> {+ if (user.getGroupNames().remove(groupName)) {+ user.setLastModifiedDate(now);+ userStore.put(userKey(userPoolId, user.getUsername()), user);+ }+ });+ }}groupStore.delete(groupKey(userPoolId, groupName));LOG.infov("Deleted Cognito group: {0} from pool {1}", groupName, userPoolId);@@ -2223,6 +2335,13 @@ public class CognitoService implements ResourceProvider {}public void adminAddUserToGroup(String userPoolId, String groupName, String username) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminAddUserToGroupUnderUserLock(userPoolId, groupName, resolvedUser.getUsername());+ }+ }++ private void adminAddUserToGroupUnderUserLock(String userPoolId, String groupName, String username) {CognitoGroup group = getGroup(userPoolId, groupName);CognitoUser user = adminGetUser(userPoolId, username);long now = System.currentTimeMillis() / 1000L;@@ -2238,6 +2357,13 @@ public class CognitoService implements ResourceProvider {}public void adminRemoveUserFromGroup(String userPoolId, String groupName, String username) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminRemoveUserFromGroupUnderUserLock(userPoolId, groupName, resolvedUser.getUsername());+ }+ }++ private void adminRemoveUserFromGroupUnderUserLock(String userPoolId, String groupName, String username) {CognitoGroup group = getGroup(userPoolId, groupName);CognitoUser user = adminGetUser(userPoolId, username);long now = System.currentTimeMillis() / 1000L;@@ -2266,6 +2392,15 @@ public class CognitoService implements ResourceProvider {.orElseThrow(() -> new AwsException("ResourceNotFoundException", "Client not found",400));String userPoolId = client.getUserPoolId();+ // Locked on the requested username/alias, same reasoning as adminCreateUser: an alias+ // pool has no canonical id to lock on until creation succeeds.+ synchronized (userLock(userPoolId, username)) {+ return signUpUnderUserLock(client, userPoolId, username, password, attributes);+ }+ }++ private CognitoUser signUpUnderUserLock(UserPoolClient client, String userPoolId,+ String username, String password, Map<String, String> attributes) {UserPool pool = describeUserPool(userPoolId);boolean aliasPool = usesAliasUsernames(pool);@@ -2363,6 +2498,13 @@ public class CognitoService implements ResourceProvider {.orElseThrow(() -> new AwsException("ResourceNotFoundException", "Client not found",400));String userPoolId = client.getUserPoolId();+ synchronized (userLock(userPoolId, username)) {+ confirmSignUpUnderUserLock(client, userPoolId, username, confirmationCode);+ }+ }++ private void confirmSignUpUnderUserLock(UserPoolClient client, String userPoolId, String username,+ String confirmationCode) {UserPool pool = poolStore.get(userPoolId).orElseThrow(() -> userPoolNotFound(userPoolId));CognitoUser user = adminGetUser(client.getUserPoolId(), username);@@ -2375,7 +2517,7 @@ public class CognitoService implements ResourceProvider {throw mapVerificationCodeException(e);}- var signupDeliveryTarget = resolveSignUpDeliveryTarget(pool, user);+ DeliveryTarget signupDeliveryTarget = resolveSignUpDeliveryTarget(pool, user);if (signupDeliveryTarget != null) {if ("email".equals(signupDeliveryTarget.attributeName())) {@@ -2452,6 +2594,13 @@ public class CognitoService implements ResourceProvider {}public void adminConfirmSignUp(String userPoolId, String username) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminConfirmSignUpUnderUserLock(userPoolId, resolvedUser.getUsername());+ }+ }++ private void adminConfirmSignUpUnderUserLock(String userPoolId, String username) {CognitoUser user = adminGetUser(userPoolId, username);user.setUserStatus("CONFIRMED");user.setLastModifiedDate(System.currentTimeMillis() / 1000L);@@ -2510,6 +2659,13 @@ public class CognitoService implements ResourceProvider {String username = token.username();String poolId = token.poolId();+ synchronized (userLock(poolId, username)) {+ changePasswordUnderUserLock(poolId, username, previousPassword, proposedPassword);+ }+ }++ private void changePasswordUnderUserLock(String poolId, String username, String previousPassword,+ String proposedPassword) {CognitoUser user = adminGetUser(poolId, username);if (user.getPasswordHash() != null && !user.getPasswordHash().equals(hashPassword(previousPassword))) {throw new AwsException("NotAuthorizedException", "Incorrect username or password", 400);@@ -2590,6 +2746,13 @@ public class CognitoService implements ResourceProvider {String username = token.username();String poolId = token.poolId();+ synchronized (userLock(poolId, username)) {+ return getUserAttributeVerificationCodeUnderUserLock(poolId, username, attributeName);+ }+ }++ private Map<String, Object> getUserAttributeVerificationCodeUnderUserLock(+ String poolId, String username, String attributeName) {if (!"email".equals(attributeName) && !"phone_number".equals(attributeName)) {throw new AwsException("InvalidParameterException","Invalid attribute name. Only phone_number and email can be verified.", 400);@@ -2642,6 +2805,13 @@ public class CognitoService implements ResourceProvider {String username = token.username();String poolId = token.poolId();+ synchronized (userLock(poolId, username)) {+ verifyUserAttributeUnderUserLock(poolId, username, attributeName, code);+ }+ }++ private void verifyUserAttributeUnderUserLock(+ String poolId, String username, String attributeName, String code) {if (!"email".equals(attributeName) && !"phone_number".equals(attributeName)) {throw new AwsException("InvalidParameterException","Invalid attribute name. Only phone_number and email can be verified.", 400);@@ -2691,6 +2861,13 @@ public class CognitoService implements ResourceProvider {400);}+ synchronized (userLock(poolId, username)) {+ return updateUserAttributesUnderUserLock(poolId, username, attributes);+ }+ }++ private List<Map<String, Object>> updateUserAttributesUnderUserLock(+ String poolId, String username, Map<String, String> attributes) {UserPool pool = describeUserPool(poolId);CognitoUser currentUser = adminGetUser(poolId, username);@@ -4324,6 +4501,19 @@ public class CognitoService implements ResourceProvider {Boolean emailEnabled,Boolean emailPreferred) {+ CognitoUser resolvedUser = adminGetUser(userPoolId, username);+ synchronized (userLock(userPoolId, resolvedUser.getUsername())) {+ adminSetUserMFAPreferenceUnderUserLock(+ userPoolId, resolvedUser.getUsername(), emailEnabled, emailPreferred);+ }+ }++ private void adminSetUserMFAPreferenceUnderUserLock(+ String userPoolId,+ String username,+ Boolean emailEnabled,+ Boolean emailPreferred) {+CognitoUser user = adminGetUser(userPoolId, username);updateEmailMfaPreference(user, emailEnabled, emailPreferred);@@ -4339,13 +4529,25 @@ public class CognitoService implements ResourceProvider {Boolean emailPreferred) {VerifiedAccessToken token = verifyAccessToken(accessToken);- CognitoUser user = adminGetUser(token.poolId(), token.username());+ synchronized (userLock(token.poolId(), token.username())) {+ setUserMFAPreferenceUnderUserLock(+ token.poolId(), token.username(), emailEnabled, emailPreferred);+ }+ }++ private void setUserMFAPreferenceUnderUserLock(+ String poolId,+ String username,+ Boolean emailEnabled,+ Boolean emailPreferred) {++ CognitoUser user = adminGetUser(poolId, username);updateEmailMfaPreference(user, emailEnabled, emailPreferred);user.setLastModifiedDate(System.currentTimeMillis() / 1000L);- userStore.put(userKey(token.poolId(), user.getUsername()), user);+ userStore.put(userKey(poolId, user.getUsername()), user);}private void updateEmailMfaPreference(diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoAttributeVerificationConcurrencyTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoAttributeVerificationConcurrencyTest.javanew file mode 100644index 0000000000..09fd7196cc--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoAttributeVerificationConcurrencyTest.java@@ -0,0 +1,486 @@+package io.github.hectorvent.floci.services.cognito;++import io.github.hectorvent.floci.config.TlsCertificateManager;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.acm.AcmService;+import io.github.hectorvent.floci.services.cognito.model.CognitoUser;+import io.github.hectorvent.floci.services.cognito.model.UserPool;+import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;+import io.github.hectorvent.floci.services.cognito.verification.CognitoMessageDispatcher;+import io.github.hectorvent.floci.services.cognito.verification.VerificationCode;+import io.github.hectorvent.floci.services.cognito.verification.VerificationCodeException;+import io.github.hectorvent.floci.services.cognito.verification.VerificationCodeService;+import org.junit.jupiter.api.Test;++import java.time.Duration;+import java.util.List;+import java.util.Map;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.TimeoutException;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.concurrent.atomic.AtomicReference;++import static org.junit.jupiter.api.Assertions.assertEquals;+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.Mockito.doAnswer;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++class CognitoAttributeVerificationConcurrencyTest {++ private static final String OLD_EMAIL = "[email protected]";+ private static final String FIRST_EMAIL = "[email protected]";+ private static final String SECOND_EMAIL = "[email protected]";+ private static final String ADMIN_EMAIL = "[email protected]";+ private static final String FIRST_CODE = "111111";+ private static final String SECOND_CODE = "222222";++ @Test+ void concurrentUpdatesAreSerializedPerUser() throws Exception {+ VerificationCodeService codes = mock(VerificationCodeService.class);+ CognitoMessageDispatcher dispatcher = mock(CognitoMessageDispatcher.class);+ Harness harness = harness(codes, dispatcher);+ AtomicInteger issues = new AtomicInteger();+ AtomicReference<String> latestCode = new AtomicReference<>();+ Map<String, String> destinationByCode = new java.util.concurrent.ConcurrentHashMap<>();+ CountDownLatch firstIssueEntered = new CountDownLatch(1);+ CountDownLatch releaseFirstIssue = new CountDownLatch(1);+ CountDownLatch secondStarted = new CountDownLatch(1);++ when(codes.issue(anyString(), anyString(), any(), any(Duration.class)))+ .thenAnswer(invocation -> {+ int issue = issues.incrementAndGet();+ if (issue == 1) {+ firstIssueEntered.countDown();+ await(releaseFirstIssue);+ }+ String code = issue == 1 ? FIRST_CODE : SECOND_CODE;+ latestCode.set(code);+ return code;+ });+ doAnswer(invocation -> {+ CognitoUser deliveryUser = invocation.getArgument(1);+ String code = invocation.getArgument(3);+ destinationByCode.put(code, deliveryUser.getAttributes().get("email"));+ return null;+ }).when(dispatcher).dispatch(any(), any(), any(), anyString(), any());+ acceptOnlyLatestCode(codes, latestCode);++ ExecutorService executor = Executors.newFixedThreadPool(2);+ try {+ Future<?> first = executor.submit(() -> harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", FIRST_EMAIL)));+ assertTrue(firstIssueEntered.await(5, TimeUnit.SECONDS));++ Future<?> second = executor.submit(() -> {+ secondStarted.countDown();+ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", SECOND_EMAIL));+ });+ assertTrue(secondStarted.await(5, TimeUnit.SECONDS));+ assertThrows(TimeoutException.class, () -> second.get(100, TimeUnit.MILLISECONDS));+ releaseFirstIssue.countDown();+ first.get(5, TimeUnit.SECONDS);+ second.get(5, TimeUnit.SECONDS);++ String validCode = latestCode.get();+ harness.service().verifyUserAttribute(harness.accessToken(), "email", validCode);++ assertEquals(SECOND_CODE, validCode);+ assertEquals(SECOND_EMAIL, harness.user().getAttributes().get("email"));+ assertEquals(destinationByCode.get(validCode), harness.user().getAttributes().get("email"),+ "the valid code must only promote the destination it was sent to");+ } finally {+ releaseFirstIssue.countDown();+ executor.shutdownNow();+ }+ }++ @Test+ void resendAndUpdateAreSerializedPerUser() throws Exception {+ VerificationCodeService codes = mock(VerificationCodeService.class);+ CognitoMessageDispatcher dispatcher = mock(CognitoMessageDispatcher.class);+ Harness harness = harness(codes, dispatcher);+ AtomicInteger issues = new AtomicInteger();+ AtomicReference<String> latestCode = new AtomicReference<>();+ CountDownLatch resendIssueEntered = new CountDownLatch(1);+ CountDownLatch releaseResendIssue = new CountDownLatch(1);+ CountDownLatch updateStarted = new CountDownLatch(1);++ when(codes.issue(anyString(), anyString(), any(), any(Duration.class)))+ .thenAnswer(invocation -> {+ int issue = issues.incrementAndGet();+ if (issue == 2) {+ resendIssueEntered.countDown();+ await(releaseResendIssue);+ }+ String code = issue == 1 ? FIRST_CODE : issue == 2 ? SECOND_CODE : "333333";+ latestCode.set(code);+ return code;+ });+ acceptOnlyLatestCode(codes, latestCode);++ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", FIRST_EMAIL));++ ExecutorService executor = Executors.newFixedThreadPool(2);+ try {+ Future<Map<String, Object>> resend = executor.submit(() -> harness.service()+ .getUserAttributeVerificationCode(harness.accessToken(), "email"));+ assertTrue(resendIssueEntered.await(5, TimeUnit.SECONDS));++ Future<?> update = executor.submit(() -> {+ updateStarted.countDown();+ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", SECOND_EMAIL));+ });+ assertTrue(updateStarted.await(5, TimeUnit.SECONDS));+ assertThrows(TimeoutException.class, () -> update.get(100, TimeUnit.MILLISECONDS));+ releaseResendIssue.countDown();+ Map<String, Object> resendResult = resend.get(5, TimeUnit.SECONDS);+ update.get(5, TimeUnit.SECONDS);++ harness.service().verifyUserAttribute(+ harness.accessToken(), "email", latestCode.get());++ assertEquals("a***@e***", resendResult.get("Destination"),+ "the resend must complete against its serialized pending email");+ assertEquals(SECOND_EMAIL, harness.user().getAttributes().get("email"));+ } finally {+ releaseResendIssue.countDown();+ executor.shutdownNow();+ }+ }++ @Test+ void verifyAndUpdateAreSerializedPerUser() throws Exception {+ VerificationCodeService codes = mock(VerificationCodeService.class);+ CognitoMessageDispatcher dispatcher = mock(CognitoMessageDispatcher.class);+ Harness harness = harness(codes, dispatcher);+ AtomicInteger issues = new AtomicInteger();+ CountDownLatch consumeEntered = new CountDownLatch(1);+ CountDownLatch releaseConsume = new CountDownLatch(1);+ CountDownLatch updateStarted = new CountDownLatch(1);++ when(codes.issue(anyString(), anyString(), any(), any(Duration.class)))+ .thenAnswer(invocation -> issues.incrementAndGet() == 1 ? FIRST_CODE : SECOND_CODE);+ doAnswer(invocation -> {+ assertEquals(FIRST_CODE, invocation.getArgument(3));+ consumeEntered.countDown();+ await(releaseConsume);+ return null;+ }).when(codes).consume(anyString(), anyString(), any(), anyString());++ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", FIRST_EMAIL));++ ExecutorService executor = Executors.newFixedThreadPool(2);+ try {+ Future<?> verify = executor.submit(() -> harness.service().verifyUserAttribute(+ harness.accessToken(), "email", FIRST_CODE));+ assertTrue(consumeEntered.await(5, TimeUnit.SECONDS));++ Future<?> update = executor.submit(() -> {+ updateStarted.countDown();+ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", SECOND_EMAIL));+ });+ assertTrue(updateStarted.await(5, TimeUnit.SECONDS));+ assertThrows(TimeoutException.class, () -> update.get(100, TimeUnit.MILLISECONDS));+ releaseConsume.countDown();+ verify.get(5, TimeUnit.SECONDS);+ update.get(5, TimeUnit.SECONDS);++ assertEquals(FIRST_EMAIL, harness.user().getAttributes().get("email"));+ assertEquals(SECOND_EMAIL, harness.user().getPendingAttributes().get("email"),+ "a successful concurrent update must not be lost when verification completes");+ } finally {+ releaseConsume.countDown();+ executor.shutdownNow();+ }+ }++ @Test+ void verificationFinishingAfterAdminUpdateDoesNotOverwriteAdminEmail() throws Exception {+ VerificationCodeService codes = mock(VerificationCodeService.class);+ CognitoMessageDispatcher dispatcher = mock(CognitoMessageDispatcher.class);+ Harness harness = harness(codes, dispatcher);+ CountDownLatch consumeEntered = new CountDownLatch(1);+ CountDownLatch releaseConsume = new CountDownLatch(1);+ CountDownLatch adminStarted = new CountDownLatch(1);++ when(codes.issue(anyString(), anyString(), any(), any(Duration.class)))+ .thenReturn(FIRST_CODE);+ doAnswer(invocation -> {+ assertEquals(FIRST_CODE, invocation.getArgument(3));+ consumeEntered.countDown();+ await(releaseConsume);+ return null;+ }).when(codes).consume(anyString(), anyString(), any(), anyString());+ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", FIRST_EMAIL));++ ExecutorService executor = Executors.newFixedThreadPool(2);+ try {+ Future<?> verify = executor.submit(() -> harness.service().verifyUserAttribute(+ harness.accessToken(), "email", FIRST_CODE));+ assertTrue(consumeEntered.await(5, TimeUnit.SECONDS));++ Future<?> adminUpdate = executor.submit(() -> {+ adminStarted.countDown();+ harness.service().adminUpdateUserAttributes(+ harness.poolId(), "alice", Map.of("email", ADMIN_EMAIL));+ });+ assertTrue(adminStarted.await(5, TimeUnit.SECONDS));+ assertThrows(TimeoutException.class,+ () -> adminUpdate.get(100, TimeUnit.MILLISECONDS));++ releaseConsume.countDown();+ verify.get(5, TimeUnit.SECONDS);+ adminUpdate.get(5, TimeUnit.SECONDS);++ assertEquals(ADMIN_EMAIL, harness.user().getAttributes().get("email"),+ "verification finishing later must not overwrite a completed admin update");+ assertNull(harness.user().getPendingAttributes().get("email"));+ } finally {+ releaseConsume.countDown();+ executor.shutdownNow();+ }+ }++ @Test+ void verificationFinishingAfterAdminDeleteDoesNotRestoreDeletedEmail() throws Exception {+ VerificationCodeService codes = mock(VerificationCodeService.class);+ CognitoMessageDispatcher dispatcher = mock(CognitoMessageDispatcher.class);+ Harness harness = harness(codes, dispatcher);+ CountDownLatch consumeEntered = new CountDownLatch(1);+ CountDownLatch releaseConsume = new CountDownLatch(1);+ CountDownLatch adminStarted = new CountDownLatch(1);++ when(codes.issue(anyString(), anyString(), any(), any(Duration.class)))+ .thenReturn(FIRST_CODE);+ doAnswer(invocation -> {+ assertEquals(FIRST_CODE, invocation.getArgument(3));+ consumeEntered.countDown();+ await(releaseConsume);+ return null;+ }).when(codes).consume(anyString(), anyString(), any(), anyString());+ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", FIRST_EMAIL));++ ExecutorService executor = Executors.newFixedThreadPool(2);+ try {+ Future<?> verify = executor.submit(() -> harness.service().verifyUserAttribute(+ harness.accessToken(), "email", FIRST_CODE));+ assertTrue(consumeEntered.await(5, TimeUnit.SECONDS));++ Future<?> adminDelete = executor.submit(() -> {+ adminStarted.countDown();+ harness.service().adminDeleteUserAttributes(+ harness.poolId(), "alice", List.of("email"));+ });+ assertTrue(adminStarted.await(5, TimeUnit.SECONDS));+ assertThrows(TimeoutException.class,+ () -> adminDelete.get(100, TimeUnit.MILLISECONDS));++ releaseConsume.countDown();+ verify.get(5, TimeUnit.SECONDS);+ adminDelete.get(5, TimeUnit.SECONDS);++ assertNull(harness.user().getAttributes().get("email"),+ "verification finishing later must not restore a completed admin deletion");+ assertNull(harness.user().getPendingAttributes().get("email"));+ } finally {+ releaseConsume.countDown();+ executor.shutdownNow();+ }+ }++ @Test+ void verificationFinishingAfterAdminUserDeleteDoesNotResurrectTheUser() throws Exception {+ VerificationCodeService codes = mock(VerificationCodeService.class);+ CognitoMessageDispatcher dispatcher = mock(CognitoMessageDispatcher.class);+ Harness harness = harness(codes, dispatcher);+ CountDownLatch consumeEntered = new CountDownLatch(1);+ CountDownLatch releaseConsume = new CountDownLatch(1);+ CountDownLatch adminStarted = new CountDownLatch(1);++ when(codes.issue(anyString(), anyString(), any(), any(Duration.class)))+ .thenReturn(FIRST_CODE);+ doAnswer(invocation -> {+ assertEquals(FIRST_CODE, invocation.getArgument(3));+ consumeEntered.countDown();+ await(releaseConsume);+ return null;+ }).when(codes).consume(anyString(), anyString(), any(), anyString());+ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", FIRST_EMAIL));++ ExecutorService executor = Executors.newFixedThreadPool(2);+ try {+ Future<?> verify = executor.submit(() -> harness.service().verifyUserAttribute(+ harness.accessToken(), "email", FIRST_CODE));+ assertTrue(consumeEntered.await(5, TimeUnit.SECONDS));++ Future<?> adminDelete = executor.submit(() -> {+ adminStarted.countDown();+ harness.service().adminDeleteUser(harness.poolId(), "alice");+ });+ assertTrue(adminStarted.await(5, TimeUnit.SECONDS));+ assertThrows(TimeoutException.class,+ () -> adminDelete.get(100, TimeUnit.MILLISECONDS));++ releaseConsume.countDown();+ verify.get(5, TimeUnit.SECONDS);+ adminDelete.get(5, TimeUnit.SECONDS);++ AwsException notFound = assertThrows(AwsException.class,+ () -> harness.service().adminGetUser(harness.poolId(), "alice"),+ "verification finishing later must not resurrect a completed admin deletion");+ assertEquals("UserNotFoundException", notFound.getErrorCode());+ } finally {+ releaseConsume.countDown();+ executor.shutdownNow();+ }+ }++ @Test+ void changePasswordFinishingDuringVerificationDoesNotLoseEitherChange() throws Exception {+ // Demonstrates the per-user lock also serializes an operation outside the original+ // five: ChangePassword never touched pending-attribute state before this fix, so+ // nothing stopped it from racing VerifyUserAttribute's read-modify-write on the same+ // whole-object user record.+ VerificationCodeService codes = mock(VerificationCodeService.class);+ CognitoMessageDispatcher dispatcher = mock(CognitoMessageDispatcher.class);+ Harness harness = harness(codes, dispatcher);+ CountDownLatch consumeEntered = new CountDownLatch(1);+ CountDownLatch releaseConsume = new CountDownLatch(1);+ CountDownLatch changeStarted = new CountDownLatch(1);++ when(codes.issue(anyString(), anyString(), any(), any(Duration.class)))+ .thenReturn(FIRST_CODE);+ doAnswer(invocation -> {+ assertEquals(FIRST_CODE, invocation.getArgument(3));+ consumeEntered.countDown();+ await(releaseConsume);+ return null;+ }).when(codes).consume(anyString(), anyString(), any(), anyString());+ harness.service().updateUserAttributes(+ harness.accessToken(), Map.of("email", FIRST_EMAIL));++ ExecutorService executor = Executors.newFixedThreadPool(2);+ try {+ Future<?> verify = executor.submit(() -> harness.service().verifyUserAttribute(+ harness.accessToken(), "email", FIRST_CODE));+ assertTrue(consumeEntered.await(5, TimeUnit.SECONDS));++ Future<?> changePassword = executor.submit(() -> {+ changeStarted.countDown();+ harness.service().changePassword(harness.accessToken(), "Permanent1!", "Permanent2!");+ });+ assertTrue(changeStarted.await(5, TimeUnit.SECONDS));+ assertThrows(TimeoutException.class,+ () -> changePassword.get(100, TimeUnit.MILLISECONDS));++ releaseConsume.countDown();+ verify.get(5, TimeUnit.SECONDS);+ changePassword.get(5, TimeUnit.SECONDS);++ assertEquals(FIRST_EMAIL, harness.user().getAttributes().get("email"),+ "the password change finishing after verification must not lose the promoted email");+ assertEquals("true", harness.user().getAttributes().get("email_verified"));++ assertThrows(AwsException.class, () -> harness.service().initiateAuth(+ harness.clientId(), "USER_PASSWORD_AUTH",+ Map.of("USERNAME", "alice", "PASSWORD", "Permanent1!")),+ "verification finishing must not lose the password change back to the old password");+ @SuppressWarnings("unchecked")+ Map<String, Object> reAuth = (Map<String, Object>) harness.service().initiateAuth(+ harness.clientId(), "USER_PASSWORD_AUTH",+ Map.of("USERNAME", "alice", "PASSWORD", "Permanent2!"))+ .get("AuthenticationResult");+ assertTrue(reAuth.get("AccessToken") instanceof String);+ } finally {+ releaseConsume.countDown();+ executor.shutdownNow();+ }+ }++ private static Harness harness(VerificationCodeService codes,+ CognitoMessageDispatcher dispatcher) {+ CognitoService service = new CognitoService(+ new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ "http://localhost:4566",+ new RegionResolver("us-east-1", "000000000000"),+ null,+ mock(AcmService.class),+ codes,+ dispatcher,+ mock(TlsCertificateManager.class));+ UserPool pool = service.createUserPool(Map.of(+ "PoolName", "ConcurrencyPool",+ "AutoVerifiedAttributes", List.of("email"),+ "UserAttributeUpdateSettings", Map.of(+ "AttributesRequireVerificationBeforeUpdate", List.of("email"))),+ "us-east-1");+ UserPoolClient client = service.createUserPoolClient(+ pool.getId(), "concurrency-client", false, false, List.of(), List.of());+ service.adminCreateUser(pool.getId(), "alice", Map.of(+ "email", OLD_EMAIL,+ "email_verified", "true"), "TempPass1!");+ service.adminSetUserPassword(pool.getId(), "alice", "Permanent1!", true);++ @SuppressWarnings("unchecked")+ Map<String, Object> authentication = (Map<String, Object>) service.initiateAuth(+ client.getClientId(), "USER_PASSWORD_AUTH",+ Map.of("USERNAME", "alice", "PASSWORD", "Permanent1!"))+ .get("AuthenticationResult");+ return new Harness(service, pool.getId(), client.getClientId(),+ (String) authentication.get("AccessToken"));+ }++ private static void acceptOnlyLatestCode(VerificationCodeService codes,+ AtomicReference<String> latestCode) {+ doAnswer(invocation -> {+ String supplied = invocation.getArgument(3);+ if (!supplied.equals(latestCode.get())) {+ throw new VerificationCodeException(+ VerificationCodeException.Kind.MISMATCH,+ "Invalid verification code provided, please try again");+ }+ return null;+ }).when(codes).consume(anyString(), anyString(), any(), anyString());+ }++ private static void await(CountDownLatch latch) {+ try {+ assertTrue(latch.await(5, TimeUnit.SECONDS));+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new AssertionError("Interrupted while coordinating concurrency test", e);+ }+ }++ private record Harness(CognitoService service, String poolId, String clientId, String accessToken) {+ CognitoUser user() {+ return service.adminGetUser(poolId, "alice");+ }+ }+}