You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by bt...@apache.org on 2025/11/25 06:22:02 UTC

(james-project) 21/34: JAMES-3728 Implement MessageIdManager::updateEmail

This is an automated email from the ASF dual-hosted git repository.

btellier pushed a commit to branch 3.9.x
in repository https://gitbox.apache.org/repos/asf/james-project.git

commit 395171def2a01c89ea8d0cd406b79594a772c4dc
Author: Benoit TELLIER <bt...@linagora.com>
AuthorDate: Mon Nov 10 11:31:24 2025 +0100

    JAMES-3728 Implement MessageIdManager::updateEmail
    
    This method bundles together move and flag update firing a single event for both operations.
    This prevents a data race from arising in listeners when the two operations are sequentially done,
    causing flags updates to be dropped.
---
 .../org/apache/james/mailbox/MessageIdManager.java |   2 +
 .../james/mailbox/store/StoreMessageIdManager.java | 122 ++++++++++++---------
 2 files changed, 71 insertions(+), 53 deletions(-)

diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/MessageIdManager.java b/mailbox/api/src/main/java/org/apache/james/mailbox/MessageIdManager.java
index 4605a0fcbd..d682448910 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/MessageIdManager.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/MessageIdManager.java
@@ -76,6 +76,8 @@ public interface MessageIdManager {
 
     Publisher<Void> setInMailboxesReactive(MessageId messageId, Collection<MailboxId> mailboxIds, MailboxSession mailboxSession);
 
+    Publisher<Void> updateEmail(MessageId messageId, List<MailboxId> mailboxIds, Flags newState, FlagsUpdateMode replace, MailboxSession mailboxSession);
+
     default List<MessageResult> getMessage(MessageId messageId, FetchGroup fetchGroup, MailboxSession mailboxSession) throws MailboxException {
         return getMessages(ImmutableList.of(messageId), fetchGroup, mailboxSession);
     }
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageIdManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageIdManager.java
index 6a7187e15c..3c5d4ef76e 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageIdManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageIdManager.java
@@ -38,6 +38,7 @@ import jakarta.mail.Flags;
 
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.james.events.EventBus;
+import org.apache.james.events.EventBus.EventWithRegistrationKey;
 import org.apache.james.mailbox.MailboxSession;
 import org.apache.james.mailbox.MessageIdManager;
 import org.apache.james.mailbox.MessageManager;
@@ -94,6 +95,8 @@ import reactor.core.scheduler.Schedulers;
 
 public class StoreMessageIdManager implements MessageIdManager {
 
+    public static final int SET_FLAGS_CONCURRENCY = 4;
+
     public static ImmutableSet<MailboxId> toMailboxIds(List<MailboxMessage> mailboxMessages) {
         return mailboxMessages
             .stream()
@@ -129,21 +132,22 @@ public class StoreMessageIdManager implements MessageIdManager {
 
     @Override
     public Mono<Void> setFlagsReactive(Flags newState, MessageManager.FlagsUpdateMode replace, MessageId messageId, List<MailboxId> mailboxIds, MailboxSession mailboxSession) {
-        MessageIdMapper messageIdMapper = mailboxSessionMapperFactory.getMessageIdMapper(mailboxSession);
-        MailboxMapper mailboxMapper = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession);
-
-        int concurrency = 4;
+        return setFlagsReactiveWithoutEventPublishing(newState, replace, messageId, mailboxIds, mailboxSession)
+            .collectList()
+            .flatMap(eventBus::dispatch);
+    }
 
+    private Flux<EventWithRegistrationKey> setFlagsReactiveWithoutEventPublishing(Flags newState, MessageManager.FlagsUpdateMode replace, MessageId messageId, List<MailboxId> mailboxIds, MailboxSession mailboxSession) {
         return Flux.fromIterable(mailboxIds)
-            .flatMap(mailboxMapper::findMailboxById, concurrency)
+            .flatMap(mailboxSessionMapperFactory.getMailboxMapper(mailboxSession)::findMailboxById, SET_FLAGS_CONCURRENCY)
             .collect(ImmutableList.toImmutableList())
-            .flatMap(Throwing.<List<Mailbox>, Mono<Void>>function(targetMailboxes -> {
+            .flatMapMany(Throwing.<List<Mailbox>, Flux<EventWithRegistrationKey>>function(targetMailboxes -> {
                 assertRightsOnMailboxes(targetMailboxes, mailboxSession, Right.Write);
 
-                return messageIdMapper.setFlags(messageId, mailboxIds, newState, replace)
+                return mailboxSessionMapperFactory.getMessageIdMapper(mailboxSession)
+                    .setFlags(messageId, mailboxIds, newState, replace)
                     .flatMapIterable(updatedFlags -> updatedFlags.asMap().entrySet())
-                    .concatMap(entry -> dispatchFlagsChange(mailboxSession, entry.getKey(), ImmutableList.copyOf(entry.getValue()), targetMailboxes))
-                    .then();
+                    .concatMap(entry -> flagsChangedEvent(mailboxSession, entry.getKey(), ImmutableList.copyOf(entry.getValue()), targetMailboxes));
             }).sneakyThrow());
     }
 
@@ -321,44 +325,60 @@ public class StoreMessageIdManager implements MessageIdManager {
 
     @Override
     public Mono<Void> setInMailboxesReactive(MessageId messageId, Collection<MailboxId> targetMailboxIds, MailboxSession mailboxSession) {
+        return setInMailboxesWithoutEventPublishing(messageId, targetMailboxIds, mailboxSession)
+            .collectList()
+            .flatMap(eventBus::dispatch);
+    }
+
+    private Flux<EventWithRegistrationKey> setInMailboxesWithoutEventPublishing(MessageId messageId, Collection<MailboxId> targetMailboxIds, MailboxSession mailboxSession) {
         return findRelatedMailboxMessages(messageId, mailboxSession)
-            .flatMap(currentMailboxMessages -> messageMovesWithMailbox(MessageMoves.builder()
+            .flatMapMany(currentMailboxMessages -> messageMovesWithMailbox(MessageMoves.builder()
                 .targetMailboxIds(targetMailboxIds)
                 .previousMailboxIds(toMailboxIds(currentMailboxMessages))
                 .build(), mailboxSession)
-                .flatMap(Throwing.<MessageMovesWithMailbox, Mono<Void>>function(messageMove -> {
+                .flatMapMany(Throwing.<MessageMovesWithMailbox, Flux<EventWithRegistrationKey>>function(messageMove -> {
                     MessageMovesWithMailbox refined = messageMove.filterPrevious(hasRightsOnMailbox(mailboxSession, Right.Read));
 
                     if (messageMove.getPreviousMailboxes().isEmpty()) {
                         LOGGER.info("Tried to access {} not accessible for {}", messageId, mailboxSession.getUser().asString());
-                        return Mono.empty();
+                        return Flux.empty();
                     }
                     if (refined.getPreviousMailboxes().isEmpty()) {
                         MailboxPath unreadablePreviousMailbox = messageMove.getPreviousMailboxes().iterator().next().generateAssociatedPath();
-                        return Mono.error(() -> new MailboxNotFoundException(unreadablePreviousMailbox));
+                        return Flux.error(() -> new MailboxNotFoundException(unreadablePreviousMailbox));
                     }
                     if (refined.isChange()) {
                         return applyMessageMoves(mailboxSession, currentMailboxMessages, refined);
                     }
-                    return Mono.empty();
+                    return Flux.empty();
                 }).sneakyThrow()));
     }
 
+    @Override
+    public Publisher<Void> updateEmail(MessageId messageId, List<MailboxId> targetMailboxIds, Flags newState, MessageManager.FlagsUpdateMode replace, MailboxSession mailboxSession) {
+        return Flux.concat(
+                setInMailboxesWithoutEventPublishing(messageId, targetMailboxIds, mailboxSession),
+                setFlagsReactiveWithoutEventPublishing(newState, replace, messageId, targetMailboxIds, mailboxSession))
+            .collectList()
+            .flatMap(eventBus::dispatch);
+    }
+
     public void setInMailboxesNoCheck(MessageId messageId, MailboxId targetMailboxId, MailboxSession mailboxSession) throws MailboxException {
         MessageIdMapper messageIdMapper = mailboxSessionMapperFactory.getMessageIdMapper(mailboxSession);
         List<MailboxMessage> currentMailboxMessages = messageIdMapper.find(ImmutableList.of(messageId), MessageMapper.FetchType.METADATA);
 
-
         MailboxReactorUtils.block(messageMovesWithMailbox(MessageMoves.builder()
             .targetMailboxIds(targetMailboxId)
             .previousMailboxIds(toMailboxIds(currentMailboxMessages))
             .build(), mailboxSession)
-            .flatMap(messageMove -> {
+            .flatMapMany(messageMove -> {
                 if (messageMove.isChange()) {
                     return applyMessageMoveNoMailboxChecks(mailboxSession, currentMailboxMessages, messageMove);
                 }
-                return Mono.empty();
-            }));
+                return Flux.empty();
+            })
+            .collectList()
+            .flatMap(eventBus::dispatch));
     }
 
     private Mono<List<MailboxMessage>> findRelatedMailboxMessages(MessageId messageId, MailboxSession mailboxSession) {
@@ -368,7 +388,7 @@ public class StoreMessageIdManager implements MessageIdManager {
             .collect(ImmutableList.toImmutableList());
     }
 
-    private Mono<Void> applyMessageMoves(MailboxSession mailboxSession, List<MailboxMessage> currentMailboxMessages, MessageMovesWithMailbox messageMoves) throws MailboxNotFoundException {
+    private Flux<EventWithRegistrationKey> applyMessageMoves(MailboxSession mailboxSession, List<MailboxMessage> currentMailboxMessages, MessageMovesWithMailbox messageMoves) throws MailboxNotFoundException {
         assertRightsOnMailboxes(messageMoves.addedMailboxes(), mailboxSession, Right.Insert);
         assertRightsOnMailboxes(messageMoves.removedMailboxes(), mailboxSession, Right.DeleteMessages);
         assertRightsOnMailboxes(messageMoves.getTargetMailboxes(), mailboxSession, Right.Read);
@@ -376,11 +396,11 @@ public class StoreMessageIdManager implements MessageIdManager {
         return applyMessageMoveNoMailboxChecks(mailboxSession, currentMailboxMessages, messageMoves);
     }
 
-    private Mono<Void> applyMessageMoveNoMailboxChecks(MailboxSession mailboxSession, List<MailboxMessage> currentMailboxMessages, MessageMovesWithMailbox messageMoves) {
+    private Flux<EventWithRegistrationKey> applyMessageMoveNoMailboxChecks(MailboxSession mailboxSession, List<MailboxMessage> currentMailboxMessages, MessageMovesWithMailbox messageMoves) {
         Optional<MailboxMessage> mailboxMessage = currentMailboxMessages.stream().findAny();
 
         if (mailboxMessage.isEmpty()) {
-            return Mono.error(new MailboxNotFoundException("can't load message"));
+            return Flux.error(new MailboxNotFoundException("can't load message"));
         }
         List<Pair<MailboxMessage, Mailbox>> messagesToRemove = currentMailboxMessages.stream()
             .flatMap(message -> messageMoves.removedMailboxes()
@@ -390,23 +410,21 @@ public class StoreMessageIdManager implements MessageIdManager {
             .collect(ImmutableList.toImmutableList());
 
         return validateQuota(messageMoves, mailboxMessage.get())
-            .then(Flux.concat(
-                    addMessageToMailboxes(mailboxMessage.get(), messageMoves, mailboxSession),
-                    expungeMessageFromMailboxes(mailboxMessage.get().getMessageId(), messagesToRemove, mailboxSession, messageMoves),
-                    Flux.just(new EventBus.EventWithRegistrationKey(EventFactory.moved()
-                            .session(mailboxSession)
-                            .messageMoves(messageMoves.asMessageMoves())
-                            .messageId(mailboxMessage.get().getMessageId())
-                            .build(),
-                        messageMoves.impactedMailboxes()
-                            .map(Mailbox::getMailboxId)
-                            .map(MailboxIdRegistrationKey::new)
-                            .collect(ImmutableSet.toImmutableSet()))))
-                .collectList()
-                .flatMap(eventBus::dispatch));
-    }
-
-    private Flux<EventBus.EventWithRegistrationKey> expungeMessageFromMailboxes(MessageId messageId, List<Pair<MailboxMessage, Mailbox>> messages, MailboxSession mailboxSession, MessageMovesWithMailbox messageMoves) {
+            .thenMany(Flux.concat(
+                addMessageToMailboxes(mailboxMessage.get(), messageMoves, mailboxSession),
+                expungeMessageFromMailboxes(mailboxMessage.get().getMessageId(), messagesToRemove, mailboxSession, messageMoves),
+                Flux.just(new EventWithRegistrationKey(EventFactory.moved()
+                    .session(mailboxSession)
+                    .messageMoves(messageMoves.asMessageMoves())
+                    .messageId(mailboxMessage.get().getMessageId())
+                    .build(),
+                    messageMoves.impactedMailboxes()
+                        .map(Mailbox::getMailboxId)
+                        .map(MailboxIdRegistrationKey::new)
+                        .collect(ImmutableSet.toImmutableSet())))));
+    }
+
+    private Flux<EventWithRegistrationKey> expungeMessageFromMailboxes(MessageId messageId, List<Pair<MailboxMessage, Mailbox>> messages, MailboxSession mailboxSession, MessageMovesWithMailbox messageMoves) {
         if (messages.isEmpty()) {
             return Flux.empty();
         }
@@ -422,7 +440,7 @@ public class StoreMessageIdManager implements MessageIdManager {
                 .map(message -> expungedEvent(message, mailboxSession, messageMoves)));
     }
 
-    private EventBus.EventWithRegistrationKey expungedEvent(Pair<MailboxMessage, Mailbox> message, MailboxSession mailboxSession, MessageMovesWithMailbox messageMoves) {
+    private EventWithRegistrationKey expungedEvent(Pair<MailboxMessage, Mailbox> message, MailboxSession mailboxSession, MessageMovesWithMailbox messageMoves) {
         EventFactory.ExpungedFinalStage.Builder eventBuilder = EventFactory.expunged()
             .randomEventId()
             .mailboxSession(mailboxSession)
@@ -431,23 +449,21 @@ public class StoreMessageIdManager implements MessageIdManager {
         if (isSingleMove(messageMoves)) {
             eventBuilder.movedTo(messageMoves.addedMailboxes().iterator().next().getMailboxId());
         }
-        return new EventBus.EventWithRegistrationKey(eventBuilder.build(), ImmutableSet.of(new MailboxIdRegistrationKey(message.getRight().getMailboxId())));
+        return new EventWithRegistrationKey(eventBuilder.build(), ImmutableSet.of(new MailboxIdRegistrationKey(message.getRight().getMailboxId())));
     }
 
-    private Mono<Void> dispatchFlagsChange(MailboxSession mailboxSession, MailboxId mailboxId, ImmutableList<UpdatedFlags> updatedFlags, List<Mailbox> knownMailboxes) {
+    private Mono<EventWithRegistrationKey> flagsChangedEvent(MailboxSession mailboxSession, MailboxId mailboxId, ImmutableList<UpdatedFlags> updatedFlags, List<Mailbox> knownMailboxes) {
         return knownMailboxes.stream()
             .filter(knownMailbox -> knownMailbox.getMailboxId().equals(mailboxId))
             .findFirst()
             .map(Mono::just)
             .orElseGet(() -> mailboxSessionMapperFactory.getMailboxMapper(mailboxSession).findMailboxById(mailboxId))
-            .flatMap(mailbox ->
-                eventBus.dispatch(EventFactory.flagsUpdated()
-                        .randomEventId()
-                        .mailboxSession(mailboxSession)
-                        .mailbox(mailbox)
-                        .updatedFlags(updatedFlags)
-                        .build(),
-                    new MailboxIdRegistrationKey(mailboxId)));
+            .map(mailbox -> new EventWithRegistrationKey(EventFactory.flagsUpdated()
+                .randomEventId()
+                .mailboxSession(mailboxSession)
+                .mailbox(mailbox)
+                .updatedFlags(updatedFlags)
+                .build(), ImmutableSet.of(new MailboxIdRegistrationKey(mailboxId))));
     }
 
     private Mono<Void> validateQuota(MessageMovesWithMailbox messageMoves, MailboxMessage mailboxMessage) {
@@ -490,11 +506,11 @@ public class StoreMessageIdManager implements MessageIdManager {
         }
     }
 
-    private Flux<EventBus.EventWithRegistrationKey> addMessageToMailboxes(MailboxMessage mailboxMessage, MessageMovesWithMailbox messageMoves, MailboxSession mailboxSession) {
+    private Flux<EventWithRegistrationKey> addMessageToMailboxes(MailboxMessage mailboxMessage, MessageMovesWithMailbox messageMoves, MailboxSession mailboxSession) {
         MessageIdMapper messageIdMapper = mailboxSessionMapperFactory.getMessageIdMapper(mailboxSession);
 
         return Flux.fromIterable(messageMoves.addedMailboxes())
-            .flatMap(Throwing.<Mailbox, Mono<EventBus.EventWithRegistrationKey>>function(mailbox -> {
+            .flatMap(Throwing.<Mailbox, Mono<EventWithRegistrationKey>>function(mailbox -> {
                 MailboxACL.Rfc4314Rights myRights = rightManager.myRights(mailbox, mailboxSession);
                 boolean shouldPreserveFlags = myRights.contains(Right.Write);
                 MailboxMessage copy = mailboxMessage.copy(mailbox);
@@ -513,7 +529,7 @@ public class StoreMessageIdManager implements MessageIdManager {
             }).sneakyThrow());
     }
 
-    private EventBus.EventWithRegistrationKey addedEvent(MailboxSession mailboxSession, Mailbox mailbox, MessageMetaData messageMetaData, MessageMovesWithMailbox messageMoves) {
+    private EventWithRegistrationKey addedEvent(MailboxSession mailboxSession, Mailbox mailbox, MessageMetaData messageMetaData, MessageMovesWithMailbox messageMoves) {
         EventFactory.AddedFinalStage.Builder appended = EventFactory.added()
             .randomEventId()
             .mailboxSession(mailboxSession)
@@ -524,7 +540,7 @@ public class StoreMessageIdManager implements MessageIdManager {
         if (isSingleMove(messageMoves)) {
             appended.movedFrom(messageMoves.removedMailboxes().iterator().next().getMailboxId());
         }
-        return new EventBus.EventWithRegistrationKey(appended.build(), ImmutableSet.of(new MailboxIdRegistrationKey(mailbox.getMailboxId())));
+        return new EventWithRegistrationKey(appended.build(), ImmutableSet.of(new MailboxIdRegistrationKey(mailbox.getMailboxId())));
     }
 
     private boolean isSingleMove(MessageMovesWithMailbox messageMoves) {


---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org