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 <[email protected]> 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: [email protected] For additional commands, e-mail: [email protected]
