@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)); }
@Override public void removeGroupMapping(MappingSource source, String address) throws RecipientRewriteTableException { Mapping mapping = Mapping.group(address) .appendDomainFromThrowingSupplierIfNone(this::defaultDomain); LOGGER.info("Remove group mapping => {} for source: {}", mapping, source.asString()); removeMapping(source, mapping); }
@Override public void removeForwardMapping(MappingSource source, String address) throws RecipientRewriteTableException { Mapping mapping = Mapping.forward(address) .appendDomainFromThrowingSupplierIfNone(this::defaultDomain); LOGGER.info("Remove forward mapping => {} for source: {}", mapping, source.asString()); removeMapping(source, mapping); }
@Override public void removeAddressMapping(MappingSource source, String address) throws RecipientRewriteTableException { Mapping mapping = Mapping.address(address) .appendDomainFromThrowingSupplierIfNone(this::defaultDomain); LOGGER.info("Remove address mapping => {} for source: {}", mapping, source.asString()); removeMapping(source, mapping); }
@Test public void selectShouldReturnMatchingElementsInOrderWhenMatchingMapping() { MappingsImpl mappings = MappingsImpl.builder() .add(Mapping.regex("toto")) .add(Mapping.address("toto")) .add(Mapping.domain(Domain.of("domain"))) .add(Mapping.regex("tata")) .build(); MappingsImpl expected = MappingsImpl.builder() .add(Mapping.regex("toto")) .add(Mapping.regex("tata")) .build(); assertThat(mappings.select(Mapping.Type.Regex)).isEqualTo(expected); }
@Test public void builderShouldPutGroupsBetweenDomainAndForward() { Mapping regexMapping = Mapping.regex("regex"); Mapping forwardMapping = Mapping.forward("forward"); Mapping domainMapping = Mapping.domain(Domain.of("domain")); Mapping groupMapping = Mapping.group("group"); MappingsImpl mappingsImpl = MappingsImpl.builder() .add(regexMapping) .add(forwardMapping) .add(domainMapping) .add(groupMapping) .build(); assertThat(mappingsImpl).containsExactly(domainMapping, groupMapping, forwardMapping, regexMapping); } }
@Test public void builderShouldPutDomainAliasFirstWhenVariousMappings() { Mapping addressMapping = Mapping.address("aaa"); Mapping errorMapping = Mapping.error("error"); Mapping domainMapping = Mapping.domain(Domain.of("domain")); Mapping domain2Mapping = Mapping.domain(Domain.of("domain2")); MappingsImpl mappingsImpl = MappingsImpl.builder() .add(domainMapping) .add(addressMapping) .add(errorMapping) .add(domain2Mapping) .build(); assertThat(mappingsImpl).containsExactly(domainMapping, domain2Mapping, addressMapping, errorMapping); }
@Test public void addMappingShouldNotThrowWhenMappingAlreadyExistsWithAnOtherType() throws Exception { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.address(address)); virtualUserTable.addMapping(source, Mapping.regex(address)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); }
@Override public void addMapping(MappingSource source, Mapping mapping) { executor.executeVoid(insertStatement.bind() .setString(USER, source.getFixedUser()) .setString(DOMAIN, source.getFixedDomain()) .setString(MAPPING, mapping.asString())) .join(); }
@Test public void builderShouldPutDomainAliasFirstThenForwardWhenVariousMappings() { Mapping regexMapping = Mapping.regex("regex"); Mapping forwardMapping = Mapping.forward("forward"); Mapping domainMapping = Mapping.domain(Domain.of("domain")); MappingsImpl mappingsImpl = MappingsImpl.builder() .add(regexMapping) .add(forwardMapping) .add(domainMapping) .build(); assertThat(mappingsImpl).containsExactly(domainMapping, forwardMapping, regexMapping); }
@GET @Path(ROOT_PATH + "/{" + FORWARD_BASE_ADDRESS + "}") @ApiOperation(value = "listing forward destinations") @ApiImplicitParams({ @ApiImplicitParam(required = true, dataType = "string", name = FORWARD_BASE_ADDRESS, paramType = "path") }) @ApiResponses(value = { @ApiResponse(code = HttpStatus.OK_200, message = "OK", response = List.class), @ApiResponse(code = HttpStatus.BAD_REQUEST_400, message = "The forward is not an address"), @ApiResponse(code = HttpStatus.NOT_FOUND_404, message = "The forward does not exist"), @ApiResponse(code = HttpStatus.INTERNAL_SERVER_ERROR_500, message = "Internal server error - Something went bad on the server side.") }) public ImmutableSet<ForwardDestinationResponse> listForwardDestinations(Request request, Response response) throws RecipientRewriteTableException { MailAddress baseAddress = parseMailAddress(request.params(FORWARD_BASE_ADDRESS)); Mappings mappings = Optional.ofNullable(recipientRewriteTable.getUserDomainMappings(MappingSource.fromMailAddress(baseAddress))) .orElse(MappingsImpl.empty()) .select(Mapping.Type.Forward); ensureNonEmptyMappings(mappings); return mappings.asStream() .map(mapping -> mapping.asMailAddress() .orElseThrow(() -> new IllegalStateException(String.format("Can not compute address for mapping %s", mapping.asString())))) .map(MailAddress::asString) .sorted() .map(ForwardDestinationResponse::new) .collect(Guavate.toImmutableSet()); }
private Mapping toMapping(User rewrittenUser, Type type) { switch (type) { case Forward: case Group: return Mapping.of(type, rewrittenUser.asString()); case Regex: case Domain: case Error: case Address: return Mapping.address(rewrittenUser.asString()); } throw new IllegalArgumentException("unhandled enum type"); }
@Test public void testAliasDomainMapping() throws ErrorMappingException, RecipientRewriteTableException { String domain = "realdomain"; Domain aliasDomain = Domain.of("aliasdomain"); String user = "user"; String user2 = "user2"; assertThat(virtualUserTable.getAllMappings()).describedAs("No mappings").isEmpty(); 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") .isEqualTo(MappingsImpl.builder() .add(Mapping.address(user + "@" + domain)) .add(Mapping.address(user2 + "@" + domain)) .build()); virtualUserTable.removeMapping(MappingSource.fromDomain(aliasDomain), Mapping.address(user2 + "@" + domain)); virtualUserTable.removeMapping(MappingSource.fromDomain(aliasDomain), Mapping.domain(Domain.of(domain))); }
@Override public void removeRegexMapping(MappingSource source, String regex) throws RecipientRewriteTableException { LOGGER.info("Remove regex mapping => {} for source: {}", regex, source.asString()); removeMapping(source, Mapping.regex(regex)); }
private Stream<Mapping> convertAndRecurseMapping(Mapping mapping, User originalUser, User rewrittenUser, int remainingLoops) throws ErrorMappingException, RecipientRewriteTableException { LOGGER.debug("Valid virtual user mapping {} to {}", originalUser, rewrittenUser); Stream<Mapping> nonRecursiveResult = Stream.of(toMapping(rewrittenUser, mapping.getType())); if (!recursive) { return nonRecursiveResult; } // Check if the returned mapping is the same as the input. If so we need to handle identity to avoid loops. if (originalUser.equals(rewrittenUser)) { return mapping.handleIdentity(nonRecursiveResult); } else { return recurseMapping(nonRecursiveResult, rewrittenUser, remainingLoops); } }
@Override public void addMapping(String user, String domain, String mapping) throws RecipientRewriteTableException { MappingSource source = MappingSource.fromUser(user, domain); rrt.addMapping(source, Mapping.of(mapping)); }
@Override public void removeErrorMapping(MappingSource source, String error) throws RecipientRewriteTableException { LOGGER.info("Remove error mapping => {} for source: {}", error, source.asString()); removeMapping(source, Mapping.error(error)); }
@Test public void removeGroupMappingShouldDelete() 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.group(address)); virtualUserTable.addMapping(source, Mapping.group(address2)); virtualUserTable.removeMapping(source, Mapping.group(address)); virtualUserTable.removeMapping(source, Mapping.group(address2)); assertThat(virtualUserTable.getMappings(user, domain)) .isEqualTo(MappingsImpl.empty()); } }