You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by rc...@apache.org on 2023/03/27 03:37:49 UTC
[james-project] 01/02: MaxQuotaManager should support more reactive methods
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 <vt...@linagora.com>
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: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org