This is an automated email from the ASF dual-hosted git repository. rcordier pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/james-project.git
commit 89ec35215821d0b0d18080472ba76fee1d6d83c8 Author: Tung Van TRAN <[email protected]> AuthorDate: Fri Mar 24 15:14:50 2023 +0700 MaxQuotaManager should support more reactive methods --- .../james/mailbox/quota/MaxQuotaManager.java | 32 ++++++ .../quota/CassandraPerUserMaxQuotaManager.java | 112 ++++++++++++++++++--- .../jpa/quota/JPAPerUserMaxQuotaManager.java | 87 ++++++++++++++++ .../quota/InMemoryPerUserMaxQuotaManager.java | 83 +++++++++++++++ .../mailbox/store/quota/FixedMaxQuotaManager.java | 83 +++++++++++++++ .../mailbox/store/quota/NoMaxQuotaManager.java | 83 +++++++++++++++ 6 files changed, 464 insertions(+), 16 deletions(-) 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 367f79fec2..66275b3fc8 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 @@ -53,6 +53,8 @@ public interface MaxQuotaManager { */ void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) throws MailboxException; + Publisher<Void> setMaxStorageReactive(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota); + /** * Method allowing you to set the maximum message count allowed for this quotaroot * @@ -61,6 +63,8 @@ public interface MaxQuotaManager { */ void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) throws MailboxException; + Publisher<Void> setMaxMessageReactive(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount); + /** * Method allowing you to remove the maximum messages count allowed for this quotaroot * @@ -68,6 +72,8 @@ public interface MaxQuotaManager { */ void removeMaxMessage(QuotaRoot quotaRoot) throws MailboxException; + Publisher<Void> removeMaxMessageReactive(QuotaRoot quotaRoot); + /** * Method allowing you to remove the maximum messages size allowed for this quotaroot * @@ -75,6 +81,8 @@ public interface MaxQuotaManager { */ void removeMaxStorage(QuotaRoot quotaRoot) throws MailboxException; + Publisher<Void> removeMaxStorageReactive(QuotaRoot quotaRoot); + /** * Method allowing you to set the global maximum storage in bytes. * @@ -82,11 +90,15 @@ public interface MaxQuotaManager { */ void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) throws MailboxException; + Publisher<Void> setGlobalMaxStorageReactive(QuotaSizeLimit globalMaxStorage); + /** * Method allowing you to remove the global maximum messages size in bytes. */ void removeGlobalMaxStorage() throws MailboxException; + Publisher<Void> removeGlobalMaxStorageReactive(); + /** * Method allowing you to set the global maximum message count allowed * @@ -94,11 +106,15 @@ public interface MaxQuotaManager { */ void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) throws MailboxException; + Publisher<Void> setGlobalMaxMessageReactive(QuotaCountLimit globalMaxMessageCount); + /** * Method allowing you to remove the global maximum messages count. */ void removeGlobalMaxMessage() throws MailboxException; + Publisher<Void> removeGlobalMaxMessageReactive(); + /** * Method allowing you to get the global maximum storage in bytes. * @@ -106,6 +122,8 @@ public interface MaxQuotaManager { */ Optional<QuotaSizeLimit> getGlobalMaxStorage() throws MailboxException; + Publisher<QuotaSizeLimit> getGlobalMaxStorageReactive(); + /** * Method allowing you to get the global maximum message count allowed * @@ -113,6 +131,8 @@ public interface MaxQuotaManager { */ Optional<QuotaCountLimit> getGlobalMaxMessage() throws MailboxException; + Publisher<QuotaCountLimit> getGlobalMaxMessageReactive(); + /** * Return the maximum storage which is allowed for the given {@link QuotaRoot} (in fact the user which the session is bound to) * @@ -179,16 +199,28 @@ public interface MaxQuotaManager { Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain); + Publisher<QuotaCountLimit> getDomainMaxMessageReactive(Domain domain); + void setDomainMaxMessage(Domain domain, QuotaCountLimit count) throws MailboxException; + Publisher<Void> setDomainMaxMessageReactive(Domain domain, QuotaCountLimit count); + void removeDomainMaxMessage(Domain domain) throws MailboxException; + Publisher<Void> removeDomainMaxMessageReactive(Domain domain); + void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) throws MailboxException; + Publisher<Void> setDomainMaxStorageReactive(Domain domain, QuotaSizeLimit size); + Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain); + Publisher<QuotaSizeLimit> getDomainMaxStorageReactive(Domain domain); + void removeDomainMaxStorage(Domain domain) throws MailboxException; + Publisher<Void> removeDomainMaxStorageReactive(Domain domain); + default Optional<QuotaCountLimit> getComputedMaxMessage(Domain domain) throws MailboxException { return Stream.of( Throwing.supplier(() -> getDomainMaxMessage(domain)).sneakyThrow(), 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 51352f1943..f6e0ccaca9 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 @@ -56,82 +56,162 @@ public class CassandraPerUserMaxQuotaManager implements MaxQuotaManager { @Override public void setMaxStorage(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) { - perUserQuota.setMaxStorage(quotaRoot, maxStorageQuota).block(); + setMaxStorageReactive(quotaRoot, maxStorageQuota).block(); + } + + @Override + public Mono<Void> setMaxStorageReactive(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) { + return perUserQuota.setMaxStorage(quotaRoot, maxStorageQuota); } @Override public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { - perUserQuota.setMaxMessage(quotaRoot, maxMessageCount).block(); + setMaxMessageReactive(quotaRoot, maxMessageCount).block(); + } + + @Override + public Mono<Void> setMaxMessageReactive(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { + return perUserQuota.setMaxMessage(quotaRoot, maxMessageCount); } @Override public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) { - perDomainQuota.setMaxMessage(domain, count).block(); + setDomainMaxMessageReactive(domain, count).block(); + } + + @Override + public Mono<Void> setDomainMaxMessageReactive(Domain domain, QuotaCountLimit count) { + return perDomainQuota.setMaxMessage(domain, count); } @Override public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) { - perDomainQuota.setMaxStorage(domain, size).block(); + setDomainMaxStorageReactive(domain, size).block(); + } + + @Override + public Mono<Void> setDomainMaxStorageReactive(Domain domain, QuotaSizeLimit size) { + return perDomainQuota.setMaxStorage(domain, size); } @Override public void removeDomainMaxMessage(Domain domain) { - perDomainQuota.removeMaxMessage(domain).block(); + removeDomainMaxMessageReactive(domain).block(); + } + + @Override + public Mono<Void> removeDomainMaxMessageReactive(Domain domain) { + return perDomainQuota.removeMaxMessage(domain); } @Override public void removeDomainMaxStorage(Domain domain) { - perDomainQuota.removeMaxStorage(domain).block(); + removeDomainMaxStorageReactive(domain).block(); + } + + @Override + public Mono<Void> removeDomainMaxStorageReactive(Domain domain) { + return perDomainQuota.removeMaxStorage(domain); } @Override public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) { - return perDomainQuota.getMaxMessage(domain).blockOptional(); + return getDomainMaxMessageReactive(domain).blockOptional(); + } + + @Override + public Mono<QuotaCountLimit> getDomainMaxMessageReactive(Domain domain) { + return perDomainQuota.getMaxMessage(domain); } @Override public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) { - return perDomainQuota.getMaxStorage(domain).blockOptional(); + return getDomainMaxStorageReactive(domain).blockOptional(); + } + + @Override + public Mono<QuotaSizeLimit> getDomainMaxStorageReactive(Domain domain) { + return perDomainQuota.getMaxStorage(domain); } @Override public void removeMaxMessage(QuotaRoot quotaRoot) { - perUserQuota.removeMaxMessage(quotaRoot).block(); + removeMaxMessageReactive(quotaRoot).block(); + } + + @Override + public Mono<Void> removeMaxMessageReactive(QuotaRoot quotaRoot) { + return perUserQuota.removeMaxMessage(quotaRoot); } @Override public void removeMaxStorage(QuotaRoot quotaRoot) { - perUserQuota.removeMaxStorage(quotaRoot).block(); + removeMaxStorageReactive(quotaRoot).block(); + } + + @Override + public Mono<Void> removeMaxStorageReactive(QuotaRoot quotaRoot) { + return perUserQuota.removeMaxStorage(quotaRoot); } @Override public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) { - globalQuota.setGlobalMaxStorage(globalMaxStorage).block(); + setGlobalMaxStorageReactive(globalMaxStorage).block(); + } + + @Override + public Mono<Void> setGlobalMaxStorageReactive(QuotaSizeLimit globalMaxStorage) { + return globalQuota.setGlobalMaxStorage(globalMaxStorage); } @Override public void removeGlobalMaxStorage() { - globalQuota.removeGlobaltMaxStorage().block(); + removeGlobalMaxStorageReactive().block(); + } + + @Override + public Mono<Void> removeGlobalMaxStorageReactive() { + return globalQuota.removeGlobaltMaxStorage(); } @Override public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) { - globalQuota.setGlobalMaxMessage(globalMaxMessageCount).block(); + setGlobalMaxMessageReactive(globalMaxMessageCount).block(); + } + + @Override + public Mono<Void> setGlobalMaxMessageReactive(QuotaCountLimit globalMaxMessageCount) { + return globalQuota.setGlobalMaxMessage(globalMaxMessageCount); } @Override public void removeGlobalMaxMessage() { - globalQuota.removeGlobalMaxMessage().block(); + removeGlobalMaxMessageReactive().block(); + } + + @Override + public Mono<Void> removeGlobalMaxMessageReactive() { + return globalQuota.removeGlobalMaxMessage(); } @Override public Optional<QuotaSizeLimit> getGlobalMaxStorage() { - return globalQuota.getGlobalMaxStorage().blockOptional(); + return getGlobalMaxStorageReactive().blockOptional(); + } + + @Override + public Mono<QuotaSizeLimit> getGlobalMaxStorageReactive() { + return globalQuota.getGlobalMaxStorage(); } @Override public Optional<QuotaCountLimit> getGlobalMaxMessage() { - return globalQuota.getGlobalMaxMessage().blockOptional(); + return getGlobalMaxMessageReactive().blockOptional(); + } + + @Override + public Mono<QuotaCountLimit> getGlobalMaxMessageReactive() { + return globalQuota.getGlobalMaxMessage(); } @Override 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 1706a277f0..8b29dbdb88 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 @@ -33,10 +33,13 @@ 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; +import org.reactivestreams.Publisher; import com.github.fge.lambdas.Throwing; import com.google.common.collect.ImmutableMap; +import reactor.core.publisher.Mono; + public class JPAPerUserMaxQuotaManager implements MaxQuotaManager { private final JPAPerUserMaxQuotaDAO dao; @@ -51,71 +54,145 @@ public class JPAPerUserMaxQuotaManager implements MaxQuotaManager { dao.setMaxStorage(quotaRoot, Optional.of(maxStorageQuota)); } + @Override + public Publisher<Void> setMaxStorageReactive(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) { + return Mono.fromRunnable(() -> setMaxStorage(quotaRoot, maxStorageQuota)); + } + @Override public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { dao.setMaxMessage(quotaRoot, Optional.of(maxMessageCount)); } + @Override + public Publisher<Void> setMaxMessageReactive(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { + return Mono.fromRunnable(() -> setMaxMessage(quotaRoot, maxMessageCount)); + } + @Override public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) { dao.setDomainMaxMessage(domain, Optional.of(count)); } + @Override + public Publisher<Void> setDomainMaxMessageReactive(Domain domain, QuotaCountLimit count) { + return Mono.fromRunnable(() -> setDomainMaxMessage(domain, count)); + } + @Override public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) { dao.setDomainMaxStorage(domain, Optional.of(size)); } + @Override + public Publisher<Void> setDomainMaxStorageReactive(Domain domain, QuotaSizeLimit size) { + return Mono.fromRunnable(() -> setDomainMaxStorage(domain, size)); + } + @Override public void removeDomainMaxMessage(Domain domain) { dao.setDomainMaxMessage(domain, Optional.empty()); } + @Override + public Publisher<Void> removeDomainMaxMessageReactive(Domain domain) { + return Mono.fromRunnable(() -> removeDomainMaxMessage(domain)); + } + @Override public void removeDomainMaxStorage(Domain domain) { dao.setDomainMaxStorage(domain, Optional.empty()); } + @Override + public Publisher<Void> removeDomainMaxStorageReactive(Domain domain) { + return Mono.fromRunnable(() -> removeDomainMaxStorage(domain)); + } + @Override public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) { return dao.getDomainMaxMessage(domain); } + @Override + public Publisher<QuotaCountLimit> getDomainMaxMessageReactive(Domain domain) { + return Mono.fromSupplier(() -> getDomainMaxMessage(domain)) + .flatMap(Mono::justOrEmpty); + } + @Override public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) { return dao.getDomainMaxStorage(domain); } + @Override + public Publisher<QuotaSizeLimit> getDomainMaxStorageReactive(Domain domain) { + return Mono.fromSupplier(() -> getDomainMaxStorage(domain)) + .flatMap(Mono::justOrEmpty); + } + @Override public void removeMaxMessage(QuotaRoot quotaRoot) { dao.setMaxMessage(quotaRoot, Optional.empty()); } + @Override + public Publisher<Void> removeMaxMessageReactive(QuotaRoot quotaRoot) { + return Mono.fromRunnable(() -> removeMaxMessage(quotaRoot)); + } + @Override public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) { dao.setGlobalMaxStorage(Optional.of(globalMaxStorage)); } + @Override + public Publisher<Void> setGlobalMaxStorageReactive(QuotaSizeLimit globalMaxStorage) { + return Mono.fromRunnable(() -> setGlobalMaxStorage(globalMaxStorage)); + } + @Override public void removeGlobalMaxMessage() { dao.setGlobalMaxMessage(Optional.empty()); } + @Override + public Publisher<Void> removeGlobalMaxMessageReactive() { + return Mono.fromRunnable(this::removeGlobalMaxMessage); + } + @Override public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) { dao.setGlobalMaxMessage(Optional.of(globalMaxMessageCount)); } + @Override + public Publisher<Void> setGlobalMaxMessageReactive(QuotaCountLimit globalMaxMessageCount) { + return Mono.fromRunnable(() -> setGlobalMaxMessage(globalMaxMessageCount)); + } + @Override public Optional<QuotaSizeLimit> getGlobalMaxStorage() { return dao.getGlobalMaxStorage(); } + @Override + public Publisher<QuotaSizeLimit> getGlobalMaxStorageReactive() { + return Mono.fromSupplier(this::getGlobalMaxStorage) + .flatMap(Mono::justOrEmpty); + } + @Override public Optional<QuotaCountLimit> getGlobalMaxMessage() { return dao.getGlobalMaxMessage(); } + @Override + public Publisher<QuotaCountLimit> getGlobalMaxMessageReactive() { + return Mono.fromSupplier(this::getGlobalMaxMessage) + .flatMap(Mono::justOrEmpty); + } + @Override public Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot) { Function<Domain, Optional<QuotaCountLimit>> domainQuotaFunction = Throwing.function(this::getDomainMaxMessage).sneakyThrow(); @@ -143,9 +220,19 @@ public class JPAPerUserMaxQuotaManager implements MaxQuotaManager { dao.setMaxStorage(quotaRoot, Optional.empty()); } + @Override + public Publisher<Void> removeMaxStorageReactive(QuotaRoot quotaRoot) { + return Mono.fromRunnable(() -> removeMaxStorage(quotaRoot)); + } + @Override public void removeGlobalMaxStorage() { dao.setGlobalMaxStorage(Optional.empty()); } + @Override + public Publisher<Void> removeGlobalMaxStorageReactive() { + return Mono.fromRunnable(this::removeGlobalMaxStorage); + } + } 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 3e568285f7..c79a62a9ff 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 @@ -31,10 +31,13 @@ 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; +import org.reactivestreams.Publisher; import com.github.fge.lambdas.Throwing; import com.google.common.collect.ImmutableMap; +import reactor.core.publisher.Mono; + public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager { private Optional<QuotaCountLimit> maxMessage = Optional.empty(); @@ -51,26 +54,51 @@ public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager { this.maxStorage = Optional.of(maxStorage); } + @Override + public Publisher<Void> setGlobalMaxStorageReactive(QuotaSizeLimit globalMaxStorage) { + return Mono.fromRunnable(() -> setGlobalMaxStorage(globalMaxStorage)); + } + @Override public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) { domainMaxMessage.put(domain, count); } + @Override + public Publisher<Void> setDomainMaxMessageReactive(Domain domain, QuotaCountLimit count) { + return Mono.fromRunnable(() -> setDomainMaxMessage(domain, count)); + } + @Override public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) { domainMaxStorage.put(domain, size); } + @Override + public Publisher<Void> setDomainMaxStorageReactive(Domain domain, QuotaSizeLimit size) { + return Mono.fromRunnable(() -> setDomainMaxStorage(domain, size)); + } + @Override public void removeDomainMaxMessage(Domain domain) { domainMaxMessage.remove(domain); } + @Override + public Publisher<Void> removeDomainMaxMessageReactive(Domain domain) { + return Mono.fromRunnable(() -> removeDomainMaxMessage(domain)); + } + @Override public void removeDomainMaxStorage(Domain domain) { domainMaxStorage.remove(domain); } + @Override + public Publisher<Void> removeDomainMaxStorageReactive(Domain domain) { + return Mono.fromRunnable(() -> removeDomainMaxStorage(domain)); + } + @Override public Map<Quota.Scope, QuotaCountLimit> listMaxMessagesDetails(QuotaRoot quotaRoot) { Function<Domain, Optional<QuotaCountLimit>> domainQuotaFunction = Throwing.function(this::getDomainMaxMessage).sneakyThrow(); @@ -98,53 +126,108 @@ public class InMemoryPerUserMaxQuotaManager implements MaxQuotaManager { this.maxMessage = Optional.of(maxMessage); } + @Override + public Publisher<Void> setGlobalMaxMessageReactive(QuotaCountLimit globalMaxMessageCount) { + return Mono.fromRunnable(() -> setGlobalMaxMessage(globalMaxMessageCount)); + } + @Override public Optional<QuotaCountLimit> getDomainMaxMessage(Domain domain) { return Optional.ofNullable(domainMaxMessage.get(domain)); } + @Override + public Publisher<QuotaCountLimit> getDomainMaxMessageReactive(Domain domain) { + return Mono.justOrEmpty(getDomainMaxMessage(domain)); + } + @Override public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) { return Optional.ofNullable(domainMaxStorage.get(domain)); } + @Override + public Publisher<QuotaSizeLimit> getDomainMaxStorageReactive(Domain domain) { + return Mono.justOrEmpty(getDomainMaxStorage(domain)); + } + @Override public void setMaxStorage(QuotaRoot user, QuotaSizeLimit maxStorageQuota) { userMaxStorage.put(user.getValue(), maxStorageQuota); } + @Override + public Publisher<Void> setMaxStorageReactive(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) { + return Mono.fromRunnable(() -> setMaxStorage(quotaRoot, maxStorageQuota)); + } + @Override public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { userMaxMessage.put(quotaRoot.getValue(), maxMessageCount); } + @Override + public Publisher<Void> setMaxMessageReactive(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { + return Mono.fromRunnable(() -> setMaxMessage(quotaRoot, maxMessageCount)); + } + @Override public Optional<QuotaSizeLimit> getGlobalMaxStorage() { return maxStorage; } + @Override + public Publisher<QuotaSizeLimit> getGlobalMaxStorageReactive() { + return Mono.justOrEmpty(getGlobalMaxStorage()); + } + @Override public Optional<QuotaCountLimit> getGlobalMaxMessage() { return maxMessage; } + @Override + public Publisher<QuotaCountLimit> getGlobalMaxMessageReactive() { + return Mono.justOrEmpty(getGlobalMaxMessage()); + } + @Override public void removeMaxMessage(QuotaRoot quotaRoot) { userMaxMessage.remove(quotaRoot.getValue()); } + @Override + public Publisher<Void> removeMaxMessageReactive(QuotaRoot quotaRoot) { + return Mono.fromRunnable(() -> removeMaxMessage(quotaRoot)); + } + @Override public void removeMaxStorage(QuotaRoot quotaRoot) { userMaxStorage.remove(quotaRoot.getValue()); } + @Override + public Publisher<Void> removeMaxStorageReactive(QuotaRoot quotaRoot) { + return Mono.fromRunnable(() -> removeMaxStorage(quotaRoot)); + } + @Override public void removeGlobalMaxStorage() { maxStorage = Optional.empty(); } + @Override + public Publisher<Void> removeGlobalMaxStorageReactive() { + return Mono.fromRunnable(this::removeGlobalMaxStorage); + } + @Override public void removeGlobalMaxMessage() { maxMessage = Optional.empty(); } + + @Override + public Publisher<Void> removeGlobalMaxMessageReactive() { + return Mono.fromRunnable(this::removeGlobalMaxMessage); + } } 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 5ee9d8e040..9890525de6 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 @@ -11,9 +11,12 @@ 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.reactivestreams.Publisher; import com.google.common.collect.ImmutableMap; +import reactor.core.publisher.Mono; + /** * {@link MaxQuotaManager} which use the same quota for all users. * @@ -29,51 +32,101 @@ public class FixedMaxQuotaManager implements MaxQuotaManager { throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); } + @Override + public Publisher<Void> setMaxStorageReactive(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) throws MailboxException { throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); } + @Override + public Publisher<Void> setMaxMessageReactive(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { + return Mono.error(() -> 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 Publisher<Void> removeMaxMessageReactive(QuotaRoot quotaRoot) { + return Mono.error(() -> 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 Publisher<Void> removeMaxStorageReactive(QuotaRoot quotaRoot) { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) throws MailboxException { throw new UnsupportedOperationException("Can not modify domain specific upper limit for FixedMaxQuotaManager"); } + @Override + public Publisher<Void> setDomainMaxMessageReactive(Domain domain, QuotaCountLimit count) { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) throws UnsupportedOperationException { throw new UnsupportedOperationException("Can not modify domain specific upper limit for FixedMaxQuotaManager"); } + @Override + public Publisher<Void> setDomainMaxStorageReactive(Domain domain, QuotaSizeLimit size) { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) { maxStorage = Optional.of(globalMaxStorage); } + @Override + public Publisher<Void> setGlobalMaxStorageReactive(QuotaSizeLimit globalMaxStorage) { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public void removeGlobalMaxStorage() throws MailboxException { throw new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager"); } + @Override + public Publisher<Void> removeGlobalMaxStorageReactive() { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public void removeGlobalMaxMessage() { maxMessage = Optional.empty(); } + @Override + public Publisher<Void> removeGlobalMaxMessageReactive() { + return Mono.fromRunnable(() -> maxMessage = Optional.empty()); + } + @Override public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) { maxMessage = Optional.empty(); } + @Override + public Publisher<Void> setGlobalMaxMessageReactive(QuotaCountLimit globalMaxMessageCount) { + return Mono.fromRunnable(() -> maxMessage = Optional.empty()); + } + @Override public Optional<QuotaSizeLimit> getMaxStorage(QuotaRoot quotaRoot) { return maxStorage; @@ -103,28 +156,58 @@ public class FixedMaxQuotaManager implements MaxQuotaManager { return Optional.empty(); } + @Override + public Publisher<QuotaCountLimit> getDomainMaxMessageReactive(Domain domain) { + return Mono.empty(); + } + @Override public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) { return Optional.empty(); } + @Override + public Publisher<QuotaSizeLimit> getDomainMaxStorageReactive(Domain domain) { + return Mono.empty(); + } + @Override public void removeDomainMaxMessage(Domain domain) throws UnsupportedOperationException { throw new UnsupportedOperationException("Can not modify domain specific upper limit for FixedMaxQuotaManager"); } + @Override + public Publisher<Void> removeDomainMaxMessageReactive(Domain domain) { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public void removeDomainMaxStorage(Domain domain) throws UnsupportedOperationException { throw new UnsupportedOperationException("Can not modify domain specific upper limit for FixedMaxQuotaManager"); } + @Override + public Publisher<Void> removeDomainMaxStorageReactive(Domain domain) { + return Mono.error(() -> new UnsupportedOperationException("Can not modify QuotaRoot specific upper limit for FixedMaxQuotaManager")); + } + @Override public Optional<QuotaSizeLimit> getGlobalMaxStorage() { return maxStorage; } + @Override + public Publisher<QuotaSizeLimit> getGlobalMaxStorageReactive() { + return Mono.justOrEmpty(maxStorage); + } + @Override public Optional<QuotaCountLimit> getGlobalMaxMessage() { return maxMessage; } + + @Override + public Publisher<QuotaCountLimit> getGlobalMaxMessageReactive() { + return Mono.justOrEmpty(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 a280e8d978..a475c6582a 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 @@ -29,9 +29,12 @@ 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.reactivestreams.Publisher; import com.google.common.collect.ImmutableMap; +import reactor.core.publisher.Mono; + /** * A Max Quota Manager that simply throws exceptions * @@ -44,61 +47,121 @@ public class NoMaxQuotaManager implements MaxQuotaManager { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> setMaxStorageReactive(QuotaRoot quotaRoot, QuotaSizeLimit maxStorageQuota) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void setMaxMessage(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> setMaxMessageReactive(QuotaRoot quotaRoot, QuotaCountLimit maxMessageCount) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void removeMaxMessage(QuotaRoot quotaRoot) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> removeMaxMessageReactive(QuotaRoot quotaRoot) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void removeMaxStorage(QuotaRoot quotaRoot) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> removeMaxStorageReactive(QuotaRoot quotaRoot) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void setDomainMaxMessage(Domain domain, QuotaCountLimit count) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> setDomainMaxMessageReactive(Domain domain, QuotaCountLimit count) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void setDomainMaxStorage(Domain domain, QuotaSizeLimit size) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> setDomainMaxStorageReactive(Domain domain, QuotaSizeLimit size) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void removeDomainMaxMessage(Domain domain) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> removeDomainMaxMessageReactive(Domain domain) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void removeDomainMaxStorage(Domain domain) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> removeDomainMaxStorageReactive(Domain domain) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void setGlobalMaxStorage(QuotaSizeLimit globalMaxStorage) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> setGlobalMaxStorageReactive(QuotaSizeLimit globalMaxStorage) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void removeGlobalMaxStorage() throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> removeGlobalMaxStorageReactive() { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void removeGlobalMaxMessage() throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> removeGlobalMaxMessageReactive() { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public void setGlobalMaxMessage(QuotaCountLimit globalMaxMessageCount) throws MailboxException { throw new MailboxException("Operation is not supported"); } + @Override + public Publisher<Void> setGlobalMaxMessageReactive(QuotaCountLimit globalMaxMessageCount) { + return Mono.error(() -> new MailboxException("Operation is not supported")); + } + @Override public Optional<QuotaSizeLimit> getMaxStorage(QuotaRoot quotaRoot) { return Optional.empty(); @@ -124,18 +187,38 @@ public class NoMaxQuotaManager implements MaxQuotaManager { return Optional.empty(); } + @Override + public Publisher<QuotaCountLimit> getDomainMaxMessageReactive(Domain domain) { + return Mono.empty(); + } + @Override public Optional<QuotaSizeLimit> getDomainMaxStorage(Domain domain) { return Optional.empty(); } + @Override + public Publisher<QuotaSizeLimit> getDomainMaxStorageReactive(Domain domain) { + return Mono.empty(); + } + @Override public Optional<QuotaSizeLimit> getGlobalMaxStorage() { return Optional.empty(); } + @Override + public Publisher<QuotaSizeLimit> getGlobalMaxStorageReactive() { + return Mono.empty(); + } + @Override public Optional<QuotaCountLimit> getGlobalMaxMessage() { return Optional.empty(); } + + @Override + public Publisher<QuotaCountLimit> getGlobalMaxMessageReactive() { + return Mono.empty(); + } } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
