@JsonIgnore public IpSpaceSpecifier getIpSpaceSpecifier() { checkNotNull(_ipSpaceSpecifierFactory, PROP_IP_SPACE_SPECIFIER_FACTORY + " is null"); return IpSpaceSpecifierFactory.load(_ipSpaceSpecifierFactory) .buildIpSpaceSpecifier(_ipSpaceSpecifierInput); }
@Nonnull private IpSpaceSpecifier getSourceSpecifier() { return IpSpaceSpecifierFactory.load(FlexibleUniverseIpSpaceSpecifierFactory.NAME) .buildIpSpaceSpecifier(_headerConstraints.getSrcIps()); }
@Nonnull private IpSpaceSpecifier getDestinationSpecifier() { return IpSpaceSpecifierFactory.load(FlexibleUniverseIpSpaceSpecifierFactory.NAME) .buildIpSpaceSpecifier(_headerConstraints.getDstIps()); }
private IpSpaceSpecifier getSourceIpSpaceSpecifier() { return IpSpaceSpecifierFactory.load(FlexibleInferFromLocationIpSpaceSpecifierFactory.NAME) .buildIpSpaceSpecifier(_headerConstraints.getSrcIps()); }
private IpSpaceSpecifier getDestinationIpSpaceSpecifier() { return IpSpaceSpecifierFactory.load(FlexibleUniverseIpSpaceSpecifierFactory.NAME) .buildIpSpaceSpecifier(_headerConstraints.getDstIps()); }
private void setDstIp(PacketHeaderConstraints constraints, Flow.Builder builder) { String headerDstIp = constraints.getDstIps(); checkArgument( constraints.getDstIps() != null, "Cannot perform traceroute without a destination"); IpSpaceSpecifier dstIpSpecifier = IpSpaceSpecifierFactory.load(IP_SPECIFIER_FACTORY).buildIpSpaceSpecifier(headerDstIp); IpSpaceAssignment dstIps = dstIpSpecifier.resolve(ImmutableSet.of(), _specifierContext); checkArgument( dstIps.getEntries().size() == 1, "Specified destination: %s, resolves to more than one IP", headerDstIp); IpSpace space = dstIps.getEntries().iterator().next().getIpSpace(); Optional<Ip> dstIp = _ipSpaceRepresentative.getRepresentative(space); checkArgument(dstIp.isPresent(), "At least one destination IP is required"); builder.setDstIp(dstIp.get()); }
@VisibleForTesting static IpSpaceAssignment initSourceIpAssignment( String sourceLocation, String sourceIps, SpecifierContext specifierContext) { /* construct specifiers */ LocationSpecifier sourceLocationSpecifier = LocationSpecifierFactory.load(SRC_LOCATION_SPECIFIER_FACTORY) .buildLocationSpecifier(sourceLocation); IpSpaceSpecifier sourceIpSpaceSpecifier = IpSpaceSpecifierFactory.load(IP_SPECIFIER_FACTORY).buildIpSpaceSpecifier(sourceIps); /* resolve specifiers */ Set<Location> sourceLocations = sourceLocationSpecifier.resolve(specifierContext); return sourceIpSpaceSpecifier.resolve(sourceLocations, specifierContext); }
IpSpaceSpecifierFactory.load(IP_SPECIFIER_FACTORY).buildIpSpaceSpecifier(headerSrcIp);
private void setDstIp(PacketHeaderConstraints constraints, Builder builder) { String headerDstIp = constraints.getDstIps(); if (headerDstIp != null) { IpSpaceSpecifier dstIpSpecifier = IpSpaceSpecifierFactory.load(IP_SPECIFIER_FACTORY).buildIpSpaceSpecifier(headerDstIp); IpSpaceAssignment dstIps = dstIpSpecifier.resolve(ImmutableSet.of(), _batfish.specifierContext()); // Filter out empty IP assignments ImmutableList<Entry> nonEmptyIpSpaces = dstIps.getEntries().stream() .filter(e -> !e.getIpSpace().equals(EmptyIpSpace.INSTANCE)) .collect(ImmutableList.toImmutableList()); checkArgument( nonEmptyIpSpaces.size() > 0, "At least one destination IP is required, could not resolve any"); checkArgument( nonEmptyIpSpaces.size() == 1, "Specified destination: %s, resolves to more than one IP", headerDstIp); IpSpace space = nonEmptyIpSpaces.iterator().next().getIpSpace(); Optional<Ip> dstIp = _ipSpaceRepresentative.getRepresentative(space); checkArgument(dstIp.isPresent(), "Specified destination: %s has no IPs", headerDstIp); builder.setDstIp(dstIp.get()); } else { builder.setDstIp(DEFAULT_IP_ADDRESS); } }
@Test public void testLoad() { assertThat( IpSpaceSpecifierFactory.load(FlexibleInferFromLocationIpSpaceSpecifierFactory.NAME) instanceof FlexibleInferFromLocationIpSpaceSpecifierFactory, is(true)); }
@Test public void testFlexibleInferFromLocationIpSpaceSpecifierFactory() { assertThat( load(FlexibleInferFromLocationIpSpaceSpecifierFactory.NAME), Matchers.instanceOf(FlexibleInferFromLocationIpSpaceSpecifierFactory.class)); assertThat( new FlexibleInferFromLocationIpSpaceSpecifierFactory().buildIpSpaceSpecifier(null), equalTo(InferFromLocationIpSpaceSpecifier.INSTANCE)); }
@VisibleForTesting static IpSpaceAssignment initSourceIpAssignment( TestFiltersQuestion question, SpecifierContext ctxt) { /* construct specifiers */ LocationSpecifier sourceLocationSpecifier = question.getStartLocationSpecifier(); IpSpaceSpecifier sourceIpSpaceSpecifier = IpSpaceSpecifierFactory.load(IP_SPECIFIER_FACTORY) .buildIpSpaceSpecifier(question.getHeaders().getSrcIps()); /* resolve specifiers */ Set<Location> sourceLocations = sourceLocationSpecifier.resolve(ctxt); return sourceIpSpaceSpecifier.resolve(sourceLocations, ctxt); }
IpSpaceSpecifierFactory.load(IP_SPECIFIER_FACTORY).buildIpSpaceSpecifier(headerSrcIp);
@Test public void testFlexibleUniverseIpSpaceSpecifierFactory() { assertThat( load(FlexibleUniverseIpSpaceSpecifierFactory.NAME), instanceOf(FlexibleUniverseIpSpaceSpecifierFactory.class)); assertThat( new FlexibleUniverseIpSpaceSpecifierFactory().buildIpSpaceSpecifier(null), equalTo(new ConstantIpSpaceSpecifier(UniverseIpSpace.INSTANCE))); }
@Test public void testLoad() { IpSpaceSpecifierFactory loaded = load(new InferFromLocationIpSpaceSpecifierFactory().getName()); assertThat(loaded, instanceOf(InferFromLocationIpSpaceSpecifierFactory.class)); }
@Test public void testFlexibleLocationIpSpaceSpecifierFactory() { assertThat( load(FlexibleLocationIpSpaceSpecifierFactory.NAME), instanceOf(FlexibleLocationIpSpaceSpecifierFactory.class)); IpSpaceSpecifier actual = new FlexibleLocationIpSpaceSpecifierFactory().buildIpSpaceSpecifier("[vrf(foo)]"); assertThat( actual, equalTo( new LocationIpSpaceSpecifier( new InterfaceSpecifierInterfaceLocationSpecifier( new VrfNameRegexInterfaceSpecifier(Pattern.compile("foo")))))); }
@Test public void testConstantWildcardSetIpSpaceSpecifierFactory() { assertThat( load(ConstantWildcardSetIpSpaceSpecifierFactory.NAME), Matchers.instanceOf(ConstantWildcardSetIpSpaceSpecifierFactory.class)); assertThat( new ConstantWildcardSetIpSpaceSpecifierFactory() .buildIpSpaceSpecifier("1.2.3.0/24 - 1.2.3.4"), equalTo( new ConstantIpSpaceSpecifier( IpWildcardSetIpSpace.builder() .including(new IpWildcard("1.2.3.0/24")) .excluding(new IpWildcard("1.2.3.4")) .build()))); } }