You are viewing a plain text version of this content. The canonical link for it is here.
Posted to server-dev@james.apache.org by bt...@apache.org on 2019/11/19 02:43:42 UTC
[james-project] 40/43: JAMES-2964 differentiate domain objects for
quota limits and quota usages
This is an automated email from the ASF dual-hosted git repository.
btellier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit 05078f9e4b4451df1687a0e9f355d94365c37edc
Author: Rémi KOWALSKI <rk...@linagora.com>
AuthorDate: Thu Nov 7 13:42:18 2019 +0100
JAMES-2964 differentiate domain objects for quota limits and quota usages
---
.../{QuotaCount.java => QuotaCountLimit.java} | 30 ++---
.../{QuotaCount.java => QuotaCountUsage.java} | 48 +++++---
.../{QuotaValue.java => QuotaLimitValue.java} | 2 +-
.../quota/{QuotaSize.java => QuotaSizeLimit.java} | 30 ++---
.../quota/{QuotaSize.java => QuotaSizeUsage.java} | 39 +++---
.../{QuotaValue.java => QuotaUsageValue.java} | 8 +-
...uotaCountTest.java => QuotaCountLimitTest.java} | 12 +-
...QuotaSizeTest.java => QuotaCountUsageTest.java} | 22 ++--
...uotaValueTest.java => QuotaLimitValueTest.java} | 2 +-
...{QuotaSizeTest.java => QuotaSizeLimitTest.java} | 12 +-
...{QuotaSizeTest.java => QuotaSizeUsageTest.java} | 22 ++--
...uotaValueTest.java => QuotaUsageValueTest.java} | 35 +++---
.../james/mailbox/events/MailboxListener.java | 26 ++--
.../mailbox/exception/OverQuotaException.java | 15 +--
.../java/org/apache/james/mailbox/model/Quota.java | 37 +++---
.../org/apache/james/mailbox/model/QuotaRatio.java | 18 +--
.../james/mailbox/model/SerializableQuota.java | 25 ++--
...Value.java => SerializableQuotaLimitValue.java} | 60 ++++-----
...Value.java => SerializableQuotaUsageValue.java} | 61 ++++-----
.../org/apache/james/mailbox/probe/QuotaProbe.java | 28 +++--
.../james/mailbox/quota/CurrentQuotaManager.java | 8 +-
.../james/mailbox/quota/MaxQuotaManager.java | 44 +++----
.../apache/james/mailbox/quota/QuotaManager.java | 10 +-
.../apache/james/mailbox/MailboxListenerTest.java | 19 +--
.../apache/james/mailbox/MailboxManagerTest.java | 23 ++--
.../mailbox/manager/ManagerTestProvisionner.java | 8 +-
.../mailbox/manager/QuotaMessageManagerTest.java | 38 +++---
.../apache/james/mailbox/model/QuotaRatioTest.java | 18 +--
.../org/apache/james/mailbox/model/QuotaTest.java | 43 +++----
.../apache/james/mailbox/quota/QuotaFixture.java | 102 ++++++++--------
.../quota/CassandraCurrentQuotaManager.java | 16 +--
.../quota/CassandraGlobalMaxQuotaDao.java | 12 +-
.../quota/CassandraPerDomainMaxQuotaDao.java | 12 +-
.../quota/CassandraPerUserMaxQuotaDao.java | 12 +-
.../quota/CassandraPerUserMaxQuotaManager.java | 32 ++---
.../james/mailbox/cassandra/quota/QuotaCodec.java | 18 +--
.../scala/org/apache/james/event/json/DTOs.scala | 10 +-
.../apache/james/event/json/EventSerializer.scala | 41 ++++---
.../json/MailboxDeletionSerializationTest.java | 8 +-
.../QuotaUsageUpdatedEventSerializationTest.java | 18 +--
.../james/event/json/dtos/QuotaCountTest.java | 89 +++++++++-----
.../james/event/json/dtos/QuotaSizeTest.java | 89 +++++++++-----
.../mailbox/jpa/quota/JPAPerUserMaxQuotaDAO.java | 54 ++++----
.../jpa/quota/JPAPerUserMaxQuotaManager.java | 32 ++---
.../mailbox/jpa/quota/JpaCurrentQuotaManager.java | 12 +-
.../mailbox/jpa/quota/model/JpaCurrentQuota.java | 12 +-
.../quota/InMemoryCurrentQuotaManager.java | 12 +-
.../quota/InMemoryPerUserMaxQuotaManager.java | 44 +++----
.../quota/InMemoryCurrentQuotaManagerTest.java | 12 +-
.../mailbox/quota/cassandra/dto/QuotaDTO.java | 24 ++--
.../james/mailbox/quota/cassandra/dto/DTOTest.java | 16 +--
.../mailing/aggregates/UserQuotaThresholds.java | 10 +-
.../mailing/commands/DetectThresholdCrossing.java | 16 +--
.../mailing/events/QuotaThresholdChangedEvent.java | 16 +--
.../mailing/subscribers/QuotaThresholdNotice.java | 20 +--
.../james/mailbox/quota/model/QuotaThreshold.java | 2 +-
.../james/mailbox/quota/model/QuotaThresholds.java | 2 +-
.../subscribers/QuotaThresholdNoticeTest.java | 30 ++---
.../mailbox/quota/model/QuotaThresholdTest.java | 9 +-
.../mailbox/quota/model/QuotaThresholdsTest.java | 16 +--
.../ElasticSearchQuotaSearcherTest.java | 6 +-
.../elasticsearch/json/QuotaRatioAsJsonTest.java | 18 +--
.../quota/search/scanning/ClauseConverter.java | 10 +-
.../james/quota/search/QuotaSearcherContract.java | 22 ++--
.../james/mailbox/store/StoreMailboxManager.java | 8 +-
.../james/mailbox/store/event/EventFactory.java | 26 ++--
.../mailbox/store/quota/FixedMaxQuotaManager.java | 36 +++---
.../mailbox/store/quota/NoMaxQuotaManager.java | 32 ++---
.../james/mailbox/store/quota/NoQuotaManager.java | 22 ++--
.../james/mailbox/store/quota/QuotaChecker.java | 16 +--
.../mailbox/store/quota/StoreQuotaManager.java | 22 ++--
.../store/AbstractMessageIdManagerQuotaTest.java | 14 +--
.../AbstractMessageIdManagerSideEffectTest.java | 21 ++--
.../store/event/MailboxAnnotationListenerTest.java | 8 +-
.../store/quota/GenericMaxQuotaManagerTest.java | 136 ++++++++++-----------
.../quota/ListeningCurrentQuotaUpdaterTest.java | 12 +-
.../mailbox/store/quota/QuotaCheckerTest.java | 26 ++--
.../store/quota/StoreCurrentQuotaManagerTest.java | 18 +--
.../mailbox/store/quota/StoreQuotaManagerTest.java | 30 ++---
.../org/apache/james/mpt/api/ImapHostSystem.java | 6 +-
.../apache/james/mpt/host/ExternalHostSystem.java | 6 +-
.../cassandra/host/CassandraHostSystem.java | 6 +-
.../james/mpt/imapmailbox/suite/QuotaTest.java | 8 +-
.../imapmailbox/cyrus/host/CyrusHostSystem.java | 6 +-
.../host/ElasticSearchHostSystem.java | 6 +-
.../host/external/ExternalJamesImapHostSystem.java | 6 +-
.../inmemory/host/InMemoryHostSystem.java | 6 +-
.../mpt/imapmailbox/jpa/host/JPAHostSystem.java | 6 +-
.../lucenesearch/host/LuceneSearchHostSystem.java | 6 +-
.../maildir/host/MaildirHostSystem.java | 6 +-
.../rabbitmq/host/RabbitMQEventBusHostSystem.java | 6 +-
.../james/mpt/host/JamesManageSieveHostSystem.java | 4 +-
.../james/imap/encode/QuotaResponseEncoder.java | 6 +-
.../james/imap/message/response/QuotaResponse.java | 6 +-
.../james/imap/processor/GetQuotaProcessor.java | 10 +-
.../imap/processor/GetQuotaRootProcessor.java | 10 +-
.../imap/encode/QuotaResponseEncoderTest.java | 10 +-
.../imap/message/response/QuotaResponseTest.java | 15 +--
.../imap/processor/GetQuotaProcessorTest.java | 14 ++-
.../imap/processor/GetQuotaRootProcessorTest.java | 14 ++-
.../main/java/org/apache/james/cli/ServerCmd.java | 36 +++---
.../apache/james/cli/probe/impl/JmxQuotaProbe.java | 28 +++--
.../java/org/apache/james/cli/ServerCmdTest.java | 36 +++---
.../java/org/apache/james/JPAJamesServerTest.java | 6 +-
.../org/apache/james/modules/QuotaProbesImpl.java | 48 ++++----
.../james/modules/protocols/SieveProbeImpl.java | 6 +-
.../james/adapter/mailbox/QuotaManagement.java | 48 ++++----
.../adapter/mailbox/QuotaManagementMBean.java | 28 +++--
.../mailbox/MaxQuotaConfigurationReader.java | 12 +-
.../sieverepository/api/SieveQuotaRepository.java | 10 +-
.../sieve/cassandra/CassandraSieveQuotaDAO.java | 14 +--
.../sieve/cassandra/CassandraSieveRepository.java | 18 +--
.../james/sieve/cassandra/model/SieveQuota.java | 11 +-
.../cassandra/CassandraSieveQuotaDAOTest.java | 4 +-
.../sieve/cassandra/model/SieveQuotaTest.java | 8 +-
.../sieverepository/file/SieveFileRepository.java | 14 +--
.../apache/james/sieve/jpa/JPASieveRepository.java | 29 ++---
.../james/sieve/jpa/model/JPASieveQuota.java | 8 +-
.../lib/SieveRepositoryManagement.java | 6 +-
.../lib/AbstractSieveRepositoryTest.java | 16 +--
.../memory/InMemorySieveQuotaRepository.java | 16 +--
.../transport/mailets/IsOverQuotaMatcherTest.java | 12 +-
.../james/transport/matchers/IsOverQuotaTest.java | 16 +--
.../integration/GetMailboxesMethodTest.java | 14 +--
.../methods/integration/QuotaMailingTest.java | 8 +-
.../methods/integration/SendMDNMethodTest.java | 6 +-
.../methods/integration/SetMessagesMethodTest.java | 10 +-
.../james/jmap/draft/model/mailbox/Quotas.java | 21 ++--
.../james/jmap/draft/utils/quotas/QuotaLoader.java | 17 ++-
.../james/webadmin/routes/SieveQuotaRoutes.java | 16 +--
.../webadmin/routes/SieveQuotaRoutesTest.java | 14 +--
.../apache/james/webadmin/dto/OccupationDTO.java | 8 +-
.../james/webadmin/dto/OccupationRatioDTO.java | 8 +-
.../apache/james/webadmin/dto/QuotaDetailsDTO.java | 8 +-
.../james/webadmin/dto/QuotaValueDeserializer.java | 4 +-
.../james/webadmin/dto/QuotaValueSerializer.java | 4 +-
.../james/webadmin/dto/ValidatedQuotaDTO.java | 22 ++--
.../apache/james/webadmin/jackson/QuotaModule.java | 12 +-
.../james/webadmin/routes/DomainQuotaRoutes.java | 12 +-
.../james/webadmin/routes/GlobalQuotaRoutes.java | 16 +--
.../james/webadmin/routes/UserQuotaRoutes.java | 12 +-
.../james/webadmin/service/DomainQuotaService.java | 12 +-
.../james/webadmin/service/GlobalQuotaService.java | 16 +--
.../james/webadmin/service/UserQuotaService.java | 14 +--
.../webadmin/validation/QuotaDTOValidator.java | 20 +--
.../apache/james/webadmin/validation/Quotas.java | 16 +--
...t.java => QuotaLimitValueDeserializerTest.java} | 14 +--
.../webadmin/dto/UsersQuotaDetailsDTOTest.java | 10 +-
.../webadmin/routes/DomainQuotaRoutesTest.java | 78 ++++++------
.../webadmin/routes/GlobalQuotaRoutesTest.java | 68 +++++------
.../james/webadmin/routes/UserQuotaRoutesTest.java | 108 ++++++++--------
...uotaValueTest.java => QuotaLimitValueTest.java} | 10 +-
152 files changed, 1683 insertions(+), 1512 deletions(-)
diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaCount.java b/core/src/main/java/org/apache/james/core/quota/QuotaCountLimit.java
similarity index 72%
copy from core/src/main/java/org/apache/james/core/quota/QuotaCount.java
copy to core/src/main/java/org/apache/james/core/quota/QuotaCountLimit.java
index 0eb6915..1867e83 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaCount.java
+++ b/core/src/main/java/org/apache/james/core/quota/QuotaCountLimit.java
@@ -24,24 +24,24 @@ import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
-public class QuotaCount implements QuotaValue<QuotaCount> {
+public class QuotaCountLimit implements QuotaLimitValue<QuotaCountLimit> {
- public static QuotaCount unlimited() {
- return new QuotaCount(Optional.empty());
+ public static QuotaCountLimit unlimited() {
+ return new QuotaCountLimit(Optional.empty());
}
- public static QuotaCount count(long value) {
+ public static QuotaCountLimit count(long value) {
return count(Optional.of(value));
}
- public static QuotaCount count(Optional<Long> value) {
- return new QuotaCount(value);
+ public static QuotaCountLimit count(Optional<Long> value) {
+ return new QuotaCountLimit(value);
}
private final Optional<Long> value;
- private QuotaCount(Optional<Long> value) {
- Preconditions.checkArgument(QuotaValue.isValidValue(value), "Quota limit should be positive");
+ private QuotaCountLimit(Optional<Long> value) {
+ Preconditions.checkArgument(QuotaLimitValue.isValidValue(value), "Quota limit should be positive");
this.value = value;
}
@@ -56,16 +56,16 @@ public class QuotaCount implements QuotaValue<QuotaCount> {
}
@Override
- public QuotaCount add(long additionalValue) {
- return new QuotaCount(value.map(x -> x + additionalValue));
+ public QuotaCountLimit add(long additionalValue) {
+ return new QuotaCountLimit(value.map(x -> x + additionalValue));
}
@Override
- public QuotaCount add(QuotaCount additionalValue) {
+ public QuotaCountLimit add(QuotaCountLimit additionalValue) {
if (additionalValue.isUnlimited()) {
return unlimited();
}
- return new QuotaCount(value.map(x -> x + additionalValue.asLong()));
+ return new QuotaCountLimit(value.map(x -> x + additionalValue.asLong()));
}
@Override
@@ -76,14 +76,14 @@ public class QuotaCount implements QuotaValue<QuotaCount> {
}
@Override
- public boolean isGreaterThan(QuotaCount other) {
+ public boolean isGreaterThan(QuotaCountLimit other) {
return value.orElse(Long.MAX_VALUE) > other.value.orElse(Long.MAX_VALUE);
}
@Override
public final boolean equals(Object o) {
- if (o instanceof QuotaCount) {
- QuotaCount that = (QuotaCount) o;
+ if (o instanceof QuotaCountLimit) {
+ QuotaCountLimit that = (QuotaCountLimit) o;
return Objects.equal(this.value, that.value);
}
return false;
diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaCount.java b/core/src/main/java/org/apache/james/core/quota/QuotaCountUsage.java
similarity index 68%
rename from core/src/main/java/org/apache/james/core/quota/QuotaCount.java
rename to core/src/main/java/org/apache/james/core/quota/QuotaCountUsage.java
index 0eb6915..7e67f1b 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaCount.java
+++ b/core/src/main/java/org/apache/james/core/quota/QuotaCountUsage.java
@@ -22,26 +22,24 @@ import java.util.Optional;
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-public class QuotaCount implements QuotaValue<QuotaCount> {
+public class QuotaCountUsage implements QuotaUsageValue<QuotaCountUsage, QuotaCountLimit> {
- public static QuotaCount unlimited() {
- return new QuotaCount(Optional.empty());
+ public static QuotaCountUsage unlimited() {
+ return new QuotaCountUsage(Optional.empty());
}
- public static QuotaCount count(long value) {
+ public static QuotaCountUsage count(long value) {
return count(Optional.of(value));
}
- public static QuotaCount count(Optional<Long> value) {
- return new QuotaCount(value);
+ public static QuotaCountUsage count(Optional<Long> value) {
+ return new QuotaCountUsage(value);
}
private final Optional<Long> value;
- private QuotaCount(Optional<Long> value) {
- Preconditions.checkArgument(QuotaValue.isValidValue(value), "Quota limit should be positive");
+ private QuotaCountUsage(Optional<Long> value) {
this.value = value;
}
@@ -56,16 +54,30 @@ public class QuotaCount implements QuotaValue<QuotaCount> {
}
@Override
- public QuotaCount add(long additionalValue) {
- return new QuotaCount(value.map(x -> x + additionalValue));
+ public QuotaCountUsage add(long additionalValue) {
+ return new QuotaCountUsage(value.map(x -> x + additionalValue));
}
@Override
- public QuotaCount add(QuotaCount additionalValue) {
+ public QuotaCountUsage add(QuotaCountUsage additionalValue) {
if (additionalValue.isUnlimited()) {
return unlimited();
}
- return new QuotaCount(value.map(x -> x + additionalValue.asLong()));
+ return new QuotaCountUsage(value.map(x -> x + additionalValue.asLong()));
+ }
+
+ @Override
+ public boolean greaterThan(QuotaCountUsage other) {
+ return value.orElse(Long.MAX_VALUE) > other.value.orElse(Long.MAX_VALUE);
+ }
+
+ @Override
+ public boolean exceedLimit(QuotaCountLimit limit) {
+ if (limit.isLimited()) {
+ return value.orElse(Long.MAX_VALUE) > limit.asLong();
+ } else {
+ return false;
+ }
}
@Override
@@ -76,14 +88,9 @@ public class QuotaCount implements QuotaValue<QuotaCount> {
}
@Override
- public boolean isGreaterThan(QuotaCount other) {
- return value.orElse(Long.MAX_VALUE) > other.value.orElse(Long.MAX_VALUE);
- }
-
- @Override
public final boolean equals(Object o) {
- if (o instanceof QuotaCount) {
- QuotaCount that = (QuotaCount) o;
+ if (o instanceof QuotaCountUsage) {
+ QuotaCountUsage that = (QuotaCountUsage) o;
return Objects.equal(this.value, that.value);
}
return false;
@@ -93,4 +100,5 @@ public class QuotaCount implements QuotaValue<QuotaCount> {
public final int hashCode() {
return Objects.hashCode(value);
}
+
}
diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaValue.java b/core/src/main/java/org/apache/james/core/quota/QuotaLimitValue.java
similarity index 96%
copy from core/src/main/java/org/apache/james/core/quota/QuotaValue.java
copy to core/src/main/java/org/apache/james/core/quota/QuotaLimitValue.java
index 4f07eec..ff32575 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaValue.java
+++ b/core/src/main/java/org/apache/james/core/quota/QuotaLimitValue.java
@@ -20,7 +20,7 @@ package org.apache.james.core.quota;
import java.util.Optional;
-public interface QuotaValue<T extends QuotaValue<T>> {
+public interface QuotaLimitValue<T extends QuotaLimitValue<T>> {
static boolean isValidValue(Optional<Long> value) {
return !value.isPresent() || value.get() >= 0;
diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaSize.java b/core/src/main/java/org/apache/james/core/quota/QuotaSizeLimit.java
similarity index 71%
copy from core/src/main/java/org/apache/james/core/quota/QuotaSize.java
copy to core/src/main/java/org/apache/james/core/quota/QuotaSizeLimit.java
index 22d788f..d8997ae 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaSize.java
+++ b/core/src/main/java/org/apache/james/core/quota/QuotaSizeLimit.java
@@ -24,26 +24,26 @@ import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
-public class QuotaSize implements QuotaValue<QuotaSize> {
+public class QuotaSizeLimit implements QuotaLimitValue<QuotaSizeLimit> {
- public static final QuotaSize QUOTA_SIZE = new QuotaSize(Optional.empty());
+ public static final QuotaSizeLimit QUOTA_SIZE = new QuotaSizeLimit(Optional.empty());
- public static QuotaSize unlimited() {
+ public static QuotaSizeLimit unlimited() {
return QUOTA_SIZE;
}
- public static QuotaSize size(long value) {
+ public static QuotaSizeLimit size(long value) {
return size(Optional.of(value));
}
- public static QuotaSize size(Optional<Long> value) {
- return new QuotaSize(value);
+ public static QuotaSizeLimit size(Optional<Long> value) {
+ return new QuotaSizeLimit(value);
}
private final Optional<Long> value;
- private QuotaSize(Optional<Long> value) {
- Preconditions.checkArgument(QuotaValue.isValidValue(value), "Quota limit should be positive");
+ private QuotaSizeLimit(Optional<Long> value) {
+ Preconditions.checkArgument(QuotaLimitValue.isValidValue(value), "Quota limit should be positive");
this.value = value;
}
@@ -58,20 +58,20 @@ public class QuotaSize implements QuotaValue<QuotaSize> {
}
@Override
- public QuotaSize add(long additionalValue) {
- return new QuotaSize(value.map(x -> x + additionalValue));
+ public QuotaSizeLimit add(long additionalValue) {
+ return new QuotaSizeLimit(value.map(x -> x + additionalValue));
}
@Override
- public QuotaSize add(QuotaSize additionalValue) {
+ public QuotaSizeLimit add(QuotaSizeLimit additionalValue) {
if (additionalValue.isUnlimited()) {
return unlimited();
}
- return new QuotaSize(value.map(x -> x + additionalValue.asLong()));
+ return new QuotaSizeLimit(value.map(x -> x + additionalValue.asLong()));
}
@Override
- public boolean isGreaterThan(QuotaSize other) {
+ public boolean isGreaterThan(QuotaSizeLimit other) {
return value.orElse(Long.MAX_VALUE) > other.value.orElse(Long.MAX_VALUE);
}
@@ -84,8 +84,8 @@ public class QuotaSize implements QuotaValue<QuotaSize> {
@Override
public final boolean equals(Object o) {
- if (o instanceof QuotaSize) {
- QuotaSize that = (QuotaSize) o;
+ if (o instanceof QuotaSizeLimit) {
+ QuotaSizeLimit that = (QuotaSizeLimit) o;
return Objects.equal(this.value, that.value);
}
return false;
diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaSize.java b/core/src/main/java/org/apache/james/core/quota/QuotaSizeUsage.java
similarity index 68%
rename from core/src/main/java/org/apache/james/core/quota/QuotaSize.java
rename to core/src/main/java/org/apache/james/core/quota/QuotaSizeUsage.java
index 22d788f..7bc74fb 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaSize.java
+++ b/core/src/main/java/org/apache/james/core/quota/QuotaSizeUsage.java
@@ -22,28 +22,26 @@ import java.util.Optional;
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-public class QuotaSize implements QuotaValue<QuotaSize> {
+public class QuotaSizeUsage implements QuotaUsageValue<QuotaSizeUsage, QuotaSizeLimit> {
- public static final QuotaSize QUOTA_SIZE = new QuotaSize(Optional.empty());
+ public static final QuotaSizeUsage QUOTA_SIZE = new QuotaSizeUsage(Optional.empty());
- public static QuotaSize unlimited() {
+ public static QuotaSizeUsage unlimited() {
return QUOTA_SIZE;
}
- public static QuotaSize size(long value) {
+ public static QuotaSizeUsage size(long value) {
return size(Optional.of(value));
}
- public static QuotaSize size(Optional<Long> value) {
- return new QuotaSize(value);
+ public static QuotaSizeUsage size(Optional<Long> value) {
+ return new QuotaSizeUsage(value);
}
private final Optional<Long> value;
- private QuotaSize(Optional<Long> value) {
- Preconditions.checkArgument(QuotaValue.isValidValue(value), "Quota limit should be positive");
+ private QuotaSizeUsage(Optional<Long> value) {
this.value = value;
}
@@ -58,24 +56,33 @@ public class QuotaSize implements QuotaValue<QuotaSize> {
}
@Override
- public QuotaSize add(long additionalValue) {
- return new QuotaSize(value.map(x -> x + additionalValue));
+ public QuotaSizeUsage add(long additionalValue) {
+ return new QuotaSizeUsage(value.map(x -> x + additionalValue));
}
@Override
- public QuotaSize add(QuotaSize additionalValue) {
+ public QuotaSizeUsage add(QuotaSizeUsage additionalValue) {
if (additionalValue.isUnlimited()) {
return unlimited();
}
- return new QuotaSize(value.map(x -> x + additionalValue.asLong()));
+ return new QuotaSizeUsage(value.map(x -> x + additionalValue.asLong()));
}
@Override
- public boolean isGreaterThan(QuotaSize other) {
+ public boolean greaterThan(QuotaSizeUsage other) {
return value.orElse(Long.MAX_VALUE) > other.value.orElse(Long.MAX_VALUE);
}
@Override
+ public boolean exceedLimit(QuotaSizeLimit limit) {
+ if (limit.isLimited()) {
+ return value.orElse(Long.MAX_VALUE) > limit.asLong();
+ } else {
+ return false;
+ }
+ }
+
+ @Override
public String toString() {
return MoreObjects.toStringHelper(this)
.add("value", value.map(String::valueOf).orElse("unlimited"))
@@ -84,8 +91,8 @@ public class QuotaSize implements QuotaValue<QuotaSize> {
@Override
public final boolean equals(Object o) {
- if (o instanceof QuotaSize) {
- QuotaSize that = (QuotaSize) o;
+ if (o instanceof QuotaSizeUsage) {
+ QuotaSizeUsage that = (QuotaSizeUsage) o;
return Objects.equal(this.value, that.value);
}
return false;
diff --git a/core/src/main/java/org/apache/james/core/quota/QuotaValue.java b/core/src/main/java/org/apache/james/core/quota/QuotaUsageValue.java
similarity index 87%
rename from core/src/main/java/org/apache/james/core/quota/QuotaValue.java
rename to core/src/main/java/org/apache/james/core/quota/QuotaUsageValue.java
index 4f07eec..d96d55d 100644
--- a/core/src/main/java/org/apache/james/core/quota/QuotaValue.java
+++ b/core/src/main/java/org/apache/james/core/quota/QuotaUsageValue.java
@@ -20,10 +20,10 @@ package org.apache.james.core.quota;
import java.util.Optional;
-public interface QuotaValue<T extends QuotaValue<T>> {
+public interface QuotaUsageValue<T extends QuotaUsageValue<T, U>, U extends QuotaLimitValue<U>> {
static boolean isValidValue(Optional<Long> value) {
- return !value.isPresent() || value.get() >= 0;
+ return !value.isPresent() || value.get() >= -1;
}
long asLong();
@@ -38,5 +38,7 @@ public interface QuotaValue<T extends QuotaValue<T>> {
T add(T additionalValue);
- boolean isGreaterThan(T other);
+ boolean greaterThan(T other);
+
+ boolean exceedLimit(U limit);
}
diff --git a/core/src/test/java/org/apache/james/core/quota/QuotaCountTest.java b/core/src/test/java/org/apache/james/core/quota/QuotaCountLimitTest.java
similarity index 81%
rename from core/src/test/java/org/apache/james/core/quota/QuotaCountTest.java
rename to core/src/test/java/org/apache/james/core/quota/QuotaCountLimitTest.java
index 4722297..f001076 100644
--- a/core/src/test/java/org/apache/james/core/quota/QuotaCountTest.java
+++ b/core/src/test/java/org/apache/james/core/quota/QuotaCountLimitTest.java
@@ -22,21 +22,21 @@ import org.junit.jupiter.api.Test;
import nl.jqno.equalsverifier.EqualsVerifier;
-public class QuotaCountTest implements QuotaValueTest<QuotaCount> {
+public class QuotaCountLimitTest implements QuotaLimitValueTest<QuotaCountLimit> {
@Override
- public QuotaCount instance(long value) {
- return QuotaCount.count(value);
+ public QuotaCountLimit instance(long value) {
+ return QuotaCountLimit.count(value);
}
@Override
- public QuotaCount unlimited() {
- return QuotaCount.unlimited();
+ public QuotaCountLimit unlimited() {
+ return QuotaCountLimit.unlimited();
}
@Test
void shouldRespectBeanContract() {
- EqualsVerifier.forClass(QuotaCount.class).verify();
+ EqualsVerifier.forClass(QuotaCountLimit.class).verify();
}
}
diff --git a/core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java b/core/src/test/java/org/apache/james/core/quota/QuotaCountUsageTest.java
similarity index 75%
copy from core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java
copy to core/src/test/java/org/apache/james/core/quota/QuotaCountUsageTest.java
index 7d1fa7b..5e6679a 100644
--- a/core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java
+++ b/core/src/test/java/org/apache/james/core/quota/QuotaCountUsageTest.java
@@ -18,25 +18,19 @@
****************************************************************/
package org.apache.james.core.quota;
-import org.junit.jupiter.api.Test;
-
-import nl.jqno.equalsverifier.EqualsVerifier;
-
-public class QuotaSizeTest implements QuotaValueTest<QuotaSize> {
-
+public class QuotaCountUsageTest implements QuotaUsageValueTest<QuotaCountLimit, QuotaCountUsage> {
@Override
- public QuotaSize instance(long value) {
- return QuotaSize.size(value);
+ public QuotaCountUsage usageInstance(long value) {
+ return QuotaCountUsage.count(value);
}
@Override
- public QuotaSize unlimited() {
- return QuotaSize.unlimited();
+ public QuotaCountLimit limitInstance(long value) {
+ return QuotaCountLimit.count(value);
}
- @Test
- void shouldRespectBeanContract() {
- EqualsVerifier.forClass(QuotaSize.class).verify();
+ @Override
+ public QuotaCountLimit unlimited() {
+ return QuotaCountLimit.unlimited();
}
-
}
diff --git a/core/src/test/java/org/apache/james/core/quota/QuotaValueTest.java b/core/src/test/java/org/apache/james/core/quota/QuotaLimitValueTest.java
similarity index 97%
copy from core/src/test/java/org/apache/james/core/quota/QuotaValueTest.java
copy to core/src/test/java/org/apache/james/core/quota/QuotaLimitValueTest.java
index 8545e31..8a8e28f 100644
--- a/core/src/test/java/org/apache/james/core/quota/QuotaValueTest.java
+++ b/core/src/test/java/org/apache/james/core/quota/QuotaLimitValueTest.java
@@ -22,7 +22,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
-public interface QuotaValueTest<T extends QuotaValue<T>> {
+public interface QuotaLimitValueTest<T extends QuotaLimitValue<T>> {
T instance(long i);
diff --git a/core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java b/core/src/test/java/org/apache/james/core/quota/QuotaSizeLimitTest.java
similarity index 81%
copy from core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java
copy to core/src/test/java/org/apache/james/core/quota/QuotaSizeLimitTest.java
index 7d1fa7b..d540166 100644
--- a/core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java
+++ b/core/src/test/java/org/apache/james/core/quota/QuotaSizeLimitTest.java
@@ -22,21 +22,21 @@ import org.junit.jupiter.api.Test;
import nl.jqno.equalsverifier.EqualsVerifier;
-public class QuotaSizeTest implements QuotaValueTest<QuotaSize> {
+public class QuotaSizeLimitTest implements QuotaLimitValueTest<QuotaSizeLimit> {
@Override
- public QuotaSize instance(long value) {
- return QuotaSize.size(value);
+ public QuotaSizeLimit instance(long value) {
+ return QuotaSizeLimit.size(value);
}
@Override
- public QuotaSize unlimited() {
- return QuotaSize.unlimited();
+ public QuotaSizeLimit unlimited() {
+ return QuotaSizeLimit.unlimited();
}
@Test
void shouldRespectBeanContract() {
- EqualsVerifier.forClass(QuotaSize.class).verify();
+ EqualsVerifier.forClass(QuotaSizeLimit.class).verify();
}
}
diff --git a/core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java b/core/src/test/java/org/apache/james/core/quota/QuotaSizeUsageTest.java
similarity index 75%
rename from core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java
rename to core/src/test/java/org/apache/james/core/quota/QuotaSizeUsageTest.java
index 7d1fa7b..7e81862 100644
--- a/core/src/test/java/org/apache/james/core/quota/QuotaSizeTest.java
+++ b/core/src/test/java/org/apache/james/core/quota/QuotaSizeUsageTest.java
@@ -18,25 +18,19 @@
****************************************************************/
package org.apache.james.core.quota;
-import org.junit.jupiter.api.Test;
-
-import nl.jqno.equalsverifier.EqualsVerifier;
-
-public class QuotaSizeTest implements QuotaValueTest<QuotaSize> {
-
+public class QuotaSizeUsageTest implements QuotaUsageValueTest<QuotaSizeLimit, QuotaSizeUsage> {
@Override
- public QuotaSize instance(long value) {
- return QuotaSize.size(value);
+ public QuotaSizeUsage usageInstance(long value) {
+ return QuotaSizeUsage.size(value);
}
@Override
- public QuotaSize unlimited() {
- return QuotaSize.unlimited();
+ public QuotaSizeLimit limitInstance(long value) {
+ return QuotaSizeLimit.size(value);
}
- @Test
- void shouldRespectBeanContract() {
- EqualsVerifier.forClass(QuotaSize.class).verify();
+ @Override
+ public QuotaSizeLimit unlimited() {
+ return QuotaSizeLimit.unlimited();
}
-
}
diff --git a/core/src/test/java/org/apache/james/core/quota/QuotaValueTest.java b/core/src/test/java/org/apache/james/core/quota/QuotaUsageValueTest.java
similarity index 61%
rename from core/src/test/java/org/apache/james/core/quota/QuotaValueTest.java
rename to core/src/test/java/org/apache/james/core/quota/QuotaUsageValueTest.java
index 8545e31..8e4ddce 100644
--- a/core/src/test/java/org/apache/james/core/quota/QuotaValueTest.java
+++ b/core/src/test/java/org/apache/james/core/quota/QuotaUsageValueTest.java
@@ -22,54 +22,51 @@ import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
-public interface QuotaValueTest<T extends QuotaValue<T>> {
+public interface QuotaUsageValueTest<T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> {
- T instance(long i);
+ U usageInstance(long value);
+
+ T limitInstance(long value);
T unlimited();
@Test
default void greaterThanShouldReturnFalseWhenFirstEqualToSecond() {
- assertThat(instance(1).isGreaterThan(instance(1))).isFalse();
+ assertThat(usageInstance(1).greaterThan(usageInstance(1))).isFalse();
}
@Test
default void greaterThanShouldReturnFalseWhenFirstSmallerThanSecond() {
- assertThat(instance(1).isGreaterThan(instance(2))).isFalse();
+ assertThat(usageInstance(1).greaterThan(usageInstance(2))).isFalse();
}
@Test
default void greaterThanShouldReturnTrueWhenFirstGreaterThanSecond() {
- assertThat(instance(2).isGreaterThan(instance(1))).isTrue();
- }
-
- @Test
- default void greaterThanShouldReturnFalseWhenFirstIsLimitedAndSecondUnlimited() {
- assertThat(instance(1).isGreaterThan(unlimited())).isFalse();
+ assertThat(usageInstance(2).greaterThan(usageInstance(1))).isTrue();
}
@Test
- default void greaterThanShouldReturnFalseWhenBothAreUnlimited() {
- assertThat(unlimited().isGreaterThan(unlimited())).isFalse();
+ default void greaterThanShouldReturnFalseWhenUsageEqualToLimit() {
+ assertThat(usageInstance(1).exceedLimit(limitInstance(1))).isFalse();
}
@Test
- default void greaterThanShouldReturnTrueWhenFirstIsUnlimitedAndSecondLimited() {
- assertThat(unlimited().isGreaterThan(instance(1))).isTrue();
+ default void greaterThanShouldReturnFalseWhenUsageSmallerThanLimit() {
+ assertThat(usageInstance(1).exceedLimit(limitInstance(2))).isFalse();
}
@Test
- default void addShouldReturnUnlimitedWhenThisIsUnlimited() {
- assertThat(unlimited().add(2)).isEqualTo(unlimited());
+ default void greaterThanShouldReturnTrueWhenUsageGreaterThanLimit() {
+ assertThat(usageInstance(2).exceedLimit(limitInstance(1))).isTrue();
}
@Test
- default void addShouldReturnUnlimitedWhenBothAre() {
- assertThat(unlimited().add(unlimited())).isEqualTo(unlimited());
+ default void greaterThanShouldReturnFalseWhenUsageIsLimitedAndLimitIsUnlimited() {
+ assertThat(usageInstance(1).exceedLimit(unlimited())).isFalse();
}
@Test
default void addShouldReturnSumResult() {
- assertThat(instance(12).add(instance(23))).isEqualTo(instance(35));
+ assertThat(usageInstance(12).add(usageInstance(23))).isEqualTo(usageInstance(35));
}
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/events/MailboxListener.java b/mailbox/api/src/main/java/org/apache/james/mailbox/events/MailboxListener.java
index 34bfdc6..7c71968 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/events/MailboxListener.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/events/MailboxListener.java
@@ -27,8 +27,10 @@ import java.util.Objects;
import java.util.SortedMap;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.MessageUid;
import org.apache.james.mailbox.acl.ACLDiff;
@@ -83,11 +85,11 @@ public interface MailboxListener {
private final EventId eventId;
private final Username username;
private final QuotaRoot quotaRoot;
- private final Quota<QuotaCount> countQuota;
- private final Quota<QuotaSize> sizeQuota;
+ private final Quota<QuotaCountLimit, QuotaCountUsage> countQuota;
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota;
private final Instant instant;
- public QuotaUsageUpdatedEvent(EventId eventId, Username username, QuotaRoot quotaRoot, Quota<QuotaCount> countQuota, Quota<QuotaSize> sizeQuota, Instant instant) {
+ public QuotaUsageUpdatedEvent(EventId eventId, Username username, QuotaRoot quotaRoot, Quota<QuotaCountLimit, QuotaCountUsage> countQuota, Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Instant instant) {
this.eventId = eventId;
this.username = username;
this.quotaRoot = quotaRoot;
@@ -106,11 +108,11 @@ public interface MailboxListener {
return username;
}
- public Quota<QuotaCount> getCountQuota() {
+ public Quota<QuotaCountLimit, QuotaCountUsage> getCountQuota() {
return countQuota;
}
- public Quota<QuotaSize> getSizeQuota() {
+ public Quota<QuotaSizeLimit, QuotaSizeUsage> getSizeQuota() {
return sizeQuota;
}
@@ -218,10 +220,10 @@ public interface MailboxListener {
*/
class MailboxDeletion extends MailboxEvent {
private final QuotaRoot quotaRoot;
- private final QuotaCount deletedMessageCount;
- private final QuotaSize totalDeletedSize;
+ private final QuotaCountUsage deletedMessageCount;
+ private final QuotaSizeUsage totalDeletedSize;
- public MailboxDeletion(MailboxSession.SessionId sessionId, Username username, MailboxPath path, QuotaRoot quotaRoot, QuotaCount deletedMessageCount, QuotaSize totalDeletedSize,
+ public MailboxDeletion(MailboxSession.SessionId sessionId, Username username, MailboxPath path, QuotaRoot quotaRoot, QuotaCountUsage deletedMessageCount, QuotaSizeUsage totalDeletedSize,
MailboxId mailboxId, EventId eventId) {
super(sessionId, username, path, mailboxId, eventId);
this.quotaRoot = quotaRoot;
@@ -238,11 +240,11 @@ public interface MailboxListener {
return quotaRoot;
}
- public QuotaCount getDeletedMessageCount() {
+ public QuotaCountUsage getDeletedMessageCount() {
return deletedMessageCount;
}
- public QuotaSize getTotalDeletedSize() {
+ public QuotaSizeUsage getTotalDeletedSize() {
return totalDeletedSize;
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/exception/OverQuotaException.java b/mailbox/api/src/main/java/org/apache/james/mailbox/exception/OverQuotaException.java
index b8b13bd..711bfc0 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/exception/OverQuotaException.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/exception/OverQuotaException.java
@@ -18,7 +18,8 @@
****************************************************************/
package org.apache.james.mailbox.exception;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaUsageValue;
/**
* {@link MailboxException} which identicate that a user was over-quota
@@ -27,24 +28,24 @@ public class OverQuotaException extends MailboxException {
private static final long serialVersionUID = 532673188582481689L;
- private QuotaValue<?> used;
- private QuotaValue<?> max;
+ private QuotaUsageValue<?, ?> used;
+ private QuotaLimitValue<?> max;
- public OverQuotaException(String msg, QuotaValue<?> max, QuotaValue<?> used) {
+ public OverQuotaException(String msg, QuotaLimitValue<?> max, QuotaUsageValue<?, ?> used) {
super(msg);
this.used = used;
this.max = max;
}
- public OverQuotaException(QuotaValue<?> max, QuotaValue<?> used) {
+ public OverQuotaException(QuotaLimitValue<?> max, QuotaUsageValue<?, ?> used) {
this(null, max, used);
}
- public QuotaValue<?> getUsed() {
+ public QuotaUsageValue<?, ?> getUsed() {
return used;
}
- public QuotaValue<?> getMax() {
+ public QuotaLimitValue<?> getMax() {
return max;
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/model/Quota.java b/mailbox/api/src/main/java/org/apache/james/mailbox/model/Quota.java
index 0ea126f..0cbfe2e 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/model/Quota.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/model/Quota.java
@@ -20,13 +20,14 @@ package org.apache.james.mailbox.model;
import java.util.Map;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaUsageValue;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
-public class Quota<T extends QuotaValue<T>> {
+public class Quota<T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> {
public enum Scope {
Domain,
@@ -34,53 +35,53 @@ public class Quota<T extends QuotaValue<T>> {
User
}
- public static <T extends QuotaValue<T>> Builder<T> builder() {
+ public static <T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> Builder<T, U> builder() {
return new Builder<>();
}
- public static class Builder<T extends QuotaValue<T>> {
+ public static class Builder<T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> {
private final ImmutableMap.Builder<Scope, T> limitsByScope;
private T computedLimit;
- private T used;
+ private U used;
private Builder() {
limitsByScope = ImmutableMap.builder();
}
- public Builder<T> computedLimit(T limit) {
+ public Builder<T, U> computedLimit(T limit) {
this.computedLimit = limit;
return this;
}
- public Builder<T> used(T used) {
+ public Builder<T, U> used(U used) {
this.used = used;
return this;
}
- public Builder<T> limitsByScope(Map<Scope, T> limits) {
+ public Builder<T, U> limitsByScope(Map<Scope, T> limits) {
limitsByScope.putAll(limits);
return this;
}
- public Builder<T> limitForScope(T limit, Scope scope) {
+ public Builder<T, U> limitForScope(T limit, Scope scope) {
limitsByScope.put(scope, limit);
return this;
}
- public Quota<T> build() {
+ public Quota<T, U> build() {
Preconditions.checkState(used != null);
Preconditions.checkState(computedLimit != null);
- return new Quota<>(used, computedLimit, limitsByScope.build());
+ return new Quota<T, U>(used, computedLimit, limitsByScope.build());
}
}
private final T limit;
private final ImmutableMap<Scope, T> limitByScope;
- private final T used;
+ private final U used;
- private Quota(T used, T max, ImmutableMap<Scope, T> limitByScope) {
+ private Quota(U used, T max, ImmutableMap<Scope, T> limitByScope) {
this.used = used;
this.limit = max;
this.limitByScope = limitByScope;
@@ -90,7 +91,7 @@ public class Quota<T extends QuotaValue<T>> {
return limit;
}
- public T getUsed() {
+ public U getUsed() {
return used;
}
@@ -105,8 +106,8 @@ public class Quota<T extends QuotaValue<T>> {
return limitByScope;
}
- public Quota<T> addValueToQuota(T value) {
- return new Quota<>(used.add(value), limit, limitByScope);
+ public Quota<T, U> addValueToQuota(U value) {
+ return new Quota<T, U>(used.add(value), limit, limitByScope);
}
/**
@@ -120,7 +121,7 @@ public class Quota<T extends QuotaValue<T>> {
public boolean isOverQuotaWithAdditionalValue(long additionalValue) {
Preconditions.checkArgument(additionalValue >= 0);
- return limit.isLimited() && used.add(additionalValue).isGreaterThan(limit);
+ return limit.isLimited() && used.add(additionalValue).exceedLimit(limit);
}
@Override
@@ -133,7 +134,7 @@ public class Quota<T extends QuotaValue<T>> {
if (o == null || ! (o instanceof Quota)) {
return false;
}
- Quota<?> other = (Quota<?>) o;
+ Quota<?, ?> other = (Quota<?, ?>) o;
return Objects.equal(used, other.getUsed())
&& Objects.equal(limit,other.getLimit());
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/model/QuotaRatio.java b/mailbox/api/src/main/java/org/apache/james/mailbox/model/QuotaRatio.java
index 649439f..dcf3d15 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/model/QuotaRatio.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/model/QuotaRatio.java
@@ -20,33 +20,35 @@ package org.apache.james.mailbox.model;
import java.util.Objects;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
public class QuotaRatio {
- public static QuotaRatio from(Quota<QuotaSize> quotaSize, Quota<QuotaCount> quotaCount) {
+ public static QuotaRatio from(Quota<QuotaSizeLimit, QuotaSizeUsage> quotaSize, Quota<QuotaCountLimit, QuotaCountUsage> quotaCount) {
return new QuotaRatio(quotaSize, quotaCount);
}
- private final Quota<QuotaSize> quotaSize;
- private final Quota<QuotaCount> quotaCount;
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> quotaSize;
+ private final Quota<QuotaCountLimit, QuotaCountUsage> quotaCount;
- private QuotaRatio(Quota<QuotaSize> quotaSize, Quota<QuotaCount> quotaCount) {
+ private QuotaRatio(Quota<QuotaSizeLimit, QuotaSizeUsage> quotaSize, Quota<QuotaCountLimit, QuotaCountUsage> quotaCount) {
Preconditions.checkNotNull(quotaSize, "'quotaSize' is mandatory");
Preconditions.checkNotNull(quotaCount, "'quotaCount' is mandatory");
this.quotaSize = quotaSize;
this.quotaCount = quotaCount;
}
- public Quota<QuotaSize> getQuotaSize() {
+ public Quota<QuotaSizeLimit, QuotaSizeUsage> getQuotaSize() {
return quotaSize;
}
- public Quota<QuotaCount> getQuotaCount() {
+ public Quota<QuotaCountLimit, QuotaCountUsage> getQuotaCount() {
return quotaCount;
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuota.java b/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuota.java
index 4e1ff1d..a490201 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuota.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuota.java
@@ -23,29 +23,30 @@ import java.io.Serializable;
import java.util.Objects;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaUsageValue;
import com.google.common.base.MoreObjects;
-public class SerializableQuota<T extends QuotaValue<T>> implements Serializable {
+public class SerializableQuota<T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> implements Serializable {
public static final long UNLIMITED = -1;
- public static <U extends QuotaValue<U>> SerializableQuota<U> newInstance(Quota<U> quota) {
+ public static <T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> SerializableQuota<T, U> newInstance(Quota<T, U> quota) {
return newInstance(quota.getUsed(), quota.getLimit());
}
- public static <U extends QuotaValue<U>> SerializableQuota<U> newInstance(U used, U max) {
+ public static <T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> SerializableQuota<T, U> newInstance(U used, T max) {
return new SerializableQuota<>(
- new SerializableQuotaValue<>(used),
- new SerializableQuotaValue<>(max)
+ new SerializableQuotaUsageValue<>(used),
+ new SerializableQuotaLimitValue<>(max)
);
}
- private final SerializableQuotaValue<T> max;
- private final SerializableQuotaValue<T> used;
+ private final SerializableQuotaLimitValue<T> max;
+ private final SerializableQuotaUsageValue<T, U> used;
- private SerializableQuota(SerializableQuotaValue<T> used, SerializableQuotaValue<T> max) {
+ private SerializableQuota(SerializableQuotaUsageValue<T, U> used, SerializableQuotaLimitValue<T> max) {
this.max = max;
this.used = used;
}
@@ -55,13 +56,13 @@ public class SerializableQuota<T extends QuotaValue<T>> implements Serializable
}
public Long getUsed() {
- return Optional.ofNullable(used).map(SerializableQuotaValue::encodeAsLong).orElse(null);
+ return Optional.ofNullable(used).map(SerializableQuotaUsageValue::encodeAsLong).orElse(null);
}
@Override
public boolean equals(Object o) {
- if (o instanceof SerializableQuota<?>) {
- SerializableQuota<?> that = (SerializableQuota<?>) o;
+ if (o instanceof SerializableQuota<?, ?>) {
+ SerializableQuota<?, ?> that = (SerializableQuota<?,?>) o;
return Objects.equals(max, that.max) &&
Objects.equals(used, that.used);
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaValue.java b/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaLimitValue.java
similarity index 79%
copy from mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaValue.java
copy to mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaLimitValue.java
index 20689f9..07fe751 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaValue.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaLimitValue.java
@@ -24,32 +24,54 @@ import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
import com.google.common.base.MoreObjects;
-public class SerializableQuotaValue<T extends QuotaValue<T>> implements Serializable {
+public class SerializableQuotaLimitValue<T extends QuotaLimitValue<T>> implements Serializable {
- public static <U extends QuotaValue<U>> SerializableQuotaValue<U> valueOf(Optional<U> input) {
- return new SerializableQuotaValue<>(input.orElse(null));
+ public static <U extends QuotaLimitValue<U>> SerializableQuotaLimitValue<U> valueOf(Optional<U> input) {
+ return new SerializableQuotaLimitValue<>(input.orElse(null));
}
public static final long UNLIMITED = -1;
+ private static <U extends QuotaLimitValue<U>> Long encodeAsLong(U quota) {
+ if (quota.isLimited()) {
+ return quota.asLong();
+ }
+ return UNLIMITED;
+ }
+
private final Long value;
- public SerializableQuotaValue(T value) {
+ public SerializableQuotaLimitValue(T value) {
this(encodeAsLong(value));
}
- SerializableQuotaValue(Long value) {
+ SerializableQuotaLimitValue(Long value) {
this.value = value;
}
+ public Long encodeAsLong() {
+ return value;
+ }
+
+ public Optional<T> toValue(Function<Long, T> factory, T unlimited) {
+ Long longValue = encodeAsLong();
+ if (longValue == null) {
+ return Optional.empty();
+ }
+ if (longValue == UNLIMITED) {
+ return Optional.of(unlimited);
+ }
+ return Optional.of(factory.apply(longValue));
+ }
+
@Override
public boolean equals(Object o) {
- if (o instanceof SerializableQuotaValue<?>) {
- SerializableQuotaValue<?> that = (SerializableQuotaValue<?>) o;
+ if (o instanceof SerializableQuotaLimitValue<?>) {
+ SerializableQuotaLimitValue<?> that = (SerializableQuotaLimitValue<?>) o;
return Objects.equals(value, that.value);
}
return false;
@@ -66,26 +88,4 @@ public class SerializableQuotaValue<T extends QuotaValue<T>> implements Serializ
.add("value", value)
.toString();
}
-
- private static <U extends QuotaValue<U>> Long encodeAsLong(U quota) {
- if (quota.isLimited()) {
- return quota.asLong();
- }
- return UNLIMITED;
- }
-
- public Long encodeAsLong() {
- return value;
- }
-
- public Optional<T> toValue(Function<Long, T> factory, T unlimited) {
- Long longValue = encodeAsLong();
- if (longValue == null) {
- return Optional.empty();
- }
- if (longValue == UNLIMITED) {
- return Optional.of(unlimited);
- }
- return Optional.of(factory.apply(longValue));
- }
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaValue.java b/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaUsageValue.java
similarity index 73%
rename from mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaValue.java
rename to mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaUsageValue.java
index 20689f9..d62bc71 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaValue.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/model/SerializableQuotaUsageValue.java
@@ -24,32 +24,55 @@ import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaUsageValue;
import com.google.common.base.MoreObjects;
-public class SerializableQuotaValue<T extends QuotaValue<T>> implements Serializable {
+public class SerializableQuotaUsageValue<T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> implements Serializable {
- public static <U extends QuotaValue<U>> SerializableQuotaValue<U> valueOf(Optional<U> input) {
- return new SerializableQuotaValue<>(input.orElse(null));
+ public static <T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> SerializableQuotaUsageValue<T, U> valueOf(Optional<U> input) {
+ return new SerializableQuotaUsageValue<T, U>(input.orElse(null));
}
public static final long UNLIMITED = -1;
+ private static <T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> Long encodeAsLong(U quota) {
+ if (quota.isLimited()) {
+ return quota.asLong();
+ }
+ return UNLIMITED;
+ }
+
private final Long value;
- public SerializableQuotaValue(T value) {
+ public SerializableQuotaUsageValue(U value) {
this(encodeAsLong(value));
}
- SerializableQuotaValue(Long value) {
+ SerializableQuotaUsageValue(Long value) {
this.value = value;
}
+ public Long encodeAsLong() {
+ return value;
+ }
+
+ public Optional<U> toValue(Function<Long, U> factory, U unlimited) {
+ Long longValue = encodeAsLong();
+ if (longValue == null) {
+ return Optional.empty();
+ }
+ if (longValue == UNLIMITED) {
+ return Optional.of(unlimited);
+ }
+ return Optional.of(factory.apply(longValue));
+ }
+
@Override
public boolean equals(Object o) {
- if (o instanceof SerializableQuotaValue<?>) {
- SerializableQuotaValue<?> that = (SerializableQuotaValue<?>) o;
+ if (o instanceof SerializableQuotaUsageValue<?, ?>) {
+ SerializableQuotaUsageValue<?, ?> that = (SerializableQuotaUsageValue<?,?>) o;
return Objects.equals(value, that.value);
}
return false;
@@ -66,26 +89,4 @@ public class SerializableQuotaValue<T extends QuotaValue<T>> implements Serializ
.add("value", value)
.toString();
}
-
- private static <U extends QuotaValue<U>> Long encodeAsLong(U quota) {
- if (quota.isLimited()) {
- return quota.asLong();
- }
- return UNLIMITED;
- }
-
- public Long encodeAsLong() {
- return value;
- }
-
- public Optional<T> toValue(Function<Long, T> factory, T unlimited) {
- Long longValue = encodeAsLong();
- if (longValue == null) {
- return Optional.empty();
- }
- if (longValue == UNLIMITED) {
- return Optional.of(unlimited);
- }
- return Optional.of(factory.apply(longValue));
- }
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/probe/QuotaProbe.java b/mailbox/api/src/main/java/org/apache/james/mailbox/probe/QuotaProbe.java
index 40f89ac..1a223a7 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/probe/QuotaProbe.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/probe/QuotaProbe.java
@@ -19,34 +19,36 @@
package org.apache.james.mailbox.probe;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.SerializableQuota;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
public interface QuotaProbe {
String getQuotaRoot(String namespace, String user, String name) throws MailboxException;
- SerializableQuota<QuotaCount> getMessageCountQuota(String quotaRoot) throws MailboxException;
+ SerializableQuota<QuotaCountLimit, QuotaCountUsage> getMessageCountQuota(String quotaRoot) throws MailboxException;
- SerializableQuota<QuotaSize> getStorageQuota(String quotaRoot) throws MailboxException;
+ SerializableQuota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(String quotaRoot) throws MailboxException;
- SerializableQuotaValue<QuotaCount> getMaxMessageCount(String quotaRoot) throws MailboxException;
+ SerializableQuotaLimitValue<QuotaCountLimit> getMaxMessageCount(String quotaRoot) throws MailboxException;
- SerializableQuotaValue<QuotaSize> getMaxStorage(String quotaRoot) throws MailboxException;
+ SerializableQuotaLimitValue<QuotaSizeLimit> getMaxStorage(String quotaRoot) throws MailboxException;
- SerializableQuotaValue<QuotaCount> getGlobalMaxMessageCount() throws MailboxException;
+ SerializableQuotaLimitValue<QuotaCountLimit> getGlobalMaxMessageCount() throws MailboxException;
- SerializableQuotaValue<QuotaSize> getGlobalMaxStorage() throws MailboxException;
+ SerializableQuotaLimitValue<QuotaSizeLimit> getGlobalMaxStorage() throws MailboxException;
- void setMaxMessageCount(String quotaRoot, SerializableQuotaValue<QuotaCount> maxMessageCount) throws MailboxException;
+ void setMaxMessageCount(String quotaRoot, SerializableQuotaLimitValue<QuotaCountLimit> maxMessageCount) throws MailboxException;
- void setMaxStorage(String quotaRoot, SerializableQuotaValue<QuotaSize> maxSize) throws MailboxException;
+ void setMaxStorage(String quotaRoot, SerializableQuotaLimitValue<QuotaSizeLimit> maxSize) throws MailboxException;
- void setGlobalMaxMessageCount(SerializableQuotaValue<QuotaCount> maxGlobalMessageCount) throws MailboxException;
+ void setGlobalMaxMessageCount(SerializableQuotaLimitValue<QuotaCountLimit> maxGlobalMessageCount) throws MailboxException;
- void setGlobalMaxStorage(SerializableQuotaValue<QuotaSize> maxGlobalSize) throws MailboxException;
+ void setGlobalMaxStorage(SerializableQuotaLimitValue<QuotaSizeLimit> maxGlobalSize) throws MailboxException;
}
\ No newline at end of file
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/quota/CurrentQuotaManager.java b/mailbox/api/src/main/java/org/apache/james/mailbox/quota/CurrentQuotaManager.java
index 4fe63b5..06cc970 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/quota/CurrentQuotaManager.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/quota/CurrentQuotaManager.java
@@ -19,8 +19,8 @@
package org.apache.james.mailbox.quota;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -29,8 +29,8 @@ import org.apache.james.mailbox.model.QuotaRoot;
*/
public interface CurrentQuotaManager {
- QuotaCount getCurrentMessageCount(QuotaRoot quotaRoot) throws MailboxException;
+ QuotaCountUsage getCurrentMessageCount(QuotaRoot quotaRoot) throws MailboxException;
- QuotaSize getCurrentStorage(QuotaRoot quotaRoot) throws MailboxException;
+ QuotaSizeUsage getCurrentStorage(QuotaRoot quotaRoot) throws MailboxException;
}
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/quota/MaxQuotaManager.java b/mailbox/api/src/main/java/org/apache/james/mailbox/quota/MaxQuotaManager.java
index 6cb89b7..76afb3f 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/quota/MaxQuotaManager.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/quota/MaxQuotaManager.java
@@ -23,8 +23,8 @@ import java.util.Map;
import java.util.Optional;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.Quota.Scope;
@@ -45,7 +45,7 @@ public interface MaxQuotaManager {
* @param quotaRoot Quota root argument from RFC 2087 ( correspond to the user owning this mailbox )
* @param maxStorageQuota The new storage quota ( in bytes ) for this user
*/
- void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) throws MailboxException;
+ void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) throws MailboxException;
/**
* Method allowing you to set the maximum message count allowed for this quotaroot
@@ -53,7 +53,7 @@ public interface MaxQuotaManager {
* @param quotaRoot Quota root argument from RFC 2087
* @param maxMessageCount The new message count allowed.
*/
- void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) throws MailboxException;
+ void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) throws MailboxException;
/**
* Method allowing you to remove the maximum messages count allowed for this quotaroot
@@ -74,7 +74,7 @@ public interface MaxQuotaManager {
*
* @param globalMaxStorage new global maximum storage
*/
- void setGlobalMaxStorage(QuotaSize globalMaxStorage) throws MailboxException;
+ void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) throws MailboxException;
/**
* Method allowing you to remove the global maximum messages size in bytes.
@@ -86,7 +86,7 @@ public interface MaxQuotaManager {
*
* @param globalMaxMessageCount new global message count
*/
- void setGlobalMaxMessage(QuotaCount globalMaxMessageCount) throws MailboxException;
+ void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) throws MailboxException;
/**
* Method allowing you to remove the global maximum messages count.
@@ -98,14 +98,14 @@ public interface MaxQuotaManager {
*
* @return global maximum storage, if defined
*/
- Optional<QuotaSize> getGlobalMaxStorage() throws MailboxException;
+ Optional<QuotaSizeLimit> getGlobalMaxStorage() throws MailboxException;
/**
* Method allowing you to get the global maximum message count allowed
*
* @return global maximum message count, if defined
*/
- Optional<QuotaCount> getGlobalMaxMessage() throws MailboxException;
+ Optional<QuotaCountLimit> getGlobalMaxMessage() throws MailboxException;
/**
* Return the maximum storage which is allowed for the given {@link QuotaRoot} (in fact the user which the session is bound to)
@@ -115,12 +115,12 @@ public interface MaxQuotaManager {
* @param quotaRoot Quota root argument from RFC 2087 ( correspond to the user owning this mailbox )
* @return The maximum storage in bytes if any
*/
- default Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) throws MailboxException {
- Map<Scope, QuotaSize> maxStorageDetails = listMaxStorageDetails(quotaRoot);
+ default Optional<QuotaSizeLimit> getMaxStorage(QuotaRoot quotaRoot) throws MailboxException {
+ Map<Scope, QuotaSizeLimit> maxStorageDetails = listMaxStorageDetails(quotaRoot);
return getMaxStorage(maxStorageDetails);
}
- default Optional<QuotaSize> getMaxStorage(Map<Quota.Scope, QuotaSize> maxStorageDetails) {
+ default Optional<QuotaSizeLimit> getMaxStorage(Map<Quota.Scope, QuotaSizeLimit> maxStorageDetails) {
return OptionalUtils.or(
Optional.ofNullable(maxStorageDetails.get(Quota.Scope.User)),
Optional.ofNullable(maxStorageDetails.get(Quota.Scope.Domain)),
@@ -133,41 +133,41 @@ public interface MaxQuotaManager {
* @param quotaRoot Quota root argument from RFC 2087 ( correspond to the user owning this mailbox )
* @return maximum of allowed message count
*/
- default Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) throws MailboxException {
- Map<Scope, QuotaCount> maxMessagesDetails = listMaxMessagesDetails(quotaRoot);
+ default Optional<QuotaCountLimit> getMaxMessage(QuotaRoot quotaRoot) throws MailboxException {
+ Map<Scope, QuotaCountLimit> maxMessagesDetails = listMaxMessagesDetails(quotaRoot);
return getMaxMessage(maxMessagesDetails);
}
- default Optional<QuotaCount> getMaxMessage(Map<Quota.Scope, QuotaCount> maxMessagesDetails) {
+ default Optional<QuotaCountLimit> getMaxMessage(Map<Quota.Scope, QuotaCountLimit> maxMessagesDetails) {
return OptionalUtils.or(
Optional.ofNullable(maxMessagesDetails.get(Quota.Scope.User)),
Optional.ofNullable(maxMessagesDetails.get(Quota.Scope.Domain)),
Optional.ofNullable(maxMessagesDetails.get(Quota.Scope.Global)));
}
- Map<Quota.Scope, QuotaCount> listMaxMessagesDetails(QuotaRoot quotaRoot);
+ Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot);
- Map<Quota.Scope, QuotaSize> listMaxStorageDetails(QuotaRoot quotaRoot);
+ Map<Quota.Scope, QuotaSizeLimit> listMaxStorageDetails(QuotaRoot quotaRoot);
- Optional<QuotaCount> getDomainMaxMessage(Domain domain);
+ Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain);
- void setDomainMaxMessage(Domain domain, QuotaCount count) throws MailboxException;
+ void setDomainMaxMessage(Domain domain, QuotaCountLimit count) throws MailboxException;
void removeDomainMaxMessage(Domain domain) throws MailboxException;
- void setDomainMaxStorage(Domain domain, QuotaSize size) throws MailboxException;
+ void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) throws MailboxException;
- Optional<QuotaSize> getDomainMaxStorage(Domain domain);
+ Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain);
void removeDomainMaxStorage(Domain domain) throws MailboxException;
- default Optional<QuotaCount> getComputedMaxMessage(Domain domain) throws MailboxException {
+ default Optional<QuotaCountLimit> getComputedMaxMessage(Domain domain) throws MailboxException {
return OptionalUtils.orSuppliers(
Throwing.supplier(() -> getDomainMaxMessage(domain)).sneakyThrow(),
Throwing.supplier(this::getGlobalMaxMessage).sneakyThrow());
}
- default Optional<QuotaSize> getComputedMaxStorage(Domain domain) throws MailboxException {
+ default Optional<QuotaSizeLimit> getComputedMaxStorage(Domain domain) throws MailboxException {
return OptionalUtils.orSuppliers(
Throwing.supplier(() -> getDomainMaxStorage(domain)).sneakyThrow(),
Throwing.supplier(this::getGlobalMaxStorage).sneakyThrow());
diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/quota/QuotaManager.java b/mailbox/api/src/main/java/org/apache/james/mailbox/quota/QuotaManager.java
index 675f2e5..5d1262c 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/quota/QuotaManager.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/quota/QuotaManager.java
@@ -18,8 +18,10 @@
****************************************************************/
package org.apache.james.mailbox.quota;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -37,7 +39,7 @@ public interface QuotaManager {
*
* @param quotaRoot Quota root argument from RFC 2087 ( correspond to the user owning this mailbox )
*/
- Quota<QuotaCount> getMessageQuota(QuotaRoot quotaRoot) throws MailboxException;
+ Quota<QuotaCountLimit, QuotaCountUsage> getMessageQuota(QuotaRoot quotaRoot) throws MailboxException;
/**
@@ -46,5 +48,5 @@ public interface QuotaManager {
*
* @param quotaRoot Quota root argument from RFC 2087 ( correspond to the user owning this mailbox )
*/
- Quota<QuotaSize> getStorageQuota(QuotaRoot quotaRoot) throws MailboxException;
+ Quota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(QuotaRoot quotaRoot) throws MailboxException;
}
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxListenerTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxListenerTest.java
index f58f049..fdaaf67 100644
--- a/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxListenerTest.java
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxListenerTest.java
@@ -29,8 +29,10 @@ import javax.mail.Flags;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.acl.ACLDiff;
import org.apache.james.mailbox.events.Event;
import org.apache.james.mailbox.events.MailboxListener;
@@ -46,7 +48,6 @@ import org.junit.jupiter.api.Test;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSortedMap;
-
import nl.jqno.equalsverifier.EqualsVerifier;
class MailboxListenerTest {
@@ -56,8 +57,8 @@ class MailboxListenerTest {
private static final MailboxSession.SessionId SESSION_ID = MailboxSession.SessionId.of(42);
private static final TestId MAILBOX_ID = TestId.of(18);
private static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("bob", Optional.empty());
- private static final QuotaCount QUOTA_COUNT = QuotaCount.count(34);
- private static final QuotaSize QUOTA_SIZE = QuotaSize.size(48);
+ private static final QuotaCountUsage QUOTA_COUNT = QuotaCountUsage.count(34);
+ private static final QuotaSizeUsage QUOTA_SIZE = QuotaSizeUsage.size(48);
private static final MailboxACL ACL_1 = new MailboxACL(
Pair.of(MailboxACL.EntryKey.createUserEntryKey(Username.of("Bob")), new MailboxACL.Rfc4314Rights(MailboxACL.Right.Administer)));
private static final MailboxACL ACL_2 = new MailboxACL(
@@ -204,13 +205,13 @@ class MailboxListenerTest {
@Test
void quotaUsageUpdatedEventShouldNotBeNoop() {
MailboxListener.QuotaUsageUpdatedEvent event = new MailboxListener.QuotaUsageUpdatedEvent(Event.EventId.random(), BOB, QUOTA_ROOT,
- Quota.<QuotaCount>builder()
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder()
.used(QUOTA_COUNT)
- .computedLimit(QuotaCount.unlimited())
+ .computedLimit(QuotaCountLimit.unlimited())
.build(),
- Quota.<QuotaSize>builder()
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
.used(QUOTA_SIZE)
- .computedLimit(QuotaSize.unlimited())
+ .computedLimit(QuotaSizeLimit.unlimited())
.build(), Instant.now());
assertThat(event.isNoop()).isFalse();
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java
index 14fd87e..6293e57 100644
--- a/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java
@@ -40,8 +40,10 @@ import java.util.concurrent.CountDownLatch;
import javax.mail.Flags;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MailboxManager.MailboxCapabilities;
import org.apache.james.mailbox.MessageManager.AppendCommand;
import org.apache.james.mailbox.events.EventBus;
@@ -86,7 +88,6 @@ import org.mockito.ArgumentCaptor;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-
import reactor.core.publisher.Mono;
/**
@@ -633,8 +634,8 @@ public abstract class MailboxManagerTest<T extends MailboxManager> {
.element(0)
.satisfies(event -> assertThat(event.getMailboxId()).isEqualTo(inboxId))
.satisfies(event -> assertThat(event.getQuotaRoot()).isEqualTo(quotaRoot))
- .satisfies(event -> assertThat(event.getDeletedMessageCount()).isEqualTo(QuotaCount.count(0)))
- .satisfies(event -> assertThat(event.getTotalDeletedSize()).isEqualTo(QuotaSize.size(0)));
+ .satisfies(event -> assertThat(event.getDeletedMessageCount()).isEqualTo(QuotaCountUsage.count(0)))
+ .satisfies(event -> assertThat(event.getTotalDeletedSize()).isEqualTo(QuotaSizeUsage.size(0)));
}
@Test
@@ -665,13 +666,13 @@ public abstract class MailboxManagerTest<T extends MailboxManager> {
.extracting(event -> (MailboxListener.QuotaUsageUpdatedEvent) event)
.element(0)
.satisfies(event -> assertThat(event.getQuotaRoot()).isEqualTo(quotaRoot))
- .satisfies(event -> assertThat(event.getSizeQuota()).isEqualTo(Quota.<QuotaSize>builder()
- .used(QuotaSize.size(85))
- .computedLimit(QuotaSize.unlimited())
+ .satisfies(event -> assertThat(event.getSizeQuota()).isEqualTo(Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(85))
+ .computedLimit(QuotaSizeLimit.unlimited())
.build()))
- .satisfies(event -> assertThat(event.getCountQuota()).isEqualTo(Quota.<QuotaCount>builder()
- .used(QuotaCount.count(1))
- .computedLimit(QuotaCount.unlimited())
+ .satisfies(event -> assertThat(event.getCountQuota()).isEqualTo(Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(1))
+ .computedLimit(QuotaCountLimit.unlimited())
.build()));
}
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/manager/ManagerTestProvisionner.java b/mailbox/api/src/test/java/org/apache/james/mailbox/manager/ManagerTestProvisionner.java
index 26d36af..0bb8411 100644
--- a/mailbox/api/src/test/java/org/apache/james/mailbox/manager/ManagerTestProvisionner.java
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/manager/ManagerTestProvisionner.java
@@ -27,8 +27,8 @@ import java.util.Calendar;
import javax.mail.Flags;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.FlagsBuilder;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.MessageManager;
@@ -63,8 +63,8 @@ public class ManagerTestProvisionner {
subFolder = new MailboxPath(inbox, "INBOX.SUB");
MaxQuotaManager maxQuotaManager = integrationResources.getMaxQuotaManager();
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(1000));
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(1000000));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(1000));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(1000000));
}
public void createMailboxes() throws MailboxException {
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/manager/QuotaMessageManagerTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/manager/QuotaMessageManagerTest.java
index a2ce2da..c97b475 100644
--- a/mailbox/api/src/test/java/org/apache/james/mailbox/manager/QuotaMessageManagerTest.java
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/manager/QuotaMessageManagerTest.java
@@ -27,8 +27,10 @@ import java.util.List;
import javax.mail.Flags;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.FlagsBuilder;
import org.apache.james.mailbox.MailboxManager;
import org.apache.james.mailbox.MailboxSession;
@@ -87,7 +89,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
@Test
void testAppendOverQuotaMessages() throws Exception {
- QuotaCount maxMessageCount = QuotaCount.count(8);
+ QuotaCountLimit maxMessageCount = QuotaCountLimit.count(8);
maxQuotaManager.setMaxMessage(quotaRootResolver.getQuotaRoot(inbox), maxMessageCount);
assertThatThrownBy(() -> provisionner.fillMailbox())
@@ -96,7 +98,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
@Test
void testAppendOverQuotaSize() throws Exception {
- QuotaSize maxQuotaSize = QuotaSize.size(3 * MockMail.MAIL_TEXT_PLAIN.length() + 1);
+ QuotaSizeLimit maxQuotaSize = QuotaSizeLimit.size(3 * MockMail.MAIL_TEXT_PLAIN.length() + 1);
maxQuotaManager.setMaxStorage(quotaRootResolver.getQuotaRoot(inbox), maxQuotaSize);
assertThatThrownBy(() -> provisionner.fillMailbox())
@@ -110,7 +112,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
} catch (OverQuotaException overQuotaException) {
// Silent these exception as we don't want it to disturb the test
}
- QuotaCount maxMessageCount = QuotaCount.count(15L);
+ QuotaCountLimit maxMessageCount = QuotaCountLimit.count(15L);
maxQuotaManager.setMaxMessage(quotaRootResolver.getQuotaRoot(inbox), maxMessageCount);
assertThatThrownBy(() -> mailboxManager.copyMessages(MessageRange.all(), inbox, subFolder, session))
@@ -119,7 +121,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
@Test
void testCopyOverQuotaSize() throws Exception {
- QuotaSize maxQuotaSize = QuotaSize.size(15L * MockMail.MAIL_TEXT_PLAIN.length());
+ QuotaSizeLimit maxQuotaSize = QuotaSizeLimit.size(15L * MockMail.MAIL_TEXT_PLAIN.length());
maxQuotaManager.setMaxStorage(quotaRootResolver.getQuotaRoot(inbox), maxQuotaSize);
try {
provisionner.fillMailbox();
@@ -132,7 +134,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
@Test
void testRetrievalOverMaxMessageAfterExpunge() throws Exception {
- QuotaCount maxMessageCount = QuotaCount.count(15L);
+ QuotaCountLimit maxMessageCount = QuotaCountLimit.count(15L);
maxQuotaManager.setMaxMessage(quotaRootResolver.getQuotaRoot(inbox), maxMessageCount);
try {
provisionner.fillMailbox();
@@ -147,7 +149,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
@Test
void testRetrievalOverMaxStorageAfterExpunge() throws Exception {
- QuotaSize maxQuotaSize = QuotaSize.size(15 * MockMail.MAIL_TEXT_PLAIN.getBytes(StandardCharsets.UTF_8).length + 1);
+ QuotaSizeLimit maxQuotaSize = QuotaSizeLimit.size(15 * MockMail.MAIL_TEXT_PLAIN.getBytes(StandardCharsets.UTF_8).length + 1);
maxQuotaManager.setMaxStorage(quotaRootResolver.getQuotaRoot(inbox), maxQuotaSize);
try {
provisionner.fillMailbox();
@@ -162,7 +164,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
@Test
void testRetrievalOverMaxMessageAfterDelete() throws Exception {
- QuotaCount maxMessageCount = QuotaCount.count(15L);
+ QuotaCountLimit maxMessageCount = QuotaCountLimit.count(15L);
maxQuotaManager.setMaxMessage(quotaRootResolver.getQuotaRoot(inbox), maxMessageCount);
try {
provisionner.fillMailbox();
@@ -179,7 +181,7 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
@Test
void testRetrievalOverMaxStorageAfterDelete() throws Exception {
- QuotaSize maxQuotaSize = QuotaSize.size(15 * MockMail.MAIL_TEXT_PLAIN.getBytes(StandardCharsets.UTF_8).length + 1);
+ QuotaSizeLimit maxQuotaSize = QuotaSizeLimit.size(15 * MockMail.MAIL_TEXT_PLAIN.getBytes(StandardCharsets.UTF_8).length + 1);
maxQuotaManager.setMaxStorage(quotaRootResolver.getQuotaRoot(inbox), maxQuotaSize);
try {
provisionner.fillMailbox();
@@ -201,11 +203,11 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
mailboxManager.deleteMailbox(inbox, session);
QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(inbox);
- Quota<QuotaCount> messageQuota = quotaManager.getMessageQuota(quotaRoot);
- Quota<QuotaSize> storageQuota = quotaManager.getStorageQuota(quotaRoot);
+ Quota<QuotaCountLimit, QuotaCountUsage> messageQuota = quotaManager.getMessageQuota(quotaRoot);
+ Quota<QuotaSizeLimit, QuotaSizeUsage> storageQuota = quotaManager.getStorageQuota(quotaRoot);
SoftAssertions.assertSoftly(softly -> {
- softly.assertThat(messageQuota.getUsed()).isEqualTo(QuotaCount.count(0));
- softly.assertThat(storageQuota.getUsed()).isEqualTo(QuotaSize.size(0));
+ softly.assertThat(messageQuota.getUsed()).isEqualTo(QuotaCountUsage.count(0));
+ softly.assertThat(storageQuota.getUsed()).isEqualTo(QuotaSizeUsage.size(0));
});
}
@@ -223,11 +225,11 @@ public abstract class QuotaMessageManagerTest<T extends MailboxManager> {
mailboxManager.deleteMailbox(subFolder, session);
QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(inbox);
- Quota<QuotaCount> messageQuota = quotaManager.getMessageQuota(quotaRoot);
- Quota<QuotaSize> storageQuota = quotaManager.getStorageQuota(quotaRoot);
+ Quota<QuotaCountLimit, QuotaCountUsage> messageQuota = quotaManager.getMessageQuota(quotaRoot);
+ Quota<QuotaSizeLimit, QuotaSizeUsage> storageQuota = quotaManager.getStorageQuota(quotaRoot);
SoftAssertions.assertSoftly(softly -> {
- softly.assertThat(messageQuota.getUsed()).isEqualTo(QuotaCount.count(16));
- softly.assertThat(storageQuota.getUsed()).isEqualTo(QuotaSize.size(16 * 247));
+ softly.assertThat(messageQuota.getUsed()).isEqualTo(QuotaCountUsage.count(16));
+ softly.assertThat(storageQuota.getUsed()).isEqualTo(QuotaSizeUsage.size(16 * 247));
});
}
}
\ No newline at end of file
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaRatioTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaRatioTest.java
index 98fc6ce..4461f91 100644
--- a/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaRatioTest.java
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaRatioTest.java
@@ -21,21 +21,23 @@ package org.apache.james.mailbox.model;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.junit.jupiter.api.Test;
import nl.jqno.equalsverifier.EqualsVerifier;
class QuotaRatioTest {
- private static final Quota<QuotaSize> QUOTA_SIZE = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(15))
- .computedLimit(QuotaSize.size(60))
+ private static final Quota<QuotaSizeLimit, QuotaSizeUsage> QUOTA_SIZE = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(15))
+ .computedLimit(QuotaSizeLimit.size(60))
.build();
- private static final Quota<QuotaCount> QUOTA_COUNT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(1))
- .computedLimit(QuotaCount.count(2))
+ private static final Quota<QuotaCountLimit, QuotaCountUsage> QUOTA_COUNT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(1))
+ .computedLimit(QuotaCountLimit.count(2))
.build();
@Test
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaTest.java
index f1633bc..4bfa64f 100644
--- a/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaTest.java
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/model/QuotaTest.java
@@ -22,74 +22,75 @@ package org.apache.james.mailbox.model;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.junit.jupiter.api.Test;
class QuotaTest {
-
@Test
void isOverQuotaShouldReturnFalseWhenQuotaIsNotExceeded() {
- Quota<QuotaCount> quota = Quota.<QuotaCount>builder().used(QuotaCount.count(36)).computedLimit(QuotaCount.count(360)).build();
+ Quota<QuotaCountLimit, QuotaCountUsage> quota = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(36)).computedLimit(QuotaCountLimit.count(360)).build();
assertThat(quota.isOverQuota()).isFalse();
}
@Test
void isOverQuotaShouldReturnFalseWhenMaxValueIsUnlimited() {
- Quota<QuotaCount> quota = Quota.<QuotaCount>builder().used(QuotaCount.count(36)).computedLimit(QuotaCount.unlimited()).build();
+ Quota<QuotaCountLimit, QuotaCountUsage> quota = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(36)).computedLimit(QuotaCountLimit.unlimited()).build();
assertThat(quota.isOverQuota()).isFalse();
}
@Test
void isOverQuotaShouldReturnTrueWhenQuotaIsExceeded() {
- Quota<QuotaCount> quota = Quota.<QuotaCount>builder().used(QuotaCount.count(360)).computedLimit(QuotaCount.count(36)).build();
+ Quota<QuotaCountLimit, QuotaCountUsage> quota = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(360)).computedLimit(QuotaCountLimit.count(36)).build();
assertThat(quota.isOverQuota()).isTrue();
}
@Test
void isOverQuotaWithAdditionalValueShouldReturnTrueWhenOverLimit() {
- Quota<QuotaCount> quota = Quota.<QuotaCount>builder().used(QuotaCount.count(36)).computedLimit(QuotaCount.count(36)).build();
+ Quota<QuotaCountLimit, QuotaCountUsage> quota = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(36)).computedLimit(QuotaCountLimit.count(36)).build();
assertThat(quota.isOverQuotaWithAdditionalValue(1)).isTrue();
}
@Test
void isOverQuotaWithAdditionalValueShouldReturnTrueWhenUnderLimit() {
- Quota<QuotaCount> quota = Quota.<QuotaCount>builder().used(QuotaCount.count(34)).computedLimit(QuotaCount.count(36)).build();
+ Quota<QuotaCountLimit, QuotaCountUsage> quota = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(34)).computedLimit(QuotaCountLimit.count(36)).build();
assertThat(quota.isOverQuotaWithAdditionalValue(1)).isFalse();
}
@Test
void isOverQuotaWithAdditionalValueShouldReturnFalseWhenAtLimit() {
- Quota<QuotaCount> quota = Quota.<QuotaCount>builder().used(QuotaCount.count(36)).computedLimit(QuotaCount.count(36)).build();
+ Quota<QuotaCountLimit, QuotaCountUsage> quota = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(36)).computedLimit(QuotaCountLimit.count(36)).build();
assertThat(quota.isOverQuotaWithAdditionalValue(0)).isFalse();
}
@Test
void isOverQuotaWithAdditionalValueShouldThrowOnNegativeValue() {
- Quota<QuotaCount> quota = Quota.<QuotaCount>builder().used(QuotaCount.count(25)).computedLimit(QuotaCount.count(36)).build();
+ Quota<QuotaCountLimit, QuotaCountUsage> quota = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(25)).computedLimit(QuotaCountLimit.count(36)).build();
assertThatThrownBy(() -> quota.isOverQuotaWithAdditionalValue(-1)).isInstanceOf(IllegalArgumentException.class);
}
@Test
void buildShouldThrowOnMissingUsedValue() {
assertThatThrownBy(
- () -> Quota.<QuotaCount>builder().computedLimit(QuotaCount.count(1)).build())
+ () -> Quota.<QuotaCountLimit, QuotaCountUsage>builder().computedLimit(QuotaCountLimit.count(1)).build())
.isInstanceOf(IllegalStateException.class);
}
@Test
void buildShouldThrowOnMissingComputedLimitValue() {
assertThatThrownBy(
- () -> Quota.<QuotaCount>builder().used(QuotaCount.count(1)).build())
+ () -> Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(1)).build())
.isInstanceOf(IllegalStateException.class);
}
@Test
void buildShouldCreateValidObjectGivenMandatoryFields() {
- Quota<QuotaCount> actual = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(1))
- .computedLimit(QuotaCount.count(2))
+ Quota<QuotaCountLimit, QuotaCountUsage> actual = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(1))
+ .computedLimit(QuotaCountLimit.count(2))
.build();
assertThat(actual).isNotNull();
}
@@ -97,9 +98,9 @@ class QuotaTest {
@Test
void getRatioShouldReturnUsedDividedByLimit() {
assertThat(
- Quota.<QuotaSize>builder()
- .used(QuotaSize.size(15))
- .computedLimit(QuotaSize.size(60))
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(15))
+ .computedLimit(QuotaSizeLimit.size(60))
.build()
.getRatio())
.isEqualTo(0.25);
@@ -108,9 +109,9 @@ class QuotaTest {
@Test
void getRatioShouldReturnZeroWhenUnlimited() {
assertThat(
- Quota.<QuotaSize>builder()
- .used(QuotaSize.size(15))
- .computedLimit(QuotaSize.unlimited())
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(15))
+ .computedLimit(QuotaSizeLimit.unlimited())
.build()
.getRatio())
.isEqualTo(0);
diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/quota/QuotaFixture.java b/mailbox/api/src/test/java/org/apache/james/mailbox/quota/QuotaFixture.java
index 594c787..e77b86a 100644
--- a/mailbox/api/src/test/java/org/apache/james/mailbox/quota/QuotaFixture.java
+++ b/mailbox/api/src/test/java/org/apache/james/mailbox/quota/QuotaFixture.java
@@ -19,91 +19,93 @@
package org.apache.james.mailbox.quota;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
public interface QuotaFixture {
interface Counts {
- Quota<QuotaCount> _32_PERCENT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(32))
- .computedLimit(QuotaCount.count(100))
+ Quota<QuotaCountLimit, QuotaCountUsage> _32_PERCENT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(32))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- Quota<QuotaCount> _40_PERCENT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(40))
- .computedLimit(QuotaCount.count(100))
+ Quota<QuotaCountLimit, QuotaCountUsage> _40_PERCENT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(40))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- Quota<QuotaCount> _52_PERCENT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(52))
- .computedLimit(QuotaCount.count(100))
+ Quota<QuotaCountLimit, QuotaCountUsage> _52_PERCENT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(52))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- Quota<QuotaCount> _72_PERCENT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(72))
- .computedLimit(QuotaCount.count(100))
+ Quota<QuotaCountLimit, QuotaCountUsage> _72_PERCENT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(72))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- Quota<QuotaCount> _82_PERCENT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(82))
- .computedLimit(QuotaCount.count(100))
+ Quota<QuotaCountLimit, QuotaCountUsage> _82_PERCENT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(82))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- Quota<QuotaCount> _85_PERCENT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(85))
- .computedLimit(QuotaCount.count(100))
+ Quota<QuotaCountLimit, QuotaCountUsage> _85_PERCENT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(85))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- Quota<QuotaCount> _92_PERCENT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(92))
- .computedLimit(QuotaCount.count(100))
+ Quota<QuotaCountLimit, QuotaCountUsage> _92_PERCENT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(92))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- Quota<QuotaCount> _UNLIMITED = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(92))
- .computedLimit(QuotaCount.unlimited())
+ Quota<QuotaCountLimit, QuotaCountUsage> _UNLIMITED = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(92))
+ .computedLimit(QuotaCountLimit.unlimited())
.build();
}
interface Sizes {
- Quota<QuotaSize> _30_PERCENT = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(30))
- .computedLimit(QuotaSize.size(100))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _30_PERCENT = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(30))
+ .computedLimit(QuotaSizeLimit.size(100))
.build();
- Quota<QuotaSize> _42_PERCENT = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(42))
- .computedLimit(QuotaSize.size(100))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _42_PERCENT = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(42))
+ .computedLimit(QuotaSizeLimit.size(100))
.build();
- Quota<QuotaSize> _55_PERCENT = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(55))
- .computedLimit(QuotaSize.size(100))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _55_PERCENT = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(55))
+ .computedLimit(QuotaSizeLimit.size(100))
.build();
- Quota<QuotaSize> _60_PERCENT = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(60))
- .computedLimit(QuotaSize.size(100))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _60_PERCENT = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(60))
+ .computedLimit(QuotaSizeLimit.size(100))
.build();
- Quota<QuotaSize> _75_PERCENT = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(75))
- .computedLimit(QuotaSize.size(100))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _75_PERCENT = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(75))
+ .computedLimit(QuotaSizeLimit.size(100))
.build();
- Quota<QuotaSize> _82_PERCENT = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(82))
- .computedLimit(QuotaSize.size(100))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _82_PERCENT = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(82))
+ .computedLimit(QuotaSizeLimit.size(100))
.build();
- Quota<QuotaSize> _92_PERCENT = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(92))
- .computedLimit(QuotaSize.size(100))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _92_PERCENT = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(92))
+ .computedLimit(QuotaSizeLimit.size(100))
.build();
- Quota<QuotaSize> _992_PERTHOUSAND = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(992))
- .computedLimit(QuotaSize.size(1000))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> _992_PERTHOUSAND = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(992))
+ .computedLimit(QuotaSizeLimit.size(1000))
.build();
}
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManager.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManager.java
index 873cc9c..eb23bf2 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManager.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManager.java
@@ -28,8 +28,8 @@ import static com.datastax.driver.core.querybuilder.QueryBuilder.update;
import javax.inject.Inject;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.cassandra.table.CassandraCurrentQuota;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -80,21 +80,21 @@ public class CassandraCurrentQuotaManager implements StoreCurrentQuotaManager {
}
@Override
- public QuotaCount getCurrentMessageCount(QuotaRoot quotaRoot) throws MailboxException {
+ public QuotaCountUsage getCurrentMessageCount(QuotaRoot quotaRoot) throws MailboxException {
ResultSet resultSet = session.execute(getCurrentMessageCountStatement.bind(quotaRoot.getValue()));
if (resultSet.isExhausted()) {
- return QuotaCount.count(0L);
+ return QuotaCountUsage.count(0L);
}
- return QuotaCount.count(resultSet.one().getLong(CassandraCurrentQuota.MESSAGE_COUNT));
+ return QuotaCountUsage.count(resultSet.one().getLong(CassandraCurrentQuota.MESSAGE_COUNT));
}
@Override
- public QuotaSize getCurrentStorage(QuotaRoot quotaRoot) throws MailboxException {
+ public QuotaSizeUsage getCurrentStorage(QuotaRoot quotaRoot) throws MailboxException {
ResultSet resultSet = session.execute(getCurrentStorageStatement.bind(quotaRoot.getValue()));
if (resultSet.isExhausted()) {
- return QuotaSize.size(0L);
+ return QuotaSizeUsage.size(0L);
}
- return QuotaSize.size(resultSet.one().getLong(CassandraCurrentQuota.STORAGE));
+ return QuotaSizeUsage.size(resultSet.one().getLong(CassandraCurrentQuota.STORAGE));
}
private void checkArguments(long count, long size) {
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraGlobalMaxQuotaDao.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraGlobalMaxQuotaDao.java
index eda028e..fba2c52 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraGlobalMaxQuotaDao.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraGlobalMaxQuotaDao.java
@@ -29,8 +29,8 @@ import java.util.Optional;
import javax.inject.Inject;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.cassandra.table.CassandraGlobalMaxQuota;
import com.datastax.driver.core.PreparedStatement;
@@ -81,15 +81,15 @@ public class CassandraGlobalMaxQuotaDao {
.where(eq(CassandraGlobalMaxQuota.TYPE, bindMarker(CassandraGlobalMaxQuota.TYPE)));
}
- public void setGlobalMaxStorage(QuotaSize globalMaxStorage) {
+ public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) {
session.execute(setGlobalMaxStorageStatement.bind(QuotaCodec.quotaValueToLong(globalMaxStorage)));
}
- public void setGlobalMaxMessage(QuotaCount globalMaxMessageCount) {
+ public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) {
session.execute(setGlobalMaxMessageStatement.bind(QuotaCodec.quotaValueToLong(globalMaxMessageCount)));
}
- public Optional<QuotaSize> getGlobalMaxStorage() {
+ public Optional<QuotaSizeLimit> getGlobalMaxStorage() {
ResultSet resultSet = session.execute(getGlobalMaxStatement.bind()
.setString(CassandraGlobalMaxQuota.TYPE, CassandraGlobalMaxQuota.STORAGE));
if (resultSet.isExhausted()) {
@@ -99,7 +99,7 @@ public class CassandraGlobalMaxQuotaDao {
return QuotaCodec.longToQuotaSize(maxStorage);
}
- public Optional<QuotaCount> getGlobalMaxMessage() {
+ public Optional<QuotaCountLimit> getGlobalMaxMessage() {
ResultSet resultSet = session.execute(getGlobalMaxStatement.bind()
.setString(CassandraGlobalMaxQuota.TYPE, CassandraGlobalMaxQuota.MESSAGE));
if (resultSet.isExhausted()) {
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerDomainMaxQuotaDao.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerDomainMaxQuotaDao.java
index 0b34759..cccbdc2 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerDomainMaxQuotaDao.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerDomainMaxQuotaDao.java
@@ -30,8 +30,8 @@ import java.util.Optional;
import javax.inject.Inject;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.cassandra.table.CassandraDomainMaxQuota;
import com.datastax.driver.core.PreparedStatement;
@@ -98,15 +98,15 @@ public class CassandraPerDomainMaxQuotaDao {
.value(CassandraDomainMaxQuota.STORAGE, bindMarker());
}
- public void setMaxStorage(Domain domain, QuotaSize maxStorageQuota) {
+ public void setMaxStorage(Domain domain, QuotaSizeLimit maxStorageQuota) {
session.execute(setMaxStorageStatement.bind(domain.asString(), QuotaCodec.quotaValueToLong(maxStorageQuota)));
}
- public void setMaxMessage(Domain domain, QuotaCount maxMessageCount) {
+ public void setMaxMessage(Domain domain, QuotaCountLimit maxMessageCount) {
session.execute(setMaxMessageStatement.bind(domain.asString(), QuotaCodec.quotaValueToLong(maxMessageCount)));
}
- public Optional<QuotaSize> getMaxStorage(Domain domain) {
+ public Optional<QuotaSizeLimit> getMaxStorage(Domain domain) {
ResultSet resultSet = session.execute(getMaxStorageStatement.bind(domain.asString()));
if (resultSet.isExhausted()) {
return Optional.empty();
@@ -115,7 +115,7 @@ public class CassandraPerDomainMaxQuotaDao {
return QuotaCodec.longToQuotaSize(maxStorage);
}
- public Optional<QuotaCount> getMaxMessage(Domain domain) {
+ public Optional<QuotaCountLimit> getMaxMessage(Domain domain) {
ResultSet resultSet = session.execute(getMaxMessageStatement.bind(domain.asString()));
if (resultSet.isExhausted()) {
return Optional.empty();
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaDao.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaDao.java
index 5eeff8f..52beb42 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaDao.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaDao.java
@@ -29,8 +29,8 @@ import java.util.Optional;
import javax.inject.Inject;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.cassandra.table.CassandraMaxQuota;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -98,15 +98,15 @@ public class CassandraPerUserMaxQuotaDao {
.value(CassandraMaxQuota.STORAGE, bindMarker());
}
- public void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) {
+ public void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) {
session.execute(setMaxStorageStatement.bind(quotaRoot.getValue(), QuotaCodec.quotaValueToLong(maxStorageQuota)));
}
- public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) {
+ public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) {
session.execute(setMaxMessageStatement.bind(quotaRoot.getValue(), QuotaCodec.quotaValueToLong(maxMessageCount)));
}
- public Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) {
+ public Optional<QuotaSizeLimit> getMaxStorage(QuotaRoot quotaRoot) {
ResultSet resultSet = session.execute(getMaxStorageStatement.bind(quotaRoot.getValue()));
if (resultSet.isExhausted()) {
return Optional.empty();
@@ -115,7 +115,7 @@ public class CassandraPerUserMaxQuotaDao {
return QuotaCodec.longToQuotaSize(maxStorage);
}
- public Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) {
+ public Optional<QuotaCountLimit> getMaxMessage(QuotaRoot quotaRoot) {
ResultSet resultSet = session.execute(getMaxMessageStatement.bind(quotaRoot.getValue()));
if (resultSet.isExhausted()) {
return Optional.empty();
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManager.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManager.java
index c278ae6..671e707 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManager.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManager.java
@@ -28,8 +28,8 @@ import javax.inject.Inject;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.MaxQuotaManager;
@@ -53,22 +53,22 @@ public class CassandraPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) {
+ public void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) {
perUserQuota.setMaxStorage(quotaRoot, maxStorageQuota);
}
@Override
- public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) {
+ public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) {
perUserQuota.setMaxMessage(quotaRoot, maxMessageCount);
}
@Override
- public void setDomainMaxMessage(Domain domain, QuotaCount count) {
+ public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) {
perDomainQuota.setMaxMessage(domain, count);
}
@Override
- public void setDomainMaxStorage(Domain domain, QuotaSize size) {
+ public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) {
perDomainQuota.setMaxStorage(domain, size);
}
@@ -83,12 +83,12 @@ public class CassandraPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Optional<QuotaCount> getDomainMaxMessage(Domain domain) {
+ public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) {
return perDomainQuota.getMaxMessage(domain);
}
@Override
- public Optional<QuotaSize> getDomainMaxStorage(Domain domain) {
+ public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) {
return perDomainQuota.getMaxStorage(domain);
}
@@ -103,7 +103,7 @@ public class CassandraPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxStorage(QuotaSize globalMaxStorage) {
+ public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) {
globalQuota.setGlobalMaxStorage(globalMaxStorage);
}
@@ -113,7 +113,7 @@ public class CassandraPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxMessage(QuotaCount globalMaxMessageCount) {
+ public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) {
globalQuota.setGlobalMaxMessage(globalMaxMessageCount);
}
@@ -123,18 +123,18 @@ public class CassandraPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Optional<QuotaSize> getGlobalMaxStorage() {
+ public Optional<QuotaSizeLimit> getGlobalMaxStorage() {
return globalQuota.getGlobalMaxStorage();
}
@Override
- public Optional<QuotaCount> getGlobalMaxMessage() {
+ public Optional<QuotaCountLimit> getGlobalMaxMessage() {
return globalQuota.getGlobalMaxMessage();
}
@Override
- public Map<Quota.Scope, QuotaCount> listMaxMessagesDetails(QuotaRoot quotaRoot) {
- Function<Domain, Optional<QuotaCount>> domainQuotaSupplier = Throwing.function(this::getDomainMaxMessage).sneakyThrow();
+ public Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot) {
+ Function<Domain, Optional<QuotaCountLimit>> domainQuotaSupplier = Throwing.function(this::getDomainMaxMessage).sneakyThrow();
return Stream.of(
Pair.of(Quota.Scope.User, perUserQuota.getMaxMessage(quotaRoot)),
Pair.of(Quota.Scope.Domain, quotaRoot.getDomain().flatMap(domainQuotaSupplier)),
@@ -144,8 +144,8 @@ public class CassandraPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Map<Quota.Scope, QuotaSize> listMaxStorageDetails(QuotaRoot quotaRoot) {
- Function<Domain, Optional<QuotaSize>> domainQuotaSupplier = Throwing.function(this::getDomainMaxStorage).sneakyThrow();
+ public Map<Quota.Scope, QuotaSizeLimit> listMaxStorageDetails(QuotaRoot quotaRoot) {
+ Function<Domain, Optional<QuotaSizeLimit>> domainQuotaSupplier = Throwing.function(this::getDomainMaxStorage).sneakyThrow();
return Stream.of(
Pair.of(Quota.Scope.User, perUserQuota.getMaxStorage(quotaRoot)),
Pair.of(Quota.Scope.Domain, quotaRoot.getDomain().flatMap(domainQuotaSupplier)),
diff --git a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/QuotaCodec.java b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/QuotaCodec.java
index d68d104..87b6cdc 100644
--- a/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/QuotaCodec.java
+++ b/mailbox/cassandra/src/main/java/org/apache/james/mailbox/cassandra/quota/QuotaCodec.java
@@ -21,31 +21,31 @@ package org.apache.james.mailbox.cassandra.quota;
import java.util.Optional;
import java.util.function.Function;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaSizeLimit;
public class QuotaCodec {
private static final long INFINITE = -1;
private static final long NO_RIGHT = 0L;
- static Long quotaValueToLong(QuotaValue<?> value) {
+ static Long quotaValueToLong(QuotaLimitValue<?> value) {
if (value.isUnlimited()) {
return INFINITE;
}
return value.asLong();
}
- static Optional<QuotaSize> longToQuotaSize(Long value) {
- return longToQuotaValue(value, QuotaSize.unlimited(), QuotaSize::size);
+ static Optional<QuotaSizeLimit> longToQuotaSize(Long value) {
+ return longToQuotaValue(value, QuotaSizeLimit.unlimited(), QuotaSizeLimit::size);
}
- static Optional<QuotaCount> longToQuotaCount(Long value) {
- return longToQuotaValue(value, QuotaCount.unlimited(), QuotaCount::count);
+ static Optional<QuotaCountLimit> longToQuotaCount(Long value) {
+ return longToQuotaValue(value, QuotaCountLimit.unlimited(), QuotaCountLimit::count);
}
- private static <T extends QuotaValue<T>> Optional<T> longToQuotaValue(Long value, T infiniteValue, Function<Long, T> quotaFactory) {
+ private static <T extends QuotaLimitValue<T>> Optional<T> longToQuotaValue(Long value, T infiniteValue, Function<Long, T> quotaFactory) {
if (value == null) {
return Optional.empty();
}
diff --git a/mailbox/event/json/src/main/scala/org/apache/james/event/json/DTOs.scala b/mailbox/event/json/src/main/scala/org/apache/james/event/json/DTOs.scala
index 9917073..880e676 100644
--- a/mailbox/event/json/src/main/scala/org/apache/james/event/json/DTOs.scala
+++ b/mailbox/event/json/src/main/scala/org/apache/james/event/json/DTOs.scala
@@ -25,7 +25,7 @@ import java.util.Date
import javax.mail.Flags.Flag
import javax.mail.{Flags => JavaMailFlags}
import org.apache.james.core.Username
-import org.apache.james.core.quota.QuotaValue
+import org.apache.james.core.quota.{QuotaLimitValue, QuotaUsageValue}
import org.apache.james.event.json.DTOs.SystemFlag.SystemFlag
import org.apache.james.mailbox.acl.{ACLDiff => JavaACLDiff}
import org.apache.james.mailbox.model.{MailboxACL, MessageId, MailboxPath => JavaMailboxPath, MessageMetaData => JavaMessageMetaData, Quota => JavaQuota, UpdatedFlags => JavaUpdatedFlags}
@@ -49,7 +49,7 @@ object DTOs {
}
object Quota {
- def toScala[T <: QuotaValue[T]](java: JavaQuota[T]): Quota[T] = Quota(
+ def toScala[T <: QuotaLimitValue[T], U <: QuotaUsageValue[U, T]](java: JavaQuota[T, U]): Quota[T, U] = Quota(
used = java.getUsed,
limit = java.getLimit,
limits = java.getLimitByScope.asScala.toMap)
@@ -64,9 +64,9 @@ object DTOs {
def toJava: JavaMailboxPath = new JavaMailboxPath(namespace.orNull, user.orNull, name)
}
- case class Quota[T <: QuotaValue[T]](used: T, limit: T, limits: Map[JavaQuota.Scope, T]) {
- def toJava: JavaQuota[T] =
- JavaQuota.builder[T]
+ case class Quota[T <: QuotaLimitValue[T], U <: QuotaUsageValue[U, T]](used: U, limit: T, limits: Map[JavaQuota.Scope, T]) {
+ def toJava: JavaQuota[T, U] =
+ JavaQuota.builder[T, U]
.used(used)
.computedLimit(limit)
.limitsByScope(limits.asJava)
diff --git a/mailbox/event/json/src/main/scala/org/apache/james/event/json/EventSerializer.scala b/mailbox/event/json/src/main/scala/org/apache/james/event/json/EventSerializer.scala
index bc9831f..be52b08 100644
--- a/mailbox/event/json/src/main/scala/org/apache/james/event/json/EventSerializer.scala
+++ b/mailbox/event/json/src/main/scala/org/apache/james/event/json/EventSerializer.scala
@@ -25,7 +25,7 @@ import java.util.{TreeMap => JavaTreeMap}
import javax.inject.Inject
import julienrf.json.derived
import org.apache.james.core.Username
-import org.apache.james.core.quota.{QuotaCount, QuotaSize, QuotaValue}
+import org.apache.james.core.quota.{QuotaCountLimit, QuotaCountUsage, QuotaLimitValue, QuotaSizeLimit, QuotaSizeUsage, QuotaUsageValue}
import org.apache.james.event.json.DTOs.SystemFlag.SystemFlag
import org.apache.james.event.json.DTOs._
import org.apache.james.mailbox.MailboxSession.SessionId
@@ -53,7 +53,7 @@ private object DTO {
}
case class MailboxDeletion(eventId: EventId, sessionId: SessionId, user: Username, path: MailboxPath, quotaRoot: QuotaRoot,
- deletedMessageCount: QuotaCount, totalDeletedSize: QuotaSize, mailboxId: MailboxId) extends Event {
+ deletedMessageCount: QuotaCountUsage, totalDeletedSize: QuotaSizeUsage, mailboxId: MailboxId) extends Event {
override def toJava: JavaEvent = new JavaMailboxDeletion(sessionId, user, path.toJava, quotaRoot, deletedMessageCount,
totalDeletedSize, mailboxId, eventId)
}
@@ -62,8 +62,8 @@ private object DTO {
override def toJava: JavaEvent = new JavaMailboxRenamed(sessionId, user, path.toJava, mailboxId, newPath.toJava, eventId)
}
- case class QuotaUsageUpdatedEvent(eventId: EventId, user: Username, quotaRoot: QuotaRoot, countQuota: Quota[QuotaCount],
- sizeQuota: Quota[QuotaSize], time: Instant) extends Event {
+ case class QuotaUsageUpdatedEvent(eventId: EventId, user: Username, quotaRoot: QuotaRoot, countQuota: Quota[QuotaCountLimit, QuotaCountUsage],
+ sizeQuota: Quota[QuotaSizeLimit, QuotaSizeUsage], time: Instant) extends Event {
override def toJava: JavaEvent = new JavaQuotaUsageUpdatedEvent(eventId, user, quotaRoot, countQuota.toJava, sizeQuota.toJava, time)
}
@@ -205,10 +205,11 @@ class JsonSerialize(mailboxIdFactory: MailboxId.Factory, messageIdFactory: Messa
implicit val systemFlagsWrites: Writes[SystemFlag] = Writes.enumNameWrites
implicit val userWriters: Writes[Username] = (user: Username) => JsString(user.asString)
implicit val quotaRootWrites: Writes[QuotaRoot] = quotaRoot => JsString(quotaRoot.getValue)
- implicit val quotaValueWrites: Writes[QuotaValue[_]] = value => if (value.isUnlimited) JsNull else JsNumber(value.asLong())
+ implicit val quotaUsageValueWrites: Writes[QuotaUsageValue[_, _]] = value => if (value.isUnlimited) JsNull else JsNumber(value.asLong())
+ implicit val quotaLimitValueWrites: Writes[QuotaLimitValue[_]] = value => if (value.isUnlimited) JsNull else JsNumber(value.asLong())
implicit val quotaScopeWrites: Writes[JavaQuota.Scope] = value => JsString(value.name)
- implicit val quotaCountWrites: Writes[Quota[QuotaCount]] = Json.writes[Quota[QuotaCount]]
- implicit val quotaSizeWrites: Writes[Quota[QuotaSize]] = Json.writes[Quota[QuotaSize]]
+ implicit val quotaCountWrites: Writes[Quota[QuotaCountLimit, QuotaCountUsage]] = Json.writes[Quota[QuotaCountLimit, QuotaCountUsage]]
+ implicit val quotaSizeWrites: Writes[Quota[QuotaSizeLimit, QuotaSizeUsage]] = Json.writes[Quota[QuotaSizeLimit, QuotaSizeUsage]]
implicit val mailboxPathWrites: Writes[MailboxPath] = Json.writes[MailboxPath]
implicit val mailboxIdWrites: Writes[MailboxId] = value => JsString(value.serialize())
implicit val sessionIdWrites: Writes[SessionId] = value => JsNumber(value.getValue)
@@ -238,9 +239,14 @@ class JsonSerialize(mailboxIdFactory: MailboxId.Factory, messageIdFactory: Messa
case JsString(serializedMailboxId) => JsSuccess(mailboxIdFactory.fromString(serializedMailboxId))
case _ => JsError()
}
- implicit val quotaCountReads: Reads[QuotaCount] = {
- case JsNumber(count) => JsSuccess(QuotaCount.count(count.toLong))
- case JsNull => JsSuccess(QuotaCount.unlimited())
+ implicit val quotaCountLimitReads: Reads[QuotaCountLimit] = {
+ case JsNumber(count) => JsSuccess(QuotaCountLimit.count(count.toLong))
+ case JsNull => JsSuccess(QuotaCountLimit.unlimited())
+ case _ => JsError()
+ }
+ implicit val quotaCountUsageReads: Reads[QuotaCountUsage] = {
+ case JsNumber(count) => JsSuccess(QuotaCountUsage.count(count.toLong))
+ case JsNull => JsSuccess(QuotaCountUsage.unlimited())
case _ => JsError()
}
implicit val quotaRootReads: Reads[QuotaRoot] = {
@@ -251,9 +257,14 @@ class JsonSerialize(mailboxIdFactory: MailboxId.Factory, messageIdFactory: Messa
case JsString(value) => JsSuccess(JavaQuota.Scope.valueOf(value))
case _ => JsError()
}
- implicit val quotaSizeReads: Reads[QuotaSize] = {
- case JsNumber(size) => JsSuccess(QuotaSize.size(size.toLong))
- case JsNull => JsSuccess(QuotaSize.unlimited())
+ implicit val quotaSizeLimitReads: Reads[QuotaSizeLimit] = {
+ case JsNumber(size) => JsSuccess(QuotaSizeLimit.size(size.toLong))
+ case JsNull => JsSuccess(QuotaSizeLimit.unlimited())
+ case _ => JsError()
+ }
+ implicit val quotaSizeUsageReads: Reads[QuotaSizeUsage] = {
+ case JsNumber(size) => JsSuccess(QuotaSizeUsage.size(size.toLong))
+ case JsNull => JsSuccess(QuotaSizeUsage.unlimited())
case _ => JsError()
}
implicit val sessionIdReads: Reads[SessionId] = {
@@ -314,8 +325,8 @@ class JsonSerialize(mailboxIdFactory: MailboxId.Factory, messageIdFactory: Messa
implicit val flagsReads: Reads[Flags] = Json.reads[Flags]
implicit val aclDiffReads: Reads[ACLDiff] = Json.reads[ACLDiff]
- implicit val quotaCReads: Reads[DTOs.Quota[QuotaCount]] = Json.reads[DTOs.Quota[QuotaCount]]
- implicit val quotaSReads: Reads[DTOs.Quota[QuotaSize]] = Json.reads[DTOs.Quota[QuotaSize]]
+ implicit val quotaCReads: Reads[DTOs.Quota[QuotaCountLimit, QuotaCountUsage]] = Json.reads[DTOs.Quota[QuotaCountLimit, QuotaCountUsage]]
+ implicit val quotaSReads: Reads[DTOs.Quota[QuotaSizeLimit, QuotaSizeUsage]] = Json.reads[DTOs.Quota[QuotaSizeLimit, QuotaSizeUsage]]
implicit val mailboxPathReads: Reads[DTOs.MailboxPath] = Json.reads[DTOs.MailboxPath]
implicit val messageMetaDataReads: Reads[DTOs.MessageMetaData] = Json.reads[DTOs.MessageMetaData]
implicit val updatedFlagsReads: Reads[DTOs.UpdatedFlags] = Json.reads[DTOs.UpdatedFlags]
diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java
index e5d0e95..068d866 100644
--- a/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java
+++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/MailboxDeletionSerializationTest.java
@@ -31,8 +31,8 @@ import java.util.Optional;
import org.apache.james.core.Domain;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.events.MailboxListener;
import org.apache.james.mailbox.model.MailboxId;
@@ -49,8 +49,8 @@ class MailboxDeletionSerializationTest {
private static final MailboxPath MAILBOX_PATH = new MailboxPath(USER_NAMESPACE, USERNAME, "mailboxName");
private static final MailboxId MAILBOX_ID = TestId.of(789);
private static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("#private&user@domain", Optional.of(Domain.of("domain")));
- private static final QuotaCount DELETED_MESSAGE_COUNT = QuotaCount.count(60);
- private static final QuotaSize TOTAL_DELETED_SIZE = QuotaSize.size(100);
+ private static final QuotaCountUsage DELETED_MESSAGE_COUNT = QuotaCountUsage.count(60);
+ private static final QuotaSizeUsage TOTAL_DELETED_SIZE = QuotaSizeUsage.size(100);
private static final MailboxListener.MailboxDeletion DEFAULT_MAILBOX_DELETION_EVENT = new MailboxListener.MailboxDeletion(
SESSION_ID,
USERNAME,
diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java
index 5753b70..345016e 100644
--- a/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java
+++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/QuotaUsageUpdatedEventSerializationTest.java
@@ -30,8 +30,10 @@ import java.util.NoSuchElementException;
import java.util.Optional;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.events.MailboxListener;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -39,13 +41,13 @@ import org.junit.jupiter.api.Test;
class QuotaUsageUpdatedEventSerializationTest {
private static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("#private&foo", Optional.empty());
- private static final Quota<QuotaCount> QUOTA_COUNT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(12))
- .computedLimit(QuotaCount.count(100))
+ private static final Quota<QuotaCountLimit, QuotaCountUsage> QUOTA_COUNT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(12))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
- private static final Quota<QuotaSize> QUOTA_SIZE = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(1234))
- .computedLimit(QuotaSize.size(10000))
+ private static final Quota<QuotaSizeLimit, QuotaSizeUsage> QUOTA_SIZE = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(1234))
+ .computedLimit(QuotaSizeLimit.size(10000))
.build();
private static final Instant INSTANT = Instant.parse("2018-11-13T12:00:55Z");
private final MailboxListener.QuotaUsageUpdatedEvent eventWithUserContainsUsername = new MailboxListener.QuotaUsageUpdatedEvent(
diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java
index e203cc6..80191db 100644
--- a/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java
+++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaCountTest.java
@@ -24,7 +24,8 @@ import static org.apache.james.event.json.SerializerFixture.DTO_JSON_SERIALIZE;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import org.apache.james.core.quota.QuotaCount;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
import org.apache.james.event.json.DTOs;
import org.apache.james.mailbox.model.Quota;
import org.junit.jupiter.api.Nested;
@@ -39,49 +40,79 @@ import scala.math.BigDecimal;
class QuotaCountTest {
@Test
- void quotaCountShouldBeWellSerialized() {
- assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaCount.count(18)))
+ void quotaCountLimitShouldBeWellSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaLimitValueWrites().writes(QuotaCountLimit.count(18)))
.isEqualTo(new JsNumber(BigDecimal.valueOf(18)));
}
@Test
- void quotaCountShouldBeWellDeSerialized() {
- assertThat(DTO_JSON_SERIALIZE.quotaCountReads().reads(new JsNumber(BigDecimal.valueOf(18))).get())
- .isEqualTo(QuotaCount.count(18));
+ void quotaCountLimitShouldBeWellDeSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaCountLimitReads().reads(new JsNumber(BigDecimal.valueOf(18))).get())
+ .isEqualTo(QuotaCountLimit.count(18));
}
@Test
- void quotaCountShouldBeWellSerializedWhenUnlimited() {
- assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaCount.unlimited()))
+ void quotaCountLimitShouldBeWellSerializedWhenUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaLimitValueWrites().writes(QuotaCountLimit.unlimited()))
.isEqualTo(JsNull$.MODULE$);
}
@Test
- void quotaCountShouldBeWellDeSerializedWhenUnlimited() {
- assertThat(DTO_JSON_SERIALIZE.quotaCountReads().reads(JsNull$.MODULE$).get())
- .isEqualTo(QuotaCount.unlimited());
+ void quotaCountLimitShouldBeWellDeSerializedWhenUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaCountLimitReads().reads(JsNull$.MODULE$).get())
+ .isEqualTo(QuotaCountLimit.unlimited());
}
@Test
- void quotaCountShouldReturnErrorWhenString() {
- assertThat(DTO_JSON_SERIALIZE.quotaCountReads().reads(new JsString("18")))
+ void quotaCountLimitShouldReturnErrorWhenString() {
+ assertThat(DTO_JSON_SERIALIZE.quotaCountLimitReads().reads(new JsString("18")))
+ .isInstanceOf(JsError.class);
+ }
+
+ @Test
+ void quotaCountUsageShouldBeWellSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaUsageValueWrites().writes(QuotaCountUsage.count(18)))
+ .isEqualTo(new JsNumber(BigDecimal.valueOf(18)));
+ }
+
+ @Test
+ void quotaCountUsageShouldBeWellDeSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaCountUsageReads().reads(new JsNumber(BigDecimal.valueOf(18))).get())
+ .isEqualTo(QuotaCountUsage.count(18));
+ }
+
+ @Test
+ void quotaCountUsageShouldBeWellSerializedWhenUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaUsageValueWrites().writes(QuotaCountUsage.unlimited()))
+ .isEqualTo(JsNull$.MODULE$);
+ }
+
+ @Test
+ void quotaCountUsageShouldBeWellDeSerializedWhenUnUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaCountUsageReads().reads(JsNull$.MODULE$).get())
+ .isEqualTo(QuotaCountUsage.unlimited());
+ }
+
+ @Test
+ void quotaCountUsageShouldReturnErrorWhenString() {
+ assertThat(DTO_JSON_SERIALIZE.quotaCountUsageReads().reads(new JsString("18")))
.isInstanceOf(JsError.class);
}
@Nested
class LimitedQuotaCount {
- private Quota<QuotaCount> limitedQuotaCountByScopes(Quota.Scope scope) {
- return Quota.<QuotaCount>builder()
- .used(QuotaCount.count(12))
- .computedLimit(QuotaCount.count(100))
- .limitForScope(QuotaCount.count(100), scope)
+ private Quota<QuotaCountLimit, QuotaCountUsage> limitedQuotaCountByScopes(Quota.Scope scope) {
+ return Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(12))
+ .computedLimit(QuotaCountLimit.count(100))
+ .limitForScope(QuotaCountLimit.count(100), scope)
.build();
}
@Nested
class LimitedQuotaGlobalScope {
private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Global\":100}}";
- private final Quota<QuotaCount> quota = limitedQuotaCountByScopes(Quota.Scope.Global);
+ private final Quota<QuotaCountLimit, QuotaCountUsage> quota = limitedQuotaCountByScopes(Quota.Scope.Global);
@Test
void toJsonShouldSerializeQuotaCount() {
@@ -100,7 +131,7 @@ class QuotaCountTest {
@Nested
class LimitedQuotaDomainScope {
private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Domain\":100}}";
- private final Quota<QuotaCount> quota = limitedQuotaCountByScopes(Quota.Scope.Domain);
+ private final Quota<QuotaCountLimit, QuotaCountUsage> quota = limitedQuotaCountByScopes(Quota.Scope.Domain);
@Test
void toJsonShouldSerializeQuotaCount() {
@@ -119,7 +150,7 @@ class QuotaCountTest {
@Nested
class LimitedQuotaUserScope {
private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"User\":100}}";
- private final Quota<QuotaCount> quota = limitedQuotaCountByScopes(Quota.Scope.User);
+ private final Quota<QuotaCountLimit, QuotaCountUsage> quota = limitedQuotaCountByScopes(Quota.Scope.User);
@Test
void toJsonShouldSerializeQuotaCount() {
@@ -138,18 +169,18 @@ class QuotaCountTest {
@Nested
class UnLimitedQuotaCount {
- private Quota<QuotaCount> unLimitedQuotaCountByScopes(Quota.Scope scope) {
- return Quota.<QuotaCount>builder()
- .used(QuotaCount.count(12))
- .computedLimit(QuotaCount.unlimited())
- .limitForScope(QuotaCount.unlimited(), scope)
+ private Quota<QuotaCountLimit, QuotaCountUsage> unLimitedQuotaCountByScopes(Quota.Scope scope) {
+ return Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(12))
+ .computedLimit(QuotaCountLimit.unlimited())
+ .limitForScope(QuotaCountLimit.unlimited(), scope)
.build();
}
@Nested
class UnLimitedQuotaGlobalScope {
private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Global\":null}}";
- private final Quota<QuotaCount> quota = unLimitedQuotaCountByScopes(Quota.Scope.Global);
+ private final Quota<QuotaCountLimit, QuotaCountUsage> quota = unLimitedQuotaCountByScopes(Quota.Scope.Global);
@Test
void toJsonShouldSerializeQuotaCount() {
@@ -168,7 +199,7 @@ class QuotaCountTest {
@Nested
class UnLimitedQuotaDomainScope {
private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Domain\":null}}";
- private final Quota<QuotaCount> quota = unLimitedQuotaCountByScopes(Quota.Scope.Domain);
+ private final Quota<QuotaCountLimit, QuotaCountUsage> quota = unLimitedQuotaCountByScopes(Quota.Scope.Domain);
@Test
void toJsonShouldSerializeQuotaCount() {
@@ -187,7 +218,7 @@ class QuotaCountTest {
@Nested
class UnLimitedQuotaUserScope {
private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"User\":null}}";
- private final Quota<QuotaCount> quota = unLimitedQuotaCountByScopes(Quota.Scope.User);
+ private final Quota<QuotaCountLimit, QuotaCountUsage> quota = unLimitedQuotaCountByScopes(Quota.Scope.User);
@Test
void toJsonShouldSerializeQuotaCount() {
diff --git a/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java
index 5940f13..ad2d54a 100644
--- a/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java
+++ b/mailbox/event/json/src/test/java/org/apache/james/event/json/dtos/QuotaSizeTest.java
@@ -23,7 +23,8 @@ import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
import static org.apache.james.event.json.SerializerFixture.DTO_JSON_SERIALIZE;
import static org.assertj.core.api.Assertions.assertThat;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.event.json.DTOs;
import org.apache.james.mailbox.model.Quota;
import org.junit.jupiter.api.Nested;
@@ -38,49 +39,79 @@ import scala.math.BigDecimal;
class QuotaSizeTest {
@Test
- void quotaSizeShouldBeWellSerialized() {
- assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaSize.size(18)))
+ void quotaSizeLimitShouldBeWellSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaLimitValueWrites().writes(QuotaSizeLimit.size(18)))
.isEqualTo(new JsNumber(BigDecimal.valueOf(18)));
}
@Test
- void quotaSizeShouldBeWellDeSerialized() {
- assertThat(DTO_JSON_SERIALIZE.quotaSizeReads().reads(new JsNumber(BigDecimal.valueOf(18))).get())
- .isEqualTo(QuotaSize.size(18));
+ void quotaSizeLimitShouldBeWellDeSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaSizeLimitReads().reads(new JsNumber(BigDecimal.valueOf(18))).get())
+ .isEqualTo(QuotaSizeLimit.size(18));
}
@Test
- void quotaSizeShouldBeWellSerializedWhenUnlimited() {
- assertThat(DTO_JSON_SERIALIZE.quotaValueWrites().writes(QuotaSize.unlimited()))
+ void quotaSizeLimitShouldBeWellSerializedWhenUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaLimitValueWrites().writes(QuotaSizeLimit.unlimited()))
.isEqualTo(JsNull$.MODULE$);
}
@Test
- void quotaSizeShouldBeWellDeSerializedWhenUnlimited() {
- assertThat(DTO_JSON_SERIALIZE.quotaSizeReads().reads(JsNull$.MODULE$).get())
- .isEqualTo(QuotaSize.unlimited());
+ void quotaSizeLimitShouldBeWellDeSerializedWhenUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaSizeLimitReads().reads(JsNull$.MODULE$).get())
+ .isEqualTo(QuotaSizeLimit.unlimited());
}
@Test
- void quotaSizeShouldReturnErrorWhenString() {
- assertThat(DTO_JSON_SERIALIZE.quotaSizeReads().reads(new JsString("18")))
+ void quotaSizeLimitShouldReturnErrorWhenString() {
+ assertThat(DTO_JSON_SERIALIZE.quotaSizeLimitReads().reads(new JsString("18")))
+ .isInstanceOf(JsError.class);
+ }
+
+ @Test
+ void quotaSizeUsageShouldBeWellSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaUsageValueWrites().writes(QuotaSizeUsage.size(18)))
+ .isEqualTo(new JsNumber(BigDecimal.valueOf(18)));
+ }
+
+ @Test
+ void quotaSizeUsageShouldBeWellDeSerialized() {
+ assertThat(DTO_JSON_SERIALIZE.quotaSizeUsageReads().reads(new JsNumber(BigDecimal.valueOf(18))).get())
+ .isEqualTo(QuotaSizeUsage.size(18));
+ }
+
+ @Test
+ void quotaSizeUsageShouldBeWellSerializedWhenUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaUsageValueWrites().writes(QuotaSizeUsage.unlimited()))
+ .isEqualTo(JsNull$.MODULE$);
+ }
+
+ @Test
+ void quotaSizeUsageShouldBeWellDeSerializedWhenUnlimited() {
+ assertThat(DTO_JSON_SERIALIZE.quotaSizeUsageReads().reads(JsNull$.MODULE$).get())
+ .isEqualTo(QuotaSizeUsage.unlimited());
+ }
+
+ @Test
+ void quotaSizeUsageShouldReturnErrorWhenString() {
+ assertThat(DTO_JSON_SERIALIZE.quotaSizeUsageReads().reads(new JsString("18")))
.isInstanceOf(JsError.class);
}
@Nested
class LimitedQuotaSize {
- private Quota<QuotaSize> limitedQuotaSizeByScopes(Quota.Scope scope) {
- return Quota.<QuotaSize>builder()
- .used(QuotaSize.size(12))
- .computedLimit(QuotaSize.size(100))
- .limitForScope(QuotaSize.size(100), scope)
+ private Quota<QuotaSizeLimit, QuotaSizeUsage> limitedQuotaSizeByScopes(Quota.Scope scope) {
+ return Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(12))
+ .computedLimit(QuotaSizeLimit.size(100))
+ .limitForScope(QuotaSizeLimit.size(100), scope)
.build();
}
@Nested
class LimitedQuotaGlobalScope {
private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Global\":100}}";
- private final Quota<QuotaSize> quota = limitedQuotaSizeByScopes(Quota.Scope.Global);
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> quota = limitedQuotaSizeByScopes(Quota.Scope.Global);
@Test
void toJsonShouldSerializeQuotaSize() {
@@ -98,7 +129,7 @@ class QuotaSizeTest {
@Nested
class LimitedQuotaDomainScope {
private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"Domain\":100}}";
- private final Quota<QuotaSize> quota = limitedQuotaSizeByScopes(Quota.Scope.Domain);
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> quota = limitedQuotaSizeByScopes(Quota.Scope.Domain);
@Test
void toJsonShouldSerializeQuotaSize() {
@@ -116,7 +147,7 @@ class QuotaSizeTest {
@Nested
class LimitedQuotaUserScope {
private final String json = "{\"used\":12,\"limit\":100,\"limits\":{\"User\":100}}";
- private final Quota<QuotaSize> quota = limitedQuotaSizeByScopes(Quota.Scope.User);
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> quota = limitedQuotaSizeByScopes(Quota.Scope.User);
@Test
void toJsonShouldSerializeQuotaSize() {
@@ -134,18 +165,18 @@ class QuotaSizeTest {
@Nested
class UnLimitedQuotaSize {
- private Quota<QuotaSize> unLimitedQuotaSizeByScopes(Quota.Scope scope) {
- return Quota.<QuotaSize>builder()
- .used(QuotaSize.size(12))
- .computedLimit(QuotaSize.unlimited())
- .limitForScope(QuotaSize.unlimited(), scope)
+ private Quota<QuotaSizeLimit, QuotaSizeUsage> unLimitedQuotaSizeByScopes(Quota.Scope scope) {
+ return Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(12))
+ .computedLimit(QuotaSizeLimit.unlimited())
+ .limitForScope(QuotaSizeLimit.unlimited(), scope)
.build();
}
@Nested
class UnLimitedQuotaGlobalScope {
private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Global\":null}}";
- private final Quota<QuotaSize> quota = unLimitedQuotaSizeByScopes(Quota.Scope.Global);
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> quota = unLimitedQuotaSizeByScopes(Quota.Scope.Global);
@Test
void toJsonShouldSerializeQuotaSize() {
@@ -163,7 +194,7 @@ class QuotaSizeTest {
@Nested
class UnLimitedQuotaDomainScope {
private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"Domain\":null}}";
- private final Quota<QuotaSize> quota = unLimitedQuotaSizeByScopes(Quota.Scope.Domain);
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> quota = unLimitedQuotaSizeByScopes(Quota.Scope.Domain);
@Test
void toJsonShouldSerializeQuotaSize() {
@@ -181,7 +212,7 @@ class QuotaSizeTest {
@Nested
class UnLimitedQuotaUserScope {
private final String json = "{\"used\":12,\"limit\":null,\"limits\":{\"User\":null}}";
- private final Quota<QuotaSize> quota = unLimitedQuotaSizeByScopes(Quota.Scope.User);
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> quota = unLimitedQuotaSizeByScopes(Quota.Scope.User);
@Test
void toJsonShouldSerializeQuotaSize() {
diff --git a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaDAO.java b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaDAO.java
index f0b21d2..dcd23ba 100644
--- a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaDAO.java
+++ b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaDAO.java
@@ -28,9 +28,9 @@ import javax.persistence.EntityManagerFactory;
import org.apache.james.backends.jpa.TransactionRunner;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.jpa.quota.model.MaxDomainMessageCount;
import org.apache.james.mailbox.jpa.quota.model.MaxDomainStorage;
import org.apache.james.mailbox.jpa.quota.model.MaxGlobalMessageCount;
@@ -51,7 +51,7 @@ public class JPAPerUserMaxQuotaDAO {
this.transactionRunner = new TransactionRunner(entityManagerFactory);
}
- public void setMaxStorage(QuotaRoot quotaRoot, Optional<QuotaSize> maxStorageQuota) {
+ public void setMaxStorage(QuotaRoot quotaRoot, Optional<QuotaSizeLimit> maxStorageQuota) {
transactionRunner.run(
entityManager -> {
MaxUserStorage storedValue = getMaxUserStorageEntity(entityManager, quotaRoot, maxStorageQuota);
@@ -59,7 +59,7 @@ public class JPAPerUserMaxQuotaDAO {
});
}
- private MaxUserStorage getMaxUserStorageEntity(EntityManager entityManager, QuotaRoot quotaRoot, Optional<QuotaSize> maxStorageQuota) {
+ private MaxUserStorage getMaxUserStorageEntity(EntityManager entityManager, QuotaRoot quotaRoot, Optional<QuotaSizeLimit> maxStorageQuota) {
MaxUserStorage storedValue = entityManager.find(MaxUserStorage.class, quotaRoot.getValue());
Long value = quotaValueToLong(maxStorageQuota);
if (storedValue == null) {
@@ -69,7 +69,7 @@ public class JPAPerUserMaxQuotaDAO {
return storedValue;
}
- public void setMaxMessage(QuotaRoot quotaRoot, Optional<QuotaCount> maxMessageCount) {
+ public void setMaxMessage(QuotaRoot quotaRoot, Optional<QuotaCountLimit> maxMessageCount) {
transactionRunner.run(
entityManager -> {
MaxUserMessageCount storedValue = getMaxUserMessageEntity(entityManager, quotaRoot, maxMessageCount);
@@ -77,7 +77,7 @@ public class JPAPerUserMaxQuotaDAO {
});
}
- private MaxUserMessageCount getMaxUserMessageEntity(EntityManager entityManager, QuotaRoot quotaRoot, Optional<QuotaCount> maxMessageQuota) {
+ private MaxUserMessageCount getMaxUserMessageEntity(EntityManager entityManager, QuotaRoot quotaRoot, Optional<QuotaCountLimit> maxMessageQuota) {
MaxUserMessageCount storedValue = entityManager.find(MaxUserMessageCount.class, quotaRoot.getValue());
Long value = quotaValueToLong(maxMessageQuota);
if (storedValue == null) {
@@ -87,7 +87,7 @@ public class JPAPerUserMaxQuotaDAO {
return storedValue;
}
- public void setDomainMaxMessage(Domain domain, Optional<QuotaCount> count) {
+ public void setDomainMaxMessage(Domain domain, Optional<QuotaCountLimit> count) {
transactionRunner.run(
entityManager -> {
MaxDomainMessageCount storedValue = getMaxDomainMessageEntity(entityManager, domain, count);
@@ -96,7 +96,7 @@ public class JPAPerUserMaxQuotaDAO {
}
- public void setDomainMaxStorage(Domain domain, Optional<QuotaSize> size) {
+ public void setDomainMaxStorage(Domain domain, Optional<QuotaSizeLimit> size) {
transactionRunner.run(
entityManager -> {
MaxDomainStorage storedValue = getMaxDomainStorageEntity(entityManager, domain, size);
@@ -104,7 +104,7 @@ public class JPAPerUserMaxQuotaDAO {
});
}
- private MaxDomainMessageCount getMaxDomainMessageEntity(EntityManager entityManager, Domain domain, Optional<QuotaCount> maxMessageQuota) {
+ private MaxDomainMessageCount getMaxDomainMessageEntity(EntityManager entityManager, Domain domain, Optional<QuotaCountLimit> maxMessageQuota) {
MaxDomainMessageCount storedValue = entityManager.find(MaxDomainMessageCount.class, domain.asString());
Long value = quotaValueToLong(maxMessageQuota);
if (storedValue == null) {
@@ -114,7 +114,7 @@ public class JPAPerUserMaxQuotaDAO {
return storedValue;
}
- private MaxDomainStorage getMaxDomainStorageEntity(EntityManager entityManager, Domain domain, Optional<QuotaSize> maxStorageQuota) {
+ private MaxDomainStorage getMaxDomainStorageEntity(EntityManager entityManager, Domain domain, Optional<QuotaSizeLimit> maxStorageQuota) {
MaxDomainStorage storedValue = entityManager.find(MaxDomainStorage.class, domain.asString());
Long value = quotaValueToLong(maxStorageQuota);
if (storedValue == null) {
@@ -125,7 +125,7 @@ public class JPAPerUserMaxQuotaDAO {
}
- public void setGlobalMaxStorage(Optional<QuotaSize> globalMaxStorage) {
+ public void setGlobalMaxStorage(Optional<QuotaSizeLimit> globalMaxStorage) {
transactionRunner.run(
entityManager -> {
MaxGlobalStorage globalMaxStorageEntity = getGlobalMaxStorageEntity(entityManager, globalMaxStorage);
@@ -133,7 +133,7 @@ public class JPAPerUserMaxQuotaDAO {
});
}
- private MaxGlobalStorage getGlobalMaxStorageEntity(EntityManager entityManager, Optional<QuotaSize> maxSizeQuota) {
+ private MaxGlobalStorage getGlobalMaxStorageEntity(EntityManager entityManager, Optional<QuotaSizeLimit> maxSizeQuota) {
MaxGlobalStorage storedValue = entityManager.find(MaxGlobalStorage.class, MaxGlobalStorage.DEFAULT_KEY);
Long value = quotaValueToLong(maxSizeQuota);
if (storedValue == null) {
@@ -143,7 +143,7 @@ public class JPAPerUserMaxQuotaDAO {
return storedValue;
}
- public void setGlobalMaxMessage(Optional<QuotaCount> globalMaxMessageCount) {
+ public void setGlobalMaxMessage(Optional<QuotaCountLimit> globalMaxMessageCount) {
transactionRunner.run(
entityManager -> {
MaxGlobalMessageCount globalMaxMessageEntity = getGlobalMaxMessageEntity(entityManager, globalMaxMessageCount);
@@ -151,7 +151,7 @@ public class JPAPerUserMaxQuotaDAO {
});
}
- private MaxGlobalMessageCount getGlobalMaxMessageEntity(EntityManager entityManager, Optional<QuotaCount> maxMessageQuota) {
+ private MaxGlobalMessageCount getGlobalMaxMessageEntity(EntityManager entityManager, Optional<QuotaCountLimit> maxMessageQuota) {
MaxGlobalMessageCount storedValue = entityManager.find(MaxGlobalMessageCount.class, MaxGlobalMessageCount.DEFAULT_KEY);
Long value = quotaValueToLong(maxMessageQuota);
if (storedValue == null) {
@@ -161,7 +161,7 @@ public class JPAPerUserMaxQuotaDAO {
return storedValue;
}
- public Optional<QuotaSize> getGlobalMaxStorage() {
+ public Optional<QuotaSizeLimit> getGlobalMaxStorage() {
EntityManager entityManager = entityManagerFactory.createEntityManager();
MaxGlobalStorage storedValue = entityManager.find(MaxGlobalStorage.class, MaxGlobalStorage.DEFAULT_KEY);
if (storedValue == null) {
@@ -170,7 +170,7 @@ public class JPAPerUserMaxQuotaDAO {
return longToQuotaSize(storedValue.getValue());
}
- public Optional<QuotaCount> getGlobalMaxMessage() {
+ public Optional<QuotaCountLimit> getGlobalMaxMessage() {
EntityManager entityManager = entityManagerFactory.createEntityManager();
MaxGlobalMessageCount storedValue = entityManager.find(MaxGlobalMessageCount.class, MaxGlobalMessageCount.DEFAULT_KEY);
if (storedValue == null) {
@@ -179,7 +179,7 @@ public class JPAPerUserMaxQuotaDAO {
return longToQuotaCount(storedValue.getValue());
}
- public Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) {
+ public Optional<QuotaSizeLimit> getMaxStorage(QuotaRoot quotaRoot) {
EntityManager entityManager = entityManagerFactory.createEntityManager();
MaxUserStorage storedValue = entityManager.find(MaxUserStorage.class, quotaRoot.getValue());
if (storedValue == null) {
@@ -188,7 +188,7 @@ public class JPAPerUserMaxQuotaDAO {
return longToQuotaSize(storedValue.getValue());
}
- public Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) {
+ public Optional<QuotaCountLimit> getMaxMessage(QuotaRoot quotaRoot) {
EntityManager entityManager = entityManagerFactory.createEntityManager();
MaxUserMessageCount storedValue = entityManager.find(MaxUserMessageCount.class, quotaRoot.getValue());
if (storedValue == null) {
@@ -197,7 +197,7 @@ public class JPAPerUserMaxQuotaDAO {
return longToQuotaCount(storedValue.getValue());
}
- public Optional<QuotaCount> getDomainMaxMessage(Domain domain) {
+ public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) {
EntityManager entityManager = entityManagerFactory.createEntityManager();
MaxDomainMessageCount storedValue = entityManager.find(MaxDomainMessageCount.class, domain.asString());
if (storedValue == null) {
@@ -206,7 +206,7 @@ public class JPAPerUserMaxQuotaDAO {
return longToQuotaCount(storedValue.getValue());
}
- public Optional<QuotaSize> getDomainMaxStorage(Domain domain) {
+ public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) {
EntityManager entityManager = entityManagerFactory.createEntityManager();
MaxDomainStorage storedValue = entityManager.find(MaxDomainStorage.class, domain.asString());
if (storedValue == null) {
@@ -216,7 +216,7 @@ public class JPAPerUserMaxQuotaDAO {
}
- private Long quotaValueToLong(Optional<? extends QuotaValue<?>> maxStorageQuota) {
+ private Long quotaValueToLong(Optional<? extends QuotaLimitValue<?>> maxStorageQuota) {
return maxStorageQuota.map(value -> {
if (value.isUnlimited()) {
return INFINITE;
@@ -225,15 +225,15 @@ public class JPAPerUserMaxQuotaDAO {
}).orElse(null);
}
- private Optional<QuotaSize> longToQuotaSize(Long value) {
- return longToQuotaValue(value, QuotaSize.unlimited(), QuotaSize::size);
+ private Optional<QuotaSizeLimit> longToQuotaSize(Long value) {
+ return longToQuotaValue(value, QuotaSizeLimit.unlimited(), QuotaSizeLimit::size);
}
- private Optional<QuotaCount> longToQuotaCount(Long value) {
- return longToQuotaValue(value, QuotaCount.unlimited(), QuotaCount::count);
+ private Optional<QuotaCountLimit> longToQuotaCount(Long value) {
+ return longToQuotaValue(value, QuotaCountLimit.unlimited(), QuotaCountLimit::count);
}
- private <T extends QuotaValue<T>> Optional<T> longToQuotaValue(Long value, T infiniteValue, Function<Long, T> quotaFactory) {
+ private <T extends QuotaLimitValue<T>> Optional<T> longToQuotaValue(Long value, T infiniteValue, Function<Long, T> quotaFactory) {
if (value == null) {
return Optional.empty();
}
diff --git a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaManager.java b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaManager.java
index 53b6ccd..12ac40b 100644
--- a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaManager.java
+++ b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaManager.java
@@ -28,8 +28,8 @@ import javax.inject.Inject;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.MaxQuotaManager;
@@ -47,22 +47,22 @@ public class JPAPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) {
+ public void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) {
dao.setMaxStorage(quotaRoot, Optional.of(maxStorageQuota));
}
@Override
- public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) {
+ public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) {
dao.setMaxMessage(quotaRoot, Optional.of(maxMessageCount));
}
@Override
- public void setDomainMaxMessage(Domain domain, QuotaCount count) {
+ public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) {
dao.setDomainMaxMessage(domain, Optional.of(count));
}
@Override
- public void setDomainMaxStorage(Domain domain, QuotaSize size) {
+ public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) {
dao.setDomainMaxStorage(domain, Optional.of(size));
}
@@ -77,12 +77,12 @@ public class JPAPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Optional<QuotaCount> getDomainMaxMessage(Domain domain) {
+ public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) {
return dao.getDomainMaxMessage(domain);
}
@Override
- public Optional<QuotaSize> getDomainMaxStorage(Domain domain) {
+ public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) {
return dao.getDomainMaxStorage(domain);
}
@@ -92,7 +92,7 @@ public class JPAPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxStorage(QuotaSize globalMaxStorage) {
+ public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) {
dao.setGlobalMaxStorage(Optional.of(globalMaxStorage));
}
@@ -102,23 +102,23 @@ public class JPAPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxMessage(QuotaCount globalMaxMessageCount) {
+ public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) {
dao.setGlobalMaxMessage(Optional.of(globalMaxMessageCount));
}
@Override
- public Optional<QuotaSize> getGlobalMaxStorage() {
+ public Optional<QuotaSizeLimit> getGlobalMaxStorage() {
return dao.getGlobalMaxStorage();
}
@Override
- public Optional<QuotaCount> getGlobalMaxMessage() {
+ public Optional<QuotaCountLimit> getGlobalMaxMessage() {
return dao.getGlobalMaxMessage();
}
@Override
- public Map<Quota.Scope, QuotaCount> listMaxMessagesDetails(QuotaRoot quotaRoot) {
- Function<Domain, Optional<QuotaCount>> domainQuotaFunction = Throwing.function(this::getDomainMaxMessage).sneakyThrow();
+ public Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot) {
+ Function<Domain, Optional<QuotaCountLimit>> domainQuotaFunction = Throwing.function(this::getDomainMaxMessage).sneakyThrow();
return Stream.of(
Pair.of(Quota.Scope.User, dao.getMaxMessage(quotaRoot)),
Pair.of(Quota.Scope.Domain, quotaRoot.getDomain().flatMap(domainQuotaFunction)),
@@ -128,8 +128,8 @@ public class JPAPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Map<Quota.Scope, QuotaSize> listMaxStorageDetails(QuotaRoot quotaRoot) {
- Function<Domain, Optional<QuotaSize>> domainQuotaFunction = Throwing.function(this::getDomainMaxStorage).sneakyThrow();
+ public Map<Quota.Scope, QuotaSizeLimit> listMaxStorageDetails(QuotaRoot quotaRoot) {
+ Function<Domain, Optional<QuotaSizeLimit>> domainQuotaFunction = Throwing.function(this::getDomainMaxStorage).sneakyThrow();
return Stream.of(
Pair.of(Quota.Scope.User, dao.getMaxStorage(quotaRoot)),
Pair.of(Quota.Scope.Domain, quotaRoot.getDomain().flatMap(domainQuotaFunction)),
diff --git a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JpaCurrentQuotaManager.java b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JpaCurrentQuotaManager.java
index bca9406..99ff928 100644
--- a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JpaCurrentQuotaManager.java
+++ b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/JpaCurrentQuotaManager.java
@@ -26,8 +26,8 @@ import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import org.apache.james.backends.jpa.TransactionRunner;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.jpa.quota.model.JpaCurrentQuota;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -50,19 +50,19 @@ public class JpaCurrentQuotaManager implements StoreCurrentQuotaManager {
}
@Override
- public QuotaCount getCurrentMessageCount(QuotaRoot quotaRoot) {
+ public QuotaCountUsage getCurrentMessageCount(QuotaRoot quotaRoot) {
EntityManager entityManager = entityManagerFactory.createEntityManager();
return Optional.ofNullable(retrieveUserQuota(entityManager, quotaRoot))
.map(JpaCurrentQuota::getMessageCount)
- .orElse(QuotaCount.count(NO_STORED_BYTES));
+ .orElse(QuotaCountUsage.count(NO_STORED_BYTES));
}
@Override
- public QuotaSize getCurrentStorage(QuotaRoot quotaRoot) {
+ public QuotaSizeUsage getCurrentStorage(QuotaRoot quotaRoot) {
EntityManager entityManager = entityManagerFactory.createEntityManager();
return Optional.ofNullable(retrieveUserQuota(entityManager, quotaRoot))
.map(JpaCurrentQuota::getSize)
- .orElse(QuotaSize.size(NO_STORED_BYTES));
+ .orElse(QuotaSizeUsage.size(NO_STORED_BYTES));
}
@Override
diff --git a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/model/JpaCurrentQuota.java b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/model/JpaCurrentQuota.java
index 0011e41..f058ba0 100644
--- a/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/model/JpaCurrentQuota.java
+++ b/mailbox/jpa/src/main/java/org/apache/james/mailbox/jpa/quota/model/JpaCurrentQuota.java
@@ -24,8 +24,8 @@ import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
@Entity(name = "CurrentQuota")
@Table(name = "JAMES_QUOTA_CURRENTQUOTA")
@@ -50,12 +50,12 @@ public class JpaCurrentQuota {
this.size = size;
}
- public QuotaCount getMessageCount() {
- return QuotaCount.count(messageCount);
+ public QuotaCountUsage getMessageCount() {
+ return QuotaCountUsage.count(messageCount);
}
- public QuotaSize getSize() {
- return QuotaSize.size(size);
+ public QuotaSizeUsage getSize() {
+ return QuotaSizeUsage.size(size);
}
@Override
diff --git a/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManager.java b/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManager.java
index 02ef7b6..5df517f 100644
--- a/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManager.java
+++ b/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManager.java
@@ -25,8 +25,8 @@ import java.util.concurrent.atomic.AtomicLong;
import javax.inject.Inject;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.store.SessionProvider;
@@ -65,18 +65,18 @@ public class InMemoryCurrentQuotaManager implements StoreCurrentQuotaManager {
}
@Override
- public QuotaCount getCurrentMessageCount(QuotaRoot quotaRoot) throws MailboxException {
+ public QuotaCountUsage getCurrentMessageCount(QuotaRoot quotaRoot) throws MailboxException {
try {
- return QuotaCount.count(quotaCache.get(quotaRoot).getCount().get());
+ return QuotaCountUsage.count(quotaCache.get(quotaRoot).getCount().get());
} catch (ExecutionException e) {
throw new MailboxException("Exception caught", e);
}
}
@Override
- public QuotaSize getCurrentStorage(QuotaRoot quotaRoot) throws MailboxException {
+ public QuotaSizeUsage getCurrentStorage(QuotaRoot quotaRoot) throws MailboxException {
try {
- return QuotaSize.size(quotaCache.get(quotaRoot).getSize().get());
+ return QuotaSizeUsage.size(quotaCache.get(quotaRoot).getSize().get());
} catch (ExecutionException e) {
throw new MailboxException("Exception caught", e);
}
diff --git a/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManager.java b/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManager.java
index 848118a..6808197 100644
--- a/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManager.java
+++ b/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManager.java
@@ -26,8 +26,8 @@ import java.util.stream.Stream;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.MaxQuotaManager;
@@ -37,27 +37,27 @@ import com.github.steveash.guavate.Guavate;
public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager {
- private Optional<QuotaCount> maxMessage = Optional.empty();
- private Optional<QuotaSize> maxStorage = Optional.empty();
+ private Optional<QuotaCountLimit> maxMessage = Optional.empty();
+ private Optional<QuotaSizeLimit> maxStorage = Optional.empty();
- private final Map<Domain, QuotaCount> domainMaxMessage = new ConcurrentHashMap<>();
- private final Map<Domain, QuotaSize> domainMaxStorage = new ConcurrentHashMap<>();
+ private final Map<Domain, QuotaCountLimit> domainMaxMessage = new ConcurrentHashMap<>();
+ private final Map<Domain, QuotaSizeLimit> domainMaxStorage = new ConcurrentHashMap<>();
- private final Map<String, QuotaSize> userMaxStorage = new ConcurrentHashMap<>();
- private final Map<String, QuotaCount> userMaxMessage = new ConcurrentHashMap<>();
+ private final Map<String, QuotaSizeLimit> userMaxStorage = new ConcurrentHashMap<>();
+ private final Map<String, QuotaCountLimit> userMaxMessage = new ConcurrentHashMap<>();
@Override
- public void setGlobalMaxStorage(QuotaSize maxStorage) {
+ public void setGlobalMaxStorage(QuotaSizeLimit maxStorage) {
this.maxStorage = Optional.of(maxStorage);
}
@Override
- public void setDomainMaxMessage(Domain domain, QuotaCount count) {
+ public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) {
domainMaxMessage.put(domain, count);
}
@Override
- public void setDomainMaxStorage(Domain domain, QuotaSize size) {
+ public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) {
domainMaxStorage.put(domain, size);
}
@@ -72,8 +72,8 @@ public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Map<Quota.Scope, QuotaCount> listMaxMessagesDetails(QuotaRoot quotaRoot) {
- Function<Domain, Optional<QuotaCount>> domainQuotaFunction = Throwing.function(this::getDomainMaxMessage).sneakyThrow();
+ public Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot) {
+ Function<Domain, Optional<QuotaCountLimit>> domainQuotaFunction = Throwing.function(this::getDomainMaxMessage).sneakyThrow();
return Stream.of(
Pair.of(Quota.Scope.User, Optional.ofNullable(userMaxMessage.get(quotaRoot.getValue()))),
Pair.of(Quota.Scope.Domain, quotaRoot.getDomain().flatMap(domainQuotaFunction)),
@@ -83,8 +83,8 @@ public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Map<Quota.Scope, QuotaSize> listMaxStorageDetails(QuotaRoot quotaRoot) {
- Function<Domain, Optional<QuotaSize>> domainQuotaFunction = Throwing.function(this::getDomainMaxStorage).sneakyThrow();
+ public Map<Quota.Scope, QuotaSizeLimit> listMaxStorageDetails(QuotaRoot quotaRoot) {
+ Function<Domain, Optional<QuotaSizeLimit>> domainQuotaFunction = Throwing.function(this::getDomainMaxStorage).sneakyThrow();
return Stream.of(
Pair.of(Quota.Scope.User, Optional.ofNullable(userMaxStorage.get(quotaRoot.getValue()))),
Pair.of(Quota.Scope.Domain, quotaRoot.getDomain().flatMap(domainQuotaFunction)),
@@ -94,37 +94,37 @@ public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxMessage(QuotaCount maxMessage) {
+ public void setGlobalMaxMessage(QuotaCountLimit maxMessage) {
this.maxMessage = Optional.of(maxMessage);
}
@Override
- public Optional<QuotaCount> getDomainMaxMessage(Domain domain) {
+ public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) {
return Optional.ofNullable(domainMaxMessage.get(domain));
}
@Override
- public Optional<QuotaSize> getDomainMaxStorage(Domain domain) {
+ public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) {
return Optional.ofNullable(domainMaxStorage.get(domain));
}
@Override
- public void setMaxStorage(QuotaRoot user, QuotaSize maxStorageQuota) {
+ public void setMaxStorage(QuotaRoot user, QuotaSizeLimit maxStorageQuota) {
userMaxStorage.put(user.getValue(), maxStorageQuota);
}
@Override
- public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) {
+ public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) {
userMaxMessage.put(quotaRoot.getValue(), maxMessageCount);
}
@Override
- public Optional<QuotaSize> getGlobalMaxStorage() {
+ public Optional<QuotaSizeLimit> getGlobalMaxStorage() {
return maxStorage;
}
@Override
- public Optional<QuotaCount> getGlobalMaxMessage() {
+ public Optional<QuotaCountLimit> getGlobalMaxMessage() {
return maxMessage;
}
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManagerTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManagerTest.java
index 1446af8..95aa1b4 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManagerTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManagerTest.java
@@ -25,8 +25,8 @@ import static org.mockito.Mockito.when;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.store.SessionProvider;
import org.apache.james.mailbox.store.quota.CurrentQuotaCalculator;
@@ -51,7 +51,7 @@ public class InMemoryCurrentQuotaManagerTest {
when(mockedCurrentQuotaCalculator.recalculateCurrentQuotas(QUOTA_ROOT, null))
.thenReturn(new CurrentQuotaCalculator.CurrentQuotas(18, 512));
- assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(18));
+ assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCountUsage.count(18));
}
@Test
@@ -59,7 +59,7 @@ public class InMemoryCurrentQuotaManagerTest {
when(mockedCurrentQuotaCalculator.recalculateCurrentQuotas(QUOTA_ROOT, null))
.thenReturn(new CurrentQuotaCalculator.CurrentQuotas(18, 512));
- assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(512));
+ assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSizeUsage.size(512));
}
@Test
@@ -69,8 +69,8 @@ public class InMemoryCurrentQuotaManagerTest {
testee.increase(QUOTA_ROOT, 10, 100);
- assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(28));
- assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(612));
+ assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCountUsage.count(28));
+ assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSizeUsage.size(612));
}
@Test(expected = IllegalArgumentException.class)
diff --git a/mailbox/plugin/quota-mailing-cassandra/src/main/java/org/apache/james/mailbox/quota/cassandra/dto/QuotaDTO.java b/mailbox/plugin/quota-mailing-cassandra/src/main/java/org/apache/james/mailbox/quota/cassandra/dto/QuotaDTO.java
index 30b0685..78e69cd 100644
--- a/mailbox/plugin/quota-mailing-cassandra/src/main/java/org/apache/james/mailbox/quota/cassandra/dto/QuotaDTO.java
+++ b/mailbox/plugin/quota-mailing-cassandra/src/main/java/org/apache/james/mailbox/quota/cassandra/dto/QuotaDTO.java
@@ -21,8 +21,10 @@ package org.apache.james.mailbox.quota.cassandra.dto;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import com.fasterxml.jackson.annotation.JsonCreator;
@@ -30,7 +32,7 @@ import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
class QuotaDTO {
- public static QuotaDTO from(Quota<?> quota) {
+ public static QuotaDTO from(Quota<?, ?> quota) {
if (quota.getLimit().isUnlimited()) {
return new QuotaDTO(quota.getUsed().asLong(), Optional.empty());
}
@@ -56,18 +58,18 @@ class QuotaDTO {
}
@JsonIgnore
- public Quota<QuotaSize> asSizeQuota() {
- return Quota.<QuotaSize>builder()
- .used(QuotaSize.size(used))
- .computedLimit(QuotaSize.size(limit))
+ public Quota<QuotaSizeLimit, QuotaSizeUsage> asSizeQuota() {
+ return Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(used))
+ .computedLimit(QuotaSizeLimit.size(limit))
.build();
}
@JsonIgnore
- public Quota<QuotaCount> asCountQuota() {
- return Quota.<QuotaCount>builder()
- .used(QuotaCount.count(used))
- .computedLimit(QuotaCount.count(limit))
+ public Quota<QuotaCountLimit, QuotaCountUsage> asCountQuota() {
+ return Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(used))
+ .computedLimit(QuotaCountLimit.count(limit))
.build();
}
}
diff --git a/mailbox/plugin/quota-mailing-cassandra/src/test/java/org/apache/james/mailbox/quota/cassandra/dto/DTOTest.java b/mailbox/plugin/quota-mailing-cassandra/src/test/java/org/apache/james/mailbox/quota/cassandra/dto/DTOTest.java
index a239520..d9a323d 100644
--- a/mailbox/plugin/quota-mailing-cassandra/src/test/java/org/apache/james/mailbox/quota/cassandra/dto/DTOTest.java
+++ b/mailbox/plugin/quota-mailing-cassandra/src/test/java/org/apache/james/mailbox/quota/cassandra/dto/DTOTest.java
@@ -27,8 +27,10 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.time.Instant;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.eventsourcing.EventId;
import org.apache.james.eventsourcing.eventstore.cassandra.JsonEventSerializer;
import org.apache.james.mailbox.model.Quota;
@@ -46,8 +48,8 @@ import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
class DTOTest {
- static final Quota<QuotaSize> SIZE_QUOTA = Quota.<QuotaSize>builder().used(QuotaSize.size(23)).computedLimit(QuotaSize.size(33)).build();
- static final Quota<QuotaCount> COUNT_QUOTA = Quota.<QuotaCount>builder().used(QuotaCount.count(12)).computedLimit(QuotaCount.count(45)).build();
+ static final Quota<QuotaSizeLimit, QuotaSizeUsage> SIZE_QUOTA = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(23)).computedLimit(QuotaSizeLimit.size(33)).build();
+ static final Quota<QuotaCountLimit, QuotaCountUsage> COUNT_QUOTA = Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(12)).computedLimit(QuotaCountLimit.count(45)).build();
static final Instant INSTANT = Instant.ofEpochMilli(45554);
public static final String DEFAULT_LISTENER_NAME = "default";
static final QuotaThresholdChangedEvent EVENT = new QuotaThresholdChangedEvent(
@@ -62,7 +64,7 @@ class DTOTest {
HistoryEvolution.lowerThresholdReached(new QuotaThresholdChange(_75, INSTANT)),
HistoryEvolution.noChanges(),
SIZE_QUOTA,
- Quota.<QuotaCount>builder().used(QuotaCount.count(12)).computedLimit(QuotaCount.unlimited()).build(),
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(12)).computedLimit(QuotaCountLimit.unlimited()).build(),
UserQuotaThresholds.Id.from(Username.of("foo@bar.com"), DEFAULT_LISTENER_NAME));
static final QuotaThresholdChangedEvent EVENT_3 = new QuotaThresholdChangedEvent(
EventId.first(),
@@ -70,7 +72,7 @@ class DTOTest {
HistoryEvolution.higherThresholdReached(new QuotaThresholdChange(_80, INSTANT),
HistoryEvolution.HighestThresholdRecentness.NotAlreadyReachedDuringGracePeriod),
SIZE_QUOTA,
- Quota.<QuotaCount>builder().used(QuotaCount.count(12)).computedLimit(QuotaCount.unlimited()).build(),
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(12)).computedLimit(QuotaCountLimit.unlimited()).build(),
UserQuotaThresholds.Id.from(Username.of("foo@bar.com"), DEFAULT_LISTENER_NAME));
static final QuotaThresholdChangedEvent EVENT_4 = new QuotaThresholdChangedEvent(
EventId.first(),
@@ -78,7 +80,7 @@ class DTOTest {
HistoryEvolution.higherThresholdReached(new QuotaThresholdChange(_80, INSTANT),
HistoryEvolution.HighestThresholdRecentness.AlreadyReachedDuringGracePeriod),
SIZE_QUOTA,
- Quota.<QuotaCount>builder().used(QuotaCount.count(12)).computedLimit(QuotaCount.unlimited()).build(),
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(12)).computedLimit(QuotaCountLimit.unlimited()).build(),
UserQuotaThresholds.Id.from(Username.of("foo@bar.com"), DEFAULT_LISTENER_NAME));
static final String EVENT_JSON = ClassLoaderUtils.getSystemResourceAsString("json/event.json");
diff --git a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/aggregates/UserQuotaThresholds.java b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/aggregates/UserQuotaThresholds.java
index 7203a7a..d3162cf 100644
--- a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/aggregates/UserQuotaThresholds.java
+++ b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/aggregates/UserQuotaThresholds.java
@@ -26,8 +26,10 @@ import java.util.Objects;
import java.util.stream.Collectors;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.eventsourcing.AggregateId;
import org.apache.james.eventsourcing.eventstore.History;
import org.apache.james.mailbox.model.Quota;
@@ -142,7 +144,7 @@ public class UserQuotaThresholds {
return events;
}
- private List<QuotaThresholdChangedEvent> generateEvents(QuotaThresholds configuration, Duration gracePeriod, Quota<QuotaCount> countQuota, Quota<QuotaSize> sizeQuota, Instant now) {
+ private List<QuotaThresholdChangedEvent> generateEvents(QuotaThresholds configuration, Duration gracePeriod, Quota<QuotaCountLimit, QuotaCountUsage> countQuota, Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Instant now) {
QuotaThresholdChange countThresholdChange = new QuotaThresholdChange(configuration.highestExceededThreshold(countQuota), now);
QuotaThresholdChange sizeThresholdChange = new QuotaThresholdChange(configuration.highestExceededThreshold(sizeQuota), now);
@@ -172,7 +174,7 @@ public class UserQuotaThresholds {
.collect(Guavate.toImmutableList()));
}
- private List<QuotaThresholdChangedEvent> generateEvents(HistoryEvolution countHistoryEvolution, HistoryEvolution sizeHistoryEvolution, Quota<QuotaCount> countQuota, Quota<QuotaSize> sizeQuota) {
+ private List<QuotaThresholdChangedEvent> generateEvents(HistoryEvolution countHistoryEvolution, HistoryEvolution sizeHistoryEvolution, Quota<QuotaCountLimit, QuotaCountUsage> countQuota, Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota) {
if (countHistoryEvolution.isChange() || sizeHistoryEvolution.isChange()) {
return ImmutableList.of(
new QuotaThresholdChangedEvent(
diff --git a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/commands/DetectThresholdCrossing.java b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/commands/DetectThresholdCrossing.java
index 833388d..557d22e 100644
--- a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/commands/DetectThresholdCrossing.java
+++ b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/commands/DetectThresholdCrossing.java
@@ -23,19 +23,21 @@ import java.time.Instant;
import java.util.Objects;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.eventsourcing.Command;
import org.apache.james.mailbox.model.Quota;
public class DetectThresholdCrossing implements Command {
private final Username username;
- private final Quota<QuotaCount> countQuota;
- private final Quota<QuotaSize> sizeQuota;
+ private final Quota<QuotaCountLimit, QuotaCountUsage> countQuota;
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota;
private final Instant instant;
- public DetectThresholdCrossing(Username username, Quota<QuotaCount> countQuota, Quota<QuotaSize> sizeQuota, Instant instant) {
+ public DetectThresholdCrossing(Username username, Quota<QuotaCountLimit, QuotaCountUsage> countQuota, Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Instant instant) {
this.username = username;
this.countQuota = countQuota;
this.sizeQuota = sizeQuota;
@@ -46,11 +48,11 @@ public class DetectThresholdCrossing implements Command {
return username;
}
- public Quota<QuotaCount> getCountQuota() {
+ public Quota<QuotaCountLimit, QuotaCountUsage> getCountQuota() {
return countQuota;
}
- public Quota<QuotaSize> getSizeQuota() {
+ public Quota<QuotaSizeLimit, QuotaSizeUsage> getSizeQuota() {
return sizeQuota;
}
diff --git a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/events/QuotaThresholdChangedEvent.java b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/events/QuotaThresholdChangedEvent.java
index 99022f3..d5017e2 100644
--- a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/events/QuotaThresholdChangedEvent.java
+++ b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/events/QuotaThresholdChangedEvent.java
@@ -21,8 +21,10 @@ package org.apache.james.mailbox.quota.mailing.events;
import java.util.Objects;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.eventsourcing.Event;
import org.apache.james.eventsourcing.EventId;
import org.apache.james.mailbox.model.Quota;
@@ -34,11 +36,11 @@ public class QuotaThresholdChangedEvent implements Event {
private final EventId eventId;
private final HistoryEvolution sizeHistoryEvolution;
private final HistoryEvolution countHistoryEvolution;
- private final Quota<QuotaSize> sizeQuota;
- private final Quota<QuotaCount> countQuota;
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota;
+ private final Quota<QuotaCountLimit, QuotaCountUsage> countQuota;
private final UserQuotaThresholds.Id aggregateId;
- public QuotaThresholdChangedEvent(EventId eventId, HistoryEvolution sizeHistoryEvolution, HistoryEvolution countHistoryEvolution, Quota<QuotaSize> sizeQuota, Quota<QuotaCount> countQuota, UserQuotaThresholds.Id aggregateId) {
+ public QuotaThresholdChangedEvent(EventId eventId, HistoryEvolution sizeHistoryEvolution, HistoryEvolution countHistoryEvolution, Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Quota<QuotaCountLimit, QuotaCountUsage> countQuota, UserQuotaThresholds.Id aggregateId) {
this.eventId = eventId;
this.sizeHistoryEvolution = sizeHistoryEvolution;
this.countHistoryEvolution = countHistoryEvolution;
@@ -55,11 +57,11 @@ public class QuotaThresholdChangedEvent implements Event {
return countHistoryEvolution;
}
- public Quota<QuotaSize> getSizeQuota() {
+ public Quota<QuotaSizeLimit, QuotaSizeUsage> getSizeQuota() {
return sizeQuota;
}
- public Quota<QuotaCount> getCountQuota() {
+ public Quota<QuotaCountLimit, QuotaCountUsage> getCountQuota() {
return countQuota;
}
diff --git a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNotice.java b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNotice.java
index 884f4a1..018d1fa 100644
--- a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNotice.java
+++ b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNotice.java
@@ -34,8 +34,10 @@ import java.util.stream.Stream;
import org.apache.commons.io.IOUtils;
import org.apache.james.core.builder.MimeMessageBuilder;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.filesystem.api.FileSystem;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.quota.mailing.QuotaMailingListenerConfiguration;
@@ -56,8 +58,8 @@ public class QuotaThresholdNotice {
public static class Builder {
private Optional<QuotaThreshold> countThreshold;
private Optional<QuotaThreshold> sizeThreshold;
- private Quota<QuotaSize> sizeQuota;
- private Quota<QuotaCount> countQuota;
+ private Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota;
+ private Quota<QuotaCountLimit, QuotaCountUsage> countQuota;
private QuotaMailingListenerConfiguration configuration;
public Builder() {
@@ -65,12 +67,12 @@ public class QuotaThresholdNotice {
sizeThreshold = Optional.empty();
}
- public Builder sizeQuota(Quota<QuotaSize> sizeQuota) {
+ public Builder sizeQuota(Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota) {
this.sizeQuota = sizeQuota;
return this;
}
- public Builder countQuota(Quota<QuotaCount> countQuota) {
+ public Builder countQuota(Quota<QuotaCountLimit, QuotaCountUsage> countQuota) {
this.countQuota = countQuota;
return this;
}
@@ -120,13 +122,13 @@ public class QuotaThresholdNotice {
private final Optional<QuotaThreshold> countThreshold;
private final Optional<QuotaThreshold> sizeThreshold;
- private final Quota<QuotaSize> sizeQuota;
- private final Quota<QuotaCount> countQuota;
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota;
+ private final Quota<QuotaCountLimit, QuotaCountUsage> countQuota;
private final QuotaMailingListenerConfiguration configuration;
@VisibleForTesting
QuotaThresholdNotice(Optional<QuotaThreshold> countThreshold, Optional<QuotaThreshold> sizeThreshold,
- Quota<QuotaSize> sizeQuota, Quota<QuotaCount> countQuota, QuotaMailingListenerConfiguration configuration) {
+ Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Quota<QuotaCountLimit, QuotaCountUsage> countQuota, QuotaMailingListenerConfiguration configuration) {
this.countThreshold = countThreshold;
this.sizeThreshold = sizeThreshold;
this.sizeQuota = sizeQuota;
diff --git a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThreshold.java b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThreshold.java
index dea2676..1706e6e 100644
--- a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThreshold.java
+++ b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThreshold.java
@@ -47,7 +47,7 @@ public class QuotaThreshold implements Comparable<QuotaThreshold> {
return Double.valueOf(quotaOccupationRatio * 100).intValue();
}
- public boolean isExceeded(Quota<?> quota) {
+ public boolean isExceeded(Quota<?, ?> quota) {
if (quota.getLimit().isUnlimited()) {
return false;
}
diff --git a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThresholds.java b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThresholds.java
index 8f92ed3..1b8c551 100644
--- a/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThresholds.java
+++ b/mailbox/plugin/quota-mailing/src/main/java/org/apache/james/mailbox/quota/model/QuotaThresholds.java
@@ -43,7 +43,7 @@ public class QuotaThresholds {
.collect(Guavate.toImmutableList());
}
- public QuotaThreshold highestExceededThreshold(Quota<?> quota) {
+ public QuotaThreshold highestExceededThreshold(Quota<?, ?> quota) {
return quotaThresholds.stream()
.filter(quotaLevel -> quotaLevel.isExceeded(quota))
.findFirst()
diff --git a/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNoticeTest.java b/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNoticeTest.java
index f62ad85..325b111 100644
--- a/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNoticeTest.java
+++ b/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/mailing/subscribers/QuotaThresholdNoticeTest.java
@@ -29,8 +29,10 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.filesystem.api.FileSystem;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.quota.QuotaFixture.Counts;
@@ -107,8 +109,8 @@ class QuotaThresholdNoticeTest {
@Test
void buildShouldReturnPresentWhenAbove() {
- Quota<QuotaSize> sizeQuota = Sizes._82_PERCENT;
- Quota<QuotaCount> countQuota = Counts._82_PERCENT;
+ Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota = Sizes._82_PERCENT;
+ Quota<QuotaCountLimit, QuotaCountUsage> countQuota = Counts._82_PERCENT;
QuotaThresholdChange sizeThresholdChange = new QuotaThresholdChange(_80, NOW);
assertThat(QuotaThresholdNotice.builder()
@@ -123,8 +125,8 @@ class QuotaThresholdNoticeTest {
@Test
void buildShouldFilterOutNotInterestingFields() {
- Quota<QuotaSize> sizeQuota = Sizes._82_PERCENT;
- Quota<QuotaCount> countQuota = Counts._82_PERCENT;
+ Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota = Sizes._82_PERCENT;
+ Quota<QuotaCountLimit, QuotaCountUsage> countQuota = Counts._82_PERCENT;
QuotaThresholdChange sizeThresholdChange = new QuotaThresholdChange(_80, NOW);
QuotaThresholdChange countThresholdChange = new QuotaThresholdChange(_80, NOW);
@@ -141,8 +143,8 @@ class QuotaThresholdNoticeTest {
@Test
void buildShouldKeepAllInterestingFields() {
- Quota<QuotaSize> sizeQuota = Sizes._82_PERCENT;
- Quota<QuotaCount> countQuota = Counts._82_PERCENT;
+ Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota = Sizes._82_PERCENT;
+ Quota<QuotaCountLimit, QuotaCountUsage> countQuota = Counts._82_PERCENT;
QuotaThresholdChange sizeThresholdChange = new QuotaThresholdChange(_80, NOW);
QuotaThresholdChange countThresholdChange = new QuotaThresholdChange(_80, NOW);
@@ -210,9 +212,9 @@ class QuotaThresholdNoticeTest {
assertThat(QuotaThresholdNotice.builder()
.withConfiguration(DEFAULT_CONFIGURATION)
- .sizeQuota(Quota.<QuotaSize>builder()
- .used(QuotaSize.size(801 * 1024 * 1024))
- .computedLimit(QuotaSize.size(1 * 1024 * 1024 * 1024))
+ .sizeQuota(Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(801 * 1024 * 1024))
+ .computedLimit(QuotaSizeLimit.size(1 * 1024 * 1024 * 1024))
.build())
.countQuota(Counts._72_PERCENT)
.sizeThreshold(HistoryEvolution.higherThresholdReached(sizeThresholdChange, NotAlreadyReachedDuringGracePeriod))
@@ -228,9 +230,9 @@ class QuotaThresholdNoticeTest {
assertThat(QuotaThresholdNotice.builder()
.withConfiguration(DEFAULT_CONFIGURATION)
- .sizeQuota(Quota.<QuotaSize>builder()
- .used(QuotaSize.size(801 * 1024 * 1024))
- .computedLimit(QuotaSize.size((2 * 1024 * 1024 * 1024) - 1))
+ .sizeQuota(Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(801 * 1024 * 1024))
+ .computedLimit(QuotaSizeLimit.size((2 * 1024 * 1024 * 1024) - 1))
.build())
.countQuota(Counts._72_PERCENT)
.sizeThreshold(HistoryEvolution.higherThresholdReached(sizeThresholdChange, NotAlreadyReachedDuringGracePeriod))
diff --git a/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdTest.java b/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdTest.java
index f316459..15a47e8 100644
--- a/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdTest.java
+++ b/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdTest.java
@@ -26,7 +26,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.quota.QuotaFixture.Sizes;
import org.junit.jupiter.api.Test;
@@ -86,9 +87,9 @@ public class QuotaThresholdTest {
@Test
public void isExceededShouldReturnFalseWhenUnlimited() {
- Quota<QuotaSize> quota = Quota.<QuotaSize>builder()
- .computedLimit(QuotaSize.unlimited())
- .used(QuotaSize.size(80))
+ Quota<QuotaSizeLimit, QuotaSizeUsage> quota = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .computedLimit(QuotaSizeLimit.unlimited())
+ .used(QuotaSizeUsage.size(80))
.build();
assertThat(_75.isExceeded(quota))
diff --git a/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdsTest.java b/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdsTest.java
index 4674f02..c2a07bb 100644
--- a/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdsTest.java
+++ b/mailbox/plugin/quota-mailing/src/test/java/org/apache/james/mailbox/quota/model/QuotaThresholdsTest.java
@@ -25,13 +25,13 @@ import static org.apache.james.mailbox.quota.model.QuotaThresholdFixture._95;
import static org.apache.james.mailbox.quota.model.QuotaThresholdFixture._99;
import static org.assertj.core.api.Assertions.assertThat;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.quota.QuotaFixture.Sizes;
import org.junit.jupiter.api.Test;
import com.google.common.collect.ImmutableList;
-
import nl.jqno.equalsverifier.EqualsVerifier;
public class QuotaThresholdsTest {
@@ -46,9 +46,9 @@ public class QuotaThresholdsTest {
public void highestExceededThresholdShouldReturnZeroWhenBelowAllThresholds() {
assertThat(
new QuotaThresholds(ImmutableList.of(_50, _80, _95, _99))
- .highestExceededThreshold(Quota.<QuotaSize>builder()
- .used(QuotaSize.size(40))
- .computedLimit(QuotaSize.size(100))
+ .highestExceededThreshold(Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(40))
+ .computedLimit(QuotaSizeLimit.size(100))
.build()))
.isEqualTo(QuotaThreshold.ZERO);
}
@@ -81,9 +81,9 @@ public class QuotaThresholdsTest {
public void highestExceededThresholdShouldReturnZeroWhenUnlimitedQuota() {
assertThat(
new QuotaThresholds(ImmutableList.of(_50, _80, _95, _99))
- .highestExceededThreshold(Quota.<QuotaSize>builder()
- .used(QuotaSize.size(992))
- .computedLimit(QuotaSize.unlimited())
+ .highestExceededThreshold(Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(992))
+ .computedLimit(QuotaSizeLimit.unlimited())
.build()))
.isEqualTo(QuotaThreshold.ZERO);
}
diff --git a/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/ElasticSearchQuotaSearcherTest.java b/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/ElasticSearchQuotaSearcherTest.java
index 373a069..1489e72 100644
--- a/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/ElasticSearchQuotaSearcherTest.java
+++ b/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/ElasticSearchQuotaSearcherTest.java
@@ -25,7 +25,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.stream.IntStream;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.quota.search.Limit;
import org.apache.james.quota.search.Offset;
import org.apache.james.quota.search.QuotaQuery;
@@ -40,7 +40,7 @@ class ElasticSearchQuotaSearcherTest implements QuotaSearcherContract {
void searchShouldNotBeLimitedByElasticSearchDefaultSearchLimit(QuotaSearchTestSystem testSystem) throws Exception {
int userCount = 11;
testSystem.getDomainList().addDomain(SIMPSON_COM);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
IntStream.range(0, userCount)
.boxed()
@@ -60,7 +60,7 @@ class ElasticSearchQuotaSearcherTest implements QuotaSearcherContract {
void searchShouldNotBeLimitedByElasticSearchDefaultSearchLimitWhenUsingOffset(QuotaSearchTestSystem testSystem) throws Exception {
int userCount = 12;
testSystem.getDomainList().addDomain(SIMPSON_COM);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
IntStream.range(0, userCount)
.boxed()
diff --git a/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/json/QuotaRatioAsJsonTest.java b/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/json/QuotaRatioAsJsonTest.java
index 68ff7d9..67102ef 100644
--- a/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/json/QuotaRatioAsJsonTest.java
+++ b/mailbox/plugin/quota-search-elasticsearch/src/test/java/org/apache/james/quota/search/elasticsearch/json/QuotaRatioAsJsonTest.java
@@ -23,8 +23,10 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRatio;
import org.junit.jupiter.api.Test;
@@ -33,13 +35,13 @@ import nl.jqno.equalsverifier.EqualsVerifier;
class QuotaRatioAsJsonTest {
- private static final Quota<QuotaSize> QUOTA_SIZE = Quota.<QuotaSize>builder()
- .used(QuotaSize.size(15))
- .computedLimit(QuotaSize.size(60))
+ private static final Quota<QuotaSizeLimit, QuotaSizeUsage> QUOTA_SIZE = Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(15))
+ .computedLimit(QuotaSizeLimit.size(60))
.build();
- private static final Quota<QuotaCount> QUOTA_COUNT = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(1))
- .computedLimit(QuotaCount.count(2))
+ private static final Quota<QuotaCountLimit, QuotaCountUsage> QUOTA_COUNT = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(1))
+ .computedLimit(QuotaCountLimit.count(2))
.build();
@Test
diff --git a/mailbox/plugin/quota-search-scanning/src/main/java/org/apache/james/quota/search/scanning/ClauseConverter.java b/mailbox/plugin/quota-search-scanning/src/main/java/org/apache/james/quota/search/scanning/ClauseConverter.java
index 0a9105a..b7728c0 100644
--- a/mailbox/plugin/quota-search-scanning/src/main/java/org/apache/james/quota/search/scanning/ClauseConverter.java
+++ b/mailbox/plugin/quota-search-scanning/src/main/java/org/apache/james/quota/search/scanning/ClauseConverter.java
@@ -26,8 +26,10 @@ import java.util.function.Predicate;
import javax.inject.Inject;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRatio;
@@ -93,8 +95,8 @@ public class ClauseConverter {
private double retrieveUserRatio(Username username) {
try {
QuotaRoot quotaRoot = quotaRootResolver.forUser(username);
- Quota<QuotaSize> storageQuota = quotaManager.getStorageQuota(quotaRoot);
- Quota<QuotaCount> messageQuota = quotaManager.getMessageQuota(quotaRoot);
+ Quota<QuotaSizeLimit, QuotaSizeUsage> storageQuota = quotaManager.getStorageQuota(quotaRoot);
+ Quota<QuotaCountLimit, QuotaCountUsage> messageQuota = quotaManager.getMessageQuota(quotaRoot);
return QuotaRatio.from(storageQuota, messageQuota).max();
} catch (MailboxException e) {
diff --git a/mailbox/plugin/quota-search/src/test/java/org/apache/james/quota/search/QuotaSearcherContract.java b/mailbox/plugin/quota-search/src/test/java/org/apache/james/quota/search/QuotaSearcherContract.java
index 9fbac9a..a24b393 100644
--- a/mailbox/plugin/quota-search/src/test/java/org/apache/james/quota/search/QuotaSearcherContract.java
+++ b/mailbox/plugin/quota-search/src/test/java/org/apache/james/quota/search/QuotaSearcherContract.java
@@ -32,7 +32,7 @@ import java.nio.charset.StandardCharsets;
import org.apache.james.core.CoreFixture.Users.Alphabet;
import org.apache.james.core.CoreFixture.Users.Simpson;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.domainlist.api.DomainListException;
import org.apache.james.mailbox.MailboxManager;
import org.apache.james.mailbox.MailboxSession;
@@ -54,7 +54,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Simpson.BART, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.HOMER, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.LISA, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Simpson.BART, withSize(49));
appendMessage(testSystem, Simpson.HOMER, withSize(50));
@@ -74,7 +74,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Simpson.BART, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.HOMER, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.LISA, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Simpson.BART, withSize(49));
appendMessage(testSystem, Simpson.HOMER, withSize(50));
@@ -94,7 +94,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Simpson.BART, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.HOMER, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.LISA, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Simpson.BART, withSize(40));
appendMessage(testSystem, Simpson.HOMER, withSize(51));
@@ -117,7 +117,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Simpson.BART, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.LISA, PASSWORD);
testSystem.getUsersRepository().addUser(BENOIT_AT_DOMAIN_TLD, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Simpson.BART, withSize(49));
appendMessage(testSystem, Simpson.LISA, withSize(51));
@@ -138,7 +138,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Simpson.BART, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.LISA, PASSWORD);
testSystem.getUsersRepository().addUser(BENOIT_AT_DOMAIN_TLD, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Simpson.BART, withSize(49));
appendMessage(testSystem, Simpson.LISA, withSize(51));
@@ -160,7 +160,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Alphabet.ABA, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ABB, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ACB, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Alphabet.AAA, withSize(49));
appendMessage(testSystem, Alphabet.ABA, withSize(50));
@@ -181,7 +181,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Alphabet.ABA, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ABB, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ACB, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Alphabet.AAA, withSize(49));
appendMessage(testSystem, Alphabet.ABA, withSize(50));
@@ -203,7 +203,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Alphabet.ABA, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ABB, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ACB, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Alphabet.AAA, withSize(49));
appendMessage(testSystem, Alphabet.ABA, withSize(50));
@@ -226,7 +226,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Simpson.HOMER, PASSWORD);
testSystem.getUsersRepository().addUser(Simpson.LISA, PASSWORD);
testSystem.getUsersRepository().addUser(BENOIT_AT_DOMAIN_TLD, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Simpson.BART, withSize(49));
appendMessage(testSystem, Simpson.HOMER, withSize(50));
@@ -248,7 +248,7 @@ public interface QuotaSearcherContract {
testSystem.getUsersRepository().addUser(Alphabet.ABA, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ABB, PASSWORD);
testSystem.getUsersRepository().addUser(Alphabet.ACB, PASSWORD);
- testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSize.size(100));
+ testSystem.getMaxQuotaManager().setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem, Alphabet.AAA, withSize(49));
appendMessage(testSystem, Alphabet.ABA, withSize(50));
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
index 671bc8c..877fca0 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java
@@ -33,8 +33,8 @@ import java.util.stream.Stream;
import javax.inject.Inject;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MailboxAnnotationManager;
import org.apache.james.mailbox.MailboxManager;
import org.apache.james.mailbox.MailboxPathLocker;
@@ -449,8 +449,8 @@ public class StoreMailboxManager implements MailboxManager {
.mailboxSession(session)
.mailbox(mailbox)
.quotaRoot(quotaRoot)
- .quotaCount(QuotaCount.count(messageCount))
- .quotaSize(QuotaSize.size(totalSize))
+ .quotaCount(QuotaCountUsage.count(messageCount))
+ .quotaSize(QuotaSizeUsage.size(totalSize))
.build(),
new MailboxIdRegistrationKey(mailbox.getMailboxId()))
.block();
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/event/EventFactory.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/event/EventFactory.java
index e2dd560..42f852c 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/event/EventFactory.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/event/EventFactory.java
@@ -25,8 +25,10 @@ import java.util.Map;
import java.util.SortedMap;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.MessageUid;
import org.apache.james.mailbox.acl.ACLDiff;
@@ -154,22 +156,22 @@ public class EventFactory {
@FunctionalInterface
public interface RequireQuotaCountValue<T> {
- T quotaCount(QuotaCount quotaCount);
+ T quotaCount(QuotaCountUsage quotaCount);
}
@FunctionalInterface
public interface RequireQuotaSizeValue<T> {
- T quotaSize(QuotaSize quotaSize);
+ T quotaSize(QuotaSizeUsage quotaSize);
}
@FunctionalInterface
public interface RequireQuotaCount<T> {
- T quotaCount(Quota<QuotaCount> quotaCount);
+ T quotaCount(Quota<QuotaCountLimit, QuotaCountUsage> quotaCount);
}
@FunctionalInterface
public interface RequireQuotaSize<T> {
- T quotaSize(Quota<QuotaSize> quotaSize);
+ T quotaSize(Quota<QuotaSizeLimit, QuotaSizeUsage> quotaSize);
}
@FunctionalInterface
@@ -296,10 +298,10 @@ public class EventFactory {
private final Username username;
private final MailboxSession.SessionId sessionId;
private final QuotaRoot quotaRoot;
- private final QuotaCount deletedMessageCount;
- private final QuotaSize totalDeletedSize;
+ private final QuotaCountUsage deletedMessageCount;
+ private final QuotaSizeUsage totalDeletedSize;
- MailboxDeletionFinalStage(Event.EventId eventId, MailboxPath path, MailboxId mailboxId, Username username, MailboxSession.SessionId sessionId, QuotaRoot quotaRoot, QuotaCount deletedMessageCount, QuotaSize totalDeletedSize) {
+ MailboxDeletionFinalStage(Event.EventId eventId, MailboxPath path, MailboxId mailboxId, Username username, MailboxSession.SessionId sessionId, QuotaRoot quotaRoot, QuotaCountUsage deletedMessageCount, QuotaSizeUsage totalDeletedSize) {
this.eventId = eventId;
this.path = path;
this.mailboxId = mailboxId;
@@ -385,11 +387,11 @@ public class EventFactory {
private final Event.EventId eventId;
private final Username username;
private final QuotaRoot quotaRoot;
- private final Quota<QuotaCount> countQuota;
- private final Quota<QuotaSize> sizeQuota;
+ private final Quota<QuotaCountLimit, QuotaCountUsage> countQuota;
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota;
private final Instant instant;
- QuotaUsageUpdatedFinalStage(Event.EventId eventId, Username username, QuotaRoot quotaRoot, Quota<QuotaCount> countQuota, Quota<QuotaSize> sizeQuota, Instant instant) {
+ QuotaUsageUpdatedFinalStage(Event.EventId eventId, Username username, QuotaRoot quotaRoot, Quota<QuotaCountLimit, QuotaCountUsage> countQuota, Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Instant instant) {
this.eventId = eventId;
this.username = username;
this.quotaRoot = quotaRoot;
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/FixedMaxQuotaManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/FixedMaxQuotaManager.java
index 63847a9..5ee9d8e 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/FixedMaxQuotaManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/FixedMaxQuotaManager.java
@@ -4,8 +4,8 @@ import java.util.Map;
import java.util.Optional;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.exception.UnsupportedOperationException;
import org.apache.james.mailbox.model.Quota;
@@ -21,16 +21,16 @@ import com.google.common.collect.ImmutableMap;
*/
public class FixedMaxQuotaManager implements MaxQuotaManager {
- private Optional<QuotaSize> maxStorage = Optional.empty();
- private Optional<QuotaCount> maxMessage = Optional.empty();
+ private Optional<QuotaSizeLimit> maxStorage = Optional.empty();
+ private Optional<QuotaCountLimit> maxMessage = Optional.empty();
@Override
- public void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) throws MailboxException {
+ public void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) throws MailboxException {
throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager");
}
@Override
- public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) throws MailboxException {
+ public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) throws MailboxException {
throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager");
}
@@ -45,17 +45,17 @@ public class FixedMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setDomainMaxMessage(Domain domain, QuotaCount count) throws MailboxException {
+ public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) throws MailboxException {
throw new UnsupportedOperationException("Can not modify domain specific upper limit for FixedMaxQuotaManager");
}
@Override
- public void setDomainMaxStorage(Domain domain, QuotaSize size) throws UnsupportedOperationException {
+ public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) throws UnsupportedOperationException {
throw new UnsupportedOperationException("Can not modify domain specific upper limit for FixedMaxQuotaManager");
}
@Override
- public void setGlobalMaxStorage(QuotaSize globalMaxStorage) {
+ public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) {
maxStorage = Optional.of(globalMaxStorage);
}
@@ -70,41 +70,41 @@ public class FixedMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxMessage(QuotaCount globalMaxMessageCount) {
+ public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) {
maxMessage = Optional.empty();
}
@Override
- public Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) {
+ public Optional<QuotaSizeLimit> getMaxStorage(QuotaRoot quotaRoot) {
return maxStorage;
}
@Override
- public Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) {
+ public Optional<QuotaCountLimit> getMaxMessage(QuotaRoot quotaRoot) {
return maxMessage;
}
@Override
- public Map<Quota.Scope, QuotaCount> listMaxMessagesDetails(QuotaRoot quotaRoot) {
+ public Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot) {
return maxMessage
.map(value -> ImmutableMap.of(Quota.Scope.Global, value))
.orElse(ImmutableMap.of());
}
@Override
- public Map<Quota.Scope, QuotaSize> listMaxStorageDetails(QuotaRoot quotaRoot) {
+ public Map<Quota.Scope, QuotaSizeLimit> listMaxStorageDetails(QuotaRoot quotaRoot) {
return maxStorage
.map(value -> ImmutableMap.of(Quota.Scope.Global, value))
.orElse(ImmutableMap.of());
}
@Override
- public Optional<QuotaCount> getDomainMaxMessage(Domain domain) {
+ public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) {
return Optional.empty();
}
@Override
- public Optional<QuotaSize> getDomainMaxStorage(Domain domain) {
+ public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) {
return Optional.empty();
}
@@ -119,12 +119,12 @@ public class FixedMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public Optional<QuotaSize> getGlobalMaxStorage() {
+ public Optional<QuotaSizeLimit> getGlobalMaxStorage() {
return maxStorage;
}
@Override
- public Optional<QuotaCount> getGlobalMaxMessage() {
+ public Optional<QuotaCountLimit> getGlobalMaxMessage() {
return maxMessage;
}
}
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoMaxQuotaManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoMaxQuotaManager.java
index 9f52bce..a280e8d 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoMaxQuotaManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoMaxQuotaManager.java
@@ -23,8 +23,8 @@ import java.util.Map;
import java.util.Optional;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -40,12 +40,12 @@ import com.google.common.collect.ImmutableMap;
public class NoMaxQuotaManager implements MaxQuotaManager {
@Override
- public void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) throws MailboxException {
+ public void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) throws MailboxException {
throw new MailboxException("Operation is not supported");
}
@Override
- public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) throws MailboxException {
+ public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) throws MailboxException {
throw new MailboxException("Operation is not supported");
}
@@ -60,12 +60,12 @@ public class NoMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setDomainMaxMessage(Domain domain, QuotaCount count) throws MailboxException {
+ public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) throws MailboxException {
throw new MailboxException("Operation is not supported");
}
@Override
- public void setDomainMaxStorage(Domain domain, QuotaSize size) throws MailboxException {
+ public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) throws MailboxException {
throw new MailboxException("Operation is not supported");
}
@@ -80,7 +80,7 @@ public class NoMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxStorage(QuotaSize globalMaxStorage) throws MailboxException {
+ public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) throws MailboxException {
throw new MailboxException("Operation is not supported");
}
@@ -95,47 +95,47 @@ public class NoMaxQuotaManager implements MaxQuotaManager {
}
@Override
- public void setGlobalMaxMessage(QuotaCount globalMaxMessageCount) throws MailboxException {
+ public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) throws MailboxException {
throw new MailboxException("Operation is not supported");
}
@Override
- public Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) {
+ public Optional<QuotaSizeLimit> getMaxStorage(QuotaRoot quotaRoot) {
return Optional.empty();
}
@Override
- public Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) {
+ public Optional<QuotaCountLimit> getMaxMessage(QuotaRoot quotaRoot) {
return Optional.empty();
}
@Override
- public Map<Quota.Scope, QuotaCount> listMaxMessagesDetails(QuotaRoot quotaRoot) {
+ public Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot) {
return ImmutableMap.of();
}
@Override
- public Map<Quota.Scope, QuotaSize> listMaxStorageDetails(QuotaRoot quotaRoot) {
+ public Map<Quota.Scope, QuotaSizeLimit> listMaxStorageDetails(QuotaRoot quotaRoot) {
return ImmutableMap.of();
}
@Override
- public Optional<QuotaCount> getDomainMaxMessage(Domain domain) {
+ public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) {
return Optional.empty();
}
@Override
- public Optional<QuotaSize> getDomainMaxStorage(Domain domain) {
+ public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) {
return Optional.empty();
}
@Override
- public Optional<QuotaSize> getGlobalMaxStorage() {
+ public Optional<QuotaSizeLimit> getGlobalMaxStorage() {
return Optional.empty();
}
@Override
- public Optional<QuotaCount> getGlobalMaxMessage() {
+ public Optional<QuotaCountLimit> getGlobalMaxMessage() {
return Optional.empty();
}
}
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoQuotaManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoQuotaManager.java
index ded398a..15ae69a 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoQuotaManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoQuotaManager.java
@@ -19,8 +19,10 @@
package org.apache.james.mailbox.store.quota;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.QuotaManager;
@@ -31,18 +33,18 @@ import org.apache.james.mailbox.quota.QuotaManager;
public class NoQuotaManager implements QuotaManager {
@Override
- public Quota<QuotaCount> getMessageQuota(QuotaRoot quotaRoot) {
- return Quota.<QuotaCount>builder()
- .used(QuotaCount.count(0))
- .computedLimit(QuotaCount.unlimited())
+ public Quota<QuotaCountLimit, QuotaCountUsage> getMessageQuota(QuotaRoot quotaRoot) {
+ return Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(0))
+ .computedLimit(QuotaCountLimit.unlimited())
.build();
}
@Override
- public Quota<QuotaSize> getStorageQuota(QuotaRoot quotaRoot) {
- return Quota.<QuotaSize>builder()
- .used(QuotaSize.size(0))
- .computedLimit(QuotaSize.unlimited())
+ public Quota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(QuotaRoot quotaRoot) {
+ return Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
+ .used(QuotaSizeUsage.size(0))
+ .computedLimit(QuotaSizeLimit.unlimited())
.build();
}
}
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/QuotaChecker.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/QuotaChecker.java
index 2c870ea..87e0816 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/QuotaChecker.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/QuotaChecker.java
@@ -19,8 +19,10 @@
package org.apache.james.mailbox.store.quota;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.exception.OverQuotaException;
import org.apache.james.mailbox.model.Mailbox;
@@ -31,8 +33,8 @@ import org.apache.james.mailbox.quota.QuotaRootResolver;
public class QuotaChecker {
- private final Quota<QuotaCount> messageQuota;
- private final Quota<QuotaSize> sizeQuota;
+ private final Quota<QuotaCountLimit, QuotaCountUsage> messageQuota;
+ private final Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota;
private final QuotaRoot quotaRoot;
public QuotaChecker(QuotaManager quotaManager, QuotaRootResolver quotaRootResolver, Mailbox mailbox) throws MailboxException {
@@ -41,7 +43,7 @@ public class QuotaChecker {
this.sizeQuota = quotaManager.getStorageQuota(quotaRoot);
}
- public QuotaChecker(Quota<QuotaCount> messageQuota, Quota<QuotaSize> sizeQuota, QuotaRoot quotaRoot) {
+ public QuotaChecker(Quota<QuotaCountLimit, QuotaCountUsage> messageQuota, Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, QuotaRoot quotaRoot) {
this.messageQuota = messageQuota;
this.sizeQuota = sizeQuota;
this.quotaRoot = quotaRoot;
@@ -53,7 +55,7 @@ public class QuotaChecker {
}
private void trySizeAddition(long size) throws OverQuotaException {
- Quota<QuotaSize> afterAdditionQuotaSize = sizeQuota.addValueToQuota(QuotaSize.size(size));
+ Quota<QuotaSizeLimit, QuotaSizeUsage> afterAdditionQuotaSize = sizeQuota.addValueToQuota(QuotaSizeUsage.size(size));
if (afterAdditionQuotaSize.isOverQuota()) {
throw new OverQuotaException(
"You use too much space in " + quotaRoot.getValue(),
@@ -63,7 +65,7 @@ public class QuotaChecker {
}
private void tryCountAddition(long count) throws OverQuotaException {
- Quota<QuotaCount> afterAdditionQuotaCount = messageQuota.addValueToQuota(QuotaCount.count(count));
+ Quota<QuotaCountLimit, QuotaCountUsage> afterAdditionQuotaCount = messageQuota.addValueToQuota(QuotaCountUsage.count(count));
if (afterAdditionQuotaCount.isOverQuota()) {
throw new OverQuotaException(
"You have too many messages in " + quotaRoot.getValue(),
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/StoreQuotaManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/StoreQuotaManager.java
index 2889270..82d227d 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/StoreQuotaManager.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/StoreQuotaManager.java
@@ -23,8 +23,10 @@ import java.util.Map;
import javax.inject.Inject;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.Quota.Scope;
@@ -49,22 +51,22 @@ public class StoreQuotaManager implements QuotaManager {
}
@Override
- public Quota<QuotaCount> getMessageQuota(QuotaRoot quotaRoot) throws MailboxException {
- Map<Scope, QuotaCount> maxMessageDetails = maxQuotaManager.listMaxMessagesDetails(quotaRoot);
- return Quota.<QuotaCount>builder()
+ public Quota<QuotaCountLimit, QuotaCountUsage> getMessageQuota(QuotaRoot quotaRoot) throws MailboxException {
+ Map<Scope, QuotaCountLimit> maxMessageDetails = maxQuotaManager.listMaxMessagesDetails(quotaRoot);
+ return Quota.<QuotaCountLimit, QuotaCountUsage>builder()
.used(currentQuotaManager.getCurrentMessageCount(quotaRoot))
- .computedLimit(maxQuotaManager.getMaxMessage(maxMessageDetails).orElse(QuotaCount.unlimited()))
+ .computedLimit(maxQuotaManager.getMaxMessage(maxMessageDetails).orElse(QuotaCountLimit.unlimited()))
.limitsByScope(maxMessageDetails)
.build();
}
@Override
- public Quota<QuotaSize> getStorageQuota(QuotaRoot quotaRoot) throws MailboxException {
- Map<Scope, QuotaSize> maxStorageDetails = maxQuotaManager.listMaxStorageDetails(quotaRoot);
- return Quota.<QuotaSize>builder()
+ public Quota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(QuotaRoot quotaRoot) throws MailboxException {
+ Map<Scope, QuotaSizeLimit> maxStorageDetails = maxQuotaManager.listMaxStorageDetails(quotaRoot);
+ return Quota.<QuotaSizeLimit, QuotaSizeUsage>builder()
.used(currentQuotaManager.getCurrentStorage(quotaRoot))
- .computedLimit(maxQuotaManager.getMaxStorage(maxStorageDetails).orElse(QuotaSize.unlimited()))
+ .computedLimit(maxQuotaManager.getMaxStorage(maxStorageDetails).orElse(QuotaSizeLimit.unlimited()))
.limitsByScope(maxStorageDetails)
.build();
}
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerQuotaTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerQuotaTest.java
index 82190d9..8624426 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerQuotaTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerQuotaTest.java
@@ -24,8 +24,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import javax.mail.Flags;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.MailboxSessionUtil;
import org.apache.james.mailbox.MessageIdManager;
@@ -80,7 +80,7 @@ public abstract class AbstractMessageIdManagerQuotaTest {
@Test
void setInMailboxesShouldNotThrowWhenMessageQuotaNotExceeded() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(1));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(1));
MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session);
@@ -89,7 +89,7 @@ public abstract class AbstractMessageIdManagerQuotaTest {
@Test
void setInMailboxesShouldNotThrowWhenStorageQuotaNotExceeded() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(testingData.getConstantMessageSize()));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(testingData.getConstantMessageSize()));
MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session);
@@ -98,7 +98,7 @@ public abstract class AbstractMessageIdManagerQuotaTest {
@Test
void setInMailboxesShouldThrowWhenStorageQuotaExceeded() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(2 * testingData.getConstantMessageSize()));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(2 * testingData.getConstantMessageSize()));
testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session);
MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session);
@@ -111,7 +111,7 @@ public abstract class AbstractMessageIdManagerQuotaTest {
@Test
void setInMailboxesShouldThrowWhenStorageQuotaExceededWhenCopiedToMultipleMailboxes() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(2 * testingData.getConstantMessageSize()));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(2 * testingData.getConstantMessageSize()));
MessageId messageId = testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session);
@@ -123,7 +123,7 @@ public abstract class AbstractMessageIdManagerQuotaTest {
@Test
void setInMailboxesShouldThrowWhenStorageMessageExceeded() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(2));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(2));
testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session);
MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session);
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerSideEffectTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerSideEffectTest.java
index 0a87367..b850249 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerSideEffectTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerSideEffectTest.java
@@ -34,8 +34,10 @@ import java.util.concurrent.CountDownLatch;
import javax.mail.Flags;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.MailboxSessionUtil;
import org.apache.james.mailbox.MessageIdManager;
@@ -73,13 +75,12 @@ import org.mockito.ArgumentCaptor;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedMap;
-
import reactor.core.publisher.Mono;
public abstract class AbstractMessageIdManagerSideEffectTest {
- private static final Quota<QuotaCount> OVER_QUOTA = Quota.<QuotaCount>builder()
- .used(QuotaCount.count(102))
- .computedLimit(QuotaCount.count(100))
+ private static final Quota<QuotaCountLimit, QuotaCountUsage> OVER_QUOTA = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .used(QuotaCountUsage.count(102))
+ .computedLimit(QuotaCountLimit.count(100))
.build();
private static final MessageUid messageUid1 = MessageUid.of(111);
private static final MessageUid messageUid2 = MessageUid.of(113);
@@ -353,10 +354,10 @@ public abstract class AbstractMessageIdManagerSideEffectTest {
MessageId messageId = testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session);
when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(2)).computedLimit(QuotaSize.unlimited()).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(2)).computedLimit(QuotaSizeLimit.unlimited()).build());
when(quotaManager.getMessageQuota(any(QuotaRoot.class))).thenReturn(OVER_QUOTA);
when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(2)).computedLimit(QuotaSize.unlimited()).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(2)).computedLimit(QuotaSizeLimit.unlimited()).build());
assertThatThrownBy(() -> messageIdManager.setInMailboxes(messageId,
ImmutableList.of(mailbox1.getMailboxId(), mailbox2.getMailboxId()),
@@ -522,8 +523,8 @@ public abstract class AbstractMessageIdManagerSideEffectTest {
private void givenUnlimitedQuota() throws MailboxException {
when(quotaManager.getMessageQuota(any(QuotaRoot.class))).thenReturn(
- Quota.<QuotaCount>builder().used(QuotaCount.count(2)).computedLimit(QuotaCount.unlimited()).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(2)).computedLimit(QuotaCountLimit.unlimited()).build());
when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(2)).computedLimit(QuotaSize.unlimited()).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(2)).computedLimit(QuotaSizeLimit.unlimited()).build());
}
}
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/event/MailboxAnnotationListenerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/event/MailboxAnnotationListenerTest.java
index b7feb4d..6be4aad 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/event/MailboxAnnotationListenerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/event/MailboxAnnotationListenerTest.java
@@ -31,8 +31,8 @@ import java.util.List;
import java.util.Optional;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MailboxSession;
import org.apache.james.mailbox.MailboxSessionUtil;
import org.apache.james.mailbox.events.Event;
@@ -89,8 +89,8 @@ public class MailboxAnnotationListenerTest {
.mailboxId(mailboxId)
.mailboxPath(MailboxPath.forUser(USER, "name"))
.quotaRoot(QuotaRoot.quotaRoot("root", Optional.empty()))
- .quotaCount(QuotaCount.count(123))
- .quotaSize(QuotaSize.size(456))
+ .quotaCount(QuotaCountUsage.count(123))
+ .quotaSize(QuotaSizeUsage.size(456))
.build();
when(sessionProvider.createSystemSession(deleteEvent.getUsername()))
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java
index 40a8adf..dbc8e49 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java
@@ -24,8 +24,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.Optional;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.MaxQuotaManager;
@@ -58,66 +58,66 @@ public abstract class GenericMaxQuotaManagerTest {
@Test
void getMaxMessageShouldReturnDomainWhenNoValue() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(36));
- maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(23));
- assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCount.count(23));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(36));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCountLimit.count(23));
+ assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCountLimit.count(23));
}
@Test
void getMaxMessageShouldReturnGlobalWhenNoValue() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(36));
- assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCount.count(36));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(36));
+ assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCountLimit.count(36));
}
@Test
void getMaxStorageShouldReturnGlobalWhenNoValue() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(36));
- assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSize.size(36));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(36));
+ assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSizeLimit.size(36));
}
@Test
void getMaxStorageShouldReturnDomainWhenNoValue() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(234));
- maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(111));
- assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSize.size(111));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(234));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSizeLimit.size(111));
+ assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSizeLimit.size(111));
}
@Test
void getMaxMessageShouldReturnProvidedValue() throws Exception {
- maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(36));
- assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCount.count(36));
+ maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCountLimit.count(36));
+ assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCountLimit.count(36));
}
@Test
void getMaxStorageShouldReturnProvidedValue() throws Exception {
- maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(36));
- assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSize.size(36));
+ maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSizeLimit.size(36));
+ assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSizeLimit.size(36));
}
@Test
void deleteMaxStorageShouldRemoveCurrentValue() throws Exception {
- maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(36));
+ maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSizeLimit.size(36));
maxQuotaManager.removeMaxStorage(QUOTA_ROOT);
assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).isEmpty();
}
@Test
void deleteMaxMessageShouldRemoveCurrentValue() throws Exception {
- maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(36));
+ maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCountLimit.count(36));
maxQuotaManager.removeMaxMessage(QUOTA_ROOT);
assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).isEmpty();
}
@Test
void deleteGlobalMaxStorageShouldRemoveCurrentValue() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(36));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(36));
maxQuotaManager.removeGlobalMaxStorage();
assertThat(maxQuotaManager.getGlobalMaxStorage()).isEmpty();
}
@Test
void deleteGlobalMaxMessageShouldRemoveCurrentValue() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(36));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(36));
maxQuotaManager.removeGlobalMaxMessage();
assertThat(maxQuotaManager.getGlobalMaxMessage()).isEmpty();
}
@@ -134,94 +134,94 @@ public abstract class GenericMaxQuotaManagerTest {
@Test
void listMaxMessagesDetailsShouldReturnGlobalValueWhenDefined() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(123));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(1)
- .containsEntry(Quota.Scope.Global, QuotaCount.count(123));
+ .containsEntry(Quota.Scope.Global, QuotaCountLimit.count(123));
}
@Test
void listMaxMessagesDetailsShouldReturnDomainValueWhenDefined() throws Exception {
- maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(123));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCountLimit.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(1)
- .containsEntry(Quota.Scope.Domain, QuotaCount.count(123));
+ .containsEntry(Quota.Scope.Domain, QuotaCountLimit.count(123));
}
@Test
void listMaxMessagesDetailsShouldReturnUserValueWhenDefined() throws Exception {
- maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(123));
+ maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCountLimit.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(1)
- .containsEntry(Quota.Scope.User, QuotaCount.count(123));
+ .containsEntry(Quota.Scope.User, QuotaCountLimit.count(123));
}
@Test
void listMaxMessagesDetailsShouldReturnBothValuesWhenGlobalAndUserDefined() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(1234));
- maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(123));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(1234));
+ maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCountLimit.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(2)
- .containsEntry(Quota.Scope.Global, QuotaCount.count(1234))
- .containsEntry(Quota.Scope.User, QuotaCount.count(123));
+ .containsEntry(Quota.Scope.Global, QuotaCountLimit.count(1234))
+ .containsEntry(Quota.Scope.User, QuotaCountLimit.count(123));
}
@Test
void listMaxMessagesDetailsShouldReturnAllValuesWhenDefined() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(1234));
- maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(333));
- maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(123));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(1234));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCountLimit.count(333));
+ maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCountLimit.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(3)
- .containsEntry(Quota.Scope.Global, QuotaCount.count(1234))
- .containsEntry(Quota.Scope.Domain, QuotaCount.count(333))
- .containsEntry(Quota.Scope.User, QuotaCount.count(123));
+ .containsEntry(Quota.Scope.Global, QuotaCountLimit.count(1234))
+ .containsEntry(Quota.Scope.Domain, QuotaCountLimit.count(333))
+ .containsEntry(Quota.Scope.User, QuotaCountLimit.count(123));
}
@Test
void listMaxStorageDetailsShouldReturnGlobalValueWhenDefined() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(1111));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(1111));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(1)
- .containsEntry(Quota.Scope.Global, QuotaSize.size(1111));
+ .containsEntry(Quota.Scope.Global, QuotaSizeLimit.size(1111));
}
@Test
void listMaxStorageDetailsShouldReturnDomainValueWhenDefined() throws Exception {
- maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(1111));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSizeLimit.size(1111));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(1)
- .containsEntry(Quota.Scope.Domain, QuotaSize.size(1111));
+ .containsEntry(Quota.Scope.Domain, QuotaSizeLimit.size(1111));
}
@Test
void listMaxStorageDetailsShouldReturnUserValueWhenDefined() throws Exception {
- maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(2222));
+ maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSizeLimit.size(2222));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(1)
- .containsEntry(Quota.Scope.User, QuotaSize.size(2222));
+ .containsEntry(Quota.Scope.User, QuotaSizeLimit.size(2222));
}
@Test
void listMaxStorageDetailsShouldReturnBothValuesWhenDefined() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(3333));
- maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(4444));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(3333));
+ maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSizeLimit.size(4444));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(2)
- .containsEntry(Quota.Scope.Global, QuotaSize.size(3333))
- .containsEntry(Quota.Scope.User, QuotaSize.size(4444));
+ .containsEntry(Quota.Scope.Global, QuotaSizeLimit.size(3333))
+ .containsEntry(Quota.Scope.User, QuotaSizeLimit.size(4444));
}
@Test
void listMaxStorageDetailsShouldReturnAllValuesWhenDefined() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(3333));
- maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(2222));
- maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(4444));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(3333));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSizeLimit.size(2222));
+ maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSizeLimit.size(4444));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(3)
- .containsEntry(Quota.Scope.Global, QuotaSize.size(3333))
- .containsEntry(Quota.Scope.Domain, QuotaSize.size(2222))
- .containsEntry(Quota.Scope.User, QuotaSize.size(4444));
+ .containsEntry(Quota.Scope.Global, QuotaSizeLimit.size(3333))
+ .containsEntry(Quota.Scope.Domain, QuotaSizeLimit.size(2222))
+ .containsEntry(Quota.Scope.User, QuotaSizeLimit.size(4444));
}
@Test
@@ -236,33 +236,33 @@ public abstract class GenericMaxQuotaManagerTest {
@Test
void getDomainMaxMessageShouldReturnProvidedValue() throws Exception {
- maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
- assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN)).contains(QuotaCount.count(36));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCountLimit.count(36));
+ assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN)).contains(QuotaCountLimit.count(36));
}
@Test
void getDomainMaxStorageShouldReturnProvidedValue() throws Exception {
- maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
- assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN)).contains(QuotaSize.size(36));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSizeLimit.size(36));
+ assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN)).contains(QuotaSizeLimit.size(36));
}
@Test
void deleteDomainMaxStorageShouldRemoveCurrentValue() throws Exception {
- maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSizeLimit.size(36));
maxQuotaManager.removeDomainMaxStorage(DOMAIN);
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN)).isEmpty();
}
@Test
void deleteDomainMaxMessageShouldRemoveCurrentValue() throws Exception {
- maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCountLimit.count(36));
maxQuotaManager.removeDomainMaxMessage(DOMAIN);
assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN)).isEmpty();
}
@Test
void deleteDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
- maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCountLimit.count(36));
maxQuotaManager.removeDomainMaxMessage(DOMAIN_CASE_VARIATION);
@@ -271,7 +271,7 @@ public abstract class GenericMaxQuotaManagerTest {
@Test
void deleteDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
- maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSizeLimit.size(36));
maxQuotaManager.removeDomainMaxStorage(DOMAIN_CASE_VARIATION);
@@ -280,36 +280,36 @@ public abstract class GenericMaxQuotaManagerTest {
@Test
void setDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
- maxQuotaManager.setDomainMaxMessage(DOMAIN_CASE_VARIATION, QuotaCount.count(36));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN_CASE_VARIATION, QuotaCountLimit.count(36));
assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN))
- .contains(QuotaCount.count(36));
+ .contains(QuotaCountLimit.count(36));
}
@Test
void setDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
- maxQuotaManager.setDomainMaxStorage(DOMAIN_CASE_VARIATION, QuotaSize.size(36));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN_CASE_VARIATION, QuotaSizeLimit.size(36));
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN))
- .contains(QuotaSize.size(36));
+ .contains(QuotaSizeLimit.size(36));
}
@Test
void getDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
- maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
+ maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCountLimit.count(36));
assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN_CASE_VARIATION))
- .contains(QuotaCount.count(36));
+ .contains(QuotaCountLimit.count(36));
}
@Test
void getDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
- maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
+ maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSizeLimit.size(36));
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN_CASE_VARIATION))
- .contains(QuotaSize.size(36));
+ .contains(QuotaSizeLimit.size(36));
}
}
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/ListeningCurrentQuotaUpdaterTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/ListeningCurrentQuotaUpdaterTest.java
index 917165d..c7f8820 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/ListeningCurrentQuotaUpdaterTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/ListeningCurrentQuotaUpdaterTest.java
@@ -35,8 +35,8 @@ import java.util.Optional;
import javax.mail.Flags;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.MessageUid;
import org.apache.james.mailbox.events.Event;
import org.apache.james.mailbox.events.EventBus;
@@ -144,8 +144,8 @@ public class ListeningCurrentQuotaUpdaterTest {
public void mailboxDeletionEventShouldDecreaseCurrentQuotaValues() throws Exception {
MailboxListener.MailboxDeletion deletion = mock(MailboxListener.MailboxDeletion.class);
when(deletion.getQuotaRoot()).thenReturn(QUOTA_ROOT);
- when(deletion.getDeletedMessageCount()).thenReturn(QuotaCount.count(10));
- when(deletion.getTotalDeletedSize()).thenReturn(QuotaSize.size(5));
+ when(deletion.getDeletedMessageCount()).thenReturn(QuotaCountUsage.count(10));
+ when(deletion.getTotalDeletedSize()).thenReturn(QuotaSizeUsage.size(5));
when(deletion.getMailboxId()).thenReturn(MAILBOX_ID);
when(deletion.getUsername()).thenReturn(USERNAME_BENWA);
when(mockedQuotaRootResolver.getQuotaRoot(eq(MAILBOX_ID))).thenReturn(QUOTA_ROOT);
@@ -159,8 +159,8 @@ public class ListeningCurrentQuotaUpdaterTest {
public void mailboxDeletionEventShouldDoNothingWhenEmptyMailbox() throws Exception {
MailboxListener.MailboxDeletion deletion = mock(MailboxListener.MailboxDeletion.class);
when(deletion.getQuotaRoot()).thenReturn(QUOTA_ROOT);
- when(deletion.getDeletedMessageCount()).thenReturn(QuotaCount.count(0));
- when(deletion.getTotalDeletedSize()).thenReturn(QuotaSize.size(0));
+ when(deletion.getDeletedMessageCount()).thenReturn(QuotaCountUsage.count(0));
+ when(deletion.getTotalDeletedSize()).thenReturn(QuotaSizeUsage.size(0));
when(deletion.getMailboxId()).thenReturn(MAILBOX_ID);
when(deletion.getUsername()).thenReturn(USERNAME_BENWA);
when(mockedQuotaRootResolver.getQuotaRoot(eq(MAILBOX_ID))).thenReturn(QUOTA_ROOT);
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java
index 81ca0d6..3d23b11 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java
@@ -26,8 +26,10 @@ import static org.mockito.Mockito.when;
import java.util.Optional;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.exception.OverQuotaException;
import org.apache.james.mailbox.model.Mailbox;
@@ -58,9 +60,9 @@ public class QuotaCheckerTest {
public void quotaCheckerShouldNotThrowOnRegularQuotas() throws MailboxException {
when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT);
when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaCount>builder().used(QuotaCount.count(10)).computedLimit(QuotaCount.count(100)).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(10)).computedLimit(QuotaCountLimit.count(100)).build());
when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(100)).computedLimit(QuotaSize.size(1000)).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(100)).computedLimit(QuotaSizeLimit.size(1000)).build());
QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
quotaChecker.tryAddition(0, 0);
@@ -70,9 +72,9 @@ public class QuotaCheckerTest {
public void quotaCheckerShouldNotThrowOnRegularModifiedQuotas() throws MailboxException {
when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT);
when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaCount>builder().used(QuotaCount.count(10)).computedLimit(QuotaCount.count(100)).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(10)).computedLimit(QuotaCountLimit.count(100)).build());
when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(100)).computedLimit(QuotaSize.size(1000)).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(100)).computedLimit(QuotaSizeLimit.size(1000)).build());
QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
quotaChecker.tryAddition(89, 899);
@@ -82,9 +84,9 @@ public class QuotaCheckerTest {
public void quotaCheckerShouldNotThrowOnReachedMaximumQuotas() throws MailboxException {
when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT);
when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaCount>builder().used(QuotaCount.count(10)).computedLimit(QuotaCount.count(100)).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(10)).computedLimit(QuotaCountLimit.count(100)).build());
when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(100)).computedLimit(QuotaSize.size(1000)).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(100)).computedLimit(QuotaSizeLimit.size(1000)).build());
QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
quotaChecker.tryAddition(90, 900);
@@ -94,9 +96,9 @@ public class QuotaCheckerTest {
public void quotaCheckerShouldThrowOnExceededMessages() throws MailboxException {
when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT);
when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaCount>builder().used(QuotaCount.count(10)).computedLimit(QuotaCount.count(100)).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(10)).computedLimit(QuotaCountLimit.count(100)).build());
when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(100)).computedLimit(QuotaSize.size(1000)).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(100)).computedLimit(QuotaSizeLimit.size(1000)).build());
QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
assertThatThrownBy(() -> quotaChecker.tryAddition(91, 899))
@@ -107,9 +109,9 @@ public class QuotaCheckerTest {
public void quotaCheckerShouldThrowOnExceededStorage() throws MailboxException {
when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT);
when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaCount>builder().used(QuotaCount.count(10)).computedLimit(QuotaCount.count(100)).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(10)).computedLimit(QuotaCountLimit.count(100)).build());
when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(
- Quota.<QuotaSize>builder().used(QuotaSize.size(100)).computedLimit(QuotaSize.size(1000)).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(100)).computedLimit(QuotaSizeLimit.size(1000)).build());
QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX);
assertThatThrownBy(() -> quotaChecker.tryAddition(89, 901))
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java
index b80322f..f6614ff 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java
@@ -24,8 +24,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.QuotaRoot;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -44,15 +44,15 @@ public abstract class StoreCurrentQuotaManagerTest {
@Test
void getCurrentStorageShouldReturnZeroByDefault() throws Exception {
- assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(0));
+ assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSizeUsage.size(0));
}
@Test
void increaseShouldWork() throws Exception {
testee.increase(QUOTA_ROOT, 10, 100);
- assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(10));
- assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(100));
+ assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCountUsage.count(10));
+ assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSizeUsage.size(100));
}
@Test
@@ -61,16 +61,16 @@ public abstract class StoreCurrentQuotaManagerTest {
testee.decrease(QUOTA_ROOT, 10, 100);
- assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(10));
- assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(100));
+ assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCountUsage.count(10));
+ assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSizeUsage.size(100));
}
@Test
void decreaseShouldNotFailWhenItLeadsToNegativeValues() throws Exception {
testee.decrease(QUOTA_ROOT, 10, 100);
- assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(-10));
- assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(-100));
+ assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCountUsage.count(-10));
+ assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSizeUsage.size(-100));
}
@Test
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreQuotaManagerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreQuotaManagerTest.java
index 2fde29d..6e735df 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreQuotaManagerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreQuotaManagerTest.java
@@ -27,8 +27,10 @@ import static org.mockito.Mockito.when;
import java.util.Map;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.CurrentQuotaManager;
@@ -54,39 +56,39 @@ public class StoreQuotaManagerTest {
@SuppressWarnings("unchecked")
@Test
public void getMessageQuotaShouldWorkWithNumericValues() throws Exception {
- when(mockedMaxQuotaManager.getMaxMessage(any(Map.class))).thenReturn(Optional.of(QuotaCount.count(360L)));
- when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(QuotaCount.count(36L));
+ when(mockedMaxQuotaManager.getMaxMessage(any(Map.class))).thenReturn(Optional.of(QuotaCountLimit.count(360L)));
+ when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(QuotaCountUsage.count(36L));
assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(
- Quota.<QuotaCount>builder().used(QuotaCount.count(36)).computedLimit(QuotaCount.count(360)).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(36)).computedLimit(QuotaCountLimit.count(360)).build());
}
@SuppressWarnings("unchecked")
@Test
public void getStorageQuotaShouldWorkWithNumericValues() throws Exception {
- when(mockedMaxQuotaManager.getMaxStorage(any(Map.class))).thenReturn(Optional.of(QuotaSize.size(360L)));
- when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(QuotaSize.size(36L));
+ when(mockedMaxQuotaManager.getMaxStorage(any(Map.class))).thenReturn(Optional.of(QuotaSizeLimit.size(360L)));
+ when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(QuotaSizeUsage.size(36L));
assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(
- Quota.<QuotaSize>builder().used(QuotaSize.size(36)).computedLimit(QuotaSize.size(360)).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(36)).computedLimit(QuotaSizeLimit.size(360)).build());
}
@SuppressWarnings("unchecked")
@Test
public void getStorageQuotaShouldCalculateCurrentQuotaWhenUnlimited() throws Exception {
- when(mockedMaxQuotaManager.getMaxStorage(any(Map.class))).thenReturn(Optional.of(QuotaSize.unlimited()));
- when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(QuotaSize.size(36L));
+ when(mockedMaxQuotaManager.getMaxStorage(any(Map.class))).thenReturn(Optional.of(QuotaSizeLimit.unlimited()));
+ when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(QuotaSizeUsage.size(36L));
assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(
- Quota.<QuotaSize>builder().used(QuotaSize.size(36)).computedLimit(QuotaSize.unlimited()).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(36)).computedLimit(QuotaSizeLimit.unlimited()).build());
}
@SuppressWarnings("unchecked")
@Test
public void getMessageQuotaShouldCalculateCurrentQuotaWhenUnlimited() throws Exception {
- when(mockedMaxQuotaManager.getMaxMessage(any(Map.class))).thenReturn(Optional.of(QuotaCount.unlimited()));
- when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(QuotaCount.count(36L));
+ when(mockedMaxQuotaManager.getMaxMessage(any(Map.class))).thenReturn(Optional.of(QuotaCountLimit.unlimited()));
+ when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(QuotaCountUsage.count(36L));
assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(
- Quota.<QuotaCount>builder().used(QuotaCount.count(36)).computedLimit(QuotaCount.unlimited()).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(36)).computedLimit(QuotaCountLimit.unlimited()).build());
}
}
diff --git a/mpt/core/src/main/java/org/apache/james/mpt/api/ImapHostSystem.java b/mpt/core/src/main/java/org/apache/james/mpt/api/ImapHostSystem.java
index 2f6482f..44980e5 100644
--- a/mpt/core/src/main/java/org/apache/james/mpt/api/ImapHostSystem.java
+++ b/mpt/core/src/main/java/org/apache/james/mpt/api/ImapHostSystem.java
@@ -19,8 +19,8 @@
package org.apache.james.mpt.api;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.MailboxACL;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mpt.api.ImapFeatures.Feature;
@@ -31,7 +31,7 @@ public interface ImapHostSystem extends HostSystem {
void createMailbox(MailboxPath mailboxPath) throws Exception;
- void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception;
+ void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) throws Exception;
void grantRights(MailboxPath mailboxPath, Username userName, MailboxACL.Rfc4314Rights rights) throws Exception;
}
\ No newline at end of file
diff --git a/mpt/core/src/main/java/org/apache/james/mpt/host/ExternalHostSystem.java b/mpt/core/src/main/java/org/apache/james/mpt/host/ExternalHostSystem.java
index 0b4e6fe..dbc1b13 100644
--- a/mpt/core/src/main/java/org/apache/james/mpt/host/ExternalHostSystem.java
+++ b/mpt/core/src/main/java/org/apache/james/mpt/host/ExternalHostSystem.java
@@ -21,8 +21,8 @@ package org.apache.james.mpt.host;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.MailboxACL;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mpt.api.ImapFeatures;
@@ -118,7 +118,7 @@ public class ExternalHostSystem extends ExternalSessionFactory implements ImapHo
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) throws Exception {
throw new NotImplementedException("Not implemented");
}
diff --git a/mpt/impl/imap-mailbox/cassandra/src/test/java/org/apache/james/mpt/imapmailbox/cassandra/host/CassandraHostSystem.java b/mpt/impl/imap-mailbox/cassandra/src/test/java/org/apache/james/mpt/imapmailbox/cassandra/host/CassandraHostSystem.java
index bee7d68..a4b2155 100644
--- a/mpt/impl/imap-mailbox/cassandra/src/test/java/org/apache/james/mpt/imapmailbox/cassandra/host/CassandraHostSystem.java
+++ b/mpt/impl/imap-mailbox/cassandra/src/test/java/org/apache/james/mpt/imapmailbox/cassandra/host/CassandraHostSystem.java
@@ -19,8 +19,8 @@
package org.apache.james.mpt.imapmailbox.cassandra.host;
import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.imap.encode.main.DefaultImapEncoderFactory;
import org.apache.james.imap.main.DefaultImapDecoderFactory;
import org.apache.james.imap.processor.main.DefaultImapProcessorFactory;
@@ -136,7 +136,7 @@ public class CassandraHostSystem extends JamesImapHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) {
perUserMaxQuotaManager.setGlobalMaxMessage(maxMessageQuota);
perUserMaxQuotaManager.setGlobalMaxStorage(maxStorageQuota);
}
diff --git a/mpt/impl/imap-mailbox/core/src/main/java/org/apache/james/mpt/imapmailbox/suite/QuotaTest.java b/mpt/impl/imap-mailbox/core/src/main/java/org/apache/james/mpt/imapmailbox/suite/QuotaTest.java
index 87603fe..c827b48 100644
--- a/mpt/impl/imap-mailbox/core/src/main/java/org/apache/james/mpt/imapmailbox/suite/QuotaTest.java
+++ b/mpt/impl/imap-mailbox/core/src/main/java/org/apache/james/mpt/imapmailbox/suite/QuotaTest.java
@@ -21,8 +21,8 @@ package org.apache.james.mpt.imapmailbox.suite;
import java.util.Locale;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mpt.api.ImapFeatures;
import org.apache.james.mpt.api.ImapHostSystem;
import org.apache.james.mpt.imapmailbox.ImapTestConstants;
@@ -34,8 +34,8 @@ import org.junit.Test;
public abstract class QuotaTest implements ImapTestConstants {
- private static final QuotaCount MAX_MESSAGE_QUOTA = QuotaCount.count(4096);
- private static final QuotaSize MAX_STORAGE_QUOTA = QuotaSize.size(5 * 1024L * 1024L * 1024L);
+ private static final QuotaCountLimit MAX_MESSAGE_QUOTA = QuotaCountLimit.count(4096);
+ private static final QuotaSizeLimit MAX_STORAGE_QUOTA = QuotaSizeLimit.size(5 * 1024L * 1024L * 1024L);
protected abstract ImapHostSystem createImapHostSystem();
diff --git a/mpt/impl/imap-mailbox/cyrus/src/test/java/org/apache/james/mpt/imapmailbox/cyrus/host/CyrusHostSystem.java b/mpt/impl/imap-mailbox/cyrus/src/test/java/org/apache/james/mpt/imapmailbox/cyrus/host/CyrusHostSystem.java
index c644e30..5572dcb 100644
--- a/mpt/impl/imap-mailbox/cyrus/src/test/java/org/apache/james/mpt/imapmailbox/cyrus/host/CyrusHostSystem.java
+++ b/mpt/impl/imap-mailbox/cyrus/src/test/java/org/apache/james/mpt/imapmailbox/cyrus/host/CyrusHostSystem.java
@@ -23,8 +23,8 @@ import java.util.function.Supplier;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mpt.api.ImapFeatures;
import org.apache.james.mpt.api.ImapFeatures.Feature;
@@ -135,7 +135,7 @@ public class CyrusHostSystem extends ExternalHostSystem implements Provider<Cont
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) throws Exception {
throw new NotImplementedException("not implemented");
}
}
diff --git a/mpt/impl/imap-mailbox/elasticsearch/src/test/java/org/apache/james/mpt/imapmailbox/elasticsearch/host/ElasticSearchHostSystem.java b/mpt/impl/imap-mailbox/elasticsearch/src/test/java/org/apache/james/mpt/imapmailbox/elasticsearch/host/ElasticSearchHostSystem.java
index b84bc80..38e1d5c 100644
--- a/mpt/impl/imap-mailbox/elasticsearch/src/test/java/org/apache/james/mpt/imapmailbox/elasticsearch/host/ElasticSearchHostSystem.java
+++ b/mpt/impl/imap-mailbox/elasticsearch/src/test/java/org/apache/james/mpt/imapmailbox/elasticsearch/host/ElasticSearchHostSystem.java
@@ -27,8 +27,8 @@ import org.apache.james.backends.es.DockerElasticSearch;
import org.apache.james.backends.es.DockerElasticSearchSingleton;
import org.apache.james.backends.es.ElasticSearchConfiguration;
import org.apache.james.backends.es.ElasticSearchIndexer;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.imap.api.process.ImapProcessor;
import org.apache.james.imap.encode.main.DefaultImapEncoderFactory;
import org.apache.james.imap.main.DefaultImapDecoderFactory;
@@ -133,7 +133,7 @@ public class ElasticSearchHostSystem extends JamesImapHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) {
throw new NotImplementedException("not implemented");
}
diff --git a/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/external/ExternalJamesImapHostSystem.java b/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/external/ExternalJamesImapHostSystem.java
index 10c6bf9..db8a5d7 100644
--- a/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/external/ExternalJamesImapHostSystem.java
+++ b/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/external/ExternalJamesImapHostSystem.java
@@ -23,8 +23,8 @@ import java.util.function.Supplier;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mpt.api.ImapFeatures;
import org.apache.james.mpt.api.ImapFeatures.Feature;
@@ -74,7 +74,7 @@ public class ExternalJamesImapHostSystem extends ExternalHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) throws Exception {
throw new NotImplementedException("Not implemented");
}
diff --git a/mpt/impl/imap-mailbox/inmemory/src/test/java/org/apache/james/mpt/imapmailbox/inmemory/host/InMemoryHostSystem.java b/mpt/impl/imap-mailbox/inmemory/src/test/java/org/apache/james/mpt/imapmailbox/inmemory/host/InMemoryHostSystem.java
index 3dcd5b6..d327eae 100644
--- a/mpt/impl/imap-mailbox/inmemory/src/test/java/org/apache/james/mpt/imapmailbox/inmemory/host/InMemoryHostSystem.java
+++ b/mpt/impl/imap-mailbox/inmemory/src/test/java/org/apache/james/mpt/imapmailbox/inmemory/host/InMemoryHostSystem.java
@@ -20,8 +20,8 @@
package org.apache.james.mpt.imapmailbox.inmemory.host;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.imap.api.process.ImapProcessor;
import org.apache.james.imap.encode.main.DefaultImapEncoderFactory;
import org.apache.james.imap.main.DefaultImapDecoderFactory;
@@ -83,7 +83,7 @@ public class InMemoryHostSystem extends JamesImapHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) {
perUserMaxQuotaManager.setGlobalMaxMessage(maxMessageQuota);
perUserMaxQuotaManager.setGlobalMaxStorage(maxStorageQuota);
}
diff --git a/mpt/impl/imap-mailbox/jpa/src/test/java/org/apache/james/mpt/imapmailbox/jpa/host/JPAHostSystem.java b/mpt/impl/imap-mailbox/jpa/src/test/java/org/apache/james/mpt/imapmailbox/jpa/host/JPAHostSystem.java
index 80541b4..9c57525 100644
--- a/mpt/impl/imap-mailbox/jpa/src/test/java/org/apache/james/mpt/imapmailbox/jpa/host/JPAHostSystem.java
+++ b/mpt/impl/imap-mailbox/jpa/src/test/java/org/apache/james/mpt/imapmailbox/jpa/host/JPAHostSystem.java
@@ -22,8 +22,8 @@ package org.apache.james.mpt.imapmailbox.jpa.host;
import javax.persistence.EntityManagerFactory;
import org.apache.james.backends.jpa.JpaTestCluster;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.imap.api.process.ImapProcessor;
import org.apache.james.imap.encode.main.DefaultImapEncoderFactory;
import org.apache.james.imap.main.DefaultImapDecoderFactory;
@@ -156,7 +156,7 @@ public class JPAHostSystem extends JamesImapHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) {
maxQuotaManager.setGlobalMaxMessage(maxMessageQuota);
maxQuotaManager.setGlobalMaxStorage(maxStorageQuota);
}
diff --git a/mpt/impl/imap-mailbox/lucenesearch/src/test/java/org/apache/james/mpt/imapmailbox/lucenesearch/host/LuceneSearchHostSystem.java b/mpt/impl/imap-mailbox/lucenesearch/src/test/java/org/apache/james/mpt/imapmailbox/lucenesearch/host/LuceneSearchHostSystem.java
index 62df73f..a197599 100644
--- a/mpt/impl/imap-mailbox/lucenesearch/src/test/java/org/apache/james/mpt/imapmailbox/lucenesearch/host/LuceneSearchHostSystem.java
+++ b/mpt/impl/imap-mailbox/lucenesearch/src/test/java/org/apache/james/mpt/imapmailbox/lucenesearch/host/LuceneSearchHostSystem.java
@@ -20,8 +20,8 @@
package org.apache.james.mpt.imapmailbox.lucenesearch.host;
import org.apache.commons.lang3.NotImplementedException;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.imap.api.process.ImapProcessor;
import org.apache.james.imap.encode.main.DefaultImapEncoderFactory;
import org.apache.james.imap.main.DefaultImapDecoderFactory;
@@ -102,7 +102,7 @@ public class LuceneSearchHostSystem extends JamesImapHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) {
throw new NotImplementedException("not implemented");
}
diff --git a/mpt/impl/imap-mailbox/maildir/src/test/java/org/apache/james/mpt/imapmailbox/maildir/host/MaildirHostSystem.java b/mpt/impl/imap-mailbox/maildir/src/test/java/org/apache/james/mpt/imapmailbox/maildir/host/MaildirHostSystem.java
index d97a8f6..7ac5da9 100644
--- a/mpt/impl/imap-mailbox/maildir/src/test/java/org/apache/james/mpt/imapmailbox/maildir/host/MaildirHostSystem.java
+++ b/mpt/impl/imap-mailbox/maildir/src/test/java/org/apache/james/mpt/imapmailbox/maildir/host/MaildirHostSystem.java
@@ -22,8 +22,8 @@ import java.io.File;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.NotImplementedException;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.imap.api.process.ImapProcessor;
import org.apache.james.imap.encode.main.DefaultImapEncoderFactory;
import org.apache.james.imap.main.DefaultImapDecoderFactory;
@@ -132,7 +132,7 @@ public class MaildirHostSystem extends JamesImapHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) {
throw new NotImplementedException("not implemented");
}
diff --git a/mpt/impl/imap-mailbox/rabbitmq/src/test/java/org/apache/james/mpt/imapmailbox/rabbitmq/host/RabbitMQEventBusHostSystem.java b/mpt/impl/imap-mailbox/rabbitmq/src/test/java/org/apache/james/mpt/imapmailbox/rabbitmq/host/RabbitMQEventBusHostSystem.java
index 25c3635..3c72917 100644
--- a/mpt/impl/imap-mailbox/rabbitmq/src/test/java/org/apache/james/mpt/imapmailbox/rabbitmq/host/RabbitMQEventBusHostSystem.java
+++ b/mpt/impl/imap-mailbox/rabbitmq/src/test/java/org/apache/james/mpt/imapmailbox/rabbitmq/host/RabbitMQEventBusHostSystem.java
@@ -25,8 +25,8 @@ import java.util.concurrent.TimeUnit;
import org.apache.james.backends.rabbitmq.DockerRabbitMQ;
import org.apache.james.backends.rabbitmq.ReactorRabbitMQChannelPool;
import org.apache.james.backends.rabbitmq.SimpleConnectionPool;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.event.json.EventSerializer;
import org.apache.james.imap.api.process.ImapProcessor;
import org.apache.james.imap.encode.main.DefaultImapEncoderFactory;
@@ -131,7 +131,7 @@ public class RabbitMQEventBusHostSystem extends JamesImapHostSystem {
}
@Override
- public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) {
+ public void setQuotaLimits(QuotaCountLimit maxMessageQuota, QuotaSizeLimit maxStorageQuota) {
resources.getMaxQuotaManager().setGlobalMaxMessage(maxMessageQuota);
resources.getMaxQuotaManager().setGlobalMaxStorage(maxStorageQuota);
}
diff --git a/mpt/impl/managesieve/core/src/main/java/org/apache/james/mpt/host/JamesManageSieveHostSystem.java b/mpt/impl/managesieve/core/src/main/java/org/apache/james/mpt/host/JamesManageSieveHostSystem.java
index 202fa0c..b8f747a 100644
--- a/mpt/impl/managesieve/core/src/main/java/org/apache/james/mpt/host/JamesManageSieveHostSystem.java
+++ b/mpt/impl/managesieve/core/src/main/java/org/apache/james/mpt/host/JamesManageSieveHostSystem.java
@@ -20,7 +20,7 @@
package org.apache.james.mpt.host;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.managesieve.core.CoreProcessor;
import org.apache.james.managesieve.jsieve.Parser;
import org.apache.james.managesieve.transcode.ArgumentParser;
@@ -60,7 +60,7 @@ public abstract class JamesManageSieveHostSystem implements ManageSieveHostSyste
@Override
public void setMaxQuota(String user, long value) throws Exception {
- sieveRepository.setQuota(Username.of(user), QuotaSize.size(value));
+ sieveRepository.setQuota(Username.of(user), QuotaSizeLimit.size(value));
}
@Override
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/encode/QuotaResponseEncoder.java b/protocols/imap/src/main/java/org/apache/james/imap/encode/QuotaResponseEncoder.java
index 9cdaa2f..a803ec7 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/encode/QuotaResponseEncoder.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/encode/QuotaResponseEncoder.java
@@ -44,7 +44,7 @@ public class QuotaResponseEncoder extends AbstractChainedImapEncoder {
QuotaResponse quotaResponse = (QuotaResponse) acceptableMessage;
String quotaRoot = quotaResponse.getQuotaRoot();
- Quota<?> quota = quotaResponse.getQuota();
+ Quota<?, ?> quota = quotaResponse.getQuota();
composer.untagged();
composer.commandName(ImapConstants.QUOTA_RESPONSE_NAME);
@@ -66,12 +66,12 @@ public class QuotaResponseEncoder extends AbstractChainedImapEncoder {
composer.end();
}
- private void writeMessagesSize(ImapResponseComposer composer, Quota<?> quota) throws IOException {
+ private void writeMessagesSize(ImapResponseComposer composer, Quota<?, ?> quota) throws IOException {
composer.message(quota.getUsed().asLong() / 1024);
composer.message(quota.getLimit().asLong() / 1024);
}
- private void writeMessagesCount(ImapResponseComposer composer, Quota<?> quota) throws IOException {
+ private void writeMessagesCount(ImapResponseComposer composer, Quota<?, ?> quota) throws IOException {
composer.message(quota.getUsed().asLong());
composer.message(quota.getLimit().asLong());
}
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/message/response/QuotaResponse.java b/protocols/imap/src/main/java/org/apache/james/imap/message/response/QuotaResponse.java
index 07b3c7a..1cace6b 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/message/response/QuotaResponse.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/message/response/QuotaResponse.java
@@ -31,15 +31,15 @@ import com.google.common.base.Objects;
public class QuotaResponse implements ImapResponseMessage {
private final String resourceName;
private final String quotaRoot;
- private final Quota<?> quota;
+ private final Quota<?, ?> quota;
- public QuotaResponse(String resource, String quotaRoot, Quota<?> quota) {
+ public QuotaResponse(String resource, String quotaRoot, Quota<?, ?> quota) {
this.quota = quota;
this.resourceName = resource;
this.quotaRoot = quotaRoot;
}
- public Quota<?> getQuota() {
+ public Quota<?, ?> getQuota() {
return quota;
}
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java
index 6dba743..3b86940 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java
@@ -22,8 +22,10 @@ package org.apache.james.imap.processor;
import java.io.Closeable;
import java.util.List;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.imap.api.ImapConstants;
import org.apache.james.imap.api.ImapSessionUtils;
import org.apache.james.imap.api.display.HumanReadableText;
@@ -73,8 +75,8 @@ public class GetQuotaProcessor extends AbstractMailboxProcessor<GetQuotaRequest>
try {
QuotaRoot quotaRoot = quotaRootResolver.fromString(request.getQuotaRoot());
if (hasRight(quotaRoot, session)) {
- Quota<QuotaCount> messageQuota = quotaManager.getMessageQuota(quotaRoot);
- Quota<QuotaSize> storageQuota = quotaManager.getStorageQuota(quotaRoot);
+ Quota<QuotaCountLimit, QuotaCountUsage> messageQuota = quotaManager.getMessageQuota(quotaRoot);
+ Quota<QuotaSizeLimit, QuotaSizeUsage> storageQuota = quotaManager.getStorageQuota(quotaRoot);
if (messageQuota.getLimit().isLimited()) {
responder.respond(new QuotaResponse(ImapConstants.MESSAGE_QUOTA_RESOURCE, quotaRoot.getValue(), messageQuota));
}
diff --git a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java
index 2674736..8d70dcc 100644
--- a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java
+++ b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java
@@ -22,8 +22,10 @@ package org.apache.james.imap.processor;
import java.io.Closeable;
import java.util.List;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.imap.api.ImapConstants;
import org.apache.james.imap.api.ImapSessionUtils;
import org.apache.james.imap.api.display.HumanReadableText;
@@ -80,8 +82,8 @@ public class GetQuotaRootProcessor extends AbstractMailboxProcessor<GetQuotaRoot
try {
if (mailboxManager.hasRight(mailboxPath, MailboxACL.Right.Read, mailboxSession)) {
QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(mailboxPath);
- Quota<QuotaCount> messageQuota = quotaManager.getMessageQuota(quotaRoot);
- Quota<QuotaSize> storageQuota = quotaManager.getStorageQuota(quotaRoot);
+ Quota<QuotaCountLimit, QuotaCountUsage> messageQuota = quotaManager.getMessageQuota(quotaRoot);
+ Quota<QuotaSizeLimit, QuotaSizeUsage> storageQuota = quotaManager.getStorageQuota(quotaRoot);
responder.respond(new QuotaRootResponse(request.getMailboxName(), quotaRoot.getValue()));
if (messageQuota.getLimit().isLimited()) {
responder.respond(new QuotaResponse(ImapConstants.MESSAGE_QUOTA_RESOURCE, quotaRoot.getValue(), messageQuota));
diff --git a/protocols/imap/src/test/java/org/apache/james/imap/encode/QuotaResponseEncoderTest.java b/protocols/imap/src/test/java/org/apache/james/imap/encode/QuotaResponseEncoderTest.java
index d4ff764..a4518c5 100644
--- a/protocols/imap/src/test/java/org/apache/james/imap/encode/QuotaResponseEncoderTest.java
+++ b/protocols/imap/src/test/java/org/apache/james/imap/encode/QuotaResponseEncoderTest.java
@@ -21,8 +21,10 @@ package org.apache.james.imap.encode;
import static org.assertj.core.api.Assertions.assertThat;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.imap.encode.base.ByteImapResponseWriter;
import org.apache.james.imap.encode.base.EndImapEncoder;
import org.apache.james.imap.encode.base.ImapResponseComposerImpl;
@@ -38,7 +40,7 @@ public class QuotaResponseEncoderTest {
@Test
public void quotaMessageResponseShouldBeWellFormatted() throws Exception {
QuotaResponse response = new QuotaResponse("MESSAGE", "root",
- Quota.<QuotaCount>builder().used(QuotaCount.count(231)).computedLimit(QuotaCount.count(1024)).build());
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(231)).computedLimit(QuotaCountLimit.count(1024)).build());
ByteImapResponseWriter byteImapResponseWriter = new ByteImapResponseWriter();
ImapResponseComposer composer = new ImapResponseComposerImpl(byteImapResponseWriter, 1024);
QuotaResponseEncoder encoder = new QuotaResponseEncoder(new EndImapEncoder());
@@ -50,7 +52,7 @@ public class QuotaResponseEncoderTest {
@Test
public void quotaStorageResponseShouldBeWellFormatted() throws Exception {
QuotaResponse response = new QuotaResponse("STORAGE", "root",
- Quota.<QuotaSize>builder().used(QuotaSize.size(231 * 1024)).computedLimit(QuotaSize.size(1024 * 1024)).build());
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(231 * 1024)).computedLimit(QuotaSizeLimit.size(1024 * 1024)).build());
ByteImapResponseWriter byteImapResponseWriter = new ByteImapResponseWriter();
ImapResponseComposer composer = new ImapResponseComposerImpl(byteImapResponseWriter, 1024);
QuotaResponseEncoder encoder = new QuotaResponseEncoder(new EndImapEncoder());
diff --git a/protocols/imap/src/test/java/org/apache/james/imap/message/response/QuotaResponseTest.java b/protocols/imap/src/test/java/org/apache/james/imap/message/response/QuotaResponseTest.java
index cd3ffda..e70ae80 100644
--- a/protocols/imap/src/test/java/org/apache/james/imap/message/response/QuotaResponseTest.java
+++ b/protocols/imap/src/test/java/org/apache/james/imap/message/response/QuotaResponseTest.java
@@ -19,7 +19,8 @@
package org.apache.james.imap.message.response;
-import org.apache.james.core.quota.QuotaCount;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
import org.apache.james.mailbox.model.Quota;
import org.junit.Test;
@@ -28,13 +29,13 @@ import nl.jqno.equalsverifier.EqualsVerifier;
public class QuotaResponseTest {
@Test
public void shouldMatchBeanContract() {
- Quota<QuotaCount> red = Quota.<QuotaCount>builder()
- .computedLimit(QuotaCount.count(36))
- .used(QuotaCount.count(22))
+ Quota<QuotaCountLimit, QuotaCountUsage> red = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .computedLimit(QuotaCountLimit.count(36))
+ .used(QuotaCountUsage.count(22))
.build();
- Quota<QuotaCount> black = Quota.<QuotaCount>builder()
- .computedLimit(QuotaCount.count(32))
- .used(QuotaCount.count(24))
+ Quota<QuotaCountLimit, QuotaCountUsage> black = Quota.<QuotaCountLimit, QuotaCountUsage>builder()
+ .computedLimit(QuotaCountLimit.count(32))
+ .used(QuotaCountUsage.count(24))
.build();
EqualsVerifier.forClass(QuotaResponse.class)
diff --git a/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaProcessorTest.java b/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaProcessorTest.java
index 46ff00c..7f18494 100644
--- a/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaProcessorTest.java
+++ b/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaProcessorTest.java
@@ -31,8 +31,10 @@ import static org.mockito.Mockito.when;
import java.util.Optional;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.imap.api.ImapCommand;
import org.apache.james.imap.api.ImapSessionState;
import org.apache.james.imap.api.ImapSessionUtils;
@@ -65,10 +67,10 @@ public class GetQuotaProcessorTest {
private static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("plop", Optional.empty());
private static final Username PLOP = Username.of("plop");
private static final MailboxPath MAILBOX_PATH = new MailboxPath("namespace", PLOP, "INBOX");
- private static final Quota<QuotaCount> MESSAGE_QUOTA =
- Quota.<QuotaCount>builder().used(QuotaCount.count(24)).computedLimit(QuotaCount.count(1589)).build();
- private static final Quota<QuotaSize> STORAGE_QUOTA =
- Quota.<QuotaSize>builder().used(QuotaSize.size(240)).computedLimit(QuotaSize.size(15890)).build();
+ private static final Quota<QuotaCountLimit, QuotaCountUsage> MESSAGE_QUOTA =
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(24)).computedLimit(QuotaCountLimit.count(1589)).build();
+ private static final Quota<QuotaSizeLimit, QuotaSizeUsage> STORAGE_QUOTA =
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(240)).computedLimit(QuotaSizeLimit.size(15890)).build();
private GetQuotaProcessor testee;
private ImapSession mockedImapSession;
diff --git a/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaRootProcessorTest.java b/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaRootProcessorTest.java
index 4ac151d..726799f 100644
--- a/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaRootProcessorTest.java
+++ b/protocols/imap/src/test/java/org/apache/james/imap/processor/GetQuotaRootProcessorTest.java
@@ -32,8 +32,10 @@ import java.util.List;
import java.util.Optional;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.imap.api.ImapCommand;
import org.apache.james.imap.api.ImapSessionState;
import org.apache.james.imap.api.ImapSessionUtils;
@@ -65,10 +67,10 @@ public class GetQuotaRootProcessorTest {
private static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("plop", Optional.empty());
private static final Username PLOP = Username.of("plop");
private static final MailboxPath MAILBOX_PATH = MailboxPath.forUser(PLOP, "INBOX");
- private static final Quota<QuotaCount> MESSAGE_QUOTA =
- Quota.<QuotaCount>builder().used(QuotaCount.count(24)).computedLimit(QuotaCount.count(1589)).build();
- private static final Quota<QuotaSize> STORAGE_QUOTA =
- Quota.<QuotaSize>builder().used(QuotaSize.size(240)).computedLimit(QuotaSize.size(15890)).build();
+ private static final Quota<QuotaCountLimit, QuotaCountUsage> MESSAGE_QUOTA =
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(24)).computedLimit(QuotaCountLimit.count(1589)).build();
+ private static final Quota<QuotaSizeLimit, QuotaSizeUsage> STORAGE_QUOTA =
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(240)).computedLimit(QuotaSizeLimit.size(15890)).build();
private GetQuotaRootProcessor testee;
private ImapSession mockedImapSession;
diff --git a/server/container/cli/src/main/java/org/apache/james/cli/ServerCmd.java b/server/container/cli/src/main/java/org/apache/james/cli/ServerCmd.java
index e1e9864..ffceb09 100644
--- a/server/container/cli/src/main/java/org/apache/james/cli/ServerCmd.java
+++ b/server/container/cli/src/main/java/org/apache/james/cli/ServerCmd.java
@@ -44,11 +44,13 @@ import org.apache.james.cli.probe.impl.JmxMailboxProbe;
import org.apache.james.cli.probe.impl.JmxQuotaProbe;
import org.apache.james.cli.probe.impl.JmxSieveProbe;
import org.apache.james.cli.type.CmdType;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.SerializableQuota;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.MailboxProbe;
import org.apache.james.mailbox.probe.QuotaProbe;
import org.apache.james.probe.DataProbe;
@@ -339,21 +341,21 @@ public class ServerCmd {
}
}
- private SerializableQuotaValue<QuotaSize> parseQuotaSize(String argument) throws Exception {
+ private SerializableQuotaLimitValue<QuotaSizeLimit> parseQuotaSize(String argument) throws Exception {
long convertedValue = Size.parse(argument).asBytes();
- return longToSerializableQuotaValue(convertedValue, QuotaSize.unlimited(), QuotaSize::size);
+ return longToSerializableQuotaValue(convertedValue, QuotaSizeLimit.unlimited(), QuotaSizeLimit::size);
}
- private SerializableQuotaValue<QuotaCount> parseQuotaCount(String argument) {
+ private SerializableQuotaLimitValue<QuotaCountLimit> parseQuotaCount(String argument) {
long value = Long.parseLong(argument);
- return longToSerializableQuotaValue(value, QuotaCount.unlimited(), QuotaCount::count);
+ return longToSerializableQuotaValue(value, QuotaCountLimit.unlimited(), QuotaCountLimit::count);
}
- private <T extends QuotaValue<T>> SerializableQuotaValue<T> longToSerializableQuotaValue(long value, T unlimited, Function<Long, T> factory) {
- return SerializableQuotaValue.valueOf(Optional.of(longToQuotaValue(value, unlimited, factory)));
+ private <T extends QuotaLimitValue<T>> SerializableQuotaLimitValue<T> longToSerializableQuotaValue(long value, T unlimited, Function<Long, T> factory) {
+ return SerializableQuotaLimitValue.valueOf(Optional.of(longToQuotaValue(value, unlimited, factory)));
}
- private <T extends QuotaValue<T>> T longToQuotaValue(long value, T unlimited, Function<Long, T> factory) {
+ private <T extends QuotaLimitValue<T>> T longToQuotaValue(long value, T unlimited, Function<Long, T> factory) {
if (value == -1) {
return unlimited;
}
@@ -385,14 +387,14 @@ public class ServerCmd {
footerBuilder.toString());
}
- private void printStorageQuota(String quotaRootString, SerializableQuota<QuotaSize> quota, PrintStream printStream) {
+ private void printStorageQuota(String quotaRootString, SerializableQuota<QuotaSizeLimit, QuotaSizeUsage> quota, PrintStream printStream) {
printStream.println(String.format("Storage quota for %s is: %s / %s",
quotaRootString,
formatStorageValue(quota.getUsed()),
formatStorageValue(quota.encodeAsLong())));
}
- private void printMessageQuota(String quotaRootString, SerializableQuota<QuotaCount> quota, PrintStream printStream) {
+ private void printMessageQuota(String quotaRootString, SerializableQuota<QuotaCountLimit, QuotaCountUsage> quota, PrintStream printStream) {
printStream.println(String.format("MailboxMessage count quota for %s is: %s / %s",
quotaRootString,
formatMessageValue(quota.getUsed()),
@@ -409,9 +411,9 @@ public class ServerCmd {
return SizeFormat.format(value);
}
- private String formatStorageValue(SerializableQuotaValue<QuotaSize> value) {
+ private String formatStorageValue(SerializableQuotaLimitValue<QuotaSizeLimit> value) {
return value
- .toValue(QuotaSize::size, QuotaSize.unlimited())
+ .toValue(QuotaSizeLimit::size, QuotaSizeLimit.unlimited())
.map(size -> {
if (size.isUnlimited()) {
return Size.UNLIMITED;
@@ -430,9 +432,9 @@ public class ServerCmd {
return String.valueOf(value);
}
- private String formatMessageValue(SerializableQuotaValue<QuotaCount> value) {
+ private String formatMessageValue(SerializableQuotaLimitValue<QuotaCountLimit> value) {
return value
- .toValue(QuotaCount::count, QuotaCount.unlimited())
+ .toValue(QuotaCountLimit::count, QuotaCountLimit.unlimited())
.map(count -> {
if (count.isUnlimited()) {
return Size.UNLIMITED;
diff --git a/server/container/cli/src/main/java/org/apache/james/cli/probe/impl/JmxQuotaProbe.java b/server/container/cli/src/main/java/org/apache/james/cli/probe/impl/JmxQuotaProbe.java
index 53c11c5..6f73f3a 100644
--- a/server/container/cli/src/main/java/org/apache/james/cli/probe/impl/JmxQuotaProbe.java
+++ b/server/container/cli/src/main/java/org/apache/james/cli/probe/impl/JmxQuotaProbe.java
@@ -24,11 +24,13 @@ import java.io.IOException;
import javax.management.MalformedObjectNameException;
import org.apache.james.adapter.mailbox.QuotaManagementMBean;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.SerializableQuota;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.QuotaProbe;
public class JmxQuotaProbe implements QuotaProbe, JmxProbe {
@@ -52,52 +54,52 @@ public class JmxQuotaProbe implements QuotaProbe, JmxProbe {
}
@Override
- public SerializableQuota<QuotaCount> getMessageCountQuota(String quotaRoot) throws MailboxException {
+ public SerializableQuota<QuotaCountLimit, QuotaCountUsage> getMessageCountQuota(String quotaRoot) throws MailboxException {
return quotaManagement.getMessageCountQuota(quotaRoot);
}
@Override
- public SerializableQuota<QuotaSize> getStorageQuota(String quotaRoot) throws MailboxException {
+ public SerializableQuota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(String quotaRoot) throws MailboxException {
return quotaManagement.getStorageQuota(quotaRoot);
}
@Override
- public SerializableQuotaValue<QuotaCount> getMaxMessageCount(String quotaRoot) throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaCountLimit> getMaxMessageCount(String quotaRoot) throws MailboxException {
return quotaManagement.getMaxMessageCount(quotaRoot);
}
@Override
- public SerializableQuotaValue<QuotaSize> getMaxStorage(String quotaRoot) throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaSizeLimit> getMaxStorage(String quotaRoot) throws MailboxException {
return quotaManagement.getMaxStorage(quotaRoot);
}
@Override
- public SerializableQuotaValue<QuotaCount> getGlobalMaxMessageCount() throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaCountLimit> getGlobalMaxMessageCount() throws MailboxException {
return quotaManagement.getGlobalMaxMessageCount();
}
@Override
- public SerializableQuotaValue<QuotaSize> getGlobalMaxStorage() throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaSizeLimit> getGlobalMaxStorage() throws MailboxException {
return quotaManagement.getGlobalMaxStorage();
}
@Override
- public void setMaxMessageCount(String quotaRoot, SerializableQuotaValue<QuotaCount> maxMessageCount) throws MailboxException {
+ public void setMaxMessageCount(String quotaRoot, SerializableQuotaLimitValue<QuotaCountLimit> maxMessageCount) throws MailboxException {
quotaManagement.setMaxMessageCount(quotaRoot, maxMessageCount);
}
@Override
- public void setMaxStorage(String quotaRoot, SerializableQuotaValue<QuotaSize> maxSize) throws MailboxException {
+ public void setMaxStorage(String quotaRoot, SerializableQuotaLimitValue<QuotaSizeLimit> maxSize) throws MailboxException {
quotaManagement.setMaxStorage(quotaRoot, maxSize);
}
@Override
- public void setGlobalMaxMessageCount(SerializableQuotaValue<QuotaCount> maxGlobalMessageCount) throws MailboxException {
+ public void setGlobalMaxMessageCount(SerializableQuotaLimitValue<QuotaCountLimit> maxGlobalMessageCount) throws MailboxException {
quotaManagement.setGlobalMaxMessageCount(maxGlobalMessageCount);
}
@Override
- public void setGlobalMaxStorage(SerializableQuotaValue<QuotaSize> maxGlobalSize) throws MailboxException {
+ public void setGlobalMaxStorage(SerializableQuotaLimitValue<QuotaSizeLimit> maxGlobalSize) throws MailboxException {
quotaManagement.setGlobalMaxStorage(maxGlobalSize);
}
diff --git a/server/container/cli/src/test/java/org/apache/james/cli/ServerCmdTest.java b/server/container/cli/src/test/java/org/apache/james/cli/ServerCmdTest.java
index f3542f5..ce70e3b 100644
--- a/server/container/cli/src/test/java/org/apache/james/cli/ServerCmdTest.java
+++ b/server/container/cli/src/test/java/org/apache/james/cli/ServerCmdTest.java
@@ -34,11 +34,13 @@ import org.apache.james.cli.exceptions.InvalidArgumentNumberException;
import org.apache.james.cli.exceptions.MissingCommandException;
import org.apache.james.cli.exceptions.UnrecognizedCommandException;
import org.apache.james.cli.type.CmdType;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.model.SerializableQuota;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.MailboxProbe;
import org.apache.james.mailbox.probe.QuotaProbe;
import org.apache.james.probe.DataProbe;
@@ -324,7 +326,7 @@ public class ServerCmdTest {
String[] arguments = { "-h", "127.0.0.1", "-p", "9999", CmdType.GETGLOBALMAXMESSAGECOUNTQUOTA.getCommand()};
CommandLine commandLine = ServerCmd.parseCommandLine(arguments);
- when(quotaProbe.getGlobalMaxMessageCount()).thenReturn(new SerializableQuotaValue<>(QuotaCount.count(1024L * 1024L)));
+ when(quotaProbe.getGlobalMaxMessageCount()).thenReturn(new SerializableQuotaLimitValue<>(QuotaCountLimit.count(1024L * 1024L)));
testee.executeCommandLine(commandLine);
}
@@ -334,7 +336,7 @@ public class ServerCmdTest {
String[] arguments = { "-h", "127.0.0.1", "-p", "9999", CmdType.GETGLOBALMAXSTORAGEQUOTA.getCommand()};
CommandLine commandLine = ServerCmd.parseCommandLine(arguments);
- when(quotaProbe.getGlobalMaxStorage()).thenReturn(new SerializableQuotaValue<>(QuotaSize.size(1024L * 1024L * 1024L)));
+ when(quotaProbe.getGlobalMaxStorage()).thenReturn(new SerializableQuotaLimitValue<>(QuotaSizeLimit.size(1024L * 1024L * 1024L)));
testee.executeCommandLine(commandLine);
}
@@ -346,7 +348,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setGlobalMaxMessageCount(new SerializableQuotaValue<>(QuotaCount.count(1054)));
+ verify(quotaProbe).setGlobalMaxMessageCount(new SerializableQuotaLimitValue<>(QuotaCountLimit.count(1054)));
}
@Test
@@ -356,7 +358,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setGlobalMaxMessageCount(new SerializableQuotaValue<>(QuotaCount.unlimited()));
+ verify(quotaProbe).setGlobalMaxMessageCount(new SerializableQuotaLimitValue<>(QuotaCountLimit.unlimited()));
}
@Test
@@ -375,7 +377,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setGlobalMaxStorage(new SerializableQuotaValue<>(QuotaSize.size(1024 * 1024 * 1024)));
+ verify(quotaProbe).setGlobalMaxStorage(new SerializableQuotaLimitValue<>(QuotaSizeLimit.size(1024 * 1024 * 1024)));
}
@Test
@@ -385,7 +387,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setGlobalMaxStorage(new SerializableQuotaValue<>(QuotaSize.unlimited()));
+ verify(quotaProbe).setGlobalMaxStorage(new SerializableQuotaLimitValue<>(QuotaSizeLimit.unlimited()));
}
@Test
@@ -405,7 +407,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setMaxMessageCount(quotaroot, new SerializableQuotaValue<>(QuotaCount.count(1000)));
+ verify(quotaProbe).setMaxMessageCount(quotaroot, new SerializableQuotaLimitValue<>(QuotaCountLimit.count(1000)));
}
@Test
@@ -416,7 +418,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setMaxMessageCount(quotaroot, new SerializableQuotaValue<>(QuotaCount.unlimited()));
+ verify(quotaProbe).setMaxMessageCount(quotaroot, new SerializableQuotaLimitValue<>(QuotaCountLimit.unlimited()));
}
@Test
@@ -437,7 +439,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setMaxStorage(quotaroot, new SerializableQuotaValue<>(QuotaSize.size(5 * 1024 * 1024)));
+ verify(quotaProbe).setMaxStorage(quotaroot, new SerializableQuotaLimitValue<>(QuotaSizeLimit.size(5 * 1024 * 1024)));
}
@Test
@@ -448,7 +450,7 @@ public class ServerCmdTest {
testee.executeCommandLine(commandLine);
- verify(quotaProbe).setMaxStorage(quotaroot, new SerializableQuotaValue<>(QuotaSize.unlimited()));
+ verify(quotaProbe).setMaxStorage(quotaroot, new SerializableQuotaLimitValue<>(QuotaSizeLimit.unlimited()));
}
@Test
@@ -467,7 +469,7 @@ public class ServerCmdTest {
String[] arguments = { "-h", "127.0.0.1", "-p", "9999", CmdType.GETMAXMESSAGECOUNTQUOTA.getCommand(), quotaroot};
CommandLine commandLine = ServerCmd.parseCommandLine(arguments);
- when(quotaProbe.getMaxMessageCount(quotaroot)).thenReturn(new SerializableQuotaValue<>(QuotaCount.unlimited()));
+ when(quotaProbe.getMaxMessageCount(quotaroot)).thenReturn(new SerializableQuotaLimitValue<>(QuotaCountLimit.unlimited()));
testee.executeCommandLine(commandLine);
}
@@ -478,7 +480,7 @@ public class ServerCmdTest {
String[] arguments = { "-h", "127.0.0.1", "-p", "9999", CmdType.GETMAXSTORAGEQUOTA.getCommand(), quotaroot};
CommandLine commandLine = ServerCmd.parseCommandLine(arguments);
- when(quotaProbe.getMaxStorage(quotaroot)).thenReturn(new SerializableQuotaValue<>(QuotaSize.unlimited()));
+ when(quotaProbe.getMaxStorage(quotaroot)).thenReturn(new SerializableQuotaLimitValue<>(QuotaSizeLimit.unlimited()));
testee.executeCommandLine(commandLine);
}
@@ -489,7 +491,7 @@ public class ServerCmdTest {
String[] arguments = { "-h", "127.0.0.1", "-p", "9999", CmdType.GETSTORAGEQUOTA.getCommand(), quotaroot};
CommandLine commandLine = ServerCmd.parseCommandLine(arguments);
- when(quotaProbe.getStorageQuota(quotaroot)).thenReturn(SerializableQuota.newInstance(QuotaSize.unlimited(), QuotaSize.size(12)));
+ when(quotaProbe.getStorageQuota(quotaroot)).thenReturn(SerializableQuota.newInstance(QuotaSizeUsage.unlimited(), QuotaSizeLimit.size(12)));
testee.executeCommandLine(commandLine);
}
@@ -500,7 +502,7 @@ public class ServerCmdTest {
String[] arguments = { "-h", "127.0.0.1", "-p", "9999", CmdType.GETMESSAGECOUNTQUOTA.getCommand(), quotaroot};
CommandLine commandLine = ServerCmd.parseCommandLine(arguments);
- when(quotaProbe.getMessageCountQuota(quotaroot)).thenReturn(SerializableQuota.newInstance(QuotaCount.unlimited(), QuotaCount.count(12)));
+ when(quotaProbe.getMessageCountQuota(quotaroot)).thenReturn(SerializableQuota.newInstance(QuotaCountUsage.unlimited(), QuotaCountLimit.count(12)));
testee.executeCommandLine(commandLine);
}
diff --git a/server/container/guice/jpa-guice/src/test/java/org/apache/james/JPAJamesServerTest.java b/server/container/guice/jpa-guice/src/test/java/org/apache/james/JPAJamesServerTest.java
index 7efb399..08edc58 100644
--- a/server/container/guice/jpa-guice/src/test/java/org/apache/james/JPAJamesServerTest.java
+++ b/server/container/guice/jpa-guice/src/test/java/org/apache/james/JPAJamesServerTest.java
@@ -21,8 +21,8 @@ package org.apache.james;
import static org.assertj.core.api.Assertions.assertThat;
-import org.apache.james.core.quota.QuotaSize;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.modules.QuotaProbesImpl;
import org.apache.james.modules.protocols.ImapGuiceProbe;
import org.apache.james.modules.protocols.SmtpGuiceProbe;
@@ -70,7 +70,7 @@ class JPAJamesServerTest implements JamesServerContract {
.fluent()
.addDomain(DOMAIN)
.addUser(USER, PASSWORD);
- jamesServer.getProbe(QuotaProbesImpl.class).setGlobalMaxStorage(new SerializableQuotaValue<>(QuotaSize.size(50 * 1024)));
+ jamesServer.getProbe(QuotaProbesImpl.class).setGlobalMaxStorage(new SerializableQuotaLimitValue<>(QuotaSizeLimit.size(50 * 1024)));
// ~ 12 KB email
int imapPort = jamesServer.getProbe(ImapGuiceProbe.class).getImapPort();
diff --git a/server/container/guice/mailbox/src/main/java/org/apache/james/modules/QuotaProbesImpl.java b/server/container/guice/mailbox/src/main/java/org/apache/james/modules/QuotaProbesImpl.java
index 5b66e67..6b163e6 100644
--- a/server/container/guice/mailbox/src/main/java/org/apache/james/modules/QuotaProbesImpl.java
+++ b/server/container/guice/mailbox/src/main/java/org/apache/james/modules/QuotaProbesImpl.java
@@ -22,12 +22,14 @@ package org.apache.james.modules;
import javax.inject.Inject;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mailbox.model.SerializableQuota;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.QuotaProbe;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.mailbox.quota.QuotaManager;
@@ -55,62 +57,62 @@ public class QuotaProbesImpl implements QuotaProbe, GuiceProbe {
}
@Override
- public SerializableQuota<QuotaCount> getMessageCountQuota(String quotaRoot) throws MailboxException {
+ public SerializableQuota<QuotaCountLimit, QuotaCountUsage> getMessageCountQuota(String quotaRoot) throws MailboxException {
return SerializableQuota.newInstance(quotaManager.getMessageQuota(quotaRootResolver.fromString(quotaRoot)));
}
@Override
- public SerializableQuota<QuotaSize> getStorageQuota(String quotaRoot) throws MailboxException {
+ public SerializableQuota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(String quotaRoot) throws MailboxException {
return SerializableQuota.newInstance(quotaManager.getStorageQuota(quotaRootResolver.fromString(quotaRoot)));
}
@Override
- public SerializableQuotaValue<QuotaCount> getMaxMessageCount(String quotaRoot) throws MailboxException {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getMaxMessage(quotaRootResolver.fromString(quotaRoot)));
+ public SerializableQuotaLimitValue<QuotaCountLimit> getMaxMessageCount(String quotaRoot) throws MailboxException {
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getMaxMessage(quotaRootResolver.fromString(quotaRoot)));
}
@Override
- public SerializableQuotaValue<QuotaSize> getMaxStorage(String quotaRoot) throws MailboxException {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getMaxStorage(quotaRootResolver.fromString(quotaRoot)));
+ public SerializableQuotaLimitValue<QuotaSizeLimit> getMaxStorage(String quotaRoot) throws MailboxException {
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getMaxStorage(quotaRootResolver.fromString(quotaRoot)));
}
@Override
- public SerializableQuotaValue<QuotaCount> getGlobalMaxMessageCount() throws MailboxException {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getGlobalMaxMessage());
+ public SerializableQuotaLimitValue<QuotaCountLimit> getGlobalMaxMessageCount() throws MailboxException {
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getGlobalMaxMessage());
}
@Override
- public SerializableQuotaValue<QuotaSize> getGlobalMaxStorage() throws MailboxException {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getGlobalMaxStorage());
+ public SerializableQuotaLimitValue<QuotaSizeLimit> getGlobalMaxStorage() throws MailboxException {
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getGlobalMaxStorage());
}
@Override
- public void setMaxMessageCount(String quotaRoot, SerializableQuotaValue<QuotaCount> maxMessageCount) throws MailboxException {
- maxMessageCount.toValue(QuotaCount::count, QuotaCount.unlimited())
+ public void setMaxMessageCount(String quotaRoot, SerializableQuotaLimitValue<QuotaCountLimit> maxMessageCount) throws MailboxException {
+ maxMessageCount.toValue(QuotaCountLimit::count, QuotaCountLimit.unlimited())
.ifPresent(
Throwing.consumer(
- (QuotaCount value) -> maxQuotaManager.setMaxMessage(quotaRootResolver.fromString(quotaRoot), value))
+ (QuotaCountLimit value) -> maxQuotaManager.setMaxMessage(quotaRootResolver.fromString(quotaRoot), value))
.sneakyThrow());
}
@Override
- public void setMaxStorage(String quotaRoot, SerializableQuotaValue<QuotaSize> maxSize) throws MailboxException {
- maxSize.toValue(QuotaSize::size, QuotaSize.unlimited())
+ public void setMaxStorage(String quotaRoot, SerializableQuotaLimitValue<QuotaSizeLimit> maxSize) throws MailboxException {
+ maxSize.toValue(QuotaSizeLimit::size, QuotaSizeLimit.unlimited())
.ifPresent(
Throwing.consumer(
- (QuotaSize value) -> maxQuotaManager.setMaxStorage(quotaRootResolver.fromString(quotaRoot), value))
+ (QuotaSizeLimit value) -> maxQuotaManager.setMaxStorage(quotaRootResolver.fromString(quotaRoot), value))
.sneakyThrow());
}
@Override
- public void setGlobalMaxMessageCount(SerializableQuotaValue<QuotaCount> maxGlobalMessageCount) throws MailboxException {
- maxGlobalMessageCount.toValue(QuotaCount::count, QuotaCount.unlimited())
+ public void setGlobalMaxMessageCount(SerializableQuotaLimitValue<QuotaCountLimit> maxGlobalMessageCount) throws MailboxException {
+ maxGlobalMessageCount.toValue(QuotaCountLimit::count, QuotaCountLimit.unlimited())
.ifPresent(Throwing.consumer(maxQuotaManager::setGlobalMaxMessage).sneakyThrow());
}
@Override
- public void setGlobalMaxStorage(SerializableQuotaValue<QuotaSize> maxGlobalSize) throws MailboxException {
- maxGlobalSize.toValue(QuotaSize::size, QuotaSize.unlimited())
+ public void setGlobalMaxStorage(SerializableQuotaLimitValue<QuotaSizeLimit> maxGlobalSize) throws MailboxException {
+ maxGlobalSize.toValue(QuotaSizeLimit::size, QuotaSizeLimit.unlimited())
.ifPresent(Throwing.consumer(maxQuotaManager::setGlobalMaxStorage).sneakyThrow());
}
}
diff --git a/server/container/guice/protocols/managedsieve/src/main/java/org/apache/james/modules/protocols/SieveProbeImpl.java b/server/container/guice/protocols/managedsieve/src/main/java/org/apache/james/modules/protocols/SieveProbeImpl.java
index a1929ef..9a46442 100644
--- a/server/container/guice/protocols/managedsieve/src/main/java/org/apache/james/modules/protocols/SieveProbeImpl.java
+++ b/server/container/guice/protocols/managedsieve/src/main/java/org/apache/james/modules/protocols/SieveProbeImpl.java
@@ -25,7 +25,7 @@ import javax.inject.Inject;
import org.apache.commons.io.IOUtils;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.probe.SieveProbe;
import org.apache.james.sieverepository.api.ScriptContent;
import org.apache.james.sieverepository.api.ScriptName;
@@ -49,7 +49,7 @@ public class SieveProbeImpl implements GuiceProbe, SieveProbe {
@Override
public void setSieveQuota(long quota) throws Exception {
- sieveRepository.setDefaultQuota(QuotaSize.size(quota));
+ sieveRepository.setDefaultQuota(QuotaSizeLimit.size(quota));
}
@Override
@@ -64,7 +64,7 @@ public class SieveProbeImpl implements GuiceProbe, SieveProbe {
@Override
public void setSieveQuota(String user, long quota) throws Exception {
- sieveRepository.setQuota(Username.of(user), QuotaSize.size(quota));
+ sieveRepository.setQuota(Username.of(user), QuotaSizeLimit.size(quota));
}
@Override
diff --git a/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagement.java b/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagement.java
index c0ff902..564b45b 100644
--- a/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagement.java
+++ b/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagement.java
@@ -25,12 +25,14 @@ import java.io.IOException;
import javax.inject.Inject;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mailbox.model.SerializableQuota;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.mailbox.quota.QuotaManager;
import org.apache.james.mailbox.quota.QuotaRootResolver;
@@ -65,67 +67,67 @@ public class QuotaManagement implements QuotaManagementMBean {
}
@Override
- public SerializableQuotaValue<QuotaCount> getMaxMessageCount(String quotaRoot) throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaCountLimit> getMaxMessageCount(String quotaRoot) throws MailboxException {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "getMaxMessageCount")
.build()) {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getMaxMessage(quotaRootResolver.fromString(quotaRoot)));
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getMaxMessage(quotaRootResolver.fromString(quotaRoot)));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
- public SerializableQuotaValue<QuotaSize> getMaxStorage(String quotaRoot) throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaSizeLimit> getMaxStorage(String quotaRoot) throws MailboxException {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "getMaxStorage")
.build()) {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getMaxStorage(quotaRootResolver.fromString(quotaRoot)));
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getMaxStorage(quotaRootResolver.fromString(quotaRoot)));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
- public SerializableQuotaValue<QuotaCount> getGlobalMaxMessageCount() throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaCountLimit> getGlobalMaxMessageCount() throws MailboxException {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "getGlobalMaxMessageCount")
.build()) {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getGlobalMaxMessage());
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getGlobalMaxMessage());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
- public SerializableQuotaValue<QuotaSize> getGlobalMaxStorage() throws MailboxException {
+ public SerializableQuotaLimitValue<QuotaSizeLimit> getGlobalMaxStorage() throws MailboxException {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "getGlobalMaxStorage")
.build()) {
- return SerializableQuotaValue.valueOf(maxQuotaManager.getGlobalMaxStorage());
+ return SerializableQuotaLimitValue.valueOf(maxQuotaManager.getGlobalMaxStorage());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
- public void setMaxMessageCount(String quotaRoot, SerializableQuotaValue<QuotaCount> maxMessageCount) {
+ public void setMaxMessageCount(String quotaRoot, SerializableQuotaLimitValue<QuotaCountLimit> maxMessageCount) {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "setMaxMessageCount")
.build()) {
- maxMessageCount.toValue(QuotaCount::count, QuotaCount.unlimited())
+ maxMessageCount.toValue(QuotaCountLimit::count, QuotaCountLimit.unlimited())
.ifPresent(
- Throwing.consumer((QuotaCount value) ->
+ Throwing.consumer((QuotaCountLimit value) ->
maxQuotaManager.setMaxMessage(quotaRootResolver.fromString(quotaRoot), value))
.sneakyThrow());
} catch (IOException e) {
@@ -134,15 +136,15 @@ public class QuotaManagement implements QuotaManagementMBean {
}
@Override
- public void setMaxStorage(String quotaRoot, SerializableQuotaValue<QuotaSize> maxSize) {
+ public void setMaxStorage(String quotaRoot, SerializableQuotaLimitValue<QuotaSizeLimit> maxSize) {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "setMaxStorage")
.build()) {
- maxSize.toValue(QuotaSize::size, QuotaSize.unlimited())
+ maxSize.toValue(QuotaSizeLimit::size, QuotaSizeLimit.unlimited())
.ifPresent(
- Throwing.consumer((QuotaSize value) ->
+ Throwing.consumer((QuotaSizeLimit value) ->
maxQuotaManager.setMaxStorage(quotaRootResolver.fromString(quotaRoot), value))
.sneakyThrow());
} catch (IOException e) {
@@ -151,14 +153,14 @@ public class QuotaManagement implements QuotaManagementMBean {
}
@Override
- public void setGlobalMaxMessageCount(SerializableQuotaValue<QuotaCount> maxGlobalMessageCount) {
+ public void setGlobalMaxMessageCount(SerializableQuotaLimitValue<QuotaCountLimit> maxGlobalMessageCount) {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "setGlobalMaxMessageCount")
.build()) {
maxGlobalMessageCount
- .toValue(QuotaCount::count, QuotaCount.unlimited())
+ .toValue(QuotaCountLimit::count, QuotaCountLimit.unlimited())
.ifPresent(Throwing.consumer(maxQuotaManager::setGlobalMaxMessage).sneakyThrow());
} catch (IOException e) {
throw new RuntimeException(e);
@@ -166,14 +168,14 @@ public class QuotaManagement implements QuotaManagementMBean {
}
@Override
- public void setGlobalMaxStorage(SerializableQuotaValue<QuotaSize> maxGlobalSize) {
+ public void setGlobalMaxStorage(SerializableQuotaLimitValue<QuotaSizeLimit> maxGlobalSize) {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
.addContext(MDCBuilder.ACTION, "setGlobalMaxStorage")
.build()) {
maxGlobalSize
- .toValue(QuotaSize::size, QuotaSize.unlimited())
+ .toValue(QuotaSizeLimit::size, QuotaSizeLimit.unlimited())
.ifPresent(Throwing.consumer(maxQuotaManager::setGlobalMaxStorage).sneakyThrow());
} catch (IOException e) {
throw new RuntimeException(e);
@@ -181,7 +183,7 @@ public class QuotaManagement implements QuotaManagementMBean {
}
@Override
- public SerializableQuota<QuotaCount> getMessageCountQuota(String quotaRoot) throws MailboxException {
+ public SerializableQuota<QuotaCountLimit, QuotaCountUsage> getMessageCountQuota(String quotaRoot) throws MailboxException {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
@@ -194,7 +196,7 @@ public class QuotaManagement implements QuotaManagementMBean {
}
@Override
- public SerializableQuota<QuotaSize> getStorageQuota(String quotaRoot) throws MailboxException {
+ public SerializableQuota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(String quotaRoot) throws MailboxException {
try (Closeable closeable =
MDCBuilder.create()
.addContext(MDCBuilder.PROTOCOL, "CLI")
diff --git a/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagementMBean.java b/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagementMBean.java
index 36ae9d1..2cc7914 100644
--- a/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagementMBean.java
+++ b/server/container/mailbox-jmx/src/main/java/org/apache/james/adapter/mailbox/QuotaManagementMBean.java
@@ -19,32 +19,34 @@
package org.apache.james.adapter.mailbox;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.SerializableQuota;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
public interface QuotaManagementMBean {
String getQuotaRoot(String namespace, String user, String name) throws MailboxException;
- SerializableQuota<QuotaCount> getMessageCountQuota(String quotaRoot) throws MailboxException;
+ SerializableQuota<QuotaCountLimit, QuotaCountUsage> getMessageCountQuota(String quotaRoot) throws MailboxException;
- SerializableQuota<QuotaSize> getStorageQuota(String quotaRoot) throws MailboxException;
+ SerializableQuota<QuotaSizeLimit, QuotaSizeUsage> getStorageQuota(String quotaRoot) throws MailboxException;
- SerializableQuotaValue<QuotaCount> getMaxMessageCount(String quotaRoot) throws MailboxException;
+ SerializableQuotaLimitValue<QuotaCountLimit> getMaxMessageCount(String quotaRoot) throws MailboxException;
- SerializableQuotaValue<QuotaSize> getMaxStorage(String quotaRoot) throws MailboxException;
+ SerializableQuotaLimitValue<QuotaSizeLimit> getMaxStorage(String quotaRoot) throws MailboxException;
- SerializableQuotaValue<QuotaCount> getGlobalMaxMessageCount() throws MailboxException;
+ SerializableQuotaLimitValue<QuotaCountLimit> getGlobalMaxMessageCount() throws MailboxException;
- SerializableQuotaValue<QuotaSize> getGlobalMaxStorage() throws MailboxException;
+ SerializableQuotaLimitValue<QuotaSizeLimit> getGlobalMaxStorage() throws MailboxException;
- void setMaxMessageCount(String quotaRoot, SerializableQuotaValue<QuotaCount> maxMessageCount) throws MailboxException;
+ void setMaxMessageCount(String quotaRoot, SerializableQuotaLimitValue<QuotaCountLimit> maxMessageCount) throws MailboxException;
- void setMaxStorage(String quotaRoot, SerializableQuotaValue<QuotaSize> maxSize) throws MailboxException;
+ void setMaxStorage(String quotaRoot, SerializableQuotaLimitValue<QuotaSizeLimit> maxSize) throws MailboxException;
- void setGlobalMaxMessageCount(SerializableQuotaValue<QuotaCount> maxGlobalMessageCount) throws MailboxException;
+ void setGlobalMaxMessageCount(SerializableQuotaLimitValue<QuotaCountLimit> maxGlobalMessageCount) throws MailboxException;
- void setGlobalMaxStorage(SerializableQuotaValue<QuotaSize> maxGlobalSize) throws MailboxException;
+ void setGlobalMaxStorage(SerializableQuotaLimitValue<QuotaSizeLimit> maxGlobalSize) throws MailboxException;
}
diff --git a/server/container/spring/src/main/java/org/apache/james/container/spring/mailbox/MaxQuotaConfigurationReader.java b/server/container/spring/src/main/java/org/apache/james/container/spring/mailbox/MaxQuotaConfigurationReader.java
index ac548f6..ca3c1da 100644
--- a/server/container/spring/src/main/java/org/apache/james/container/spring/mailbox/MaxQuotaConfigurationReader.java
+++ b/server/container/spring/src/main/java/org/apache/james/container/spring/mailbox/MaxQuotaConfigurationReader.java
@@ -26,8 +26,8 @@ import java.util.Map;
import org.apache.commons.configuration2.HierarchicalConfiguration;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.apache.commons.configuration2.tree.ImmutableNode;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.lifecycle.api.Configurable;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -69,19 +69,19 @@ public class MaxQuotaConfigurationReader implements Configurable {
private void configureGlobalValues(Long globalMaxMessage, Long globalMaxStorage) throws MailboxException {
if (globalMaxMessage != null) {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(globalMaxMessage));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(globalMaxMessage));
}
if (globalMaxStorage != null) {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(globalMaxStorage));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(globalMaxStorage));
}
}
private void configureQuotaRootSpecificValues(Map<String, Long> maxMessage, Map<String, Long> maxStorage) throws MailboxException {
for (Map.Entry<String, Long> entry : maxMessage.entrySet()) {
- maxQuotaManager.setMaxMessage(toQuotaRoot(entry.getKey()), QuotaCount.count(entry.getValue()));
+ maxQuotaManager.setMaxMessage(toQuotaRoot(entry.getKey()), QuotaCountLimit.count(entry.getValue()));
}
for (Map.Entry<String, Long> entry : maxStorage.entrySet()) {
- maxQuotaManager.setMaxStorage(toQuotaRoot(entry.getKey()), QuotaSize.size(entry.getValue()));
+ maxQuotaManager.setMaxStorage(toQuotaRoot(entry.getKey()), QuotaSizeLimit.size(entry.getValue()));
}
}
diff --git a/server/data/data-api/src/main/java/org/apache/james/sieverepository/api/SieveQuotaRepository.java b/server/data/data-api/src/main/java/org/apache/james/sieverepository/api/SieveQuotaRepository.java
index f712bcf..a2f316b 100644
--- a/server/data/data-api/src/main/java/org/apache/james/sieverepository/api/SieveQuotaRepository.java
+++ b/server/data/data-api/src/main/java/org/apache/james/sieverepository/api/SieveQuotaRepository.java
@@ -21,7 +21,7 @@
package org.apache.james.sieverepository.api;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieverepository.api.exception.QuotaNotFoundException;
import org.apache.james.sieverepository.api.exception.StorageException;
@@ -32,17 +32,17 @@ public interface SieveQuotaRepository {
boolean hasDefaultQuota() throws StorageException;
- QuotaSize getDefaultQuota() throws QuotaNotFoundException, StorageException;
+ QuotaSizeLimit getDefaultQuota() throws QuotaNotFoundException, StorageException;
- void setDefaultQuota(QuotaSize quota) throws StorageException;
+ void setDefaultQuota(QuotaSizeLimit quota) throws StorageException;
void removeQuota() throws QuotaNotFoundException, StorageException;
boolean hasQuota(Username username) throws StorageException;
- QuotaSize getQuota(Username username) throws QuotaNotFoundException, StorageException;
+ QuotaSizeLimit getQuota(Username username) throws QuotaNotFoundException, StorageException;
- void setQuota(Username username, QuotaSize quota) throws StorageException;
+ void setQuota(Username username, QuotaSizeLimit quota) throws StorageException;
void removeQuota(Username username) throws QuotaNotFoundException, StorageException;
}
diff --git a/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAO.java b/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAO.java
index d8b140e..54c3072 100644
--- a/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAO.java
+++ b/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAO.java
@@ -33,7 +33,7 @@ import javax.inject.Inject;
import org.apache.james.backends.cassandra.utils.CassandraAsyncExecutor;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieve.cassandra.tables.CassandraSieveClusterQuotaTable;
import org.apache.james.sieve.cassandra.tables.CassandraSieveQuotaTable;
import org.apache.james.sieve.cassandra.tables.CassandraSieveSpaceTable;
@@ -114,15 +114,15 @@ public class CassandraSieveQuotaDAO {
.setString(CassandraSieveSpaceTable.USER_NAME, username.asString()));
}
- public Mono<Optional<QuotaSize>> getQuota() {
+ public Mono<Optional<QuotaSizeLimit>> getQuota() {
return cassandraAsyncExecutor.executeSingleRowOptional(
selectClusterQuotaStatement.bind()
.setString(CassandraSieveClusterQuotaTable.NAME, CassandraSieveClusterQuotaTable.DEFAULT_NAME))
.map(optional -> optional.map(row ->
- QuotaSize.size(row.getLong(CassandraSieveClusterQuotaTable.VALUE))));
+ QuotaSizeLimit.size(row.getLong(CassandraSieveClusterQuotaTable.VALUE))));
}
- public Mono<Void> setQuota(QuotaSize quota) {
+ public Mono<Void> setQuota(QuotaSizeLimit quota) {
return cassandraAsyncExecutor.executeVoid(
updateClusterQuotaStatement.bind()
.setLong(CassandraSieveClusterQuotaTable.VALUE, quota.asLong())
@@ -135,15 +135,15 @@ public class CassandraSieveQuotaDAO {
.setString(CassandraSieveClusterQuotaTable.NAME, CassandraSieveClusterQuotaTable.DEFAULT_NAME));
}
- public Mono<Optional<QuotaSize>> getQuota(Username username) {
+ public Mono<Optional<QuotaSizeLimit>> getQuota(Username username) {
return cassandraAsyncExecutor.executeSingleRowOptional(
selectUserQuotaStatement.bind()
.setString(CassandraSieveQuotaTable.USER_NAME, username.asString()))
.map(optional -> optional.map(row ->
- QuotaSize.size(row.getLong(CassandraSieveQuotaTable.QUOTA))));
+ QuotaSizeLimit.size(row.getLong(CassandraSieveQuotaTable.QUOTA))));
}
- public Mono<Void> setQuota(Username username, QuotaSize quota) {
+ public Mono<Void> setQuota(Username username, QuotaSizeLimit quota) {
return cassandraAsyncExecutor.executeVoid(
updateUserQuotaStatement.bind()
.setLong(CassandraSieveQuotaTable.QUOTA, quota.asLong())
diff --git a/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveRepository.java b/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveRepository.java
index 7cbc029..cbb51b9 100644
--- a/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveRepository.java
+++ b/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/CassandraSieveRepository.java
@@ -30,7 +30,7 @@ import javax.inject.Inject;
import org.apache.commons.io.IOUtils;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieve.cassandra.model.ActiveScriptInfo;
import org.apache.james.sieve.cassandra.model.Script;
import org.apache.james.sieve.cassandra.model.SieveQuota;
@@ -80,15 +80,15 @@ public class CassandraSieveRepository implements SieveRepository {
}
private Mono<Void> throwOnOverQuota(Username username, Long sizeDifference) {
- Mono<Optional<QuotaSize>> userQuotaMono = cassandraSieveQuotaDAO.getQuota(username);
- Mono<Optional<QuotaSize>> globalQuotaMono = cassandraSieveQuotaDAO.getQuota();
+ Mono<Optional<QuotaSizeLimit>> userQuotaMono = cassandraSieveQuotaDAO.getQuota(username);
+ Mono<Optional<QuotaSizeLimit>> globalQuotaMono = cassandraSieveQuotaDAO.getQuota();
Mono<Long> spaceUsedMono = cassandraSieveQuotaDAO.spaceUsedBy(username);
return limitToUse(userQuotaMono, globalQuotaMono).zipWith(spaceUsedMono)
.flatMap(pair -> checkOverQuotaUponModification(sizeDifference, pair.getT2(), pair.getT1()));
}
- private Mono<Void> checkOverQuotaUponModification(Long sizeDifference, Long spaceUsed, Optional<QuotaSize> limit) {
+ private Mono<Void> checkOverQuotaUponModification(Long sizeDifference, Long spaceUsed, Optional<QuotaSizeLimit> limit) {
try {
new SieveQuota(spaceUsed, limit)
.checkOverQuotaUponModification(sizeDifference);
@@ -105,7 +105,7 @@ public class CassandraSieveRepository implements SieveRepository {
.map(sizeOfStoredScript -> scriptSize - sizeOfStoredScript);
}
- private Mono<Optional<QuotaSize>> limitToUse(Mono<Optional<QuotaSize>> userQuota, Mono<Optional<QuotaSize>> globalQuota) {
+ private Mono<Optional<QuotaSizeLimit>> limitToUse(Mono<Optional<QuotaSizeLimit>> userQuota, Mono<Optional<QuotaSizeLimit>> globalQuota) {
return userQuota
.filter(Optional::isPresent)
.switchIfEmpty(globalQuota);
@@ -253,14 +253,14 @@ public class CassandraSieveRepository implements SieveRepository {
}
@Override
- public QuotaSize getDefaultQuota() throws QuotaNotFoundException {
+ public QuotaSizeLimit getDefaultQuota() throws QuotaNotFoundException {
return cassandraSieveQuotaDAO.getQuota()
.block()
.orElseThrow(QuotaNotFoundException::new);
}
@Override
- public void setDefaultQuota(QuotaSize quota) {
+ public void setDefaultQuota(QuotaSizeLimit quota) {
cassandraSieveQuotaDAO.setQuota(quota).block();
}
@@ -279,14 +279,14 @@ public class CassandraSieveRepository implements SieveRepository {
}
@Override
- public QuotaSize getQuota(Username username) throws QuotaNotFoundException {
+ public QuotaSizeLimit getQuota(Username username) throws QuotaNotFoundException {
return cassandraSieveQuotaDAO.getQuota(username)
.block()
.orElseThrow(QuotaNotFoundException::new);
}
@Override
- public void setQuota(Username username, QuotaSize quota) {
+ public void setQuota(Username username, QuotaSizeLimit quota) {
cassandraSieveQuotaDAO.setQuota(username, quota).block();
}
diff --git a/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/model/SieveQuota.java b/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/model/SieveQuota.java
index 25cdff6..0c5f2c7 100644
--- a/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/model/SieveQuota.java
+++ b/server/data/data-cassandra/src/main/java/org/apache/james/sieve/cassandra/model/SieveQuota.java
@@ -22,7 +22,8 @@ package org.apache.james.sieve.cassandra.model;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.sieverepository.api.exception.QuotaExceededException;
import com.google.common.base.Preconditions;
@@ -30,9 +31,9 @@ import com.google.common.base.Preconditions;
public class SieveQuota {
private final long currentUsage;
- private final Optional<QuotaSize> limit;
+ private final Optional<QuotaSizeLimit> limit;
- public SieveQuota(long currentUsage, Optional<QuotaSize> limit) {
+ public SieveQuota(long currentUsage, Optional<QuotaSizeLimit> limit) {
Preconditions.checkArgument(currentUsage >= 0, "Current usage should be positive or equal to zero");
limit.ifPresent(limitValue -> Preconditions.checkArgument(limitValue.asLong() >= 0, "Limit value should be positive or equal to zero"));
this.currentUsage = currentUsage;
@@ -47,9 +48,9 @@ public class SieveQuota {
public boolean isExceededUponModification(long sizeDifference) {
return limit.map(limitContent ->
- QuotaSize.size(currentUsage)
+ QuotaSizeUsage.size(currentUsage)
.add(sizeDifference)
- .isGreaterThan(limitContent))
+ .exceedLimit(limitContent))
.orElse(false);
}
}
diff --git a/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAOTest.java b/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAOTest.java
index 895fa37..46d4469 100644
--- a/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAOTest.java
+++ b/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/CassandraSieveQuotaDAOTest.java
@@ -24,14 +24,14 @@ 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.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
class CassandraSieveQuotaDAOTest {
private static final Username USERNAME = Username.of("user");
- private static final QuotaSize QUOTA_SIZE = QuotaSize.size(15L);
+ private static final QuotaSizeLimit QUOTA_SIZE = QuotaSizeLimit.size(15L);
@RegisterExtension
static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(CassandraSieveRepositoryModule.MODULE);
diff --git a/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/model/SieveQuotaTest.java b/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/model/SieveQuotaTest.java
index 3ec44ce..213add4 100644
--- a/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/model/SieveQuotaTest.java
+++ b/server/data/data-cassandra/src/test/java/org/apache/james/sieve/cassandra/model/SieveQuotaTest.java
@@ -21,17 +21,17 @@ package org.apache.james.sieve.cassandra.model;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieverepository.api.exception.QuotaExceededException;
import org.junit.Test;
public class SieveQuotaTest {
public static final long INVALID_VALUE = -1L;
- public static final QuotaSize LIMIT_LOW_VALUE = QuotaSize.size(10L);
+ public static final QuotaSizeLimit LIMIT_LOW_VALUE = QuotaSizeLimit.size(10L);
public static final long SIZE_DIFFERENCE = 20L;
public static final int CURRENT_USAGE = 0;
- public static final QuotaSize LIMIT_HIGH_VALUE = QuotaSize.size(100L);
+ public static final QuotaSizeLimit LIMIT_HIGH_VALUE = QuotaSizeLimit.size(100L);
@Test(expected = IllegalArgumentException.class)
public void sieveQuotaShouldThrowOnNegativeCurrentValue() {
@@ -40,7 +40,7 @@ public class SieveQuotaTest {
@Test(expected = IllegalArgumentException.class)
public void sieveQuotaShouldThrowOnNegativeLimitValue() {
- new SieveQuota(0, Optional.of(QuotaSize.size(INVALID_VALUE)));
+ new SieveQuota(0, Optional.of(QuotaSizeLimit.size(INVALID_VALUE)));
}
@Test(expected = QuotaExceededException.class)
diff --git a/server/data/data-file/src/main/java/org/apache/james/sieverepository/file/SieveFileRepository.java b/server/data/data-file/src/main/java/org/apache/james/sieverepository/file/SieveFileRepository.java
index 9089cd3..7c67504 100644
--- a/server/data/data-file/src/main/java/org/apache/james/sieverepository/file/SieveFileRepository.java
+++ b/server/data/data-file/src/main/java/org/apache/james/sieverepository/file/SieveFileRepository.java
@@ -42,7 +42,7 @@ import javax.inject.Inject;
import org.apache.commons.io.FileUtils;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.filesystem.api.FileSystem;
import org.apache.james.sieverepository.api.ScriptContent;
import org.apache.james.sieverepository.api.ScriptName;
@@ -381,7 +381,7 @@ public class SieveFileRepository implements SieveRepository {
}
@Override
- public QuotaSize getDefaultQuota() throws QuotaNotFoundException, StorageException {
+ public QuotaSizeLimit getDefaultQuota() throws QuotaNotFoundException, StorageException {
Long quota = null;
File file = getQuotaFile();
if (file.exists()) {
@@ -394,7 +394,7 @@ public class SieveFileRepository implements SieveRepository {
if (null == quota) {
throw new QuotaNotFoundException("No default quota");
}
- return QuotaSize.size(quota);
+ return QuotaSizeLimit.size(quota);
}
@Override
@@ -411,7 +411,7 @@ public class SieveFileRepository implements SieveRepository {
}
@Override
- public synchronized void setDefaultQuota(QuotaSize quota) throws StorageException {
+ public synchronized void setDefaultQuota(QuotaSizeLimit quota) throws StorageException {
File file = getQuotaFile();
String content = Long.toString(quota.asLong());
toFile(file, content);
@@ -427,7 +427,7 @@ public class SieveFileRepository implements SieveRepository {
}
@Override
- public QuotaSize getQuota(Username username) throws QuotaNotFoundException, StorageException {
+ public QuotaSizeLimit getQuota(Username username) throws QuotaNotFoundException, StorageException {
Long quota = null;
File file = getQuotaFile(username);
if (file.exists()) {
@@ -440,7 +440,7 @@ public class SieveFileRepository implements SieveRepository {
if (null == quota) {
throw new QuotaNotFoundException("No quota for user: " + username.asString());
}
- return QuotaSize.size(quota);
+ return QuotaSizeLimit.size(quota);
}
@Override
@@ -459,7 +459,7 @@ public class SieveFileRepository implements SieveRepository {
}
@Override
- public void setQuota(Username username, QuotaSize quota) throws StorageException {
+ public void setQuota(Username username, QuotaSizeLimit quota) throws StorageException {
synchronized (lock) {
File file = getQuotaFile(username);
String content = Long.toString(quota.asLong());
diff --git a/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/JPASieveRepository.java b/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/JPASieveRepository.java
index c9bbb05..a293638 100644
--- a/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/JPASieveRepository.java
+++ b/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/JPASieveRepository.java
@@ -36,7 +36,8 @@ import javax.persistence.PersistenceException;
import org.apache.commons.io.IOUtils;
import org.apache.james.backends.jpa.TransactionRunner;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.sieve.jpa.model.JPASieveQuota;
import org.apache.james.sieve.jpa.model.JPASieveScript;
import org.apache.james.sieverepository.api.ScriptContent;
@@ -75,24 +76,24 @@ public class JPASieveRepository implements SieveRepository {
.mapToLong(JPASieveScript::getScriptSize)
.sum();
- QuotaSize quota = limitToUser(username);
+ QuotaSizeLimit quota = limitToUser(username);
if (overQuotaAfterModification(usedSpace, size, quota)) {
throw new QuotaExceededException();
}
}
- private QuotaSize limitToUser(Username username) throws StorageException {
+ private QuotaSizeLimit limitToUser(Username username) throws StorageException {
return OptionalUtils.orSuppliers(
Throwing.supplier(() -> findQuotaForUser(username.asString())).sneakyThrow(),
Throwing.supplier(() -> findQuotaForUser(DEFAULT_SIEVE_QUOTA_USERNAME)).sneakyThrow())
.map(JPASieveQuota::toQuotaSize)
- .orElse(QuotaSize.unlimited());
+ .orElse(QuotaSizeLimit.unlimited());
}
- private boolean overQuotaAfterModification(long usedSpace, long size, QuotaSize quota) {
- return QuotaSize.size(usedSpace)
+ private boolean overQuotaAfterModification(long usedSpace, long size, QuotaSizeLimit quota) {
+ return QuotaSizeUsage.size(usedSpace)
.add(size)
- .isGreaterThan(quota);
+ .exceedLimit(quota);
}
@Override
@@ -261,14 +262,14 @@ public class JPASieveRepository implements SieveRepository {
}
@Override
- public QuotaSize getDefaultQuota() throws QuotaNotFoundException, StorageException {
+ public QuotaSizeLimit getDefaultQuota() throws QuotaNotFoundException, StorageException {
JPASieveQuota jpaSieveQuota = findQuotaForUser(DEFAULT_SIEVE_QUOTA_USERNAME)
.orElseThrow(() -> new QuotaNotFoundException("Unable to find quota for default user"));
- return QuotaSize.size(jpaSieveQuota.getSize());
+ return QuotaSizeLimit.size(jpaSieveQuota.getSize());
}
@Override
- public void setDefaultQuota(QuotaSize quota) throws StorageException {
+ public void setDefaultQuota(QuotaSizeLimit quota) throws StorageException {
setQuotaForUser(DEFAULT_SIEVE_QUOTA_USERNAME, quota);
}
@@ -284,14 +285,14 @@ public class JPASieveRepository implements SieveRepository {
}
@Override
- public QuotaSize getQuota(Username username) throws QuotaNotFoundException, StorageException {
+ public QuotaSizeLimit getQuota(Username username) throws QuotaNotFoundException, StorageException {
JPASieveQuota jpaSieveQuota = findQuotaForUser(username.asString())
.orElseThrow(() -> new QuotaNotFoundException("Unable to find quota for user " + username.asString()));
- return QuotaSize.size(jpaSieveQuota.getSize());
+ return QuotaSizeLimit.size(jpaSieveQuota.getSize());
}
@Override
- public void setQuota(Username username, QuotaSize quota) throws StorageException {
+ public void setQuota(Username username, QuotaSizeLimit quota) throws StorageException {
setQuotaForUser(username.asString(), quota);
}
@@ -321,7 +322,7 @@ public class JPASieveRepository implements SieveRepository {
}
}
- private void setQuotaForUser(String username, QuotaSize quota) throws StorageException {
+ private void setQuotaForUser(String username, QuotaSizeLimit quota) throws StorageException {
transactionRunner.runAndHandleException(Throwing.consumer(entityManager -> {
Optional<JPASieveQuota> sieveQuota = findQuotaForUser(username, entityManager);
if (sieveQuota.isPresent()) {
diff --git a/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/model/JPASieveQuota.java b/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/model/JPASieveQuota.java
index 9c5e097..52485c1 100644
--- a/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/model/JPASieveQuota.java
+++ b/server/data/data-jpa/src/main/java/org/apache/james/sieve/jpa/model/JPASieveQuota.java
@@ -28,7 +28,7 @@ import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import com.google.common.base.MoreObjects;
@@ -62,12 +62,12 @@ public class JPASieveQuota {
return size;
}
- public void setSize(QuotaSize quotaSize) {
+ public void setSize(QuotaSizeLimit quotaSize) {
this.size = quotaSize.asLong();
}
- public QuotaSize toQuotaSize() {
- return QuotaSize.size(size);
+ public QuotaSizeLimit toQuotaSize() {
+ return QuotaSizeLimit.size(size);
}
@Override
diff --git a/server/data/data-library/src/main/java/org/apache/james/sieverepository/lib/SieveRepositoryManagement.java b/server/data/data-library/src/main/java/org/apache/james/sieverepository/lib/SieveRepositoryManagement.java
index 6765dee..8ff2832 100644
--- a/server/data/data-library/src/main/java/org/apache/james/sieverepository/lib/SieveRepositoryManagement.java
+++ b/server/data/data-library/src/main/java/org/apache/james/sieverepository/lib/SieveRepositoryManagement.java
@@ -31,7 +31,7 @@ import javax.management.StandardMBean;
import org.apache.commons.io.IOUtils;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieverepository.api.ScriptContent;
import org.apache.james.sieverepository.api.ScriptName;
import org.apache.james.sieverepository.api.SieveRepository;
@@ -61,7 +61,7 @@ public class SieveRepositoryManagement extends StandardMBean implements SieveRep
@Override
public void setQuota(long quota) throws SieveRepositoryException {
- sieveRepository.setDefaultQuota(QuotaSize.size(quota));
+ sieveRepository.setDefaultQuota(QuotaSizeLimit.size(quota));
}
@Override
@@ -76,7 +76,7 @@ public class SieveRepositoryManagement extends StandardMBean implements SieveRep
@Override
public void setQuota(String user, long quota) throws SieveRepositoryException {
- sieveRepository.setQuota(Username.of(user), QuotaSize.size(quota));
+ sieveRepository.setQuota(Username.of(user), QuotaSizeLimit.size(quota));
}
@Override
diff --git a/server/data/data-library/src/test/java/org/apache/james/sieverepository/lib/AbstractSieveRepositoryTest.java b/server/data/data-library/src/test/java/org/apache/james/sieverepository/lib/AbstractSieveRepositoryTest.java
index 5e5f3fe..3f76b5a 100644
--- a/server/data/data-library/src/test/java/org/apache/james/sieverepository/lib/AbstractSieveRepositoryTest.java
+++ b/server/data/data-library/src/test/java/org/apache/james/sieverepository/lib/AbstractSieveRepositoryTest.java
@@ -29,7 +29,7 @@ import java.time.ZonedDateTime;
import org.apache.commons.io.IOUtils;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieverepository.api.ScriptContent;
import org.apache.james.sieverepository.api.ScriptName;
import org.apache.james.sieverepository.api.ScriptSummary;
@@ -49,8 +49,8 @@ public abstract class AbstractSieveRepositoryTest {
private static final ScriptName OTHER_SCRIPT_NAME = new ScriptName("other_script");
private static final ScriptContent OTHER_SCRIPT_CONTENT = new ScriptContent("Other script content");
- private static final QuotaSize DEFAULT_QUOTA = QuotaSize.size(Long.MAX_VALUE - 1L);
- private static final QuotaSize USER_QUOTA = QuotaSize.size(Long.MAX_VALUE / 2);
+ private static final QuotaSizeLimit DEFAULT_QUOTA = QuotaSizeLimit.size(Long.MAX_VALUE - 1L);
+ private static final QuotaSizeLimit USER_QUOTA = QuotaSizeLimit.size(Long.MAX_VALUE / 2);
protected SieveRepository sieveRepository;
@@ -162,15 +162,15 @@ public abstract class AbstractSieveRepositoryTest {
@Test(expected = QuotaExceededException.class)
public void putScriptShouldThrowWhenScriptTooBig() throws Exception {
- sieveRepository.setDefaultQuota(QuotaSize.size(SCRIPT_CONTENT.length() - 1));
+ sieveRepository.setDefaultQuota(QuotaSizeLimit.size(SCRIPT_CONTENT.length() - 1));
sieveRepository.putScript(USERNAME, SCRIPT_NAME, SCRIPT_CONTENT);
}
@Test(expected = QuotaExceededException.class)
public void putScriptShouldThrowWhenQuotaChangedInBetween() throws Exception {
- sieveRepository.setDefaultQuota(QuotaSize.size(SCRIPT_CONTENT.length()));
+ sieveRepository.setDefaultQuota(QuotaSizeLimit.size(SCRIPT_CONTENT.length()));
sieveRepository.putScript(USERNAME, SCRIPT_NAME, SCRIPT_CONTENT);
- sieveRepository.setDefaultQuota(QuotaSize.size(SCRIPT_CONTENT.length() - 1));
+ sieveRepository.setDefaultQuota(QuotaSizeLimit.size(SCRIPT_CONTENT.length() - 1));
sieveRepository.putScript(USERNAME, SCRIPT_NAME, SCRIPT_CONTENT);
}
@@ -348,8 +348,8 @@ public abstract class AbstractSieveRepositoryTest {
@Test
public void setQuotaShouldOverrideExistingQuota() throws Exception {
sieveRepository.setQuota(USERNAME, USER_QUOTA);
- sieveRepository.setQuota(USERNAME, QuotaSize.size(USER_QUOTA.asLong() - 1));
- assertThat(sieveRepository.getQuota(USERNAME)).isEqualTo(QuotaSize.size(USER_QUOTA.asLong() - 1));
+ sieveRepository.setQuota(USERNAME, QuotaSizeLimit.size(USER_QUOTA.asLong() - 1));
+ assertThat(sieveRepository.getQuota(USERNAME)).isEqualTo(QuotaSizeLimit.size(USER_QUOTA.asLong() - 1));
}
protected ScriptContent getScriptContent(InputStream inputStream) throws IOException {
diff --git a/server/data/data-memory/src/main/java/org/apache/james/sieverepository/memory/InMemorySieveQuotaRepository.java b/server/data/data-memory/src/main/java/org/apache/james/sieverepository/memory/InMemorySieveQuotaRepository.java
index c6e51e1..939cb64 100644
--- a/server/data/data-memory/src/main/java/org/apache/james/sieverepository/memory/InMemorySieveQuotaRepository.java
+++ b/server/data/data-memory/src/main/java/org/apache/james/sieverepository/memory/InMemorySieveQuotaRepository.java
@@ -24,15 +24,15 @@ import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieverepository.api.SieveQuotaRepository;
import org.apache.james.sieverepository.api.exception.QuotaNotFoundException;
public class InMemorySieveQuotaRepository implements SieveQuotaRepository {
- private Optional<QuotaSize> globalQuota = Optional.empty();
+ private Optional<QuotaSizeLimit> globalQuota = Optional.empty();
- private Map<Username, QuotaSize> userQuota = new ConcurrentHashMap<>();
+ private Map<Username, QuotaSizeLimit> userQuota = new ConcurrentHashMap<>();
@Override
public synchronized boolean hasDefaultQuota() {
@@ -40,12 +40,12 @@ public class InMemorySieveQuotaRepository implements SieveQuotaRepository {
}
@Override
- public synchronized QuotaSize getDefaultQuota() throws QuotaNotFoundException {
+ public synchronized QuotaSizeLimit getDefaultQuota() throws QuotaNotFoundException {
return globalQuota.orElseThrow(QuotaNotFoundException::new);
}
@Override
- public synchronized void setDefaultQuota(QuotaSize quota) {
+ public synchronized void setDefaultQuota(QuotaSizeLimit quota) {
this.globalQuota = Optional.of(quota);
}
@@ -63,19 +63,19 @@ public class InMemorySieveQuotaRepository implements SieveQuotaRepository {
}
@Override
- public QuotaSize getQuota(Username username) throws QuotaNotFoundException {
+ public QuotaSizeLimit getQuota(Username username) throws QuotaNotFoundException {
return Optional.ofNullable(userQuota.get(username))
.orElseThrow(QuotaNotFoundException::new);
}
@Override
- public synchronized void setQuota(Username username, QuotaSize quota) {
+ public synchronized void setQuota(Username username, QuotaSizeLimit quota) {
userQuota.put(username, quota);
}
@Override
public synchronized void removeQuota(Username username) throws QuotaNotFoundException {
- Optional<QuotaSize> quotaValue = Optional.ofNullable(userQuota.get(username));
+ Optional<QuotaSizeLimit> quotaValue = Optional.ofNullable(userQuota.get(username));
if (!quotaValue.isPresent()) {
throw new QuotaNotFoundException();
}
diff --git a/server/mailet/integration-testing/src/test/java/org/apache/james/transport/mailets/IsOverQuotaMatcherTest.java b/server/mailet/integration-testing/src/test/java/org/apache/james/transport/mailets/IsOverQuotaMatcherTest.java
index 0e1c4b9..99f8b60 100644
--- a/server/mailet/integration-testing/src/test/java/org/apache/james/transport/mailets/IsOverQuotaMatcherTest.java
+++ b/server/mailet/integration-testing/src/test/java/org/apache/james/transport/mailets/IsOverQuotaMatcherTest.java
@@ -26,8 +26,8 @@ import static org.apache.james.mailets.configuration.Constants.awaitAtMostOneMin
import static org.assertj.core.api.Assertions.assertThat;
import org.apache.james.MemoryJamesServerMain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailets.TemporaryJamesServer;
import org.apache.james.mailets.configuration.CommonProcessors;
import org.apache.james.mailets.configuration.MailetConfiguration;
@@ -58,10 +58,10 @@ public class IsOverQuotaMatcherTest {
private static final String BOUNCE_SENDER = "bounce.sender@" + DEFAULT_DOMAIN;
private static final String OVER_QUOTA_MESSAGE = "The recipient is over quota";
- private static final QuotaSize SMALL_SIZE = QuotaSize.size(1);
- private static final QuotaSize LARGE_SIZE = QuotaSize.size(10000);
- private static final QuotaCount SMALL_COUNT = QuotaCount.count(0);
- private static final QuotaCount LARGE_COUNT = QuotaCount.count(100);
+ private static final QuotaSizeLimit SMALL_SIZE = QuotaSizeLimit.size(1);
+ private static final QuotaSizeLimit LARGE_SIZE = QuotaSizeLimit.size(10000);
+ private static final QuotaCountLimit SMALL_COUNT = QuotaCountLimit.count(0);
+ private static final QuotaCountLimit LARGE_COUNT = QuotaCountLimit.count(100);
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
diff --git a/server/mailet/mailets/src/test/java/org/apache/james/transport/matchers/IsOverQuotaTest.java b/server/mailet/mailets/src/test/java/org/apache/james/transport/matchers/IsOverQuotaTest.java
index 0685da9..2b9c9f4 100644
--- a/server/mailet/mailets/src/test/java/org/apache/james/transport/matchers/IsOverQuotaTest.java
+++ b/server/mailet/mailets/src/test/java/org/apache/james/transport/matchers/IsOverQuotaTest.java
@@ -27,8 +27,8 @@ import java.util.Collection;
import org.apache.james.core.MailAddress;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.inmemory.manager.InMemoryIntegrationResources;
import org.apache.james.mailbox.inmemory.quota.InMemoryPerUserMaxQuotaManager;
import org.apache.james.mailbox.model.MailboxPath;
@@ -80,7 +80,7 @@ public class IsOverQuotaTest {
@Test
public void matchShouldKeepAddressesWithTooBigSize() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(100));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(100));
FakeMail fakeMail = FakeMail.builder()
.name("name")
@@ -94,7 +94,7 @@ public class IsOverQuotaTest {
@Test
public void matchShouldReturnEmptyAtSizeQuotaLimit() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(1000));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(1000));
FakeMail fakeMail = FakeMail.builder()
.name("name")
@@ -108,7 +108,7 @@ public class IsOverQuotaTest {
@Test
public void matchShouldKeepAddressesWithTooMuchMessages() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(0));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(0));
FakeMail fakeMail = FakeMail.builder()
.name("name")
@@ -121,7 +121,7 @@ public class IsOverQuotaTest {
@Test
public void matchShouldReturnEmptyOnMessageLimit() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(1));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(1));
FakeMail fakeMail = FakeMail.builder()
.name("name")
@@ -136,7 +136,7 @@ public class IsOverQuotaTest {
public void matchShouldNotIncludeRecipientNotOverQuota() throws Exception {
Username username = Username.of(MailAddressFixture.ANY_AT_JAMES.getLocalPart());
QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(MailboxPath.inbox(mailboxManager.createSystemSession(username)));
- maxQuotaManager.setMaxStorage(quotaRoot, QuotaSize.size(100));
+ maxQuotaManager.setMaxStorage(quotaRoot, QuotaSizeLimit.size(100));
FakeMail fakeMail = FakeMail.builder()
.name("name")
@@ -155,7 +155,7 @@ public class IsOverQuotaTest {
when(usersRepository.getUser(MailAddressFixture.OTHER_AT_JAMES)).thenReturn(Username.of(MailAddressFixture.OTHER_AT_JAMES.asString()));
Username username = Username.of(MailAddressFixture.ANY_AT_JAMES.asString());
QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(MailboxPath.inbox(mailboxManager.createSystemSession(username)));
- maxQuotaManager.setMaxStorage(quotaRoot, QuotaSize.size(100));
+ maxQuotaManager.setMaxStorage(quotaRoot, QuotaSizeLimit.size(100));
FakeMail fakeMail = FakeMail.builder()
.name("name")
diff --git a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/GetMailboxesMethodTest.java b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/GetMailboxesMethodTest.java
index ac18edf..c3f4d88 100644
--- a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/GetMailboxesMethodTest.java
+++ b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/GetMailboxesMethodTest.java
@@ -55,8 +55,8 @@ import java.util.Map;
import java.util.Optional;
import org.apache.james.GuiceJamesServer;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.jmap.api.access.AccessToken;
import org.apache.james.jmap.categories.BasicFeature;
import org.apache.james.jmap.draft.JmapGuiceProbe;
@@ -68,7 +68,7 @@ import org.apache.james.mailbox.model.MailboxACL.Right;
import org.apache.james.mailbox.model.MailboxConstants;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.model.MailboxPath;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.ACLProbe;
import org.apache.james.mailbox.probe.QuotaProbe;
import org.apache.james.mime4j.dom.Message;
@@ -788,7 +788,7 @@ public abstract class GetMailboxesMethodTest {
@Category(BasicFeature.class)
@Test
public void getMailboxesShouldReturnMaxStorageQuotasForInboxWhenSet() throws Exception {
- quotaProbe.setGlobalMaxStorage(SerializableQuotaValue.valueOf(Optional.of(QuotaSize.size(42))));
+ quotaProbe.setGlobalMaxStorage(SerializableQuotaLimitValue.valueOf(Optional.of(QuotaSizeLimit.size(42))));
String mailboxId = mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, ALICE.asString(), DefaultMailboxes.INBOX).serialize();
given()
@@ -805,7 +805,7 @@ public abstract class GetMailboxesMethodTest {
@Test
public void getMailboxesShouldReturnMaxMessageQuotasForInboxWhenSet() throws Exception {
- quotaProbe.setGlobalMaxMessageCount(SerializableQuotaValue.valueOf(Optional.of(QuotaCount.count(43))));
+ quotaProbe.setGlobalMaxMessageCount(SerializableQuotaLimitValue.valueOf(Optional.of(QuotaCountLimit.count(43))));
String mailboxId = mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, ALICE.asString(), DefaultMailboxes.INBOX).serialize();
given()
@@ -829,8 +829,8 @@ public abstract class GetMailboxesMethodTest {
MailboxPath bobMailboxPath = MailboxPath.forUser(BOB, sharedMailboxName);
aclProbe.replaceRights(bobMailboxPath, ALICE.asString(), new Rfc4314Rights(Right.Lookup, Right.Read));
- quotaProbe.setMaxMessageCount("#private&alice@domain.tld", SerializableQuotaValue.valueOf(Optional.of(QuotaCount.count(42))));
- quotaProbe.setMaxMessageCount("#private&bob@domain.tld", SerializableQuotaValue.valueOf(Optional.of(QuotaCount.count(43))));
+ quotaProbe.setMaxMessageCount("#private&alice@domain.tld", SerializableQuotaLimitValue.valueOf(Optional.of(QuotaCountLimit.count(42))));
+ quotaProbe.setMaxMessageCount("#private&bob@domain.tld", SerializableQuotaLimitValue.valueOf(Optional.of(QuotaCountLimit.count(43))));
given()
.header("Authorization", accessToken.serialize())
diff --git a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/QuotaMailingTest.java b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/QuotaMailingTest.java
index 2cd2734..23a18b5 100644
--- a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/QuotaMailingTest.java
+++ b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/QuotaMailingTest.java
@@ -38,13 +38,13 @@ import java.util.List;
import org.apache.james.GuiceJamesServer;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.jmap.api.access.AccessToken;
import org.apache.james.jmap.categories.BasicFeature;
import org.apache.james.jmap.draft.JmapGuiceProbe;
import org.apache.james.mailbox.DefaultMailboxes;
import org.apache.james.mailbox.model.MailboxConstants;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.MailboxProbe;
import org.apache.james.modules.MailboxProbeImpl;
import org.apache.james.modules.QuotaProbesImpl;
@@ -105,7 +105,7 @@ public abstract class QuotaMailingTest {
public void shouldSendANoticeWhenThresholdExceeded() throws Exception {
jmapServer.getProbe(QuotaProbesImpl.class)
.setMaxStorage(MailboxConstants.USER_NAMESPACE + "&" + HOMER.asString(),
- new SerializableQuotaValue<>(QuotaSize.size(100 * 1000)));
+ new SerializableQuotaLimitValue<>(QuotaSizeLimit.size(100 * 1000)));
bartSendMessageToHomer();
// Homer receives a mail big enough to trigger a configured threshold
@@ -131,7 +131,7 @@ public abstract class QuotaMailingTest {
public void configurationShouldBeWellLoaded() throws Exception {
jmapServer.getProbe(QuotaProbesImpl.class)
.setMaxStorage(MailboxConstants.USER_NAMESPACE + "&" + HOMER.asString(),
- new SerializableQuotaValue<>(QuotaSize.size(100 * 1000)));
+ new SerializableQuotaLimitValue<>(QuotaSizeLimit.size(100 * 1000)));
bartSendMessageToHomer();
// Homer receives a mail big enough to trigger a 10% configured threshold
diff --git a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SendMDNMethodTest.java b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SendMDNMethodTest.java
index 35f176b..d8692ee 100644
--- a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SendMDNMethodTest.java
+++ b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SendMDNMethodTest.java
@@ -46,7 +46,7 @@ import java.util.Optional;
import org.apache.james.GuiceJamesServer;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.jmap.MessageAppender;
import org.apache.james.jmap.api.access.AccessToken;
import org.apache.james.jmap.categories.BasicFeature;
@@ -55,7 +55,7 @@ import org.apache.james.mailbox.DefaultMailboxes;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.MailboxConstants;
import org.apache.james.mailbox.model.MessageId;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.MailboxProbe;
import org.apache.james.mailbox.probe.QuotaProbe;
import org.apache.james.modules.MailboxProbeImpl;
@@ -406,7 +406,7 @@ public abstract class SendMDNMethodTest {
QuotaProbe quotaProbe = jmapServer.getProbe(QuotaProbesImpl.class);
String inboxQuotaRoot = quotaProbe.getQuotaRoot("#private", HOMER.asString(), DefaultMailboxes.INBOX);
- quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaValue.valueOf(Optional.of(QuotaSize.size(100))));
+ quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaLimitValue.valueOf(Optional.of(QuotaSizeLimit.size(100))));
MessageAppender.fillMailbox(jmapServer.getProbe(MailboxProbeImpl.class), HOMER.asString(), MailboxConstants.INBOX);
diff --git a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SetMessagesMethodTest.java b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SetMessagesMethodTest.java
index f9eeea2..3b7047c 100644
--- a/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SetMessagesMethodTest.java
+++ b/server/protocols/jmap-draft-integration-testing/jmap-draft-integration-testing-common/src/test/java/org/apache/james/jmap/draft/methods/integration/SetMessagesMethodTest.java
@@ -74,7 +74,7 @@ import javax.mail.internet.MimeMessage;
import org.apache.commons.io.IOUtils;
import org.apache.james.GuiceJamesServer;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.jmap.HttpJmapAuthentication;
import org.apache.james.jmap.MessageAppender;
import org.apache.james.jmap.api.access.AccessToken;
@@ -95,7 +95,7 @@ import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mailbox.model.MessageId;
import org.apache.james.mailbox.model.MessageResult;
-import org.apache.james.mailbox.model.SerializableQuotaValue;
+import org.apache.james.mailbox.model.SerializableQuotaLimitValue;
import org.apache.james.mailbox.probe.ACLProbe;
import org.apache.james.mailbox.probe.MailboxProbe;
import org.apache.james.mailbox.probe.QuotaProbe;
@@ -1326,7 +1326,7 @@ public abstract class SetMessagesMethodTest {
public void setMessagesShouldNotAllowDraftCreationWhenOverQuota() throws MailboxException {
QuotaProbe quotaProbe = jmapServer.getProbe(QuotaProbesImpl.class);
String inboxQuotaRoot = quotaProbe.getQuotaRoot("#private", USERNAME.asString(), DefaultMailboxes.INBOX);
- quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaValue.valueOf(Optional.of(QuotaSize.size(100))));
+ quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaLimitValue.valueOf(Optional.of(QuotaSizeLimit.size(100))));
MessageAppender.fillMailbox(mailboxProbe, USERNAME.asString(), MailboxConstants.INBOX);
@@ -1443,7 +1443,7 @@ public abstract class SetMessagesMethodTest {
public void setMessagesShouldNotAllowCopyWhenOverQuota() throws MailboxException {
QuotaProbe quotaProbe = jmapServer.getProbe(QuotaProbesImpl.class);
String inboxQuotaRoot = quotaProbe.getQuotaRoot("#private", USERNAME.asString(), DefaultMailboxes.INBOX);
- quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaValue.valueOf(Optional.of(QuotaSize.size(100))));
+ quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaLimitValue.valueOf(Optional.of(QuotaSizeLimit.size(100))));
List<ComposedMessageId> composedMessageIds = MessageAppender.fillMailbox(mailboxProbe, USERNAME.asString(), MailboxConstants.INBOX);
@@ -2773,7 +2773,7 @@ public abstract class SetMessagesMethodTest {
public void setMessagesShouldTriggerMaxQuotaReachedWhenTryingToSendMessageAndQuotaReached() throws Exception {
QuotaProbe quotaProbe = jmapServer.getProbe(QuotaProbesImpl.class);
String inboxQuotaRoot = quotaProbe.getQuotaRoot("#private", USERNAME.asString(), DefaultMailboxes.INBOX);
- quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaValue.valueOf(Optional.of(QuotaSize.size(100))));
+ quotaProbe.setMaxStorage(inboxQuotaRoot, SerializableQuotaLimitValue.valueOf(Optional.of(QuotaSizeLimit.size(100))));
MessageAppender.fillMailbox(mailboxProbe, USERNAME.asString(), MailboxConstants.INBOX);
diff --git a/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/model/mailbox/Quotas.java b/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/model/mailbox/Quotas.java
index dd81970..d8c31a1 100644
--- a/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/model/mailbox/Quotas.java
+++ b/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/model/mailbox/Quotas.java
@@ -22,9 +22,12 @@ import java.util.Map;
import java.util.Objects;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
+import org.apache.james.core.quota.QuotaUsageValue;
import org.apache.james.jmap.draft.model.Number;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -84,23 +87,23 @@ public class Quotas {
}
public static class Quota {
- private final Map<Type, Value<?>> quota;
+ private final Map<Type, Value<?, ?>> quota;
- public static Quota from(ImmutableMap<Type, Value<?>> quota) {
+ public static Quota from(ImmutableMap<Type, Value<?, ?>> quota) {
return new Quota(quota);
}
- public static Quota from(Value<QuotaSize> storage, Value<QuotaCount> message) {
+ public static Quota from(Value<QuotaSizeLimit, QuotaSizeUsage> storage, Value<QuotaCountLimit, QuotaCountUsage> message) {
return new Quota(ImmutableMap.of(Type.STORAGE, storage,
Type.MESSAGE, message));
}
- private Quota(ImmutableMap<Type, Value<?>> quota) {
+ private Quota(ImmutableMap<Type, Value<?, ?>> quota) {
this.quota = quota;
}
@JsonValue
- public Map<Type, Value<?>> getQuota() {
+ public Map<Type, Value<?, ?>> getQuota() {
return quota;
}
}
@@ -110,7 +113,7 @@ public class Quotas {
MESSAGE;
}
- public static class Value<T extends QuotaValue<T>> {
+ public static class Value<T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> {
private final Number used;
private final Optional<Number> max;
diff --git a/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/utils/quotas/QuotaLoader.java b/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/utils/quotas/QuotaLoader.java
index a196df2..76bd371 100644
--- a/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/utils/quotas/QuotaLoader.java
+++ b/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/draft/utils/quotas/QuotaLoader.java
@@ -20,7 +20,8 @@ package org.apache.james.jmap.draft.utils.quotas;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
+import org.apache.james.core.quota.QuotaUsageValue;
import org.apache.james.jmap.draft.model.Number;
import org.apache.james.jmap.draft.model.mailbox.Quotas;
import org.apache.james.mailbox.exception.MailboxException;
@@ -31,17 +32,21 @@ public abstract class QuotaLoader {
public abstract Quotas getQuotas(MailboxPath mailboxPath) throws MailboxException;
- protected <T extends QuotaValue<T>> Quotas.Value<T> quotaToValue(Quota<T> quota) {
+ protected <T extends QuotaLimitValue<T>, U extends QuotaUsageValue<U, T>> Quotas.Value<T, U> quotaToValue(Quota<T, U> quota) {
return new Quotas.Value<>(
- quotaValueToNumber(quota.getUsed()),
- quotaValueToOptionalNumber(quota.getLimit()));
+ quotaValueUsageToNumber(quota.getUsed()),
+ quotaLimitValueToOptionalNumber(quota.getLimit()));
}
- protected Number quotaValueToNumber(QuotaValue<?> value) {
+ protected Number quotaValueToNumber(QuotaLimitValue<?> value) {
return Number.BOUND_SANITIZING_FACTORY.from(value.asLong());
}
- protected Optional<Number> quotaValueToOptionalNumber(QuotaValue<?> value) {
+ protected Number quotaValueUsageToNumber(QuotaUsageValue<?, ?> value) {
+ return Number.BOUND_SANITIZING_FACTORY.from(value.asLong());
+ }
+
+ protected Optional<Number> quotaLimitValueToOptionalNumber(QuotaLimitValue<?> value) {
if (value.isUnlimited()) {
return Optional.empty();
}
diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/SieveQuotaRoutes.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/SieveQuotaRoutes.java
index 82522e1..fbbb40d 100644
--- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/SieveQuotaRoutes.java
+++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/SieveQuotaRoutes.java
@@ -29,7 +29,7 @@ import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieverepository.api.SieveQuotaRepository;
import org.apache.james.sieverepository.api.exception.QuotaNotFoundException;
import org.apache.james.user.api.UsersRepository;
@@ -99,7 +99,7 @@ public class SieveQuotaRoutes implements Routes {
public void defineGetGlobalSieveQuota(Service service) {
service.get(DEFAULT_QUOTA_PATH, (request, response) -> {
try {
- QuotaSize sieveQuota = sieveQuotaRepository.getDefaultQuota();
+ QuotaSizeLimit sieveQuota = sieveQuotaRepository.getDefaultQuota();
response.status(HttpStatus.OK_200);
return sieveQuota.asLong();
} catch (QuotaNotFoundException e) {
@@ -120,7 +120,7 @@ public class SieveQuotaRoutes implements Routes {
})
public void defineUpdateGlobalSieveQuota(Service service) {
service.put(DEFAULT_QUOTA_PATH, (request, response) -> {
- QuotaSize requestedSize = extractRequestedQuotaSizeFromRequest(request);
+ QuotaSizeLimit requestedSize = extractRequestedQuotaSizeFromRequest(request);
sieveQuotaRepository.setDefaultQuota(requestedSize);
return Responses.returnNoContent(response);
}, jsonTransformer);
@@ -156,9 +156,9 @@ public class SieveQuotaRoutes implements Routes {
})
public void defineGetPerUserSieveQuota(Service service) {
service.get(USER_SIEVE_QUOTA_PATH, (request, response) -> {
- Username usernameId = getUsername(request.params(USER_ID));
+ Username userId = getUsername(request.params(USER_ID));
try {
- QuotaSize userQuota = sieveQuotaRepository.getQuota(usernameId);
+ QuotaSizeLimit userQuota = sieveQuotaRepository.getQuota(userId);
response.status(HttpStatus.OK_200);
return userQuota.asLong();
} catch (QuotaNotFoundException e) {
@@ -182,7 +182,7 @@ public class SieveQuotaRoutes implements Routes {
public void defineUpdatePerUserSieveQuota(Service service) {
service.put(USER_SIEVE_QUOTA_PATH, (request, response) -> {
Username userId = getUsername(request.params(USER_ID));
- QuotaSize requestedSize = extractRequestedQuotaSizeFromRequest(request);
+ QuotaSizeLimit requestedSize = extractRequestedQuotaSizeFromRequest(request);
sieveQuotaRepository.setQuota(userId, requestedSize);
return Responses.returnNoContent(response);
}, jsonTransformer);
@@ -210,7 +210,7 @@ public class SieveQuotaRoutes implements Routes {
});
}
- private QuotaSize extractRequestedQuotaSizeFromRequest(Request request) {
+ private QuotaSizeLimit extractRequestedQuotaSizeFromRequest(Request request) {
long requestedSize = extractNumberFromRequestBody(request);
if (requestedSize < 0) {
throw ErrorResponder.builder()
@@ -219,7 +219,7 @@ public class SieveQuotaRoutes implements Routes {
.message("Requested quota size have to be a positive integer")
.haltError();
}
- return QuotaSize.size(requestedSize);
+ return QuotaSizeLimit.size(requestedSize);
}
private long extractNumberFromRequestBody(Request request) {
diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/SieveQuotaRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/SieveQuotaRoutesTest.java
index cca0e2b..759b556 100644
--- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/SieveQuotaRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/SieveQuotaRoutesTest.java
@@ -24,7 +24,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.sieverepository.api.SieveQuotaRepository;
import org.apache.james.sieverepository.memory.InMemorySieveQuotaRepository;
import org.apache.james.user.api.UsersRepositoryException;
@@ -78,7 +78,7 @@ class SieveQuotaRoutesTest {
@Test
void getGlobalSieveQuotaShouldReturnStoredValue() throws Exception {
- QuotaSize value = QuotaSize.size(1000L);
+ QuotaSizeLimit value = QuotaSizeLimit.size(1000L);
sieveRepository.setDefaultQuota(value);
long actual =
@@ -95,7 +95,7 @@ class SieveQuotaRoutesTest {
@Test
void updateGlobalSieveQuotaShouldUpdateStoredValue() throws Exception {
- sieveRepository.setDefaultQuota(QuotaSize.size(500L));
+ sieveRepository.setDefaultQuota(QuotaSizeLimit.size(500L));
long requiredSize = 1024L;
given()
@@ -146,7 +146,7 @@ class SieveQuotaRoutesTest {
@Test
void removeGlobalSieveQuotaShouldRemoveGlobalSieveQuota() throws Exception {
- sieveRepository.setDefaultQuota(QuotaSize.size(1024L));
+ sieveRepository.setDefaultQuota(QuotaSizeLimit.size(1024L));
given()
.delete("/sieve/quota/default")
@@ -164,7 +164,7 @@ class SieveQuotaRoutesTest {
@Test
void getPerUserSieveQuotaShouldReturnStoredValue() throws Exception {
- QuotaSize value = QuotaSize.size(1024L);
+ QuotaSizeLimit value = QuotaSizeLimit.size(1024L);
sieveRepository.setQuota(USERNAME_A, value);
long actual =
@@ -189,7 +189,7 @@ class SieveQuotaRoutesTest {
@Test
void updatePerUserSieveQuotaShouldUpdateStoredValue() throws Exception {
- sieveRepository.setQuota(USERNAME_A, QuotaSize.size(500L));
+ sieveRepository.setQuota(USERNAME_A, QuotaSizeLimit.size(500L));
long requiredSize = 1024L;
given()
@@ -249,7 +249,7 @@ class SieveQuotaRoutesTest {
@Test
void removePerUserSieveQuotaShouldRemoveQuotaForUser() throws Exception {
- sieveRepository.setQuota(USERNAME_A, QuotaSize.size(1024));
+ sieveRepository.setQuota(USERNAME_A, QuotaSizeLimit.size(1024));
given()
.delete("/sieve/quota/users/" + USER_NAME_A)
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationDTO.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationDTO.java
index 455de1d..adc1a62 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationDTO.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationDTO.java
@@ -19,12 +19,14 @@
package org.apache.james.webadmin.dto;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
public class OccupationDTO {
- public static OccupationDTO from(Quota<QuotaSize> sizeQuota, Quota<QuotaCount> countQuota) {
+ public static OccupationDTO from(Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Quota<QuotaCountLimit, QuotaCountUsage> countQuota) {
return new OccupationDTO(
sizeQuota.getUsed().asLong(),
countQuota.getUsed().asLong(),
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationRatioDTO.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationRatioDTO.java
index d3fc923..36bcd48 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationRatioDTO.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/OccupationRatioDTO.java
@@ -19,14 +19,16 @@
package org.apache.james.webadmin.dto;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRatio;
public class OccupationRatioDTO {
- public static OccupationRatioDTO from(Quota<QuotaSize> sizeQuota, Quota<QuotaCount> countQuota) {
+ public static OccupationRatioDTO from(Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Quota<QuotaCountLimit, QuotaCountUsage> countQuota) {
return new OccupationRatioDTO(
sizeQuota.getRatio(),
countQuota.getRatio(),
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java
index 7449c90..08bb9bc 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java
@@ -22,8 +22,10 @@ package org.apache.james.webadmin.dto;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import com.google.common.base.Preconditions;
@@ -67,7 +69,7 @@ public class QuotaDetailsDTO {
return this;
}
- public Builder occupation(Quota<QuotaSize> sizeQuota, Quota<QuotaCount> countQuota) {
+ public Builder occupation(Quota<QuotaSizeLimit, QuotaSizeUsage> sizeQuota, Quota<QuotaCountLimit, QuotaCountUsage> countQuota) {
this.occupation = OccupationDTO.from(sizeQuota, countQuota);
return this;
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueDeserializer.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueDeserializer.java
index 9a2a7e8..32dc328 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueDeserializer.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueDeserializer.java
@@ -21,13 +21,13 @@ package org.apache.james.webadmin.dto;
import java.io.IOException;
import java.util.function.Function;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
-public class QuotaValueDeserializer<T extends QuotaValue<T>> extends JsonDeserializer<T> {
+public class QuotaValueDeserializer<T extends QuotaLimitValue<T>> extends JsonDeserializer<T> {
private final T unlimited;
private final Function<Long, T> quotaFactory;
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueSerializer.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueSerializer.java
index 3c4067b..ba62556 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueSerializer.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaValueSerializer.java
@@ -20,13 +20,13 @@ package org.apache.james.webadmin.dto;
import java.io.IOException;
-import org.apache.james.core.quota.QuotaValue;
+import org.apache.james.core.quota.QuotaLimitValue;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
-public class QuotaValueSerializer<T extends QuotaValue<T>> extends JsonSerializer<T> {
+public class QuotaValueSerializer<T extends QuotaLimitValue<T>> extends JsonSerializer<T> {
@Override
public void serialize(T value, JsonGenerator generator, SerializerProvider serializers) throws IOException {
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/ValidatedQuotaDTO.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/ValidatedQuotaDTO.java
index 6023096..b595a81 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/ValidatedQuotaDTO.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/ValidatedQuotaDTO.java
@@ -23,8 +23,8 @@ package org.apache.james.webadmin.dto;
import java.util.Objects;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
@@ -39,20 +39,20 @@ public class ValidatedQuotaDTO {
@JsonPOJOBuilder(withPrefix = "")
public static class Builder {
- private Optional<QuotaCount> count;
- private Optional<QuotaSize> size;
+ private Optional<QuotaCountLimit> count;
+ private Optional<QuotaSizeLimit> size;
private Builder() {
count = Optional.empty();
size = Optional.empty();
}
- public Builder count(Optional<QuotaCount> count) {
+ public Builder count(Optional<QuotaCountLimit> count) {
this.count = count;
return this;
}
- public Builder size(Optional<QuotaSize> size) {
+ public Builder size(Optional<QuotaSizeLimit> size) {
this.size = size;
return this;
}
@@ -63,19 +63,19 @@ public class ValidatedQuotaDTO {
}
- private final Optional<QuotaCount> count;
- private final Optional<QuotaSize> size;
+ private final Optional<QuotaCountLimit> count;
+ private final Optional<QuotaSizeLimit> size;
- private ValidatedQuotaDTO(Optional<QuotaCount> count, Optional<QuotaSize> size) {
+ private ValidatedQuotaDTO(Optional<QuotaCountLimit> count, Optional<QuotaSizeLimit> size) {
this.count = count;
this.size = size;
}
- public Optional<QuotaCount> getCount() {
+ public Optional<QuotaCountLimit> getCount() {
return count;
}
- public Optional<QuotaSize> getSize() {
+ public Optional<QuotaSizeLimit> getSize() {
return size;
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/jackson/QuotaModule.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/jackson/QuotaModule.java
index 003226a..de45950 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/jackson/QuotaModule.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/jackson/QuotaModule.java
@@ -18,8 +18,8 @@
****************************************************************/
package org.apache.james.webadmin.jackson;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.webadmin.dto.QuotaValueDeserializer;
import org.apache.james.webadmin.dto.QuotaValueSerializer;
import org.apache.james.webadmin.utils.JsonTransformerModule;
@@ -33,10 +33,10 @@ public class QuotaModule implements JsonTransformerModule {
public QuotaModule() {
simpleModule = new SimpleModule()
- .addSerializer(QuotaSize.class, new QuotaValueSerializer<>())
- .addSerializer(QuotaCount.class, new QuotaValueSerializer<>())
- .addDeserializer(QuotaSize.class, new QuotaValueDeserializer<>(QuotaSize.unlimited(), QuotaSize::size))
- .addDeserializer(QuotaCount.class, new QuotaValueDeserializer<>(QuotaCount.unlimited(), QuotaCount::count));
+ .addSerializer(QuotaSizeLimit.class, new QuotaValueSerializer<>())
+ .addSerializer(QuotaCountLimit.class, new QuotaValueSerializer<>())
+ .addDeserializer(QuotaSizeLimit.class, new QuotaValueDeserializer<>(QuotaSizeLimit.unlimited(), QuotaSizeLimit::size))
+ .addDeserializer(QuotaCountLimit.class, new QuotaValueDeserializer<>(QuotaCountLimit.unlimited(), QuotaCountLimit::count));
}
@Override
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/DomainQuotaRoutes.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/DomainQuotaRoutes.java
index c080910..c5c6850 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/DomainQuotaRoutes.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/DomainQuotaRoutes.java
@@ -31,8 +31,8 @@ import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.domainlist.api.DomainList;
import org.apache.james.domainlist.api.DomainListException;
import org.apache.james.user.api.UsersRepository;
@@ -201,7 +201,7 @@ public class DomainQuotaRoutes implements Routes {
public void defineUpdateQuotaSize() {
service.put(SIZE_ENDPOINT, (request, response) -> {
Domain domain = checkDomainExist(request);
- QuotaSize quotaSize = Quotas.quotaSize(request.body());
+ QuotaSizeLimit quotaSize = Quotas.quotaSize(request.body());
domainQuotaService.setMaxSizeQuota(domain, quotaSize);
return Responses.returnNoContent(response);
});
@@ -220,7 +220,7 @@ public class DomainQuotaRoutes implements Routes {
public void defineGetQuotaSize() {
service.get(SIZE_ENDPOINT, (request, response) -> {
Domain domain = checkDomainExist(request);
- Optional<QuotaSize> maxSizeQuota = domainQuotaService.getMaxSizeQuota(domain);
+ Optional<QuotaSizeLimit> maxSizeQuota = domainQuotaService.getMaxSizeQuota(domain);
if (maxSizeQuota.isPresent()) {
return maxSizeQuota;
}
@@ -261,7 +261,7 @@ public class DomainQuotaRoutes implements Routes {
public void defineUpdateQuotaCount() {
service.put(COUNT_ENDPOINT, (request, response) -> {
Domain domain = checkDomainExist(request);
- QuotaCount quotaCount = Quotas.quotaCount(request.body());
+ QuotaCountLimit quotaCount = Quotas.quotaCount(request.body());
domainQuotaService.setMaxCountQuota(domain, quotaCount);
return Responses.returnNoContent(response);
});
@@ -279,7 +279,7 @@ public class DomainQuotaRoutes implements Routes {
public void defineGetQuotaCount() {
service.get(COUNT_ENDPOINT, (request, response) -> {
Domain domain = checkDomainExist(request);
- Optional<QuotaCount> maxCountQuota = domainQuotaService.getMaxCountQuota(domain);
+ Optional<QuotaCountLimit> maxCountQuota = domainQuotaService.getMaxCountQuota(domain);
if (maxCountQuota.isPresent()) {
return maxCountQuota;
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/GlobalQuotaRoutes.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/GlobalQuotaRoutes.java
index a4c255f..470012b 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/GlobalQuotaRoutes.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/routes/GlobalQuotaRoutes.java
@@ -28,8 +28,8 @@ import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.webadmin.Routes;
import org.apache.james.webadmin.dto.QuotaDTO;
@@ -172,7 +172,7 @@ public class GlobalQuotaRoutes implements Routes {
})
public void defineUpdateQuotaSize() {
service.put(SIZE_ENDPOINT, (request, response) -> {
- QuotaSize quotaSize = Quotas.quotaSize(request.body());
+ QuotaSizeLimit quotaSize = Quotas.quotaSize(request.body());
globalQuotaService.defineMaxSizeQuota(quotaSize);
return Responses.returnNoContent(response);
});
@@ -189,8 +189,8 @@ public class GlobalQuotaRoutes implements Routes {
service.get(SIZE_ENDPOINT, this::getQuotaSize, jsonTransformer);
}
- private QuotaSize getQuotaSize(Request request, Response response) throws MailboxException {
- Optional<QuotaSize> maxSizeQuota = globalQuotaService.getMaxSizeQuota();
+ private QuotaSizeLimit getQuotaSize(Request request, Response response) throws MailboxException {
+ Optional<QuotaSizeLimit> maxSizeQuota = globalQuotaService.getMaxSizeQuota();
if (maxSizeQuota.isPresent()) {
return maxSizeQuota.get();
}
@@ -225,7 +225,7 @@ public class GlobalQuotaRoutes implements Routes {
})
public void defineUpdateQuotaCount() {
service.put(COUNT_ENDPOINT, (request, response) -> {
- QuotaCount quotaRequest = Quotas.quotaCount(request.body());
+ QuotaCountLimit quotaRequest = Quotas.quotaCount(request.body());
globalQuotaService.defineMaxCountQuota(quotaRequest);
return Responses.returnNoContent(response);
});
@@ -243,8 +243,8 @@ public class GlobalQuotaRoutes implements Routes {
service.get(COUNT_ENDPOINT, this::getQuotaCount, jsonTransformer);
}
- private QuotaCount getQuotaCount(Request request, Response response) throws MailboxException {
- Optional<QuotaCount> maxCountQuota = globalQuotaService.getMaxCountQuota();
+ private QuotaCountLimit getQuotaCount(Request request, Response response) throws MailboxException {
+ Optional<QuotaCountLimit> maxCountQuota = globalQuotaService.getMaxCountQuota();
if (maxCountQuota.isPresent()) {
return maxCountQuota.get();
}
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 4fbf4cc..fda1b65 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
@@ -35,8 +35,8 @@ import javax.ws.rs.Produces;
import org.apache.james.core.Domain;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.quota.search.Limit;
import org.apache.james.quota.search.Offset;
import org.apache.james.quota.search.QuotaBoundary;
@@ -282,7 +282,7 @@ public class UserQuotaRoutes implements Routes {
public void defineUpdateQuotaSize() {
service.put(SIZE_ENDPOINT, (request, response) -> {
Username username = checkUserExist(request);
- QuotaSize quotaSize = Quotas.quotaSize(request.body());
+ QuotaSizeLimit quotaSize = Quotas.quotaSize(request.body());
userQuotaService.defineMaxSizeQuota(username, quotaSize);
return Responses.returnNoContent(response);
});
@@ -300,7 +300,7 @@ public class UserQuotaRoutes implements Routes {
public void defineGetQuotaSize() {
service.get(SIZE_ENDPOINT, (request, response) -> {
Username username = checkUserExist(request);
- Optional<QuotaSize> maxSizeQuota = userQuotaService.getMaxSizeQuota(username);
+ Optional<QuotaSizeLimit> maxSizeQuota = userQuotaService.getMaxSizeQuota(username);
if (maxSizeQuota.isPresent()) {
return maxSizeQuota;
}
@@ -339,7 +339,7 @@ public class UserQuotaRoutes implements Routes {
public void defineUpdateQuotaCount() {
service.put(COUNT_ENDPOINT, (request, response) -> {
Username username = checkUserExist(request);
- QuotaCount quotaCount = Quotas.quotaCount(request.body());
+ QuotaCountLimit quotaCount = Quotas.quotaCount(request.body());
userQuotaService.defineMaxCountQuota(username, quotaCount);
return Responses.returnNoContent(response);
});
@@ -357,7 +357,7 @@ public class UserQuotaRoutes implements Routes {
public void defineGetQuotaCount() {
service.get(COUNT_ENDPOINT, (request, response) -> {
Username username = checkUserExist(request);
- Optional<QuotaCount> maxCountQuota = userQuotaService.getMaxCountQuota(username);
+ Optional<QuotaCountLimit> maxCountQuota = userQuotaService.getMaxCountQuota(username);
if (maxCountQuota.isPresent()) {
return maxCountQuota;
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java
index e9b7491..2d0864e 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java
@@ -24,8 +24,8 @@ import java.util.Optional;
import javax.inject.Inject;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.webadmin.dto.QuotaDomainDTO;
@@ -40,11 +40,11 @@ public class DomainQuotaService {
this.maxQuotaManager = maxQuotaManager;
}
- public Optional<QuotaCount> getMaxCountQuota(Domain domain) {
+ public Optional<QuotaCountLimit> getMaxCountQuota(Domain domain) {
return maxQuotaManager.getDomainMaxMessage(domain);
}
- public void setMaxCountQuota(Domain domain, QuotaCount quotaCount) throws MailboxException {
+ public void setMaxCountQuota(Domain domain, QuotaCountLimit quotaCount) throws MailboxException {
maxQuotaManager.setDomainMaxMessage(domain, quotaCount);
}
@@ -52,11 +52,11 @@ public class DomainQuotaService {
maxQuotaManager.removeDomainMaxMessage(domain);
}
- public Optional<QuotaSize> getMaxSizeQuota(Domain domain) {
+ public Optional<QuotaSizeLimit> getMaxSizeQuota(Domain domain) {
return maxQuotaManager.getDomainMaxStorage(domain);
}
- public void setMaxSizeQuota(Domain domain, QuotaSize quotaSize) throws MailboxException {
+ public void setMaxSizeQuota(Domain domain, QuotaSizeLimit quotaSize) throws MailboxException {
maxQuotaManager.setDomainMaxStorage(domain, quotaSize);
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java
index abd3aed..a957c4d 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java
@@ -22,8 +22,8 @@ import java.util.Optional;
import javax.inject.Inject;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.webadmin.dto.ValidatedQuotaDTO;
@@ -38,14 +38,14 @@ public class GlobalQuotaService {
}
public void defineQuota(ValidatedQuotaDTO quota) throws MailboxException {
- Optional<QuotaCount> count = quota.getCount();
+ Optional<QuotaCountLimit> count = quota.getCount();
if (count.isPresent()) {
maxQuotaManager.setGlobalMaxMessage(count.get());
} else {
maxQuotaManager.removeGlobalMaxMessage();
}
- Optional<QuotaSize> size = quota.getSize();
+ Optional<QuotaSizeLimit> size = quota.getSize();
if (size.isPresent()) {
maxQuotaManager.setGlobalMaxStorage(size.get());
} else {
@@ -61,11 +61,11 @@ public class GlobalQuotaService {
.build();
}
- public Optional<QuotaSize> getMaxSizeQuota() throws MailboxException {
+ public Optional<QuotaSizeLimit> getMaxSizeQuota() throws MailboxException {
return maxQuotaManager.getGlobalMaxStorage();
}
- public void defineMaxSizeQuota(QuotaSize quotaRequest) throws MailboxException {
+ public void defineMaxSizeQuota(QuotaSizeLimit quotaRequest) throws MailboxException {
maxQuotaManager.setGlobalMaxStorage(quotaRequest);
}
@@ -73,11 +73,11 @@ public class GlobalQuotaService {
maxQuotaManager.removeGlobalMaxStorage();
}
- public Optional<QuotaCount> getMaxCountQuota() throws MailboxException {
+ public Optional<QuotaCountLimit> getMaxCountQuota() throws MailboxException {
return maxQuotaManager.getGlobalMaxMessage();
}
- public void defineMaxCountQuota(QuotaCount value) throws MailboxException {
+ public void defineMaxCountQuota(QuotaCountLimit value) throws MailboxException {
maxQuotaManager.setGlobalMaxMessage(value);
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java
index 1aaf012..cb42f06 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java
@@ -27,8 +27,8 @@ import java.util.stream.Collectors;
import javax.inject.Inject;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
@@ -102,7 +102,7 @@ public class UserQuotaService {
.build();
}
- private Map<Quota.Scope, ValidatedQuotaDTO> mergeMaps(Map<Quota.Scope, QuotaCount> counts, Map<Quota.Scope, QuotaSize> sizes) {
+ private Map<Quota.Scope, ValidatedQuotaDTO> mergeMaps(Map<Quota.Scope, QuotaCountLimit> counts, Map<Quota.Scope, QuotaSizeLimit> sizes) {
return Sets.union(counts.keySet(), sizes.keySet())
.stream()
.collect(Collectors.toMap(Function.identity(),
@@ -114,11 +114,11 @@ public class UserQuotaService {
}
- public Optional<QuotaSize> getMaxSizeQuota(Username username) throws MailboxException {
+ public Optional<QuotaSizeLimit> getMaxSizeQuota(Username username) throws MailboxException {
return maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(username));
}
- public void defineMaxSizeQuota(Username username, QuotaSize quotaSize) throws MailboxException {
+ public void defineMaxSizeQuota(Username username, QuotaSizeLimit quotaSize) throws MailboxException {
maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(username), quotaSize);
}
@@ -126,11 +126,11 @@ public class UserQuotaService {
maxQuotaManager.removeMaxStorage(userQuotaRootResolver.forUser(username));
}
- public Optional<QuotaCount> getMaxCountQuota(Username username) throws MailboxException {
+ public Optional<QuotaCountLimit> getMaxCountQuota(Username username) throws MailboxException {
return maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(username));
}
- public void defineMaxCountQuota(Username username, QuotaCount quotaCount) throws MailboxException {
+ public void defineMaxCountQuota(Username username, QuotaCountLimit quotaCount) throws MailboxException {
maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(username), quotaCount);
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/QuotaDTOValidator.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/QuotaDTOValidator.java
index 63de521..b8f5a55 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/QuotaDTOValidator.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/QuotaDTOValidator.java
@@ -20,8 +20,8 @@ package org.apache.james.webadmin.validation;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.webadmin.dto.QuotaDTO;
import org.apache.james.webadmin.dto.ValidatedQuotaDTO;
import org.apache.james.webadmin.utils.ErrorResponder;
@@ -33,9 +33,9 @@ public class QuotaDTOValidator {
public ValidatedQuotaDTO validatedQuotaDTO(QuotaDTO quotaDTO) {
try {
- Optional<QuotaCount> count = quotaDTO.getCount()
+ Optional<QuotaCountLimit> count = quotaDTO.getCount()
.map(this::getQuotaCount);
- Optional<QuotaSize> size = quotaDTO.getSize()
+ Optional<QuotaSizeLimit> size = quotaDTO.getSize()
.map(this::getQuotaSize);
return ValidatedQuotaDTO.builder()
@@ -52,19 +52,19 @@ public class QuotaDTOValidator {
}
}
- private QuotaSize getQuotaSize(Long quotaValue) {
+ private QuotaSizeLimit getQuotaSize(Long quotaValue) {
if (quotaValue == UNLIMITED) {
- return QuotaSize.unlimited();
+ return QuotaSizeLimit.unlimited();
} else {
- return QuotaSize.size(quotaValue);
+ return QuotaSizeLimit.size(quotaValue);
}
}
- private QuotaCount getQuotaCount(Long quotaValue) {
+ private QuotaCountLimit getQuotaCount(Long quotaValue) {
if (quotaValue == UNLIMITED) {
- return QuotaCount.unlimited();
+ return QuotaCountLimit.unlimited();
} else {
- return QuotaCount.count(quotaValue);
+ return QuotaCountLimit.count(quotaValue);
}
}
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/Quotas.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/Quotas.java
index 5843082..3f79a6f 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/Quotas.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/validation/Quotas.java
@@ -21,23 +21,23 @@ package org.apache.james.webadmin.validation;
import java.util.Optional;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.webadmin.utils.ErrorResponder;
import org.eclipse.jetty.http.HttpStatus;
public abstract class Quotas {
- public static QuotaCount quotaCount(String serialized) {
+ public static QuotaCountLimit quotaCount(String serialized) {
return minusOneToEmpty(parseToLong(serialized))
- .map(QuotaCount::count)
- .orElse(QuotaCount.unlimited());
+ .map(QuotaCountLimit::count)
+ .orElse(QuotaCountLimit.unlimited());
}
- public static QuotaSize quotaSize(String serialized) {
+ public static QuotaSizeLimit quotaSize(String serialized) {
return minusOneToEmpty(parseToLong(serialized))
- .map(QuotaSize::size)
- .orElse(QuotaSize.unlimited());
+ .map(QuotaSizeLimit::size)
+ .orElse(QuotaSizeLimit.unlimited());
}
private static Optional<Long> minusOneToEmpty(long value) {
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/QuotaValueDeserializerTest.java b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/QuotaLimitValueDeserializerTest.java
similarity index 77%
rename from server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/QuotaValueDeserializerTest.java
rename to server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/QuotaLimitValueDeserializerTest.java
index fd0d679..f953b6b 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/QuotaValueDeserializerTest.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/QuotaLimitValueDeserializerTest.java
@@ -18,8 +18,8 @@
****************************************************************/
package org.apache.james.webadmin.dto;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.webadmin.utils.JsonExtractException;
import org.apache.james.webadmin.utils.JsonExtractor;
import org.assertj.core.api.Assertions;
@@ -27,22 +27,22 @@ import org.junit.jupiter.api.Test;
import com.fasterxml.jackson.databind.module.SimpleModule;
-class QuotaValueDeserializerTest {
+class QuotaLimitValueDeserializerTest {
@Test
void objectDeserializeShouldContainGivenValues() throws JsonExtractException {
String payload = "{\"count\":52,\"size\":42}";
ValidatedQuotaDTO actual = new JsonExtractor<>(ValidatedQuotaDTO.class,
new SimpleModule()
- .addDeserializer(QuotaCount.class, new QuotaValueDeserializer<>(QuotaCount.unlimited(), QuotaCount::count))
- .addDeserializer(QuotaSize.class, new QuotaValueDeserializer<>(QuotaSize.unlimited(), QuotaSize::size))
+ .addDeserializer(QuotaCountLimit.class, new QuotaValueDeserializer<>(QuotaCountLimit.unlimited(), QuotaCountLimit::count))
+ .addDeserializer(QuotaSizeLimit.class, new QuotaValueDeserializer<>(QuotaSizeLimit.unlimited(), QuotaSizeLimit::size))
).parse(payload);
Assertions.assertThat(actual)
.isEqualTo(
ValidatedQuotaDTO
.builder()
- .count(java.util.Optional.of(QuotaCount.count(52)))
- .size(java.util.Optional.of(QuotaSize.size(42)))
+ .count(java.util.Optional.of(QuotaCountLimit.count(52)))
+ .size(java.util.Optional.of(QuotaSizeLimit.size(42)))
.build());
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/UsersQuotaDetailsDTOTest.java b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/UsersQuotaDetailsDTOTest.java
index c22d39d..5c3f497 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/UsersQuotaDetailsDTOTest.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/dto/UsersQuotaDetailsDTOTest.java
@@ -24,8 +24,10 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import javax.mail.internet.AddressException;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaCountUsage;
+import org.apache.james.core.quota.QuotaSizeLimit;
+import org.apache.james.core.quota.QuotaSizeUsage;
import org.apache.james.mailbox.model.Quota;
import org.junit.Test;
@@ -50,8 +52,8 @@ public class UsersQuotaDetailsDTOTest {
Username username = Username.of("user@domain.org");
QuotaDetailsDTO quotaDetailsDTO = QuotaDetailsDTO.builder()
.occupation(
- Quota.<QuotaSize>builder().used(QuotaSize.size(1)).computedLimit(QuotaSize.size(12)).build(),
- Quota.<QuotaCount>builder().used(QuotaCount.count(36)).computedLimit(QuotaCount.count(360)).build())
+ Quota.<QuotaSizeLimit, QuotaSizeUsage>builder().used(QuotaSizeUsage.size(1)).computedLimit(QuotaSizeLimit.size(12)).build(),
+ Quota.<QuotaCountLimit, QuotaCountUsage>builder().used(QuotaCountUsage.count(36)).computedLimit(QuotaCountLimit.count(360)).build())
.build();
UsersQuotaDetailsDTO usersQuotaDetailsDTO = UsersQuotaDetailsDTO.builder()
.user(username)
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/DomainQuotaRoutesTest.java b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/DomainQuotaRoutesTest.java
index df823e3..ecba53b 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/DomainQuotaRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/DomainQuotaRoutesTest.java
@@ -27,8 +27,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.Map;
import org.apache.james.core.Domain;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.eclipse.jetty.http.HttpStatus;
@@ -80,7 +80,7 @@ class DomainQuotaRoutesTest {
@Test
void getCountShouldReturnStoredValue() throws Exception {
int value = 42;
- maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCount.count(value));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(value));
Long actual =
given()
@@ -133,7 +133,7 @@ class DomainQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCount.unlimited());
+ assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCountLimit.unlimited());
}
@Test
@@ -163,7 +163,7 @@ class DomainQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCount.count(42));
+ assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCountLimit.count(42));
}
@Test
@@ -176,7 +176,7 @@ class DomainQuotaRoutesTest {
@Test
void deleteCountShouldSetQuotaToEmpty() throws Exception {
- maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCount.count(42));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(42));
given()
.delete(QUOTA_DOMAINS + "/" + FOUND_LOCAL.name() + "/" + COUNT)
@@ -205,7 +205,7 @@ class DomainQuotaRoutesTest {
@Test
void getSizeShouldReturnStoredValue() throws Exception {
long value = 42;
- maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSize.size(value));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.size(value));
long quota =
given()
@@ -258,7 +258,7 @@ class DomainQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSize.unlimited());
+ assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSizeLimit.unlimited());
}
@Test
@@ -289,7 +289,7 @@ class DomainQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSize.size(42));
+ assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSizeLimit.size(42));
}
@Test
@@ -302,7 +302,7 @@ class DomainQuotaRoutesTest {
@Test
void deleteSizeShouldSetQuotaToEmpty() throws Exception {
- maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSize.size(42));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.size(42));
given()
.delete(QUOTA_DOMAINS + "/" + FOUND_LOCAL.name() + "/" + SIZE)
@@ -338,7 +338,7 @@ class DomainQuotaRoutesTest {
@Test
void getQuotaShouldReturnSizeWhenNoCount() throws Exception {
int maxStorage = 42;
- maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSize.size(maxStorage));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.size(maxStorage));
String json =
given()
@@ -360,7 +360,7 @@ class DomainQuotaRoutesTest {
@Test
void getQuotaShouldReturnBothWhenNoSize() throws Exception {
int maxMessage = 42;
- maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCount.count(maxMessage));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(maxMessage));
String json =
given()
@@ -382,10 +382,10 @@ class DomainQuotaRoutesTest {
@Test
void getQuotaShouldDisplayScopesWhenUnlimited() throws Exception {
int maxMessage = 42;
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.unlimited());
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(42));
- maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCount.count(maxMessage));
- maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSize.unlimited());
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.unlimited());
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(42));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(maxMessage));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.unlimited());
String json =
given()
@@ -407,9 +407,9 @@ class DomainQuotaRoutesTest {
@Test
void getQuotaShouldDisplayScopedInformation() throws Exception {
int maxMessage = 42;
- maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCount.count(maxMessage));
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(32));
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(36));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(maxMessage));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(32));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(36));
String json =
given()
@@ -444,17 +444,17 @@ class DomainQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCount.count(52));
- assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSize.size(42));
+ assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCountLimit.count(52));
+ assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSizeLimit.size(42));
}
@Test
void putQuotaWithNegativeCountShouldFail() throws MailboxException {
- maxQuotaManager.setDomainMaxMessage(TROUVÉ_COM, QuotaCount.count(52));
- maxQuotaManager.setDomainMaxStorage(TROUVÉ_COM, QuotaSize.size(42));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(52));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.size(42));
Map<String, Object> errors = given()
.body("{\"count\":-5,\"size\":30}")
- .put(QUOTA_DOMAINS + "/" + TROUVÉ_COM.name())
+ .put(QUOTA_DOMAINS + "/" + FOUND_LOCAL.name())
.then()
.statusCode(HttpStatus.BAD_REQUEST_400)
.contentType(ContentType.JSON)
@@ -471,26 +471,26 @@ class DomainQuotaRoutesTest {
@Test
void putQuotaWithNegativeCountShouldNotUpdatePreviousQuota() throws MailboxException {
- maxQuotaManager.setDomainMaxMessage(TROUVÉ_COM, QuotaCount.count(52));
- maxQuotaManager.setDomainMaxStorage(TROUVÉ_COM, QuotaSize.size(42));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(52));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.size(42));
given()
.body("{\"count\":-5,\"size\":30}")
- .put(QUOTA_DOMAINS + "/" + TROUVÉ_COM.name())
+ .put(QUOTA_DOMAINS + "/" + FOUND_LOCAL.name())
.then()
.statusCode(HttpStatus.BAD_REQUEST_400)
.contentType(ContentType.JSON);
- assertThat(maxQuotaManager.getDomainMaxMessage(TROUVÉ_COM)).contains(QuotaCount.count(52));
- assertThat(maxQuotaManager.getDomainMaxStorage(TROUVÉ_COM)).contains(QuotaSize.size(42));
+ assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCountLimit.count(52));
+ assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSizeLimit.size(42));
}
@Test
void putQuotaWithNegativeSizeShouldFail() throws MailboxException {
- maxQuotaManager.setDomainMaxMessage(TROUVÉ_COM, QuotaCount.count(52));
- maxQuotaManager.setDomainMaxStorage(TROUVÉ_COM, QuotaSize.size(42));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(52));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.size(42));
Map<String, Object> errors = given()
.body("{\"count\":40,\"size\":-19}")
- .put(QUOTA_DOMAINS + "/" + TROUVÉ_COM.name())
+ .put(QUOTA_DOMAINS + "/" + FOUND_LOCAL.name())
.then()
.statusCode(HttpStatus.BAD_REQUEST_400)
.contentType(ContentType.JSON)
@@ -507,17 +507,17 @@ class DomainQuotaRoutesTest {
@Test
void putQuotaWithNegativeSizeShouldNotUpdatePreviousQuota() throws MailboxException {
- maxQuotaManager.setDomainMaxMessage(TROUVÉ_COM, QuotaCount.count(52));
- maxQuotaManager.setDomainMaxStorage(TROUVÉ_COM, QuotaSize.size(42));
+ maxQuotaManager.setDomainMaxMessage(FOUND_LOCAL, QuotaCountLimit.count(52));
+ maxQuotaManager.setDomainMaxStorage(FOUND_LOCAL, QuotaSizeLimit.size(42));
given()
.body("{\"count\":40,\"size\":-19}")
- .put(QUOTA_DOMAINS + "/" + TROUVÉ_COM.name())
+ .put(QUOTA_DOMAINS + "/" + FOUND_LOCAL.name())
.then()
.statusCode(HttpStatus.BAD_REQUEST_400)
.contentType(ContentType.JSON);
- assertThat(maxQuotaManager.getDomainMaxMessage(TROUVÉ_COM)).contains(QuotaCount.count(52));
- assertThat(maxQuotaManager.getDomainMaxStorage(TROUVÉ_COM)).contains(QuotaSize.size(42));
+ assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCountLimit.count(52));
+ assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSizeLimit.size(42));
}
@Test
@@ -554,7 +554,7 @@ class DomainQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSize.size(42));
+ assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).contains(QuotaSizeLimit.size(42));
assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).isEmpty();
}
@@ -574,7 +574,7 @@ class DomainQuotaRoutesTest {
.statusCode(HttpStatus.NO_CONTENT_204);
assertThat(maxQuotaManager.getDomainMaxStorage(FOUND_LOCAL)).isEmpty();
- assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCount.count(52));
+ assertThat(maxQuotaManager.getDomainMaxMessage(FOUND_LOCAL)).contains(QuotaCountLimit.count(52));
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/GlobalQuotaRoutesTest.java b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/GlobalQuotaRoutesTest.java
index 2132646..f721f8e 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/GlobalQuotaRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/routes/GlobalQuotaRoutesTest.java
@@ -25,8 +25,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.Map;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.assertj.core.api.SoftAssertions;
import org.eclipse.jetty.http.HttpStatus;
@@ -60,7 +60,7 @@ class GlobalQuotaRoutesTest {
@Test
void getCountShouldReturnStoredValue() throws Exception {
int value = 42;
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(value));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(value));
Long actual =
when()
@@ -127,7 +127,7 @@ class GlobalQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCount.unlimited());
+ assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCountLimit.unlimited());
}
@Test
@@ -139,12 +139,12 @@ class GlobalQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCount.count(42));
+ assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCountLimit.count(42));
}
@Test
void deleteCountShouldSetQuotaToUnlimited() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(42));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(42));
when()
.delete("/quota/count")
@@ -165,7 +165,7 @@ class GlobalQuotaRoutesTest {
@Test
void getSizeShouldReturnStoredValue() throws Exception {
long value = 42;
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(value));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(value));
long quota =
@@ -212,7 +212,7 @@ class GlobalQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSize.unlimited());
+ assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSizeLimit.unlimited());
}
@Test
@@ -246,12 +246,12 @@ class GlobalQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSize.size(42));
+ assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSizeLimit.size(42));
}
@Test
void deleteSizeShouldSetQuotaToUnlimited() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(42));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(42));
when()
.delete("/quota/count")
@@ -265,8 +265,8 @@ class GlobalQuotaRoutesTest {
void getQuotaShouldReturnBothWhenValueSpecified() throws Exception {
int maxStorage = 42;
int maxMessage = 52;
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(maxStorage));
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(maxMessage));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(maxStorage));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(maxMessage));
JsonPath jsonPath =
when()
@@ -302,7 +302,7 @@ class GlobalQuotaRoutesTest {
@Test
void getQuotaShouldReturnOnlySizeWhenNoCount() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(42));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(42));
JsonPath jsonPath =
when()
@@ -322,7 +322,7 @@ class GlobalQuotaRoutesTest {
@Test
void getQuotaShouldReturnOnlyCountWhenNoSize() throws Exception {
int maxMessage = 42;
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(maxMessage));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(maxMessage));
JsonPath jsonPath =
@@ -350,8 +350,8 @@ class GlobalQuotaRoutesTest {
.statusCode(HttpStatus.NO_CONTENT_204);
SoftAssertions softly = new SoftAssertions();
- softly.assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCount.count(52));
- softly.assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSize.size(42));
+ softly.assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCountLimit.count(52));
+ softly.assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSizeLimit.size(42));
softly.assertAll();
}
@@ -365,15 +365,15 @@ class GlobalQuotaRoutesTest {
.statusCode(HttpStatus.NO_CONTENT_204);
SoftAssertions softly = new SoftAssertions();
- softly.assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCount.unlimited());
- softly.assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSize.unlimited());
+ softly.assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCountLimit.unlimited());
+ softly.assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSizeLimit.unlimited());
softly.assertAll();
}
@Test
void putQuotaWithNegativeCountShouldFail() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(42));
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(43));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(42));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(43));
Map<String, Object> errors = given()
.body("{\"count\":-2,\"size\":43}")
@@ -395,8 +395,8 @@ class GlobalQuotaRoutesTest {
@Test
void putQuotaWithNegativeCountShouldNotUpdatePreviousQuota() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(42));
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(43));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(42));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(43));
given()
.body("{\"count\":-2,\"size\":43}")
@@ -406,14 +406,14 @@ class GlobalQuotaRoutesTest {
.statusCode(HttpStatus.BAD_REQUEST_400)
.contentType(ContentType.JSON);
- assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCount.count(42));
- assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSize.size(43));
+ assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCountLimit.count(42));
+ assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSizeLimit.size(43));
}
@Test
void putQuotaWithNegativeSizeShouldFail() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(42));
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(43));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(42));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(43));
Map<String, Object> errors = given()
.body("{\"count\":42,\"size\":-2}")
@@ -435,8 +435,8 @@ class GlobalQuotaRoutesTest {
@Test
void putQuotaWithNegativeSizeShouldNotUpdatePreviousQuota() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(42));
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(43));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(42));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(43));
given()
.body("{\"count\":42,\"size\":-2}")
@@ -446,13 +446,13 @@ class GlobalQuotaRoutesTest {
.statusCode(HttpStatus.BAD_REQUEST_400)
.contentType(ContentType.JSON);
- assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCount.count(42));
- assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSize.size(43));
+ assertThat(maxQuotaManager.getGlobalMaxMessage()).contains(QuotaCountLimit.count(42));
+ assertThat(maxQuotaManager.getGlobalMaxStorage()).contains(QuotaSizeLimit.size(43));
}
@Test
void putQuotaShouldUnsetCountWhenNull() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(42));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(42));
given()
.body("{\"count\":null,\"size\":43}")
.when()
@@ -465,7 +465,7 @@ class GlobalQuotaRoutesTest {
@Test
void putQuotaShouldUnsetSizeWhenNull() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(44));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(44));
given()
.body("{\"count\":45,\"size\":null}")
.when()
@@ -478,7 +478,7 @@ class GlobalQuotaRoutesTest {
@Test
void putQuotaShouldUnsetCountWhenAbsent() throws Exception {
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(42));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(42));
given()
.body("{\"size\":43}")
.when()
@@ -491,7 +491,7 @@ class GlobalQuotaRoutesTest {
@Test
void putQuotaShouldUnsetSizeWhenAbsent() throws Exception {
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(44));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(44));
given()
.body("{\"count\":45}")
.when()
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 8841e27..c98a4fd 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
@@ -35,8 +35,8 @@ import java.util.Map;
import org.apache.james.core.Domain;
import org.apache.james.core.Username;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.apache.james.domainlist.api.DomainList;
import org.apache.james.mailbox.MailboxManager;
import org.apache.james.mailbox.MailboxSession;
@@ -175,7 +175,7 @@ class UserQuotaRoutesTest {
default void getUsersQuotaShouldFilterOnMinOccupationRatio(WebAdminQuotaSearchTestSystem testSystem) throws Exception {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(100));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem.getQuotaSearchTestSystem(), BOB, withSize(49));
appendMessage(testSystem.getQuotaSearchTestSystem(), JACK, withSize(50));
appendMessage(testSystem.getQuotaSearchTestSystem(), GUY_WITH_STRANGE_DOMAIN, withSize(51));
@@ -198,7 +198,7 @@ class UserQuotaRoutesTest {
default void getUsersQuotaShouldFilterOnMaxOccupationRatio(WebAdminQuotaSearchTestSystem testSystem) throws Exception {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(100));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem.getQuotaSearchTestSystem(), BOB, withSize(49));
appendMessage(testSystem.getQuotaSearchTestSystem(), JACK, withSize(50));
appendMessage(testSystem.getQuotaSearchTestSystem(), GUY_WITH_STRANGE_DOMAIN, withSize(51));
@@ -221,7 +221,7 @@ class UserQuotaRoutesTest {
default void getUsersQuotaShouldOrderByUsername(WebAdminQuotaSearchTestSystem testSystem) throws Exception {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(100));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem.getQuotaSearchTestSystem(), GUY_WITH_STRANGE_DOMAIN, withSize(51));
appendMessage(testSystem.getQuotaSearchTestSystem(), JACK, withSize(50));
appendMessage(testSystem.getQuotaSearchTestSystem(), BOB, withSize(49));
@@ -385,7 +385,7 @@ class UserQuotaRoutesTest {
default void getUsersQuotaShouldReturnUserDetails(WebAdminQuotaSearchTestSystem testSystem) throws Exception {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(100));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(100));
appendMessage(testSystem.getQuotaSearchTestSystem(), BOB, withSize(10));
appendMessage(testSystem.getQuotaSearchTestSystem(), JACK, withSize(11));
appendMessage(testSystem.getQuotaSearchTestSystem(), GUY_WITH_STRANGE_DOMAIN, withSize(50));
@@ -487,7 +487,7 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(value));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(value));
Long actual =
given()
@@ -527,7 +527,7 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(value));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(value));
long quota =
@@ -597,7 +597,7 @@ class UserQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB))).contains(QuotaCount.unlimited());
+ assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB))).contains(QuotaCountLimit.unlimited());
}
@Test
@@ -630,7 +630,7 @@ class UserQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB))).contains(QuotaCount.count(42));
+ assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB))).contains(QuotaCountLimit.count(42));
}
@Test
@@ -704,7 +704,7 @@ class UserQuotaRoutesTest {
.statusCode(HttpStatus.NO_CONTENT_204);
assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaSize.unlimited());
+ .contains(QuotaSizeLimit.unlimited());
}
@Test
@@ -737,7 +737,7 @@ class UserQuotaRoutesTest {
.then()
.statusCode(HttpStatus.NO_CONTENT_204);
- assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB))).contains(QuotaSize.size(42));
+ assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB))).contains(QuotaSizeLimit.size(42));
}
}
@@ -757,7 +757,7 @@ class UserQuotaRoutesTest {
void deleteCountShouldSetQuotaToEmpty(WebAdminQuotaSearchTestSystem testSystem) throws Exception {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(42));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(42));
with()
.delete(QUOTA_USERS + "/" + BOB.asString() + "/" + COUNT)
@@ -784,7 +784,7 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
with()
.delete(QUOTA_USERS + "/" + BOB.asString() + "/" + SIZE)
@@ -811,12 +811,12 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(1111));
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(22));
- maxQuotaManager.setDomainMaxStorage(Domain.of(LOST_LOCAL), QuotaSize.size(34));
- maxQuotaManager.setDomainMaxMessage(Domain.of(LOST_LOCAL), QuotaCount.count(23));
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(52));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(1111));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(22));
+ maxQuotaManager.setDomainMaxStorage(Domain.of(LOST_LOCAL), QuotaSizeLimit.size(34));
+ maxQuotaManager.setDomainMaxMessage(Domain.of(LOST_LOCAL), QuotaCountLimit.count(23));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(52));
JsonPath jsonPath =
when()
@@ -845,8 +845,8 @@ class UserQuotaRoutesTest {
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
InMemoryCurrentQuotaManager currentQuotaManager = testSystem.getQuotaSearchTestSystem().getCurrentQuotaManager();
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(80));
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(100));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(80));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(100));
currentQuotaManager.increase(userQuotaRootResolver.forUser(BOB), 20, 40);
JsonPath jsonPath =
@@ -873,8 +873,8 @@ class UserQuotaRoutesTest {
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
InMemoryCurrentQuotaManager currentQuotaManager = testSystem.getQuotaSearchTestSystem().getCurrentQuotaManager();
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.unlimited());
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.unlimited());
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.unlimited());
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.unlimited());
currentQuotaManager.increase(userQuotaRootResolver.forUser(BOB), 20, 40);
JsonPath jsonPath =
@@ -900,9 +900,9 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(1111));
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(18));
- maxQuotaManager.setDomainMaxMessage(Domain.of(LOST_LOCAL), QuotaCount.count(52));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(1111));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(18));
+ maxQuotaManager.setDomainMaxMessage(Domain.of(LOST_LOCAL), QuotaCountLimit.count(52));
JsonPath jsonPath =
when()
@@ -929,8 +929,8 @@ class UserQuotaRoutesTest {
public void getQuotaShouldReturnGlobalValuesWhenNoUserValuesDefined(WebAdminQuotaSearchTestSystem testSystem) throws Exception {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
- maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(1111));
- maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(12));
+ maxQuotaManager.setGlobalMaxStorage(QuotaSizeLimit.size(1111));
+ maxQuotaManager.setGlobalMaxMessage(QuotaCountLimit.count(12));
JsonPath jsonPath =
when()
@@ -958,8 +958,8 @@ class UserQuotaRoutesTest {
int maxStorage = 42;
int maxMessage = 52;
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(maxStorage));
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(maxMessage));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(maxStorage));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(maxMessage));
JsonPath jsonPath =
when()
@@ -999,7 +999,7 @@ class UserQuotaRoutesTest {
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
int maxStorage = 42;
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(maxStorage));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(maxStorage));
JsonPath jsonPath =
when()
@@ -1022,7 +1022,7 @@ class UserQuotaRoutesTest {
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
int maxMessage = 42;
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(maxMessage));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(maxMessage));
JsonPath jsonPath =
@@ -1058,8 +1058,8 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(52));
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(52));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
Map<String, Object> errors = with()
.body("{\"count\":-2,\"size\":42}")
@@ -1083,8 +1083,8 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(52));
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(52));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
with()
.body("{\"count\":-2,\"size\":42}")
@@ -1095,9 +1095,9 @@ class UserQuotaRoutesTest {
SoftAssertions softly = new SoftAssertions();
softly.assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaCount.count(52));
+ .contains(QuotaCountLimit.count(52));
softly.assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaSize.size(42));
+ .contains(QuotaSizeLimit.size(42));
softly.assertAll();
}
@@ -1106,8 +1106,8 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(52));
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(52));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
Map<String, Object> errors = with()
.body("{\"count\":52,\"size\":-3}")
@@ -1131,8 +1131,8 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(52));
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(52));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
with()
.body("{\"count\":52,\"size\":-3}")
@@ -1143,9 +1143,9 @@ class UserQuotaRoutesTest {
SoftAssertions softly = new SoftAssertions();
softly.assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaCount.count(52));
+ .contains(QuotaCountLimit.count(52));
softly.assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaSize.size(42));
+ .contains(QuotaSizeLimit.size(42));
softly.assertAll();
}
@@ -1162,9 +1162,9 @@ class UserQuotaRoutesTest {
SoftAssertions softly = new SoftAssertions();
softly.assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaCount.count(52));
+ .contains(QuotaCountLimit.count(52));
softly.assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaSize.size(42));
+ .contains(QuotaSizeLimit.size(42));
softly.assertAll();
}
@@ -1181,9 +1181,9 @@ class UserQuotaRoutesTest {
SoftAssertions softly = new SoftAssertions();
softly.assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaCount.count(52));
+ .contains(QuotaCountLimit.count(52));
softly.assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaSize.size(42));
+ .contains(QuotaSizeLimit.size(42));
softly.assertAll();
}
@@ -1192,7 +1192,7 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCount.count(52));
+ maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(BOB), QuotaCountLimit.count(52));
with()
.body("{\"count\":null,\"size\":42}")
@@ -1204,7 +1204,7 @@ class UserQuotaRoutesTest {
softly.assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB)))
.isEmpty();
softly.assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaSize.size(42));
+ .contains(QuotaSizeLimit.size(42));
softly.assertAll();
}
@@ -1213,7 +1213,7 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
with()
.body("{\"count\":52,\"size\":null}")
@@ -1223,7 +1223,7 @@ class UserQuotaRoutesTest {
SoftAssertions softly = new SoftAssertions();
softly.assertThat(maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(BOB)))
- .contains(QuotaCount.count(52));
+ .contains(QuotaCountLimit.count(52));
softly.assertThat(maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(BOB)))
.isEmpty();
softly.assertAll();
@@ -1234,7 +1234,7 @@ class UserQuotaRoutesTest {
MaxQuotaManager maxQuotaManager = testSystem.getQuotaSearchTestSystem().getMaxQuotaManager();
UserQuotaRootResolver userQuotaRootResolver = testSystem.getQuotaSearchTestSystem().getQuotaRootResolver();
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSize.size(42));
+ maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(BOB), QuotaSizeLimit.size(42));
with()
.body("{\"count\":null,\"size\":null}")
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/validation/QuotaValueTest.java b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/validation/QuotaLimitValueTest.java
similarity index 92%
rename from server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/validation/QuotaValueTest.java
rename to server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/validation/QuotaLimitValueTest.java
index 23f88ce..4535f39 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/validation/QuotaValueTest.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/test/java/org/apache/james/webadmin/validation/QuotaLimitValueTest.java
@@ -22,13 +22,13 @@ package org.apache.james.webadmin.validation;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import org.apache.james.core.quota.QuotaCount;
-import org.apache.james.core.quota.QuotaSize;
+import org.apache.james.core.quota.QuotaCountLimit;
+import org.apache.james.core.quota.QuotaSizeLimit;
import org.junit.jupiter.api.Test;
import spark.HaltException;
-class QuotaValueTest {
+class QuotaLimitValueTest {
@Test
void quotaCountShouldThrowWhenNotANumber() {
@@ -50,7 +50,7 @@ class QuotaValueTest {
@Test
void quotaCountShouldBeUnlimitedOnMinusOne() {
- assertThat(Quotas.quotaCount("-1")).isEqualTo(QuotaCount.unlimited());
+ assertThat(Quotas.quotaCount("-1")).isEqualTo(QuotaCountLimit.unlimited());
}
@Test
@@ -79,7 +79,7 @@ class QuotaValueTest {
@Test
void quotaSizeShouldBeUnlimitedOnMinusOne() {
- assertThat(Quotas.quotaSize("-1")).isEqualTo(QuotaSize.unlimited());
+ assertThat(Quotas.quotaSize("-1")).isEqualTo(QuotaSizeLimit.unlimited());
}
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org