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