@Override public void addGroupMapping(MappingSource source, String address) throws RecipientRewriteTableException { Mapping mapping = Mapping.group(address) .appendDomainFromThrowingSupplierIfNone(this::defaultDomain); checkHasValidAddress(mapping); checkDuplicateMapping(source, mapping); LOGGER.info("Add group mapping => {} for source: {}", mapping, source.asString()); addMapping(source, mapping); }
private Mappings getMappings(User user, int mappingLimit) throws ErrorMappingException, RecipientRewriteTableException { // We have to much mappings throw ErrorMappingException to avoid // infinity loop if (mappingLimit == 0) { throw new TooManyMappingException("554 Too many mappings to process"); } Mappings targetMappings = mapAddress(user.getLocalPart(), user.getDomainPart().get()); try { return MappingsImpl.fromMappings( targetMappings.asStream() .flatMap(Throwing.function((Mapping target) -> convertAndRecurseMapping(user, target, mappingLimit)).sneakyThrow())); } catch (SkipMappingProcessingException e) { return MappingsImpl.empty(); } }
private void checkDuplicateMapping(MappingSource source, Mapping mapping) throws RecipientRewriteTableException { Mappings mappings = getUserDomainMappings(source); if (mappings != null && mappings.contains(mapping)) { throw new MappingAlreadyExistsException("Mapping " + mapping + " for " + source.asString() + " already exist!"); } }
@Override public void addErrorMapping(MappingSource source, String error) throws RecipientRewriteTableException { Mapping mapping = Mapping.error(error); checkDuplicateMapping(source, mapping); LOGGER.info("Add error mapping => {} for source: {}", error, source.asString()); addMapping(source, mapping); }
@Override public void configure(HierarchicalConfiguration config) throws ConfigurationException { setRecursiveMapping(config.getBoolean("recursiveMapping", true)); try { setMappingLimit(config.getInt("mappingLimit", 10)); } catch (IllegalArgumentException e) { throw new ConfigurationException(e.getMessage()); } doConfigure(config); }
@Test public void testStoreAndRetrieveAddressMapping() throws ErrorMappingException, RecipientRewriteTableException { 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(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(source, Mapping.address(address)); virtualUserTable.removeMapping(source, Mapping.address(address2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); assertThat(virtualUserTable.getAllMappings()).describedAs("No mapping").isEmpty(); }
@Test public void removeForwardMappingShouldDelete() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.forward(address)); virtualUserTable.addMapping(source, Mapping.forward(address2)); virtualUserTable.removeMapping(source, Mapping.forward(address)); virtualUserTable.removeMapping(source, Mapping.forward(address2)); assertThat(virtualUserTable.getMappings(user, domain)) .isEqualTo(MappingsImpl.empty()); }
@Test public void addForwardMappingShouldStore() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.forward(address)); virtualUserTable.addMapping(source, Mapping.forward(address2)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); }
@Test public void testRecursiveMapping() throws ErrorMappingException, RecipientRewriteTableException { String user1 = "user1"; String user2 = "user2"; String user3 = "user3"; 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(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(source3, Mapping.address(user1 + "@" + domain1.asString())); assertThatThrownBy(() -> virtualUserTable.getMappings(user1, domain1)) .describedAs("Exception thrown on to many mappings") .isInstanceOf(ErrorMappingException.class); // disable recursive mapping virtualUserTable.setRecursiveMapping(false); assertThat(virtualUserTable.getMappings(user1, domain1)).describedAs("Not recursive mapped").containsExactly(Mapping.address(user2 + "@" + domain2.asString())); }
@Override public void removeAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException { LOGGER.info("Remove domain mapping: {} => {}", source.asDomain().map(Domain::asString).orElse("null"), realDomain); removeMapping(source, Mapping.domain(realDomain)); }
private Stream<Mapping> recurseMapping(Stream<Mapping> nonRecursiveResult, User targetUser, int remainingLoops) throws ErrorMappingException, RecipientRewriteTableException { Mappings childMappings = getMappings(targetUser, remainingLoops - 1); if (childMappings.isEmpty()) { return nonRecursiveResult; } else { return childMappings.asStream(); } }
public void tearDown() throws Exception { Map<MappingSource, Mappings> mappings = virtualUserTable.getAllMappings(); if (mappings != null) { for (MappingSource key : virtualUserTable.getAllMappings().keySet()) { Mappings map = mappings.get(key); map.asStream() .forEach(Throwing.consumer(mapping -> virtualUserTable.removeMapping(key, mapping))); } } LifecycleUtil.dispose(virtualUserTable); }
@Test public void getAllMappingsShouldListAllEntries() throws Exception { String user = "test"; String user2 = "test2"; String regex = "(.*)@localhost"; String regex2 = "(.+)@test"; 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(source1, MappingsImpl.builder() .add(Mapping.regex(regex)) .add(Mapping.regex(regex2)) .build()), Pair.of(source2, MappingsImpl.builder() .add(Mapping.address(user + "@" + Domain.LOCALHOST.asString())) .build())); }
@Override protected AbstractRecipientRewriteTable getRecipientRewriteTable() throws Exception { AbstractRecipientRewriteTable rrt = new MemoryRecipientRewriteTable(); rrt.configure(new DefaultConfigurationBuilder()); return rrt; } }
@Given("recursive mapping is disable") public void disableRecursiveMapping() { rewriteTable.setRecursiveMapping(false); }
@Override public void addAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException { LOGGER.info("Add domain mapping: {} => {}", source.asDomain().map(Domain::asString).orElse("null"), realDomain); addMapping(source, Mapping.domain(realDomain)); }
@Test public void addMappingShouldThrowWhenMappingAlreadyExists() throws Exception { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; MappingSource source = MappingSource.fromUser(user, domain); expectedException.expect(RecipientRewriteTableException.class); virtualUserTable.addAddressMapping(source, address); virtualUserTable.addAddressMapping(source, address); }
@Given("store \"([^\"]*)\" error mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeErrorMappingForUserAtDomain(String error, String user, String domain) throws Throwable { MappingSource source = MappingSource.fromUser(user, domain); rewriteTable.addErrorMapping(source, error); }
@Given("store \"([^\"]*)\" forward mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"") public void storeForwardMappingForUserAtDomain(String address, String user, String domain) throws Throwable { MappingSource source = MappingSource.fromUser(user, domain); rewriteTable.addForwardMapping(source, address); }
@Given("store \"([^\"]*)\" alias domain mapping for domain \"([^\"]*)\"") public void storeAliasDomainMappingForDomain(String aliasDomain, String domain) throws Throwable { rewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(domain)); }