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"aComponent=MAILBOX"aComponent=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"aComponent=MAILBOX"aComponent=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