You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by rc...@apache.org on 2023/09/18 02:45:30 UTC

[james-project] branch master updated: JAMES-3925 Recompute current values of JMAP upload (#1707)

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

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


The following commit(s) were added to refs/heads/master by this push:
     new c3daca6f00 JAMES-3925 Recompute current values of JMAP upload (#1707)
c3daca6f00 is described below

commit c3daca6f00a038a953d6c5733991404fbb52923a
Author: hungphan227 <45...@users.noreply.github.com>
AuthorDate: Mon Sep 18 09:45:24 2023 +0700

    JAMES-3925 Recompute current values of JMAP upload (#1707)
---
 .../apache/james/core/quota/QuotaComponent.java    |   6 +-
 ...CassandraRecomputeCurrentQuotasServiceTest.java |  18 ++-
 .../task/JPARecomputeCurrentQuotasServiceTest.java |  10 +-
 .../MemoryRecomputeCurrentQuotasServiceTest.java   |  11 +-
 .../quota/task/RecomputeCurrentQuotasService.java  | 159 ++++++++++++---------
 .../quota/task/RecomputeCurrentQuotasTask.java     |  29 ++--
 ...eCurrentQuotasTaskAdditionalInformationDTO.java | 116 ++++++++++++---
 .../task/RecomputeMailboxCurrentQuotasService.java |  74 ++++++++++
 ...omputeSingleComponentCurrentQuotasService.java} |  31 +---
 .../task/RecomputeSingleQuotaComponentResult.java  |  55 +++----
 .../mailbox/quota/task/RunningOptionsDTO.java      |  19 ++-
 .../RecomputeCurrentQuotasServiceContract.java     |  47 +++++-
 ...ecomputeCurrentQuotasTaskSerializationTest.java |  20 ++-
 .../docs/modules/ROOT/pages/operate/webadmin.adoc  |  22 ++-
 .../server/JmapTaskSerializationModule.java        |  11 ++
 .../james/modules/server/MailboxRoutesModule.java  |   6 +
 ...sandraJMAPCurrentUploadUsageCalculatorTest.java |  72 ++++++++++
 server/data/data-jmap/pom.xml                      |   4 +
 .../upload/JMAPCurrentUploadUsageCalculator.java   |  40 +++---
 .../RecomputeJMAPUploadCurrentQuotasService.java   |  36 +++--
 .../JMAPCurrentUploadUsageCalculatorContract.scala |  62 ++++++++
 ...MemoryJMAPCurrentUploadUsageCalculatorTest.java |  63 ++++++++
 .../james/webadmin/routes/UserQuotaRoutes.java     |  24 +++-
 .../james/webadmin/routes/UserQuotaRoutesTest.java |  39 +++++
 src/site/markdown/server/manage-webadmin.md        |  22 ++-
 25 files changed, 765 insertions(+), 231 deletions(-)

diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaComponent.java b/core/src/main/java/org/apache/james/core/quota/QuotaComponent.java
index 5be7fa9f47..11dbbdec7c 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaComponent.java
+++ b/core/src/main/java/org/apache/james/core/quota/QuotaComponent.java
@@ -28,9 +28,9 @@ import com.google.common.base.Preconditions;
 
 public class QuotaComponent {
 
-    public static final QuotaComponent MAILBOX = of("mailbox");
-    public static final QuotaComponent SIEVE = of("sieve");
-    public static final QuotaComponent JMAP_UPLOADS = of("jmapUploads");
+    public static final QuotaComponent MAILBOX = of("MAILBOX");
+    public static final QuotaComponent SIEVE = of("SIEVE");
+    public static final QuotaComponent JMAP_UPLOADS = of("JMAP_UPLOADS");
 
     public static QuotaComponent of(String value) {
         Preconditions.checkArgument(StringUtils.isNotBlank(value), "`value` is mandatory");
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/CassandraRecomputeCurrentQuotasServiceTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/CassandraRecomputeCurrentQuotasServiceTest.java
index 64629f2302..26acc3d196 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/CassandraRecomputeCurrentQuotasServiceTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/task/CassandraRecomputeCurrentQuotasServiceTest.java
@@ -25,6 +25,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import org.apache.james.backends.cassandra.CassandraCluster;
 import org.apache.james.backends.cassandra.CassandraClusterExtension;
 import org.apache.james.backends.cassandra.components.CassandraModule;
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.domainlist.api.DomainList;
 import org.apache.james.domainlist.cassandra.CassandraDomainListModule;
 import org.apache.james.mailbox.MailboxManager;
@@ -39,10 +40,10 @@ import org.apache.james.mailbox.quota.UserQuotaRootResolver;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasServiceContract;
+import org.apache.james.mailbox.quota.task.RecomputeMailboxCurrentQuotasService;
 import org.apache.james.mailbox.store.StoreMailboxManager;
 import org.apache.james.mailbox.store.quota.CurrentQuotaCalculator;
 import org.apache.james.mailbox.store.quota.DefaultUserQuotaRootResolver;
-import org.apache.james.sieve.cassandra.CassandraSieveRepositoryModule;
 import org.apache.james.task.Task;
 import org.apache.james.user.api.UsersRepository;
 import org.apache.james.user.cassandra.CassandraUsersDAO;
@@ -54,6 +55,8 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 
 public class CassandraRecomputeCurrentQuotasServiceTest implements RecomputeCurrentQuotasServiceContract {
     static final DomainList NO_DOMAIN_LIST = null;
@@ -86,7 +89,13 @@ public class CassandraRecomputeCurrentQuotasServiceTest implements RecomputeCurr
         userQuotaRootResolver = new DefaultUserQuotaRootResolver(sessionProvider, mapperFactory);
         CurrentQuotaCalculator currentQuotaCalculator = new CurrentQuotaCalculator(mapperFactory, userQuotaRootResolver);
 
-        testee = new RecomputeCurrentQuotasService(usersRepository, currentQuotaManager, currentQuotaCalculator, userQuotaRootResolver, sessionProvider, mailboxManager);
+        testee = new RecomputeCurrentQuotasService(usersRepository,
+            ImmutableSet.of(new RecomputeMailboxCurrentQuotasService(currentQuotaManager,
+                    currentQuotaCalculator,
+                    userQuotaRootResolver,
+                    sessionProvider,
+                    mailboxManager),
+                RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE));
     }
 
     @Override
@@ -157,7 +166,8 @@ public class CassandraRecomputeCurrentQuotasServiceTest implements RecomputeCurr
         testee().recomputeCurrentQuotas(context, RunningOptions.DEFAULT).block();
 
         assertThat(context.snapshot())
-            .isEqualTo(new RecomputeCurrentQuotasService.Context(0L,
-                ImmutableList.of(userQuotaRootResolver.forUser(USER_1))).snapshot());
+            .isEqualTo(new RecomputeCurrentQuotasService.Context(ImmutableMap.of(QuotaComponent.MAILBOX,
+                new RecomputeCurrentQuotasService.Context.Statistic(1L, ImmutableList.of(userQuotaRootResolver.forUser(USER_1).asString()))))
+                .snapshot());
     }
 }
diff --git a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/task/JPARecomputeCurrentQuotasServiceTest.java b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/task/JPARecomputeCurrentQuotasServiceTest.java
index 43925070a6..8fcb1300bc 100644
--- a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/task/JPARecomputeCurrentQuotasServiceTest.java
+++ b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/task/JPARecomputeCurrentQuotasServiceTest.java
@@ -37,6 +37,7 @@ import org.apache.james.mailbox.quota.CurrentQuotaManager;
 import org.apache.james.mailbox.quota.UserQuotaRootResolver;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasServiceContract;
+import org.apache.james.mailbox.quota.task.RecomputeMailboxCurrentQuotasService;
 import org.apache.james.mailbox.store.StoreMailboxManager;
 import org.apache.james.mailbox.store.quota.CurrentQuotaCalculator;
 import org.apache.james.mailbox.store.quota.DefaultUserQuotaRootResolver;
@@ -47,6 +48,7 @@ import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 class JPARecomputeCurrentQuotasServiceTest implements RecomputeCurrentQuotasServiceContract {
 
@@ -87,7 +89,13 @@ class JPARecomputeCurrentQuotasServiceTest implements RecomputeCurrentQuotasServ
 
         CurrentQuotaCalculator currentQuotaCalculator = new CurrentQuotaCalculator(mapperFactory, userQuotaRootResolver);
 
-        testee = new RecomputeCurrentQuotasService(usersRepository, currentQuotaManager, currentQuotaCalculator, userQuotaRootResolver, sessionProvider, mailboxManager);
+        testee = new RecomputeCurrentQuotasService(usersRepository,
+            ImmutableSet.of(new RecomputeMailboxCurrentQuotasService(currentQuotaManager,
+                    currentQuotaCalculator,
+                    userQuotaRootResolver,
+                    sessionProvider,
+                    mailboxManager),
+                RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE));
     }
 
     @AfterEach
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/task/MemoryRecomputeCurrentQuotasServiceTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/task/MemoryRecomputeCurrentQuotasServiceTest.java
index 2fa06bde62..40568fbe81 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/task/MemoryRecomputeCurrentQuotasServiceTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/task/MemoryRecomputeCurrentQuotasServiceTest.java
@@ -32,10 +32,13 @@ import org.apache.james.mailbox.quota.CurrentQuotaManager;
 import org.apache.james.mailbox.quota.UserQuotaRootResolver;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasServiceContract;
+import org.apache.james.mailbox.quota.task.RecomputeMailboxCurrentQuotasService;
 import org.apache.james.user.api.UsersRepository;
 import org.apache.james.user.memory.MemoryUsersRepository;
 import org.junit.jupiter.api.BeforeEach;
 
+import com.google.common.collect.ImmutableSet;
+
 class MemoryRecomputeCurrentQuotasServiceTest implements RecomputeCurrentQuotasServiceContract {
 
     MemoryUsersRepository usersRepository;
@@ -54,7 +57,13 @@ class MemoryRecomputeCurrentQuotasServiceTest implements RecomputeCurrentQuotasS
 
         resources = InMemoryIntegrationResources.defaultResources();
         InMemoryMailboxManager mailboxManager = resources.getMailboxManager();
-        testee = new RecomputeCurrentQuotasService(usersRepository, resources.getCurrentQuotaManager(), resources.getCurrentQuotaCalculator(), resources.getDefaultUserQuotaRootResolver(), mailboxManager.getSessionProvider(), mailboxManager);
+        testee = new RecomputeCurrentQuotasService(usersRepository,
+            ImmutableSet.of(new RecomputeMailboxCurrentQuotasService(resources.getCurrentQuotaManager(),
+                    resources.getCurrentQuotaCalculator(),
+                    resources.getDefaultUserQuotaRootResolver(),
+                    mailboxManager.getSessionProvider(),
+                    mailboxManager),
+                RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE));
     }
 
     @Override
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasService.java b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasService.java
index f2d1a9c431..1a8b91909f 100644
--- a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasService.java
+++ b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasService.java
@@ -21,21 +21,20 @@ package org.apache.james.mailbox.quota.task;
 
 import java.time.Duration;
 import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
 
 import javax.inject.Inject;
 
 import org.apache.james.core.Username;
-import org.apache.james.mailbox.MailboxManager;
-import org.apache.james.mailbox.MailboxSession;
-import org.apache.james.mailbox.SessionProvider;
-import org.apache.james.mailbox.model.QuotaOperation;
-import org.apache.james.mailbox.model.QuotaRoot;
-import org.apache.james.mailbox.quota.CurrentQuotaManager;
-import org.apache.james.mailbox.quota.UserQuotaRootResolver;
-import org.apache.james.mailbox.store.quota.CurrentQuotaCalculator;
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.task.Task;
 import org.apache.james.user.api.UsersRepository;
 import org.apache.james.user.api.UsersRepositoryException;
@@ -51,44 +50,50 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public class RecomputeCurrentQuotasService {
+
     private static final Logger LOGGER = LoggerFactory.getLogger(RecomputeCurrentQuotasService.class);
 
     public static class RunningOptions {
+        public static RunningOptions of(int usersPerSecond, List<QuotaComponent> quotaComponent) {
+            return new RunningOptions(usersPerSecond, quotaComponent);
+        }
+
         public static RunningOptions withUsersPerSecond(int usersPerSecond) {
-            return new RunningOptions(usersPerSecond);
+            return new RunningOptions(usersPerSecond, ImmutableList.of());
         }
 
-        public static final RunningOptions DEFAULT = withUsersPerSecond(1);
+        public static final int DEFAULT_USERS_PER_SECOND = 1;
+        public static final RunningOptions DEFAULT = of(DEFAULT_USERS_PER_SECOND, ImmutableList.of());
 
         private final int usersPerSecond;
+        private final List<QuotaComponent> quotaComponents;
 
-        private RunningOptions(int usersPerSecond) {
+        private RunningOptions(int usersPerSecond, List<QuotaComponent> quotaComponent) {
             Preconditions.checkArgument(usersPerSecond > 0, "'usersPerSecond' needs to be strictly positive");
 
             this.usersPerSecond = usersPerSecond;
+            this.quotaComponents = quotaComponent;
         }
 
         public int getUsersPerSecond() {
             return usersPerSecond;
         }
+
+        public List<QuotaComponent> getQuotaComponents() {
+            return quotaComponents;
+        }
     }
 
     public static class Context {
         static class Snapshot {
-            private final long processedQuotaRootCount;
-            private final ImmutableList<QuotaRoot> failedQuotaRoots;
+            private final List<RecomputeSingleQuotaComponentResult> recomputeSingleQuotaComponentResults;
 
-            private Snapshot(long processedQuotaRootCount, ImmutableList<QuotaRoot> failedQuotaRoots) {
-                this.processedQuotaRootCount = processedQuotaRootCount;
-                this.failedQuotaRoots = failedQuotaRoots;
+            private Snapshot(List<RecomputeSingleQuotaComponentResult> results) {
+                this.recomputeSingleQuotaComponentResults = results;
             }
 
-            long getProcessedQuotaRootCount() {
-                return processedQuotaRootCount;
-            }
-
-            ImmutableList<QuotaRoot> getFailedQuotaRoots() {
-                return failedQuotaRoots;
+            public List<RecomputeSingleQuotaComponentResult> getResults() {
+                return recomputeSingleQuotaComponentResults;
             }
 
             @Override
@@ -96,73 +101,80 @@ public class RecomputeCurrentQuotasService {
                 if (o instanceof Snapshot) {
                     Snapshot that = (Snapshot) o;
 
-                    return Objects.equals(this.processedQuotaRootCount, that.processedQuotaRootCount)
-                        && Objects.equals(this.failedQuotaRoots, that.failedQuotaRoots);
+                    return Objects.equals(this.recomputeSingleQuotaComponentResults, that.recomputeSingleQuotaComponentResults);
                 }
                 return false;
             }
 
             @Override
             public final int hashCode() {
-                return Objects.hash(processedQuotaRootCount, failedQuotaRoots);
+                return Objects.hash(recomputeSingleQuotaComponentResults);
             }
 
             @Override
             public String toString() {
                 return MoreObjects.toStringHelper(this)
-                    .add("processedQuotaRootCount", processedQuotaRootCount)
-                    .add("failedQuotaRoots", failedQuotaRoots)
+                    .add("results", recomputeSingleQuotaComponentResults)
                     .toString();
             }
         }
 
-        private final AtomicLong processedQuotaRootCount;
-        private final ConcurrentLinkedDeque<QuotaRoot> failedQuotaRoots;
+        public static class Statistic {
+            private final AtomicLong processedIdentifierCount;
+            private final ConcurrentLinkedDeque<String> failedIdentifiers;
 
-        public Context() {
-            this.processedQuotaRootCount = new AtomicLong();
-            this.failedQuotaRoots = new ConcurrentLinkedDeque<>();
+            public Statistic(AtomicLong processedIdentifierCount, ConcurrentLinkedDeque<String> failedIdentifiers) {
+                this.processedIdentifierCount = processedIdentifierCount;
+                this.failedIdentifiers = failedIdentifiers;
+            }
+
+            public Statistic(long processedQuotaRootCount, Collection<String> failedQuotaRoots) {
+                this.processedIdentifierCount = new AtomicLong(processedQuotaRootCount);
+                this.failedIdentifiers = new ConcurrentLinkedDeque<>(failedQuotaRoots);
+            }
+
+            public void incrementProcessed() {
+                processedIdentifierCount.incrementAndGet();
+            }
+
+            public void addToFailedIdentifiers(String identifier) {
+                failedIdentifiers.add(identifier);
+            }
         }
 
-        public Context(long processedQuotaRootCount, Collection<QuotaRoot> failedQuotaRoots) {
-            this.processedQuotaRootCount = new AtomicLong(processedQuotaRootCount);
-            this.failedQuotaRoots = new ConcurrentLinkedDeque<>(failedQuotaRoots);
+        private Map<QuotaComponent, Statistic> mapQuotaComponentToStatistic;
+
+        public Context() {
+            this.mapQuotaComponentToStatistic = new ConcurrentHashMap<>();
         }
 
-        void incrementProcessed() {
-            processedQuotaRootCount.incrementAndGet();
+        public Context(Map<QuotaComponent, Statistic> mapQuotaComponentToStatistic) {
+            this.mapQuotaComponentToStatistic = new ConcurrentHashMap<>(mapQuotaComponentToStatistic);
         }
 
-        void addToFailedMailboxes(QuotaRoot quotaRoot) {
-            failedQuotaRoots.add(quotaRoot);
+        public Statistic getStatistic(QuotaComponent quotaComponent) {
+            return mapQuotaComponentToStatistic.computeIfAbsent(quotaComponent, key -> new Statistic(new AtomicLong(), new ConcurrentLinkedDeque<>()));
         }
 
         public Snapshot snapshot() {
-            return new Snapshot(processedQuotaRootCount.get(),
-                ImmutableList.copyOf(failedQuotaRoots));
+            return new Snapshot(mapQuotaComponentToStatistic.entrySet().stream()
+                .map(quotaComponentStatisticEntry -> new RecomputeSingleQuotaComponentResult(quotaComponentStatisticEntry.getKey().getValue(),
+                    quotaComponentStatisticEntry.getValue().processedIdentifierCount.get(),
+                    ImmutableList.copyOf(quotaComponentStatisticEntry.getValue().failedIdentifiers)))
+                .collect(Collectors.toUnmodifiableList()));
         }
     }
 
     private final UsersRepository usersRepository;
-    private final CurrentQuotaManager storeCurrentQuotaManager;
-    private final CurrentQuotaCalculator currentQuotaCalculator;
-    private final UserQuotaRootResolver userQuotaRootResolver;
-    private final SessionProvider sessionProvider;
-    private final MailboxManager mailboxManager;
+    private final Map<QuotaComponent, RecomputeSingleComponentCurrentQuotasService> recomputeSingleComponentCurrentQuotasServiceMap;
 
     @Inject
     public RecomputeCurrentQuotasService(UsersRepository usersRepository,
-                                         CurrentQuotaManager storeCurrentQuotaManager,
-                                         CurrentQuotaCalculator currentQuotaCalculator,
-                                         UserQuotaRootResolver userQuotaRootResolver,
-                                         SessionProvider sessionProvider,
-                                         MailboxManager mailboxManager) {
+                                         Set<RecomputeSingleComponentCurrentQuotasService> recomputeSingleComponentCurrentQuotasServices) {
         this.usersRepository = usersRepository;
-        this.storeCurrentQuotaManager = storeCurrentQuotaManager;
-        this.currentQuotaCalculator = currentQuotaCalculator;
-        this.userQuotaRootResolver = userQuotaRootResolver;
-        this.sessionProvider = sessionProvider;
-        this.mailboxManager = mailboxManager;
+        this.recomputeSingleComponentCurrentQuotasServiceMap = recomputeSingleComponentCurrentQuotasServices.stream()
+            .collect(Collectors.toUnmodifiableMap(recomputeSingleComponentCurrentQuotasService -> recomputeSingleComponentCurrentQuotasService.getQuotaComponent(),
+                recomputeSingleComponentCurrentQuotasService -> recomputeSingleComponentCurrentQuotasService));
     }
 
     public Mono<Task.Result> recomputeCurrentQuotas(Context context, RunningOptions runningOptions) {
@@ -170,7 +182,7 @@ public class RecomputeCurrentQuotasService {
             .transform(ReactorUtils.<Username, Task.Result>throttle()
                 .elements(runningOptions.getUsersPerSecond())
                 .per(Duration.ofSeconds(1))
-                .forOperation(username -> recomputeUserCurrentQuotas(context, username)))
+                .forOperation(username -> recomputeQuotasOfUser(runningOptions.getQuotaComponents(), context, username)))
             .reduce(Task.Result.COMPLETED, Task::combine)
             .onErrorResume(UsersRepositoryException.class, e -> {
                 LOGGER.error("Error while accessing users from repository", e);
@@ -178,23 +190,32 @@ public class RecomputeCurrentQuotasService {
             });
     }
 
-    private Mono<Task.Result> recomputeUserCurrentQuotas(Context context, Username username) {
-        MailboxSession session = sessionProvider.createSystemSession(username);
-        QuotaRoot quotaRoot = userQuotaRootResolver.forUser(username);
+    private Mono<Task.Result> recomputeQuotasOfUser(List<QuotaComponent> quotaComponents, Context context, Username username) {
+        if (quotaComponents.isEmpty()) {
+            return Flux.merge(recomputeSingleComponentCurrentQuotasServiceMap.values().stream()
+                    .map(recomputeSingleComponentCurrentQuotasService -> recomputeCurrentQuotas(recomputeSingleComponentCurrentQuotasService, context, username))
+                    .collect(Collectors.toUnmodifiableList()))
+                .reduce(Task.Result.COMPLETED, Task::combine);
+        } else {
+            return Flux.fromIterable(quotaComponents)
+                .flatMap(quotaComponent -> Optional.ofNullable(recomputeSingleComponentCurrentQuotasServiceMap.get(quotaComponent))
+                    .map(recomputeSingleComponentCurrentQuotasService -> recomputeCurrentQuotas(recomputeSingleComponentCurrentQuotasService, context, username))
+                    .orElse(Mono.just(Task.Result.PARTIAL)))
+                .reduce(Task.Result.COMPLETED, Task::combine);
+        }
+    }
 
-        return currentQuotaCalculator.recalculateCurrentQuotas(quotaRoot, session)
-            .map(recalculatedQuotas -> QuotaOperation.from(quotaRoot, recalculatedQuotas))
-            .flatMap(quotaOperation -> Mono.from(storeCurrentQuotaManager.setCurrentQuotas(quotaOperation)))
+    public Mono<Task.Result> recomputeCurrentQuotas(RecomputeSingleComponentCurrentQuotasService recomputeSingleComponentCurrentQuotasService, Context context, Username username) {
+        return recomputeSingleComponentCurrentQuotasService.recomputeCurrentQuotas(username)
             .then(Mono.just(Task.Result.COMPLETED))
             .doOnNext(any -> {
-                LOGGER.info("Current quotas recomputed for {}", quotaRoot);
-                context.incrementProcessed();
+                LOGGER.info("jmap current upload usage quota recomputed for {}", username);
+                context.getStatistic(recomputeSingleComponentCurrentQuotasService.getQuotaComponent()).incrementProcessed();
             })
             .onErrorResume(e -> {
-                LOGGER.error("Error while recomputing current quotas for {}", quotaRoot, e);
-                context.addToFailedMailboxes(quotaRoot);
+                LOGGER.error("Error while recomputing jmap current upload usage quota for {}", username, e);
+                context.getStatistic(recomputeSingleComponentCurrentQuotasService.getQuotaComponent()).addToFailedIdentifiers(username.asString());
                 return Mono.just(Task.Result.PARTIAL);
-            })
-            .doFinally(any -> mailboxManager.endProcessingRequest(session));
+            });
     }
 }
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTask.java b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTask.java
index 5731b45f9c..524694f6d1 100644
--- a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTask.java
+++ b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTask.java
@@ -21,9 +21,9 @@ package org.apache.james.mailbox.quota.task;
 
 import java.time.Clock;
 import java.time.Instant;
+import java.util.List;
 import java.util.Optional;
 
-import org.apache.james.mailbox.model.QuotaRoot;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.Context;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.Context.Snapshot;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
@@ -31,21 +31,17 @@ import org.apache.james.task.Task;
 import org.apache.james.task.TaskExecutionDetails;
 import org.apache.james.task.TaskType;
 
-import com.google.common.collect.ImmutableList;
-
 public class RecomputeCurrentQuotasTask implements Task {
     static final TaskType RECOMPUTE_CURRENT_QUOTAS = TaskType.of("recompute-current-quotas");
 
     public static class Details implements TaskExecutionDetails.AdditionalInformation {
         private final Instant instant;
-        private final long processedQuotaRoots;
-        private final ImmutableList<String> failedQuotaRoots;
+        private final List<RecomputeSingleQuotaComponentResult> recomputeSingleQuotaComponentResults;
         private final RunningOptions runningOptions;
 
-        Details(Instant instant, long processedQuotaRoots, ImmutableList<String> failedQuotaRoots, RunningOptions runningOptions) {
+        Details(Instant instant, List<RecomputeSingleQuotaComponentResult> recomputeSingleQuotaComponentResults, RunningOptions runningOptions) {
             this.instant = instant;
-            this.processedQuotaRoots = processedQuotaRoots;
-            this.failedQuotaRoots = failedQuotaRoots;
+            this.recomputeSingleQuotaComponentResults = recomputeSingleQuotaComponentResults;
             this.runningOptions = runningOptions;
         }
 
@@ -54,12 +50,8 @@ public class RecomputeCurrentQuotasTask implements Task {
             return instant;
         }
 
-        long getProcessedQuotaRoots() {
-            return processedQuotaRoots;
-        }
-
-        ImmutableList<String> getFailedQuotaRoots() {
-            return failedQuotaRoots;
+        public List<RecomputeSingleQuotaComponentResult> getResults() {
+            return recomputeSingleQuotaComponentResults;
         }
 
         public RunningOptions getRunningOptions() {
@@ -79,7 +71,7 @@ public class RecomputeCurrentQuotasTask implements Task {
 
     @Override
     public Task.Result run() {
-        return service.recomputeCurrentQuotas(context, RunningOptions.DEFAULT)
+        return service.recomputeCurrentQuotas(context, runningOptions)
             .block();
     }
 
@@ -97,10 +89,7 @@ public class RecomputeCurrentQuotasTask implements Task {
         Snapshot snapshot = context.snapshot();
 
         return Optional.of(new Details(Clock.systemUTC().instant(),
-            snapshot.getProcessedQuotaRootCount(),
-            snapshot.getFailedQuotaRoots()
-                .stream()
-                .map(QuotaRoot::asString)
-                .collect(ImmutableList.toImmutableList()), runningOptions));
+            snapshot.getResults(),
+            runningOptions));
     }
 }
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskAdditionalInformationDTO.java b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskAdditionalInformationDTO.java
index 8d807e3c27..600bfa7105 100644
--- a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskAdditionalInformationDTO.java
+++ b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskAdditionalInformationDTO.java
@@ -20,61 +20,134 @@
 package org.apache.james.mailbox.quota.task;
 
 import java.time.Instant;
+import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.json.DTOModule;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
 import org.apache.james.server.task.json.dto.AdditionalInformationDTO;
 import org.apache.james.server.task.json.dto.AdditionalInformationDTOModule;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableList;
 
 public class RecomputeCurrentQuotasTaskAdditionalInformationDTO implements AdditionalInformationDTO {
+
+    static class RecomputeSingleQuotaComponentResultDTO {
+        private final String quotaComponent;
+        private final long processedIdentifierCount;
+        private final ImmutableList<String> failedIdentifiers;
+
+        public RecomputeSingleQuotaComponentResultDTO(@JsonProperty("quotaComponent") String quotaComponent,
+                                                      @JsonProperty("processedQuotaRoots") long processedIdentifierCount,
+                                                      @JsonProperty("failedQuotaRoots") ImmutableList<String> failedIdentifiers) {
+            this.quotaComponent = quotaComponent;
+            this.processedIdentifierCount = processedIdentifierCount;
+            this.failedIdentifiers = failedIdentifiers;
+        }
+
+        public String getQuotaComponent() {
+            return quotaComponent;
+        }
+
+        public long getProcessedIdentifierCount() {
+            return processedIdentifierCount;
+        }
+
+        public ImmutableList<String> getFailedIdentifiers() {
+            return failedIdentifiers;
+        }
+
+        @Override
+        public final boolean equals(Object o) {
+            if (o instanceof RecomputeSingleQuotaComponentResultDTO) {
+                RecomputeSingleQuotaComponentResultDTO that = (RecomputeSingleQuotaComponentResultDTO) o;
+
+                return Objects.equals(this.quotaComponent, that.quotaComponent)
+                        && Objects.equals(this.processedIdentifierCount, that.processedIdentifierCount)
+                        && Objects.equals(this.failedIdentifiers, that.failedIdentifiers);
+            }
+            return false;
+        }
+
+        @Override
+        public final int hashCode() {
+            return Objects.hash(quotaComponent, processedIdentifierCount, failedIdentifiers);
+        }
+
+        @Override
+        public String toString() {
+            return MoreObjects.toStringHelper(this)
+                    .add("quotaComponent", quotaComponent)
+                    .add("processedIdentifierCount", processedIdentifierCount)
+                    .add("failedIdentifiers", failedIdentifiers)
+                    .toString();
+        }
+    }
+
     private static RecomputeCurrentQuotasTaskAdditionalInformationDTO fromDomainObject(RecomputeCurrentQuotasTask.Details details, String type) {
+        Optional<RecomputeSingleQuotaComponentResult> recomputeSingleQuotaComponentResultOfMailbox = details.getResults().stream()
+                .filter(recomputeSingleQuotaComponentResult -> QuotaComponent.MAILBOX.getValue().equals(recomputeSingleQuotaComponentResult.getQuotaComponent()))
+                .findFirst();
         return new RecomputeCurrentQuotasTaskAdditionalInformationDTO(
-            type,
-            details.getProcessedQuotaRoots(),
-            details.getFailedQuotaRoots(),
-            Optional.of(RunningOptionsDTO.asDTO(details.getRunningOptions())),
-            details.timestamp());
+                type,
+                recomputeSingleQuotaComponentResultOfMailbox.map(RecomputeSingleQuotaComponentResult::getProcessedIdentifierCount).or(() -> Optional.of(0L)),
+                recomputeSingleQuotaComponentResultOfMailbox.map(RecomputeSingleQuotaComponentResult::getFailedIdentifiers).or(() -> Optional.of(ImmutableList.of())),
+                Optional.of(details.getResults().stream()
+                        .map(recomputeSingleQuotaComponentResult -> new RecomputeSingleQuotaComponentResultDTO(recomputeSingleQuotaComponentResult.getQuotaComponent(),
+                                recomputeSingleQuotaComponentResult.getProcessedIdentifierCount(),
+                                recomputeSingleQuotaComponentResult.getFailedIdentifiers()))
+                        .collect(Collectors.toUnmodifiableList())),
+                Optional.of(RunningOptionsDTO.asDTO(details.getRunningOptions())),
+                details.timestamp());
     }
 
     public static AdditionalInformationDTOModule<RecomputeCurrentQuotasTask.Details, RecomputeCurrentQuotasTaskAdditionalInformationDTO> module() {
         return DTOModule.forDomainObject(RecomputeCurrentQuotasTask.Details.class)
-            .convertToDTO(RecomputeCurrentQuotasTaskAdditionalInformationDTO.class)
-            .toDomainObjectConverter(RecomputeCurrentQuotasTaskAdditionalInformationDTO::toDomainObject)
-            .toDTOConverter(RecomputeCurrentQuotasTaskAdditionalInformationDTO::fromDomainObject)
-            .typeName(RecomputeCurrentQuotasTask.RECOMPUTE_CURRENT_QUOTAS.asString())
-            .withFactory(AdditionalInformationDTOModule::new);
+                .convertToDTO(RecomputeCurrentQuotasTaskAdditionalInformationDTO.class)
+                .toDomainObjectConverter(RecomputeCurrentQuotasTaskAdditionalInformationDTO::toDomainObject)
+                .toDTOConverter(RecomputeCurrentQuotasTaskAdditionalInformationDTO::fromDomainObject)
+                .typeName(RecomputeCurrentQuotasTask.RECOMPUTE_CURRENT_QUOTAS.asString())
+                .withFactory(AdditionalInformationDTOModule::new);
     }
 
     private final String type;
-    private final long processedQuotaRoots;
-    private final ImmutableList<String> failedQuotaRoots;
+    private final Optional<Long> processedQuotaRoots;
+    private final Optional<ImmutableList<String>> failedQuotaRoots;
+    private final Optional<List<RecomputeSingleQuotaComponentResultDTO>> recomputeSingleQuotaComponentResults;
     private final Optional<RunningOptionsDTO> runningOptions;
     private final Instant timestamp;
 
     public RecomputeCurrentQuotasTaskAdditionalInformationDTO(@JsonProperty("type") String type,
-                                                              @JsonProperty("processedQuotaRoots") long processedQuotaRoots,
-                                                              @JsonProperty("failedQuotaRoots") ImmutableList<String> failedQuotaRoots,
+                                                              @JsonProperty("processedQuotaRoots") Optional<Long> processedQuotaRoots,
+                                                              @JsonProperty("failedQuotaRoots") Optional<ImmutableList<String>> failedQuotaRoots,
+                                                              @JsonProperty("recomputeSingleQuotaComponentResults") Optional<List<RecomputeSingleQuotaComponentResultDTO>> recomputeSingleQuotaComponentResults,
                                                               @JsonProperty("runningOptions") Optional<RunningOptionsDTO> runningOptions,
                                                               @JsonProperty("timestamp") Instant timestamp) {
         this.type = type;
         this.processedQuotaRoots = processedQuotaRoots;
         this.failedQuotaRoots = failedQuotaRoots;
+        this.recomputeSingleQuotaComponentResults = recomputeSingleQuotaComponentResults;
         this.runningOptions = runningOptions;
         this.timestamp = timestamp;
     }
 
-    public long getProcessedQuotaRoots() {
+    public Optional<Long> getProcessedQuotaRoots() {
         return processedQuotaRoots;
     }
 
-    public ImmutableList<String> getFailedQuotaRoots() {
+    public Optional<ImmutableList<String>> getFailedQuotaRoots() {
         return failedQuotaRoots;
     }
 
+    public Optional<List<RecomputeSingleQuotaComponentResultDTO>> getRecomputeSingleQuotaComponentResults() {
+        return recomputeSingleQuotaComponentResults;
+    }
+
     @Override
     public Instant getTimestamp() {
         return timestamp;
@@ -91,8 +164,13 @@ public class RecomputeCurrentQuotasTaskAdditionalInformationDTO implements Addit
 
     private RecomputeCurrentQuotasTask.Details toDomainObject() {
         return new RecomputeCurrentQuotasTask.Details(timestamp,
-            processedQuotaRoots,
-            failedQuotaRoots,
-            runningOptions.map(RunningOptionsDTO::asDomainObject).orElse(RunningOptions.DEFAULT));
+                recomputeSingleQuotaComponentResults.map(recomputeSingleQuotaComponentResults -> recomputeSingleQuotaComponentResults.stream()
+                                .map(recomputeSingleQuotaComponentResultDTO -> new RecomputeSingleQuotaComponentResult(recomputeSingleQuotaComponentResultDTO.getQuotaComponent(),
+                                        recomputeSingleQuotaComponentResultDTO.getProcessedIdentifierCount(),
+                                        recomputeSingleQuotaComponentResultDTO.getFailedIdentifiers()))
+                                .collect(Collectors.toUnmodifiableList()))
+                        .orElse(ImmutableList.of(new RecomputeSingleQuotaComponentResult(QuotaComponent.MAILBOX.getValue(),
+                                processedQuotaRoots.get(), failedQuotaRoots.get()))),
+                runningOptions.map(RunningOptionsDTO::asDomainObject).orElse(RunningOptions.DEFAULT));
     }
 }
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeMailboxCurrentQuotasService.java b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeMailboxCurrentQuotasService.java
new file mode 100644
index 0000000000..239ba0c3eb
--- /dev/null
+++ b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeMailboxCurrentQuotasService.java
@@ -0,0 +1,74 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ ****************************************************************/
+
+package org.apache.james.mailbox.quota.task;
+
+import javax.inject.Inject;
+
+import org.apache.james.core.Username;
+import org.apache.james.core.quota.QuotaComponent;
+import org.apache.james.mailbox.MailboxManager;
+import org.apache.james.mailbox.MailboxSession;
+import org.apache.james.mailbox.SessionProvider;
+import org.apache.james.mailbox.model.QuotaOperation;
+import org.apache.james.mailbox.model.QuotaRoot;
+import org.apache.james.mailbox.quota.CurrentQuotaManager;
+import org.apache.james.mailbox.quota.UserQuotaRootResolver;
+import org.apache.james.mailbox.store.quota.CurrentQuotaCalculator;
+
+import reactor.core.publisher.Mono;
+
+public class RecomputeMailboxCurrentQuotasService implements RecomputeSingleComponentCurrentQuotasService {
+
+    private final CurrentQuotaManager storeCurrentQuotaManager;
+    private final CurrentQuotaCalculator currentQuotaCalculator;
+    private final UserQuotaRootResolver userQuotaRootResolver;
+    private final SessionProvider sessionProvider;
+    private final MailboxManager mailboxManager;
+
+    @Inject
+    public RecomputeMailboxCurrentQuotasService(CurrentQuotaManager storeCurrentQuotaManager,
+                                         CurrentQuotaCalculator currentQuotaCalculator,
+                                         UserQuotaRootResolver userQuotaRootResolver,
+                                         SessionProvider sessionProvider,
+                                         MailboxManager mailboxManager) {
+        this.storeCurrentQuotaManager = storeCurrentQuotaManager;
+        this.currentQuotaCalculator = currentQuotaCalculator;
+        this.userQuotaRootResolver = userQuotaRootResolver;
+        this.sessionProvider = sessionProvider;
+        this.mailboxManager = mailboxManager;
+    }
+
+
+    @Override
+    public QuotaComponent getQuotaComponent() {
+        return QuotaComponent.MAILBOX;
+    }
+
+    @Override
+    public Mono<Void> recomputeCurrentQuotas(Username username) {
+        MailboxSession session = sessionProvider.createSystemSession(username);
+        QuotaRoot quotaRoot = userQuotaRootResolver.forUser(username);
+
+        return currentQuotaCalculator.recalculateCurrentQuotas(quotaRoot, session)
+            .map(recalculatedQuotas -> QuotaOperation.from(quotaRoot, recalculatedQuotas))
+            .flatMap(quotaOperation -> Mono.from(storeCurrentQuotaManager.setCurrentQuotas(quotaOperation)))
+            .doFinally(any -> mailboxManager.endProcessingRequest(session));
+    }
+}
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeSingleComponentCurrentQuotasService.java
similarity index 57%
copy from mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
copy to mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeSingleComponentCurrentQuotasService.java
index e73d267a18..f36c6f7b56 100644
--- a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
+++ b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeSingleComponentCurrentQuotasService.java
@@ -19,32 +19,13 @@
 
 package org.apache.james.mailbox.quota.task;
 
-import java.util.Optional;
+import org.apache.james.core.Username;
+import org.apache.james.core.quota.QuotaComponent;
 
-import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
+import reactor.core.publisher.Mono;
 
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
+public interface RecomputeSingleComponentCurrentQuotasService {
+    QuotaComponent getQuotaComponent();
 
-public class RunningOptionsDTO {
-    public static RunningOptionsDTO asDTO(RunningOptions domainObject) {
-        return new RunningOptionsDTO(Optional.of(domainObject.getUsersPerSecond()));
-    }
-
-    private final Optional<Integer> usersPerSecond;
-
-    @JsonCreator
-    public RunningOptionsDTO(
-            @JsonProperty("usersPerSecond") Optional<Integer> usersPerSecond) {
-        this.usersPerSecond = usersPerSecond;
-    }
-
-    public Optional<Integer> getUsersPerSecond() {
-        return usersPerSecond;
-    }
-
-    public RunningOptions asDomainObject() {
-        return usersPerSecond.map(RunningOptions::withUsersPerSecond)
-            .orElse(RunningOptions.DEFAULT);
-    }
+    Mono<Void> recomputeCurrentQuotas(Username username);
 }
diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaComponent.java b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeSingleQuotaComponentResult.java
similarity index 50%
copy from core/src/main/java/org/apache/james/core/quota/QuotaComponent.java
copy to mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeSingleQuotaComponentResult.java
index 5be7fa9f47..f37e42893c 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaComponent.java
+++ b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RecomputeSingleQuotaComponentResult.java
@@ -17,54 +17,59 @@
  * under the License.                                           *
  ****************************************************************/
 
-package org.apache.james.core.quota;
+package org.apache.james.mailbox.quota.task;
 
 import java.util.Objects;
 
-import org.apache.commons.lang3.StringUtils;
-
 import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
-
-public class QuotaComponent {
+import com.google.common.collect.ImmutableList;
 
-    public static final QuotaComponent MAILBOX = of("mailbox");
-    public static final QuotaComponent SIEVE = of("sieve");
-    public static final QuotaComponent JMAP_UPLOADS = of("jmapUploads");
+public class RecomputeSingleQuotaComponentResult {
+    private final String quotaComponent;
+    private final long processedIdentifierCount;
+    private final ImmutableList<String> failedIdentifiers;
 
-    public static QuotaComponent of(String value) {
-        Preconditions.checkArgument(StringUtils.isNotBlank(value), "`value` is mandatory");
-        return new QuotaComponent(value);
+    public RecomputeSingleQuotaComponentResult(String quotaComponent, long processedIdentifierCount, ImmutableList<String> failedIdentifiers) {
+        this.quotaComponent = quotaComponent;
+        this.processedIdentifierCount = processedIdentifierCount;
+        this.failedIdentifiers = failedIdentifiers;
     }
 
-    private final String value;
-
-    private QuotaComponent(String value) {
-        this.value = value;
+    public String getQuotaComponent() {
+        return quotaComponent;
     }
 
-    public String getValue() {
-        return value;
+    public long getProcessedIdentifierCount() {
+        return processedIdentifierCount;
     }
 
-    @Override
-    public final int hashCode() {
-        return Objects.hash(value);
+    public ImmutableList<String> getFailedIdentifiers() {
+        return failedIdentifiers;
     }
 
     @Override
     public final boolean equals(Object o) {
-        if (o instanceof QuotaComponent) {
-            QuotaComponent other = (QuotaComponent) o;
-            return Objects.equals(value, other.value);
+        if (o instanceof RecomputeSingleQuotaComponentResult) {
+            RecomputeSingleQuotaComponentResult that = (RecomputeSingleQuotaComponentResult) o;
+
+            return Objects.equals(this.quotaComponent, that.quotaComponent)
+                && Objects.equals(this.processedIdentifierCount, that.processedIdentifierCount)
+                && Objects.equals(this.failedIdentifiers, that.failedIdentifiers);
         }
         return false;
     }
 
+    @Override
+    public final int hashCode() {
+        return Objects.hash(quotaComponent, processedIdentifierCount, processedIdentifierCount);
+    }
+
     @Override
     public String toString() {
         return MoreObjects.toStringHelper(this)
-            .add("value", value)
+            .add("quotaComponent", quotaComponent)
+            .add("processedIdentifierCount", processedIdentifierCount)
+            .add("processedIdentifierCount", processedIdentifierCount)
             .toString();
     }
 }
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
index e73d267a18..e7f74c5166 100644
--- a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
+++ b/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
@@ -19,32 +19,43 @@
 
 package org.apache.james.mailbox.quota.task;
 
+import java.util.List;
 import java.util.Optional;
 
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.collect.ImmutableList;
 
 public class RunningOptionsDTO {
     public static RunningOptionsDTO asDTO(RunningOptions domainObject) {
-        return new RunningOptionsDTO(Optional.of(domainObject.getUsersPerSecond()));
+        return new RunningOptionsDTO(Optional.of(domainObject.getUsersPerSecond()),
+            domainObject.getQuotaComponents().stream().map(QuotaComponent::getValue).collect(ImmutableList.toImmutableList()));
     }
 
     private final Optional<Integer> usersPerSecond;
+    private final List<String> quotaComponents;
 
     @JsonCreator
     public RunningOptionsDTO(
-            @JsonProperty("usersPerSecond") Optional<Integer> usersPerSecond) {
+            @JsonProperty("usersPerSecond") Optional<Integer> usersPerSecond,
+            @JsonProperty("quotaComponents") List<String> quotaComponents) {
         this.usersPerSecond = usersPerSecond;
+        this.quotaComponents = quotaComponents;
     }
 
     public Optional<Integer> getUsersPerSecond() {
         return usersPerSecond;
     }
 
+    public List<String> getQuotaComponents() {
+        return quotaComponents;
+    }
+
     public RunningOptions asDomainObject() {
-        return usersPerSecond.map(RunningOptions::withUsersPerSecond)
-            .orElse(RunningOptions.DEFAULT);
+        return RunningOptions.of(usersPerSecond.orElse(RunningOptions.DEFAULT_USERS_PER_SECOND),
+            quotaComponents.stream().map(QuotaComponent::of).collect(ImmutableList.toImmutableList()));
     }
 }
diff --git a/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasServiceContract.java b/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasServiceContract.java
index 80b84b4c0f..e0c048df85 100644
--- a/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasServiceContract.java
+++ b/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasServiceContract.java
@@ -20,10 +20,12 @@
 package org.apache.james.mailbox.quota.task;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
 
 import java.nio.charset.StandardCharsets;
 
 import org.apache.james.core.Username;
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.core.quota.QuotaCountUsage;
 import org.apache.james.core.quota.QuotaSizeUsage;
 import org.apache.james.mailbox.MailboxManager;
@@ -41,9 +43,12 @@ import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.Running
 import org.apache.james.mime4j.dom.Message;
 import org.apache.james.task.Task;
 import org.apache.james.user.api.UsersRepository;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 
 import reactor.core.publisher.Mono;
 
@@ -53,6 +58,8 @@ public interface RecomputeCurrentQuotasServiceContract {
     MailboxPath MAILBOX_PATH = MailboxPath.forUser(USER_1, "mailbox");
     CurrentQuotas EXPECTED_QUOTAS = new CurrentQuotas(QuotaCountUsage.count(1L), QuotaSizeUsage.size(103L));
 
+    RecomputeSingleComponentCurrentQuotasService RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE = Mockito.mock(RecomputeSingleComponentCurrentQuotasService.class);
+
     UsersRepository usersRepository();
 
     SessionProvider sessionProvider();
@@ -65,6 +72,12 @@ public interface RecomputeCurrentQuotasServiceContract {
 
     RecomputeCurrentQuotasService testee();
 
+    @BeforeEach
+    default void setup() {
+        when(RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE.getQuotaComponent()).thenReturn(QuotaComponent.JMAP_UPLOADS);
+        when(RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE.recomputeCurrentQuotas(Mockito.any())).thenReturn(Mono.empty());
+    }
+
     @Test
     default void recomputeCurrentQuotasShouldReturnCompleteWhenNoData() {
         assertThat(testee().recomputeCurrentQuotas(new Context(), RunningOptions.DEFAULT).block())
@@ -79,6 +92,25 @@ public interface RecomputeCurrentQuotasServiceContract {
             .isEqualTo(Task.Result.COMPLETED);
     }
 
+    @Test
+    default void recomputeCurrentQuotasShouldReturnPartialWhenRecomputeJMAPCurrentUploadUsageFail() throws Exception {
+        when(RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE.recomputeCurrentQuotas(Mockito.any())).thenReturn(Mono.error(new RuntimeException()));
+        usersRepository().addUser(USER_1, PASSWORD);
+
+        assertThat(testee().recomputeCurrentQuotas(new Context(), RunningOptions.DEFAULT).block())
+            .isEqualTo(Task.Result.PARTIAL);
+    }
+
+    @Test
+    default void recomputeCurrentQuotasShouldRunRecomputeMailboxUserCurrentQuotasOnly() throws Exception {
+        when(RECOMPUTE_JMAP_UPLOAD_CURRENT_QUOTAS_SERVICE.recomputeCurrentQuotas(Mockito.any())).thenReturn(Mono.error(new RuntimeException()));
+        usersRepository().addUser(USER_1, PASSWORD);
+
+        assertThat(testee().recomputeCurrentQuotas(new Context(),
+            RunningOptions.of(RunningOptions.DEFAULT_USERS_PER_SECOND, ImmutableList.of(QuotaComponent.MAILBOX))).block())
+            .isEqualTo(Task.Result.COMPLETED);
+    }
+
     @Test
     default void recomputeCurrentQuotasShouldComputeEmptyQuotasWhenUserWithNoMessage() throws Exception {
         usersRepository().addUser(USER_1, PASSWORD);
@@ -176,8 +208,9 @@ public interface RecomputeCurrentQuotasServiceContract {
         Context context = new Context();
         testee().recomputeCurrentQuotas(context, RunningOptions.DEFAULT).block();
 
-        assertThat(context.snapshot())
-            .isEqualTo(new Context(1L, ImmutableList.of()).snapshot());
+        assertThat(context.snapshot().getResults())
+            .containsExactlyInAnyOrderElementsOf(new Context(ImmutableMap.of(QuotaComponent.MAILBOX, new Context.Statistic(1L, ImmutableList.of()),
+                QuotaComponent.JMAP_UPLOADS, new Context.Statistic(1L, ImmutableList.of()))).snapshot().getResults());
     }
 
     @Test
@@ -193,8 +226,9 @@ public interface RecomputeCurrentQuotasServiceContract {
         Context context = new Context();
         testee().recomputeCurrentQuotas(context, RunningOptions.DEFAULT).block();
 
-        assertThat(context.snapshot())
-            .isEqualTo(new Context(1L, ImmutableList.of()).snapshot());
+        assertThat(context.snapshot().getResults())
+            .containsExactlyInAnyOrderElementsOf(new Context(ImmutableMap.of(QuotaComponent.MAILBOX, new Context.Statistic(1L, ImmutableList.of()),
+                QuotaComponent.JMAP_UPLOADS, new Context.Statistic(1L, ImmutableList.of()))).snapshot().getResults());
     }
 
     @Test
@@ -216,8 +250,9 @@ public interface RecomputeCurrentQuotasServiceContract {
         Context context = new Context();
         testee().recomputeCurrentQuotas(context, RunningOptions.DEFAULT).block();
 
-        assertThat(context.snapshot())
-            .isEqualTo(new Context(2L, ImmutableList.of()).snapshot());
+        assertThat(context.snapshot().getResults())
+            .containsExactlyInAnyOrderElementsOf(new Context(ImmutableMap.of(QuotaComponent.MAILBOX, new Context.Statistic(2L, ImmutableList.of()),
+                QuotaComponent.JMAP_UPLOADS, new Context.Statistic(2L, ImmutableList.of()))).snapshot().getResults());
     }
 
     default void appendAMessageForUser(MessageManager messageManager, MailboxSession session) throws Exception {
diff --git a/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskSerializationTest.java b/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskSerializationTest.java
index 116ae10180..ac37d2837b 100644
--- a/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskSerializationTest.java
+++ b/mailbox/tools/quota-recompute/src/test/java/org/apache/james/mailbox/quota/task/RecomputeCurrentQuotasTaskSerializationTest.java
@@ -25,6 +25,7 @@ import static org.mockito.Mockito.mock;
 import java.time.Instant;
 
 import org.apache.james.JsonSerializationVerifier;
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.json.JsonGenericSerializer;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
 import org.junit.jupiter.api.Test;
@@ -36,12 +37,20 @@ class RecomputeCurrentQuotasTaskSerializationTest {
     static final String QUOTA_ROOT_AS_STRING = "bob@localhost";
 
     static final RecomputeCurrentQuotasService SERVICE = mock(RecomputeCurrentQuotasService.class);
-    static final RecomputeCurrentQuotasTask TASK = new RecomputeCurrentQuotasTask(SERVICE, RunningOptions.withUsersPerSecond(17));
+    static final RecomputeCurrentQuotasTask TASK = new RecomputeCurrentQuotasTask(SERVICE, RunningOptions.of(17, ImmutableList.of(QuotaComponent.MAILBOX)));
     static final RecomputeCurrentQuotasTask TASK_DEFAULT = new RecomputeCurrentQuotasTask(SERVICE, RunningOptions.DEFAULT);
     static final String SERIALIZED_TASK_LEGACY = "{\"type\": \"recompute-current-quotas\"}";
-    static final String SERIALIZED_TASK = "{\"type\": \"recompute-current-quotas\",\"runningOptions\":{\"usersPerSecond\":17}}";
-    static final RecomputeCurrentQuotasTask.Details DETAILS = new RecomputeCurrentQuotasTask.Details(TIMESTAMP, 12, ImmutableList.of(QUOTA_ROOT_AS_STRING), RunningOptions.withUsersPerSecond(17));
-    static final RecomputeCurrentQuotasTask.Details DETAILS_DEFAULT = new RecomputeCurrentQuotasTask.Details(TIMESTAMP, 12, ImmutableList.of(QUOTA_ROOT_AS_STRING), RunningOptions.DEFAULT);
+    static final String SERIALIZED_TASK = "{\"type\": \"recompute-current-quotas\",\"runningOptions\":{\"usersPerSecond\":17,\"quotaComponents\":[\"MAILBOX\"]}}";
+    static final RecomputeCurrentQuotasTask.Details DETAILS = new RecomputeCurrentQuotasTask.Details(TIMESTAMP,
+        ImmutableList.of(new RecomputeSingleQuotaComponentResult(QuotaComponent.MAILBOX.getValue(),
+            12,
+            ImmutableList.of(QUOTA_ROOT_AS_STRING))),
+        RunningOptions.of(17, ImmutableList.of(QuotaComponent.MAILBOX)));
+    static final RecomputeCurrentQuotasTask.Details DETAILS_DEFAULT = new RecomputeCurrentQuotasTask.Details(TIMESTAMP,
+        ImmutableList.of(new RecomputeSingleQuotaComponentResult(QuotaComponent.MAILBOX.getValue(),
+            12,
+            ImmutableList.of(QUOTA_ROOT_AS_STRING))),
+        RunningOptions.DEFAULT);
     static final String SERIALIZED_ADDITIONAL_INFORMATION_LEGACY = "{" +
         "  \"type\":\"recompute-current-quotas\"," +
         "  \"processedQuotaRoots\":12," +
@@ -52,7 +61,8 @@ class RecomputeCurrentQuotasTaskSerializationTest {
         "  \"type\":\"recompute-current-quotas\"," +
         "  \"processedQuotaRoots\":12," +
         "  \"failedQuotaRoots\":[\"bob@localhost\"]," +
-        "  \"runningOptions\":{\"usersPerSecond\":17}," +
+        "  \"recomputeSingleQuotaComponentResults\":[{\"quotaComponent\":\"MAILBOX\",\"processedIdentifierCount\":12,\"failedIdentifiers\":[\"bob@localhost\"]}]," +
+        "  \"runningOptions\":{\"usersPerSecond\":17,\"quotaComponents\":[\"MAILBOX\"]}," +
         "  \"timestamp\":\"2018-11-13T12:00:55Z\"" +
         "}";
 
diff --git a/server/apps/distributed-app/docs/modules/ROOT/pages/operate/webadmin.adoc b/server/apps/distributed-app/docs/modules/ROOT/pages/operate/webadmin.adoc
index dcaec35bee..0ff242d344 100644
--- a/server/apps/distributed-app/docs/modules/ROOT/pages/operate/webadmin.adoc
+++ b/server/apps/distributed-app/docs/modules/ROOT/pages/operate/webadmin.adoc
@@ -2327,10 +2327,16 @@ second. Defaults to 1.
 This optional parameter must have a strictly positive integer as a value
 and be passed as query parameters.
 
+An admin can select which quota component he wants to recompute:
+
+* `quotaComponent` component whose quota need to be reprocessed. It could be one of values: MAILBOX, SIEVE, JMAP_UPLOADS.
+
+The admin could select several quota components. If he does not select, quotas of all components would be recomputed.
+
 Example:
 
 ....
-curl -XPOST /quota/users?task=RecomputeCurrentQuotas&usersPerSecond=20
+curl -XPOST /quota/users?task=RecomputeCurrentQuotas&usersPerSecond=20&quotaComponent=MAILBOX&quotaComponent=JMAP_UPLOADS
 ....
 
 The scheduled task will have the following type
@@ -2339,8 +2345,18 @@ The scheduled task will have the following type
 ....
 {
   "type":"recompute-current-quotas",
-  "processedQuotaRoots": 3,
-  "failedQuotaRoots": ["#private&bob@localhost"],
+  "recomputeSingleQuotaComponentResults": [
+    {
+      "quotaComponent": "MAILBOX",
+      "processedIdentifierCount": 3,
+      "failedIdentifiers": ["#private&bob@localhost"]
+    },
+    {
+      "quotaComponent": "JMAP_UPLOADS",
+      "processedIdentifierCount": 3,
+      "failedIdentifiers": ["bob@localhost"]
+    }
+  ],
   "runningOptions": {
     "usersPerSecond":20
   }
diff --git a/server/container/guice/protocols/webadmin-jmap/src/main/java/org/apache/james/modules/server/JmapTaskSerializationModule.java b/server/container/guice/protocols/webadmin-jmap/src/main/java/org/apache/james/modules/server/JmapTaskSerializationModule.java
index 13a1a189e4..c7233e1c28 100644
--- a/server/container/guice/protocols/webadmin-jmap/src/main/java/org/apache/james/modules/server/JmapTaskSerializationModule.java
+++ b/server/container/guice/protocols/webadmin-jmap/src/main/java/org/apache/james/modules/server/JmapTaskSerializationModule.java
@@ -19,6 +19,8 @@
 package org.apache.james.modules.server;
 
 import org.apache.james.jmap.api.filtering.impl.EventSourcingFilteringManagement;
+import org.apache.james.jmap.api.upload.RecomputeJMAPUploadCurrentQuotasService;
+import org.apache.james.mailbox.quota.task.RecomputeSingleComponentCurrentQuotasService;
 import org.apache.james.server.task.json.dto.AdditionalInformationDTO;
 import org.apache.james.server.task.json.dto.AdditionalInformationDTOModule;
 import org.apache.james.server.task.json.dto.TaskDTO;
@@ -39,10 +41,19 @@ import org.apache.james.webadmin.data.jmap.RecomputeUserFastViewTaskAdditionalIn
 import org.apache.james.webadmin.dto.DTOModuleInjections;
 
 import com.google.inject.AbstractModule;
+import com.google.inject.multibindings.Multibinder;
 import com.google.inject.multibindings.ProvidesIntoSet;
 import com.google.inject.name.Named;
 
 public class JmapTaskSerializationModule extends AbstractModule {
+
+    @Override
+    protected void configure() {
+        Multibinder.newSetBinder(binder(), RecomputeSingleComponentCurrentQuotasService.class)
+            .addBinding()
+            .to(RecomputeJMAPUploadCurrentQuotasService.class);
+    }
+
     @ProvidesIntoSet
     public TaskDTOModule<? extends Task, ? extends TaskDTO> recomputeAllJmapPreviewsTask(MessageFastViewProjectionCorrector corrector) {
         return RecomputeAllFastViewProjectionItemsTask.module(corrector);
diff --git a/server/container/guice/protocols/webadmin-mailbox/src/main/java/org/apache/james/modules/server/MailboxRoutesModule.java b/server/container/guice/protocols/webadmin-mailbox/src/main/java/org/apache/james/modules/server/MailboxRoutesModule.java
index d3c7b48df1..99b650ee93 100644
--- a/server/container/guice/protocols/webadmin-mailbox/src/main/java/org/apache/james/modules/server/MailboxRoutesModule.java
+++ b/server/container/guice/protocols/webadmin-mailbox/src/main/java/org/apache/james/modules/server/MailboxRoutesModule.java
@@ -25,6 +25,8 @@ import static org.apache.james.webadmin.routes.MailboxesRoutes.ONE_MAIL_TASKS;
 import static org.apache.james.webadmin.routes.UserMailboxesRoutes.USER_MAILBOXES_OPERATIONS_INJECTION_KEY;
 import static org.apache.james.webadmin.routes.UserQuotaRoutes.USER_QUOTAS_OPERATIONS_INJECTION_KEY;
 
+import org.apache.james.mailbox.quota.task.RecomputeMailboxCurrentQuotasService;
+import org.apache.james.mailbox.quota.task.RecomputeSingleComponentCurrentQuotasService;
 import org.apache.james.webadmin.Routes;
 import org.apache.james.webadmin.jackson.QuotaModule;
 import org.apache.james.webadmin.routes.DomainQuotaRoutes;
@@ -66,6 +68,10 @@ public class MailboxRoutesModule extends AbstractModule {
         Multibinder.newSetBinder(binder(), TaskRegistration.class, Names.named(ONE_MAIL_TASKS));
         Multibinder.newSetBinder(binder(), TaskRegistration.class, Names.named(USER_QUOTAS_OPERATIONS_INJECTION_KEY));
 
+        Multibinder.newSetBinder(binder(), RecomputeSingleComponentCurrentQuotasService.class)
+            .addBinding()
+            .to(RecomputeMailboxCurrentQuotasService.class);
+
         userBoundTasks.addBinding().to(SubscribeAllRequestToTask.class);
         allMailboxesTasks.addBinding().to(CreateMissingParentsRequestToTask.class);
     }
diff --git a/server/data/data-jmap-cassandra/src/test/java/org/apache/james/jmap/cassandra/upload/CassandraJMAPCurrentUploadUsageCalculatorTest.java b/server/data/data-jmap-cassandra/src/test/java/org/apache/james/jmap/cassandra/upload/CassandraJMAPCurrentUploadUsageCalculatorTest.java
new file mode 100644
index 0000000000..93df1ee8e7
--- /dev/null
+++ b/server/data/data-jmap-cassandra/src/test/java/org/apache/james/jmap/cassandra/upload/CassandraJMAPCurrentUploadUsageCalculatorTest.java
@@ -0,0 +1,72 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ ****************************************************************/
+
+package org.apache.james.jmap.cassandra.upload;
+
+import java.time.Clock;
+
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.components.CassandraModule;
+import org.apache.james.backends.cassandra.components.CassandraMutualizedQuotaModule;
+import org.apache.james.backends.cassandra.components.CassandraQuotaCurrentValueDao;
+import org.apache.james.blob.api.BucketName;
+import org.apache.james.blob.api.HashBlobId;
+import org.apache.james.blob.memory.MemoryBlobStoreDAO;
+import org.apache.james.jmap.api.upload.JMAPCurrentUploadUsageCalculator;
+import org.apache.james.jmap.api.upload.JMAPCurrentUploadUsageCalculatorContract;
+import org.apache.james.jmap.api.upload.UploadRepository;
+import org.apache.james.jmap.api.upload.UploadUsageRepository;
+import org.apache.james.server.blob.deduplication.DeDuplicationBlobStore;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+public class CassandraJMAPCurrentUploadUsageCalculatorTest implements JMAPCurrentUploadUsageCalculatorContract {
+
+    @RegisterExtension
+    static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(CassandraModule.aggregateModules(UploadModule.MODULE, CassandraMutualizedQuotaModule.MODULE));
+
+    private UploadRepository uploadRepository;
+    private UploadUsageRepository uploadUsageRepository;
+    private JMAPCurrentUploadUsageCalculator jmapCurrentUploadUsageCalculator;
+
+    @BeforeEach
+    private void setup() {
+        Clock clock = Clock.systemUTC();
+        uploadRepository = new CassandraUploadRepository(new UploadDAO(cassandraCluster.getCassandraCluster().getConf(),
+            new HashBlobId.Factory()), new DeDuplicationBlobStore(new MemoryBlobStoreDAO(), BucketName.of("default"), new HashBlobId.Factory()),
+            clock);
+        uploadUsageRepository = new CassandraUploadUsageRepository(new CassandraQuotaCurrentValueDao(cassandraCluster.getCassandraCluster().getConf()));
+        jmapCurrentUploadUsageCalculator = new JMAPCurrentUploadUsageCalculator(uploadRepository, uploadUsageRepository);
+    }
+
+    @Override
+    public UploadRepository uploadRepository() {
+        return uploadRepository;
+    }
+
+    @Override
+    public UploadUsageRepository uploadUsageRepository() {
+        return uploadUsageRepository;
+    }
+
+    @Override
+    public JMAPCurrentUploadUsageCalculator currentUploadUsageRecomputator() {
+        return jmapCurrentUploadUsageCalculator;
+    }
+}
diff --git a/server/data/data-jmap/pom.xml b/server/data/data-jmap/pom.xml
index a20f50791f..a032dc3b72 100644
--- a/server/data/data-jmap/pom.xml
+++ b/server/data/data-jmap/pom.xml
@@ -43,6 +43,10 @@
             <type>test-jar</type>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>${james.groupId}</groupId>
+            <artifactId>apache-james-mailbox-tools-quota-recompute</artifactId>
+        </dependency>
         <dependency>
             <groupId>${james.groupId}</groupId>
             <artifactId>blob-api</artifactId>
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java b/server/data/data-jmap/src/main/java/org/apache/james/jmap/api/upload/JMAPCurrentUploadUsageCalculator.java
similarity index 54%
copy from mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
copy to server/data/data-jmap/src/main/java/org/apache/james/jmap/api/upload/JMAPCurrentUploadUsageCalculator.java
index e73d267a18..8a08e32fee 100644
--- a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
+++ b/server/data/data-jmap/src/main/java/org/apache/james/jmap/api/upload/JMAPCurrentUploadUsageCalculator.java
@@ -17,34 +17,32 @@
  * under the License.                                           *
  ****************************************************************/
 
-package org.apache.james.mailbox.quota.task;
+package org.apache.james.jmap.api.upload;
 
-import java.util.Optional;
+import javax.inject.Inject;
 
-import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
+import org.apache.james.core.Username;
+import org.apache.james.core.quota.QuotaSizeUsage;
+import org.apache.james.jmap.api.model.UploadMetaData;
 
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
 
-public class RunningOptionsDTO {
-    public static RunningOptionsDTO asDTO(RunningOptions domainObject) {
-        return new RunningOptionsDTO(Optional.of(domainObject.getUsersPerSecond()));
-    }
-
-    private final Optional<Integer> usersPerSecond;
+public class JMAPCurrentUploadUsageCalculator {
 
-    @JsonCreator
-    public RunningOptionsDTO(
-            @JsonProperty("usersPerSecond") Optional<Integer> usersPerSecond) {
-        this.usersPerSecond = usersPerSecond;
-    }
+    private final UploadRepository uploadRepository;
+    private final UploadUsageRepository uploadUsageRepository;
 
-    public Optional<Integer> getUsersPerSecond() {
-        return usersPerSecond;
+    @Inject
+    public JMAPCurrentUploadUsageCalculator(UploadRepository uploadRepository, UploadUsageRepository uploadUsageRepository) {
+        this.uploadRepository = uploadRepository;
+        this.uploadUsageRepository = uploadUsageRepository;
     }
 
-    public RunningOptions asDomainObject() {
-        return usersPerSecond.map(RunningOptions::withUsersPerSecond)
-            .orElse(RunningOptions.DEFAULT);
+    public Mono<Void> recomputeCurrentUploadUsage(Username username) {
+        return Flux.from(uploadRepository.listUploads(username))
+            .map(UploadMetaData::sizeAsLong)
+            .reduce(Long::sum)
+            .flatMap(sum -> Mono.from(uploadUsageRepository.resetSpace(username, QuotaSizeUsage.size(sum))));
     }
 }
diff --git a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java b/server/data/data-jmap/src/main/java/org/apache/james/jmap/api/upload/RecomputeJMAPUploadCurrentQuotasService.java
similarity index 55%
copy from mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
copy to server/data/data-jmap/src/main/java/org/apache/james/jmap/api/upload/RecomputeJMAPUploadCurrentQuotasService.java
index e73d267a18..53c5aab8fc 100644
--- a/mailbox/tools/quota-recompute/src/main/java/org/apache/james/mailbox/quota/task/RunningOptionsDTO.java
+++ b/server/data/data-jmap/src/main/java/org/apache/james/jmap/api/upload/RecomputeJMAPUploadCurrentQuotasService.java
@@ -17,34 +17,32 @@
  * under the License.                                           *
  ****************************************************************/
 
-package org.apache.james.mailbox.quota.task;
+package org.apache.james.jmap.api.upload;
 
-import java.util.Optional;
+import javax.inject.Inject;
 
-import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService.RunningOptions;
+import org.apache.james.core.Username;
+import org.apache.james.core.quota.QuotaComponent;
+import org.apache.james.mailbox.quota.task.RecomputeSingleComponentCurrentQuotasService;
 
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
+import reactor.core.publisher.Mono;
 
-public class RunningOptionsDTO {
-    public static RunningOptionsDTO asDTO(RunningOptions domainObject) {
-        return new RunningOptionsDTO(Optional.of(domainObject.getUsersPerSecond()));
-    }
+public class RecomputeJMAPUploadCurrentQuotasService implements RecomputeSingleComponentCurrentQuotasService {
 
-    private final Optional<Integer> usersPerSecond;
+    private final JMAPCurrentUploadUsageCalculator jmapCurrentUploadUsageCalculator;
 
-    @JsonCreator
-    public RunningOptionsDTO(
-            @JsonProperty("usersPerSecond") Optional<Integer> usersPerSecond) {
-        this.usersPerSecond = usersPerSecond;
+    @Inject
+    public RecomputeJMAPUploadCurrentQuotasService(JMAPCurrentUploadUsageCalculator jmapCurrentUploadUsageCalculator) {
+        this.jmapCurrentUploadUsageCalculator = jmapCurrentUploadUsageCalculator;
     }
 
-    public Optional<Integer> getUsersPerSecond() {
-        return usersPerSecond;
+    @Override
+    public QuotaComponent getQuotaComponent() {
+        return QuotaComponent.JMAP_UPLOADS;
     }
 
-    public RunningOptions asDomainObject() {
-        return usersPerSecond.map(RunningOptions::withUsersPerSecond)
-            .orElse(RunningOptions.DEFAULT);
+    @Override
+    public Mono<Void> recomputeCurrentQuotas(Username username) {
+        return jmapCurrentUploadUsageCalculator.recomputeCurrentUploadUsage(username);
     }
 }
diff --git a/server/data/data-jmap/src/test/java/org/apache/james/jmap/api/upload/JMAPCurrentUploadUsageCalculatorContract.scala b/server/data/data-jmap/src/test/java/org/apache/james/jmap/api/upload/JMAPCurrentUploadUsageCalculatorContract.scala
new file mode 100644
index 0000000000..a65970df1f
--- /dev/null
+++ b/server/data/data-jmap/src/test/java/org/apache/james/jmap/api/upload/JMAPCurrentUploadUsageCalculatorContract.scala
@@ -0,0 +1,62 @@
+/** **************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0                 *
+ * *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ * ************************************************************** */
+
+package org.apache.james.jmap.api.upload
+
+import java.nio.charset.StandardCharsets
+
+import org.apache.commons.io.IOUtils
+import org.apache.james.core.Username
+import org.apache.james.core.quota.QuotaSizeUsage
+import org.apache.james.jmap.api.upload.JMAPCurrentUploadUsageCalculatorContract.USER_1
+import org.apache.james.mailbox.model.ContentType
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import reactor.core.publisher.Mono
+
+object JMAPCurrentUploadUsageCalculatorContract {
+  val USER_1: Username = Username.of("user1")
+}
+
+trait JMAPCurrentUploadUsageCalculatorContract {
+  def uploadRepository: UploadRepository
+  def uploadUsageRepository: UploadUsageRepository
+  def currentUploadUsageRecomputator: JMAPCurrentUploadUsageCalculator
+
+  @Test
+  def recomputeCurrentUploadUsageShouldRecomputeSuccessfully(): Unit = {
+    uploadUsageRepository.increaseSpace(USER_1, QuotaSizeUsage.size(100L));
+
+    val data1 = IOUtils.toInputStream("123456", StandardCharsets.UTF_8)
+    Mono.from(uploadRepository.upload(data1, ContentType.of("text/html"), USER_1)).block()
+    val data2 = IOUtils.toInputStream("12345678", StandardCharsets.UTF_8)
+    Mono.from(uploadRepository.upload(data2, ContentType.of("text/html"), USER_1)).block();
+
+    currentUploadUsageRecomputator.recomputeCurrentUploadUsage(USER_1).block();
+    assertThat(Mono.from(uploadUsageRepository.getSpaceUsage(USER_1)).block.asLong()).isEqualTo(14L)
+  }
+
+  @Test
+  def recomputeCurrentUploadUsageShouldRecomputeSuccessfullyWhenUserHasNoUpload(): Unit = {
+    uploadUsageRepository.increaseSpace(USER_1, QuotaSizeUsage.size(100L));
+
+    currentUploadUsageRecomputator.recomputeCurrentUploadUsage(USER_1).block();
+    assertThat(Mono.from(uploadUsageRepository.getSpaceUsage(USER_1)).block.asLong()).isEqualTo(0L)
+  }
+}
diff --git a/server/data/data-jmap/src/test/java/org/apache/james/jmap/memory/upload/InMemoryJMAPCurrentUploadUsageCalculatorTest.java b/server/data/data-jmap/src/test/java/org/apache/james/jmap/memory/upload/InMemoryJMAPCurrentUploadUsageCalculatorTest.java
new file mode 100644
index 0000000000..64c4530075
--- /dev/null
+++ b/server/data/data-jmap/src/test/java/org/apache/james/jmap/memory/upload/InMemoryJMAPCurrentUploadUsageCalculatorTest.java
@@ -0,0 +1,63 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ ****************************************************************/
+
+package org.apache.james.jmap.memory.upload;
+
+import java.time.Clock;
+
+import org.apache.james.blob.api.BlobStore;
+import org.apache.james.blob.api.BucketName;
+import org.apache.james.blob.api.HashBlobId;
+import org.apache.james.blob.memory.MemoryBlobStoreDAO;
+import org.apache.james.jmap.api.upload.JMAPCurrentUploadUsageCalculator;
+import org.apache.james.jmap.api.upload.JMAPCurrentUploadUsageCalculatorContract;
+import org.apache.james.jmap.api.upload.UploadRepository;
+import org.apache.james.jmap.api.upload.UploadUsageRepository;
+import org.apache.james.server.blob.deduplication.DeDuplicationBlobStore;
+import org.junit.jupiter.api.BeforeEach;
+
+public class InMemoryJMAPCurrentUploadUsageCalculatorTest implements JMAPCurrentUploadUsageCalculatorContract {
+
+    private UploadRepository uploadRepository;
+    private UploadUsageRepository uploadUsageRepository;
+    private JMAPCurrentUploadUsageCalculator jmapCurrentUploadUsageCalculator;
+
+    @BeforeEach
+    private void setup() {
+        BlobStore blobStore = new DeDuplicationBlobStore(new MemoryBlobStoreDAO(), BucketName.DEFAULT, new HashBlobId.Factory());
+        uploadRepository = new InMemoryUploadRepository(blobStore, Clock.systemUTC());
+        uploadUsageRepository = new InMemoryUploadUsageRepository();
+        jmapCurrentUploadUsageCalculator = new JMAPCurrentUploadUsageCalculator(uploadRepository, uploadUsageRepository);
+    }
+
+    @Override
+    public UploadRepository uploadRepository() {
+        return uploadRepository;
+    }
+
+    @Override
+    public UploadUsageRepository uploadUsageRepository() {
+        return uploadUsageRepository;
+    }
+
+    @Override
+    public JMAPCurrentUploadUsageCalculator currentUploadUsageRecomputator() {
+        return jmapCurrentUploadUsageCalculator;
+    }
+}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/UserQuotaRoutes.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/UserQuotaRoutes.java
index b3c6a9578b..af00cd3e42 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/UserQuotaRoutes.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/UserQuotaRoutes.java
@@ -21,6 +21,8 @@ package org.apache.james.webadmin.routes;
 
 import static org.apache.james.webadmin.routes.MailboxesRoutes.TASK_PARAMETER;
 
+import java.util.Arrays;
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -30,6 +32,7 @@ import javax.inject.Named;
 
 import org.apache.james.core.Domain;
 import org.apache.james.core.Username;
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.core.quota.QuotaCountLimit;
 import org.apache.james.core.quota.QuotaSizeLimit;
 import org.apache.james.mailbox.quota.task.RecomputeCurrentQuotasService;
@@ -59,6 +62,9 @@ import org.apache.james.webadmin.validation.QuotaDTOValidator;
 import org.apache.james.webadmin.validation.Quotas;
 import org.eclipse.jetty.http.HttpStatus;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
 import spark.Request;
 import spark.Route;
 import spark.Service;
@@ -69,6 +75,10 @@ public class UserQuotaRoutes implements Routes {
 
     public static class RecomputeCurrentQuotasRequestToTask extends TaskFromRequestRegistry.TaskRegistration {
         private static final String USERS_PER_SECOND = "usersPerSecond";
+        private static final String QUOTA_COMPONENT = "quotaComponent";
+        private static final ImmutableMap<String, QuotaComponent> QUOTA_COMPONENT_MAP = ImmutableMap.of(QuotaComponent.MAILBOX.getValue(), QuotaComponent.MAILBOX,
+                QuotaComponent.SIEVE.getValue(), QuotaComponent.SIEVE,
+                QuotaComponent.JMAP_UPLOADS.getValue(), QuotaComponent.JMAP_UPLOADS);
 
         @Inject
         public RecomputeCurrentQuotasRequestToTask(RecomputeCurrentQuotasService service) {
@@ -76,9 +86,7 @@ public class UserQuotaRoutes implements Routes {
         }
 
         private static RunningOptions parseRunningOptions(Request request) {
-            return intQueryParameter(request)
-                .map(RunningOptions::withUsersPerSecond)
-                .orElse(RunningOptions.DEFAULT);
+            return RunningOptions.of(intQueryParameter(request).orElse(RunningOptions.DEFAULT_USERS_PER_SECOND), getQuotaComponent(request));
         }
 
         private static Optional<Integer> intQueryParameter(Request request) {
@@ -90,6 +98,16 @@ public class UserQuotaRoutes implements Routes {
                     "strictly positive optional integer", USERS_PER_SECOND), e);
             }
         }
+
+        private static List<QuotaComponent> getQuotaComponent(Request request) {
+            return Optional.ofNullable(request.queryParamsValues(QUOTA_COMPONENT))
+                .map(quotaComponentStrings -> Arrays.stream(quotaComponentStrings)
+                    .map(quotaComponentString -> Optional.ofNullable(QUOTA_COMPONENT_MAP.get(quotaComponentString.toUpperCase()))
+                        .orElseThrow(() -> new IllegalArgumentException(String.format("Illegal value supplied for query parameter '%s' with value '%s', expecting existing " +
+                            "quota components", QUOTA_COMPONENT, quotaComponentString))))
+                    .collect(Collectors.toUnmodifiableList()))
+                .orElse(ImmutableList.of());
+        }
     }
 
     private static final TaskRegistrationKey RECOMPUTE_CURRENT_QUOTAS = TaskRegistrationKey.of("RecomputeCurrentQuotas");
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserQuotaRoutesTest.java b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserQuotaRoutesTest.java
index f7311b3e2c..fe9efbf06b 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserQuotaRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/UserQuotaRoutesTest.java
@@ -38,6 +38,7 @@ import java.util.Map;
 
 import org.apache.james.core.Domain;
 import org.apache.james.core.Username;
+import org.apache.james.core.quota.QuotaComponent;
 import org.apache.james.core.quota.QuotaCountLimit;
 import org.apache.james.core.quota.QuotaCountUsage;
 import org.apache.james.core.quota.QuotaSizeLimit;
@@ -1378,6 +1379,21 @@ class UserQuotaRoutesTest {
                 .body("details", is("'usersPerSecond' needs to be strictly positive"));
         }
 
+        @Test
+        void postShouldFailWhenQuotaComponentIsWrong() {
+            given()
+                .queryParam("task", "RecomputeCurrentQuotas")
+                .queryParam("quotaComponent", QuotaComponent.MAILBOX.getValue())
+                .queryParam("quotaComponent", "invalid")
+                .post("/quota/users")
+                .then()
+                .statusCode(HttpStatus.BAD_REQUEST_400)
+                .body("statusCode", is(400))
+                .body("type", is(ErrorResponder.ErrorType.INVALID_ARGUMENT.getType()))
+                .body("message", is("Invalid arguments supplied in the user request"))
+                .body("details", is("Illegal value supplied for query parameter 'quotaComponent' with value 'invalid', expecting existing quota components"));
+        }
+
         @Test
         void postShouldCreateANewTask() {
             given()
@@ -1393,6 +1409,8 @@ class UserQuotaRoutesTest {
             given()
                 .queryParam("task", "RecomputeCurrentQuotas")
                 .queryParam("usersPerSecond", "1")
+                .queryParam("quotaComponent", QuotaComponent.MAILBOX.getValue())
+                .queryParam("quotaComponent", QuotaComponent.JMAP_UPLOADS.getValue())
                 .post("/quota/users")
             .then()
                 .statusCode(HttpStatus.CREATED_201)
@@ -1441,5 +1459,26 @@ class UserQuotaRoutesTest {
                 .body("type", is("recompute-current-quotas"))
                 .body("additionalInformation.runningOptions.usersPerSecond", is(20));
         }
+
+        @Test
+        void quotaComponentsShouldBePartOfTaskDetails() {
+            String taskId = with()
+                .queryParam("task", "RecomputeCurrentQuotas")
+                .queryParam("quotaComponent", QuotaComponent.MAILBOX.getValue())
+                .queryParam("quotaComponent", "JMAP_UPLOADS")
+                .post("/quota/users")
+                .jsonPath()
+                .get("taskId");
+
+            given()
+                .basePath(TasksRoutes.BASE)
+                .when()
+                .get(taskId + "/await")
+                .then()
+                .body("taskId", is(taskId))
+                .body("type", is("recompute-current-quotas"))
+                .body("additionalInformation.runningOptions.quotaComponents",
+                    containsInAnyOrder(QuotaComponent.MAILBOX.getValue(), QuotaComponent.JMAP_UPLOADS.getValue()));
+        }
     }
 }
diff --git a/src/site/markdown/server/manage-webadmin.md b/src/site/markdown/server/manage-webadmin.md
index 0042970a98..f1bb6a26c2 100644
--- a/src/site/markdown/server/manage-webadmin.md
+++ b/src/site/markdown/server/manage-webadmin.md
@@ -2000,10 +2000,16 @@ An admin can specify the concurrency that should be used when running the task:
  
 This optional parameter must have a strictly positive integer as a value and be passed as query parameters.
 
+An admin can select which quota component he wants to recompute:
+
+- `quotaComponent` component whose quota need to be reprocessed. It could be one of values: MAILBOX, SIEVE, JMAP_UPLOADS.
+
+The admin could select several quota components. If he does not select, quotas of all components would be recomputed.
+
 Example:
 
 ```
-curl -XPOST /quota/users?task=RecomputeCurrentQuotas&usersPerSecond=20
+curl -XPOST /quota/users?task=RecomputeCurrentQuotas&usersPerSecond=20&quotaComponent=MAILBOX&quotaComponent=JMAP_UPLOADS
 ```
 
 The scheduled task will have the following type `recompute-current-quotas` and the following `additionalInformation`:
@@ -2011,8 +2017,18 @@ The scheduled task will have the following type `recompute-current-quotas` and t
 ```
 {
   "type":"recompute-current-quotas",
-  "processedQuotaRoots": 3,
-  "failedQuotaRoots": ["#private&bob@localhost"],
+  "recomputeSingleQuotaComponentResults": [
+    {
+      "quotaComponent": "MAILBOX",
+      "processedIdentifierCount": 3,
+      "failedIdentifiers": ["#private&bob@localhost"]
+    },
+    {
+      "quotaComponent": "JMAP_UPLOADS",
+      "processedIdentifierCount": 3,
+      "failedIdentifiers": ["bob@localhost"]
+    }
+  ],
   "runningOptions": {
     "usersPerSecond":20
   }


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