@Test public void constructorIpv4() { FiltersSpecifier specifier = new FiltersSpecifier("ipv4:secret.*"); assertThat(specifier.getType(), equalTo(Type.IPV4)); assertThat(specifier.getRegex().pattern(), equalTo(Pattern.compile("secret.*").pattern())); }
@Override public Set<IpAccessList> resolve(String node, SpecifierContext ctxt) { checkArgument( ctxt.getConfigs().containsKey(node), "SpecifierContext does not have configs for node: " + node); Configuration config = ctxt.getConfigs().get(node); return config.getIpAccessLists().values().stream() .filter(filter -> _shorthandSpecifier.matches(filter, config)) .collect(Collectors.toSet()); } }
/** * Evaluates if the given IPv4 filter matches this specifier * * @param filter The filter to evaluate * @param c The configuration providing context in which to evaluate * @return Results of the match */ public boolean matches(IpAccessList filter, Configuration c) { switch (_type) { case INPUTFILTERON: return isFilterOnInterface(c, Interface::getIncomingFilter, filter); case IPV4: return _regex.matcher(filter.getName()).matches(); case IPV6: return false; case NAME: return _regex.matcher(filter.getName()).matches(); case OUTPUTFILTERON: return isFilterOnInterface(c, Interface::getOutgoingFilter, filter); default: throw new BatfishException("Unhandled FiltersSpecifier type: " + _type); } }
@Override public FilterSpecifier buildFilterSpecifier(@Nullable Object input) { if (input == null) { return new ShorthandFilterSpecifier(FiltersSpecifier.ALL); } checkArgument(input instanceof String, "String input required for " + getName()); FiltersSpecifier specifier = new FiltersSpecifier(input.toString().trim()); checkArgument(specifier.getType() != Type.IPV6, "IPv6 is not currently supported"); return new ShorthandFilterSpecifier(specifier); } }
@Test public void matchesIpv4() { FiltersSpecifier specifier = new FiltersSpecifier("ipv4:acl.*"); IpAccessList matchingList = new IpAccessList("acl-99"); Ip6AccessList nonMatchingList = new Ip6AccessList("acl-99"); assertThat(specifier.matches(matchingList, null), equalTo(true)); assertThat(specifier.matches(nonMatchingList), equalTo(false)); }
@Test public void conversionToAndFrom() { FilterGroup group = new FilterGroup( ImmutableList.of(new FiltersSpecifier("abc"), new FiltersSpecifier("ipv4:def")), "fg1"); FilterGroupBean bean = new FilterGroupBean(group); assertThat(new FilterGroupBean(bean.toFilterGroup()), equalTo(bean)); } }
@Test public void matchesName() { FiltersSpecifier specifier = new FiltersSpecifier("name:acl.*"); IpAccessList matchingList = new IpAccessList("acl-99"); IpAccessList nonMatchingList = new IpAccessList("nana"); assertThat(specifier.matches(matchingList, null), equalTo(true)); assertThat(specifier.matches(nonMatchingList, null), equalTo(false)); }
@Test public void resolve() { assertThat( new ShorthandFilterSpecifier(new FiltersSpecifier(_filter1.getName())) .resolve(_nodeName, _ctxt), equalTo(ImmutableSet.of(_filter1))); }
@Test public void nameWithColons() { String expression = "foo::bar::baz"; FiltersSpecifier specifier = new FiltersSpecifier("name:" + expression); assertThat(specifier.getType(), is(Type.NAME)); assertThat(specifier.getRegex().pattern(), equalTo(expression)); } }
@Test public void matchesFilterOn() { String inAclName = "inAcl"; String outAclName = "outAcl"; NetworkFactory nf = new NetworkFactory(); Configuration c = nf.configurationBuilder().setConfigurationFormat(ConfigurationFormat.CISCO_IOS).build(); Vrf v = nf.vrfBuilder().setOwner(c).build(); IpAccessList inAcl = IpAccessList.builder().setName(inAclName).setOwner(c).build(); IpAccessList outAcl = IpAccessList.builder().setName(outAclName).setOwner(c).build(); Interface i = nf.interfaceBuilder() .setIncomingFilter(inAcl) .setOutgoingFilter(outAcl) .setOwner(c) .setVrf(v) .build(); String iName = i.getName(); FiltersSpecifier inputFilterSpecifier = new FiltersSpecifier(String.format("%s:%s", Type.INPUTFILTERON.name(), iName)); FiltersSpecifier outputFilterSpecifier = new FiltersSpecifier(String.format("%s:%s", Type.OUTPUTFILTERON.name(), iName)); assertThat(inputFilterSpecifier.matches(inAcl, c), equalTo(true)); assertThat(inputFilterSpecifier.matches(outAcl, c), equalTo(false)); assertThat(outputFilterSpecifier.matches(outAcl, c), equalTo(true)); assertThat(outputFilterSpecifier.matches(inAcl, c), equalTo(false)); }
/** * Check that if a simple string is the specifier input, that maps to the expected * FilterSpecifier. (That this happens is being assumed by SearchFiltersAnswerer, which it ideally * shouldn't but in the meanwhile this test helps.) */ @Test public void testDefaultSpecifierInput() { TestFiltersQuestion question = new TestFiltersQuestion(null, "acl", null, null); assertThat( question.getFilterSpecifier(), equalTo(new ShorthandFilterSpecifier(new FiltersSpecifier("acl")))); }
@Override public Set<IpAccessList> resolve(String node, SpecifierContext ctxt) { checkArgument( ctxt.getConfigs().containsKey(node), "SpecifierContext does not have configs for node " + node); Configuration config = ctxt.getConfigs().get(node); FilterGroup filterGroup = ctxt.getReferenceBook(_bookName) .orElseThrow( () -> new NoSuchElementException("ReferenceBook '" + _bookName + "' not found")) .getFilterGroup(_filterGroupName) .orElseThrow( () -> new NoSuchElementException( "FilterGroup '" + _filterGroupName + "' not found in ReferenceBook '" + _bookName + "'")); return config.getIpAccessLists().values().stream() .filter( filter -> filterGroup.getFilters().stream() .anyMatch(specifier -> specifier.matches(filter, config))) .collect(Collectors.toSet()); } }
@Test public void constructorExplicitName() { FiltersSpecifier specifier = new FiltersSpecifier("name:acl.*"); assertThat(specifier.getType(), equalTo(Type.NAME)); assertThat(specifier.getRegex().pattern(), equalTo(Pattern.compile("acl.*").pattern())); }
@Test public void testNonNullInput() { assertThat( new ShorthandFilterSpecifierFactory().buildFilterSpecifier("filter1"), equalTo(new ShorthandFilterSpecifier(new FiltersSpecifier("filter1")))); }
@Test public void defaultWithColons() { String expression = "foo::bar::baz"; FiltersSpecifier specifier = new FiltersSpecifier(expression); assertThat(specifier.getType(), is(Type.NAME)); assertThat(specifier.getRegex().pattern(), equalTo(expression)); }
@Test public void testShorthandFilterSpecifier() { assertThat( new FlexibleFilterSpecifierFactory().buildFilterSpecifier("ipv4:.*"), equalTo(new ShorthandFilterSpecifier(new FiltersSpecifier("ipv4:.*")))); }
@Test public void constructorImplicitName() { FiltersSpecifier specifier = new FiltersSpecifier("acl.*"); assertThat(specifier.getType(), equalTo(Type.NAME)); assertThat(specifier.getRegex().pattern(), equalTo(Pattern.compile("acl.*").pattern())); }