http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java ---------------------------------------------------------------------- diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java index 14aa1c8..9ee4bb5 100644 --- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java +++ b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java @@ -29,7 +29,7 @@ import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTableException; import org.apache.james.rrt.api.RecipientRewriteTableManagementMBean; -import com.google.common.collect.ImmutableMap; +import com.github.steveash.guavate.Guavate; /** * Management for RecipientRewriteTables @@ -46,89 +46,102 @@ public class RecipientRewriteTableManagement extends StandardMBean implements Re @Override public void addRegexMapping(String user, String domain, String regex) throws RecipientRewriteTableException { - rrt.addRegexMapping(user, Domain.of(domain), regex); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.addRegexMapping(source, regex); } @Override public void removeRegexMapping(String user, String domain, String regex) throws RecipientRewriteTableException { - rrt.removeRegexMapping(user, Domain.of(domain), regex); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.removeRegexMapping(source, regex); } @Override public void addAddressMapping(String user, String domain, String address) throws RecipientRewriteTableException { - rrt.addAddressMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.addAddressMapping(source, address); } @Override public void removeAddressMapping(String user, String domain, String address) throws RecipientRewriteTableException { - rrt.removeAddressMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.removeAddressMapping(source, address); } @Override public void addErrorMapping(String user, String domain, String error) throws RecipientRewriteTableException { - rrt.addErrorMapping(user, Domain.of(domain), error); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.addErrorMapping(source, error); } @Override public void removeErrorMapping(String user, String domain, String error) throws RecipientRewriteTableException { - rrt.removeErrorMapping(user, Domain.of(domain), error); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.removeErrorMapping(source, error); } @Override public void addDomainMapping(String domain, String targetDomain) throws RecipientRewriteTableException { - rrt.addAliasDomainMapping(Domain.of(domain), Domain.of(targetDomain)); + MappingSource source = MappingSource.fromDomain(Domain.of(domain)); + rrt.addAliasDomainMapping(source, Domain.of(targetDomain)); } @Override public void removeDomainMapping(String domain, String targetDomain) throws RecipientRewriteTableException { - rrt.removeAliasDomainMapping(Domain.of(domain), Domain.of(targetDomain)); + MappingSource source = MappingSource.fromDomain(Domain.of(domain)); + rrt.removeAliasDomainMapping(source, Domain.of(targetDomain)); } @Override public Mappings getUserDomainMappings(String user, String domain) throws RecipientRewriteTableException { - return rrt.getUserDomainMappings(user, Domain.of(domain)); + MappingSource source = MappingSource.fromUser(user, domain); + return rrt.getUserDomainMappings(source); } @Override public void addMapping(String user, String domain, String mapping) throws RecipientRewriteTableException { - rrt.addMapping(user, Domain.of(domain), Mapping.of(mapping)); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.addMapping(source, Mapping.of(mapping)); } @Override public void removeMapping(String user, String domain, String mapping) throws RecipientRewriteTableException { - rrt.removeMapping(user, Domain.of(domain), Mapping.of(mapping)); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.removeMapping(source, Mapping.of(mapping)); } @Override public Map<String, Mappings> getAllMappings() throws RecipientRewriteTableException { - return ImmutableMap.copyOf(rrt.getAllMappings()); + return rrt.getAllMappings() + .entrySet() + .stream() + .collect( + Guavate.toImmutableMap( + entry -> entry.getKey().asString(), + entry -> entry.getValue())); } @Override public void addForwardMapping(String user, String domain, String address) throws RecipientRewriteTableException { - rrt.addForwardMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.addForwardMapping(source, address); } @Override public void removeForwardMapping(String user, String domain, String address) throws RecipientRewriteTableException { - rrt.removeForwardMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rrt.removeForwardMapping(source, address); } @Override - public void addGroupMapping(String toUser, String toDomain, String fromAddress) { - try { - rrt.addGroupMapping(toUser, Domain.of(toDomain), fromAddress); - } catch (RecipientRewriteTableException e) { - throw new RuntimeException(e); - } + public void addGroupMapping(String toUser, String toDomain, String fromAddress) throws RecipientRewriteTableException { + MappingSource source = MappingSource.fromUser(toUser, toDomain); + rrt.addGroupMapping(source, fromAddress); } @Override - public void removeGroupMapping(String toUser, String toDomain, String fromAddress) { - try { - rrt.removeForwardMapping(toUser, Domain.of(toDomain), fromAddress); - } catch (RecipientRewriteTableException e) { - throw new RuntimeException(e); - } + public void removeGroupMapping(String toUser, String toDomain, String fromAddress) throws RecipientRewriteTableException { + MappingSource source = MappingSource.fromUser(toUser, toDomain); + rrt.removeForwardMapping(source, fromAddress); } }
http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableUtil.java ---------------------------------------------------------------------- diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableUtil.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableUtil.java index 1546a84..6de8378 100644 --- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableUtil.java +++ b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableUtil.java @@ -46,32 +46,11 @@ public class RecipientRewriteTableUtil { * @return the real recipient address, or <code>null</code> if no mapping * exists */ - public static String getTargetString(String user, Domain domain, Map<String, String> mappings) { - StringBuffer buf; - String target; - - // Look for exact (user@domain) match - buf = new StringBuffer().append(user).append("@").append(domain.asString()); - target = mappings.get(buf.toString()); - if (target != null) { - return target; - } - - // Look for user@* match - buf = new StringBuffer().append(user).append("@*"); - target = mappings.get(buf.toString()); - if (target != null) { - return target; - } - - // Look for *@domain match - buf = new StringBuffer().append("*@").append(domain.asString()); - target = mappings.get(buf.toString()); - if (target != null) { - return target; - } - - return null; + public static String getTargetString(String user, Domain domain, Map<MappingSource, String> mappings) { + return OptionalUtils.or( + Optional.ofNullable(mappings.get(MappingSource.fromUser(user, domain))), + Optional.ofNullable(mappings.get(MappingSource.fromDomain(domain)))) + .orElse(null); } /** @@ -116,15 +95,15 @@ public class RecipientRewriteTableUtil { * A String which contains a list of mappings * @return Map which contains the mappings */ - public static Map<String, String> getXMLMappings(String mapping) { - Map<String, String> mappings = new HashMap<>(); + public static Map<MappingSource, String> getXMLMappings(String mapping) { + Map<MappingSource, String> mappings = new HashMap<>(); StringTokenizer tokenizer = new StringTokenizer(mapping, ","); while (tokenizer.hasMoreTokens()) { String mappingItem = tokenizer.nextToken(); int index = mappingItem.indexOf('='); String virtual = mappingItem.substring(0, index).trim().toLowerCase(Locale.US); String real = mappingItem.substring(index + 1).trim().toLowerCase(Locale.US); - mappings.put(virtual, real); + mappings.put(MappingSource.parse(virtual), real); } return mappings; } http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/data/data-library/src/main/java/org/apache/james/user/lib/AbstractJamesUsersRepository.java ---------------------------------------------------------------------- diff --git a/server/data/data-library/src/main/java/org/apache/james/user/lib/AbstractJamesUsersRepository.java b/server/data/data-library/src/main/java/org/apache/james/user/lib/AbstractJamesUsersRepository.java index 3f9c4d3..491accb 100644 --- a/server/data/data-library/src/main/java/org/apache/james/user/lib/AbstractJamesUsersRepository.java +++ b/server/data/data-library/src/main/java/org/apache/james/user/lib/AbstractJamesUsersRepository.java @@ -29,6 +29,7 @@ import org.apache.james.core.Domain; import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTableException; import org.apache.james.rrt.lib.Mapping; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.lib.Mappings; import org.apache.james.rrt.lib.MappingsImpl; import org.apache.james.rrt.lib.MappingsImpl.Builder; @@ -172,8 +173,8 @@ public abstract class AbstractJamesUsersRepository extends AbstractUsersReposito } @Override - public Map<String, Mappings> getAllMappings() throws RecipientRewriteTableException { - Map<String, Mappings> mappings = new HashMap<>(); + public Map<MappingSource, Mappings> getAllMappings() throws RecipientRewriteTableException { + Map<MappingSource, Mappings> mappings = new HashMap<>(); if (enableAliases || enableForwarding) { try { Iterator<String> users = list(); @@ -190,7 +191,8 @@ public abstract class AbstractJamesUsersRepository extends AbstractUsersReposito domain = Domain.LOCALHOST; } try { - mappings.put(user, getMappings(username, domain)); + MappingSource source = MappingSource.fromUser(org.apache.james.core.User.fromUsername(user)); + mappings.put(source, getMappings(username, domain)); } catch (ErrorMappingException e) { // shold never happen here } @@ -204,86 +206,86 @@ public abstract class AbstractJamesUsersRepository extends AbstractUsersReposito } @Override - public Mappings getUserDomainMappings(String user, Domain domain) throws RecipientRewriteTableException { + public Mappings getUserDomainMappings(MappingSource source) throws RecipientRewriteTableException { return MappingsImpl.empty(); } @Override - public void addRegexMapping(String user, Domain domain, String regex) throws RecipientRewriteTableException { + public void addRegexMapping(MappingSource source, String regex) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void removeRegexMapping(String user, Domain domain, String regex) throws RecipientRewriteTableException { + public void removeRegexMapping(MappingSource source, String regex) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void addAddressMapping(String user, Domain domain, String address) throws RecipientRewriteTableException { + public void addAddressMapping(MappingSource source, String address) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void removeAddressMapping(String user, Domain domain, String address) throws RecipientRewriteTableException { + public void removeAddressMapping(MappingSource source, String address) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void addErrorMapping(String user, Domain domain, String error) throws RecipientRewriteTableException { + public void addErrorMapping(MappingSource source, String error) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void removeErrorMapping(String user, Domain domain, String error) throws RecipientRewriteTableException { + public void removeErrorMapping(MappingSource source, String error) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void addMapping(String user, Domain domain, Mapping mapping) throws RecipientRewriteTableException { + public void addMapping(MappingSource source, Mapping mapping) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void removeMapping(String user, Domain domain, Mapping mapping) throws RecipientRewriteTableException { + public void removeMapping(MappingSource source, Mapping mapping) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void addAliasDomainMapping(Domain aliasDomain, Domain realDomain) throws RecipientRewriteTableException { + public void addAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void removeAliasDomainMapping(Domain aliasDomain, Domain realDomain) throws RecipientRewriteTableException { + public void removeAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void addForwardMapping(String user, Domain domain, String address) throws RecipientRewriteTableException { + public void addForwardMapping(MappingSource source, String address) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void removeForwardMapping(String user, Domain domain, String address) throws RecipientRewriteTableException { + public void removeForwardMapping(MappingSource source, String address) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void addGroupMapping(String user, Domain domain, String address) throws RecipientRewriteTableException { + public void addGroupMapping(MappingSource source, String address) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } @Override - public void removeGroupMapping(String user, Domain domain, String address) throws RecipientRewriteTableException { + public void removeGroupMapping(MappingSource source, String address) throws RecipientRewriteTableException { throw new RecipientRewriteTableException("Read-Only RecipientRewriteTable"); } } http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java ---------------------------------------------------------------------- diff --git a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java index 2873feb..17bb88e 100644 --- a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java +++ b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java @@ -26,7 +26,6 @@ import java.util.Map; import org.apache.commons.lang3.tuple.Pair; import org.apache.james.core.Domain; import org.apache.james.lifecycle.api.LifecycleUtil; -import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTable.ErrorMappingException; import org.apache.james.rrt.api.RecipientRewriteTableException; import org.junit.Rule; @@ -53,16 +52,15 @@ public abstract class AbstractRecipientRewriteTableTest { } public void tearDown() throws Exception { - Map<String, Mappings> mappings = virtualUserTable.getAllMappings(); + Map<MappingSource, Mappings> mappings = virtualUserTable.getAllMappings(); if (mappings != null) { - for (String key : virtualUserTable.getAllMappings().keySet()) { + for (MappingSource key : virtualUserTable.getAllMappings().keySet()) { Mappings map = mappings.get(key); - String[] args = key.split("@"); map.asStream() .forEach(Throwing.consumer(mapping -> - virtualUserTable.removeMapping(args[0], Domain.of(args[1]), mapping))); + virtualUserTable.removeMapping(key, mapping))); } } @@ -71,9 +69,8 @@ public abstract class AbstractRecipientRewriteTableTest { @Test public void testStoreAndGetMappings() throws ErrorMappingException, RecipientRewriteTableException { - String user = "*"; Domain domain = Domain.of("test"); - virtualUserTable.addMapping(user, domain, Mapping.regex("prefix_.*:admin@test")); + virtualUserTable.addMapping(MappingSource.fromDomain(domain), Mapping.regex("prefix_.*:admin@test")); assertThat(virtualUserTable.getMappings("prefix_abc", domain)).isNotEmpty(); } @@ -81,6 +78,7 @@ public abstract class AbstractRecipientRewriteTableTest { public void testStoreAndRetrieveRegexMapping() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; + MappingSource source = MappingSource.fromUser(user, domain); // String regex = "(.*):{$1}@localhost"; // String regex2 = "(.+):{$1}@test"; String regex = "(.*)@localhost"; @@ -90,18 +88,18 @@ public abstract class AbstractRecipientRewriteTableTest { assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); - virtualUserTable.addMapping(user, domain, Mapping.regex(regex)); - virtualUserTable.addMapping(user, domain, Mapping.regex(regex2)); + virtualUserTable.addMapping(source, Mapping.regex(regex)); + virtualUserTable.addMapping(source, Mapping.regex(regex2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("Two mappings").hasSize(2); assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1); - virtualUserTable.removeMapping(user, domain, Mapping.regex(regex)); + virtualUserTable.removeMapping(source, Mapping.regex(regex)); - assertThatThrownBy(() -> virtualUserTable.addRegexMapping(user, domain, invalidRegex)) + assertThatThrownBy(() -> virtualUserTable.addRegexMapping(source, invalidRegex)) .describedAs("Invalid Mapping throw exception") .isInstanceOf(RecipientRewriteTableException.class); - virtualUserTable.removeMapping(user, domain, Mapping.regex(regex2)); + virtualUserTable.removeMapping(source, Mapping.regex(regex2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") @@ -116,18 +114,21 @@ public abstract class AbstractRecipientRewriteTableTest { String regex = "(.*)@localhost"; String regex2 = "(.+)@test"; - virtualUserTable.addMapping(user, Domain.LOCALHOST, Mapping.regex(regex)); - virtualUserTable.addMapping(user, Domain.LOCALHOST, Mapping.regex(regex2)); - virtualUserTable.addMapping(user2, Domain.LOCALHOST, Mapping.address(user + "@" + Domain.LOCALHOST.asString())); + MappingSource source1 = MappingSource.fromUser(user, Domain.LOCALHOST); + MappingSource source2 = MappingSource.fromUser(user2, Domain.LOCALHOST); + + virtualUserTable.addMapping(source1, Mapping.regex(regex)); + virtualUserTable.addMapping(source1, Mapping.regex(regex2)); + virtualUserTable.addMapping(source2, Mapping.address(user + "@" + Domain.LOCALHOST.asString())); assertThat(virtualUserTable.getAllMappings()) .describedAs("One mappingline") .containsOnly( - Pair.of(user + "@" + Domain.LOCALHOST.asString(), MappingsImpl.builder() + Pair.of(source1, MappingsImpl.builder() .add(Mapping.regex(regex)) .add(Mapping.regex(regex2)) .build()), - Pair.of(user2 + "@" + Domain.LOCALHOST.asString(), MappingsImpl.builder() + Pair.of(source2, MappingsImpl.builder() .add(Mapping.address(user + "@" + Domain.LOCALHOST.asString())) .build())); } @@ -137,20 +138,21 @@ public abstract class AbstractRecipientRewriteTableTest { String user = "test"; Domain domain = Domain.LOCALHOST; + MappingSource source = MappingSource.fromUser(user, domain); String address = "test@localhost2"; String address2 = "test@james"; assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); - virtualUserTable.addMapping(user, domain, Mapping.address(address)); - virtualUserTable.addMapping(user, domain, Mapping.address(address2)); + virtualUserTable.addMapping(source, Mapping.address(address)); + virtualUserTable.addMapping(source, Mapping.address(address2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("Two mappings").hasSize(2); assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1); - virtualUserTable.removeMapping(user, domain, Mapping.address(address)); - virtualUserTable.removeMapping(user, domain, Mapping.address(address2)); + virtualUserTable.removeMapping(source, Mapping.address(address)); + virtualUserTable.removeMapping(source, Mapping.address(address2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); @@ -161,12 +163,13 @@ public abstract class AbstractRecipientRewriteTableTest { public void testStoreAndRetrieveErrorMapping() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; + MappingSource source = MappingSource.fromUser(user, domain); String error = "bounce!"; assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); - virtualUserTable.addMapping(user, domain, Mapping.error(error)); + virtualUserTable.addMapping(source, Mapping.error(error)); assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1); assertThatThrownBy(() -> @@ -174,7 +177,7 @@ public abstract class AbstractRecipientRewriteTableTest { .describedAs("Exception thrown on to many mappings") .isInstanceOf(ErrorMappingException.class); - virtualUserTable.removeMapping(user, domain, Mapping.error(error)); + virtualUserTable.removeMapping(source, Mapping.error(error)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); @@ -188,18 +191,19 @@ public abstract class AbstractRecipientRewriteTableTest { Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; + MappingSource source = MappingSource.fromUser(user, domain); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); - virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, domain, Mapping.address(address)); - virtualUserTable.addMapping(user, domain, Mapping.address(address2)); + virtualUserTable.addMapping(MappingSource.fromDomain(domain), Mapping.address(address)); + virtualUserTable.addMapping(source, Mapping.address(address2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("One mappings").hasSize(1); assertThat(virtualUserTable.getMappings(user2, domain)).describedAs("One mappings").hasSize(1); - virtualUserTable.removeMapping(user, domain, Mapping.address(address2)); - virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, domain, Mapping.address(address)); + virtualUserTable.removeMapping(source, Mapping.address(address2)); + virtualUserTable.removeMapping(MappingSource.fromDomain(domain), Mapping.address(address)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); @@ -215,15 +219,18 @@ public abstract class AbstractRecipientRewriteTableTest { Domain domain1 = Domain.of("domain1"); Domain domain2 = Domain.of("domain2"); Domain domain3 = Domain.of("domain3"); + MappingSource source1 = MappingSource.fromUser(user1, domain1); + MappingSource source2 = MappingSource.fromUser(user2, domain2); + MappingSource source3 = MappingSource.fromUser(user3, domain3); virtualUserTable.setRecursiveMapping(true); assertThat(virtualUserTable.getAllMappings()).describedAs("No mapping").isEmpty(); - virtualUserTable.addMapping(user1, domain1, Mapping.address(user2 + "@" + domain2.asString())); - virtualUserTable.addMapping(user2, domain2, Mapping.address(user3 + "@" + domain3.asString())); + virtualUserTable.addMapping(source1, Mapping.address(user2 + "@" + domain2.asString())); + virtualUserTable.addMapping(source2, Mapping.address(user3 + "@" + domain3.asString())); assertThat(virtualUserTable.getMappings(user1, domain1)).containsOnly(Mapping.address(user3 + "@" + domain3.asString())); - virtualUserTable.addMapping(user3, domain3, Mapping.address(user1 + "@" + domain1.asString())); + virtualUserTable.addMapping(source3, Mapping.address(user1 + "@" + domain1.asString())); assertThatThrownBy(() -> virtualUserTable.getMappings(user1, domain1)) @@ -244,8 +251,8 @@ public abstract class AbstractRecipientRewriteTableTest { assertThat(virtualUserTable.getAllMappings()).describedAs("No mappings").isEmpty(); - virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.address(user2 + "@" + domain)); - virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.domain(Domain.of(domain))); + virtualUserTable.addMapping(MappingSource.fromDomain(aliasDomain), Mapping.address(user2 + "@" + domain)); + virtualUserTable.addMapping(MappingSource.fromDomain(aliasDomain), Mapping.domain(Domain.of(domain))); assertThat(virtualUserTable.getMappings(user, aliasDomain)) .describedAs("Domain mapped as first, Address mapped as second") @@ -254,8 +261,8 @@ public abstract class AbstractRecipientRewriteTableTest { .add(Mapping.address(user2 + "@" + domain)) .build()); - virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.address(user2 + "@" + domain)); - virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.domain(Domain.of(domain))); + virtualUserTable.removeMapping(MappingSource.fromDomain(aliasDomain), Mapping.address(user2 + "@" + domain)); + virtualUserTable.removeMapping(MappingSource.fromDomain(aliasDomain), Mapping.domain(Domain.of(domain))); } @Test @@ -263,11 +270,12 @@ public abstract class AbstractRecipientRewriteTableTest { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; + MappingSource source = MappingSource.fromUser(user, domain); expectedException.expect(RecipientRewriteTableException.class); - virtualUserTable.addAddressMapping(user, domain, address); - virtualUserTable.addAddressMapping(user, domain, address); + virtualUserTable.addAddressMapping(source, address); + virtualUserTable.addAddressMapping(source, address); } @Test @@ -275,9 +283,10 @@ public abstract class AbstractRecipientRewriteTableTest { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; + MappingSource source = MappingSource.fromUser(user, domain); - virtualUserTable.addMapping(user, domain, Mapping.address(address)); - virtualUserTable.addMapping(user, domain, Mapping.regex(address)); + virtualUserTable.addMapping(source, Mapping.address(address)); + virtualUserTable.addMapping(source, Mapping.regex(address)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); } @@ -288,9 +297,10 @@ public abstract class AbstractRecipientRewriteTableTest { Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; + MappingSource source = MappingSource.fromUser(user, domain); - virtualUserTable.addMapping(user, domain, Mapping.forward(address)); - virtualUserTable.addMapping(user, domain, Mapping.forward(address2)); + virtualUserTable.addMapping(source, Mapping.forward(address)); + virtualUserTable.addMapping(source, Mapping.forward(address2)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); } @@ -301,12 +311,13 @@ public abstract class AbstractRecipientRewriteTableTest { Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; + MappingSource source = MappingSource.fromUser(user, domain); - virtualUserTable.addMapping(user, domain, Mapping.forward(address)); - virtualUserTable.addMapping(user, domain, Mapping.forward(address2)); + virtualUserTable.addMapping(source, Mapping.forward(address)); + virtualUserTable.addMapping(source, Mapping.forward(address2)); - virtualUserTable.removeMapping(user, domain, Mapping.forward(address)); - virtualUserTable.removeMapping(user, domain, Mapping.forward(address2)); + virtualUserTable.removeMapping(source, Mapping.forward(address)); + virtualUserTable.removeMapping(source, Mapping.forward(address2)); assertThat(virtualUserTable.getMappings(user, domain)) .isEqualTo(MappingsImpl.empty()); @@ -318,9 +329,10 @@ public abstract class AbstractRecipientRewriteTableTest { Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; + MappingSource source = MappingSource.fromUser(user, domain); - virtualUserTable.addMapping(user, domain, Mapping.group(address)); - virtualUserTable.addMapping(user, domain, Mapping.group(address2)); + virtualUserTable.addMapping(source, Mapping.group(address)); + virtualUserTable.addMapping(source, Mapping.group(address2)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); } @@ -331,12 +343,13 @@ public abstract class AbstractRecipientRewriteTableTest { Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; + MappingSource source = MappingSource.fromUser(user, domain); - virtualUserTable.addMapping(user, domain, Mapping.group(address)); - virtualUserTable.addMapping(user, domain, Mapping.group(address2)); + virtualUserTable.addMapping(source, Mapping.group(address)); + virtualUserTable.addMapping(source, Mapping.group(address2)); - virtualUserTable.removeMapping(user, domain, Mapping.group(address)); - virtualUserTable.removeMapping(user, domain, Mapping.group(address2)); + virtualUserTable.removeMapping(source, Mapping.group(address)); + virtualUserTable.removeMapping(source, Mapping.group(address2)); assertThat(virtualUserTable.getMappings(user, domain)) .isEqualTo(MappingsImpl.empty()); http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java ---------------------------------------------------------------------- diff --git a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java index bd888ca..a2e83b7 100644 --- a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java +++ b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java @@ -39,13 +39,15 @@ public class RewriteTablesStepdefs { @Given("store \"([^\"]*)\" regexp mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeRegexpMappingForUserAtDomain(String regexp, String user, String domain) throws Throwable { - rewriteTable.addRegexMapping(user, Domain.of(domain), regexp); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.addRegexMapping(source, regexp); } @Given("store an invalid \"([^\"]*)\" regexp mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeInvalidRegexpMappingForUserAtDomain(String regexp, String user, String domain) { try { - rewriteTable.addRegexMapping(user, Domain.of(domain), regexp); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.addRegexMapping(source, regexp); } catch (RecipientRewriteTableException e) { this.exception = e; } @@ -53,12 +55,14 @@ public class RewriteTablesStepdefs { @Given("store \"([^\"]*)\" address mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeAddressMappingForUserAtDomain(String address, String user, String domain) throws Throwable { - rewriteTable.addAddressMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.addAddressMapping(source, address); } @Given("store \"([^\"]*)\" error mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeErrorMappingForUserAtDomain(String error, String user, String domain) throws Throwable { - rewriteTable.addErrorMapping(user, Domain.of(domain), error); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.addErrorMapping(source, error); } @Given("store \"([^\"]*)\" address mapping as wildcard for domain \"([^\"]*)\"") @@ -68,17 +72,19 @@ public class RewriteTablesStepdefs { @Given("store \"([^\"]*)\" alias domain mapping for domain \"([^\"]*)\"") public void storeAliasDomainMappingForDomain(String aliasDomain, String domain) throws Throwable { - rewriteTable.addAliasDomainMapping(Domain.of(aliasDomain), Domain.of(domain)); + rewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(domain)); } @Given("store \"([^\"]*)\" forward mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeForwardMappingForUserAtDomain(String address, String user, String domain) throws Throwable { - rewriteTable.addForwardMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.addForwardMapping(source, address); } @Given("store \"([^\"]*)\" group mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeGroupMappingForUserAtDomain(String address, String user, String domain) throws Throwable { - rewriteTable.addGroupMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.addGroupMapping(source, address); } @Given("recursive mapping is disable") @@ -93,27 +99,32 @@ public class RewriteTablesStepdefs { @When("user \"([^\"]*)\" at domain \"([^\"]*)\" removes a regexp mapping \"([^\"]*)\"") public void userAtDomainRemovesRegexpMapping(String user, String domain, String regexp) throws Throwable { - rewriteTable.removeRegexMapping(user, Domain.of(domain), regexp); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.removeRegexMapping(source, regexp); } @When("user \"([^\"]*)\" at domain \"([^\"]*)\" removes a address mapping \"([^\"]*)\"") public void userAtDomainRemovesAddressMapping(String user, String domain, String address) throws Throwable { - rewriteTable.removeAddressMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.removeAddressMapping(source, address); } @When("user \"([^\"]*)\" at domain \"([^\"]*)\" removes a error mapping \"([^\"]*)\"") public void userAtDomainRemovesErrorMapping(String user, String domain, String error) throws Throwable { - rewriteTable.removeErrorMapping(user, Domain.of(domain), error); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.removeErrorMapping(source, error); } @When("user \"([^\"]*)\" at domain \"([^\"]*)\" removes a forward mapping \"([^\"]*)\"") public void userAtDomainRemovesForwardMapping(String user, String domain, String address) throws Throwable { - rewriteTable.removeForwardMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.removeForwardMapping(source, address); } @When("user \"([^\"]*)\" at domain \"([^\"]*)\" removes a group mapping \"([^\"]*)\"") public void userAtDomainRemovesGroupMapping(String user, String domain, String address) throws Throwable { - rewriteTable.removeGroupMapping(user, Domain.of(domain), address); + MappingSource source = MappingSource.fromUser(user, domain); + rewriteTable.removeGroupMapping(source, address); } @When("wildcard address mapping \"([^\"]*)\" at domain \"([^\"]*)\" is removed") @@ -123,7 +134,7 @@ public class RewriteTablesStepdefs { @When("alias domain mapping \"([^\"]*)\" for \"([^\"]*)\" domain is removed") public void removeAliasDomainMappingForDomain(String aliasdomain, String domain) throws Throwable { - rewriteTable.removeAliasDomainMapping(Domain.of(aliasdomain), Domain.of(domain)); + rewriteTable.removeAliasDomainMapping(MappingSource.fromDomain(Domain.of(aliasdomain)), Domain.of(domain)); } @Then("mappings should be empty") http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/data/data-memory/src/main/java/org/apache/james/rrt/memory/MemoryRecipientRewriteTable.java ---------------------------------------------------------------------- diff --git a/server/data/data-memory/src/main/java/org/apache/james/rrt/memory/MemoryRecipientRewriteTable.java b/server/data/data-memory/src/main/java/org/apache/james/rrt/memory/MemoryRecipientRewriteTable.java index b45e4ed..fca798c 100644 --- a/server/data/data-memory/src/main/java/org/apache/james/rrt/memory/MemoryRecipientRewriteTable.java +++ b/server/data/data-memory/src/main/java/org/apache/james/rrt/memory/MemoryRecipientRewriteTable.java @@ -28,8 +28,10 @@ import java.util.stream.Stream; import org.apache.commons.lang3.tuple.Pair; import org.apache.james.core.Domain; +import org.apache.james.core.User; import org.apache.james.rrt.lib.AbstractRecipientRewriteTable; import org.apache.james.rrt.lib.Mapping; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.lib.Mappings; import org.apache.james.rrt.lib.MappingsImpl; import org.apache.james.util.OptionalUtils; @@ -41,32 +43,22 @@ import com.google.common.collect.Multimaps; public class MemoryRecipientRewriteTable extends AbstractRecipientRewriteTable { private static class InMemoryMappingEntry { - private final String user; - private final Domain domain; + private final MappingSource source; private final Mapping mapping; - public InMemoryMappingEntry(String user, Domain domain, Mapping mapping) { - this.user = user; - this.domain = domain; + public InMemoryMappingEntry(MappingSource source, Mapping mapping) { + this.source = source; this.mapping = mapping; } - public String getUser() { - return user; - } - - public Domain getDomain() { - return domain; + public MappingSource getSource() { + return source; } public Mapping getMapping() { return mapping; } - public String asKey() { - return getUser() + "@" + getDomain().asString(); - } - @Override public boolean equals(Object o) { if (o == null || this.getClass() != o.getClass()) { @@ -75,14 +67,13 @@ public class MemoryRecipientRewriteTable extends AbstractRecipientRewriteTable { InMemoryMappingEntry that = (InMemoryMappingEntry) o; - return Objects.equal(this.user, that.user) - && Objects.equal(this.domain, that.domain) + return Objects.equal(this.source, that.source) && Objects.equal(this.mapping, that.mapping); } @Override public int hashCode() { - return Objects.hashCode(user, domain, mapping); + return Objects.hashCode(source, mapping); } } @@ -93,32 +84,32 @@ public class MemoryRecipientRewriteTable extends AbstractRecipientRewriteTable { } @Override - public void addMapping(String user, Domain domain, Mapping mapping) { - mappingEntries.add(new InMemoryMappingEntry(getFixedUser(user), getFixedDomain(domain), mapping)); + public void addMapping(MappingSource source, Mapping mapping) { + mappingEntries.add(new InMemoryMappingEntry(source, mapping)); } @Override - public void removeMapping(String user, Domain domain, Mapping mapping) { - mappingEntries.remove(new InMemoryMappingEntry(getFixedUser(user), getFixedDomain(domain), mapping)); + public void removeMapping(MappingSource source, Mapping mapping) { + mappingEntries.remove(new InMemoryMappingEntry(source, mapping)); } @Override - public Mappings getUserDomainMappings(String user, Domain domain) { - return retrieveMappings(user, domain) + public Mappings getUserDomainMappings(MappingSource mappingSource) { + return retrieveMappings(mappingSource) .orElse(null); } @Override protected Mappings mapAddress(String user, Domain domain) { return OptionalUtils.orSuppliers( - () -> retrieveMappings(user, domain), - () -> retrieveMappings(WILDCARD, domain)) + () -> retrieveMappings(MappingSource.fromUser(User.fromLocalPartWithDomain(user, domain))), + () -> retrieveMappings(MappingSource.fromDomain(domain))) .orElse(MappingsImpl.empty()); } @Override - public Map<String, Mappings> getAllMappings() { - return Multimaps.index(mappingEntries, InMemoryMappingEntry::asKey) + public Map<MappingSource, Mappings> getAllMappings() { + return Multimaps.index(mappingEntries, InMemoryMappingEntry::getSource) .asMap() .entrySet() .stream() @@ -132,9 +123,9 @@ public class MemoryRecipientRewriteTable extends AbstractRecipientRewriteTable { .map(InMemoryMappingEntry::getMapping)); } - private Optional<Mappings> retrieveMappings(String user, Domain domain) { + private Optional<Mappings> retrieveMappings(MappingSource mappingSource) { Stream<Mapping> userEntries = mappingEntries.stream() - .filter(mappingEntry -> user.equals(mappingEntry.getUser()) && domain.equals(mappingEntry.getDomain())) + .filter(mappingEntry -> mappingEntry.source.equals(mappingSource)) .map(InMemoryMappingEntry::getMapping); return MappingsImpl.fromMappings(userEntries).toOptional(); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/mailet/mailets/src/main/java/org/apache/james/transport/mailets/XMLRecipientRewriteTable.java ---------------------------------------------------------------------- diff --git a/server/mailet/mailets/src/main/java/org/apache/james/transport/mailets/XMLRecipientRewriteTable.java b/server/mailet/mailets/src/main/java/org/apache/james/transport/mailets/XMLRecipientRewriteTable.java index 9fea7da..bdb8dbc 100755 --- a/server/mailet/mailets/src/main/java/org/apache/james/transport/mailets/XMLRecipientRewriteTable.java +++ b/server/mailet/mailets/src/main/java/org/apache/james/transport/mailets/XMLRecipientRewriteTable.java @@ -28,6 +28,7 @@ import javax.mail.MessagingException; import org.apache.james.core.Domain; import org.apache.james.core.MailAddress; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.lib.RecipientRewriteTableUtil; import org.apache.mailet.Experimental; @@ -80,7 +81,7 @@ public class XMLRecipientRewriteTable extends AbstractRecipientRewriteTable { /** * Holds the configured mappings */ - private Map<String, String> mappings = new HashMap<>(); + private Map<MappingSource, String> mappings = new HashMap<>(); @Override public void init() throws MessagingException { @@ -99,7 +100,7 @@ public class XMLRecipientRewriteTable extends AbstractRecipientRewriteTable { * the mapping of virtual to real recipients */ @Override - protected void mapRecipients(Map<MailAddress, String> recipientsMap) throws MessagingException { + protected void mapRecipients(Map<MailAddress, String> recipientsMap) { Collection<MailAddress> recipients = recipientsMap.keySet(); for (MailAddress source : recipients) { http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/ValidRcptHandlerTest.java ---------------------------------------------------------------------- diff --git a/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/ValidRcptHandlerTest.java b/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/ValidRcptHandlerTest.java index c9db765..2e8e892 100644 --- a/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/ValidRcptHandlerTest.java +++ b/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/ValidRcptHandlerTest.java @@ -38,6 +38,7 @@ import org.apache.james.protocols.smtp.hook.HookReturnCode; import org.apache.james.protocols.smtp.utils.BaseFakeSMTPSession; import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTableException; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.memory.MemoryRecipientRewriteTable; import org.apache.james.smtpserver.fastfail.ValidRcptHandler; import org.apache.james.user.api.UsersRepository; @@ -116,8 +117,8 @@ public class ValidRcptHandlerTest { private RecipientRewriteTable setUpRecipientRewriteTable(DomainList domainList) throws RecipientRewriteTableException { MemoryRecipientRewriteTable memoryRecipientRewriteTable = new MemoryRecipientRewriteTable(); memoryRecipientRewriteTable.setDomainList(domainList); - memoryRecipientRewriteTable.addAddressMapping(USER1, Domain.LOCALHOST, "address"); - memoryRecipientRewriteTable.addErrorMapping(USER2, Domain.LOCALHOST, "554 BOUNCE"); + memoryRecipientRewriteTable.addAddressMapping(MappingSource.fromUser(USER1, Domain.LOCALHOST), "address"); + memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser(USER2, Domain.LOCALHOST), "554 BOUNCE"); return memoryRecipientRewriteTable; } http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/ForwardRoutes.java ---------------------------------------------------------------------- diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/ForwardRoutes.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/ForwardRoutes.java index 2145d40..935f88a 100644 --- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/ForwardRoutes.java +++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/ForwardRoutes.java @@ -39,13 +39,16 @@ import javax.ws.rs.Path; import javax.ws.rs.Produces; import org.apache.james.core.MailAddress; +import org.apache.james.core.User; import org.apache.james.domainlist.api.DomainListException; import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTableException; import org.apache.james.rrt.lib.Mapping; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.lib.Mappings; import org.apache.james.user.api.UsersRepository; import org.apache.james.user.api.UsersRepositoryException; +import org.apache.james.util.OptionalUtils; import org.apache.james.webadmin.Constants; import org.apache.james.webadmin.Routes; import org.apache.james.webadmin.dto.ForwardDestinationResponse; @@ -134,6 +137,8 @@ public class ForwardRoutes implements Routes { mappings.entrySet().stream() .filter(e -> e.getValue().contains(Mapping.Type.Forward)) .map(Map.Entry::getKey) + .flatMap(source -> OptionalUtils.toStream(source.asMailAddress())) + .map(MailAddress::asString) .collect(Guavate.toImmutableSortedSet())) .orElse(ImmutableSortedSet.of()); } @@ -161,7 +166,8 @@ public class ForwardRoutes implements Routes { MailAddress forwardBaseAddress = parseMailAddress(request.params(FORWARD_BASE_ADDRESS)); ensureUserExist(forwardBaseAddress); MailAddress destinationAddress = parseMailAddress(request.params(FORWARD_DESTINATION_ADDRESS)); - recipientRewriteTable.addForwardMapping(forwardBaseAddress.getLocalPart(), forwardBaseAddress.getDomain(), destinationAddress.asString()); + MappingSource source = MappingSource.fromUser(User.fromLocalPartWithDomain(forwardBaseAddress.getLocalPart(), forwardBaseAddress.getDomain())); + recipientRewriteTable.addForwardMapping(source, destinationAddress.asString()); return halt(HttpStatus.CREATED_201); } @@ -193,10 +199,8 @@ public class ForwardRoutes implements Routes { public HaltException removeFromForwardDestination(Request request, Response response) throws JsonExtractException, AddressException, RecipientRewriteTableException { MailAddress baseAddress = parseMailAddress(request.params(FORWARD_BASE_ADDRESS)); MailAddress destinationAddressToBeRemoved = parseMailAddress(request.params(FORWARD_DESTINATION_ADDRESS)); - recipientRewriteTable.removeForwardMapping( - baseAddress.getLocalPart(), - baseAddress.getDomain(), - destinationAddressToBeRemoved.asString()); + MappingSource source = MappingSource.fromUser(User.fromLocalPartWithDomain(baseAddress.getLocalPart(), baseAddress.getDomain())); + recipientRewriteTable.removeForwardMapping(source, destinationAddressToBeRemoved.asString()); return halt(HttpStatus.OK_200); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/GroupsRoutes.java ---------------------------------------------------------------------- diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/GroupsRoutes.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/GroupsRoutes.java index 1f5cd39..2625a46 100644 --- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/GroupsRoutes.java +++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/GroupsRoutes.java @@ -40,11 +40,13 @@ import javax.ws.rs.Produces; import org.apache.james.core.Domain; import org.apache.james.core.MailAddress; +import org.apache.james.core.User; import org.apache.james.domainlist.api.DomainList; import org.apache.james.domainlist.api.DomainListException; import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTableException; import org.apache.james.rrt.lib.Mapping; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.lib.Mappings; import org.apache.james.user.api.UsersRepository; import org.apache.james.user.api.UsersRepositoryException; @@ -62,7 +64,6 @@ import org.slf4j.LoggerFactory; import com.github.steveash.guavate.Guavate; import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.ImmutableSortedSet; - import io.swagger.annotations.Api; import io.swagger.annotations.ApiImplicitParam; import io.swagger.annotations.ApiImplicitParams; @@ -129,6 +130,8 @@ public class GroupsRoutes implements Routes { mappings.entrySet().stream() .filter(e -> e.getValue().contains(Mapping.Type.Group)) .map(Map.Entry::getKey) + .flatMap(source -> OptionalUtils.toStream(source.asMailAddress())) + .map(MailAddress::asString) .collect(Guavate.toImmutableSortedSet())) .orElse(ImmutableSortedSet.of()); } @@ -159,7 +162,8 @@ public class GroupsRoutes implements Routes { ensureRegisteredDomain(domain); ensureNotShadowingAnotherAddress(groupAddress); MailAddress userAddress = parseMailAddress(request.params(USER_ADDRESS)); - recipientRewriteTable.addGroupMapping(groupAddress.getLocalPart(), domain, userAddress.asString()); + MappingSource source = MappingSource.fromUser(User.fromLocalPartWithDomain(groupAddress.getLocalPart(), domain)); + recipientRewriteTable.addGroupMapping(source, userAddress.asString()); return halt(HttpStatus.CREATED_201); } @@ -201,10 +205,10 @@ public class GroupsRoutes implements Routes { public HaltException removeFromGroup(Request request, Response response) throws JsonExtractException, AddressException, RecipientRewriteTableException { MailAddress groupAddress = parseMailAddress(request.params(GROUP_ADDRESS)); MailAddress userAddress = parseMailAddress(request.params(USER_ADDRESS)); - recipientRewriteTable.removeGroupMapping( - groupAddress.getLocalPart(), - groupAddress.getDomain(), - userAddress.asString()); + MappingSource source = MappingSource + .fromUser( + User.fromLocalPartWithDomain(groupAddress.getLocalPart(), groupAddress.getDomain())); + recipientRewriteTable.removeGroupMapping(source, userAddress.asString()); return halt(HttpStatus.OK_200); } http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java ---------------------------------------------------------------------- diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java index 08306a5..ea00515 100644 --- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java +++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java @@ -44,6 +44,7 @@ import org.apache.james.domainlist.memory.MemoryDomainList; import org.apache.james.metrics.logger.DefaultMetricFactory; import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTableException; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.memory.MemoryRecipientRewriteTable; import org.apache.james.user.api.UsersRepository; import org.apache.james.user.memory.MemoryUsersRepository; @@ -363,9 +364,9 @@ class ForwardRoutesTest { @BeforeEach void setup() throws Exception { super.setUp(); - memoryRecipientRewriteTable.addErrorMapping("error", DOMAIN, "disabled"); - memoryRecipientRewriteTable.addRegexMapping("regex", DOMAIN, ".*@b\\.com"); - memoryRecipientRewriteTable.addAliasDomainMapping(Domain.of("alias"), DOMAIN); + memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser("error", DOMAIN), "disabled"); + memoryRecipientRewriteTable.addRegexMapping(MappingSource.fromUser("regex", DOMAIN), ".*@b\\.com"); + memoryRecipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of("alias")), DOMAIN); } } @@ -524,7 +525,7 @@ class ForwardRoutesTest { void putShouldReturnErrorWhenRecipientRewriteTableExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTableException.class) .when(memoryRecipientRewriteTable) - .addForwardMapping(anyString(), any(), anyString()); + .addForwardMapping(any(), anyString()); when() .put(ALICE + SEPARATOR + "targets" + SEPARATOR + BOB) @@ -537,7 +538,7 @@ class ForwardRoutesTest { void putShouldReturnErrorWhenErrorMappingExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTable.ErrorMappingException.class) .when(memoryRecipientRewriteTable) - .addForwardMapping(anyString(), any(), anyString()); + .addForwardMapping(any(), anyString()); when() .put(ALICE + SEPARATOR + "targets" + SEPARATOR + BOB) @@ -550,7 +551,7 @@ class ForwardRoutesTest { void putShouldReturnErrorWhenRuntimeExceptionIsThrown() throws Exception { doThrow(RuntimeException.class) .when(memoryRecipientRewriteTable) - .addForwardMapping(anyString(), any(), anyString()); + .addForwardMapping(any(), anyString()); when() .put(ALICE + SEPARATOR + "targets" + SEPARATOR + BOB) @@ -602,7 +603,7 @@ class ForwardRoutesTest { void deleteShouldReturnErrorWhenRecipientRewriteTableExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTableException.class) .when(memoryRecipientRewriteTable) - .removeForwardMapping(anyString(), any(), anyString()); + .removeForwardMapping(any(), anyString()); when() .delete(ALICE + SEPARATOR + "targets" + SEPARATOR + BOB) @@ -615,7 +616,7 @@ class ForwardRoutesTest { void deleteShouldReturnErrorWhenErrorMappingExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTable.ErrorMappingException.class) .when(memoryRecipientRewriteTable) - .removeForwardMapping(anyString(), any(), anyString()); + .removeForwardMapping(any(), anyString()); when() .delete(ALICE + SEPARATOR + "targets" + SEPARATOR + BOB) @@ -628,7 +629,7 @@ class ForwardRoutesTest { void deleteShouldReturnErrorWhenRuntimeExceptionIsThrown() throws Exception { doThrow(RuntimeException.class) .when(memoryRecipientRewriteTable) - .removeForwardMapping(anyString(), any(), anyString()); + .removeForwardMapping(any(), anyString()); when() .delete(ALICE + SEPARATOR + "targets" + SEPARATOR + BOB) http://git-wip-us.apache.org/repos/asf/james-project/blob/ff8107ef/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java ---------------------------------------------------------------------- diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java index 1dd9c6c..8011720 100644 --- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java +++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java @@ -41,6 +41,7 @@ import org.apache.james.domainlist.memory.MemoryDomainList; import org.apache.james.metrics.logger.DefaultMetricFactory; import org.apache.james.rrt.api.RecipientRewriteTable; import org.apache.james.rrt.api.RecipientRewriteTableException; +import org.apache.james.rrt.lib.MappingSource; import org.apache.james.rrt.memory.MemoryRecipientRewriteTable; import org.apache.james.user.api.UsersRepository; import org.apache.james.user.api.UsersRepositoryException; @@ -370,9 +371,9 @@ class GroupsRoutesTest { @BeforeEach void setup() throws Exception { super.setUp(); - memoryRecipientRewriteTable.addErrorMapping("error", DOMAIN, "disabled"); - memoryRecipientRewriteTable.addRegexMapping("regex", DOMAIN, ".*@b\\.com"); - memoryRecipientRewriteTable.addAliasDomainMapping(Domain.of("alias"), DOMAIN); + memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser("error", DOMAIN), "disabled"); + memoryRecipientRewriteTable.addRegexMapping(MappingSource.fromUser("regex", DOMAIN), ".*@b\\.com"); + memoryRecipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of("alias")), DOMAIN); } @@ -527,7 +528,7 @@ class GroupsRoutesTest { void putShouldReturnErrorWhenRecipientRewriteTableExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTableException.class) .when(memoryRecipientRewriteTable) - .addGroupMapping(anyString(), any(), anyString()); + .addGroupMapping(any(), anyString()); when() .put(GROUP1 + SEPARATOR + GROUP2) @@ -540,7 +541,7 @@ class GroupsRoutesTest { void putShouldReturnErrorWhenErrorMappingExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTable.ErrorMappingException.class) .when(memoryRecipientRewriteTable) - .addGroupMapping(anyString(), any(), anyString()); + .addGroupMapping(any(), anyString()); when() .put(GROUP1 + SEPARATOR + GROUP2) @@ -553,7 +554,7 @@ class GroupsRoutesTest { void putShouldReturnErrorWhenRuntimeExceptionIsThrown() throws Exception { doThrow(RuntimeException.class) .when(memoryRecipientRewriteTable) - .addGroupMapping(anyString(), any(), anyString()); + .addGroupMapping(any(), anyString()); when() .put(GROUP1 + SEPARATOR + GROUP2) @@ -605,7 +606,7 @@ class GroupsRoutesTest { void deleteShouldReturnErrorWhenRecipientRewriteTableExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTableException.class) .when(memoryRecipientRewriteTable) - .removeGroupMapping(anyString(), any(), anyString()); + .removeGroupMapping(any(), anyString()); when() .delete(GROUP1 + SEPARATOR + GROUP2) @@ -618,7 +619,7 @@ class GroupsRoutesTest { void deleteShouldReturnErrorWhenErrorMappingExceptionIsThrown() throws Exception { doThrow(RecipientRewriteTable.ErrorMappingException.class) .when(memoryRecipientRewriteTable) - .removeGroupMapping(anyString(), any(), anyString()); + .removeGroupMapping(any(), anyString()); when() .delete(GROUP1 + SEPARATOR + GROUP2) @@ -631,7 +632,7 @@ class GroupsRoutesTest { void deleteShouldReturnErrorWhenRuntimeExceptionIsThrown() throws Exception { doThrow(RuntimeException.class) .when(memoryRecipientRewriteTable) - .removeGroupMapping(anyString(), any(), anyString()); + .removeGroupMapping(any(), anyString()); when() .delete(GROUP1 + SEPARATOR + GROUP2) --------------------------------------------------------------------- To unsubscribe, e-mail: server-dev-unsubscr...@james.apache.org For additional commands, e-mail: server-dev-h...@james.apache.org