You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by hq...@apache.org on 2026/10/02 02:43:06 UTC

(james-project) branch 3.9.x updated (201aca3e79 -> 172ac9cc69)

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

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


    from 201aca3e79 [FIX] Plug MailboxMerging error stream in parent task (#3220)
     new fdb22d5d9c [FIX] Re-enable SolveMessageInconsistenciesServiceTest
     new 5158569c9a [ENHANCEMENT] SolveMessageInconsistencies: do not propagate imapUidTable entries without messageV3
     new f2e995eccf [ENHANCEMENT] SolveMessageInconsistencies: offer to cleanup mailbox entry without backing content
     new 172ac9cc69 Adapt #3219 to branch 3.9.x

The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../operate/webadmin/admin-mailboxes-extend.adoc   |  24 +-
 .../operate/webadmin/admin-messages-extend.adoc    |  24 +-
 .../cassandra/mail/task/RunningOptionsDTO.java     |  15 +-
 .../task/SolveMessageInconsistenciesService.java   | 201 ++++++++++-
 .../mail/task/SolveMessageInconsistenciesTask.java |  12 +-
 ...nconsistenciesTaskAdditionalInformationDTO.java |   9 +
 .../SolveMessageInconsistenciesServiceTest.java    | 392 ++++++++++++++++++---
 ...essageInconsistenciesTaskSerializationTest.java |   5 +-
 ...ssageInconsistencies.additionalInformation.json |   4 +-
 .../json/solveMessageInconsistencies.task.json     |   3 +-
 ...itMQWebAdminServerIntegrationImmutableTest.java |   2 +
 .../webadmin/routes/RunningOptionsParser.java      |   9 +-
 ...lveMessageInconsistenciesRequestToTaskTest.java |  35 ++
 13 files changed, 656 insertions(+), 79 deletions(-)


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


(james-project) 02/04: [ENHANCEMENT] SolveMessageInconsistencies: do not propagate imapUidTable entries without messageV3

Posted by hq...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 5158569c9a6dc6f77825a9d80638da8008fad944
Author: Benoit TELLIER <bt...@linagora.com>
AuthorDate: Wed Sep 30 09:19:26 2026 +0200

    [ENHANCEMENT] SolveMessageInconsistencies: do not propagate imapUidTable entries without messageV3
    
    An orphan imapUidTable entry was blindly re-inserted into messageIdTable.
    When the message content (messageV3) is missing, typically because deleted
    data got resurrected after tombstones were purged without repair, this
    exposes a message that can not be read.
    
    Check messageV3 (READ profile, QUORUM by default) before propagating.
    When absent, skip the entry, log it and report it as an error.
---
 .../operate/webadmin/admin-mailboxes-extend.adoc   |  8 +++
 .../operate/webadmin/admin-messages-extend.adoc    |  8 +++
 .../task/SolveMessageInconsistenciesService.java   | 42 +++++++++++++-
 .../SolveMessageInconsistenciesServiceTest.java    | 66 +++++++++++++++++++++-
 4 files changed, 121 insertions(+), 3 deletions(-)

diff --git a/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc b/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc
index a1dabd7290..df7194bd54 100644
--- a/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc
+++ b/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc
@@ -167,6 +167,14 @@ The message is SEEN via JMAP
 The message is UNSEEN via IMAP
 ....
 
+Entries of `imapUidTable` missing in `messageIdTable` are propagated to
+`messageIdTable` only if the message content (`messageV3` table) still
+exists. Otherwise the entry is left untouched, logged and reported in
+the `errors` of the task, as exposing it would lead to a message that
+can not be read. Such entries typically result from deleted data being
+resurrected, for instance when Cassandra repairs are not run within
+`gc_grace_seconds`.
+
 link:#_endpoints_returning_a_task[More details about endpoints returning
 a task].
 
diff --git a/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc b/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc
index 1f77c27658..0d5df6519c 100644
--- a/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc
+++ b/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc
@@ -28,6 +28,14 @@ The message is SEEN via JMAP
 The message is UNSEEN via IMAP
 ....
 
+Entries of `imapUidTable` missing in `messageIdTable` are propagated to
+`messageIdTable` only if the message content (`messageV3` table) still
+exists. Otherwise the entry is left untouched, logged and reported in
+the `errors` of the task, as exposing it would lead to a message that
+can not be read. Such entries typically result from deleted data being
+resurrected, for instance when Cassandra repairs are not run within
+`gc_grace_seconds`.
+
 link:#_endpoints_returning_a_task[More details about endpoints returning
 a task].
 
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
index d4c98bfe7e..0b2fd7cfe2 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
@@ -38,12 +38,14 @@ import org.apache.james.backends.cassandra.init.configuration.JamesExecutionProf
 import org.apache.james.mailbox.MessageUid;
 import org.apache.james.mailbox.cassandra.ids.CassandraId;
 import org.apache.james.mailbox.cassandra.ids.CassandraMessageId;
+import org.apache.james.mailbox.cassandra.mail.CassandraMessageDAOV3;
 import org.apache.james.mailbox.cassandra.mail.CassandraMessageIdDAO;
 import org.apache.james.mailbox.cassandra.mail.CassandraMessageIdToImapUidDAO;
 import org.apache.james.mailbox.cassandra.mail.CassandraMessageMetadata;
 import org.apache.james.mailbox.model.ComposedMessageId;
 import org.apache.james.mailbox.model.ComposedMessageIdWithMetaData;
 import org.apache.james.mailbox.model.UpdatedFlags;
+import org.apache.james.mailbox.store.mail.MessageMapper.FetchType;
 import org.apache.james.task.Task;
 import org.apache.james.util.ReactorUtils;
 import org.slf4j.Logger;
@@ -110,6 +112,28 @@ public class SolveMessageInconsistenciesService {
         }
     }
 
+    /**
+     * The message is referenced in ImapUid but its content is missing in MessageV3.
+     *
+     * This happens when deleted index entries are resurrected (eg: tombstones purged before being repaired)
+     * while the message content is not. The entry is not propagated to MessageId: doing so would expose
+     * a message that can not be read. It is reported instead.
+     */
+    private static class ImapUidEntryWithoutContent implements Inconsistency {
+        private final CassandraMessageMetadata message;
+
+        private ImapUidEntryWithoutContent(CassandraMessageMetadata message) {
+            this.message = message;
+        }
+
+        @Override
+        public Mono<Task.Result> fix(Context context, CassandraMessageIdToImapUidDAO imapUidDAO, CassandraMessageIdDAO messageIdDAO) {
+            context.addErrors(message.getComposedMessageId().getComposedMessageId());
+            LOGGER.warn("Skipping orphan message in ImapUid as its content is missing in MessageV3: {}", message.getComposedMessageId());
+            return Mono.just(Task.Result.PARTIAL);
+        }
+    }
+
     private static class OutdatedMessageIdEntry implements Inconsistency {
         private final CassandraMessageMetadata messageFromMessageId;
         private final CassandraMessageMetadata messageFromImapUid;
@@ -424,13 +448,15 @@ public class SolveMessageInconsistenciesService {
 
     private final CassandraMessageIdToImapUidDAO messageIdToImapUidDAO;
     private final CassandraMessageIdDAO messageIdDAO;
+    private final CassandraMessageDAOV3 messageDAOV3;
     private final CassandraConfiguration cassandraConfiguration;
 
     @Inject
     SolveMessageInconsistenciesService(CassandraMessageIdToImapUidDAO messageIdToImapUidDAO, CassandraMessageIdDAO messageIdDAO,
-                                       CassandraConfiguration cassandraConfiguration) {
+                                       CassandraMessageDAOV3 messageDAOV3, CassandraConfiguration cassandraConfiguration) {
         this.messageIdToImapUidDAO = messageIdToImapUidDAO;
         this.messageIdDAO = messageIdDAO;
+        this.messageDAOV3 = messageDAOV3;
         this.cassandraConfiguration = cassandraConfiguration;
     }
 
@@ -492,10 +518,22 @@ public class SolveMessageInconsistenciesService {
     private Mono<Inconsistency> detectOrphanImapUidEntry(CassandraId mailboxId, CassandraMessageId messageId) {
         return messageIdToImapUidDAO.retrieve(messageId, Optional.of(mailboxId), chooseReadConsistency())
             .next()
-            .<Inconsistency>map(OrphanImapUidEntry::new)
+            .flatMap(orphanEntry -> hasContent(messageId)
+                .map(hasContent -> {
+                    if (hasContent) {
+                        return new OrphanImapUidEntry(orphanEntry);
+                    }
+                    return new ImapUidEntryWithoutContent(orphanEntry);
+                }))
             .switchIfEmpty(Mono.just(NO_INCONSISTENCY));
     }
 
+    // Upon optimistic consistency, an empty read is retried with the READ execution profile (QUORUM by default)
+    private Mono<Boolean> hasContent(CassandraMessageId messageId) {
+        return messageDAOV3.retrieveMessage(messageId, FetchType.METADATA)
+            .hasElement();
+    }
+
     private Flux<Task.Result> fixInconsistenciesInMessageId(Context context, RunningOptions runningOptions) {
         return messageIdDAO.retrieveAllMessages()
             .transform(ReactorUtils.<CassandraMessageMetadata, Task.Result>throttle()
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
index 36072ad236..2311f55d98 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
@@ -22,6 +22,7 @@ package org.apache.james.mailbox.cassandra.mail.task;
 import static org.apache.james.backends.cassandra.Scenario.Builder.awaitOn;
 import static org.apache.james.backends.cassandra.Scenario.Builder.fail;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 import java.util.Date;
 import java.util.Optional;
@@ -34,18 +35,24 @@ import org.apache.james.backends.cassandra.Scenario;
 import org.apache.james.backends.cassandra.components.CassandraDataDefinition;
 import org.apache.james.backends.cassandra.init.configuration.CassandraConfiguration;
 import org.apache.james.backends.cassandra.versions.CassandraSchemaVersionDataDefinition;
+import org.apache.james.blob.api.BlobStore;
+import org.apache.james.blob.api.BlobStoreCacheCallback;
+import org.apache.james.blob.api.BlobStoreDAO;
 import org.apache.james.blob.api.PlainBlobId;
 import org.apache.james.junit.categories.Unstable;
 import org.apache.james.mailbox.MessageUid;
 import org.apache.james.mailbox.ModSeq;
 import org.apache.james.mailbox.cassandra.ids.CassandraId;
 import org.apache.james.mailbox.cassandra.ids.CassandraMessageId;
+import org.apache.james.mailbox.cassandra.mail.CassandraMessageDAOV3;
 import org.apache.james.mailbox.cassandra.mail.CassandraMessageIdDAO;
 import org.apache.james.mailbox.cassandra.mail.CassandraMessageIdToImapUidDAO;
 import org.apache.james.mailbox.cassandra.mail.CassandraMessageMetadata;
+import org.apache.james.mailbox.cassandra.mail.MessageRepresentation;
 import org.apache.james.mailbox.cassandra.mail.task.SolveMessageInconsistenciesService.Context;
 import org.apache.james.mailbox.cassandra.mail.task.SolveMessageInconsistenciesService.RunningOptions;
 import org.apache.james.mailbox.cassandra.modules.CassandraMessageDataDefinition;
+import org.apache.james.mailbox.model.ByteContent;
 import org.apache.james.mailbox.model.ComposedMessageId;
 import org.apache.james.mailbox.model.ComposedMessageIdWithMetaData;
 import org.apache.james.mailbox.model.ThreadId;
@@ -57,6 +64,8 @@ import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
+import com.google.common.collect.ImmutableList;
+
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
 
@@ -65,11 +74,14 @@ public class SolveMessageInconsistenciesServiceTest {
     private static final CassandraId MAILBOX_ID = CassandraId.timeBased();
     private static final CassandraMessageId MESSAGE_ID_1 = new CassandraMessageId.Factory().fromString("d2bee791-7e63-11ea-883c-95b84008f979");
     private static final CassandraMessageId MESSAGE_ID_2 = new CassandraMessageId.Factory().fromString("eeeeeeee-7e63-11ea-883c-95b84008f979");
+    private static final CassandraMessageId MESSAGE_ID_3 = new CassandraMessageId.Factory().fromString("ffffffff-7e63-11ea-883c-95b84008f979");
     private static final MessageUid MESSAGE_UID_1 = MessageUid.of(1L);
     private static final MessageUid MESSAGE_UID_2 = MessageUid.of(2L);
+    private static final MessageUid MESSAGE_UID_3 = MessageUid.of(3L);
     private static final ModSeq MOD_SEQ_1 = ModSeq.of(1L);
     private static final ModSeq MOD_SEQ_2 = ModSeq.of(2L);
     private static final PlainBlobId HEADER_BLOB_ID = new PlainBlobId.Factory().of("header");
+    private static final PlainBlobId BODY_BLOB_ID = new PlainBlobId.Factory().of("body");
     private static final Date INTERNAL_DATE = new Date(1586000000000L);
     private static final long SIZE = 36L;
     private static final int BODY_START_OCTET = 18;
@@ -102,6 +114,14 @@ public class SolveMessageInconsistenciesServiceTest {
         .threadId(ThreadId.fromBaseMessageId(MESSAGE_ID_2))
         .build());
 
+    // No content is stored for this message within MessageV3
+    private static final CassandraMessageMetadata MESSAGE_3 = metadata(ComposedMessageIdWithMetaData.builder()
+        .composedMessageId(new ComposedMessageId(MAILBOX_ID, MESSAGE_ID_3, MESSAGE_UID_3))
+        .modSeq(MOD_SEQ_1)
+        .flags(new Flags())
+        .threadId(ThreadId.fromBaseMessageId(MESSAGE_ID_3))
+        .build());
+
     private static CassandraMessageMetadata metadata(ComposedMessageIdWithMetaData ids) {
         return CassandraMessageMetadata.builder()
             .ids(ids)
@@ -120,6 +140,7 @@ public class SolveMessageInconsistenciesServiceTest {
 
     CassandraMessageIdToImapUidDAO imapUidDAO;
     CassandraMessageIdDAO messageIdDAO;
+    CassandraMessageDAOV3 messageDAOV3;
     SolveMessageInconsistenciesService testee;
 
     @BeforeEach
@@ -127,7 +148,19 @@ public class SolveMessageInconsistenciesServiceTest {
         PlainBlobId.Factory blobIdFactory = new PlainBlobId.Factory();
         imapUidDAO = new CassandraMessageIdToImapUidDAO(cassandra.getConf(), blobIdFactory, CassandraConfiguration.DEFAULT_CONFIGURATION);
         messageIdDAO = new CassandraMessageIdDAO(cassandra.getConf(), blobIdFactory);
-        testee = new SolveMessageInconsistenciesService(imapUidDAO, messageIdDAO, CassandraConfiguration.DEFAULT_CONFIGURATION);
+        // Only MessageV3 metadata is read: blobs are never accessed
+        messageDAOV3 = new CassandraMessageDAOV3(cassandra.getConf(), cassandra.getTypesProvider(), mock(BlobStore.class),
+            mock(BlobStoreDAO.class), blobIdFactory, CassandraConfiguration.DEFAULT_CONFIGURATION, BlobStoreCacheCallback.NOOP);
+        testee = new SolveMessageInconsistenciesService(imapUidDAO, messageIdDAO, messageDAOV3, CassandraConfiguration.DEFAULT_CONFIGURATION);
+
+        saveContent(MESSAGE_ID_1);
+        saveContent(MESSAGE_ID_2);
+    }
+
+    private void saveContent(CassandraMessageId messageId) {
+        messageDAOV3.save(new MessageRepresentation(messageId, INTERNAL_DATE, SIZE, BODY_START_OCTET,
+                new ByteContent(new byte[0]), ImmutableList.of(), HEADER_BLOB_ID, BODY_BLOB_ID))
+            .block();
     }
 
     @Test
@@ -607,6 +640,37 @@ public class SolveMessageInconsistenciesServiceTest {
                 .build());
     }
 
+    @Test
+    void orphanImapUidEntryWithoutContentShouldNotBePropagated() {
+        imapUidDAO.insert(MESSAGE_3).block();
+
+        testee.fixMessageInconsistencies(new Context(), RunningOptions.DEFAULT).block();
+
+        SoftAssertions.assertSoftly(softly -> {
+            softly.assertThat(imapUidDAO.retrieve(MESSAGE_ID_3, Optional.of(MAILBOX_ID)).collectList().block())
+                .containsExactly(MESSAGE_3);
+            softly.assertThat(messageIdDAO.retrieve(MAILBOX_ID, MESSAGE_UID_3).block())
+                .isEmpty();
+        });
+    }
+
+    @Test
+    void orphanImapUidEntryWithoutContentShouldBeReportedAsError() {
+        Context context = new Context();
+        imapUidDAO.insert(MESSAGE_3).block();
+
+        Task.Result result = testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).block();
+
+        SoftAssertions.assertSoftly(softly -> {
+            softly.assertThat(result).isEqualTo(Task.Result.PARTIAL);
+            softly.assertThat(context.snapshot())
+                .isEqualTo(Context.Snapshot.builder()
+                    .processedImapUidEntries(1)
+                    .errors(MESSAGE_3.getComposedMessageId().getComposedMessageId())
+                    .build());
+        });
+    }
+
     @Test
     void fixMailboxInconsistenciesShouldUpdateContextWhenInconsistentModSeq() {
         Context context = new Context();


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


(james-project) 03/04: [ENHANCEMENT] SolveMessageInconsistencies: offer to cleanup mailbox entry without backing content

Posted by hq...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit f2e995eccf25e8d81da6720eb116d4f43386d4a7
Author: Benoit TELLIER <bt...@linagora.com>
AuthorDate: Wed Sep 30 09:44:25 2026 +0200

    [ENHANCEMENT] SolveMessageInconsistencies: offer to cleanup mailbox entry without backing content
---
 .../operate/webadmin/admin-mailboxes-extend.adoc   |  16 +-
 .../operate/webadmin/admin-messages-extend.adoc    |  16 +-
 .../cassandra/mail/task/RunningOptionsDTO.java     |  15 +-
 .../task/SolveMessageInconsistenciesService.java   | 159 ++++++++++++++++--
 .../mail/task/SolveMessageInconsistenciesTask.java |  12 +-
 ...nconsistenciesTaskAdditionalInformationDTO.java |   9 ++
 .../SolveMessageInconsistenciesServiceTest.java    | 178 +++++++++++++++++++++
 ...essageInconsistenciesTaskSerializationTest.java |   5 +-
 ...ssageInconsistencies.additionalInformation.json |   4 +-
 .../json/solveMessageInconsistencies.task.json     |   3 +-
 ...itMQWebAdminServerIntegrationImmutableTest.java |   2 +
 .../webadmin/routes/RunningOptionsParser.java      |   9 +-
 ...lveMessageInconsistenciesRequestToTaskTest.java |  35 ++++
 13 files changed, 437 insertions(+), 26 deletions(-)

diff --git a/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc b/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc
index df7194bd54..208ca5445c 100644
--- a/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc
+++ b/docs/modules/servers/pages/distributed/operate/webadmin/admin-mailboxes-extend.adoc
@@ -187,6 +187,18 @@ Default is 100.
 This optional parameter must have a strictly positive integer as a value
 and be passed as query parameter.
 
+An admin can also request the removal of the entries whose message
+content is missing:
+
+* `cleanupEntriesWithoutContent` when `true`, the content (`messageV3`
+table) of every `imapUidTable` entry is checked, and entries without
+content are removed from both `imapUidTable` and `messageIdTable`.
+Entries of messages created less than a day ago are never removed.
+Default is `false`, in which case such entries are only reported when
+detected as orphan.
+
+This optional parameter must be passed as query parameter. 
+
 An admin can also specify the reindexing mode it wants to use when
 running the task:
 
@@ -227,8 +239,10 @@ The scheduled task will have the following type
   "addedMessageIdEntries": 1,
   "updatedMessageIdEntries": 0,
   "removedMessageIdEntries": 1,
+  "removedImapUidEntries": 0,
   "runningOptions":{
     "messagesPerSecond": 200,
+    "cleanupEntriesWithoutContent": false,
     "mode":"REBUILD_ALL"
   },
   "fixedInconsistencies": [
@@ -325,4 +339,4 @@ The scheduled task will have the following type
     "errors": ["551f0580-82fb-11ea-970e-f9c83d4cf8c2"],
     "targetFlag": "RECENT"
 }
-....
\ No newline at end of file
+....
diff --git a/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc b/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc
index 0d5df6519c..e484b19150 100644
--- a/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc
+++ b/docs/modules/servers/pages/distributed/operate/webadmin/admin-messages-extend.adoc
@@ -48,6 +48,18 @@ Default is 100.
 This optional parameter must have a strictly positive integer as a value
 and be passed as query parameter.
 
+An admin can also request the removal of the entries whose message
+content is missing:
+
+* `cleanupEntriesWithoutContent` when `true`, the content (`messageV3`
+table) of every `imapUidTable` entry is checked, and entries without
+content are removed from both `imapUidTable` and `messageIdTable`.
+Entries of messages created less than a day ago are never removed.
+Default is `false`, in which case such entries are only reported when
+detected as orphan.
+
+This optional parameter must be passed as query parameter. 
+
 An admin can also specify the reindexing mode it wants to use when
 running the task:
 
@@ -88,8 +100,10 @@ The scheduled task will have the following type
   "addedMessageIdEntries": 1,
   "updatedMessageIdEntries": 0,
   "removedMessageIdEntries": 1,
+  "removedImapUidEntries": 0,
   "runningOptions":{
     "messagesPerSecond": 200,
+    "cleanupEntriesWithoutContent": false,
     "mode":"REBUILD_ALL"
   },
   "fixedInconsistencies": [
@@ -122,4 +136,4 @@ task will eventually fix all issues.
 
 This task could be run safely online and can be scheduled on a recurring
 basis outside of peak traffic by an admin to ensure Cassandra message
-consistency.
\ No newline at end of file
+consistency.
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/RunningOptionsDTO.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/RunningOptionsDTO.java
index 96c21fd43c..a35d05195b 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/RunningOptionsDTO.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/RunningOptionsDTO.java
@@ -28,21 +28,30 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 
 public class RunningOptionsDTO {
     public static RunningOptionsDTO asDTO(SolveMessageInconsistenciesService.RunningOptions domainObject) {
-        return new RunningOptionsDTO(Optional.of(domainObject.getMessagesPerSecond()));
+        return new RunningOptionsDTO(Optional.of(domainObject.getMessagesPerSecond()),
+            Optional.of(domainObject.isCleanupEntriesWithoutContent()));
     }
 
     private final Optional<Integer> messagesPerSecond;
+    private final Optional<Boolean> cleanupEntriesWithoutContent;
 
     @JsonCreator
-    public RunningOptionsDTO(@JsonProperty("messagesPerSecond") Optional<Integer> messagesPerSecond) {
+    public RunningOptionsDTO(@JsonProperty("messagesPerSecond") Optional<Integer> messagesPerSecond,
+                             @JsonProperty("cleanupEntriesWithoutContent") Optional<Boolean> cleanupEntriesWithoutContent) {
         this.messagesPerSecond = messagesPerSecond;
+        this.cleanupEntriesWithoutContent = cleanupEntriesWithoutContent;
     }
 
     public Optional<Integer> getMessagesPerSecond() {
         return messagesPerSecond;
     }
 
+    public Optional<Boolean> getCleanupEntriesWithoutContent() {
+        return cleanupEntriesWithoutContent;
+    }
+
     public RunningOptions asDomainObject() {
-        return new RunningOptions(messagesPerSecond.orElse(RunningOptions.DEFAULT.getMessagesPerSecond()));
+        return new RunningOptions(messagesPerSecond.orElse(RunningOptions.DEFAULT.getMessagesPerSecond()),
+            cleanupEntriesWithoutContent.orElse(RunningOptions.DEFAULT_CLEANUP_ENTRIES_WITHOUT_CONTENT));
     }
 }
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
index 0b2fd7cfe2..4f99d4c734 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
@@ -23,10 +23,13 @@ import static org.apache.james.backends.cassandra.init.configuration.JamesExecut
 import static org.apache.james.backends.cassandra.init.configuration.JamesExecutionProfiles.ConsistencyChoice.WEAK;
 import static org.apache.james.util.ReactorUtils.publishIfPresent;
 
+import java.time.Clock;
 import java.time.Duration;
+import java.time.Instant;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.UUID;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Predicate;
@@ -129,11 +132,64 @@ public class SolveMessageInconsistenciesService {
         @Override
         public Mono<Task.Result> fix(Context context, CassandraMessageIdToImapUidDAO imapUidDAO, CassandraMessageIdDAO messageIdDAO) {
             context.addErrors(message.getComposedMessageId().getComposedMessageId());
-            LOGGER.warn("Skipping orphan message in ImapUid as its content is missing in MessageV3: {}", message.getComposedMessageId());
+            LOGGER.warn("Skipping message in ImapUid as its content is missing in MessageV3: {}", message.getComposedMessageId());
             return Mono.just(Task.Result.PARTIAL);
         }
     }
 
+    /**
+     * Same as {@link ImapUidEntryWithoutContent} but the admin explicitly asked for such entries to be removed.
+     *
+     * The entry is removed from both ImapUid and MessageId. Mailbox counters, quotas and search indexes are not
+     * updated and need to be recomputed.
+     *
+     * The content is checked again right before removal, so that removals are only based on up to date reads.
+     */
+    private static class RemovableImapUidEntryWithoutContent implements Inconsistency {
+        private final CassandraMessageMetadata message;
+        private final Mono<Boolean> hasContent;
+
+        private RemovableImapUidEntryWithoutContent(CassandraMessageMetadata message, Mono<Boolean> hasContent) {
+            this.message = message;
+            this.hasContent = hasContent;
+        }
+
+        @Override
+        public Mono<Task.Result> fix(Context context, CassandraMessageIdToImapUidDAO imapUidDAO, CassandraMessageIdDAO messageIdDAO) {
+            return hasContent
+                .flatMap(contentFound -> {
+                    if (contentFound) {
+                        LOGGER.warn("Content found in MessageV3 upon re-check, skipping removal of {}", message.getComposedMessageId());
+                        return Mono.just(Task.Result.COMPLETED);
+                    }
+                    return remove(context, imapUidDAO, messageIdDAO);
+                })
+                .onErrorResume(error -> {
+                    notifyFailure(context, error);
+                    return Mono.just(Task.Result.PARTIAL);
+                });
+        }
+
+        private Mono<Task.Result> remove(Context context, CassandraMessageIdToImapUidDAO imapUidDAO, CassandraMessageIdDAO messageIdDAO) {
+            ComposedMessageId id = message.getComposedMessageId().getComposedMessageId();
+            return imapUidDAO.delete((CassandraMessageId) id.getMessageId(), (CassandraId) id.getMailboxId())
+                .then(messageIdDAO.delete((CassandraId) id.getMailboxId(), id.getUid()))
+                .then(Mono.fromRunnable(() -> notifySuccess(context)))
+                .thenReturn(Task.Result.COMPLETED);
+        }
+
+        private void notifyFailure(Context context, Throwable error) {
+            context.addErrors(message.getComposedMessageId().getComposedMessageId());
+            LOGGER.error("Failed to remove message without content in MessageV3: {}", message.getComposedMessageId(), error);
+        }
+
+        private void notifySuccess(Context context) {
+            LOGGER.warn("Removed message without content in MessageV3: {}", message.getComposedMessageId());
+            context.incrementRemovedImapUidEntries();
+            context.addFixedInconsistency(message.getComposedMessageId().getComposedMessageId());
+        }
+    }
+
     private static class OutdatedMessageIdEntry implements Inconsistency {
         private final CassandraMessageMetadata messageFromMessageId;
         private final CassandraMessageMetadata messageFromImapUid;
@@ -207,19 +263,30 @@ public class SolveMessageInconsistenciesService {
 
     public static class RunningOptions {
 
+        public static final boolean DEFAULT_CLEANUP_ENTRIES_WITHOUT_CONTENT = false;
         public static final RunningOptions DEFAULT = new RunningOptions(100);
 
         private final int messagesPerSecond;
+        private final boolean cleanupEntriesWithoutContent;
 
         public RunningOptions(int messagesPerSecond) {
+            this(messagesPerSecond, DEFAULT_CLEANUP_ENTRIES_WITHOUT_CONTENT);
+        }
+
+        public RunningOptions(int messagesPerSecond, boolean cleanupEntriesWithoutContent) {
             Preconditions.checkArgument(messagesPerSecond > 0, "'messagesPerSecond' must be strictly positive");
 
             this.messagesPerSecond = messagesPerSecond;
+            this.cleanupEntriesWithoutContent = cleanupEntriesWithoutContent;
         }
 
         public int getMessagesPerSecond() {
             return this.messagesPerSecond;
         }
+
+        public boolean isCleanupEntriesWithoutContent() {
+            return cleanupEntriesWithoutContent;
+        }
     }
 
     public static class Context {
@@ -234,6 +301,7 @@ public class SolveMessageInconsistenciesService {
                 private Optional<Long> addedMessageIdEntries;
                 private Optional<Long> updatedMessageIdEntries;
                 private Optional<Long> removedMessageIdEntries;
+                private Optional<Long> removedImapUidEntries;
                 private ImmutableList.Builder<ComposedMessageId> fixedInconsistencies;
                 private ImmutableList.Builder<ComposedMessageId> errors;
 
@@ -243,6 +311,7 @@ public class SolveMessageInconsistenciesService {
                     addedMessageIdEntries = Optional.empty();
                     updatedMessageIdEntries = Optional.empty();
                     removedMessageIdEntries = Optional.empty();
+                    removedImapUidEntries = Optional.empty();
                     fixedInconsistencies = ImmutableList.builder();
                     errors = ImmutableList.builder();
                 }
@@ -272,6 +341,11 @@ public class SolveMessageInconsistenciesService {
                     return this;
                 }
 
+                public Builder removedImapUidEntries(long count) {
+                    removedImapUidEntries = Optional.of(count);
+                    return this;
+                }
+
                 public Builder addFixedInconsistencies(ComposedMessageId composedMessageId) {
                     fixedInconsistencies.add(composedMessageId);
                     return this;
@@ -289,6 +363,7 @@ public class SolveMessageInconsistenciesService {
                         addedMessageIdEntries.orElse(0L),
                         updatedMessageIdEntries.orElse(0L),
                         removedMessageIdEntries.orElse(0L),
+                        removedImapUidEntries.orElse(0L),
                         fixedInconsistencies.build(),
                         errors.build());
                 }
@@ -299,12 +374,13 @@ public class SolveMessageInconsistenciesService {
             private final long addedMessageIdEntries;
             private final long updatedMessageIdEntries;
             private final long removedMessageIdEntries;
+            private final long removedImapUidEntries;
             private final ImmutableList<ComposedMessageId> fixedInconsistencies;
             private final ImmutableList<ComposedMessageId> errors;
 
             private Snapshot(long processedImapUidEntries, long processedMessageIdEntries,
                              long addedMessageIdEntries, long updatedMessageIdEntries,
-                             long removedMessageIdEntries,
+                             long removedMessageIdEntries, long removedImapUidEntries,
                              ImmutableList<ComposedMessageId> fixedInconsistencies,
                              ImmutableList<ComposedMessageId> errors) {
                 this.processedImapUidEntries = processedImapUidEntries;
@@ -312,6 +388,7 @@ public class SolveMessageInconsistenciesService {
                 this.addedMessageIdEntries = addedMessageIdEntries;
                 this.updatedMessageIdEntries = updatedMessageIdEntries;
                 this.removedMessageIdEntries = removedMessageIdEntries;
+                this.removedImapUidEntries = removedImapUidEntries;
                 this.fixedInconsistencies = fixedInconsistencies;
                 this.errors = errors;
             }
@@ -336,6 +413,10 @@ public class SolveMessageInconsistenciesService {
                 return removedMessageIdEntries;
             }
 
+            public long getRemovedImapUidEntries() {
+                return removedImapUidEntries;
+            }
+
             public ImmutableList<ComposedMessageId> getFixedInconsistencies() {
                 return fixedInconsistencies;
             }
@@ -354,6 +435,7 @@ public class SolveMessageInconsistenciesService {
                         && Objects.equals(this.addedMessageIdEntries, snapshot.addedMessageIdEntries)
                         && Objects.equals(this.updatedMessageIdEntries, snapshot.updatedMessageIdEntries)
                         && Objects.equals(this.removedMessageIdEntries, snapshot.removedMessageIdEntries)
+                        && Objects.equals(this.removedImapUidEntries, snapshot.removedImapUidEntries)
                         && Objects.equals(this.errors, snapshot.errors)
                         && Objects.equals(this.fixedInconsistencies, snapshot.fixedInconsistencies);
                 }
@@ -362,7 +444,7 @@ public class SolveMessageInconsistenciesService {
 
             @Override
             public final int hashCode() {
-                return Objects.hash(processedImapUidEntries, processedMessageIdEntries, addedMessageIdEntries, updatedMessageIdEntries, removedMessageIdEntries, fixedInconsistencies, errors);
+                return Objects.hash(processedImapUidEntries, processedMessageIdEntries, addedMessageIdEntries, updatedMessageIdEntries, removedMessageIdEntries, removedImapUidEntries, fixedInconsistencies, errors);
             }
 
             @Override
@@ -373,6 +455,7 @@ public class SolveMessageInconsistenciesService {
                     .add("addedMessageIdEntries", addedMessageIdEntries)
                     .add("updatedMessageIdEntries", updatedMessageIdEntries)
                     .add("removedMessageIdEntries", removedMessageIdEntries)
+                    .add("removedImapUidEntries", removedImapUidEntries)
                     .add("fixedInconsistencies", fixedInconsistencies)
                     .add("errors", errors)
                     .toString();
@@ -384,21 +467,23 @@ public class SolveMessageInconsistenciesService {
         private final AtomicLong addedMessageIdEntries;
         private final AtomicLong updatedMessageIdEntries;
         private final AtomicLong removedMessageIdEntries;
+        private final AtomicLong removedImapUidEntries;
         private final ConcurrentLinkedDeque<ComposedMessageId> fixedInconsistencies;
         private final ConcurrentLinkedDeque<ComposedMessageId> errors;
 
         Context() {
-            this(new AtomicLong(), new AtomicLong(), new AtomicLong(), new AtomicLong(), new AtomicLong(), ImmutableList.of(), ImmutableList.of());
+            this(new AtomicLong(), new AtomicLong(), new AtomicLong(), new AtomicLong(), new AtomicLong(), new AtomicLong(), ImmutableList.of(), ImmutableList.of());
         }
 
         private Context(AtomicLong processedImapUidEntries, AtomicLong processedMessageIdEntries, AtomicLong addedMessageIdEntries,
-                        AtomicLong updatedMessageIdEntries, AtomicLong removedMessageIdEntries,
+                        AtomicLong updatedMessageIdEntries, AtomicLong removedMessageIdEntries, AtomicLong removedImapUidEntries,
                         Collection<ComposedMessageId> fixedInconsistencies, Collection<ComposedMessageId> errors) {
             this.processedImapUidEntries = processedImapUidEntries;
             this.processedMessageIdEntries = processedMessageIdEntries;
             this.addedMessageIdEntries = addedMessageIdEntries;
             this.updatedMessageIdEntries = updatedMessageIdEntries;
             this.removedMessageIdEntries = removedMessageIdEntries;
+            this.removedImapUidEntries = removedImapUidEntries;
             this.fixedInconsistencies = new ConcurrentLinkedDeque<>(fixedInconsistencies);
             this.errors = new ConcurrentLinkedDeque<>(errors);
         }
@@ -423,6 +508,10 @@ public class SolveMessageInconsistenciesService {
             removedMessageIdEntries.incrementAndGet();
         }
 
+        void incrementRemovedImapUidEntries() {
+            removedImapUidEntries.incrementAndGet();
+        }
+
         void addFixedInconsistency(ComposedMessageId messageId) {
             fixedInconsistencies.add(messageId);
         }
@@ -438,6 +527,7 @@ public class SolveMessageInconsistenciesService {
                 addedMessageIdEntries.get(),
                 updatedMessageIdEntries.get(),
                 removedMessageIdEntries.get(),
+                removedImapUidEntries.get(),
                 ImmutableList.copyOf(fixedInconsistencies),
                 ImmutableList.copyOf(errors));
         }
@@ -445,19 +535,29 @@ public class SolveMessageInconsistenciesService {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(SolveMessageInconsistenciesService.class);
     private static final Duration PERIOD = Duration.ofSeconds(1);
+    // Entries of messages created recently are never removed: their content could be written but not visible yet
+    private static final Duration CLEANUP_GRACE_PERIOD = Duration.ofDays(1);
+    private static final long UUID_EPOCH_OFFSET_IN_100NS = 0x01B21DD213814000L;
 
     private final CassandraMessageIdToImapUidDAO messageIdToImapUidDAO;
     private final CassandraMessageIdDAO messageIdDAO;
     private final CassandraMessageDAOV3 messageDAOV3;
     private final CassandraConfiguration cassandraConfiguration;
+    private final Clock clock;
 
     @Inject
     SolveMessageInconsistenciesService(CassandraMessageIdToImapUidDAO messageIdToImapUidDAO, CassandraMessageIdDAO messageIdDAO,
                                        CassandraMessageDAOV3 messageDAOV3, CassandraConfiguration cassandraConfiguration) {
+        this(messageIdToImapUidDAO, messageIdDAO, messageDAOV3, cassandraConfiguration, Clock.systemUTC());
+    }
+
+    SolveMessageInconsistenciesService(CassandraMessageIdToImapUidDAO messageIdToImapUidDAO, CassandraMessageIdDAO messageIdDAO,
+                                       CassandraMessageDAOV3 messageDAOV3, CassandraConfiguration cassandraConfiguration, Clock clock) {
         this.messageIdToImapUidDAO = messageIdToImapUidDAO;
         this.messageIdDAO = messageIdDAO;
         this.messageDAOV3 = messageDAOV3;
         this.cassandraConfiguration = cassandraConfiguration;
+        this.clock = clock;
     }
 
     private ConsistencyChoice chooseReadConsistency() {
@@ -479,17 +579,52 @@ public class SolveMessageInconsistenciesService {
             .transform(ReactorUtils.<CassandraMessageMetadata, Task.Result>throttle()
                 .elements(runningOptions.getMessagesPerSecond())
                 .per(PERIOD)
-                .forOperation(metaData -> detectInconsistencyInImapUid(metaData)
+                .forOperation(metaData -> detectInconsistencyInImapUid(metaData, runningOptions)
                     .doOnNext(any -> context.incrementProcessedImapUidEntries())
                     .flatMap(inconsistency -> inconsistency.fix(context, messageIdToImapUidDAO, messageIdDAO))));
     }
 
-    private Mono<Inconsistency> detectInconsistencyInImapUid(CassandraMessageMetadata message) {
-        return compareWithMessageIdRecord(message)
+    private Mono<Inconsistency> detectInconsistencyInImapUid(CassandraMessageMetadata message, RunningOptions runningOptions) {
+        return checkContentIfNeeded(message, runningOptions)
+            .switchIfEmpty(Mono.defer(() -> compareWithMessageIdRecord(message, runningOptions)))
             .onErrorResume(error -> Mono.just(new FailedToRetrieveRecord(message)));
     }
 
-    private Mono<Inconsistency> compareWithMessageIdRecord(CassandraMessageMetadata messageFromImapUid) {
+    // Entries resurrected in both ImapUid and MessageId are consistent with each other: the content is thus checked
+    // for every entry when a cleanup is requested.
+    private Mono<Inconsistency> checkContentIfNeeded(CassandraMessageMetadata message, RunningOptions runningOptions) {
+        if (!runningOptions.isCleanupEntriesWithoutContent()) {
+            return Mono.empty();
+        }
+        CassandraMessageId messageId = (CassandraMessageId) message.getComposedMessageId().getComposedMessageId().getMessageId();
+        return hasContent(messageId)
+            .filter(hasContent -> !hasContent)
+            .map(any -> entryWithoutContent(message, runningOptions));
+    }
+
+    private Inconsistency entryWithoutContent(CassandraMessageMetadata message, RunningOptions runningOptions) {
+        CassandraMessageId messageId = (CassandraMessageId) message.getComposedMessageId().getComposedMessageId().getMessageId();
+        if (runningOptions.isCleanupEntriesWithoutContent() && isOutsideGracePeriod(messageId)) {
+            return new RemovableImapUidEntryWithoutContent(message, Mono.defer(() -> hasContent(messageId)));
+        }
+        return new ImapUidEntryWithoutContent(message);
+    }
+
+    private boolean isOutsideGracePeriod(CassandraMessageId messageId) {
+        return creationInstant(messageId)
+            .map(creation -> creation.plus(CLEANUP_GRACE_PERIOD).isBefore(clock.instant()))
+            .orElse(false);
+    }
+
+    private static Optional<Instant> creationInstant(CassandraMessageId messageId) {
+        UUID uuid = messageId.get();
+        if (uuid.version() != 1) {
+            return Optional.empty();
+        }
+        return Optional.of(Instant.ofEpochMilli((uuid.timestamp() - UUID_EPOCH_OFFSET_IN_100NS) / 10_000));
+    }
+
+    private Mono<Inconsistency> compareWithMessageIdRecord(CassandraMessageMetadata messageFromImapUid, RunningOptions runningOptions) {
         ComposedMessageId ids = messageFromImapUid.getComposedMessageId().getComposedMessageId();
         CassandraId mailboxId = (CassandraId) ids.getMailboxId();
         MessageUid uid = ids.getUid();
@@ -504,7 +639,7 @@ public class SolveMessageInconsistenciesService {
                 return detectOutdatedMessageIdEntry(mailboxId, messageId, messageIdRecord);
             })
             .switchIfEmpty(
-                detectOrphanImapUidEntry(mailboxId, messageId));
+                detectOrphanImapUidEntry(mailboxId, messageId, runningOptions));
     }
 
     private Mono<Inconsistency> detectOutdatedMessageIdEntry(CassandraId mailboxId, CassandraMessageId messageId, CassandraMessageMetadata messageIdRecord) {
@@ -515,7 +650,7 @@ public class SolveMessageInconsistenciesService {
             .switchIfEmpty(Mono.just(NO_INCONSISTENCY));
     }
 
-    private Mono<Inconsistency> detectOrphanImapUidEntry(CassandraId mailboxId, CassandraMessageId messageId) {
+    private Mono<Inconsistency> detectOrphanImapUidEntry(CassandraId mailboxId, CassandraMessageId messageId, RunningOptions runningOptions) {
         return messageIdToImapUidDAO.retrieve(messageId, Optional.of(mailboxId), chooseReadConsistency())
             .next()
             .flatMap(orphanEntry -> hasContent(messageId)
@@ -523,7 +658,7 @@ public class SolveMessageInconsistenciesService {
                     if (hasContent) {
                         return new OrphanImapUidEntry(orphanEntry);
                     }
-                    return new ImapUidEntryWithoutContent(orphanEntry);
+                    return entryWithoutContent(orphanEntry, runningOptions);
                 }))
             .switchIfEmpty(Mono.just(NO_INCONSISTENCY));
     }
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTask.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTask.java
index 5a5ec7f64d..b619aa8122 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTask.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTask.java
@@ -44,12 +44,14 @@ public class SolveMessageInconsistenciesTask implements Task {
         private final long addedMessageIdEntries;
         private final long updatedMessageIdEntries;
         private final long removedMessageIdEntries;
+        private final long removedImapUidEntries;
         private final RunningOptions runningOptions;
         private final ImmutableList<MessageInconsistenciesEntry> fixedInconsistencies;
         private final ImmutableList<MessageInconsistenciesEntry> errors;
 
         public Details(Instant instant, long processedImapUidEntries, long processedMessageIdEntries,
-                       long addedMessageIdEntries, long updatedMessageIdEntries, long removedMessageIdEntries, RunningOptions runningOptions,
+                       long addedMessageIdEntries, long updatedMessageIdEntries, long removedMessageIdEntries,
+                       long removedImapUidEntries, RunningOptions runningOptions,
                        ImmutableList<MessageInconsistenciesEntry> fixedInconsistencies, ImmutableList<MessageInconsistenciesEntry> errors) {
             this.instant = instant;
             this.processedImapUidEntries = processedImapUidEntries;
@@ -57,6 +59,7 @@ public class SolveMessageInconsistenciesTask implements Task {
             this.addedMessageIdEntries = addedMessageIdEntries;
             this.updatedMessageIdEntries = updatedMessageIdEntries;
             this.removedMessageIdEntries = removedMessageIdEntries;
+            this.removedImapUidEntries = removedImapUidEntries;
             this.runningOptions = runningOptions;
             this.fixedInconsistencies = fixedInconsistencies;
             this.errors = errors;
@@ -87,6 +90,10 @@ public class SolveMessageInconsistenciesTask implements Task {
             return removedMessageIdEntries;
         }
 
+        public long getRemovedImapUidEntries() {
+            return removedImapUidEntries;
+        }
+
         public RunningOptions getRunningOptions() {
             return runningOptions;
         }
@@ -129,7 +136,8 @@ public class SolveMessageInconsistenciesTask implements Task {
     public Optional<TaskExecutionDetails.AdditionalInformation> details() {
         Snapshot snapshot = context.snapshot();
         return Optional.of(new Details(Clock.systemUTC().instant(), snapshot.getProcessedImapUidEntries(), snapshot.getProcessedMessageIdEntries(),
-            snapshot.getAddedMessageIdEntries(), snapshot.getUpdatedMessageIdEntries(), snapshot.getRemovedMessageIdEntries(), runningOptions,
+            snapshot.getAddedMessageIdEntries(), snapshot.getUpdatedMessageIdEntries(), snapshot.getRemovedMessageIdEntries(),
+            snapshot.getRemovedImapUidEntries(), runningOptions,
             snapshot.getFixedInconsistencies().stream()
                 .map(this::toMessageInconsistenciesEntry)
                 .collect(ImmutableList.toImmutableList()),
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskAdditionalInformationDTO.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskAdditionalInformationDTO.java
index ca1484c383..d22e2c2e86 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskAdditionalInformationDTO.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskAdditionalInformationDTO.java
@@ -44,6 +44,7 @@ public class SolveMessageInconsistenciesTaskAdditionalInformationDTO implements
             details.getAddedMessageIdEntries(),
             details.getUpdatedMessageIdEntries(),
             details.getRemovedMessageIdEntries(),
+            details.getRemovedImapUidEntries(),
             Optional.of(RunningOptionsDTO.asDTO(details.getRunningOptions())),
             details.getFixedInconsistencies(),
             details.getErrors());
@@ -65,6 +66,7 @@ public class SolveMessageInconsistenciesTaskAdditionalInformationDTO implements
     private final long addedMessageIdEntries;
     private final long updatedMessageIdEntries;
     private final long removedMessageIdEntries;
+    private final long removedImapUidEntries;
     private final Optional<RunningOptionsDTO> runningOptions;
     private final ImmutableList<MessageInconsistenciesEntry> fixedInconsistencies;
     private final ImmutableList<MessageInconsistenciesEntry> errors;
@@ -75,6 +77,7 @@ public class SolveMessageInconsistenciesTaskAdditionalInformationDTO implements
                                                                    @JsonProperty("addedMessageIdEntries") long addedMessageIdEntries,
                                                                    @JsonProperty("updatedMessageIdEntries") long updatedMessageIdEntries,
                                                                    @JsonProperty("removedMessageIdEntries")long removedMessageIdEntries,
+                                                                   @JsonProperty("removedImapUidEntries") long removedImapUidEntries,
                                                                    @JsonProperty("runningOptions") Optional<RunningOptionsDTO> runningOptions,
                                                                    @JsonProperty("fixedInconsistencies") ImmutableList<MessageInconsistenciesEntry> fixedInconsistencies,
                                                                    @JsonProperty("errors") ImmutableList<MessageInconsistenciesEntry> errors) {
@@ -85,6 +88,7 @@ public class SolveMessageInconsistenciesTaskAdditionalInformationDTO implements
         this.addedMessageIdEntries = addedMessageIdEntries;
         this.updatedMessageIdEntries = updatedMessageIdEntries;
         this.removedMessageIdEntries = removedMessageIdEntries;
+        this.removedImapUidEntries = removedImapUidEntries;
         this.runningOptions = runningOptions;
         this.fixedInconsistencies = fixedInconsistencies;
         this.errors = errors;
@@ -110,6 +114,10 @@ public class SolveMessageInconsistenciesTaskAdditionalInformationDTO implements
         return removedMessageIdEntries;
     }
 
+    public long getRemovedImapUidEntries() {
+        return removedImapUidEntries;
+    }
+
     public Optional<RunningOptionsDTO> getRunningOptions() {
         return runningOptions;
     }
@@ -139,6 +147,7 @@ public class SolveMessageInconsistenciesTaskAdditionalInformationDTO implements
             addedMessageIdEntries,
             updatedMessageIdEntries,
             removedMessageIdEntries,
+            removedImapUidEntries,
             runningOptions
                 .map(RunningOptionsDTO::asDomainObject)
                 .orElse(RunningOptions.DEFAULT),
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
index 2311f55d98..402f587d55 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
@@ -20,10 +20,14 @@
 package org.apache.james.mailbox.cassandra.mail.task;
 
 import static org.apache.james.backends.cassandra.Scenario.Builder.awaitOn;
+import static org.apache.james.backends.cassandra.Scenario.Builder.executeNormally;
 import static org.apache.james.backends.cassandra.Scenario.Builder.fail;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneOffset;
 import java.util.Date;
 import java.util.Optional;
 
@@ -671,6 +675,180 @@ public class SolveMessageInconsistenciesServiceTest {
         });
     }
 
+    @Nested
+    class CleanupEntriesWithoutContentTest {
+        private static final RunningOptions CLEANUP = new RunningOptions(100, true);
+
+        @Test
+        void cleanupShouldRemoveEntriesWithoutContent() {
+            // Resurrected in both tables: ImapUid and MessageId are consistent with each other
+            imapUidDAO.insert(MESSAGE_3).block();
+            messageIdDAO.insert(MESSAGE_3).block();
+
+            testee.fixMessageInconsistencies(new Context(), CLEANUP).block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(imapUidDAO.retrieveAllMessages().collectList().block())
+                    .isEmpty();
+                softly.assertThat(messageIdDAO.retrieveAllMessages().collectList().block())
+                    .isEmpty();
+            });
+        }
+
+        @Test
+        void cleanupShouldReportRemovedEntries() {
+            Context context = new Context();
+            imapUidDAO.insert(MESSAGE_3).block();
+            messageIdDAO.insert(MESSAGE_3).block();
+
+            Task.Result result = testee.fixMessageInconsistencies(context, CLEANUP).block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(result).isEqualTo(Task.Result.COMPLETED);
+                softly.assertThat(context.snapshot())
+                    .isEqualTo(Context.Snapshot.builder()
+                        .processedImapUidEntries(1)
+                        .processedMessageIdEntries(1)
+                        .removedImapUidEntries(1)
+                        .addFixedInconsistencies(MESSAGE_3.getComposedMessageId().getComposedMessageId())
+                        .build());
+            });
+        }
+
+        @Test
+        void cleanupShouldRemoveOrphanImapUidEntriesWithoutContent() {
+            imapUidDAO.insert(MESSAGE_3).block();
+
+            testee.fixMessageInconsistencies(new Context(), CLEANUP).block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(imapUidDAO.retrieveAllMessages().collectList().block())
+                    .isEmpty();
+                softly.assertThat(messageIdDAO.retrieveAllMessages().collectList().block())
+                    .isEmpty();
+            });
+        }
+
+        @Test
+        void cleanupShouldNotRemoveEntriesWithContent() {
+            imapUidDAO.insert(MESSAGE_1).block();
+            messageIdDAO.insert(MESSAGE_1).block();
+
+            Task.Result result = testee.fixMessageInconsistencies(new Context(), CLEANUP).block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(result).isEqualTo(Task.Result.COMPLETED);
+                softly.assertThat(imapUidDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_1);
+                softly.assertThat(messageIdDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_1);
+            });
+        }
+
+        @Test
+        void cleanupShouldNotRemoveRecentEntries() {
+            // One hour after MESSAGE_ID_3 creation: within the grace period
+            Clock clock = Clock.fixed(Instant.parse("2020-04-14T16:24:15Z"), ZoneOffset.UTC);
+            testee = new SolveMessageInconsistenciesService(imapUidDAO, messageIdDAO, messageDAOV3, CassandraConfiguration.DEFAULT_CONFIGURATION, clock);
+            Context context = new Context();
+            imapUidDAO.insert(MESSAGE_3).block();
+            messageIdDAO.insert(MESSAGE_3).block();
+
+            Task.Result result = testee.fixMessageInconsistencies(context, CLEANUP).block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(result).isEqualTo(Task.Result.PARTIAL);
+                softly.assertThat(context.snapshot().getErrors())
+                    .containsExactly(MESSAGE_3.getComposedMessageId().getComposedMessageId());
+                softly.assertThat(imapUidDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+                softly.assertThat(messageIdDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+            });
+        }
+
+        @Test
+        void cleanupShouldNotRemoveEntriesWhoseContentAppearsBeforeRemoval(CassandraCluster cassandra) throws Exception {
+            imapUidDAO.insert(MESSAGE_3).block();
+            messageIdDAO.insert(MESSAGE_3).block();
+
+            // The detection read is executed normally, the re-check read right before the removal is blocked
+            Scenario.Barrier barrier = new Scenario.Barrier(1);
+            cassandra.getConf()
+                .registerScenario(
+                    executeNormally()
+                        .times(1)
+                        .whenQueryStartsWith("SELECT * FROM messagev3 WHERE messageid=:messageid"),
+                    awaitOn(barrier)
+                        .thenExecuteNormally()
+                        .times(1)
+                        .whenQueryStartsWith("SELECT * FROM messagev3 WHERE messageid=:messageid"));
+
+            Context context = new Context();
+            Mono<Task.Result> task = testee.fixMessageInconsistencies(context, CLEANUP).subscribeOn(Schedulers.boundedElastic()).cache();
+            task.subscribe();
+
+            barrier.awaitCaller();
+            saveContent(MESSAGE_ID_3);
+            barrier.releaseCaller();
+
+            Task.Result result = task.block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(result).isEqualTo(Task.Result.COMPLETED);
+                softly.assertThat(context.snapshot().getRemovedImapUidEntries()).isZero();
+                softly.assertThat(imapUidDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+                softly.assertThat(messageIdDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+            });
+        }
+
+        @Test
+        void cleanupShouldNotRemoveEntriesWhenContentReCheckFails(CassandraCluster cassandra) {
+            imapUidDAO.insert(MESSAGE_3).block();
+            messageIdDAO.insert(MESSAGE_3).block();
+
+            cassandra.getConf()
+                .registerScenario(
+                    executeNormally()
+                        .times(1)
+                        .whenQueryStartsWith("SELECT * FROM messagev3 WHERE messageid=:messageid"),
+                    fail()
+                        .times(1)
+                        .whenQueryStartsWith("SELECT * FROM messagev3 WHERE messageid=:messageid"));
+
+            Context context = new Context();
+            Task.Result result = testee.fixMessageInconsistencies(context, CLEANUP).block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(result).isEqualTo(Task.Result.PARTIAL);
+                softly.assertThat(context.snapshot().getErrors())
+                    .containsExactly(MESSAGE_3.getComposedMessageId().getComposedMessageId());
+                softly.assertThat(imapUidDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+                softly.assertThat(messageIdDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+            });
+        }
+
+        @Test
+        void entriesWithoutContentShouldNotBeRemovedWhenNoCleanup() {
+            imapUidDAO.insert(MESSAGE_3).block();
+            messageIdDAO.insert(MESSAGE_3).block();
+
+            Task.Result result = testee.fixMessageInconsistencies(new Context(), RunningOptions.DEFAULT).block();
+
+            SoftAssertions.assertSoftly(softly -> {
+                softly.assertThat(result).isEqualTo(Task.Result.COMPLETED);
+                softly.assertThat(imapUidDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+                softly.assertThat(messageIdDAO.retrieveAllMessages().collectList().block())
+                    .containsExactly(MESSAGE_3);
+            });
+        }
+    }
+
     @Test
     void fixMailboxInconsistenciesShouldUpdateContextWhenInconsistentModSeq() {
         Context context = new Context();
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskSerializationTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskSerializationTest.java
index cdd2f37013..7bda5bba06 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskSerializationTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesTaskSerializationTest.java
@@ -37,7 +37,7 @@ import com.google.common.collect.ImmutableList;
 public class SolveMessageInconsistenciesTaskSerializationTest {
 
     private static final SolveMessageInconsistenciesService SERVICE = mock(SolveMessageInconsistenciesService.class);
-    private static final SolveMessageInconsistenciesTask TASK = new SolveMessageInconsistenciesTask(SERVICE, new RunningOptions(2));
+    private static final SolveMessageInconsistenciesTask TASK = new SolveMessageInconsistenciesTask(SERVICE, new RunningOptions(2, true));
 
     private static final Instant INSTANT = Instant.parse("2007-12-03T10:15:30.00Z");
     private static final String MAILBOX_ID = "551f0580-82fb-11ea-970e-f9c83d4cf8c2";
@@ -61,7 +61,7 @@ public class SolveMessageInconsistenciesTaskSerializationTest {
         .messageId(MESSAGE_ID_3)
         .messageUid(MESSAGE_UID_3);
 
-    private static final Details DETAILS = new SolveMessageInconsistenciesTask.Details(INSTANT, 2, 1, 1, 0, 1, new SolveMessageInconsistenciesService.RunningOptions(2), ImmutableList.of(MESSAGE_1, MESSAGE_2), ImmutableList.of(MESSAGE_3));
+    private static final Details DETAILS = new SolveMessageInconsistenciesTask.Details(INSTANT, 2, 1, 1, 0, 1, 1, new SolveMessageInconsistenciesService.RunningOptions(2, true), ImmutableList.of(MESSAGE_1, MESSAGE_2), ImmutableList.of(MESSAGE_3));
 
     @Test
     void taskShouldBeSerializable() throws Exception {
@@ -108,6 +108,7 @@ public class SolveMessageInconsistenciesTaskSerializationTest {
             1,
             0,
             1,
+            0,
             RunningOptions.DEFAULT,
             ImmutableList.of(MESSAGE_1, MESSAGE_2),
             ImmutableList.of(MESSAGE_3)
diff --git a/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.additionalInformation.json b/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.additionalInformation.json
index d6516879f5..92046a2b1c 100644
--- a/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.additionalInformation.json
+++ b/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.additionalInformation.json
@@ -6,8 +6,10 @@
   "addedMessageIdEntries": 1,
   "updatedMessageIdEntries": 0,
   "removedMessageIdEntries": 1,
+  "removedImapUidEntries": 1,
   "runningOptions":{
-      "messagesPerSecond": 2
+      "messagesPerSecond": 2,
+      "cleanupEntriesWithoutContent": true
   },
   "fixedInconsistencies": [
     {
diff --git a/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.task.json b/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.task.json
index 92b1eddd5e..5eb82d4eb1 100644
--- a/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.task.json
+++ b/mailbox/cassandra/src/test/resources/json/solveMessageInconsistencies.task.json
@@ -1,6 +1,7 @@
 {
   "type":"solve-message-inconsistencies",
   "runningOptions":{
-    "messagesPerSecond":2
+    "messagesPerSecond":2,
+    "cleanupEntriesWithoutContent":true
   }
 }
\ No newline at end of file
diff --git a/server/protocols/webadmin-integration-test/distributed-webadmin-integration-test/src/test/java/org/apache/james/webadmin/integration/rabbitmq/RabbitMQWebAdminServerIntegrationImmutableTest.java b/server/protocols/webadmin-integration-test/distributed-webadmin-integration-test/src/test/java/org/apache/james/webadmin/integration/rabbitmq/RabbitMQWebAdminServerIntegrationImmutableTest.java
index 3591a21b4c..e0dc7922ee 100644
--- a/server/protocols/webadmin-integration-test/distributed-webadmin-integration-test/src/test/java/org/apache/james/webadmin/integration/rabbitmq/RabbitMQWebAdminServerIntegrationImmutableTest.java
+++ b/server/protocols/webadmin-integration-test/distributed-webadmin-integration-test/src/test/java/org/apache/james/webadmin/integration/rabbitmq/RabbitMQWebAdminServerIntegrationImmutableTest.java
@@ -118,7 +118,9 @@ class RabbitMQWebAdminServerIntegrationImmutableTest extends WebAdminServerInteg
             .body("additionalInformation.addedMessageIdEntries", is(0))
             .body("additionalInformation.updatedMessageIdEntries", is(0))
             .body("additionalInformation.removedMessageIdEntries", is(0))
+            .body("additionalInformation.removedImapUidEntries", is(0))
             .body("additionalInformation.runningOptions.messagesPerSecond", is(100))
+            .body("additionalInformation.runningOptions.cleanupEntriesWithoutContent", is(false))
             .body("additionalInformation.fixedInconsistencies", hasSize(0))
             .body("additionalInformation.errors", hasSize(0));
     }
diff --git a/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/RunningOptionsParser.java b/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/RunningOptionsParser.java
index 9d689224cb..bb74146519 100644
--- a/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/RunningOptionsParser.java
+++ b/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/RunningOptionsParser.java
@@ -27,9 +27,12 @@ import spark.Request;
 
 public class RunningOptionsParser {
     public static RunningOptions parse(Request request) {
-        return intQueryParameter(request, "messagesPerSecond")
-            .map(RunningOptions::new)
-            .orElse(RunningOptions.DEFAULT);
+        int messagesPerSecond = intQueryParameter(request, "messagesPerSecond")
+            .orElse(RunningOptions.DEFAULT.getMessagesPerSecond());
+        boolean cleanupEntriesWithoutContent = Optional.ofNullable(request.queryParams("cleanupEntriesWithoutContent"))
+            .map(Boolean::parseBoolean)
+            .orElse(RunningOptions.DEFAULT_CLEANUP_ENTRIES_WITHOUT_CONTENT);
+        return new RunningOptions(messagesPerSecond, cleanupEntriesWithoutContent);
     }
 
     public static Optional<Integer> intQueryParameter(Request request, String queryParameter) {
diff --git a/server/protocols/webadmin/webadmin-cassandra/src/test/java/org/apache/james/webadmin/routes/SolveMessageInconsistenciesRequestToTaskTest.java b/server/protocols/webadmin/webadmin-cassandra/src/test/java/org/apache/james/webadmin/routes/SolveMessageInconsistenciesRequestToTaskTest.java
index cfc34eef28..3c22a34e86 100644
--- a/server/protocols/webadmin/webadmin-cassandra/src/test/java/org/apache/james/webadmin/routes/SolveMessageInconsistenciesRequestToTaskTest.java
+++ b/server/protocols/webadmin/webadmin-cassandra/src/test/java/org/apache/james/webadmin/routes/SolveMessageInconsistenciesRequestToTaskTest.java
@@ -226,4 +226,39 @@ class SolveMessageInconsistenciesRequestToTaskTest {
             .body("type", is("solve-message-inconsistencies"))
             .body("additionalInformation.runningOptions.messagesPerSecond", is(20));
     }
+
+    @Test
+    void cleanupEntriesWithoutContentShouldBePartOfTaskDetails() {
+        String taskId = with()
+            .queryParam("action", "SolveInconsistencies")
+            .queryParam("cleanupEntriesWithoutContent", "true")
+        .post()
+            .jsonPath()
+            .get("taskId");
+
+        given()
+            .basePath(TasksRoutes.BASE)
+        .when()
+            .get(taskId + "/await")
+        .then()
+            .body("taskId", is(taskId))
+            .body("additionalInformation.runningOptions.cleanupEntriesWithoutContent", is(true));
+    }
+
+    @Test
+    void cleanupEntriesWithoutContentShouldBeDisabledByDefault() {
+        String taskId = with()
+            .queryParam("action", "SolveInconsistencies")
+        .post()
+            .jsonPath()
+            .get("taskId");
+
+        given()
+            .basePath(TasksRoutes.BASE)
+        .when()
+            .get(taskId + "/await")
+        .then()
+            .body("taskId", is(taskId))
+            .body("additionalInformation.runningOptions.cleanupEntriesWithoutContent", is(false));
+    }
 }


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


(james-project) 04/04: Adapt #3219 to branch 3.9.x

Posted by hq...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 172ac9cc69f5996471974cc2e322d04ca940cb2c
Author: Benoit TELLIER <bt...@linagora.com>
AuthorDate: Thu Oct 1 13:05:20 2026 +0200

    Adapt #3219 to branch 3.9.x
---
 .../mail/task/SolveMessageInconsistenciesServiceTest.java          | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
index 402f587d55..aec071800b 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
@@ -40,8 +40,6 @@ import org.apache.james.backends.cassandra.components.CassandraDataDefinition;
 import org.apache.james.backends.cassandra.init.configuration.CassandraConfiguration;
 import org.apache.james.backends.cassandra.versions.CassandraSchemaVersionDataDefinition;
 import org.apache.james.blob.api.BlobStore;
-import org.apache.james.blob.api.BlobStoreCacheCallback;
-import org.apache.james.blob.api.BlobStoreDAO;
 import org.apache.james.blob.api.PlainBlobId;
 import org.apache.james.junit.categories.Unstable;
 import org.apache.james.mailbox.MessageUid;
@@ -60,6 +58,7 @@ import org.apache.james.mailbox.model.ByteContent;
 import org.apache.james.mailbox.model.ComposedMessageId;
 import org.apache.james.mailbox.model.ComposedMessageIdWithMetaData;
 import org.apache.james.mailbox.model.ThreadId;
+import org.apache.james.mailbox.store.mail.model.impl.PropertyBuilder;
 import org.apache.james.task.Task;
 import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.BeforeEach;
@@ -154,7 +153,7 @@ public class SolveMessageInconsistenciesServiceTest {
         messageIdDAO = new CassandraMessageIdDAO(cassandra.getConf(), blobIdFactory);
         // Only MessageV3 metadata is read: blobs are never accessed
         messageDAOV3 = new CassandraMessageDAOV3(cassandra.getConf(), cassandra.getTypesProvider(), mock(BlobStore.class),
-            mock(BlobStoreDAO.class), blobIdFactory, CassandraConfiguration.DEFAULT_CONFIGURATION, BlobStoreCacheCallback.NOOP);
+            blobIdFactory);
         testee = new SolveMessageInconsistenciesService(imapUidDAO, messageIdDAO, messageDAOV3, CassandraConfiguration.DEFAULT_CONFIGURATION);
 
         saveContent(MESSAGE_ID_1);
@@ -163,7 +162,7 @@ public class SolveMessageInconsistenciesServiceTest {
 
     private void saveContent(CassandraMessageId messageId) {
         messageDAOV3.save(new MessageRepresentation(messageId, INTERNAL_DATE, SIZE, BODY_START_OCTET,
-                new ByteContent(new byte[0]), ImmutableList.of(), HEADER_BLOB_ID, BODY_BLOB_ID))
+                new ByteContent(new byte[0]), new PropertyBuilder().build(), ImmutableList.of(), HEADER_BLOB_ID, BODY_BLOB_ID))
             .block();
     }
 


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


(james-project) 01/04: [FIX] Re-enable SolveMessageInconsistenciesServiceTest

Posted by hq...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit fdb22d5d9c71e12b6eb58f12810fae4a71eb2887
Author: Benoit TELLIER <bt...@linagora.com>
AuthorDate: Wed Sep 30 09:18:59 2026 +0200

    [FIX] Re-enable SolveMessageInconsistenciesServiceTest
    
    The test was commented out by JAMES-3576 (message denormalization) and
    never restored. Adapt it to the current DAO APIs and query strings.
    
    Doing so reveals that outdated messageIdTable entries were not fully
    fixed: flags were diffed against an empty set, so flags only present in
    the stale record (eg \Seen) were never removed.
---
 .../task/SolveMessageInconsistenciesService.java   |   4 +-
 .../SolveMessageInconsistenciesServiceTest.java    | 149 ++++++++++++++-------
 2 files changed, 101 insertions(+), 52 deletions(-)

diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
index afcb64b93a..d4c98bfe7e 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesService.java
@@ -32,7 +32,6 @@ import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Predicate;
 
 import jakarta.inject.Inject;
-import jakarta.mail.Flags;
 
 import org.apache.james.backends.cassandra.init.configuration.CassandraConfiguration;
 import org.apache.james.backends.cassandra.init.configuration.JamesExecutionProfiles.ConsistencyChoice;
@@ -125,7 +124,8 @@ public class SolveMessageInconsistenciesService {
             ComposedMessageIdWithMetaData id = messageFromImapUid.getComposedMessageId();
             return messageIdDAO.updateMetadata(id.getComposedMessageId(),
                     UpdatedFlags.builder()
-                        .oldFlags(new Flags())
+                        // The update only writes flag changes: diff against the stale record so that extra flags get removed
+                        .oldFlags(messageFromMessageId.getComposedMessageId().getFlags())
                         .newFlags(id.getFlags())
                         .modSeq(id.getModSeq())
                         .messageId(id.getComposedMessageId().getMessageId())
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
index decabe8663..36072ad236 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/SolveMessageInconsistenciesServiceTest.java
@@ -19,7 +19,47 @@
 
 package org.apache.james.mailbox.cassandra.mail.task;
 
-/*
+import static org.apache.james.backends.cassandra.Scenario.Builder.awaitOn;
+import static org.apache.james.backends.cassandra.Scenario.Builder.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Date;
+import java.util.Optional;
+
+import jakarta.mail.Flags;
+
+import org.apache.james.backends.cassandra.CassandraCluster;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.Scenario;
+import org.apache.james.backends.cassandra.components.CassandraDataDefinition;
+import org.apache.james.backends.cassandra.init.configuration.CassandraConfiguration;
+import org.apache.james.backends.cassandra.versions.CassandraSchemaVersionDataDefinition;
+import org.apache.james.blob.api.PlainBlobId;
+import org.apache.james.junit.categories.Unstable;
+import org.apache.james.mailbox.MessageUid;
+import org.apache.james.mailbox.ModSeq;
+import org.apache.james.mailbox.cassandra.ids.CassandraId;
+import org.apache.james.mailbox.cassandra.ids.CassandraMessageId;
+import org.apache.james.mailbox.cassandra.mail.CassandraMessageIdDAO;
+import org.apache.james.mailbox.cassandra.mail.CassandraMessageIdToImapUidDAO;
+import org.apache.james.mailbox.cassandra.mail.CassandraMessageMetadata;
+import org.apache.james.mailbox.cassandra.mail.task.SolveMessageInconsistenciesService.Context;
+import org.apache.james.mailbox.cassandra.mail.task.SolveMessageInconsistenciesService.RunningOptions;
+import org.apache.james.mailbox.cassandra.modules.CassandraMessageDataDefinition;
+import org.apache.james.mailbox.model.ComposedMessageId;
+import org.apache.james.mailbox.model.ComposedMessageIdWithMetaData;
+import org.apache.james.mailbox.model.ThreadId;
+import org.apache.james.task.Task;
+import org.assertj.core.api.SoftAssertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+
 public class SolveMessageInconsistenciesServiceTest {
 
     private static final CassandraId MAILBOX_ID = CassandraId.timeBased();
@@ -29,40 +69,54 @@ public class SolveMessageInconsistenciesServiceTest {
     private static final MessageUid MESSAGE_UID_2 = MessageUid.of(2L);
     private static final ModSeq MOD_SEQ_1 = ModSeq.of(1L);
     private static final ModSeq MOD_SEQ_2 = ModSeq.of(2L);
+    private static final PlainBlobId HEADER_BLOB_ID = new PlainBlobId.Factory().of("header");
+    private static final Date INTERNAL_DATE = new Date(1586000000000L);
+    private static final long SIZE = 36L;
+    private static final int BODY_START_OCTET = 18;
 
-    private static final ComposedMessageIdWithMetaData MESSAGE_1 = ComposedMessageIdWithMetaData.builder()
+    private static final CassandraMessageMetadata MESSAGE_1 = metadata(ComposedMessageIdWithMetaData.builder()
         .composedMessageId(new ComposedMessageId(MAILBOX_ID, MESSAGE_ID_1, MESSAGE_UID_1))
         .modSeq(MOD_SEQ_1)
         .flags(new Flags())
         .threadId(ThreadId.fromBaseMessageId(MESSAGE_ID_1))
-        .build();
+        .build());
 
-    private static final ComposedMessageIdWithMetaData MESSAGE_1_WITH_SEEN_FLAG = ComposedMessageIdWithMetaData.builder()
+    private static final CassandraMessageMetadata MESSAGE_1_WITH_SEEN_FLAG = metadata(ComposedMessageIdWithMetaData.builder()
         .composedMessageId(new ComposedMessageId(MAILBOX_ID, MESSAGE_ID_1, MESSAGE_UID_1))
         .modSeq(MOD_SEQ_1)
         .flags(new Flags(Flags.Flag.SEEN))
         .threadId(ThreadId.fromBaseMessageId(MESSAGE_ID_1))
-        .build();
+        .build());
 
-    private static final ComposedMessageIdWithMetaData MESSAGE_1_WITH_MOD_SEQ_2 = ComposedMessageIdWithMetaData.builder()
+    private static final CassandraMessageMetadata MESSAGE_1_WITH_MOD_SEQ_2 = metadata(ComposedMessageIdWithMetaData.builder()
         .composedMessageId(new ComposedMessageId(MAILBOX_ID, MESSAGE_ID_1, MESSAGE_UID_1))
         .modSeq(MOD_SEQ_2)
         .flags(new Flags(Flags.Flag.SEEN))
         .threadId(ThreadId.fromBaseMessageId(MESSAGE_ID_1))
-        .build();
+        .build());
 
-    private static final ComposedMessageIdWithMetaData MESSAGE_2 = ComposedMessageIdWithMetaData.builder()
+    private static final CassandraMessageMetadata MESSAGE_2 = metadata(ComposedMessageIdWithMetaData.builder()
         .composedMessageId(new ComposedMessageId(MAILBOX_ID, MESSAGE_ID_2, MESSAGE_UID_2))
         .modSeq(MOD_SEQ_2)
         .flags(new Flags())
         .threadId(ThreadId.fromBaseMessageId(MESSAGE_ID_2))
-        .build();
+        .build());
+
+    private static CassandraMessageMetadata metadata(ComposedMessageIdWithMetaData ids) {
+        return CassandraMessageMetadata.builder()
+            .ids(ids)
+            .internalDate(INTERNAL_DATE)
+            .bodyStartOctet(BODY_START_OCTET)
+            .size(SIZE)
+            .headerContent(Optional.of(HEADER_BLOB_ID))
+            .build();
+    }
 
     @RegisterExtension
     static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(
-        CassandraModule.aggregateModules(
-            CassandraSchemaVersionModule.MODULE,
-            CassandraMessageModule.MODULE));
+        CassandraDataDefinition.aggregateModules(
+            CassandraSchemaVersionDataDefinition.MODULE,
+            CassandraMessageDataDefinition.MODULE));
 
     CassandraMessageIdToImapUidDAO imapUidDAO;
     CassandraMessageIdDAO messageIdDAO;
@@ -70,12 +124,9 @@ public class SolveMessageInconsistenciesServiceTest {
 
     @BeforeEach
     void setUp(CassandraCluster cassandra) {
-        imapUidDAO = new CassandraMessageIdToImapUidDAO(
-            cassandra.getConf(),
-            cassandraCluster.getCassandraConsistenciesConfiguration(),
-            new CassandraMessageId.Factory(),
-            CassandraConfiguration.DEFAULT_CONFIGURATION);
-        messageIdDAO = new CassandraMessageIdDAO(cassandra.getConf(), blobIdFactory, new CassandraMessageId.Factory());
+        PlainBlobId.Factory blobIdFactory = new PlainBlobId.Factory();
+        imapUidDAO = new CassandraMessageIdToImapUidDAO(cassandra.getConf(), blobIdFactory, CassandraConfiguration.DEFAULT_CONFIGURATION);
+        messageIdDAO = new CassandraMessageIdDAO(cassandra.getConf(), blobIdFactory);
         testee = new SolveMessageInconsistenciesService(imapUidDAO, messageIdDAO, CassandraConfiguration.DEFAULT_CONFIGURATION);
     }
 
@@ -140,10 +191,10 @@ public class SolveMessageInconsistenciesServiceTest {
                 .registerScenario(awaitOn(barrier)
                     .thenExecuteNormally()
                     .times(1)
-                    .whenQueryStartsWith("SELECT messageId,mailboxId,uid,threadId,modSeq,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid;"));
+                    .whenQueryStartsWith("SELECT * FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
             Context context = new Context();
-            Mono<Task.Result> task = testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).subscribeOn(Schedulers.elastic()).cache();
+            Mono<Task.Result> task = testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).subscribeOn(Schedulers.boundedElastic()).cache();
             task.subscribe();
 
             barrier.awaitCaller();
@@ -169,10 +220,10 @@ public class SolveMessageInconsistenciesServiceTest {
                 .registerScenario(awaitOn(barrier)
                     .thenExecuteNormally()
                     .times(1)
-                    .whenQueryStartsWith("SELECT messageId,mailboxId,uid,threadId,modSeq,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid;"));
+                    .whenQueryStartsWith("SELECT * FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
             Context context = new Context();
-            Mono<Task.Result> task = testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).subscribeOn(Schedulers.elastic()).cache();
+            Mono<Task.Result> task = testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).subscribeOn(Schedulers.boundedElastic()).cache();
             task.subscribe();
 
             barrier.awaitCaller();
@@ -260,7 +311,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .forever()
-                        .whenQueryStartsWith("INSERT INTO messageIdTable (mailboxId,uid,threadId,modSeq,messageId,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags) VALUES (:mailboxId,:uid,:threadId,:modSeq,:messageId,:flagAnswered,:flagDeleted,:flagDraft,:flagFlagged,:flagRecent,:flagSeen,:flagUser,:userFlags)"));
+                        .whenQueryStartsWith("UPDATE messageidtable SET threadid=:threadid, messageid=:messageid"));
 
                 assertThat(testee.fixMessageInconsistencies(new Context(), RunningOptions.DEFAULT).block())
                     .isEqualTo(Task.Result.PARTIAL);
@@ -274,7 +325,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("INSERT INTO messageIdTable (mailboxId,uid,threadId,modSeq,messageId,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags) VALUES (:mailboxId,:uid,:threadId,:modSeq,:messageId,:flagAnswered,:flagDeleted,:flagDraft,:flagFlagged,:flagRecent,:flagSeen,:flagUser,:userFlags)"));
+                        .whenQueryStartsWith("UPDATE messageidtable SET threadid=:threadid, messageid=:messageid"));
 
                 assertThat(testee.fixMessageInconsistencies(new Context(), RunningOptions.DEFAULT).block())
                     .isEqualTo(Task.Result.PARTIAL);
@@ -288,7 +339,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("INSERT INTO messageIdTable (mailboxId,uid,modSeq,messageId,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags) VALUES (:mailboxId,:uid,:modSeq,:messageId,:flagAnswered,:flagDeleted,:flagDraft,:flagFlagged,:flagRecent,:flagSeen,:flagUser,:userFlags)"));
+                        .whenQueryStartsWith("UPDATE messageidtable SET threadid=:threadid, messageid=:messageid"));
 
                 testee.fixMessageInconsistencies(new Context(), new RunningOptions(1)).block();
 
@@ -309,14 +360,14 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("SELECT messageId,mailboxId,uid,threadId,modSeq,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid;"));
+                        .whenQueryStartsWith("SELECT * FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
                 testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).block();
 
                 assertThat(context.snapshot())
                     .isEqualTo(Context.Snapshot.builder()
                         .processedImapUidEntries(1)
-                        .errors(MESSAGE_1.getComposedMessageId())
+                        .errors(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                         .build());
             }
 
@@ -329,14 +380,14 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("SELECT messageId,mailboxId,uid,threadId,modSeq,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid"));
+                        .whenQueryStartsWith("SELECT * FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
                 testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).block();
 
                 assertThat(context.snapshot())
                     .isEqualTo(Context.Snapshot.builder()
                         .processedImapUidEntries(1)
-                        .errors(MESSAGE_1.getComposedMessageId())
+                        .errors(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                         .build());
             }
         }
@@ -362,12 +413,10 @@ public class SolveMessageInconsistenciesServiceTest {
                 .registerScenario(awaitOn(barrier)
                     .thenExecuteNormally()
                     .times(1)
-                    .whenQueryStartsWith("SELECT messageId,mailboxId,uid,threadId,modSeq,flagAnswered,flagDeleted," +
-                        "flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags FROM messageIdTable " +
-                        "WHERE mailboxId=:mailboxId AND uid=:uid;"));
+                    .whenQueryStartsWith("SELECT * FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
             Context context = new Context();
-            Mono<Task.Result> task = testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).subscribeOn(Schedulers.elastic()).cache();
+            Mono<Task.Result> task = testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).subscribeOn(Schedulers.boundedElastic()).cache();
             task.subscribe();
 
             barrier.awaitCaller();
@@ -435,7 +484,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .forever()
-                        .whenQueryStartsWith("DELETE FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid"));
+                        .whenQueryStartsWith("DELETE FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
                 assertThat(testee.fixMessageInconsistencies(new Context(), RunningOptions.DEFAULT).block())
                     .isEqualTo(Task.Result.PARTIAL);
@@ -449,7 +498,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("DELETE FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid"));
+                        .whenQueryStartsWith("DELETE FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
                 assertThat(testee.fixMessageInconsistencies(new Context(), RunningOptions.DEFAULT).block())
                     .isEqualTo(Task.Result.PARTIAL);
@@ -463,7 +512,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("DELETE FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid;"));
+                        .whenQueryStartsWith("DELETE FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
                 testee.fixMessageInconsistencies(new Context(), new RunningOptions(1)).block();
 
@@ -484,14 +533,14 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("SELECT messageId,mailboxId,uid,threadId,modSeq,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid"));
+                        .whenQueryStartsWith("SELECT * FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
                 testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).block();
 
                 assertThat(context.snapshot())
                     .isEqualTo(Context.Snapshot.builder()
                         .processedMessageIdEntries(1)
-                        .errors(MESSAGE_1.getComposedMessageId())
+                        .errors(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                         .build());
             }
 
@@ -504,14 +553,14 @@ public class SolveMessageInconsistenciesServiceTest {
                 cassandra.getConf()
                     .registerScenario(fail()
                         .times(1)
-                        .whenQueryStartsWith("SELECT messageId,mailboxId,uid,threadId,modSeq,flagAnswered,flagDeleted,flagDraft,flagFlagged,flagRecent,flagSeen,flagUser,userFlags FROM imapUidTable WHERE messageid=:messageid AND mailboxid=:mailboxid"));
+                        .whenQueryStartsWith("SELECT * FROM imapuidtable WHERE messageid=:messageid AND mailboxid=:mailboxid"));
 
                 testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).block();
 
                 assertThat(context.snapshot())
                     .isEqualTo(Context.Snapshot.builder()
                         .processedMessageIdEntries(1)
-                        .errors(MESSAGE_1.getComposedMessageId())
+                        .errors(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                         .build());
             }
         }
@@ -523,7 +572,7 @@ public class SolveMessageInconsistenciesServiceTest {
 
         testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).block();
 
-        assertThat(context.snapshot()).isEqualToComparingFieldByFieldRecursively(new Context().snapshot());
+        assertThat(context.snapshot()).isEqualTo(new Context().snapshot());
     }
 
     @Test
@@ -554,7 +603,7 @@ public class SolveMessageInconsistenciesServiceTest {
             .isEqualTo(Context.Snapshot.builder()
                 .processedImapUidEntries(1)
                 .addedMessageIdEntries(1)
-                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId())
+                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                 .build());
     }
 
@@ -572,7 +621,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 .processedImapUidEntries(1)
                 .processedMessageIdEntries(1)
                 .updatedMessageIdEntries(1)
-                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId())
+                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                 .build());
     }
 
@@ -590,7 +639,7 @@ public class SolveMessageInconsistenciesServiceTest {
                 .processedImapUidEntries(1)
                 .processedMessageIdEntries(1)
                 .updatedMessageIdEntries(1)
-                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId())
+                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                 .build());
     }
 
@@ -606,9 +655,9 @@ public class SolveMessageInconsistenciesServiceTest {
             .isEqualTo(Context.Snapshot.builder()
                 .processedMessageIdEntries(1)
                 .removedMessageIdEntries(1)
-                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId())
+                .addFixedInconsistencies(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                 .build());
-    }*/
+    }
 
     /*
     Error
@@ -618,7 +667,7 @@ public class SolveMessageInconsistenciesServiceTest {
     Caused by: com.datastax.driver.core.exceptions.WriteTimeoutException: Cassandra timeout during SIMPLE write query at consistency QUORUM (1 replica were required but only 0 acknowledged the write)
     https://builds.apache.org/blue/organizations/jenkins/james%2FApacheJames/detail/PR-268/39/tests
     */
- /*   @Test
+    @Test
     @Tag(Unstable.TAG)
     void fixMailboxInconsistenciesShouldUpdateContextWhenDeleteError(CassandraCluster cassandra) {
         Context context = new Context();
@@ -628,14 +677,14 @@ public class SolveMessageInconsistenciesServiceTest {
         cassandra.getConf()
             .registerScenario(fail()
                 .times(1)
-                .whenQueryStartsWith("DELETE FROM messageIdTable WHERE mailboxId=:mailboxId AND uid=:uid;"));
+                .whenQueryStartsWith("DELETE FROM messageidtable WHERE mailboxid=:mailboxid AND uid=:uid"));
 
         testee.fixMessageInconsistencies(context, RunningOptions.DEFAULT).block();
 
         assertThat(context.snapshot())
             .isEqualTo(Context.Snapshot.builder()
                 .processedMessageIdEntries(1)
-                .errors(MESSAGE_1.getComposedMessageId())
+                .errors(MESSAGE_1.getComposedMessageId().getComposedMessageId())
                 .build());
     }
-}*/
+}


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