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 2026/10/09 04:38:07 UTC
(james-project) 02/02: [ENHANCEMENT] GET /users: search by username prefix and domain via typed UsernamePredicate
This is an automated email from the ASF dual-hosted git repository.
Arsnael pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit b8eabb3d9a3e4b8eebb13b8ad3429a2ae2baaff6
Author: Benoit TELLIER <bt...@linagora.com>
AuthorDate: Wed Oct 7 22:20:37 2026 +0200
[ENHANCEMENT] GET /users: search by username prefix and domain via typed UsernamePredicate
---
.../modules/servers/partials/operate/webadmin.adoc | 8 +-
.../org/apache/james/user/api/UsersRepository.java | 48 ++----
.../james/user/api/model/UsernamePredicate.java | 73 ++++++++
.../user/api/model/UsersPaginationHelpers.java | 66 +++++++
.../james/user/ldap/ReadOnlyLDAPUsersDAO.java | 99 +++++++----
.../ldap/ReadOnlyLDAPUsersDAOPaginationTest.java | 192 +++++++++++++++++++++
.../user/ldap/ReadOnlyUsersLDAPRepositoryTest.java | 80 +++++++++
.../java/org/apache/james/user/lib/UsersDAO.java | 21 +--
.../apache/james/user/lib/UsersRepositoryImpl.java | 11 +-
.../james/user/lib/UsersRepositoryContract.java | 148 ++++++++++++++++
.../apache/james/webadmin/routes/UserRoutes.java | 36 +++-
.../apache/james/webadmin/service/UserService.java | 46 ++---
.../james/webadmin/routes/UserRoutesTest.java | 5 +-
13 files changed, 705 insertions(+), 128 deletions(-)
diff --git a/docs/modules/servers/partials/operate/webadmin.adoc b/docs/modules/servers/partials/operate/webadmin.adoc
index ad5527450f..52e02d19a1 100644
--- a/docs/modules/servers/partials/operate/webadmin.adoc
+++ b/docs/modules/servers/partials/operate/webadmin.adoc
@@ -699,17 +699,19 @@ curl -XGET http://ip:port/users?hasNoMailboxes
curl -XGET http://ip:port/users?hasNotAllSystemMailboxes
....
-- `limit`, `anchor` and `query` allow paginating and searching the user list. Users are sorted alphabetically on their
+- `limit`, `anchor`, `query` and `domain` allow paginating and searching the user list. Users are sorted alphabetically on their
username.
- `limit`: maximum count of users returned (strictly positive integer). No limit if omitted.
- `anchor`: only users whose username comes strictly after the anchor are returned. Pass the last username of the
previous page to get the next one.
- - `query`: only users whose username contains (case insensitively) this value are returned.
+ - `query`: only users whose username starts (case insensitively) with this value are returned.
+ - `domain`: only users of this domain are returned.
....
curl -XGET http://ip:port/users?limit=50
curl -XGET http://ip:port/users?limit=50&anchor=btellier@linagora.com
curl -XGET http://ip:port/users?query=bte&limit=50&anchor=btellier@linagora.com
+curl -XGET http://ip:port/users?domain=linagora.com&limit=50
....
These parameters can be combined with the condition parameters above.
@@ -717,7 +719,7 @@ These parameters can be combined with the condition parameters above.
Response codes:
* 200: The user name list was successfully retrieved
-* 400: Invalid `limit` or `anchor`
+* 400: Invalid `limit`, `anchor` or `domain`
=== Retrieving the list of allowed `From` headers for a given user
diff --git a/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java b/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java
index 5ccbd989f5..5ca1292cb4 100644
--- a/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java
+++ b/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java
@@ -19,15 +19,16 @@
package org.apache.james.user.api;
-import java.util.Comparator;
import java.util.Iterator;
-import java.util.Locale;
+import java.util.List;
import java.util.Optional;
import org.apache.james.core.Domain;
import org.apache.james.core.MailAddress;
import org.apache.james.core.Username;
import org.apache.james.user.api.model.User;
+import org.apache.james.user.api.model.UsernamePredicate;
+import org.apache.james.user.api.model.UsersPaginationHelpers;
import org.apache.james.util.ReactorUtils;
import org.reactivestreams.Publisher;
@@ -189,47 +190,18 @@ public interface UsersRepository {
.then();
}
- Comparator<Username> USERNAME_ALPHABETICAL_ORDER = Comparator.comparing(Username::asString);
-
- /**
- * Lists users sorted alphabetically on their username.
- *
- * @param anchor exclusive lower bound: only users strictly after it are returned
- * @param limit maximum count of users returned, no limit if empty
- */
- default Publisher<Username> listPaginated(Optional<Username> anchor, Optional<Integer> limit) {
- return applyLimit(Flux.from(listReactive())
- .filter(username -> isAfter(username, anchor))
- .sort(USERNAME_ALPHABETICAL_ORDER), limit);
- }
-
/**
- * Lists users whose username contains (case insensitively) the query, sorted alphabetically on their username.
+ * Lists users matching all the predicates, sorted alphabetically on their username.
*
- * @param query substring the username needs to contain
+ * @param predicates criteria the users need to match, all users are listed when empty
* @param anchor exclusive lower bound: only users strictly after it are returned
* @param limit maximum count of users returned, no limit if empty
*/
- default Publisher<Username> searchPaginated(String query, Optional<Username> anchor, Optional<Integer> limit) {
- return applyLimit(Flux.from(listReactive())
- .filter(username -> matches(username, query))
- .filter(username -> isAfter(username, anchor))
- .sort(USERNAME_ALPHABETICAL_ORDER), limit);
- }
-
- static Flux<Username> applyLimit(Flux<Username> usernames, Optional<Integer> limit) {
- return limit.map(value -> usernames.take(value, true))
- .orElse(usernames);
- }
-
- static boolean isAfter(Username username, Optional<Username> anchor) {
- return anchor.map(a -> USERNAME_ALPHABETICAL_ORDER.compare(username, a) > 0)
- .orElse(true);
- }
-
- static boolean matches(Username username, String query) {
- return username.asString().toLowerCase(Locale.US)
- .contains(query.toLowerCase(Locale.US));
+ default Publisher<Username> searchPaginated(List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit) {
+ Publisher<Username> candidates = UsersPaginationHelpers.domain(predicates)
+ .<Publisher<Username>>map(this::listUsersOfADomainReactive)
+ .orElseGet(this::listReactive);
+ return UsersPaginationHelpers.paginate(candidates, predicates, anchor, limit);
}
default Publisher<Username> listUsersOfADomainReactive(Domain domain) {
diff --git a/server/data/data-api/src/main/java/org/apache/james/user/api/model/UsernamePredicate.java b/server/data/data-api/src/main/java/org/apache/james/user/api/model/UsernamePredicate.java
new file mode 100644
index 0000000000..f8305a468e
--- /dev/null
+++ b/server/data/data-api/src/main/java/org/apache/james/user/api/model/UsernamePredicate.java
@@ -0,0 +1,73 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.user.api.model;
+
+import java.util.Locale;
+import java.util.Objects;
+import java.util.function.Predicate;
+
+import org.apache.james.core.Domain;
+import org.apache.james.core.Username;
+
+import com.google.common.base.Preconditions;
+
+/**
+ * Typed criteria for searching users, allowing implementations to translate them into native queries.
+ */
+public sealed interface UsernamePredicate extends Predicate<Username> {
+ /**
+ * Matches users of the given domain.
+ */
+ record DomainPredicate(Domain domain) implements UsernamePredicate {
+ public DomainPredicate {
+ Objects.requireNonNull(domain);
+ }
+
+ @Override
+ public boolean test(Username username) {
+ return username.getDomainPart()
+ .map(domain::equals)
+ .orElse(false);
+ }
+ }
+
+ /**
+ * Matches users whose username starts (case insensitively) with the given prefix.
+ */
+ record UsernamePrefixPredicate(String prefix) implements UsernamePredicate {
+ public UsernamePrefixPredicate {
+ Preconditions.checkArgument(prefix != null && !prefix.isEmpty(), "'prefix' must not be empty");
+ prefix = prefix.toLowerCase(Locale.US);
+ }
+
+ @Override
+ public boolean test(Username username) {
+ return username.asString().toLowerCase(Locale.US).startsWith(prefix);
+ }
+ }
+
+ static DomainPredicate domain(Domain domain) {
+ return new DomainPredicate(domain);
+ }
+
+ static UsernamePrefixPredicate prefix(String prefix) {
+ return new UsernamePrefixPredicate(prefix);
+ }
+}
diff --git a/server/data/data-api/src/main/java/org/apache/james/user/api/model/UsersPaginationHelpers.java b/server/data/data-api/src/main/java/org/apache/james/user/api/model/UsersPaginationHelpers.java
new file mode 100644
index 0000000000..b17536893f
--- /dev/null
+++ b/server/data/data-api/src/main/java/org/apache/james/user/api/model/UsersPaginationHelpers.java
@@ -0,0 +1,66 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.user.api.model;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+
+import org.apache.james.core.Domain;
+import org.apache.james.core.Username;
+import org.reactivestreams.Publisher;
+
+import reactor.core.publisher.Flux;
+
+/**
+ * Helpers shared by the {@link org.apache.james.user.api.UsersRepository#searchPaginated} implementations.
+ */
+public final class UsersPaginationHelpers {
+ public static final Comparator<Username> USERNAME_ALPHABETICAL_ORDER = Comparator.comparing(Username::asString);
+
+ private UsersPaginationHelpers() {
+ }
+
+ public static Optional<Domain> domain(List<UsernamePredicate> predicates) {
+ return predicates.stream()
+ .filter(UsernamePredicate.DomainPredicate.class::isInstance)
+ .map(UsernamePredicate.DomainPredicate.class::cast)
+ .map(UsernamePredicate.DomainPredicate::domain)
+ .findFirst();
+ }
+
+ public static Flux<Username> paginate(Publisher<Username> users, List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit) {
+ Flux<Username> sortedUsers = Flux.from(users)
+ .filter(username -> matchesAll(username, predicates))
+ .filter(username -> isAfter(username, anchor))
+ .sort(USERNAME_ALPHABETICAL_ORDER);
+ return limit.map(value -> sortedUsers.take(value, true))
+ .orElse(sortedUsers);
+ }
+
+ public static boolean matchesAll(Username username, List<UsernamePredicate> predicates) {
+ return predicates.stream().allMatch(predicate -> predicate.test(username));
+ }
+
+ public static boolean isAfter(Username username, Optional<Username> anchor) {
+ return anchor.map(a -> USERNAME_ALPHABETICAL_ORDER.compare(username, a) > 0)
+ .orElse(true);
+ }
+}
diff --git a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java
index f1e20f054d..d229b106dd 100644
--- a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java
+++ b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java
@@ -27,6 +27,7 @@ import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
@@ -42,9 +43,10 @@ import org.apache.james.core.Domain;
import org.apache.james.core.Username;
import org.apache.james.lifecycle.api.Configurable;
import org.apache.james.metrics.api.GaugeRegistry;
-import org.apache.james.user.api.UsersRepository;
import org.apache.james.user.api.UsersRepositoryException;
import org.apache.james.user.api.model.User;
+import org.apache.james.user.api.model.UsernamePredicate;
+import org.apache.james.user.api.model.UsersPaginationHelpers;
import org.apache.james.user.lib.UsersDAO;
import org.reactivestreams.Publisher;
import org.slf4j.Logger;
@@ -62,6 +64,7 @@ import com.unboundid.ldap.sdk.Filter;
import com.unboundid.ldap.sdk.LDAPConnection;
import com.unboundid.ldap.sdk.LDAPConnectionPool;
import com.unboundid.ldap.sdk.LDAPException;
+import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.ldap.sdk.SearchRequest;
import com.unboundid.ldap.sdk.SearchResult;
import com.unboundid.ldap.sdk.SearchResultEntry;
@@ -211,8 +214,27 @@ public class ReadOnlyLDAPUsersDAO implements UsersDAO, Configurable {
/**
* Relies on the simple paged results control (RFC 2696) so that listing a large directory is not capped by the
* server size limit. The paging cookie is bound to the LDAP connection thus all pages are read on the same connection.
+ *
+ * As the connection is not handled by the pool, we mimic its retry of operations failing due to an invalid connection
+ * (eg failover): the search is retried once on a new connection, as long as no entry was handed over yet.
*/
private void pagedSearch(String dn, Filter filter, String attributes, Consumer<SearchResultEntry> entryConsumer) throws LDAPException {
+ AtomicBoolean entryHandedOver = new AtomicBoolean(false);
+ Consumer<SearchResultEntry> trackingConsumer = entry -> {
+ entryHandedOver.set(true);
+ entryConsumer.accept(entry);
+ };
+ try {
+ pagedSearchOnSingleConnection(dn, filter, attributes, trackingConsumer);
+ } catch (LDAPException e) {
+ if (ResultCode.isConnectionUsable(e.getResultCode()) || entryHandedOver.get()) {
+ throw e;
+ }
+ pagedSearchOnSingleConnection(dn, filter, attributes, entryConsumer);
+ }
+ }
+
+ private void pagedSearchOnSingleConnection(String dn, Filter filter, String attributes, Consumer<SearchResultEntry> entryConsumer) throws LDAPException {
LDAPConnection connection = ldapConnectionPool.getConnection();
try {
ASN1OctetString cookie = null;
@@ -393,48 +415,63 @@ public class ReadOnlyLDAPUsersDAO implements UsersDAO, Configurable {
@Override
- public Publisher<Username> listPaginated(Optional<Username> anchor, Optional<Integer> limit) {
- if (ldapConfiguration.getRestriction().isActivated()) {
- return UsersDAO.super.listPaginated(anchor, limit);
- }
- return firstUsernamesAfter(listingFilter, username -> true, anchor, limit);
- }
-
- @Override
- public Publisher<Username> searchPaginated(String query, Optional<Username> anchor, Optional<Integer> limit) {
+ public Publisher<Username> searchPaginated(List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit) {
if (ldapConfiguration.getRestriction().isActivated()) {
- return UsersDAO.super.searchPaginated(query, anchor, limit);
+ return UsersDAO.super.searchPaginated(predicates, anchor, limit);
}
- Filter queryFilter = Filter.createSubstringFilter(usernameAttribute(), null, new String[]{query}, null);
- return firstUsernamesAfter(Filter.createANDFilter(listingFilter, queryFilter),
- username -> UsersRepository.matches(username, query), anchor, limit);
+ String usernameAttribute = usernameAttribute();
+ Filter filter = Filter.createANDFilter(ImmutableList.<Filter>builder()
+ .add(listingFilter)
+ .addAll(predicates.stream()
+ .map(predicate -> asLdapFilter(predicate, usernameAttribute))
+ .toList())
+ .build());
+ // Only the base DN of the searched domain needs to be scanned
+ List<String> dns = UsersPaginationHelpers.domain(predicates)
+ .map(domain -> List.of(userBase(domain)))
+ .orElseGet(() -> allDNs().toList());
+ return firstUsernamesAfter(dns, filter, username -> UsersPaginationHelpers.matchesAll(username, predicates), anchor, limit);
+ }
+
+ private Filter asLdapFilter(UsernamePredicate predicate, String usernameAttribute) {
+ return switch (predicate) {
+ case UsernamePredicate.DomainPredicate domainPredicate ->
+ Filter.createSubstringFilter(usernameAttribute, null, null, "@" + domainPredicate.domain().asString());
+ case UsernamePredicate.UsernamePrefixPredicate prefixPredicate ->
+ Filter.createSubstringFilter(usernameAttribute, prefixPredicate.prefix(), null, null);
+ };
}
/**
* Only the username attribute is retrieved, and only the 'limit' first usernames after the anchor are retained
* in memory while the (paged) LDAP search results are being read.
*/
- private Flux<Username> firstUsernamesAfter(Filter filter, Predicate<Username> predicate, Optional<Username> anchor, Optional<Integer> limit) {
- String usernameAttribute = usernameAttribute();
- return Mono.fromCallable(() -> {
- TreeSet<Username> firstUsernames = new TreeSet<>(UsersRepository.USERNAME_ALPHABETICAL_ORDER);
- for (String dn : allDNs().toList()) {
- pagedSearch(dn, filter, usernameAttribute, entry -> asUsername(entry, usernameAttribute)
- .filter(predicate)
- .filter(username -> UsersRepository.isAfter(username, anchor))
- .ifPresent(username -> {
- firstUsernames.add(username);
- if (limit.isPresent() && firstUsernames.size() > limit.get()) {
- firstUsernames.pollLast();
- }
- }));
- }
- return firstUsernames;
- })
+ private Flux<Username> firstUsernamesAfter(List<String> dns, Filter filter, Predicate<Username> predicate, Optional<Username> anchor, Optional<Integer> limit) {
+ return Mono.fromCallable(() -> collectFirstUsernamesAfter(dns, filter, predicate, anchor, limit))
.flatMapIterable(usernames -> usernames)
.subscribeOn(Schedulers.boundedElastic());
}
+ private TreeSet<Username> collectFirstUsernamesAfter(List<String> dns, Filter filter, Predicate<Username> predicate,
+ Optional<Username> anchor, Optional<Integer> limit) throws LDAPException {
+ String usernameAttribute = usernameAttribute();
+ TreeSet<Username> firstUsernames = new TreeSet<>(UsersPaginationHelpers.USERNAME_ALPHABETICAL_ORDER);
+ for (String dn : dns) {
+ pagedSearch(dn, filter, usernameAttribute, entry -> asUsername(entry, usernameAttribute)
+ .filter(predicate)
+ .filter(username -> UsersPaginationHelpers.isAfter(username, anchor))
+ .ifPresent(username -> addWithinLimit(firstUsernames, username, limit)));
+ }
+ return firstUsernames;
+ }
+
+ private static void addWithinLimit(TreeSet<Username> firstUsernames, Username username, Optional<Integer> limit) {
+ firstUsernames.add(username);
+ if (limit.isPresent() && firstUsernames.size() > limit.get()) {
+ firstUsernames.pollLast();
+ }
+ }
+
@Override
public Flux<Username> listUsersOfADomainReactive(Domain domain, boolean supportsVirtualHosting) {
return Flux.fromStream(() -> {
diff --git a/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAOPaginationTest.java b/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAOPaginationTest.java
new file mode 100644
index 0000000000..1042110bb7
--- /dev/null
+++ b/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAOPaginationTest.java
@@ -0,0 +1,192 @@
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.user.ldap;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import org.apache.james.core.Domain;
+import org.apache.james.core.Username;
+import org.apache.james.metrics.api.NoopGaugeRegistry;
+import org.apache.james.user.api.model.UsernamePredicate;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.google.common.collect.ImmutableList;
+import com.unboundid.ldap.listener.InMemoryDirectoryServer;
+import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
+import com.unboundid.ldap.sdk.LDAPConnectionPool;
+
+import reactor.core.publisher.Flux;
+
+class ReadOnlyLDAPUsersDAOPaginationTest {
+ static final String BASE_DN = "dc=james,dc=org";
+ static final String PEOPLE_DN = "ou=people," + BASE_DN;
+ // More users than the server size limit, so that listing them can not rely on a single search
+ static final List<Username> JAMES_USERS = IntStream.range(0, 560)
+ .mapToObj(i -> Username.of(String.format("user%03d@james.org", i)))
+ .collect(ImmutableList.toImmutableList());
+ static final List<Username> OTHER_USERS = IntStream.range(0, 10)
+ .mapToObj(i -> Username.of(String.format("other%03d@other.org", i)))
+ .collect(ImmutableList.toImmutableList());
+ static final List<Username> ALL_USERS = Stream.concat(OTHER_USERS.stream(), JAMES_USERS.stream())
+ .collect(ImmutableList.toImmutableList());
+ // Matches the OpenLDAP default size limit
+ static final int SERVER_SIZE_LIMIT = 500;
+
+ InMemoryDirectoryServer ldapServer;
+ LDAPConnectionPool connectionPool;
+ ReadOnlyLDAPUsersDAO testee;
+
+ @BeforeEach
+ void setUp() throws Exception {
+ InMemoryDirectoryServerConfig serverConfig = new InMemoryDirectoryServerConfig(BASE_DN);
+ serverConfig.setMaxSizeLimit(SERVER_SIZE_LIMIT);
+ ldapServer = new InMemoryDirectoryServer(serverConfig);
+ ldapServer.startListening();
+ ldapServer.add("dn: " + BASE_DN, "objectClass: domain", "dc: james");
+ ldapServer.add("dn: " + PEOPLE_DN, "objectClass: organizationalUnit", "ou: people");
+ for (Username username : ALL_USERS) {
+ String localPart = username.getLocalPart();
+ ldapServer.add("dn: uid=" + localPart + "-" + username.getDomainPart().get().asString() + "," + PEOPLE_DN,
+ "objectClass: inetOrgPerson",
+ "uid: " + localPart,
+ "cn: " + localPart,
+ "sn: " + localPart,
+ "mail: " + username.asString());
+ }
+
+ LdapRepositoryConfiguration configuration = LdapRepositoryConfiguration.builder()
+ .ldapHosts(ImmutableList.of(URI.create("ldap://127.0.0.1:" + ldapServer.getListenPort())))
+ .principal("")
+ .credentials("")
+ .userBase(PEOPLE_DN)
+ .userIdAttribute("mail")
+ .userObjectClass("inetOrgPerson")
+ .build();
+
+ connectionPool = ldapServer.getConnectionPool(2);
+ testee = new ReadOnlyLDAPUsersDAO(new NoopGaugeRegistry(), connectionPool, configuration);
+ testee.init();
+ }
+
+ @AfterEach
+ void tearDown() {
+ connectionPool.close();
+ ldapServer.shutDown(true);
+ }
+
+ List<Username> search(List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit) {
+ return Flux.from(testee.searchPaginated(predicates, anchor, limit))
+ .collectList()
+ .block();
+ }
+
+ @Test
+ void shouldReturnFirstUsersSortedAlphabetically() {
+ assertThat(search(ImmutableList.of(), Optional.empty(), Optional.of(5)))
+ .containsExactlyElementsOf(ALL_USERS.subList(0, 5));
+ }
+
+ @Test
+ void shouldReturnAllUsersSortedWhenNoLimit() {
+ assertThat(search(ImmutableList.of(), Optional.empty(), Optional.empty()))
+ .containsExactlyElementsOf(ALL_USERS);
+ }
+
+ @Test
+ void shouldReturnUsersStrictlyAfterTheAnchor() {
+ assertThat(search(ImmutableList.of(), Optional.of(ALL_USERS.get(10)), Optional.of(3)))
+ .containsExactlyElementsOf(ALL_USERS.subList(11, 14));
+ }
+
+ @Test
+ void shouldSupportAnAnchorNotInTheDirectory() {
+ // "user0505@" sorts before "user050@" as '5' < '@'
+ assertThat(search(ImmutableList.of(), Optional.of(Username.of("user0505@james.org")), Optional.of(2)))
+ .containsExactly(Username.of("user050@james.org"), Username.of("user051@james.org"));
+ }
+
+ @Test
+ void shouldReturnLessUsersThanTheLimitOnTheLastPage() {
+ assertThat(search(ImmutableList.of(), Optional.of(ALL_USERS.get(ALL_USERS.size() - 3)), Optional.of(10)))
+ .containsExactlyElementsOf(ALL_USERS.subList(ALL_USERS.size() - 2, ALL_USERS.size()));
+ }
+
+ @Test
+ void shouldReturnNoUsersAfterTheLastOne() {
+ assertThat(search(ImmutableList.of(), Optional.of(ALL_USERS.getLast()), Optional.of(10)))
+ .isEmpty();
+ }
+
+ @Test
+ void browsingAllPagesShouldReturnAllUsersOnce() {
+ List<Username> browsed = new ArrayList<>();
+ Optional<Username> anchor = Optional.empty();
+ while (true) {
+ List<Username> page = search(ImmutableList.of(), anchor, Optional.of(50));
+ browsed.addAll(page);
+ if (page.size() < 50) {
+ break;
+ }
+ anchor = Optional.of(page.getLast());
+ }
+
+ assertThat(browsed).containsExactlyElementsOf(ALL_USERS);
+ }
+
+ @Test
+ void shouldFilterByPrefix() {
+ assertThat(search(ImmutableList.of(UsernamePredicate.prefix("user11")), Optional.empty(), Optional.of(50)))
+ .containsExactlyElementsOf(JAMES_USERS.subList(110, 120));
+ }
+
+ @Test
+ void prefixShouldBeCaseInsensitive() {
+ assertThat(search(ImmutableList.of(UsernamePredicate.prefix("USER11")), Optional.empty(), Optional.of(50)))
+ .containsExactlyElementsOf(JAMES_USERS.subList(110, 120));
+ }
+
+ @Test
+ void shouldFilterByDomain() {
+ assertThat(search(ImmutableList.of(UsernamePredicate.domain(Domain.of("other.org"))), Optional.empty(), Optional.of(50)))
+ .containsExactlyElementsOf(OTHER_USERS);
+ }
+
+ @Test
+ void shouldCombinePredicatesAnchorAndLimit() {
+ assertThat(search(ImmutableList.of(UsernamePredicate.domain(Domain.of("james.org")), UsernamePredicate.prefix("user1")),
+ Optional.of(Username.of("user104@james.org")), Optional.of(3)))
+ .containsExactly(Username.of("user105@james.org"), Username.of("user106@james.org"), Username.of("user107@james.org"));
+ }
+
+ @Test
+ void shouldReturnNothingWhenNoMatch() {
+ assertThat(search(ImmutableList.of(UsernamePredicate.prefix("nobody")), Optional.empty(), Optional.of(10)))
+ .isEmpty();
+ }
+}
diff --git a/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java b/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java
index 440f2256e0..0ff348f245 100644
--- a/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java
+++ b/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java
@@ -28,6 +28,7 @@ import static org.apache.james.user.ldap.DockerLdapSingleton.PASSWORD;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import java.util.List;
import java.util.Optional;
import java.util.Set;
@@ -41,6 +42,7 @@ import org.apache.james.domainlist.api.DomainList;
import org.apache.james.domainlist.api.mock.SimpleDomainList;
import org.apache.james.metrics.api.NoopGaugeRegistry;
import org.apache.james.user.api.UsersRepository;
+import org.apache.james.user.api.model.UsernamePredicate;
import org.apache.james.user.lib.UsersRepositoryContract;
import org.apache.james.user.lib.UsersRepositoryImpl;
import org.awaitility.Awaitility;
@@ -137,6 +139,42 @@ class ReadOnlyUsersLDAPRepositoryTest {
assertThat(ImmutableList.copyOf(usersLDAPRepository.list()))
.containsOnly(JAMES_USER_MAIL, Username.of("bob@extra.org"));
}
+
+ @Test
+ void searchPaginatedShouldListUsersOfAllDNsSorted() {
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(), Optional.empty(), Optional.empty()))
+ .containsExactly(Username.of("bob@extra.org"), JAMES_USER_MAIL);
+ }
+
+ @Test
+ void searchPaginatedShouldApplyAnchorAndLimitAcrossDNs() {
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(), Optional.of(Username.of("bob@extra.org")), Optional.of(1)))
+ .containsExactly(JAMES_USER_MAIL);
+ }
+
+ @Test
+ void searchPaginatedShouldFilterByDomainOfAnExtraDN() {
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(UsernamePredicate.domain(Domain.of("extra.org"))), Optional.empty(), Optional.empty()))
+ .containsExactly(Username.of("bob@extra.org"));
+ }
+
+ @Test
+ void searchPaginatedShouldFilterByMainDomain() {
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(UsernamePredicate.domain(Domain.of(DOMAIN))), Optional.empty(), Optional.empty()))
+ .containsExactly(JAMES_USER_MAIL);
+ }
+
+ @Test
+ void searchPaginatedShouldReturnEmptyForUnknownDomain() {
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(UsernamePredicate.domain(Domain.of("nonexistant.org"))), Optional.empty(), Optional.empty()))
+ .isEmpty();
+ }
+
+ @Test
+ void searchPaginatedShouldFilterByPrefixIgnoringCase() {
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(UsernamePredicate.prefix("JAMES")), Optional.empty(), Optional.empty()))
+ .containsExactly(JAMES_USER_MAIL);
+ }
}
@Nested
@@ -182,6 +220,13 @@ class ReadOnlyUsersLDAPRepositoryTest {
// james-user@james.org is not in userListBase thus is not listed
assertThat(ImmutableList.copyOf(usersLDAPRepository.list())).containsOnly(Username.of("bob@extra.org"));
}
+
+ @Test
+ void searchPaginatedShouldListEntriesInUserListBase() {
+ // james-user@james.org is not in userListBase thus is not listed
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(), Optional.empty(), Optional.empty()))
+ .containsExactly(Username.of("bob@extra.org"));
+ }
}
@Nested
@@ -237,6 +282,34 @@ class ReadOnlyUsersLDAPRepositoryTest {
assertThat(ImmutableList.copyOf(usersLDAPRepository.list())).isEmpty();
}
+
+ @Test
+ void searchPaginatedShouldKeepMatchingEntries() throws Exception {
+ HierarchicalConfiguration<ImmutableNode> configuration = ldapRepositoryConfiguration(ldapContainer);
+ configuration.addProperty("[@filter]", "(sn=james-user)");
+
+ ReadOnlyUsersLDAPRepository usersLDAPRepository = new ReadOnlyUsersLDAPRepository(new SimpleDomainList(), new NoopGaugeRegistry(),
+ LdapRepositoryConfiguration.from(configuration));
+ usersLDAPRepository.configure(configuration);
+ usersLDAPRepository.init();
+
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(UsernamePredicate.prefix("james")), Optional.empty(), Optional.of(10)))
+ .containsExactly(JAMES_USER);
+ }
+
+ @Test
+ void searchPaginatedShouldTakeFilterIntoAccount() throws Exception {
+ HierarchicalConfiguration<ImmutableNode> configuration = ldapRepositoryConfiguration(ldapContainer);
+ configuration.addProperty("[@filter]", "(sn=nomatch)");
+
+ ReadOnlyUsersLDAPRepository usersLDAPRepository = new ReadOnlyUsersLDAPRepository(new SimpleDomainList(), new NoopGaugeRegistry(),
+ LdapRepositoryConfiguration.from(configuration));
+ usersLDAPRepository.configure(configuration);
+ usersLDAPRepository.init();
+
+ assertThat(searchPaginated(usersLDAPRepository, ImmutableList.of(), Optional.empty(), Optional.of(10)))
+ .isEmpty();
+ }
}
@Nested
@@ -573,6 +646,13 @@ class ReadOnlyUsersLDAPRepositoryTest {
return ldapRepository;
}
+ static List<Username> searchPaginated(UsersRepository usersRepository, List<UsernamePredicate> predicates,
+ Optional<Username> anchor, Optional<Integer> limit) {
+ return Flux.from(usersRepository.searchPaginated(predicates, anchor, limit))
+ .collectList()
+ .block();
+ }
+
static HierarchicalConfiguration<ImmutableNode> ldapRepositoryConfiguration(LdapGenericContainer ldapContainer) {
return ldapRepositoryConfiguration(ldapContainer, Optional.of(Username.of(ADMIN_LOCAL_PART)));
}
diff --git a/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersDAO.java b/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersDAO.java
index f18b52cf74..1445505b0c 100644
--- a/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersDAO.java
+++ b/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersDAO.java
@@ -20,13 +20,15 @@
package org.apache.james.user.lib;
import java.util.Iterator;
+import java.util.List;
import java.util.Optional;
import org.apache.james.core.Domain;
import org.apache.james.core.Username;
-import org.apache.james.user.api.UsersRepository;
import org.apache.james.user.api.UsersRepositoryException;
import org.apache.james.user.api.model.User;
+import org.apache.james.user.api.model.UsernamePredicate;
+import org.apache.james.user.api.model.UsersPaginationHelpers;
import org.apache.james.util.ReactorUtils;
import org.reactivestreams.Publisher;
@@ -73,17 +75,12 @@ public interface UsersDAO {
.orElse(!supportsVirtualHosting));
}
- default Publisher<Username> listPaginated(Optional<Username> anchor, Optional<Integer> limit) {
- return UsersRepository.applyLimit(Flux.from(listReactive())
- .filter(username -> UsersRepository.isAfter(username, anchor))
- .sort(UsersRepository.USERNAME_ALPHABETICAL_ORDER), limit);
- }
-
- default Publisher<Username> searchPaginated(String query, Optional<Username> anchor, Optional<Integer> limit) {
- return UsersRepository.applyLimit(Flux.from(listReactive())
- .filter(username -> UsersRepository.matches(username, query))
- .filter(username -> UsersRepository.isAfter(username, anchor))
- .sort(UsersRepository.USERNAME_ALPHABETICAL_ORDER), limit);
+ default Publisher<Username> searchPaginated(List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit) {
+ // DomainPredicate only matches usernames having a domain part, hence virtual hosting can be assumed
+ Publisher<Username> candidates = UsersPaginationHelpers.domain(predicates)
+ .map(domain -> listUsersOfADomainReactive(domain, true))
+ .orElseGet(this::listReactive);
+ return UsersPaginationHelpers.paginate(candidates, predicates, anchor, limit);
}
void addUser(Username username, String password) throws UsersRepositoryException;
diff --git a/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java b/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java
index bc0bcf1780..a548c56076 100644
--- a/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java
+++ b/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java
@@ -22,6 +22,7 @@ package org.apache.james.user.lib;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.Iterator;
+import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
@@ -44,6 +45,7 @@ import org.apache.james.user.api.InvalidUsernameException;
import org.apache.james.user.api.UsersRepository;
import org.apache.james.user.api.UsersRepositoryException;
import org.apache.james.user.api.model.User;
+import org.apache.james.user.api.model.UsernamePredicate;
import org.apache.james.util.DurationParser;
import org.reactivestreams.Publisher;
import org.slf4j.LoggerFactory;
@@ -263,13 +265,8 @@ public class UsersRepositoryImpl<T extends UsersDAO> implements UsersRepository,
}
@Override
- public Publisher<Username> listPaginated(Optional<Username> anchor, Optional<Integer> limit) {
- return usersDAO.listPaginated(anchor, limit);
- }
-
- @Override
- public Publisher<Username> searchPaginated(String query, Optional<Username> anchor, Optional<Integer> limit) {
- return usersDAO.searchPaginated(query, anchor, limit);
+ public Publisher<Username> searchPaginated(List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit) {
+ return usersDAO.searchPaginated(predicates, anchor, limit);
}
@Override
diff --git a/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java b/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java
index 22c64045ad..645b9d05a2 100644
--- a/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java
+++ b/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java
@@ -22,7 +22,9 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
@@ -38,6 +40,7 @@ import org.apache.james.user.api.InvalidUsernameException;
import org.apache.james.user.api.UsersRepository;
import org.apache.james.user.api.UsersRepositoryException;
import org.apache.james.user.api.model.User;
+import org.apache.james.user.api.model.UsernamePredicate;
import org.apache.james.user.lib.model.Algorithm;
import org.apache.james.user.lib.model.DefaultUser;
import org.junit.jupiter.api.Assumptions;
@@ -51,6 +54,8 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
+import com.google.common.collect.ImmutableList;
+
import reactor.core.publisher.Flux;
public interface UsersRepositoryContract {
@@ -249,6 +254,112 @@ public interface UsersRepositoryContract {
.containsOnly(testSystem.user1, testSystem.user2, testSystem.user3);
}
+ default List<Username> searchPaginated(List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit) {
+ return Flux.from(testee().searchPaginated(predicates, anchor, limit))
+ .collectList()
+ .block();
+ }
+
+ default List<Username> addUsers(TestSystem testSystem, String... localParts) throws UsersRepositoryException {
+ ImmutableList.Builder<Username> usernames = ImmutableList.builder();
+ for (String localPart : localParts) {
+ Username username = testSystem.toUsername(localPart);
+ testee().addUser(username, "password");
+ usernames.add(username);
+ }
+ return usernames.build().stream()
+ .sorted(Comparator.comparing(Username::asString))
+ .collect(ImmutableList.toImmutableList());
+ }
+
+ @Test
+ default void searchPaginatedShouldReturnEmptyWhenEmptyRepository() {
+ assertThat(searchPaginated(ImmutableList.of(), Optional.empty(), Optional.empty()))
+ .isEmpty();
+ }
+
+ @Test
+ default void searchPaginatedShouldReturnAllUsersSortedAlphabetically(TestSystem testSystem) throws UsersRepositoryException {
+ List<Username> sortedUsers = addUsers(testSystem, "charlie", "alice", "bob");
+
+ assertThat(searchPaginated(ImmutableList.of(), Optional.empty(), Optional.empty()))
+ .containsExactlyElementsOf(sortedUsers);
+ }
+
+ @Test
+ default void searchPaginatedShouldApplyTheLimit(TestSystem testSystem) throws UsersRepositoryException {
+ List<Username> sortedUsers = addUsers(testSystem, "charlie", "alice", "bob");
+
+ assertThat(searchPaginated(ImmutableList.of(), Optional.empty(), Optional.of(2)))
+ .containsExactlyElementsOf(sortedUsers.subList(0, 2));
+ }
+
+ @Test
+ default void searchPaginatedShouldReturnUsersStrictlyAfterTheAnchor(TestSystem testSystem) throws UsersRepositoryException {
+ List<Username> sortedUsers = addUsers(testSystem, "charlie", "alice", "bob", "dave");
+
+ assertThat(searchPaginated(ImmutableList.of(), Optional.of(sortedUsers.get(1)), Optional.of(1)))
+ .containsExactly(sortedUsers.get(2));
+ }
+
+ @Test
+ default void searchPaginatedShouldAcceptAnAnchorThatIsNotAUser(TestSystem testSystem) throws UsersRepositoryException {
+ List<Username> sortedUsers = addUsers(testSystem, "alice", "charlie");
+
+ assertThat(searchPaginated(ImmutableList.of(), Optional.of(testSystem.toUsername("bob")), Optional.empty()))
+ .containsExactly(sortedUsers.get(1));
+ }
+
+ @Test
+ default void searchPaginatedShouldReturnEmptyAfterTheLastUser(TestSystem testSystem) throws UsersRepositoryException {
+ List<Username> sortedUsers = addUsers(testSystem, "alice", "bob");
+
+ assertThat(searchPaginated(ImmutableList.of(), Optional.of(sortedUsers.getLast()), Optional.of(10)))
+ .isEmpty();
+ }
+
+ @Test
+ default void browsingPagesShouldReturnAllUsersOnce(TestSystem testSystem) throws UsersRepositoryException {
+ List<Username> sortedUsers = addUsers(testSystem, "user1", "user2", "user3", "user4", "user5", "user6", "user7");
+
+ List<Username> browsed = new ArrayList<>();
+ Optional<Username> anchor = Optional.empty();
+ while (true) {
+ List<Username> page = searchPaginated(ImmutableList.of(), anchor, Optional.of(3));
+ browsed.addAll(page);
+ if (page.size() < 3) {
+ break;
+ }
+ anchor = Optional.of(page.getLast());
+ }
+
+ assertThat(browsed).containsExactlyElementsOf(sortedUsers);
+ }
+
+ @Test
+ default void searchPaginatedShouldFilterByPrefix(TestSystem testSystem) throws UsersRepositoryException {
+ addUsers(testSystem, "albert", "bob", "alice");
+
+ assertThat(searchPaginated(ImmutableList.of(UsernamePredicate.prefix("al")), Optional.empty(), Optional.empty()))
+ .containsExactly(testSystem.toUsername("albert"), testSystem.toUsername("alice"));
+ }
+
+ @Test
+ default void searchPaginatedPrefixShouldBeCaseInsensitive(TestSystem testSystem) throws UsersRepositoryException {
+ addUsers(testSystem, "albert", "bob");
+
+ assertThat(searchPaginated(ImmutableList.of(UsernamePredicate.prefix("AL")), Optional.empty(), Optional.empty()))
+ .containsExactly(testSystem.toUsername("albert"));
+ }
+
+ @Test
+ default void searchPaginatedShouldCombinePrefixAnchorAndLimit(TestSystem testSystem) throws UsersRepositoryException {
+ addUsers(testSystem, "alan", "albert", "alice", "alvin", "bob");
+
+ assertThat(searchPaginated(ImmutableList.of(UsernamePredicate.prefix("al")), Optional.of(testSystem.toUsername("albert")), Optional.of(2)))
+ .containsExactly(testSystem.toUsername("alice"), testSystem.toUsername("alvin"));
+ }
+
@Test
default void addUserShouldAddAUserWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//When
@@ -604,6 +715,43 @@ public interface UsersRepositoryContract {
.containsExactlyInAnyOrder(Username.of("alice@domain.tld"), Username.of("bob@domain.tld"));
}
+ @Test
+ default void searchPaginatedShouldFilterByDomain(TestSystem testSystem) throws Exception {
+ testSystem.domainList.addDomain(Domain.of("domain1.tld"));
+ testSystem.domainList.addDomain(Domain.of("domain2.tld"));
+ testee().addUser(Username.of("bob@domain1.tld"), "password");
+ testee().addUser(Username.of("alice@domain1.tld"), "password");
+ testee().addUser(Username.of("alice@domain2.tld"), "password");
+
+ assertThat(searchPaginated(ImmutableList.of(UsernamePredicate.domain(Domain.of("domain1.tld"))), Optional.empty(), Optional.empty()))
+ .containsExactly(Username.of("alice@domain1.tld"), Username.of("bob@domain1.tld"));
+ }
+
+ @Test
+ default void searchPaginatedShouldReturnEmptyWhenNoUserInDomain(TestSystem testSystem) throws Exception {
+ testSystem.domainList.addDomain(Domain.of("empty.tld"));
+ testee().addUser(testSystem.user1, "password");
+
+ assertThat(searchPaginated(ImmutableList.of(UsernamePredicate.domain(Domain.of("empty.tld"))), Optional.empty(), Optional.empty()))
+ .isEmpty();
+ }
+
+ @Test
+ default void searchPaginatedShouldCombineDomainPrefixAnchorAndLimit(TestSystem testSystem) throws Exception {
+ testSystem.domainList.addDomain(Domain.of("domain1.tld"));
+ testSystem.domainList.addDomain(Domain.of("domain2.tld"));
+ testee().addUser(Username.of("alan@domain1.tld"), "password");
+ testee().addUser(Username.of("albert@domain1.tld"), "password");
+ testee().addUser(Username.of("alice@domain1.tld"), "password");
+ testee().addUser(Username.of("alvin@domain1.tld"), "password");
+ testee().addUser(Username.of("alice@domain2.tld"), "password");
+ testee().addUser(Username.of("bob@domain1.tld"), "password");
+
+ assertThat(searchPaginated(ImmutableList.of(UsernamePredicate.domain(Domain.of("domain1.tld")), UsernamePredicate.prefix("al")),
+ Optional.of(Username.of("alan@domain1.tld")), Optional.of(2)))
+ .containsExactly(Username.of("albert@domain1.tld"), Username.of("alice@domain1.tld"));
+ }
+
@Test
default void addUserShouldThrowWhenUserDoesNotBelongToDomainList(TestSystem testSystem) {
assertThatThrownBy(() -> testee().addUser(testSystem.userWithUnknownDomain, "password"))
diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/UserRoutes.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/UserRoutes.java
index b62e4b1b94..1d7460f38c 100644
--- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/UserRoutes.java
+++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/UserRoutes.java
@@ -20,16 +20,17 @@
package org.apache.james.webadmin.routes;
import static org.apache.james.webadmin.Constants.SEPARATOR;
-import static org.apache.james.webadmin.UserCondition.ALL;
import static spark.Spark.halt;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.stream.Stream;
import jakarta.inject.Inject;
import org.apache.commons.lang3.NotImplementedException;
+import org.apache.james.core.Domain;
import org.apache.james.core.MailAddress;
import org.apache.james.core.Username;
import org.apache.james.rrt.api.CanSendFrom;
@@ -39,6 +40,7 @@ import org.apache.james.user.api.AlreadyExistInUsersRepositoryException;
import org.apache.james.user.api.DelegationStore;
import org.apache.james.user.api.InvalidUsernameException;
import org.apache.james.user.api.UsersRepositoryException;
+import org.apache.james.user.api.model.UsernamePredicate;
import org.apache.james.webadmin.Constants;
import org.apache.james.webadmin.Routes;
import org.apache.james.webadmin.UserCondition;
@@ -78,6 +80,7 @@ public class UserRoutes implements Routes {
private static final String AUTHORIZED_USERS = "authorizedUsers";
private static final String QUERY_PARAM = "query";
private static final String ANCHOR_PARAM = "anchor";
+ private static final String DOMAIN_PARAM = "domain";
private final UserService userService;
private final JsonTransformer jsonTransformer;
@@ -179,20 +182,28 @@ public class UserRoutes implements Routes {
}
private List<UserResponse> getUsers(Request request, Response response) {
- UserCondition combinedCondition = userConditionMap.entrySet()
+ Optional<UserCondition> combinedCondition = userConditionMap.entrySet()
.stream()
.filter(entry -> request.queryParams().contains(entry.getKey()))
.map(Map.Entry::getValue)
- .reduce(ALL, UserCondition::and);
+ .reduce(UserCondition::and);
Optional<Integer> limit = ParametersExtractor.extractLimit(request).getLimit();
- Optional<String> query = Optional.ofNullable(request.queryParams(QUERY_PARAM))
- .filter(s -> !s.isEmpty());
+ Optional<UsernamePredicate> prefixPredicate = Optional.ofNullable(request.queryParams(QUERY_PARAM))
+ .filter(s -> !s.isEmpty())
+ .map(UsernamePredicate::prefix);
+ Optional<UsernamePredicate> domainPredicate = Optional.ofNullable(request.queryParams(DOMAIN_PARAM))
+ .filter(s -> !s.isEmpty())
+ .map(this::parseDomain)
+ .map(UsernamePredicate::domain);
+ List<UsernamePredicate> predicates = Stream.of(prefixPredicate, domainPredicate)
+ .flatMap(Optional::stream)
+ .toList();
Optional<Username> anchor = Optional.ofNullable(request.queryParams(ANCHOR_PARAM))
.filter(s -> !s.isEmpty())
.map(Parsers::parseUsername);
- return userService.getUsers(query, anchor, limit, combinedCondition);
+ return userService.getUsers(predicates, anchor, limit, combinedCondition);
}
private String removeUser(Request request, Response response) {
@@ -405,6 +416,19 @@ public class UserRoutes implements Routes {
}
}
+ private Domain parseDomain(String domain) {
+ try {
+ return Domain.of(domain);
+ } catch (IllegalArgumentException e) {
+ throw ErrorResponder.builder()
+ .statusCode(HttpStatus.BAD_REQUEST_400)
+ .type(ErrorType.INVALID_ARGUMENT)
+ .message("Invalid domain: " + domain)
+ .cause(e)
+ .haltError();
+ }
+ }
+
private Username extractUsername(Request request) {
return Parsers.parseUsername(request.params(USER_NAME));
}
diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java
index 5a798728b7..0d6b574941 100644
--- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java
+++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java
@@ -19,7 +19,6 @@
package org.apache.james.webadmin.service;
-import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;
@@ -30,6 +29,7 @@ import org.apache.james.core.Username;
import org.apache.james.user.api.UsersRepository;
import org.apache.james.user.api.UsersRepositoryException;
import org.apache.james.user.api.model.User;
+import org.apache.james.user.api.model.UsernamePredicate;
import org.apache.james.webadmin.dto.UserResponse;
import com.google.common.collect.ImmutableList;
@@ -45,38 +45,26 @@ public class UserService {
}
/**
- * Users sorted alphabetically, strictly after the anchor, optionally matching the query.
+ * Users matching all the predicates, sorted alphabetically, strictly after the anchor.
*
- * The condition is applied after the repository pagination: repository pages are read until 'limit' users
- * matching the condition are found, or the repository is exhausted.
+ * The condition can not be applied by the repository: when supplied, users are read without limit then
+ * filtered, and the condition is only evaluated until 'limit' users matched.
*/
- public List<UserResponse> getUsers(Optional<String> query, Optional<Username> anchor, Optional<Integer> limit, Predicate<Username> condition) {
- List<UserResponse> result = new ArrayList<>();
- Optional<Username> pageAnchor = anchor;
- while (true) {
- List<Username> page = readPage(query, pageAnchor, limit);
- page.stream()
- .filter(condition)
- .limit(limit.map(value -> value - result.size()).orElse(Integer.MAX_VALUE))
- .map(Username::asString)
- .map(UserResponse::new)
- .forEach(result::add);
-
- boolean exhausted = limit.map(value -> page.size() < value).orElse(true);
- boolean full = limit.map(value -> result.size() >= value).orElse(false);
- if (exhausted || full) {
- return ImmutableList.copyOf(result);
- }
- pageAnchor = Optional.of(page.get(page.size() - 1));
- }
+ public List<UserResponse> getUsers(List<UsernamePredicate> predicates, Optional<Username> anchor, Optional<Integer> limit,
+ Optional<? extends Predicate<Username>> condition) {
+ Flux<Username> users = condition
+ .map(c -> applyLimit(Flux.from(usersRepository.searchPaginated(predicates, anchor, Optional.empty())).filter(c), limit))
+ .orElseGet(() -> Flux.from(usersRepository.searchPaginated(predicates, anchor, limit)));
+
+ return users.map(Username::asString)
+ .map(UserResponse::new)
+ .collect(ImmutableList.toImmutableList())
+ .block();
}
- private List<Username> readPage(Optional<String> query, Optional<Username> anchor, Optional<Integer> limit) {
- return Flux.from(query
- .map(q -> usersRepository.searchPaginated(q, anchor, limit))
- .orElseGet(() -> usersRepository.listPaginated(anchor, limit)))
- .collectList()
- .block();
+ private Flux<Username> applyLimit(Flux<Username> users, Optional<Integer> limit) {
+ return limit.map(value -> users.take(value, true))
+ .orElse(users);
}
public void removeUser(Username username) throws UsersRepositoryException {
diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/UserRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/UserRoutesTest.java
index ebb10ef422..c40b5da882 100644
--- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/UserRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/UserRoutesTest.java
@@ -26,6 +26,7 @@ import static org.apache.james.webadmin.Constants.SEPARATOR;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
@@ -651,7 +652,7 @@ class UserRoutesTest {
@Test
default void getShouldFailOnRepositoryException(UsersRepository usersRepository) throws Exception {
- when(usersRepository.listPaginated(any(), any())).thenReturn(Flux.error(new UsersRepositoryException("message")));
+ doReturn(Flux.error(new UsersRepositoryException("message"))).when(usersRepository).searchPaginated(any(), any(), any());
when()
.get()
@@ -713,7 +714,7 @@ class UserRoutesTest {
@Test
default void getShouldFailOnUnknownException(UsersRepository usersRepository) throws Exception {
- when(usersRepository.listPaginated(any(), any())).thenThrow(new RuntimeException());
+ doThrow(new RuntimeException()).when(usersRepository).searchPaginated(any(), any(), any());
when()
.get()
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org