http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/memory/src/main/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManager.java ---------------------------------------------------------------------- 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 8f41f66..15cfe8a 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 @@ -19,66 +19,88 @@ package org.apache.james.mailbox.inmemory.quota; import java.util.Map; +import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import org.apache.james.mailbox.exception.MailboxException; -import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; import org.apache.james.mailbox.quota.MaxQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager { - private long maxMessage = Quota.UNLIMITED; - private long maxStorage = Quota.UNLIMITED; + private Optional<QuotaCount> maxMessage = Optional.empty(); + private Optional<QuotaSize> maxStorage = Optional.empty(); - private final Map<String, Long> userMaxStorage = new ConcurrentHashMap<>(); - private final Map<String, Long> userMaxMessage = new ConcurrentHashMap<>(); + private final Map<String, QuotaSize> userMaxStorage = new ConcurrentHashMap<>(); + private final Map<String, QuotaCount> userMaxMessage = new ConcurrentHashMap<>(); @Override - public void setDefaultMaxStorage(long maxStorage) throws MailboxException { - this.maxStorage = maxStorage; + public void setDefaultMaxStorage(QuotaSize maxStorage) throws MailboxException { + this.maxStorage = Optional.of(maxStorage); } @Override - public void setDefaultMaxMessage(long maxMessage) throws MailboxException { - this.maxMessage = maxMessage; + public void setDefaultMaxMessage(QuotaCount maxMessage) throws MailboxException { + this.maxMessage = Optional.of(maxMessage); } @Override - public long getMaxStorage(QuotaRoot quotaRoot) throws MailboxException { - Long max = userMaxStorage.get(quotaRoot.getValue()); + public Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) throws MailboxException { + QuotaSize max = userMaxStorage.get(quotaRoot.getValue()); if (max == null) { return maxStorage; } - return max; + return Optional.of(max); } @Override - public long getMaxMessage(QuotaRoot quotaRoot) throws MailboxException { - Long max = userMaxMessage.get(quotaRoot.getValue()); + public Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) throws MailboxException { + QuotaCount max = userMaxMessage.get(quotaRoot.getValue()); if (max == null) { return maxMessage; } - return max; + return Optional.of(max); } @Override - public void setMaxStorage(QuotaRoot user, long maxStorageQuota) { + public void setMaxStorage(QuotaRoot user, QuotaSize maxStorageQuota) { userMaxStorage.put(user.getValue(), maxStorageQuota); } @Override - public void setMaxMessage(QuotaRoot quotaRoot, long maxMessageCount) { + public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) { userMaxMessage.put(quotaRoot.getValue(), maxMessageCount); } @Override - public long getDefaultMaxStorage() throws MailboxException { + public Optional<QuotaSize> getDefaultMaxStorage() throws MailboxException { return maxStorage; } @Override - public long getDefaultMaxMessage() throws MailboxException { + public Optional<QuotaCount> getDefaultMaxMessage() throws MailboxException { return maxMessage; } + + @Override + public void removeMaxMessage(QuotaRoot quotaRoot) throws MailboxException { + userMaxMessage.remove(quotaRoot.getValue()); + } + + @Override + public void removeMaxStorage(QuotaRoot quotaRoot) throws MailboxException { + userMaxStorage.remove(quotaRoot.getValue()); + } + + @Override + public void removeDefaultMaxStorage() throws MailboxException { + maxStorage = Optional.empty(); + } + + @Override + public void removeDefaultMaxMessage() throws MailboxException { + maxMessage = Optional.empty(); + } }
http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryCurrentQuotaManagerTest.java ---------------------------------------------------------------------- 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 abc5cdb..8331d20 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,6 +25,8 @@ import static org.mockito.Mockito.when; import org.apache.james.mailbox.MailboxManager; import org.apache.james.mailbox.model.QuotaRoot; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.quota.CurrentQuotaCalculator; import org.junit.Before; import org.junit.Test; @@ -48,7 +50,7 @@ public class InMemoryCurrentQuotaManagerTest { when(mockedCurrentQuotaCalculator.recalculateCurrentQuotas(QUOTA_ROOT, null)) .thenReturn(new CurrentQuotaCalculator.CurrentQuotas(18, 512)); - assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(18); + assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(18)); } @Test @@ -56,7 +58,7 @@ public class InMemoryCurrentQuotaManagerTest { when(mockedCurrentQuotaCalculator.recalculateCurrentQuotas(QUOTA_ROOT, null)) .thenReturn(new CurrentQuotaCalculator.CurrentQuotas(18, 512)); - assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(512); + assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(512)); } @Test @@ -66,8 +68,8 @@ public class InMemoryCurrentQuotaManagerTest { testee.increase(QUOTA_ROOT, 10, 100); - assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(28); - assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(612); + assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(28)); + assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(612)); } @Test(expected = IllegalArgumentException.class) http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/model/SerializableQuota.java ---------------------------------------------------------------------- diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/model/SerializableQuota.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/model/SerializableQuota.java index a636677..25370be 100644 --- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/model/SerializableQuota.java +++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/mail/model/SerializableQuota.java @@ -20,29 +20,44 @@ package org.apache.james.mailbox.store.mail.model; import java.io.Serializable; +import java.util.Optional; import org.apache.james.mailbox.model.Quota; +import org.apache.james.mailbox.quota.QuotaValue; -public class SerializableQuota implements Serializable { +public class SerializableQuota<T extends QuotaValue<T>> implements Serializable { - private final long max; - private final long used; + public static final long UNLIMITED = -1; - public SerializableQuota(long max, long used) { + private final Long max; + private final Long used; + + public SerializableQuota(Long max, Long used) { this.max = max; this.used = used; } - public SerializableQuota(Quota quota) { - this.max = quota.getMax(); - this.used = quota.getUsed(); + public SerializableQuota(Quota<T> quota) { + this.max = encodeAsLong(quota.getMax()); + this.used = getUsed(quota.getUsed()); + } + + private Long getUsed(Optional<T> quota) { + return quota.map(this::encodeAsLong).orElse(null); + } + + private Long encodeAsLong(T quota) { + if (quota.isLimited()) { + return quota.asLong(); + } + return UNLIMITED; } - public long getMax() { + public Long encodeAsLong() { return max; } - public long getUsed() { + public Long getUsed() { return used; } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/main/java/org/apache/james/mailbox/store/probe/QuotaProbe.java ---------------------------------------------------------------------- diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/probe/QuotaProbe.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/probe/QuotaProbe.java index e5eec3f..ec242be 100644 --- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/probe/QuotaProbe.java +++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/probe/QuotaProbe.java @@ -19,31 +19,35 @@ package org.apache.james.mailbox.store.probe; +import java.util.Optional; + import org.apache.james.mailbox.exception.MailboxException; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.mail.model.SerializableQuota; public interface QuotaProbe { String getQuotaRoot(String namespace, String user, String name) throws MailboxException; - SerializableQuota getMessageCountQuota(String quotaRoot) throws MailboxException; + SerializableQuota<QuotaCount> getMessageCountQuota(String quotaRoot) throws MailboxException; - SerializableQuota getStorageQuota(String quotaRoot) throws MailboxException; + SerializableQuota<QuotaSize> getStorageQuota(String quotaRoot) throws MailboxException; - long getMaxMessageCount(String quotaRoot) throws MailboxException; + Optional<QuotaCount> getMaxMessageCount(String quotaRoot) throws MailboxException; - long getMaxStorage(String quotaRoot) throws MailboxException; + Optional<QuotaSize> getMaxStorage(String quotaRoot) throws MailboxException; - long getDefaultMaxMessageCount() throws MailboxException; + Optional<QuotaCount> getDefaultMaxMessageCount() throws MailboxException; - long getDefaultMaxStorage() throws MailboxException; + Optional<QuotaSize> getDefaultMaxStorage() throws MailboxException; - void setMaxMessageCount(String quotaRoot, long maxMessageCount) throws MailboxException; + void setMaxMessageCount(String quotaRoot, QuotaCount maxMessageCount) throws MailboxException; - void setMaxStorage(String quotaRoot, long maxSize) throws MailboxException; + void setMaxStorage(String quotaRoot, QuotaSize maxSize) throws MailboxException; - void setDefaultMaxMessageCount(long maxDefaultMessageCount) throws MailboxException; + void setDefaultMaxMessageCount(QuotaCount maxDefaultMessageCount) throws MailboxException; - void setDefaultMaxStorage(long maxDefaultSize) throws MailboxException; + void setDefaultMaxStorage(QuotaSize maxDefaultSize) throws MailboxException; } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/FixedMaxQuotaManager.java ---------------------------------------------------------------------- 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 6e64b52..9fb0f47 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 @@ -1,10 +1,13 @@ package org.apache.james.mailbox.store.quota; +import java.util.Optional; + import org.apache.james.mailbox.exception.MailboxException; import org.apache.james.mailbox.exception.UnsupportedOperationException; -import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; import org.apache.james.mailbox.quota.MaxQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; /** * {@link MaxQuotaManager} which use the same quota for all users. @@ -12,38 +15,67 @@ import org.apache.james.mailbox.quota.MaxQuotaManager; * By default this means not quota at all */ public class FixedMaxQuotaManager implements MaxQuotaManager { - private long maxStorage = Quota.UNLIMITED; - private long maxMessage = Quota.UNLIMITED; - public void setMaxStorage(QuotaRoot quotaRoot, long maxStorageQuota) throws MailboxException { + private Optional<QuotaSize> maxStorage = Optional.empty(); + private Optional<QuotaCount> maxMessage = Optional.empty(); + + @Override + public void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) throws MailboxException { throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); } - public void setMaxMessage(QuotaRoot quotaRoot, long maxMessageCount) throws MailboxException { + @Override + public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) throws MailboxException { + throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); + } + + @Override + public void removeMaxMessage(QuotaRoot quotaRoot) throws MailboxException { + throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); + } + + @Override + public void removeMaxStorage(QuotaRoot quotaRoot) throws MailboxException { + throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); + } + + @Override + public void setDefaultMaxStorage(QuotaSize defaultMaxStorage) { + maxStorage = Optional.of(defaultMaxStorage); + } + + @Override + public void removeDefaultMaxStorage() throws MailboxException { throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); } - public void setDefaultMaxStorage(long defaultMaxStorage) { - maxStorage = defaultMaxStorage; + @Override + public void removeDefaultMaxMessage() { + maxMessage = Optional.empty(); } - public void setDefaultMaxMessage(long defaultMaxMessageCount) { - maxMessage = defaultMaxMessageCount; + @Override + public void setDefaultMaxMessage(QuotaCount defaultMaxMessageCount) { + maxMessage = Optional.empty(); } - public long getMaxStorage(QuotaRoot quotaRoot) throws MailboxException { + @Override + public Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) { return maxStorage; } - public long getMaxMessage(QuotaRoot quotaRoot) throws MailboxException { + @Override + public Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) { return maxMessage; } - public long getDefaultMaxStorage() throws MailboxException { + @Override + public Optional<QuotaSize> getDefaultMaxStorage() { return maxStorage; } - public long getDefaultMaxMessage() throws MailboxException { + @Override + public Optional<QuotaCount> getDefaultMaxMessage() { return maxMessage; } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoMaxQuotaManager.java ---------------------------------------------------------------------- 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 6b28e98..239439b 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 @@ -19,10 +19,13 @@ package org.apache.james.mailbox.store.quota; +import java.util.Optional; + import org.apache.james.mailbox.exception.MailboxException; -import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; import org.apache.james.mailbox.quota.MaxQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; /** * A Max Quota Manager that simply throws exceptions @@ -32,42 +35,62 @@ import org.apache.james.mailbox.quota.MaxQuotaManager; public class NoMaxQuotaManager implements MaxQuotaManager { @Override - public void setMaxStorage(QuotaRoot quotaRoot, long maxStorageQuota) throws MailboxException { + public void setMaxStorage(QuotaRoot quotaRoot, QuotaSize maxStorageQuota) throws MailboxException { + throw new MailboxException("Operation is not supported"); + } + + @Override + public void setMaxMessage(QuotaRoot quotaRoot, QuotaCount maxMessageCount) throws MailboxException { + throw new MailboxException("Operation is not supported"); + } + + @Override + public void removeMaxMessage(QuotaRoot quotaRoot) throws MailboxException { + throw new MailboxException("Operation is not supported"); + } + + @Override + public void removeMaxStorage(QuotaRoot quotaRoot) throws MailboxException { + throw new MailboxException("Operation is not supported"); + } + + @Override + public void setDefaultMaxStorage(QuotaSize defaultMaxStorage) throws MailboxException { throw new MailboxException("Operation is not supported"); } @Override - public void setMaxMessage(QuotaRoot quotaRoot, long maxMessageCount) throws MailboxException { + public void removeDefaultMaxStorage() throws MailboxException { throw new MailboxException("Operation is not supported"); } @Override - public void setDefaultMaxStorage(long defaultMaxStorage) throws MailboxException { + public void removeDefaultMaxMessage() throws MailboxException { throw new MailboxException("Operation is not supported"); } @Override - public void setDefaultMaxMessage(long defaultMaxMessageCount) throws MailboxException { + public void setDefaultMaxMessage(QuotaCount defaultMaxMessageCount) throws MailboxException { throw new MailboxException("Operation is not supported"); } @Override - public long getMaxStorage(QuotaRoot quotaRoot) throws MailboxException { - return Quota.UNLIMITED; + public Optional<QuotaSize> getMaxStorage(QuotaRoot quotaRoot) { + return Optional.empty(); } @Override - public long getMaxMessage(QuotaRoot quotaRoot) throws MailboxException { - return Quota.UNLIMITED; + public Optional<QuotaCount> getMaxMessage(QuotaRoot quotaRoot) { + return Optional.empty(); } @Override - public long getDefaultMaxStorage() throws MailboxException { - return Quota.UNLIMITED; + public Optional<QuotaSize> getDefaultMaxStorage() { + return Optional.empty(); } @Override - public long getDefaultMaxMessage() throws MailboxException { - return Quota.UNLIMITED; + public Optional<QuotaCount> getDefaultMaxMessage() { + return Optional.empty(); } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/NoQuotaManager.java ---------------------------------------------------------------------- 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 bebc32c..8f3f932 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 @@ -22,7 +22,9 @@ package org.apache.james.mailbox.store.quota; import org.apache.james.mailbox.exception.MailboxException; import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; +import org.apache.james.mailbox.quota.QuotaSize; /** * This quota manager is intended to be used when you want to deactivate the Quota feature @@ -30,12 +32,12 @@ import org.apache.james.mailbox.quota.QuotaManager; public class NoQuotaManager implements QuotaManager { @Override - public Quota getMessageQuota(QuotaRoot quotaRoot) throws MailboxException { - return Quota.unlimited(); + public Quota<QuotaCount> getMessageQuota(QuotaRoot quotaRoot) throws MailboxException { + return Quota.unknownUsedQuota(QuotaCount.unlimited()); } @Override - public Quota getStorageQuota(QuotaRoot quotaRoot) throws MailboxException { - return Quota.unlimited(); + public Quota<QuotaSize> getStorageQuota(QuotaRoot quotaRoot) throws MailboxException { + return Quota.unknownUsedQuota(QuotaSize.unlimited()); } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/QuotaChecker.java ---------------------------------------------------------------------- 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 9d46f1f..e7fc9bf 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 @@ -23,14 +23,16 @@ import org.apache.james.mailbox.exception.MailboxException; import org.apache.james.mailbox.exception.OverQuotaException; import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; import org.apache.james.mailbox.quota.QuotaRootResolver; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.mail.model.Mailbox; public class QuotaChecker { - private final Quota messageQuota; - private final Quota sizeQuota; + private final Quota<QuotaCount> messageQuota; + private final Quota<QuotaSize> sizeQuota; private final QuotaRoot quotaRoot; public QuotaChecker(QuotaManager quotaManager, QuotaRootResolver quotaRootResolver, Mailbox mailbox) throws MailboxException { @@ -39,26 +41,35 @@ public class QuotaChecker { this.sizeQuota = quotaManager.getStorageQuota(quotaRoot); } - public QuotaChecker(Quota messageQuota, Quota sizeQuota, QuotaRoot quotaRoot) { + public QuotaChecker(Quota<QuotaCount> messageQuota, Quota<QuotaSize> sizeQuota, QuotaRoot quotaRoot) { this.messageQuota = messageQuota; this.sizeQuota = sizeQuota; this.quotaRoot = quotaRoot; } - public boolean tryAddition(long count, long size) throws OverQuotaException { - messageQuota.addValueToQuota(count); - sizeQuota.addValueToQuota(size); - return check(); + public void tryAddition(long count, long size) throws OverQuotaException { + tryCountAddition(count); + trySizeAddition(size); } - private boolean check() throws OverQuotaException { - if (messageQuota.isOverQuota()) { - throw new OverQuotaException("You have too many messages in " + quotaRoot.getValue(), messageQuota.getMax(), messageQuota.getUsed()); + private void trySizeAddition(long size) throws OverQuotaException { + Quota<QuotaSize> afterAdditionQuotaSize = sizeQuota.addValueToQuota(QuotaSize.size(size)); + if (afterAdditionQuotaSize.isOverQuota()) { + throw new OverQuotaException( + "You use too much space in " + quotaRoot.getValue(), + afterAdditionQuotaSize.getMax(), + afterAdditionQuotaSize.getUsed().get()); } - if (sizeQuota.isOverQuota()) { - throw new OverQuotaException("You use too much space in " + quotaRoot.getValue(), sizeQuota.getMax(), sizeQuota.getUsed()); + } + + private void tryCountAddition(long count) throws OverQuotaException { + Quota<QuotaCount> afterAdditionQuotaCount = messageQuota.addValueToQuota(QuotaCount.count(count)); + if (afterAdditionQuotaCount.isOverQuota()) { + throw new OverQuotaException( + "You have too many messages in " + quotaRoot.getValue(), + messageQuota.getMax(), + messageQuota.getUsed().get()); } - return true; } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/main/java/org/apache/james/mailbox/store/quota/StoreQuotaManager.java ---------------------------------------------------------------------- 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 59dc23e..a4fd86b 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 @@ -19,6 +19,8 @@ package org.apache.james.mailbox.store.quota; +import java.util.Optional; + import javax.inject.Inject; import org.apache.james.mailbox.exception.MailboxException; @@ -26,7 +28,9 @@ import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; import org.apache.james.mailbox.quota.CurrentQuotaManager; import org.apache.james.mailbox.quota.MaxQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; +import org.apache.james.mailbox.quota.QuotaSize; /** * Default implementation for the Quota Manager. @@ -48,21 +52,25 @@ public class StoreQuotaManager implements QuotaManager { this.calculateWhenUnlimited = calculateWhenUnlimited; } - public Quota getMessageQuota(QuotaRoot quotaRoot) throws MailboxException { - long maxValue = maxQuotaManager.getMaxMessage(quotaRoot); - if (maxValue == Quota.UNLIMITED && !calculateWhenUnlimited) { - return Quota.quota(Quota.UNKNOWN, Quota.UNLIMITED); + public Quota<QuotaCount> getMessageQuota(QuotaRoot quotaRoot) throws MailboxException { + Optional<QuotaCount> maxValue = maxQuotaManager.getMaxMessage(quotaRoot); + if (maxValue.filter(QuotaCount::isUnlimited).isPresent() && !calculateWhenUnlimited) { + return Quota.unknownUsedQuota(QuotaCount.unlimited()); } - return Quota.quota(currentQuotaManager.getCurrentMessageCount(quotaRoot), maxValue); + QuotaCount currentMessageCount = currentQuotaManager.getCurrentMessageCount(quotaRoot); + QuotaCount limit = maxValue.orElse(QuotaCount.unlimited()); + return Quota.quota(currentMessageCount, limit); } - public Quota getStorageQuota(QuotaRoot quotaRoot) throws MailboxException { - long maxValue = maxQuotaManager.getMaxStorage(quotaRoot); - if (maxValue == Quota.UNLIMITED && !calculateWhenUnlimited) { - return Quota.quota(Quota.UNKNOWN, Quota.UNLIMITED); + public Quota<QuotaSize> getStorageQuota(QuotaRoot quotaRoot) throws MailboxException { + Optional<QuotaSize> maxValue = maxQuotaManager.getMaxStorage(quotaRoot); + if (maxValue.filter(QuotaSize::isUnlimited).isPresent() && !calculateWhenUnlimited) { + return Quota.unknownUsedQuota(QuotaSize.unlimited()); } - return Quota.quota(currentQuotaManager.getCurrentStorage(quotaRoot), maxValue); + QuotaSize currentStorage = currentQuotaManager.getCurrentStorage(quotaRoot); + QuotaSize limit = maxValue.orElse(QuotaSize.unlimited()); + return Quota.quota(currentStorage, limit); } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerQuotaTest.java ---------------------------------------------------------------------- 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 d6e0e1a..3f421c0 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 @@ -32,7 +32,9 @@ import org.apache.james.mailbox.mock.MockMailboxSession; import org.apache.james.mailbox.model.MessageId; import org.apache.james.mailbox.quota.CurrentQuotaManager; import org.apache.james.mailbox.quota.MaxQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.mail.model.Mailbox; import org.junit.Before; import org.junit.Rule; @@ -82,7 +84,7 @@ public abstract class AbstractMessageIdManagerQuotaTest { @Test public void setInMailboxesShouldNotThrowWhenMessageQuotaNotExceeded() throws Exception { - maxQuotaManager.setDefaultMaxMessage(1); + maxQuotaManager.setDefaultMaxMessage(QuotaCount.count(1)); MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session); @@ -91,7 +93,7 @@ public abstract class AbstractMessageIdManagerQuotaTest { @Test public void setInMailboxesShouldNotThrowWhenStorageQuotaNotExceeded() throws Exception { - maxQuotaManager.setDefaultMaxStorage(testingData.getConstantMessageSize()); + maxQuotaManager.setDefaultMaxStorage(QuotaSize.size(testingData.getConstantMessageSize())); MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session); @@ -100,7 +102,7 @@ public abstract class AbstractMessageIdManagerQuotaTest { @Test public void setInMailboxesShouldThrowWhenStorageQuotaExceeded() throws Exception { - maxQuotaManager.setDefaultMaxStorage(2 * testingData.getConstantMessageSize()); + maxQuotaManager.setDefaultMaxStorage(QuotaSize.size(2 * testingData.getConstantMessageSize())); testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session); MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session); @@ -111,7 +113,7 @@ public abstract class AbstractMessageIdManagerQuotaTest { @Test public void setInMailboxesShouldThrowWhenStorageQuotaExceededWhenCopiedToMultipleMailboxes() throws Exception { - maxQuotaManager.setDefaultMaxStorage(2 * testingData.getConstantMessageSize()); + maxQuotaManager.setDefaultMaxStorage(QuotaSize.size(2 * testingData.getConstantMessageSize())); MessageId messageId = testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session); @@ -121,7 +123,7 @@ public abstract class AbstractMessageIdManagerQuotaTest { @Test public void setInMailboxesShouldThrowWhenStorageMessageExceeded() throws Exception { - maxQuotaManager.setDefaultMaxMessage(2); + maxQuotaManager.setDefaultMaxMessage(QuotaCount.count(2)); testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session); MessageId messageId = testingData.persist(mailbox2.getMailboxId(), messageUid1, FLAGS, session); http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMessageIdManagerSideEffectTest.java ---------------------------------------------------------------------- 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 629256f..1a7d0a5 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 @@ -50,7 +50,9 @@ import org.apache.james.mailbox.model.MessageResult; import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; import org.apache.james.mailbox.model.UpdatedFlags; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.event.MailboxEventDispatcher; import org.apache.james.mailbox.store.mail.model.Mailbox; import org.apache.james.mailbox.store.mail.model.MailboxMessage; @@ -61,7 +63,7 @@ import org.junit.rules.ExpectedException; import com.google.common.collect.ImmutableList; public abstract class AbstractMessageIdManagerSideEffectTest { - private static final Quota OVER_QUOTA = Quota.quota(102, 100); + private static final Quota<QuotaCount> OVER_QUOTA = Quota.quota(QuotaCount.count(102), QuotaCount.count(100)); private static final MessageUid messageUid1 = MessageUid.of(111); public static final Flags FLAGS = new Flags(); @@ -162,9 +164,9 @@ public abstract class AbstractMessageIdManagerSideEffectTest { public void setInMailboxesShouldThrowExceptionWhenOverQuota() throws Exception { MessageId messageId = testingData.persist(mailbox1.getMailboxId(), messageUid1, FLAGS, session); reset(dispatcher); - when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(Quota.unlimited()); + when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(Quota.unknownUsedQuota(QuotaSize.unlimited())); when(quotaManager.getMessageQuota(any(QuotaRoot.class))).thenReturn(OVER_QUOTA); - when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(Quota.unlimited()); + when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(Quota.unknownUsedQuota(QuotaSize.unlimited())); expectedException.expect(OverQuotaException.class); @@ -306,8 +308,8 @@ public abstract class AbstractMessageIdManagerSideEffectTest { } private void givenUnlimitedQuota() throws MailboxException { - when(quotaManager.getMessageQuota(any(QuotaRoot.class))).thenReturn(Quota.unlimited()); - when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(Quota.unlimited()); + when(quotaManager.getMessageQuota(any(QuotaRoot.class))).thenReturn(Quota.unknownUsedQuota(QuotaCount.unlimited())); + when(quotaManager.getStorageQuota(any(QuotaRoot.class))).thenReturn(Quota.unknownUsedQuota(QuotaSize.unlimited())); } private SimpleMessageMetaData fromMessageResult(MessageId messageId, MessageResult messageResult) { http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java ---------------------------------------------------------------------- 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 148a899..99fe1b6 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 @@ -21,9 +21,10 @@ package org.apache.james.mailbox.store.quota; import static org.assertj.core.api.Assertions.assertThat; -import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; import org.apache.james.mailbox.quota.MaxQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.junit.Before; import org.junit.Test; @@ -41,37 +42,64 @@ public abstract class GenericMaxQuotaManagerTest { } @Test - public void getMaxMessageShouldReturnUnlimitedWhenNoDefaultValue() throws Exception { - assertThat(maxQuotaManager.getMaxMessage(quotaRoot)).isEqualTo(Quota.UNLIMITED); + public void getMaxMessageShouldReturnEmptyWhenNoDefaultValue() throws Exception { + assertThat(maxQuotaManager.getMaxMessage(quotaRoot)).isEmpty(); } @Test - public void getMaxStorageShouldReturnUnlimitedWhenNoDefaultValue() throws Exception { - assertThat(maxQuotaManager.getMaxStorage(quotaRoot)).isEqualTo(Quota.UNLIMITED); + public void getMaxStorageShouldReturnEmptyWhenNoDefaultValue() throws Exception { + assertThat(maxQuotaManager.getMaxStorage(quotaRoot)).isEmpty(); } @Test public void getMaxMessageShouldReturnDefaultWhenNoValue() throws Exception { - maxQuotaManager.setDefaultMaxMessage(36); - assertThat(maxQuotaManager.getMaxMessage(quotaRoot)).isEqualTo(36); + maxQuotaManager.setDefaultMaxMessage(QuotaCount.count(36)); + assertThat(maxQuotaManager.getMaxMessage(quotaRoot)).contains(QuotaCount.count(36)); } @Test public void getMaxStorageShouldReturnDefaultWhenNoValue() throws Exception { - maxQuotaManager.setDefaultMaxStorage(36); - assertThat(maxQuotaManager.getMaxStorage(quotaRoot)).isEqualTo(36); + maxQuotaManager.setDefaultMaxStorage(QuotaSize.size(36)); + assertThat(maxQuotaManager.getMaxStorage(quotaRoot)).contains(QuotaSize.size(36)); } @Test public void getMaxMessageShouldReturnProvidedValue() throws Exception { - maxQuotaManager.setMaxMessage(quotaRoot, 36); - assertThat(maxQuotaManager.getMaxMessage(quotaRoot)).isEqualTo(36); + maxQuotaManager.setMaxMessage(quotaRoot, QuotaCount.count(36)); + assertThat(maxQuotaManager.getMaxMessage(quotaRoot)).contains(QuotaCount.count(36)); } @Test public void getMaxStorageShouldReturnProvidedValue() throws Exception { - maxQuotaManager.setMaxStorage(quotaRoot, 36); - assertThat(maxQuotaManager.getMaxStorage(quotaRoot)).isEqualTo(36); + maxQuotaManager.setMaxStorage(quotaRoot, QuotaSize.size(36)); + assertThat(maxQuotaManager.getMaxStorage(quotaRoot)).contains(QuotaSize.size(36)); } + @Test + public void deleteMaxStorageShouldRemoveCurrentValue() throws Exception { + maxQuotaManager.setMaxStorage(quotaRoot, QuotaSize.size(36)); + maxQuotaManager.removeMaxStorage(quotaRoot); + assertThat(maxQuotaManager.getMaxStorage(quotaRoot)).isEmpty(); + } + + @Test + public void deleteMaxMessageShouldRemoveCurrentValue() throws Exception { + maxQuotaManager.setMaxMessage(quotaRoot, QuotaCount.count(36)); + maxQuotaManager.removeMaxMessage(quotaRoot); + assertThat(maxQuotaManager.getMaxMessage(quotaRoot)).isEmpty(); + } + + @Test + public void deleteDefaultMaxStorageShouldRemoveCurrentValue() throws Exception { + maxQuotaManager.setDefaultMaxStorage(QuotaSize.size(36)); + maxQuotaManager.removeDefaultMaxStorage(); + assertThat(maxQuotaManager.getDefaultMaxStorage()).isEmpty(); + } + + @Test + public void deleteDefaultMaxMessageShouldRemoveCurrentValue() throws Exception { + maxQuotaManager.setDefaultMaxMessage(QuotaCount.count(36)); + maxQuotaManager.removeDefaultMaxMessage(); + assertThat(maxQuotaManager.getDefaultMaxMessage()).isEmpty(); + } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/QuotaCheckerTest.java ---------------------------------------------------------------------- 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 f7ff670..d4901f8 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 @@ -19,7 +19,6 @@ package org.apache.james.mailbox.store.quota; -import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -29,8 +28,10 @@ import org.apache.james.mailbox.exception.OverQuotaException; import org.apache.james.mailbox.model.MailboxPath; import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; import org.apache.james.mailbox.quota.QuotaRootResolver; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox; import org.junit.Before; import org.junit.Test; @@ -53,35 +54,38 @@ public class QuotaCheckerTest { @Test public void quotaCheckerShouldNotThrowOnRegularQuotas() throws MailboxException { when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT); - when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(10, 100)); - when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(100, 1000)); + when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaCount.count(10), QuotaCount.count(100))); + when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaSize.size(100), QuotaSize.size(1000))); QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX); - assertThat(quotaChecker.tryAddition(0, 0)).isTrue(); + + quotaChecker.tryAddition(0, 0); } @Test public void quotaCheckerShouldNotThrowOnRegularModifiedQuotas() throws MailboxException { when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT); - when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(10, 100)); - when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(100, 1000)); + when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaCount.count(10), QuotaCount.count(100))); + when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaSize.size(100), QuotaSize.size(1000))); QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX); - assertThat(quotaChecker.tryAddition(89, 899)).isTrue(); + + quotaChecker.tryAddition(89, 899); } @Test public void quotaCheckerShouldNotThrowOnReachedMaximumQuotas() throws MailboxException { when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT); - when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(10, 100)); - when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(100, 1000)); + when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaCount.count(10), QuotaCount.count(100))); + when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaSize.size(100), QuotaSize.size(1000))); QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX); - assertThat(quotaChecker.tryAddition(90, 900)).isTrue(); + + quotaChecker.tryAddition(90, 900); } @Test public void quotaCheckerShouldThrowOnExceededMessages() throws MailboxException { when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT); - when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(10, 100)); - when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(100, 1000)); + when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaCount.count(10), QuotaCount.count(100))); + when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaSize.size(100), QuotaSize.size(1000))); QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX); assertThatThrownBy(() -> quotaChecker.tryAddition(91, 899)) @@ -91,8 +95,8 @@ public class QuotaCheckerTest { @Test public void quotaCheckerShouldThrowOnExceededStorage() throws MailboxException { when(mockedQuotaRootResolver.getQuotaRoot(MAILBOX_PATH)).thenReturn(QUOTA_ROOT); - when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(10, 100)); - when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(100, 1000)); + when(mockedQuotaManager.getMessageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaCount.count(10), QuotaCount.count(100))); + when(mockedQuotaManager.getStorageQuota(QUOTA_ROOT)).thenReturn(Quota.quota(QuotaSize.size(100), QuotaSize.size(1000))); QuotaChecker quotaChecker = new QuotaChecker(mockedQuotaManager, mockedQuotaRootResolver, MAILBOX); assertThatThrownBy(() -> quotaChecker.tryAddition(89, 901)) http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java ---------------------------------------------------------------------- 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 fcec1c7..c5c51b9 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 @@ -22,6 +22,8 @@ package org.apache.james.mailbox.store.quota; import static org.assertj.core.api.Assertions.assertThat; import org.apache.james.mailbox.model.QuotaRoot; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.junit.Before; import org.junit.Test; @@ -39,15 +41,15 @@ public abstract class StoreCurrentQuotaManagerTest { @Test public void getCurrentStorageShouldReturnZeroByDefault() throws Exception { - assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(0); + assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(0)); } @Test public void increaseShouldWork() throws Exception { testee.increase(QUOTA_ROOT, 10, 100); - assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(10); - assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(100); + assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(10)); + assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(100)); } @Test @@ -56,16 +58,16 @@ public abstract class StoreCurrentQuotaManagerTest { testee.decrease(QUOTA_ROOT, 10, 100); - assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(10); - assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(100); + assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(10)); + assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(100)); } @Test public void decreaseShouldNotFailWhenItLeadsToNegativeValues() throws Exception { testee.decrease(QUOTA_ROOT, 10, 100); - assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(-10); - assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(-100); + assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(-10)); + assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(-100)); } @Test(expected = IllegalArgumentException.class) http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreQuotaManagerTest.java ---------------------------------------------------------------------- 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 064be67..e85460a 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 @@ -25,10 +25,14 @@ import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import java.util.Optional; + import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; import org.apache.james.mailbox.quota.CurrentQuotaManager; import org.apache.james.mailbox.quota.MaxQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.junit.Before; import org.junit.Test; @@ -49,52 +53,52 @@ public class StoreQuotaManagerTest { @Test public void getMessageQuotaShouldWorkWithNumericValues() throws Exception { - when(mockedMaxQuotaManager.getMaxMessage(quotaRoot)).thenReturn(360L); - when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(36L); - assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(Quota.quota(36, 360)); + when(mockedMaxQuotaManager.getMaxMessage(quotaRoot)).thenReturn(Optional.of(QuotaCount.count(360L))); + when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(QuotaCount.count(36L)); + assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(Quota.quota(QuotaCount.count(36L), QuotaCount.count(360L))); } @Test public void getStorageQuotaShouldWorkWithNumericValues() throws Exception { - when(mockedMaxQuotaManager.getMaxStorage(quotaRoot)).thenReturn(360L); - when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(36L); - assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(Quota.quota(36, 360)); + when(mockedMaxQuotaManager.getMaxStorage(quotaRoot)).thenReturn(Optional.of(QuotaSize.size(360L))); + when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(QuotaSize.size(36L)); + assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(Quota.quota(QuotaSize.size(36L), QuotaSize.size(360L))); } @Test public void getStorageQuotaShouldNotCalculateCurrentQuotaWhenUnlimited() throws Exception { testee.setCalculateWhenUnlimited(false); - when(mockedMaxQuotaManager.getMaxStorage(quotaRoot)).thenReturn(Quota.UNLIMITED); + when(mockedMaxQuotaManager.getMaxStorage(quotaRoot)).thenReturn(Optional.of(QuotaSize.unlimited())); - assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(Quota.quota(Quota.UNKNOWN, Quota.UNLIMITED)); + assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(Quota.unknownUsedQuota(QuotaSize.unlimited())); verify(mockedCurrentQuotaManager, never()).getCurrentStorage(quotaRoot); } @Test public void getMessageQuotaShouldNotCalculateCurrentQuotaWhenUnlimited() throws Exception { testee.setCalculateWhenUnlimited(false); - when(mockedMaxQuotaManager.getMaxMessage(quotaRoot)).thenReturn(Quota.UNLIMITED); + when(mockedMaxQuotaManager.getMaxMessage(quotaRoot)).thenReturn(Optional.of(QuotaCount.unlimited())); - assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(Quota.quota(Quota.UNKNOWN, Quota.UNLIMITED)); + assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(Quota.unknownUsedQuota(QuotaCount.unlimited())); verify(mockedCurrentQuotaManager, never()).getCurrentMessageCount(quotaRoot); } @Test public void getStorageQuotaShouldCalculateCurrentQuotaWhenUnlimited() throws Exception { testee.setCalculateWhenUnlimited(true); - when(mockedMaxQuotaManager.getMaxStorage(quotaRoot)).thenReturn(Quota.UNLIMITED); - when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(36L); + when(mockedMaxQuotaManager.getMaxStorage(quotaRoot)).thenReturn(Optional.of(QuotaSize.unlimited())); + when(mockedCurrentQuotaManager.getCurrentStorage(quotaRoot)).thenReturn(QuotaSize.size(36L)); - assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(Quota.quota(36, Quota.UNLIMITED)); + assertThat(testee.getStorageQuota(quotaRoot)).isEqualTo(Quota.quota(QuotaSize.size(36L), QuotaSize.unlimited())); } @Test public void getMessageQuotaShouldCalculateCurrentQuotaWhenUnlimited() throws Exception { testee.setCalculateWhenUnlimited(true); - when(mockedMaxQuotaManager.getMaxMessage(quotaRoot)).thenReturn(Quota.UNLIMITED); - when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(36L); + when(mockedMaxQuotaManager.getMaxMessage(quotaRoot)).thenReturn(Optional.of(QuotaCount.unlimited())); + when(mockedCurrentQuotaManager.getCurrentMessageCount(quotaRoot)).thenReturn(QuotaCount.count(36L)); - assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(Quota.quota(36, Quota.UNLIMITED)); + assertThat(testee.getMessageQuota(quotaRoot)).isEqualTo(Quota.quota(QuotaCount.count(36L), QuotaCount.unlimited())); } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/core/src/main/java/org/apache/james/mpt/api/ImapHostSystem.java ---------------------------------------------------------------------- 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 a9fe170..41f3ecc 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 @@ -20,6 +20,8 @@ package org.apache.james.mpt.api; import org.apache.james.mailbox.model.MailboxACL; import org.apache.james.mailbox.model.MailboxPath; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mpt.api.ImapFeatures.Feature; public interface ImapHostSystem extends HostSystem { @@ -28,7 +30,7 @@ public interface ImapHostSystem extends HostSystem { void createMailbox(MailboxPath mailboxPath) throws Exception; - void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception; + void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception; void grantRights(MailboxPath mailboxPath, String userName, MailboxACL.Rfc4314Rights rights) throws Exception; } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/core/src/main/java/org/apache/james/mpt/host/ExternalHostSystem.java ---------------------------------------------------------------------- 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 43c4fc2..7a67e7d 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 @@ -22,6 +22,8 @@ package org.apache.james.mpt.host; import org.apache.commons.lang.NotImplementedException; import org.apache.james.mailbox.model.MailboxACL; import org.apache.james.mailbox.model.MailboxPath; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mpt.api.ImapFeatures; import org.apache.james.mpt.api.ImapFeatures.Feature; import org.apache.james.mpt.api.ImapHostSystem; @@ -110,7 +112,7 @@ public class ExternalHostSystem extends ExternalSessionFactory implements ImapHo } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/cassandra/src/test/java/org/apache/james/mpt/imapmailbox/cassandra/host/CassandraHostSystem.java ---------------------------------------------------------------------- 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 2676c35..89fea73 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 @@ -51,7 +51,9 @@ import org.apache.james.mailbox.cassandra.quota.CassandraCurrentQuotaManager; import org.apache.james.mailbox.cassandra.quota.CassandraPerUserMaxQuotaDao; import org.apache.james.mailbox.cassandra.quota.CassandraPerUserMaxQuotaManager; import org.apache.james.mailbox.exception.MailboxException; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaRootResolver; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.JVMMailboxPathLocker; import org.apache.james.mailbox.store.StoreMailboxAnnotationManager; import org.apache.james.mailbox.store.StoreRightManager; @@ -157,7 +159,7 @@ public class CassandraHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws MailboxException { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws MailboxException { perUserMaxQuotaManager.setDefaultMaxMessage(maxMessageQuota); perUserMaxQuotaManager.setDefaultMaxStorage(maxStorageQuota); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/core/src/main/java/org/apache/james/mpt/imapmailbox/suite/QuotaTest.java ---------------------------------------------------------------------- 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 cec3719..13427e5 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,6 +21,8 @@ package org.apache.james.mpt.imapmailbox.suite; import java.util.Locale; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mpt.api.ImapFeatures; import org.apache.james.mpt.api.ImapHostSystem; import org.apache.james.mpt.imapmailbox.ImapTestConstants; @@ -33,8 +35,8 @@ import org.junit.Test; public abstract class QuotaTest implements ImapTestConstants { - private static final int MAX_MESSAGE_QUOTA = 4096; - private static final long MAX_STORAGE_QUOTA = 5 * 1024L * 1024L * 1024L; + private static final QuotaCount MAX_MESSAGE_QUOTA = QuotaCount.count(4096); + private static final QuotaSize MAX_STORAGE_QUOTA = QuotaSize.size(5 * 1024L * 1024L * 1024L); protected abstract ImapHostSystem createImapHostSystem(); http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/cyrus/src/test/java/org/apache/james/mpt/imapmailbox/cyrus/host/CyrusHostSystem.java ---------------------------------------------------------------------- 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 9297b3d..8ba0956 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,6 +23,8 @@ import java.util.function.Supplier; import org.apache.commons.lang.NotImplementedException; import org.apache.james.mailbox.model.MailboxPath; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mpt.api.ImapFeatures; import org.apache.james.mpt.api.ImapFeatures.Feature; import org.apache.james.mpt.api.Session; @@ -131,7 +133,7 @@ public class CyrusHostSystem extends ExternalHostSystem implements Provider<Cont } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/elasticsearch/src/test/java/org/apache/james/mpt/imapmailbox/elasticsearch/host/ElasticSearchHostSystem.java ---------------------------------------------------------------------- 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 a7f2c76..4d19b58 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 @@ -52,6 +52,8 @@ import org.apache.james.mailbox.inmemory.InMemoryMailboxSessionMapperFactory; import org.apache.james.mailbox.inmemory.InMemoryMessageId; import org.apache.james.mailbox.inmemory.manager.InMemoryIntegrationResources; import org.apache.james.mailbox.mock.MockMailboxSession; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.StoreMailboxManager; import org.apache.james.mailbox.store.StoreSubscriptionManager; import org.apache.james.mailbox.store.extractor.DefaultTextExtractor; @@ -143,7 +145,7 @@ public class ElasticSearchHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/ExternalJamesHostSystem.java ---------------------------------------------------------------------- diff --git a/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/ExternalJamesHostSystem.java b/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/ExternalJamesHostSystem.java index 01fe073..782629a 100644 --- a/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/ExternalJamesHostSystem.java +++ b/mpt/impl/imap-mailbox/external-james/src/test/java/org/apache/james/mpt/imapmailbox/external/james/host/ExternalJamesHostSystem.java @@ -23,6 +23,8 @@ import java.util.function.Supplier; import org.apache.commons.lang.NotImplementedException; import org.apache.james.mailbox.model.MailboxPath; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mpt.api.ImapFeatures; import org.apache.james.mpt.api.ImapFeatures.Feature; import org.apache.james.mpt.host.ExternalHostSystem; @@ -76,7 +78,7 @@ public class ExternalJamesHostSystem extends ExternalHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/hbase/src/test/java/org/apache/james/mpt/imapmailbox/hbase/host/HBaseHostSystem.java ---------------------------------------------------------------------- diff --git a/mpt/impl/imap-mailbox/hbase/src/test/java/org/apache/james/mpt/imapmailbox/hbase/host/HBaseHostSystem.java b/mpt/impl/imap-mailbox/hbase/src/test/java/org/apache/james/mpt/imapmailbox/hbase/host/HBaseHostSystem.java index 95d86c3..a9ac883 100644 --- a/mpt/impl/imap-mailbox/hbase/src/test/java/org/apache/james/mpt/imapmailbox/hbase/host/HBaseHostSystem.java +++ b/mpt/impl/imap-mailbox/hbase/src/test/java/org/apache/james/mpt/imapmailbox/hbase/host/HBaseHostSystem.java @@ -41,6 +41,8 @@ import org.apache.james.mailbox.hbase.HBaseMailboxManager; import org.apache.james.mailbox.hbase.HBaseMailboxSessionMapperFactory; import org.apache.james.mailbox.hbase.mail.HBaseModSeqProvider; import org.apache.james.mailbox.hbase.mail.HBaseUidProvider; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.JVMMailboxPathLocker; import org.apache.james.mailbox.store.StoreMailboxAnnotationManager; import org.apache.james.mailbox.store.StoreRightManager; @@ -176,7 +178,7 @@ public class HBaseHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/inmemory/src/test/java/org/apache/james/mpt/imapmailbox/inmemory/host/InMemoryHostSystem.java ---------------------------------------------------------------------- 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 9f3f26e..feb3163 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 @@ -30,7 +30,9 @@ import org.apache.james.mailbox.inmemory.manager.InMemoryIntegrationResources; import org.apache.james.mailbox.inmemory.quota.InMemoryCurrentQuotaManager; import org.apache.james.mailbox.inmemory.quota.InMemoryPerUserMaxQuotaManager; import org.apache.james.mailbox.mock.MockMailboxSession; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaRootResolver; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.StoreMailboxManager; import org.apache.james.mailbox.store.StoreSubscriptionManager; import org.apache.james.mailbox.store.quota.CurrentQuotaCalculator; @@ -96,7 +98,7 @@ public class InMemoryHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws MailboxException { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws MailboxException { perUserMaxQuotaManager.setDefaultMaxMessage(maxMessageQuota); perUserMaxQuotaManager.setDefaultMaxStorage(maxStorageQuota); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/jcr/src/test/java/org/apache/james/mpt/imapmailbox/jcr/host/JCRHostSystem.java ---------------------------------------------------------------------- diff --git a/mpt/impl/imap-mailbox/jcr/src/test/java/org/apache/james/mpt/imapmailbox/jcr/host/JCRHostSystem.java b/mpt/impl/imap-mailbox/jcr/src/test/java/org/apache/james/mpt/imapmailbox/jcr/host/JCRHostSystem.java index b0e3a2a..985f774 100644 --- a/mpt/impl/imap-mailbox/jcr/src/test/java/org/apache/james/mpt/imapmailbox/jcr/host/JCRHostSystem.java +++ b/mpt/impl/imap-mailbox/jcr/src/test/java/org/apache/james/mpt/imapmailbox/jcr/host/JCRHostSystem.java @@ -41,6 +41,8 @@ import org.apache.james.mailbox.jcr.JCRSubscriptionManager; import org.apache.james.mailbox.jcr.JCRUtils; import org.apache.james.mailbox.jcr.mail.JCRModSeqProvider; import org.apache.james.mailbox.jcr.mail.JCRUidProvider; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.JVMMailboxPathLocker; import org.apache.james.mailbox.store.StoreMailboxAnnotationManager; import org.apache.james.mailbox.store.StoreRightManager; @@ -178,7 +180,7 @@ public class JCRHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/jpa/src/test/java/org/apache/james/mpt/imapmailbox/jpa/host/JPAHostSystem.java ---------------------------------------------------------------------- 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 c6d5c32..4b5d320 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 @@ -36,15 +36,17 @@ import org.apache.james.mailbox.acl.GroupMembershipResolver; import org.apache.james.mailbox.acl.MailboxACLResolver; import org.apache.james.mailbox.acl.SimpleGroupMembershipResolver; import org.apache.james.mailbox.acl.UnionMailboxACLResolver; -import org.apache.james.mailbox.exception.MailboxException; import org.apache.james.mailbox.jpa.JPAMailboxFixture; import org.apache.james.mailbox.jpa.JPAMailboxSessionMapperFactory; import org.apache.james.mailbox.jpa.JPASubscriptionManager; import org.apache.james.mailbox.jpa.mail.JPAModSeqProvider; import org.apache.james.mailbox.jpa.mail.JPAUidProvider; import org.apache.james.mailbox.jpa.openjpa.OpenJPAMailboxManager; +import org.apache.james.mailbox.jpa.quota.JPAPerUserMaxQuotaDAO; import org.apache.james.mailbox.jpa.quota.JPAPerUserMaxQuotaManager; import org.apache.james.mailbox.jpa.quota.JpaCurrentQuotaManager; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.JVMMailboxPathLocker; import org.apache.james.mailbox.store.StoreMailboxAnnotationManager; import org.apache.james.mailbox.store.StoreRightManager; @@ -106,7 +108,7 @@ public class JPAHostSystem extends JamesImapHostSystem { DefaultQuotaRootResolver quotaRootResolver = new DefaultQuotaRootResolver(mapperFactory); JpaCurrentQuotaManager currentQuotaManager = new JpaCurrentQuotaManager(entityManagerFactory); - maxQuotaManager = new JPAPerUserMaxQuotaManager(entityManagerFactory); + maxQuotaManager = new JPAPerUserMaxQuotaManager(new JPAPerUserMaxQuotaDAO(entityManagerFactory)); StoreQuotaManager storeQuotaManager = new StoreQuotaManager(currentQuotaManager, maxQuotaManager); ListeningCurrentQuotaUpdater quotaUpdater = new ListeningCurrentQuotaUpdater(currentQuotaManager, quotaRootResolver); @@ -161,7 +163,7 @@ public class JPAHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws MailboxException { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { maxQuotaManager.setDefaultMaxMessage(maxMessageQuota); maxQuotaManager.setDefaultMaxStorage(maxStorageQuota); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/lucenesearch/src/test/java/org/apache/james/mpt/imapmailbox/lucenesearch/host/LuceneSearchHostSystem.java ---------------------------------------------------------------------- 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 7455a89..740594e 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 @@ -49,6 +49,8 @@ import org.apache.james.mailbox.jpa.mail.JPAUidProvider; import org.apache.james.mailbox.jpa.openjpa.OpenJPAMailboxManager; import org.apache.james.mailbox.lucene.search.LuceneMessageSearchIndex; import org.apache.james.mailbox.model.MessageId; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.JVMMailboxPathLocker; import org.apache.james.mailbox.store.StoreMailboxAnnotationManager; import org.apache.james.mailbox.store.StoreRightManager; @@ -164,7 +166,7 @@ public class LuceneSearchHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/mpt/impl/imap-mailbox/maildir/src/test/java/org/apache/james/mpt/imapmailbox/maildir/host/MaildirHostSystem.java ---------------------------------------------------------------------- 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 0066773..7861d4d 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 @@ -33,6 +33,8 @@ import org.apache.james.mailbox.acl.SimpleGroupMembershipResolver; import org.apache.james.mailbox.acl.UnionMailboxACLResolver; import org.apache.james.mailbox.maildir.MaildirMailboxSessionMapperFactory; import org.apache.james.mailbox.maildir.MaildirStore; +import org.apache.james.mailbox.quota.QuotaCount; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.mailbox.store.JVMMailboxPathLocker; import org.apache.james.mailbox.store.StoreMailboxAnnotationManager; import org.apache.james.mailbox.store.StoreMailboxManager; @@ -125,7 +127,7 @@ public class MaildirHostSystem extends JamesImapHostSystem { } @Override - public void setQuotaLimits(long maxMessageQuota, long maxStorageQuota) throws Exception { + public void setQuotaLimits(QuotaCount maxMessageQuota, QuotaSize maxStorageQuota) throws Exception { throw new NotImplementedException(); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/protocols/imap/src/main/java/org/apache/james/imap/encode/QuotaResponseEncoder.java ---------------------------------------------------------------------- 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 8319ece..d09c11f 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 @@ -20,6 +20,7 @@ package org.apache.james.imap.encode; import java.io.IOException; +import java.util.Locale; import org.apache.james.imap.api.ImapConstants; import org.apache.james.imap.api.ImapMessage; @@ -42,7 +43,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); @@ -50,18 +51,32 @@ public class QuotaResponseEncoder extends AbstractChainedImapEncoder { composer.openParen(); composer.message(quotaResponse.getResourceName()); // See RFC 2087 : response for STORAGE should be in KB. For more accuracy, we stores B, so conversion should be made - if (quotaResponse.getResourceName().equalsIgnoreCase(ImapConstants.STORAGE_QUOTA_RESOURCE)) { - composer.message(quota.getUsed() / 1024); - composer.message(quota.getMax() / 1024); - } else { - composer.message(quota.getUsed()); - composer.message(quota.getMax()); + switch (quotaResponse.getResourceName().toUpperCase(Locale.US)) { + case ImapConstants.STORAGE_QUOTA_RESOURCE: + writeMessagesSize(composer, quota); + break; + case ImapConstants.MESSAGE_QUOTA_RESOURCE: + writeMessagesCount(composer, quota); + break; } + composer.closeParen(); composer.end(); } + private void writeMessagesSize(ImapResponseComposer composer, Quota<?> quota) throws IOException { + //we know there's a quota because Quota*Processor ask us to print it + composer.message(quota.getUsed().get().asLong() / 1024); + composer.message(quota.getMax().asLong() / 1024); + } + + private void writeMessagesCount(ImapResponseComposer composer, Quota<?> quota) throws IOException { + //we know there's a quota because Quota*Processor ask us to print it + composer.message(quota.getUsed().get().asLong()); + composer.message(quota.getMax().asLong()); + } + /* * (non-Javadoc) * http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/protocols/imap/src/main/java/org/apache/james/imap/message/response/QuotaResponse.java ---------------------------------------------------------------------- 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 ccd2375..84d586e 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,9 +31,9 @@ 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; @@ -50,7 +50,7 @@ public class QuotaResponse implements ImapResponseMessage { return false; } - public Quota getQuota() { + public Quota<?> getQuota() { return quota; } http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java ---------------------------------------------------------------------- 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 64d323c..bed1740 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 @@ -38,8 +38,10 @@ import org.apache.james.mailbox.model.MailboxACL; import org.apache.james.mailbox.model.MailboxPath; import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; import org.apache.james.mailbox.quota.QuotaRootResolver; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.metrics.api.MetricFactory; import org.apache.james.util.MDCBuilder; @@ -77,10 +79,14 @@ public class GetQuotaProcessor extends AbstractMailboxProcessor<GetQuotaRequest> try { if (hasRight(message.getQuotaRoot(), session)) { QuotaRoot quotaRoot = quotaRootResolver.createQuotaRoot(message.getQuotaRoot()); - Quota messageQuota = quotaManager.getMessageQuota(quotaRoot); - Quota storageQuota = quotaManager.getStorageQuota(quotaRoot); - responder.respond(new QuotaResponse(ImapConstants.MESSAGE_QUOTA_RESOURCE, quotaRoot.getValue(), messageQuota)); - responder.respond(new QuotaResponse(ImapConstants.STORAGE_QUOTA_RESOURCE, quotaRoot.getValue(), storageQuota)); + Quota<QuotaCount> messageQuota = quotaManager.getMessageQuota(quotaRoot); + Quota<QuotaSize> storageQuota = quotaManager.getStorageQuota(quotaRoot); + if (messageQuota.getMax().isLimited() && messageQuota.getUsed().isPresent()) { + responder.respond(new QuotaResponse(ImapConstants.MESSAGE_QUOTA_RESOURCE, quotaRoot.getValue(), messageQuota)); + } + if (storageQuota.getMax().isLimited() && storageQuota.getUsed().isPresent()) { + responder.respond(new QuotaResponse(ImapConstants.STORAGE_QUOTA_RESOURCE, quotaRoot.getValue(), storageQuota)); + } okComplete(command, tag, responder); } else { Object[] params = new Object[]{ http://git-wip-us.apache.org/repos/asf/james-project/blob/ebcb09a0/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java ---------------------------------------------------------------------- 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 15f2a12..345cc31 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 @@ -40,8 +40,10 @@ import org.apache.james.mailbox.model.MailboxACL; import org.apache.james.mailbox.model.MailboxPath; import org.apache.james.mailbox.model.Quota; import org.apache.james.mailbox.model.QuotaRoot; +import org.apache.james.mailbox.quota.QuotaCount; import org.apache.james.mailbox.quota.QuotaManager; import org.apache.james.mailbox.quota.QuotaRootResolver; +import org.apache.james.mailbox.quota.QuotaSize; import org.apache.james.metrics.api.MetricFactory; import org.apache.james.util.MDCBuilder; @@ -78,12 +80,15 @@ public class GetQuotaRootProcessor extends AbstractMailboxProcessor<GetQuotaRoot try { if (mailboxManager.hasRight(mailboxPath, MailboxACL.Right.Read, mailboxSession)) { QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(mailboxPath); - Quota messageQuota = quotaManager.getMessageQuota(quotaRoot); - // See RFC 2087 : response for STORAGE should be in KB. For more accuracy, we stores B, so conversion should be made - Quota storageQuota = quotaManager.getStorageQuota(quotaRoot); + Quota<QuotaCount> messageQuota = quotaManager.getMessageQuota(quotaRoot); + Quota<QuotaSize> storageQuota = quotaManager.getStorageQuota(quotaRoot); responder.respond(new QuotaRootResponse(message.getMailboxName(), quotaRoot.getValue())); - responder.respond(new QuotaResponse(ImapConstants.MESSAGE_QUOTA_RESOURCE, quotaRoot.getValue(), messageQuota)); - responder.respond(new QuotaResponse(ImapConstants.STORAGE_QUOTA_RESOURCE, quotaRoot.getValue(), storageQuota)); + if (messageQuota.getMax().isLimited() && messageQuota.getUsed().isPresent()) { + responder.respond(new QuotaResponse(ImapConstants.MESSAGE_QUOTA_RESOURCE, quotaRoot.getValue(), messageQuota)); + } + if (storageQuota.getMax().isLimited() && storageQuota.getUsed().isPresent()) { + responder.respond(new QuotaResponse(ImapConstants.STORAGE_QUOTA_RESOURCE, quotaRoot.getValue(), storageQuota)); + } okComplete(command, tag, responder); } else { Object[] params = new Object[]{ --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
