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:48 UTC
[james-project] branch master updated (b85800bbc0 -> 570da90f29)
This is an automated email from the ASF dual-hosted git repository.
rcordier pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
from b85800bbc0 [FIX] Declare all netty libs on master pom
new 89ec352158 MaxQuotaManager should support more reactive methods
new 570da90f29 Adapt MaxQuotaManager reactive api for webadmin-mailbox
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../james/mailbox/quota/MaxQuotaManager.java | 51 ++++++----
.../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 +++++++++++++++
.../apache/james/webadmin/dto/QuotaDetailsDTO.java | 6 ++
.../james/webadmin/service/DomainQuotaService.java | 102 +++++++++++--------
.../james/webadmin/service/GlobalQuotaService.java | 76 ++++++++------
.../james/webadmin/service/UserQuotaService.java | 98 +++++++++---------
10 files changed, 622 insertions(+), 159 deletions(-)
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org
[james-project] 01/02: MaxQuotaManager should support more reactive methods
Posted by rc...@apache.org.
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
[james-project] 02/02: Adapt MaxQuotaManager reactive api for webadmin-mailbox
Posted by rc...@apache.org.
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 570da90f29b82414982f59819e78ab2cc3e6ae00
Author: Tung Van TRAN <vt...@linagora.com>
AuthorDate: Fri Mar 24 15:53:55 2023 +0700
Adapt MaxQuotaManager reactive api for webadmin-mailbox
---
.../james/mailbox/quota/MaxQuotaManager.java | 21 -----
.../apache/james/webadmin/dto/QuotaDetailsDTO.java | 6 ++
.../james/webadmin/service/DomainQuotaService.java | 102 ++++++++++++---------
.../james/webadmin/service/GlobalQuotaService.java | 76 ++++++++-------
.../james/webadmin/service/UserQuotaService.java | 98 ++++++++++----------
5 files changed, 159 insertions(+), 144 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 66275b3fc8..050300ce0f 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
@@ -22,7 +22,6 @@ package org.apache.james.mailbox.quota;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
-import java.util.function.Supplier;
import java.util.stream.Stream;
import org.apache.james.core.Domain;
@@ -35,8 +34,6 @@ import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.util.ReactorUtils;
import org.reactivestreams.Publisher;
-import com.github.fge.lambdas.Throwing;
-
import reactor.core.publisher.Mono;
/**
@@ -221,24 +218,6 @@ public interface MaxQuotaManager {
Publisher<Void> removeDomainMaxStorageReactive(Domain domain);
- default Optional<QuotaCountLimit> getComputedMaxMessage(Domain domain) throws MailboxException {
- return Stream.of(
- Throwing.supplier(() -> getDomainMaxMessage(domain)).sneakyThrow(),
- Throwing.supplier(this::getGlobalMaxMessage).sneakyThrow())
- .map(Supplier::get)
- .flatMap(Optional::stream)
- .findFirst();
- }
-
- default Optional<QuotaSizeLimit> getComputedMaxStorage(Domain domain) throws MailboxException {
- return Stream.of(
- Throwing.supplier(() -> getDomainMaxStorage(domain)).sneakyThrow(),
- Throwing.supplier(this::getGlobalMaxStorage).sneakyThrow())
- .map(Supplier::get)
- .flatMap(Optional::stream)
- .findFirst();
- }
-
class QuotaDetails {
private final Map<Quota.Scope, QuotaCountLimit> maxMessageDetails;
private final Map<Quota.Scope, QuotaSizeLimit> maxStorageDetails;
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java
index 08bb9bccff..a0ee291b0b 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/dto/QuotaDetailsDTO.java
@@ -20,6 +20,7 @@
package org.apache.james.webadmin.dto;
+import java.util.Map;
import java.util.Optional;
import org.apache.james.core.quota.QuotaCountLimit;
@@ -86,6 +87,11 @@ public class QuotaDetailsDTO {
return this;
}
+ public Builder valueForScopes(Map<Quota.Scope, ValidatedQuotaDTO> value) {
+ value.forEach(this::valueForScope);
+ return this;
+ }
+
public QuotaDetailsDTO build() {
Preconditions.checkNotNull(occupation);
return new QuotaDetailsDTO(global, domain, user, computed, occupation);
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java
index 2d0864e747..ec11e8ecf7 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/DomainQuotaService.java
@@ -26,11 +26,12 @@ import javax.inject.Inject;
import org.apache.james.core.Domain;
import org.apache.james.core.quota.QuotaCountLimit;
import org.apache.james.core.quota.QuotaSizeLimit;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.webadmin.dto.QuotaDomainDTO;
import org.apache.james.webadmin.dto.ValidatedQuotaDTO;
+import reactor.core.publisher.Mono;
+
public class DomainQuotaService {
private final MaxQuotaManager maxQuotaManager;
@@ -41,61 +42,80 @@ public class DomainQuotaService {
}
public Optional<QuotaCountLimit> getMaxCountQuota(Domain domain) {
- return maxQuotaManager.getDomainMaxMessage(domain);
+ return Mono.from(maxQuotaManager.getDomainMaxMessageReactive(domain)).blockOptional();
}
- public void setMaxCountQuota(Domain domain, QuotaCountLimit quotaCount) throws MailboxException {
- maxQuotaManager.setDomainMaxMessage(domain, quotaCount);
+ public void setMaxCountQuota(Domain domain, QuotaCountLimit quotaCount) {
+ Mono.from(maxQuotaManager.setDomainMaxMessageReactive(domain, quotaCount)).block();
}
- public void remoteMaxQuotaCount(Domain domain) throws MailboxException {
- maxQuotaManager.removeDomainMaxMessage(domain);
+ public void remoteMaxQuotaCount(Domain domain) {
+ Mono.from(maxQuotaManager.removeDomainMaxMessageReactive(domain)).block();
}
public Optional<QuotaSizeLimit> getMaxSizeQuota(Domain domain) {
- return maxQuotaManager.getDomainMaxStorage(domain);
+ return Mono.from(maxQuotaManager.getDomainMaxStorageReactive(domain)).blockOptional();
}
- public void setMaxSizeQuota(Domain domain, QuotaSizeLimit quotaSize) throws MailboxException {
- maxQuotaManager.setDomainMaxStorage(domain, quotaSize);
+ public void setMaxSizeQuota(Domain domain, QuotaSizeLimit quotaSize) {
+ Mono.from(maxQuotaManager.setDomainMaxStorageReactive(domain, quotaSize)).block();
}
- public void remoteMaxQuotaSize(Domain domain) throws MailboxException {
- maxQuotaManager.removeDomainMaxStorage(domain);
+ public void remoteMaxQuotaSize(Domain domain) {
+ Mono.from(maxQuotaManager.removeDomainMaxStorageReactive(domain)).block();
}
- public QuotaDomainDTO getQuota(Domain domain) throws MailboxException {
- return QuotaDomainDTO.builder()
- .domain(ValidatedQuotaDTO
- .builder()
- .count(maxQuotaManager.getDomainMaxMessage(domain))
- .size(maxQuotaManager.getDomainMaxStorage(domain)))
- .global(ValidatedQuotaDTO
- .builder()
- .count(maxQuotaManager.getGlobalMaxMessage())
- .size(maxQuotaManager.getGlobalMaxStorage()))
- .computed(ValidatedQuotaDTO
- .builder()
- .count(maxQuotaManager.getComputedMaxMessage(domain))
- .size(maxQuotaManager.getComputedMaxStorage(domain)))
- .build();
+ public QuotaDomainDTO getQuota(Domain domain) {
+ Mono<Optional<QuotaCountLimit>> getDomainMaxMessage = Mono.from(maxQuotaManager.getDomainMaxMessageReactive(domain))
+ .map(Optional::of)
+ .defaultIfEmpty(Optional.empty());
+ Mono<Optional<QuotaSizeLimit>> getDomainMaxStorage = Mono.from(maxQuotaManager.getDomainMaxStorageReactive(domain))
+ .map(Optional::of)
+ .defaultIfEmpty(Optional.empty());
+
+ Mono<Optional<QuotaCountLimit>> getGlobalMaxMessage = Mono.from(maxQuotaManager.getGlobalMaxMessageReactive())
+ .map(Optional::of)
+ .defaultIfEmpty(Optional.empty());
+ Mono<Optional<QuotaSizeLimit>> getGlobalMaxStorage = Mono.from(maxQuotaManager.getGlobalMaxStorageReactive())
+ .map(Optional::of)
+ .defaultIfEmpty(Optional.empty());
+
+ return Mono.zip(getDomainMaxMessage,
+ getDomainMaxStorage,
+ getGlobalMaxMessage,
+ getGlobalMaxStorage)
+ .map(tuple4 -> QuotaDomainDTO.builder()
+ .domain(ValidatedQuotaDTO
+ .builder()
+ .count(tuple4.getT1())
+ .size(tuple4.getT2()))
+ .global(ValidatedQuotaDTO
+ .builder()
+ .count(tuple4.getT3())
+ .size(tuple4.getT4()))
+ .computed(ValidatedQuotaDTO
+ .builder()
+ .count(tuple4.getT1().or(tuple4::getT3))
+ .size(tuple4.getT2().or(tuple4::getT4)))
+ .build())
+ .block();
}
public void defineQuota(Domain domain, ValidatedQuotaDTO quota) {
- try {
- if (quota.getCount().isPresent()) {
- maxQuotaManager.setDomainMaxMessage(domain, quota.getCount().get());
- } else {
- maxQuotaManager.removeDomainMaxMessage(domain);
- }
-
- if (quota.getSize().isPresent()) {
- maxQuotaManager.setDomainMaxStorage(domain, quota.getSize().get());
- } else {
- maxQuotaManager.removeDomainMaxStorage(domain);
- }
- } catch (MailboxException e) {
- throw new RuntimeException(e);
- }
+ defineDomainMaxMessage(domain, quota)
+ .then(defineDomainMaxStorage(domain, quota))
+ .block();
+ }
+
+ private Mono<Void> defineDomainMaxStorage(Domain domain, ValidatedQuotaDTO quota) {
+ return quota.getSize()
+ .map(sizeLimit -> Mono.from(maxQuotaManager.setDomainMaxStorageReactive(domain, sizeLimit)))
+ .orElseGet(() -> Mono.from(maxQuotaManager.removeDomainMaxStorageReactive(domain)));
+ }
+
+ private Mono<Void> defineDomainMaxMessage(Domain domain, ValidatedQuotaDTO quota) {
+ return quota.getCount()
+ .map(countLimit -> Mono.from(maxQuotaManager.setDomainMaxMessageReactive(domain, countLimit)))
+ .orElseGet(() -> Mono.from(maxQuotaManager.removeDomainMaxMessageReactive(domain)));
}
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java
index a957c4d07b..787ba6cb19 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/GlobalQuotaService.java
@@ -24,10 +24,11 @@ import javax.inject.Inject;
import org.apache.james.core.quota.QuotaCountLimit;
import org.apache.james.core.quota.QuotaSizeLimit;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.webadmin.dto.ValidatedQuotaDTO;
+import reactor.core.publisher.Mono;
+
public class GlobalQuotaService {
private final MaxQuotaManager maxQuotaManager;
@@ -37,51 +38,60 @@ public class GlobalQuotaService {
this.maxQuotaManager = maxQuotaManager;
}
- public void defineQuota(ValidatedQuotaDTO quota) throws MailboxException {
- Optional<QuotaCountLimit> count = quota.getCount();
- if (count.isPresent()) {
- maxQuotaManager.setGlobalMaxMessage(count.get());
- } else {
- maxQuotaManager.removeGlobalMaxMessage();
- }
-
- Optional<QuotaSizeLimit> size = quota.getSize();
- if (size.isPresent()) {
- maxQuotaManager.setGlobalMaxStorage(size.get());
- } else {
- maxQuotaManager.removeGlobalMaxStorage();
- }
+ public void defineQuota(ValidatedQuotaDTO quota) {
+ defineGlobalMaxMessage(quota)
+ .then(defineGlobalMaxStorage(quota))
+ .block();
+ }
+
+ private Mono<Void> defineGlobalMaxStorage(ValidatedQuotaDTO quota) {
+ return quota.getSize()
+ .map(sizeLimit -> Mono.from(maxQuotaManager.setGlobalMaxStorageReactive(sizeLimit)))
+ .orElseGet(() -> Mono.from(maxQuotaManager.removeGlobalMaxStorageReactive()));
+ }
+
+ private Mono<Void> defineGlobalMaxMessage(ValidatedQuotaDTO quota) {
+ return quota.getCount()
+ .map(countLimit -> Mono.from(maxQuotaManager.setGlobalMaxMessageReactive(countLimit)))
+ .orElseGet(() -> Mono.from(maxQuotaManager.removeGlobalMaxMessageReactive()));
}
- public ValidatedQuotaDTO getQuota() throws MailboxException {
- return ValidatedQuotaDTO
- .builder()
- .count(maxQuotaManager.getGlobalMaxMessage())
- .size(maxQuotaManager.getGlobalMaxStorage())
- .build();
+ public ValidatedQuotaDTO getQuota() {
+ return Mono.zip(Mono.from(maxQuotaManager.getGlobalMaxMessageReactive())
+ .map(Optional::of)
+ .switchIfEmpty(Mono.just(Optional.empty())),
+ Mono.from(maxQuotaManager.getGlobalMaxStorageReactive())
+ .map(Optional::of)
+ .switchIfEmpty(Mono.just(Optional.empty())))
+ .map(tuple -> ValidatedQuotaDTO
+ .builder()
+ .count(tuple.getT1())
+ .size(tuple.getT2())
+ .build())
+ .block();
}
- public Optional<QuotaSizeLimit> getMaxSizeQuota() throws MailboxException {
- return maxQuotaManager.getGlobalMaxStorage();
+ public Optional<QuotaSizeLimit> getMaxSizeQuota() {
+ return Mono.from(maxQuotaManager.getGlobalMaxStorageReactive()).blockOptional();
}
- public void defineMaxSizeQuota(QuotaSizeLimit quotaRequest) throws MailboxException {
- maxQuotaManager.setGlobalMaxStorage(quotaRequest);
+ public void defineMaxSizeQuota(QuotaSizeLimit quotaRequest) {
+ Mono.from(maxQuotaManager.setGlobalMaxStorageReactive(quotaRequest)).block();
}
- public void deleteMaxSizeQuota() throws MailboxException {
- maxQuotaManager.removeGlobalMaxStorage();
+ public void deleteMaxSizeQuota() {
+ Mono.from(maxQuotaManager.removeGlobalMaxStorageReactive()).block();
}
- public Optional<QuotaCountLimit> getMaxCountQuota() throws MailboxException {
- return maxQuotaManager.getGlobalMaxMessage();
+ public Optional<QuotaCountLimit> getMaxCountQuota() {
+ return Mono.from(maxQuotaManager.getGlobalMaxMessageReactive()).blockOptional();
}
- public void defineMaxCountQuota(QuotaCountLimit value) throws MailboxException {
- maxQuotaManager.setGlobalMaxMessage(value);
+ public void defineMaxCountQuota(QuotaCountLimit value) {
+ Mono.from(maxQuotaManager.setGlobalMaxMessageReactive(value)).block();
}
- public void deleteMaxCountQuota() throws MailboxException {
- maxQuotaManager.removeGlobalMaxMessage();
+ public void deleteMaxCountQuota() {
+ Mono.from(maxQuotaManager.removeGlobalMaxMessageReactive()).block();
}
}
diff --git a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java
index 22c9a024da..7d68471cf6 100644
--- a/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java
+++ b/server/protocols/webadmin/webadmin-mailbox/src/main/java/org/apache/james/webadmin/service/UserQuotaService.java
@@ -29,7 +29,6 @@ import javax.inject.Inject;
import org.apache.james.core.Username;
import org.apache.james.core.quota.QuotaCountLimit;
import org.apache.james.core.quota.QuotaSizeLimit;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.MaxQuotaManager;
@@ -45,6 +44,8 @@ import com.github.fge.lambdas.Throwing;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
+import reactor.core.publisher.Mono;
+
public class UserQuotaService {
private final MaxQuotaManager maxQuotaManager;
@@ -61,49 +62,44 @@ public class UserQuotaService {
}
public void defineQuota(Username username, ValidatedQuotaDTO quota) {
- try {
- QuotaRoot quotaRoot = userQuotaRootResolver.forUser(username);
- if (quota.getCount().isPresent()) {
- maxQuotaManager.setMaxMessage(quotaRoot, quota.getCount().get());
- } else {
- maxQuotaManager.removeMaxMessage(quotaRoot);
- }
-
- if (quota.getSize().isPresent()) {
- maxQuotaManager.setMaxStorage(quotaRoot, quota.getSize().get());
- } else {
- maxQuotaManager.removeMaxStorage(quotaRoot);
- }
- } catch (MailboxException e) {
- throw new RuntimeException(e);
- }
+ QuotaRoot quotaRoot = userQuotaRootResolver.forUser(username);
+ defineUserMaxMessage(quotaRoot, quota)
+ .then(defineUserMaxStorage(quotaRoot, quota))
+ .block();
}
- public QuotaDetailsDTO getQuota(Username username) throws MailboxException {
- return getQuota(userQuotaRootResolver.forUser(username));
+ private Mono<Void> defineUserMaxMessage(QuotaRoot quotaRoot, ValidatedQuotaDTO quota) {
+ return quota.getCount()
+ .map(countLimit -> Mono.from(maxQuotaManager.setMaxMessageReactive(quotaRoot, countLimit)))
+ .orElseGet(() -> Mono.from(maxQuotaManager.removeMaxMessageReactive(quotaRoot)));
}
- private QuotaDetailsDTO getQuota(QuotaRoot quotaRoot) throws MailboxException {
- QuotaManager.Quotas quotas = quotaManager.getQuotas(quotaRoot);
- QuotaDetailsDTO.Builder quotaDetails = QuotaDetailsDTO.builder()
- .occupation(quotas.getStorageQuota(),
- quotas.getMessageQuota());
-
- mergeMaps(
- maxQuotaManager.listMaxMessagesDetails(quotaRoot),
- maxQuotaManager.listMaxStorageDetails(quotaRoot))
- .forEach(quotaDetails::valueForScope);
+ private Mono<Void> defineUserMaxStorage(QuotaRoot quotaRoot, ValidatedQuotaDTO quota) {
+ return quota.getSize()
+ .map(sizeLimit -> Mono.from(maxQuotaManager.setMaxStorageReactive(quotaRoot, sizeLimit)))
+ .orElseGet(() -> Mono.from(maxQuotaManager.removeMaxStorageReactive(quotaRoot)));
+ }
- quotaDetails.computed(computedQuota(quotaRoot));
- return quotaDetails.build();
+ public QuotaDetailsDTO getQuota(Username username) {
+ return getQuota(userQuotaRootResolver.forUser(username));
}
- private ValidatedQuotaDTO computedQuota(QuotaRoot quotaRoot) throws MailboxException {
- return ValidatedQuotaDTO
- .builder()
- .count(maxQuotaManager.getMaxMessage(quotaRoot))
- .size(maxQuotaManager.getMaxStorage(quotaRoot))
- .build();
+ private QuotaDetailsDTO getQuota(QuotaRoot quotaRoot) {
+ return Mono.zip(
+ Mono.from(quotaManager.getQuotasReactive(quotaRoot)),
+ Mono.from(maxQuotaManager.listMaxMessagesDetailsReactive(quotaRoot)),
+ Mono.from(maxQuotaManager.listMaxStorageDetailsReactive(quotaRoot)))
+ .map(tuple3 -> QuotaDetailsDTO.builder()
+ .occupation(tuple3.getT1().getStorageQuota(),
+ tuple3.getT1().getMessageQuota())
+ .computed(ValidatedQuotaDTO
+ .builder()
+ .count(maxQuotaManager.getMaxMessage(tuple3.getT2()))
+ .size(maxQuotaManager.getMaxStorage(tuple3.getT3()))
+ .build())
+ .valueForScopes(mergeMaps(tuple3.getT2(), tuple3.getT3()))
+ .build())
+ .block();
}
private Map<Quota.Scope, ValidatedQuotaDTO> mergeMaps(Map<Quota.Scope, QuotaCountLimit> counts, Map<Quota.Scope, QuotaSizeLimit> sizes) {
@@ -118,28 +114,32 @@ public class UserQuotaService {
}
- public Optional<QuotaSizeLimit> getMaxSizeQuota(Username username) throws MailboxException {
- return maxQuotaManager.getMaxStorage(userQuotaRootResolver.forUser(username));
+ public Optional<QuotaSizeLimit> getMaxSizeQuota(Username username) {
+ return Mono.from(maxQuotaManager.listMaxStorageDetailsReactive(userQuotaRootResolver.forUser(username)))
+ .map(maxQuotaManager::getMaxStorage)
+ .block();
}
- public void defineMaxSizeQuota(Username username, QuotaSizeLimit quotaSize) throws MailboxException {
- maxQuotaManager.setMaxStorage(userQuotaRootResolver.forUser(username), quotaSize);
+ public void defineMaxSizeQuota(Username username, QuotaSizeLimit quotaSize) {
+ Mono.from(maxQuotaManager.setMaxStorageReactive(userQuotaRootResolver.forUser(username), quotaSize)).block();
}
- public void deleteMaxSizeQuota(Username username) throws MailboxException {
- maxQuotaManager.removeMaxStorage(userQuotaRootResolver.forUser(username));
+ public void deleteMaxSizeQuota(Username username) {
+ Mono.from(maxQuotaManager.removeMaxStorageReactive(userQuotaRootResolver.forUser(username))).block();
}
- public Optional<QuotaCountLimit> getMaxCountQuota(Username username) throws MailboxException {
- return maxQuotaManager.getMaxMessage(userQuotaRootResolver.forUser(username));
+ public Optional<QuotaCountLimit> getMaxCountQuota(Username username) {
+ return Mono.from(maxQuotaManager.listMaxMessagesDetailsReactive(userQuotaRootResolver.forUser(username)))
+ .map(maxQuotaManager::getMaxMessage)
+ .block();
}
- public void defineMaxCountQuota(Username username, QuotaCountLimit quotaCount) throws MailboxException {
- maxQuotaManager.setMaxMessage(userQuotaRootResolver.forUser(username), quotaCount);
+ public void defineMaxCountQuota(Username username, QuotaCountLimit quotaCount) {
+ Mono.from(maxQuotaManager.setMaxMessageReactive(userQuotaRootResolver.forUser(username), quotaCount)).block();
}
- public void deleteMaxCountQuota(Username username) throws MailboxException {
- maxQuotaManager.removeMaxMessage(userQuotaRootResolver.forUser(username));
+ public void deleteMaxCountQuota(Username username) {
+ Mono.from(maxQuotaManager.removeMaxMessageReactive(userQuotaRootResolver.forUser(username))).block();
}
public List<UsersQuotaDetailsDTO> getUsersQuota(QuotaQuery quotaQuery) {
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org