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 2022/05/24 01:54:08 UTC

[james-project] branch master updated: JAMES-3737 Reactive IMAP for COPY + MOVE (#1010)

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

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


The following commit(s) were added to refs/heads/master by this push:
     new 4da60a059a JAMES-3737 Reactive IMAP for COPY + MOVE (#1010)
4da60a059a is described below

commit 4da60a059acc923b16dceca86d7c81183058d75e
Author: Benoit TELLIER <bt...@linagora.com>
AuthorDate: Tue May 24 08:54:03 2022 +0700

    JAMES-3737 Reactive IMAP for COPY + MOVE (#1010)
---
 .../org/apache/james/mailbox/MailboxManager.java   |  21 ++
 .../cassandra/mail/CassandraMessageMapper.java     |  66 +++---
 .../apache/james/mailbox/store/MessageBatcher.java |  17 +-
 .../org/apache/james/mailbox/store/MoveResult.java |  12 +-
 .../james/mailbox/store/StoreMailboxManager.java   |  60 ++++--
 .../james/mailbox/store/StoreMessageManager.java   | 230 ++++++++++-----------
 .../james/mailbox/store/mail/MessageMapper.java    |  19 ++
 .../processor/AbstractMessageRangeProcessor.java   | 105 +++++-----
 .../apache/james/imap/processor/CopyProcessor.java |  13 +-
 .../apache/james/imap/processor/MoveProcessor.java |  11 +-
 .../james/imap/processor/CopyProcessorTest.java    |  51 ++---
 .../james/imap/processor/MoveProcessorTest.java    |  50 +----
 12 files changed, 339 insertions(+), 316 deletions(-)

diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxManager.java b/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxManager.java
index dfaac638e2..1dfa2efec8 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxManager.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxManager.java
@@ -23,6 +23,7 @@ import java.util.EnumSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.function.Function;
 
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.exception.MailboxExistsException;
@@ -283,6 +284,16 @@ public interface MailboxManager extends RequestAware, RightManager, MailboxAnnot
     List<MessageRange> copyMessages(MessageRange set, MailboxPath from, MailboxPath to, MailboxSession session) throws MailboxException;
 
     List<MessageRange> copyMessages(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) throws MailboxException;
+
+    default Publisher<MessageRange> copyMessagesReactive(MessageRange set, MailboxPath from, MailboxPath to, MailboxSession session) {
+        return Mono.fromCallable(() -> copyMessages(set, from, to, session))
+            .flatMapIterable(Function.identity());
+    }
+
+    default Publisher<MessageRange> copyMessagesReactive(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) {
+        return Mono.fromCallable(() -> copyMessages(set, from, to, session))
+            .flatMapIterable(Function.identity());
+    }
     
     /**
      * Move the given {@link MessageRange} from one Mailbox to the other. 
@@ -303,6 +314,16 @@ public interface MailboxManager extends RequestAware, RightManager, MailboxAnnot
 
     List<MessageRange> moveMessages(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) throws MailboxException;
 
+    default Publisher<MessageRange> moveMessagesReactive(MessageRange set, MailboxPath from, MailboxPath to, MailboxSession session) {
+        return Mono.fromCallable(() -> moveMessages(set, from, to, session))
+            .flatMapIterable(Function.identity());
+    }
+
+    default Publisher<MessageRange> moveMessagesReactive(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) {
+        return Mono.fromCallable(() -> moveMessages(set, from, to, session))
+            .flatMapIterable(Function.identity());
+    }
+
     enum MailboxSearchFetchType {
         Minimal,
         Counters
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapper.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapper.java
index baaece7491..9bb21f4a9e 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapper.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapper.java
@@ -60,6 +60,7 @@ import org.apache.james.mailbox.model.MessageMetaData;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.model.UpdatedFlags;
 import org.apache.james.mailbox.store.FlagsUpdateCalculator;
+import org.apache.james.mailbox.store.MailboxReactorUtils;
 import org.apache.james.mailbox.store.mail.MessageMapper;
 import org.apache.james.mailbox.store.mail.ModSeqProvider;
 import org.apache.james.mailbox.store.mail.UidProvider;
@@ -343,24 +344,32 @@ public class CassandraMessageMapper implements MessageMapper {
 
     @Override
     public MessageMetaData move(Mailbox destinationMailbox, MailboxMessage original) throws MailboxException {
-        ComposedMessageIdWithMetaData composedMessageIdWithMetaData = original.getComposedMessageIdWithMetaData();
+        return MailboxReactorUtils.block(moveReactive(destinationMailbox, original));
+    }
 
-        MessageMetaData messageMetaData = copy(destinationMailbox, original);
-        deleteAndHandleIndexUpdates(composedMessageIdWithMetaData).block();
+    @Override
+    public List<MessageMetaData> move(Mailbox mailbox, List<MailboxMessage> original) throws MailboxException {
+        return MailboxReactorUtils.block(moveReactive(mailbox, original));
+    }
 
-        return messageMetaData;
+    @Override
+    public Mono<MessageMetaData> moveReactive(Mailbox destinationMailbox, MailboxMessage original) {
+        ComposedMessageIdWithMetaData composedMessageIdWithMetaData = original.getComposedMessageIdWithMetaData();
+
+        return copyReactive(destinationMailbox, original)
+            .flatMap(messageMetaData -> deleteAndHandleIndexUpdates(composedMessageIdWithMetaData)
+                .thenReturn(messageMetaData));
     }
 
     @Override
-    public List<MessageMetaData> move(Mailbox mailbox, List<MailboxMessage> original) throws MailboxException {
+    public Mono<List<MessageMetaData>> moveReactive(Mailbox destinationMailbox, List<MailboxMessage> original) {
         List<ComposedMessageIdWithMetaData> beforeCopy = original.stream()
             .map(MailboxMessage::getComposedMessageIdWithMetaData)
             .collect(ImmutableList.toImmutableList());
 
-        List<MessageMetaData> messageMetaData = copy(mailbox, original);
-        deleteAndHandleIndexUpdates(beforeCopy).block();
-
-        return messageMetaData;
+        return copyReactive(destinationMailbox, original)
+            .flatMap(messageMetaData -> deleteAndHandleIndexUpdates(beforeCopy)
+                .thenReturn(messageMetaData));
     }
 
     @Override
@@ -520,18 +529,31 @@ public class CassandraMessageMapper implements MessageMapper {
 
     @Override
     public MessageMetaData copy(Mailbox mailbox, MailboxMessage original) throws MailboxException {
-        original.setFlags(new FlagsBuilder().add(original.createFlags()).add(Flag.RECENT).build());
-        return setInMailbox(mailbox, original);
+        return MailboxReactorUtils.block(copyReactive(mailbox, original));
     }
 
     @Override
     public List<MessageMetaData> copy(Mailbox mailbox, List<MailboxMessage> originals) throws MailboxException {
-        return setInMailbox(mailbox, originals.stream()
+        return MailboxReactorUtils.block(copyReactive(mailbox, originals));
+    }
+
+    @Override
+    public Mono<MessageMetaData> copyReactive(Mailbox mailbox, MailboxMessage original) {
+        original.setFlags(new FlagsBuilder().add(original.createFlags()).add(Flag.RECENT).build());
+        return setInMailboxReactive(mailbox, original);
+    }
+
+    @Override
+    public Mono<List<MessageMetaData>> copyReactive(Mailbox mailbox, List<MailboxMessage> originals) {
+        if (originals.isEmpty()) {
+            return Mono.empty();
+        }
+        return setMessagesInMailboxReactive(mailbox, originals.stream()
             .map(original -> {
                 original.setFlags(new FlagsBuilder().add(original.createFlags()).add(Flag.RECENT).build());
                 return original;
-            })
-            .collect(ImmutableList.toImmutableList()));
+            }).collect(ImmutableList.toImmutableList()))
+            .collectList();
     }
 
     @Override
@@ -555,18 +577,18 @@ public class CassandraMessageMapper implements MessageMapper {
             .map(flags -> ApplicableFlagBuilder.builder().add(flags).build());
     }
 
-    private MessageMetaData setInMailbox(Mailbox mailbox, MailboxMessage message) throws MailboxException {
+    private Mono<MessageMetaData> setInMailboxReactive(Mailbox mailbox, MailboxMessage message) {
         CassandraId mailboxId = (CassandraId) mailbox.getMailboxId();
-        return block(addUidAndModseq(message, mailboxId)
+        return addUidAndModseq(message, mailboxId)
             .flatMap(messageWithUidAndModseq ->
                 insertMetadata(messageWithUidAndModseq, mailboxId,
                     CassandraMessageMetadata.from(messageWithUidAndModseq)
                         .withMailboxId(mailboxId))
                 .thenReturn(messageWithUidAndModseq))
-            .map(MailboxMessage::metaData));
+            .map(MailboxMessage::metaData);
     }
 
-    private List<MessageMetaData> setInMailbox(Mailbox mailbox, List<MailboxMessage> messages) throws MailboxException {
+    private Flux<MessageMetaData> setMessagesInMailboxReactive(Mailbox mailbox, List<MailboxMessage> messages) {
         CassandraId mailboxId = (CassandraId) mailbox.getMailboxId();
 
         Mono<List<MessageUid>> uids = uidProvider.nextUids(mailboxId, messages.size());
@@ -582,11 +604,9 @@ public class CassandraMessageMapper implements MessageMapper {
                     return aMessage;
                 }).collect(ImmutableList.toImmutableList()));
 
-        return block(messagesWithUidAndModSeq
-            .flatMap(list -> insertIds(list, mailboxId).thenReturn(list))
-            .map(list -> list.stream()
-                .map(MailboxMessage::metaData)
-                .collect(ImmutableList.toImmutableList())));
+        return messagesWithUidAndModSeq
+            .flatMapMany(list -> insertIds(list, mailboxId).thenMany(Flux.fromIterable(list)))
+            .map(MailboxMessage::metaData);
     }
 
     private Mono<Void> save(Mailbox mailbox, MailboxMessage message) throws MailboxException {
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/MessageBatcher.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/MessageBatcher.java
index f07624999c..66c00b2cce 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/MessageBatcher.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/MessageBatcher.java
@@ -28,6 +28,8 @@ import com.github.fge.lambdas.Throwing;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 
+import reactor.core.publisher.Flux;
+
 public class MessageBatcher {
 
     public static final int NO_BATCH_SIZE = 0;
@@ -36,6 +38,10 @@ public class MessageBatcher {
         List<MessageRange> execute(MessageRange messageRange) throws MailboxException;
     }
 
+    public interface ReactiveBatchedOperation {
+        Flux<MessageRange> execute(MessageRange messageRange);
+    }
+
     private final int batchSize;
 
     public MessageBatcher(int batchSize) {
@@ -52,11 +58,20 @@ public class MessageBatcher {
             return set.split(batchSize)
                 .stream()
                 .flatMap(Throwing.function(range -> batchedOperation.execute(range)
-                                                                    .stream()))
+                    .stream()))
                 .collect(ImmutableList.toImmutableList());
         } else {
             return batchedOperation.execute(set);
         }
     }
 
+    public Flux<MessageRange> batchMessagesReactive(MessageRange set, ReactiveBatchedOperation batchedOperation) {
+        if (batchSize > 0) {
+           return Flux.fromIterable(set.split(batchSize))
+                .flatMap(batchedOperation::execute);
+        } else {
+            return batchedOperation.execute(set);
+        }
+    }
+
 }
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/MoveResult.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/MoveResult.java
index 76bbb86b26..0e98dcfc0e 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/MoveResult.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/MoveResult.java
@@ -19,25 +19,25 @@
 
 package org.apache.james.mailbox.store;
 
-import java.util.Iterator;
+import java.util.List;
 
 import org.apache.james.mailbox.model.MessageMetaData;
 
 public class MoveResult {
 
-    private final Iterator<MessageMetaData> movedMessages;
-    private final Iterator<MessageMetaData> originalMessages;
+    private final List<MessageMetaData> movedMessages;
+    private final List<MessageMetaData> originalMessages;
 
-    public MoveResult(Iterator<MessageMetaData> movedMessages, Iterator<MessageMetaData> originalMessages) {
+    public MoveResult(List<MessageMetaData> movedMessages, List<MessageMetaData> originalMessages) {
         this.movedMessages = movedMessages;
         this.originalMessages = originalMessages;
     }
 
-    public Iterator<MessageMetaData> getMovedMessages() {
+    public List<MessageMetaData> getMovedMessages() {
         return movedMessages;
     }
 
-    public Iterator<MessageMetaData> getOriginalMessages() {
+    public List<MessageMetaData> getOriginalMessages() {
         return originalMessages;
     }
 }
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
index 72afb123df..d8df5eec14 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
@@ -625,40 +625,66 @@ public class StoreMailboxManager implements MailboxManager {
 
     @Override
     public List<MessageRange> copyMessages(MessageRange set, MailboxPath from, MailboxPath to, MailboxSession session) throws MailboxException {
-        StoreMessageManager toMailbox = (StoreMessageManager) getMailbox(to, session);
-        StoreMessageManager fromMailbox = (StoreMessageManager) getMailbox(from, session);
-
-        return copyMessages(set, session, toMailbox, fromMailbox);
+        return MailboxReactorUtils.block(copyMessagesReactive(set, from, to, session).collectList());
     }
 
     @Override
     public List<MessageRange> copyMessages(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) throws MailboxException {
-        StoreMessageManager toMailbox = (StoreMessageManager) getMailbox(to, session);
-        StoreMessageManager fromMailbox = (StoreMessageManager) getMailbox(from, session);
+        return MailboxReactorUtils.block(copyMessagesReactive(set, from, to, session).collectList());
+    }
 
-        return copyMessages(set, session, toMailbox, fromMailbox);
+    @Override
+    public Flux<MessageRange> copyMessagesReactive(MessageRange set, MailboxPath from, MailboxPath to, MailboxSession session) {
+        return Mono.zip(Mono.from(getMailboxReactive(from, session)), Mono.from(getMailboxReactive(to, session)))
+            .flatMapMany(fromTo -> configuration.getMoveBatcher().batchMessagesReactive(set, messageRange -> {
+                StoreMessageManager fromMessageManager = (StoreMessageManager) fromTo.getT1();
+                StoreMessageManager toMessageManager = (StoreMessageManager) fromTo.getT2();
+
+                return fromMessageManager.copyTo(messageRange, toMessageManager, session).flatMapIterable(Function.identity());
+            }));
     }
 
+    @Override
+    public Flux<MessageRange> copyMessagesReactive(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) {
+        return Mono.zip(Mono.from(getMailboxReactive(from, session)), Mono.from(getMailboxReactive(to, session)))
+            .flatMapMany(fromTo -> configuration.getMoveBatcher().batchMessagesReactive(set, messageRange -> {
+                StoreMessageManager fromMessageManager = (StoreMessageManager) fromTo.getT1();
+                StoreMessageManager toMessageManager = (StoreMessageManager) fromTo.getT2();
 
-    private List<MessageRange> copyMessages(MessageRange set, MailboxSession session, StoreMessageManager toMailbox, StoreMessageManager fromMailbox) throws MailboxException {
-        return configuration.getCopyBatcher().batchMessages(set,
-            messageRange -> fromMailbox.copyTo(messageRange, toMailbox, session));
+                return fromMessageManager.copyTo(messageRange, toMessageManager, session).flatMapIterable(Function.identity());
+            }));
     }
 
     @Override
     public List<MessageRange> moveMessages(MessageRange set, MailboxPath from, MailboxPath to, MailboxSession session) throws MailboxException {
-        StoreMessageManager toMailbox = (StoreMessageManager) getMailbox(to, session);
-        StoreMessageManager fromMailbox = (StoreMessageManager) getMailbox(from, session);
-
-        return configuration.getMoveBatcher().batchMessages(set, messageRange -> fromMailbox.moveTo(messageRange, toMailbox, session));
+        return MailboxReactorUtils.block(moveMessagesReactive(set, from, to, session).collectList());
     }
 
     @Override
     public List<MessageRange> moveMessages(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) throws MailboxException {
-        StoreMessageManager toMailbox = (StoreMessageManager) getMailbox(to, session);
-        StoreMessageManager fromMailbox = (StoreMessageManager) getMailbox(from, session);
+        return MailboxReactorUtils.block(moveMessagesReactive(set, from, to, session).collectList());
+    }
 
-        return configuration.getMoveBatcher().batchMessages(set, messageRange -> fromMailbox.moveTo(messageRange, toMailbox, session));
+    @Override
+    public Flux<MessageRange> moveMessagesReactive(MessageRange set, MailboxPath from, MailboxPath to, MailboxSession session) {
+        return Mono.zip(Mono.from(getMailboxReactive(from, session)), Mono.from(getMailboxReactive(to, session)))
+            .flatMapMany(fromTo -> configuration.getMoveBatcher().batchMessagesReactive(set, messageRange -> {
+                StoreMessageManager fromMessageManager = (StoreMessageManager) fromTo.getT1();
+                StoreMessageManager toMessageManager = (StoreMessageManager) fromTo.getT2();
+
+                return fromMessageManager.moveTo(messageRange, toMessageManager, session).flatMapIterable(Function.identity());
+            }));
+    }
+
+    @Override
+    public Flux<MessageRange> moveMessagesReactive(MessageRange set, MailboxId from, MailboxId to, MailboxSession session) {
+        return Mono.zip(Mono.from(getMailboxReactive(from, session)), Mono.from(getMailboxReactive(to, session)))
+            .flatMapMany(fromTo -> configuration.getMoveBatcher().batchMessagesReactive(set, messageRange -> {
+                StoreMessageManager fromMessageManager = (StoreMessageManager) fromTo.getT1();
+                StoreMessageManager toMessageManager = (StoreMessageManager) fromTo.getT2();
+
+                return fromMessageManager.moveTo(messageRange, toMessageManager, session).flatMapIterable(Function.identity());
+            }));
     }
 
     @Override
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageManager.java
index 58f3064cf2..f35857c0fb 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMessageManager.java
@@ -104,7 +104,6 @@ import org.apache.james.mime4j.stream.EntityState;
 import org.apache.james.mime4j.stream.MimeConfig;
 import org.apache.james.mime4j.stream.MimeTokenStream;
 import org.apache.james.mime4j.stream.RecursionMode;
-import org.apache.james.util.IteratorWrapper;
 import org.apache.james.util.io.BodyOffsetInputStream;
 import org.apache.james.util.io.InputStreamConsummer;
 import org.apache.james.util.streams.Iterators;
@@ -711,12 +710,8 @@ public class StoreMessageManager implements MessageManager {
 
     @Override
     public Publisher<Map<MessageUid, Flags>> setFlagsReactive(Flags flags, FlagsUpdateMode flagsUpdateMode, MessageRange set, MailboxSession mailboxSession) {
-        try {
-            if (!isWriteable(mailboxSession)) {
-                return Mono.error(new ReadOnlyException(getMailboxPath()));
-            }
-        } catch (MailboxException e) {
-            return Mono.error(e);
+        if (!isWriteable(mailboxSession)) {
+            return Mono.error(new ReadOnlyException(getMailboxPath()));
         }
 
         trimFlags(flags, mailboxSession);
@@ -739,33 +734,32 @@ public class StoreMessageManager implements MessageManager {
     /**
      * Copy the {@link MessageRange} to the {@link StoreMessageManager}
      */
-    public List<MessageRange> copyTo(final MessageRange set, final StoreMessageManager toMailbox, final MailboxSession session) throws MailboxException {
+    public Mono<List<MessageRange>> copyTo(MessageRange set, StoreMessageManager toMailbox, MailboxSession session) {
         if (!toMailbox.isWriteable(session)) {
-            throw new ReadOnlyException(toMailbox.getMailboxPath());
+            return Mono.error(new ReadOnlyException(toMailbox.getMailboxPath()));
         }
-
-        return locker.executeWithLock(toMailbox.getMailboxPath(), () -> {
-            SortedMap<MessageUid, MessageMetaData> copiedUids = copy(set, toMailbox, session);
-            return MessageRange.toRanges(new ArrayList<>(copiedUids.keySet()));
-        }, MailboxPathLocker.LockType.Write);
+        //TODO lock the from mailbox too, in a non-deadlocking manner - how?
+        return Mono.from(locker.executeReactiveWithLockReactive(toMailbox.getMailboxPath(),
+            copy(set, toMailbox, session)
+                .map(map -> MessageRange.toRanges(new ArrayList<>(map.keySet()))),
+            MailboxPathLocker.LockType.Write));
     }
 
     /**
      * Move the {@link MessageRange} to the {@link StoreMessageManager}
      */
-    public List<MessageRange> moveTo(final MessageRange set, final StoreMessageManager toMailbox, final MailboxSession session) throws MailboxException {
+    public Mono<List<MessageRange>> moveTo(MessageRange set, StoreMessageManager toMailbox, MailboxSession session) {
         if (!isWriteable(session)) {
-            throw new ReadOnlyException(getMailboxPath());
+            return Mono.error(new ReadOnlyException(toMailbox.getMailboxPath()));
         }
         if (!toMailbox.isWriteable(session)) {
-            throw new ReadOnlyException(toMailbox.getMailboxPath());
+            return Mono.error(new ReadOnlyException(toMailbox.getMailboxPath()));
         }
-
         //TODO lock the from mailbox too, in a non-deadlocking manner - how?
-        return locker.executeWithLock(toMailbox.getMailboxPath(), () -> {
-            SortedMap<MessageUid, MessageMetaData> movedUids = move(set, toMailbox, session);
-            return MessageRange.toRanges(new ArrayList<>(movedUids.keySet()));
-        }, MailboxPathLocker.LockType.Write);
+        return Mono.from(locker.executeReactiveWithLockReactive(toMailbox.getMailboxPath(),
+            move(set, toMailbox, session)
+                .map(map -> MessageRange.toRanges(new ArrayList<>(map.keySet()))),
+            MailboxPathLocker.LockType.Write));
     }
 
     @Override
@@ -856,127 +850,113 @@ public class StoreMessageManager implements MessageManager {
         return index.search(mailboxSession, getMailboxEntity(), query);
     }
 
-    private Iterator<MessageMetaData> copy(Iterator<MailboxMessage> originalRows, MailboxSession session) throws MailboxException {
-        int batchSize = batchSizes.getCopyBatchSize().orElse(1);
-        final List<MessageMetaData> copiedRows = new ArrayList<>();
-        final MessageMapper messageMapper = mapperFactory.getMessageMapper(session);
-
-        Iterator<List<MailboxMessage>> groupedOriginalRows = com.google.common.collect.Iterators.partition(originalRows, batchSize);
-
-        while (originalRows.hasNext()) {
-            List<MailboxMessage> originalMessages = groupedOriginalRows.next();
+    private Flux<MessageMetaData> copy(List<MailboxMessage> originalRows, MailboxSession session) {
+        MessageMapper messageMapper = mapperFactory.getMessageMapper(session);
 
-            new QuotaChecker(quotaManager, quotaRootResolver, mailbox)
-                .tryAddition(originalMessages.size(), originalMessages.stream()
-                    .mapToLong(MailboxMessage::getFullContentOctets)
-                    .sum());
-            List<MessageMetaData> data = messageMapper.execute(
-                () -> messageMapper.copy(getMailboxEntity(), originalMessages));
-            copiedRows.addAll(data);
+        try {
+            QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(getMailboxPath());
+            return Mono.from(quotaManager.getQuotasReactive(quotaRoot))
+                .doOnNext(Throwing.<QuotaManager.Quotas>consumer(quotas -> new QuotaChecker(quotas, quotaRoot)
+                    .tryAddition(originalRows.size(), originalRows.stream()
+                        .mapToLong(MailboxMessage::getFullContentOctets)
+                        .sum())).sneakyThrow())
+                .thenMany(messageMapper.executeReactive(
+                    messageMapper.copyReactive(getMailboxEntity(), originalRows))
+                    .flatMapIterable(Function.identity()));
+        } catch (MailboxException e) {
+            return Flux.error(e);
         }
-        return copiedRows.iterator();
     }
 
-    private MoveResult move(Iterator<MailboxMessage> originalRows, MailboxSession session) throws MailboxException {
-        int batchSize = batchSizes.getMoveBatchSize().orElse(1);
-        final List<MessageMetaData> movedRows = new ArrayList<>();
-        final List<MessageMetaData> originalRowsCopy = new ArrayList<>();
-        final MessageMapper messageMapper = mapperFactory.getMessageMapper(session);
-
-        Iterator<List<MailboxMessage>> groupedOriginalRows = com.google.common.collect.Iterators.partition(originalRows, batchSize);
+    private Mono<MoveResult> move(List<MailboxMessage> originalRows, MailboxSession session) {
+        List<MessageMetaData> originalRowsCopy = originalRows.stream()
+            .map(MailboxMessage::metaData)
+            .collect(ImmutableList.toImmutableList());
+        MessageMapper messageMapper = mapperFactory.getMessageMapper(session);
 
-        while (groupedOriginalRows.hasNext()) {
-            List<MailboxMessage> originalMessages = groupedOriginalRows.next();
-            originalRowsCopy.addAll(originalMessages.stream()
-                .map(MailboxMessage::metaData)
-                .collect(ImmutableList.toImmutableList()));
-            List<MessageMetaData> data = messageMapper.execute(
-                () -> messageMapper.move(getMailboxEntity(), originalMessages));
-            movedRows.addAll(data);
-        }
-        return new MoveResult(movedRows.iterator(), originalRowsCopy.iterator());
+        return messageMapper.executeReactive(messageMapper.moveReactive(getMailboxEntity(), originalRows))
+            .map(data -> new MoveResult(data, originalRowsCopy));
     }
 
 
-    private SortedMap<MessageUid, MessageMetaData> copy(MessageRange set, StoreMessageManager to, MailboxSession session) throws MailboxException {
-        IteratorWrapper<MailboxMessage> originalRows = new IteratorWrapper<>(retrieveOriginalRows(set, session));
+    private Mono<SortedMap<MessageUid, MessageMetaData>> copy(MessageRange set, StoreMessageManager to, MailboxSession session) {
+        return retrieveOriginalRows(set, session)
+            .collectList()
+            .flatMap(originalRows -> to.copy(originalRows, session).collectList().flatMap(copyResult -> {
+                SortedMap<MessageUid, MessageMetaData> copiedUids = collectMetadata(copyResult.iterator());
 
-        SortedMap<MessageUid, MessageMetaData> copiedUids = collectMetadata(to.copy(originalRows, session));
+                ImmutableList<MessageId> messageIds = originalRows.stream()
+                    .map(org.apache.james.mailbox.store.mail.model.Message::getMessageId)
+                    .collect(ImmutableList.toImmutableList());
 
-        ImmutableList.Builder<MessageId> messageIds = ImmutableList.builder();
-        for (MailboxMessage message : originalRows.getEntriesSeen()) {
-            messageIds.add(message.getMessageId());
-        }
+                MessageMoves messageMoves = MessageMoves.builder()
+                    .previousMailboxIds(getMailboxEntity().getMailboxId())
+                    .targetMailboxIds(to.getMailboxEntity().getMailboxId(), getMailboxEntity().getMailboxId())
+                    .build();
 
-        MessageMoves messageMoves = MessageMoves.builder()
-            .previousMailboxIds(getMailboxEntity().getMailboxId())
-            .targetMailboxIds(to.getMailboxEntity().getMailboxId(), getMailboxEntity().getMailboxId())
-            .build();
-        Flux.concat(
-            eventBus.dispatch(EventFactory.added()
-                    .randomEventId()
-                    .mailboxSession(session)
-                    .mailbox(to.getMailboxEntity())
-                    .metaData(copiedUids)
-                    .build(),
-                new MailboxIdRegistrationKey(to.getMailboxEntity().getMailboxId())),
-            eventBus.dispatch(EventFactory.moved()
-                    .session(session)
-                    .messageMoves(messageMoves)
-                    .messageId(messageIds.build())
-                    .build(),
-                messageMoves.impactedMailboxIds().map(MailboxIdRegistrationKey::new).collect(ImmutableSet.toImmutableSet())))
-            .subscribeOn(Schedulers.elastic())
-            .blockLast();
-
-        return copiedUids;
+                return Flux.concat(
+                    eventBus.dispatch(EventFactory.added()
+                            .randomEventId()
+                            .mailboxSession(session)
+                            .mailbox(to.getMailboxEntity())
+                            .metaData(copiedUids)
+                            .build(),
+                        new MailboxIdRegistrationKey(to.getMailboxEntity().getMailboxId())),
+                    eventBus.dispatch(EventFactory.moved()
+                            .messageMoves(messageMoves)
+                            .messageId(messageIds)
+                            .session(session)
+                            .build(),
+                        messageMoves.impactedMailboxIds().map(MailboxIdRegistrationKey::new).collect(ImmutableSet.toImmutableSet())))
+                    .then()
+                    .thenReturn(copiedUids);
+            }));
     }
 
-    private SortedMap<MessageUid, MessageMetaData> move(MessageRange set, StoreMessageManager to, MailboxSession session) throws MailboxException {
-        IteratorWrapper<MailboxMessage> originalRows = new IteratorWrapper<>(retrieveOriginalRows(set, session));
+    private Mono<SortedMap<MessageUid, MessageMetaData>> move(MessageRange set, StoreMessageManager to, MailboxSession session) {
+        return retrieveOriginalRows(set, session)
+            .collectList()
+            .flatMap(originalRows -> to.move(originalRows, session).flatMap(moveResult -> {
+                SortedMap<MessageUid, MessageMetaData> moveUids = collectMetadata(moveResult.getMovedMessages().iterator());
 
-        MoveResult moveResult = to.move(originalRows, session);
-        SortedMap<MessageUid, MessageMetaData> moveUids = collectMetadata(moveResult.getMovedMessages());
+                ImmutableList<MessageId> messageIds = originalRows.stream()
+                    .map(org.apache.james.mailbox.store.mail.model.Message::getMessageId)
+                    .collect(ImmutableList.toImmutableList());
 
-        ImmutableList.Builder<MessageId> messageIds = ImmutableList.builder();
-        for (MailboxMessage message : originalRows.getEntriesSeen()) {
-            messageIds.add(message.getMessageId());
-        }
+                MessageMoves messageMoves = MessageMoves.builder()
+                    .previousMailboxIds(getMailboxEntity().getMailboxId())
+                    .targetMailboxIds(to.getMailboxEntity().getMailboxId())
+                    .build();
 
-        MessageMoves messageMoves = MessageMoves.builder()
-            .previousMailboxIds(getMailboxEntity().getMailboxId())
-            .targetMailboxIds(to.getMailboxEntity().getMailboxId())
-            .build();
-        Flux.concat(
-            eventBus.dispatch(EventFactory.added()
-                    .randomEventId()
-                    .mailboxSession(session)
-                    .mailbox(to.getMailboxEntity())
-                    .metaData(moveUids)
-                    .build(),
-                new MailboxIdRegistrationKey(to.getMailboxEntity().getMailboxId())),
-            eventBus.dispatch(EventFactory.expunged()
-                    .randomEventId()
-                    .mailboxSession(session)
-                    .mailbox(getMailboxEntity())
-                    .addMetaData(moveResult.getOriginalMessages())
-                    .build(),
-                new MailboxIdRegistrationKey(mailbox.getMailboxId())),
-            eventBus.dispatch(EventFactory.moved()
-                    .messageMoves(messageMoves)
-                    .messageId(messageIds.build())
-                    .session(session)
-                    .build(),
-                messageMoves.impactedMailboxIds().map(MailboxIdRegistrationKey::new).collect(ImmutableSet.toImmutableSet())))
-            .subscribeOn(Schedulers.elastic())
-            .blockLast();
-
-        return moveUids;
+                return Flux.concat(
+                    eventBus.dispatch(EventFactory.added()
+                            .randomEventId()
+                            .mailboxSession(session)
+                            .mailbox(to.getMailboxEntity())
+                            .metaData(moveUids)
+                            .build(),
+                        new MailboxIdRegistrationKey(to.getMailboxEntity().getMailboxId())),
+                    eventBus.dispatch(EventFactory.expunged()
+                            .randomEventId()
+                            .mailboxSession(session)
+                            .mailbox(getMailboxEntity())
+                            .addMetaData(moveResult.getOriginalMessages())
+                            .build(),
+                        new MailboxIdRegistrationKey(mailbox.getMailboxId())),
+                    eventBus.dispatch(EventFactory.moved()
+                            .messageMoves(messageMoves)
+                            .messageId(messageIds)
+                            .session(session)
+                            .build(),
+                        messageMoves.impactedMailboxIds().map(MailboxIdRegistrationKey::new).collect(ImmutableSet.toImmutableSet())))
+                    .then()
+                    .thenReturn(moveUids);
+            }));
     }
 
-    private Iterator<MailboxMessage> retrieveOriginalRows(MessageRange set, MailboxSession session) throws MailboxException {
+    private Flux<MailboxMessage> retrieveOriginalRows(MessageRange set, MailboxSession session) {
         MessageMapper messageMapper = mapperFactory.getMessageMapper(session);
-        return messageMapper.findInMailbox(mailbox, set, FetchType.METADATA, UNLIMITED);
+        return messageMapper.findInMailboxReactive(mailbox, set, FetchType.METADATA, UNLIMITED);
     }
 
     private SortedMap<MessageUid, MessageMetaData> collectMetadata(Iterator<MessageMetaData> ids) {
@@ -994,7 +974,7 @@ public class StoreMessageManager implements MessageManager {
     }
     
     @Override
-    public MailboxPath getMailboxPath() throws MailboxException {
+    public MailboxPath getMailboxPath() {
         return getMailboxEntity().generateAssociatedPath();
     }
 
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/MessageMapper.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/MessageMapper.java
index 0fa6e16629..4268c10c2d 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/MessageMapper.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/MessageMapper.java
@@ -42,6 +42,7 @@ import org.apache.james.mailbox.store.FlagsUpdateCalculator;
 import org.apache.james.mailbox.store.mail.model.MailboxMessage;
 import org.apache.james.mailbox.store.mail.model.Property;
 import org.apache.james.mailbox.store.transaction.Mapper;
+import org.apache.james.util.ReactorUtils;
 import org.apache.james.util.streams.Iterators;
 import org.reactivestreams.Publisher;
 
@@ -211,6 +212,14 @@ public interface MessageMapper extends Mapper {
             .map(Throwing.<MailboxMessage, MessageMetaData>function(message -> copy(mailbox, message)).sneakyThrow())
             .collect(ImmutableList.toImmutableList());
     }
+
+    default Mono<MessageMetaData> copyReactive(Mailbox mailbox, MailboxMessage original) {
+        return Mono.fromCallable(() -> copy(mailbox, original));
+    }
+
+    default Mono<List<MessageMetaData>> copyReactive(Mailbox mailbox, List<MailboxMessage> original) {
+        return Mono.fromCallable(() -> copy(mailbox, original));
+    }
     
     /**
      * Move the given {@link MailboxMessage} to a new mailbox and return the uid of the moved. Be aware that the given uid is just a suggestion for the uid of the moved
@@ -227,6 +236,16 @@ public interface MessageMapper extends Mapper {
             .collect(ImmutableList.toImmutableList());
     }
 
+    default Mono<MessageMetaData> moveReactive(Mailbox mailbox, MailboxMessage original) {
+        return Mono.fromCallable(() -> move(mailbox, original));
+    }
+
+    default Mono<List<MessageMetaData>> moveReactive(Mailbox mailbox, List<MailboxMessage> original) {
+        return Flux.fromIterable(original)
+            .flatMap(message -> moveReactive(mailbox, message), ReactorUtils.DEFAULT_CONCURRENCY)
+            .collectList();
+    }
+
     
     /**
      * Return the last uid which were used for storing a MailboxMessage in the {@link Mailbox} or null if no
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java
index f4a1660fc9..73e7144549 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java
@@ -19,10 +19,9 @@
 
 package org.apache.james.imap.processor;
 
-import java.util.Arrays;
-import java.util.List;
+import static org.apache.james.util.ReactorUtils.logOnError;
+
 import java.util.Objects;
-import java.util.stream.Stream;
 
 import org.apache.james.imap.api.display.HumanReadableText;
 import org.apache.james.imap.api.message.IdRange;
@@ -34,9 +33,9 @@ import org.apache.james.imap.main.PathConverter;
 import org.apache.james.imap.message.request.AbstractMessageRangeRequest;
 import org.apache.james.mailbox.MailboxManager;
 import org.apache.james.mailbox.MailboxSession;
-import org.apache.james.mailbox.MessageManager;
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.exception.MessageRangeException;
+import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxPath;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.mailbox.model.UidValidity;
@@ -47,6 +46,7 @@ import org.slf4j.LoggerFactory;
 import com.github.fge.lambdas.Throwing;
 import com.google.common.collect.ImmutableList;
 
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public abstract class AbstractMessageRangeProcessor<R extends AbstractMessageRangeRequest> extends AbstractMailboxProcessor<R> {
@@ -57,65 +57,62 @@ public abstract class AbstractMessageRangeProcessor<R extends AbstractMessageRan
         super(acceptableClass, mailboxManager, factory, metricFactory);
     }
 
-    protected abstract List<MessageRange> process(MailboxPath targetMailbox,
+    protected abstract Flux<MessageRange> process(MailboxId targetMailbox,
                                                   SelectedMailbox currentMailbox,
                                                   MailboxSession mailboxSession,
-                                                  MessageRange messageSet) throws MailboxException;
+                                                  MessageRange messageSet);
 
     protected abstract String getOperationName();
 
     @Override
-    protected void processRequest(R request, ImapSession session, Responder responder) {
+    protected Mono<Void> processRequestReactive(R request, ImapSession session, Responder responder) {
         MailboxPath targetMailbox = PathConverter.forSession(session).buildFullPath(request.getMailboxName());
-
-        try {
-            MailboxSession mailboxSession = session.getMailboxSession();
-
-            if (!Mono.from(getMailboxManager().mailboxExists(targetMailbox, mailboxSession)).block()) {
-                no(request, responder, HumanReadableText.FAILURE_NO_SUCH_MAILBOX, StatusResponse.ResponseCode.tryCreate());
-            } else {
-                StatusResponse.ResponseCode code = handleRanges(request, session, targetMailbox, mailboxSession);
-                unsolicitedResponses(session, responder, request.isUseUids()).block();
-                okComplete(request, code, responder);
-            }
-        } catch (MessageRangeException e) {
-            LOGGER.debug("{} failed from mailbox {} to {} for invalid sequence-set {}",
-                    getOperationName(), session.getSelected().getMailboxId(), targetMailbox, request.getIdSet(), e);
-            taggedBad(request, responder, HumanReadableText.INVALID_MESSAGESET);
-        } catch (MailboxException e) {
-            LOGGER.error("{} failed from mailbox {} to {} for sequence-set {}",
-                    getOperationName(), session.getSelected().getMailboxId(), targetMailbox, request.getIdSet(), e);
-            no(request, responder, HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
-        } catch (Exception e) {
-            if (e.getCause() instanceof MailboxException) {
-                LOGGER.error("{} failed from mailbox {} to {} for sequence-set {}",
-                    getOperationName(), session.getSelected().getMailboxId(), targetMailbox, request.getIdSet(), e.getCause());
+        MailboxSession mailboxSession = session.getMailboxSession();
+
+        return Mono.from(getMailboxManager().mailboxExists(targetMailbox, mailboxSession))
+            .flatMap(targetExists -> {
+                if (!targetExists) {
+                    no(request, responder, HumanReadableText.FAILURE_NO_SUCH_MAILBOX, StatusResponse.ResponseCode.tryCreate());
+                    return Mono.empty();
+                } else {
+                    return handleRanges(request, session, targetMailbox, mailboxSession)
+                        .flatMap(code -> unsolicitedResponses(session, responder, request.isUseUids())
+                            .then(Mono.fromRunnable(() -> okComplete(request, code, responder))));
+                }
+            })
+            .doOnEach(logOnError(MessageRangeException.class, e -> LOGGER.debug("{} failed from mailbox {} to {} for invalid sequence-set {}",
+                getOperationName(), session.getSelected().getMailboxId(), targetMailbox, request.getIdSet(), e)))
+            .onErrorResume(MessageRangeException.class, e -> {
+                taggedBad(request, responder, HumanReadableText.INVALID_MESSAGESET);
+                return Mono.empty();
+            })
+            .doOnEach(logOnError(MailboxException.class, e -> LOGGER.error("{} failed from mailbox {} to {} for sequence-set {}",
+                getOperationName(), session.getSelected().getMailboxId(), targetMailbox, request.getIdSet(), e.getCause())))
+            .onErrorResume(MailboxException.class, e -> {
                 no(request, responder, HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
-            } else {
-                throw e;
-            }
-        }
+                return Mono.empty();
+            }).then();
     }
 
-    private StatusResponse.ResponseCode handleRanges(R request, ImapSession session, MailboxPath targetMailbox, MailboxSession mailboxSession) throws MailboxException {
-        MessageManager mailbox = getMailboxManager().getMailbox(targetMailbox, mailboxSession);
-
-        IdRange[] resultUids = IdRange.mergeRanges(Arrays.stream(request.getIdSet())
-            .map(Throwing.<IdRange, MessageRange>function(
-                range -> messageRange(session.getSelected(), range, request.isUseUids()))
-                .sneakyThrow())
-            .filter(Objects::nonNull)
-            .flatMap(Throwing.<MessageRange, Stream<MessageRange>>function(
-                range -> process(targetMailbox, session.getSelected(), mailboxSession, range)
-                    .stream())
-                .sneakyThrow())
-            .map(IdRange::from)
-            .collect(ImmutableList.toImmutableList()))
-            .toArray(IdRange[]::new);
-
-        // get folder UIDVALIDITY
-        UidValidity uidValidity = mailbox.getMailboxEntity().getUidValidity();
-
-        return StatusResponse.ResponseCode.copyUid(uidValidity, request.getIdSet(), resultUids);
+    private Mono<StatusResponse.ResponseCode> handleRanges(R request, ImapSession session, MailboxPath targetMailbox, MailboxSession mailboxSession) {
+        return Mono.from(getMailboxManager()
+            .getMailboxReactive(targetMailbox, mailboxSession))
+            .flatMap(target -> {
+                try {
+                    UidValidity uidValidity = target.getMailboxEntity().getUidValidity();
+                    return Flux.fromArray(request.getIdSet())
+                        .map(Throwing.<IdRange, MessageRange>function(
+                            range -> messageRange(session.getSelected(), range, request.isUseUids()))
+                            .sneakyThrow())
+                        .filter(Objects::nonNull)
+                        .concatMap(range -> process(target.getId(), session.getSelected(), mailboxSession, range)
+                            .map(IdRange::from))
+                        .collect(ImmutableList.<IdRange>toImmutableList())
+                        .map(IdRange::mergeRanges)
+                        .map(ranges -> StatusResponse.ResponseCode.copyUid(uidValidity, request.getIdSet(), ranges.toArray(IdRange[]::new)));
+                } catch (MailboxException e) {
+                    return Mono.error(e);
+                }
+            });
     }
 }
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/processor/CopyProcessor.java b/protocols/imap/src/main/java/org/apache/james/imap/processor/CopyProcessor.java
index 897e0aae95..7eca0f79c0 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/processor/CopyProcessor.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/processor/CopyProcessor.java
@@ -19,20 +19,19 @@
 
 package org.apache.james.imap.processor;
 
-import java.util.List;
-
 import org.apache.james.imap.api.message.IdRange;
 import org.apache.james.imap.api.message.response.StatusResponseFactory;
 import org.apache.james.imap.api.process.SelectedMailbox;
 import org.apache.james.imap.message.request.CopyRequest;
 import org.apache.james.mailbox.MailboxManager;
 import org.apache.james.mailbox.MailboxSession;
-import org.apache.james.mailbox.exception.MailboxException;
-import org.apache.james.mailbox.model.MailboxPath;
+import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.metrics.api.MetricFactory;
 import org.apache.james.util.MDCBuilder;
 
+import reactor.core.publisher.Flux;
+
 public class CopyProcessor extends AbstractMessageRangeProcessor<CopyRequest> {
 
     public CopyProcessor(MailboxManager mailboxManager, StatusResponseFactory factory,
@@ -46,11 +45,11 @@ public class CopyProcessor extends AbstractMessageRangeProcessor<CopyRequest> {
     }
 
     @Override
-    protected List<MessageRange> process(MailboxPath targetMailbox,
+    protected Flux<MessageRange> process(MailboxId targetMailbox,
                                          SelectedMailbox currentMailbox,
                                          MailboxSession mailboxSession,
-                                         MessageRange messageSet) throws MailboxException {
-        return getMailboxManager().copyMessages(messageSet, currentMailbox.getPath(), targetMailbox, mailboxSession);
+                                         MessageRange messageSet) {
+        return Flux.from(getMailboxManager().copyMessagesReactive(messageSet, currentMailbox.getMailboxId(), targetMailbox, mailboxSession));
     }
 
     @Override
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/processor/MoveProcessor.java b/protocols/imap/src/main/java/org/apache/james/imap/processor/MoveProcessor.java
index ec36426d32..5c01ca90b8 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/processor/MoveProcessor.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/processor/MoveProcessor.java
@@ -30,14 +30,15 @@ import org.apache.james.imap.api.process.SelectedMailbox;
 import org.apache.james.imap.message.request.MoveRequest;
 import org.apache.james.mailbox.MailboxManager;
 import org.apache.james.mailbox.MailboxSession;
-import org.apache.james.mailbox.exception.MailboxException;
-import org.apache.james.mailbox.model.MailboxPath;
+import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MessageRange;
 import org.apache.james.metrics.api.MetricFactory;
 import org.apache.james.util.MDCBuilder;
 
 import com.google.common.collect.ImmutableList;
 
+import reactor.core.publisher.Flux;
+
 public class MoveProcessor extends AbstractMessageRangeProcessor<MoveRequest> implements CapabilityImplementingProcessor {
 
     private final boolean moveCapabilitySupported;
@@ -49,9 +50,9 @@ public class MoveProcessor extends AbstractMessageRangeProcessor<MoveRequest> im
     }
 
     @Override
-    protected List<MessageRange> process(MailboxPath targetMailbox, SelectedMailbox currentMailbox,
-                                         MailboxSession mailboxSession, MessageRange messageSet) throws MailboxException {
-        return getMailboxManager().moveMessages(messageSet, currentMailbox.getPath(), targetMailbox, mailboxSession);
+    protected Flux<MessageRange> process(MailboxId targetMailbox, SelectedMailbox currentMailbox,
+                                         MailboxSession mailboxSession, MessageRange messageSet) {
+        return Flux.from(getMailboxManager().moveMessagesReactive(messageSet, currentMailbox.getMailboxId(), targetMailbox, mailboxSession));
     }
 
     @Override
diff --git a/protocols/imap/src/test/java/org/apache/james/imap/processor/CopyProcessorTest.java b/protocols/imap/src/test/java/org/apache/james/imap/processor/CopyProcessorTest.java
index 45e1e31b36..84a70424ec 100644
--- a/protocols/imap/src/test/java/org/apache/james/imap/processor/CopyProcessorTest.java
+++ b/protocols/imap/src/test/java/org/apache/james/imap/processor/CopyProcessorTest.java
@@ -21,6 +21,7 @@ package org.apache.james.imap.processor;
 
 import static org.apache.james.imap.ImapFixture.TAG;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -47,22 +48,24 @@ import org.apache.james.mailbox.MessageManager;
 import org.apache.james.mailbox.MessageUid;
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.Mailbox;
+import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxPath;
 import org.apache.james.mailbox.model.MessageRange;
+import org.apache.james.mailbox.model.TestId;
 import org.apache.james.mailbox.model.UidValidity;
 import org.apache.james.metrics.tests.RecordingMetricFactory;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.stubbing.Answer;
 
-import com.google.common.collect.Lists;
-
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 class CopyProcessorTest {
     private static final Username USERNAME = Username.of("username");
     private static final MailboxPath INBOX = MailboxPath.inbox(USERNAME);
     private static final UidValidity UID_VALIDITY = UidValidity.of(58L);
+    private static final TestId MAILBOX_ID = TestId.of(34);
 
     private CopyProcessor testee;
     private MailboxManager mockMailboxManager;
@@ -97,59 +100,29 @@ class CopyProcessorTest {
         SelectedMailbox selectedMailbox = mock(SelectedMailbox.class);
         when(selectedMailbox.getLastUid()).thenReturn(Optional.of(MessageUid.of(8)));
         when(selectedMailbox.existsCount()).thenReturn(8L);
+        when(selectedMailbox.getMailboxId()).thenReturn(MAILBOX_ID);
         when(selectedMailbox.getPath()).thenReturn(selected);
         imapSession.selected(selectedMailbox).block();
         when(mockMailboxManager.mailboxExists(INBOX, mailboxSession)).thenReturn(Mono.just(true));
         MessageManager targetMessageManager = mock(MessageManager.class);
-        when(mockMailboxManager.getMailbox(INBOX, mailboxSession)).thenReturn(targetMessageManager);
-        Mailbox mailbox = mock(Mailbox.class);
-        when(mailbox.getUidValidity()).thenReturn(UID_VALIDITY);
-        when(targetMessageManager.getMailboxEntity()).thenReturn(mailbox);
-        StatusResponse okResponse = mock(StatusResponse.class);
-        when(mockStatusResponseFactory.taggedOk(any(Tag.class), any(ImapCommand.class), any(HumanReadableText.class), any(StatusResponse.ResponseCode.class))).thenReturn(okResponse);
-        when(mockMailboxManager.moveMessages(MessageRange.range(MessageUid.of(4), MessageUid.of(6)), selected, INBOX, mailboxSession)).thenReturn(Lists.<MessageRange>newArrayList(MessageRange.range(MessageUid.of(4), MessageUid.of(6))));
-
-        testee.process(copyRequest, mockResponder, imapSession);
-
-        verify(mockMailboxManager).manageProcessing(any(), any());
-        verify(mockMailboxManager).mailboxExists(INBOX, mailboxSession);
-        verify(mockMailboxManager).getMailbox(INBOX, mailboxSession);
-        verify(mockMailboxManager).copyMessages(MessageRange.range(MessageUid.of(4), MessageUid.of(6)), selected, INBOX, mailboxSession);
-        verify(targetMessageManager).getMailboxEntity();
-        verify(mockResponder).respond(okResponse);
-        verifyNoMoreInteractions(mockMailboxManager, targetMessageManager, mockResponder);
-    }
-
-
-    @Test
-    void processShouldWorkWithMultipleRanges() throws Exception {
-        CopyRequest copyRequest = new CopyRequest(new IdRange[] {new IdRange(5, 6), new IdRange(1, 3)}, ImapConstants.INBOX_NAME, true, TAG);
-
-        MailboxPath selected = new MailboxPath(INBOX, "selected");
-        SelectedMailbox selectedMailbox = mock(SelectedMailbox.class);
-        when(selectedMailbox.getLastUid()).thenReturn(Optional.of(MessageUid.of(8)));
-        when(selectedMailbox.existsCount()).thenReturn(8L);
-        when(selectedMailbox.getPath()).thenReturn(selected);
-        imapSession.selected(selectedMailbox).block();
-        when(mockMailboxManager.mailboxExists(INBOX, mailboxSession)).thenReturn(Mono.just(true));
-        MessageManager targetMessageManager = mock(MessageManager.class);
-        when(mockMailboxManager.getMailbox(INBOX, mailboxSession)).thenReturn(targetMessageManager);
+        when(targetMessageManager.getId()).thenReturn(MAILBOX_ID);
+        when(mockMailboxManager.getMailboxReactive(any(MailboxPath.class), any(MailboxSession.class))).thenReturn(Mono.just(targetMessageManager));
         Mailbox mailbox = mock(Mailbox.class);
         when(mailbox.getUidValidity()).thenReturn(UID_VALIDITY);
         when(targetMessageManager.getMailboxEntity()).thenReturn(mailbox);
         StatusResponse okResponse = mock(StatusResponse.class);
         when(mockStatusResponseFactory.taggedOk(any(Tag.class), any(ImapCommand.class), any(HumanReadableText.class), any(StatusResponse.ResponseCode.class))).thenReturn(okResponse);
+        when(mockMailboxManager.copyMessagesReactive(eq(MessageRange.range(MessageUid.of(4), MessageUid.of(6))), any(MailboxId.class), any(MailboxId.class), eq(mailboxSession)))
+            .thenReturn(Flux.just(MessageRange.range(MessageUid.of(4), MessageUid.of(6))));
 
         testee.process(copyRequest, mockResponder, imapSession);
 
         verify(mockMailboxManager).manageProcessing(any(), any());
         verify(mockMailboxManager).mailboxExists(INBOX, mailboxSession);
-        verify(mockMailboxManager).getMailbox(INBOX, mailboxSession);
-        verify(mockMailboxManager).copyMessages(MessageRange.range(MessageUid.of(5), MessageUid.of(6)), selected, INBOX, mailboxSession);
-        verify(mockMailboxManager).copyMessages(MessageRange.range(MessageUid.of(1), MessageUid.of(3)), selected, INBOX, mailboxSession);
+        verify(mockMailboxManager).getMailboxReactive(any(MailboxPath.class), any(MailboxSession.class));
+        verify(mockMailboxManager).copyMessagesReactive(eq(MessageRange.range(MessageUid.of(4), MessageUid.of(6))), any(MailboxId.class), any(MailboxId.class), eq(mailboxSession));
         verify(targetMessageManager).getMailboxEntity();
         verify(mockResponder).respond(okResponse);
-        verifyNoMoreInteractions(mockMailboxManager, targetMessageManager, mockResponder);
     }
 
     @Test
diff --git a/protocols/imap/src/test/java/org/apache/james/imap/processor/MoveProcessorTest.java b/protocols/imap/src/test/java/org/apache/james/imap/processor/MoveProcessorTest.java
index 6847721177..c3018ae3e9 100644
--- a/protocols/imap/src/test/java/org/apache/james/imap/processor/MoveProcessorTest.java
+++ b/protocols/imap/src/test/java/org/apache/james/imap/processor/MoveProcessorTest.java
@@ -50,16 +50,17 @@ import org.apache.james.mailbox.MessageManager;
 import org.apache.james.mailbox.MessageUid;
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.model.Mailbox;
+import org.apache.james.mailbox.model.MailboxId;
 import org.apache.james.mailbox.model.MailboxPath;
 import org.apache.james.mailbox.model.MessageRange;
+import org.apache.james.mailbox.model.TestId;
 import org.apache.james.mailbox.model.UidValidity;
 import org.apache.james.metrics.tests.RecordingMetricFactory;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.stubbing.Answer;
 
-import com.google.common.collect.Lists;
-
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public class MoveProcessorTest {
@@ -114,58 +115,29 @@ public class MoveProcessorTest {
         when(selectedMailbox.getLastUid()).thenReturn(Optional.of(MessageUid.of(8)));
         when(selectedMailbox.existsCount()).thenReturn(8L);
         when(selectedMailbox.getPath()).thenReturn(selected);
+        when(selectedMailbox.getMailboxId()).thenReturn(TestId.of(234));
         imapSession.selected(selectedMailbox).block();
         when(mockMailboxManager.mailboxExists(INBOX, mailboxSession)).thenReturn(Mono.just(true));
         MessageManager targetMessageManager = mock(MessageManager.class);
-        when(mockMailboxManager.getMailbox(INBOX, mailboxSession)).thenReturn(targetMessageManager);
-        Mailbox mailbox = mock(Mailbox.class);
-        when(mailbox.getUidValidity()).thenReturn(UID_VALIDITY);
-        when(targetMessageManager.getMailboxEntity()).thenReturn(mailbox);
-        StatusResponse okResponse = mock(StatusResponse.class);
-        when(mockStatusResponseFactory.taggedOk(any(Tag.class), any(ImapCommand.class), any(HumanReadableText.class), any(StatusResponse.ResponseCode.class))).thenReturn(okResponse);
-        when(mockMailboxManager.moveMessages(MessageRange.range(MessageUid.of(4), MessageUid.of(6)), selected, INBOX, mailboxSession))
-            .thenReturn(Lists.<MessageRange>newArrayList(MessageRange.range(MessageUid.of(4), MessageUid.of(6))));
-
-        testee.process(moveRequest, mockResponder, imapSession);
-
-        verify(mockMailboxManager).manageProcessing(any(), any());
-        verify(mockMailboxManager).mailboxExists(INBOX, mailboxSession);
-        verify(mockMailboxManager).getMailbox(INBOX, mailboxSession);
-        verify(mockMailboxManager).moveMessages(MessageRange.range(MessageUid.of(4), MessageUid.of(6)), selected, INBOX, mailboxSession);
-        verify(targetMessageManager).getMailboxEntity();
-        verify(mockResponder).respond(okResponse);
-        verifyNoMoreInteractions(mockMailboxManager, targetMessageManager, mockResponder);
-    }
-
-
-    @Test
-    void processShouldWorkWithMultipleRanges() throws Exception {
-        MoveRequest moveRequest = new MoveRequest(new IdRange[] {new IdRange(5, 6), new IdRange(1,3)}, ImapConstants.INBOX_NAME, true, TAG);
-        MailboxPath selected = new MailboxPath(INBOX, "selected");
-        SelectedMailbox selectedMailbox = mock(SelectedMailbox.class);
-        when(selectedMailbox.getLastUid()).thenReturn(Optional.of(MessageUid.of(8)));
-        when(selectedMailbox.existsCount()).thenReturn(8L);
-        when(selectedMailbox.getPath()).thenReturn(selected);
-        imapSession.selected(selectedMailbox).block();
-        when(mockMailboxManager.mailboxExists(INBOX, mailboxSession)).thenReturn(Mono.just(true));
-        MessageManager targetMessageManager = mock(MessageManager.class);
-        when(mockMailboxManager.getMailbox(INBOX, mailboxSession)).thenReturn(targetMessageManager);
+        when(targetMessageManager.getId()).thenReturn(TestId.of(34));
+        when(mockMailboxManager.getMailboxReactive(any(MailboxPath.class), any(MailboxSession.class))).thenReturn(Mono.just(targetMessageManager));
         Mailbox mailbox = mock(Mailbox.class);
         when(mailbox.getUidValidity()).thenReturn(UID_VALIDITY);
         when(targetMessageManager.getMailboxEntity()).thenReturn(mailbox);
         StatusResponse okResponse = mock(StatusResponse.class);
         when(mockStatusResponseFactory.taggedOk(any(Tag.class), any(ImapCommand.class), any(HumanReadableText.class), any(StatusResponse.ResponseCode.class))).thenReturn(okResponse);
+        when(mockMailboxManager.moveMessagesReactive(eq(MessageRange.range(MessageUid.of(4), MessageUid.of(6))), any(MailboxId.class), any(MailboxId.class), eq(mailboxSession)))
+            .thenReturn(Flux.just(MessageRange.range(MessageUid.of(4), MessageUid.of(6))));
 
         testee.process(moveRequest, mockResponder, imapSession);
 
+        verify(mockMailboxManager).hasCapability(MailboxManager.MailboxCapabilities.Move);
         verify(mockMailboxManager).manageProcessing(any(), any());
         verify(mockMailboxManager).mailboxExists(INBOX, mailboxSession);
-        verify(mockMailboxManager).getMailbox(INBOX, mailboxSession);
-        verify(mockMailboxManager).moveMessages(MessageRange.range(MessageUid.of(5), MessageUid.of(6)), selected, INBOX, mailboxSession);
-        verify(mockMailboxManager).moveMessages(MessageRange.range(MessageUid.of(1), MessageUid.of(3)), selected, INBOX, mailboxSession);
+        verify(mockMailboxManager).getMailboxReactive(INBOX, mailboxSession);
+        verify(mockMailboxManager).moveMessagesReactive(eq(MessageRange.range(MessageUid.of(4), MessageUid.of(6))), any(MailboxId.class), any(MailboxId.class), eq(mailboxSession));
         verify(targetMessageManager).getMailboxEntity();
         verify(mockResponder).respond(okResponse);
-        verifyNoMoreInteractions(mockMailboxManager, targetMessageManager, mockResponder);
     }
 
     @Test


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