import static org.junit.Assert.fail;
import static org.opendaylight.lispflowmapping.integrationtest.MappingServiceIntegrationTest.ourAddress;
import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A;
-import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B;
-import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C;
-import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D4;
import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D5;
+import java.nio.ByteBuffer;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
+
+import org.apache.commons.lang3.ArrayUtils;
import org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.Site;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
+import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4Binary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkeyBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.net.InetAddresses;
+/**
+ * Contains methods for:
+ * - checking sites visibility (availability) - simulation of ping command
+ * - for preparing and processing data structures necessary for creating map request, map register LISP messages.
+ *
+ */
class MultiSiteScenario {
private final int DEFAULT_NETWORK_MASK = 24;
private final Integer TTL = 1440;
private final String MAP_RECORD_A = "MAP_RECORD_1";
- private final Short DEFAULT_PRIORITY = 1;
- private final Short DEFAULT_WEIGHT = 1;
private final Short DEFAULT_MULTICAST_PRIORITY = 255;
private final Short DEFAULT_MULTICAST_WEIGHT = 0;
private final Boolean DEFAULT_LOCAL_LOCATOR = true;
private static final Logger LOG = LoggerFactory.getLogger(MultiSiteScenario.class);
+ enum EidType {
+ EID_SRC_DST, EID_WITH_PREFIX
+ }
+
MultiSiteScenario(final IMappingService mapService, final IFlowMapping lms) {
this.mapService = mapService;
this.lms = lms;
}
- private void verifyIpv4Address(final MapReply mapReply, final MappingRecord.Action action) {
- final MappingRecord mappingRecord = verifyMappingRecord(mapReply);
- assertEquals(action, mappingRecord.getAction());
- }
-
- private Ipv4Address verifyIpv4Address(final MappingRecord mappingRecord) {
- final List<LocatorRecord> locatorRecords = mappingRecord.getLocatorRecord();
- assertNotNull(locatorRecords);
- assertEquals(1, locatorRecords.size());
- final LocatorRecord locatorRecord = locatorRecords.get(0);
+ private Ipv4AddressBinary verifyIpv4Address(final LocatorRecord locatorRecord) {
assertNotNull(locatorRecord);
final Rloc rloc = locatorRecord.getRloc();
assertNotNull(rloc);
final Address address = rloc.getAddress();
- assertTrue(address instanceof Ipv4);
- return ((Ipv4) address).getIpv4();
+ assertTrue(address instanceof Ipv4Binary);
+ return ((Ipv4Binary) address).getIpv4Binary();
+ }
+
+ private List<LocatorRecord> verifyLocatorRecordExists(final MappingRecord mappingRecord) {
+ final List<LocatorRecord> locatorRecords = mappingRecord.getLocatorRecord();
+ assertNotNull(locatorRecords);
+ return locatorRecords;
}
private MappingRecord verifyMappingRecord(MapReply mapReply) {
return mappingRecord;
}
- private void emitMapRegisterMessage(final Site dstSite) {
+ private void emitMapRegisterMessage(final Site dstSite, final boolean merge) {
final MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
+ mapRegisterBuilder.setMergeEnabled(merge);
final MappingRecordItemBuilder mappingRecordItemBuilder = new MappingRecordItemBuilder();
mappingRecordItemBuilder.setMappingRecordItemId(MAP_RECORD_A);
- final MappingRecordBuilder mrb = prepareMappingRecord(MappingOrigin.Southbound, null, dstSite);
+ final MappingRecordBuilder mrb = prepareMappingRecord(EidType.EID_WITH_PREFIX, null, dstSite);
mappingRecordItemBuilder.setMappingRecord(mrb.build());
mapRegisterBuilder.setMappingRecordItem(Collections.singletonList(mappingRecordItemBuilder.build()));
}
void setCommonAuthentication() {
- Eid eid = LispAddressUtil.toEid(new Ipv4Prefix("0.0.0.0/0"), SITE_A.getVNI());
+ Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", SITE_A.getVNI());
mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
- eid = LispAddressUtil.toEid(new Ipv4Prefix("0.0.0.0/0"), SITE_D5.getVNI());
+ eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", SITE_D5.getVNI());
mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
sleepForSeconds(1);
}
private Eid toEid(final String destSiteEidPrefix, final InstanceIdType vniValue, final int mask) {
- return LispAddressUtil.toEid(new Ipv4Prefix(destSiteEidPrefix + "/" + mask), vniValue);
+ return LispAddressUtil.asIpv4PrefixBinaryEid(destSiteEidPrefix + "/" + mask, vniValue);
}
}
void storeNorthMappingNegative(final Site dstSite, final MappingRecord.Action action) {
- final Ipv4Prefix ipv4Prefix = new Ipv4Prefix(dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK);
- final Eid eidAsIpv4Prefix = LispAddressUtil.toEid(ipv4Prefix, dstSite.getVNI());
+ final Eid eidAsIpv4Prefix = LispAddressUtil.asIpv4PrefixBinaryEid(
+ dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK, dstSite.getVNI());
- final MappingRecordBuilder mrbNegative = prepareMappingRecord(MappingOrigin.Northbound, null, dstSite);
+ final MappingRecordBuilder mrbNegative = prepareMappingRecord(EidType.EID_WITH_PREFIX, null, dstSite);
mrbNegative.setEid(eidAsIpv4Prefix);
mrbNegative.setAction(action);
- mapService.addMapping(MappingOrigin.Northbound, eidAsIpv4Prefix, dstSite.getSiteId(), mrbNegative.build());
+ mapService.addMapping(MappingOrigin.Northbound, eidAsIpv4Prefix, dstSite.getSiteId(), mrbNegative.build(),
+ false);
}
void deleteNorthMappingNegative(final Site dstSite) {
- final Ipv4Prefix ipv4Prefix = new Ipv4Prefix(dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK);
- final Eid eidAsIpv4Prefix = LispAddressUtil.toEid(ipv4Prefix, dstSite.getVNI());
+ final Eid eidAsIpv4Prefix = LispAddressUtil.asIpv4PrefixBinaryEid(
+ dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK, dstSite.getVNI());
mapService.removeMapping(MappingOrigin.Northbound, eidAsIpv4Prefix);
}
- void storeNorthMappingSrcDst(final Site srcSite, final Site dstSite) {
- final MappingRecordBuilder mrb = prepareMappingRecord(MappingOrigin.Northbound, srcSite, dstSite);
- mapService.addMapping(MappingOrigin.Northbound, mrb.getEid(), srcSite.getSiteId(), mrb.build());
+ void storeNorthMappingSrcDst(final Site srcSite, final Site ... dstSite) {
+ final MappingRecordBuilder mrb = prepareMappingRecord(EidType.EID_SRC_DST, srcSite,
+ dstSite);
+ mapService.addMapping(MappingOrigin.Northbound, mrb.getEid(), dstSite[0].getSiteId(), mrb.build(), false);
}
- private void storeDestinationSiteMappingViaSouthbound(final Site dstSite) {
- emitMapRegisterMessage(dstSite);
+ void storeNorthMappingIpPrefix(final Site... dstSite) {
+ final MappingRecordBuilder mrb = prepareMappingRecord(EidType.EID_WITH_PREFIX, null, dstSite);
+ mapService.addMapping(MappingOrigin.Northbound, mrb.getEid(), dstSite[0].getSiteId(), mrb.build(), false);
}
- private MappingRecordBuilder prepareMappingRecord(final MappingOrigin mappingOrigin, final Site srcSite, final
- Site dstSite) {
+ private void storeDestinationSiteMappingViaSouthbound(final Site dstSite, final boolean merge) {
+ emitMapRegisterMessage(dstSite, merge);
+ }
+
+ private MappingRecordBuilder prepareMappingRecordGeneral(final EidType eidType,
+ final Site srcSite, final Site dstSite) {
final MappingRecordBuilder mrb = provideCommonMapRecordBuilder();
+ mrb.setXtrId(new XtrId(ArrayUtils.addAll(dstSite.getSiteId().getValue(), dstSite.getSiteId().getValue())));
+
Eid eid = null;
- if (MappingOrigin.Northbound.equals(mappingOrigin)) {
+ if (EidType.EID_SRC_DST.equals(eidType)) {
if (srcSite != null && dstSite != null && srcSite.getEidPrefix() != null && dstSite.getEidPrefix() !=
null) {
eid = LispAddressUtil.asSrcDstEid(srcSite.getEidPrefix(), dstSite.getEidPrefix(), DEFAULT_NETWORK_MASK,
DEFAULT_NETWORK_MASK, dstSite.getVNI().getValue().intValue());
}
- } else if (MappingOrigin.Southbound.equals(mappingOrigin)) {
- if (dstSite != null && dstSite.getEidPrefix() != null) {
- eid = toEid(dstSite.getEidPrefix(), dstSite.getVNI(), DEFAULT_NETWORK_MASK);
- }
}
- mrb.setEid(eid);
+ mrb.setEid(eid == null ? toEid(dstSite.getEidPrefix(), dstSite.getVNI(), DEFAULT_NETWORK_MASK) : eid);
+ return mrb;
+ }
- if (dstSite.getRloc() != null) {
- mrb.setLocatorRecord(provideLocatorRecord(LispAddressUtil.toRloc(new Ipv4Address(dstSite.getRloc())),
- dstSite.getRloc()));
+ private MappingRecordBuilder prepareMappingRecord(final EidType eidType, final Site srcSite, final Site...
+ dstSites) {
+ assertTrue(isEidEquals(dstSites));
+ final MappingRecordBuilder mrb = prepareMappingRecordGeneral(eidType, srcSite, dstSites[0]);
+ final List<LocatorRecord> locatorRecords = new ArrayList<>();
+ if (!dstSites[0].isForDeletion) {
+ for (Site dstSite : dstSites) {
+ if (dstSite.getRloc() != null) {
+ locatorRecords.add(provideLocatorRecord(LispAddressUtil.asIpv4Rloc(dstSite.getRloc()),
+ dstSite.getRloc(), dstSite.getWeight(), dstSite.getPriority()));
+ }
+ }
}
+ mrb.setLocatorRecord(locatorRecords);
- mrb.setTimestamp(System.currentTimeMillis());
- mrb.setAction(MappingRecord.Action.NoAction);
- mrb.setRecordTtl(TTL);
return mrb;
}
- private List<LocatorRecord> provideLocatorRecord(final Rloc rloc, final String rlocStr) {
+ private boolean isEidEquals(final Site... sites) {
+ String commonEid = null;
+ for (Site site : sites) {
+ final String concreteEidPrefix = site.getEidPrefix();
+ if (!concreteEidPrefix.equals(commonEid)) {
+ if (commonEid == null) {
+ commonEid = concreteEidPrefix;
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ private LocatorRecord provideLocatorRecord(final Rloc rloc, final String rlocStr, final short weight, final short
+ priority) {
final LocatorRecordBuilder locatorRecordBuilder = new LocatorRecordBuilder();
locatorRecordBuilder.setRloc(rloc);
locatorRecordBuilder.setLocatorId(rlocStr);
- locatorRecordBuilder.setPriority(DEFAULT_PRIORITY);
- locatorRecordBuilder.setWeight(DEFAULT_WEIGHT);
+ locatorRecordBuilder.setPriority(priority);
+ locatorRecordBuilder.setWeight(weight);
locatorRecordBuilder.setMulticastPriority(DEFAULT_MULTICAST_PRIORITY);
locatorRecordBuilder.setMulticastWeight(DEFAULT_MULTICAST_WEIGHT);
locatorRecordBuilder.setLocalLocator(DEFAULT_LOCAL_LOCATOR);
locatorRecordBuilder.setRlocProbed(DEFAULT_RLOC_PROBED);
locatorRecordBuilder.setRouted(DEFAULT_ROUTED);
-
- final List<LocatorRecord> locatorRecords = new ArrayList<>();
- locatorRecords.add(locatorRecordBuilder.build());
- return locatorRecords;
+ return locatorRecordBuilder.build();
}
private MappingRecordBuilder provideCommonMapRecordBuilder() {
mappingRecordBuilder.setRecordTtl(TTL);
mappingRecordBuilder.setAction(MappingRecord.Action.NoAction);
mappingRecordBuilder.setAuthoritative(true);
+ mappingRecordBuilder.setTimestamp(System.currentTimeMillis());
return mappingRecordBuilder;
}
mapService.removeMapping(MappingOrigin.Northbound, eid);
}
-// void storeNorthMappingBidirect(final Site srcSite, final Site dstSite) {
-// storeNorthMappingSrcDst(srcSite, dstSite);
-// storeNorthMappingSrcDst(dstSite, srcSite);
-// }
+ void deleteSouthboundMappings(final Site dstSite) {
+ emitMapRegisterMessage(dstSite, false);
+
+ }
- void storeSouthboundMappings() {
- storeDestinationSiteMappingViaSouthbound(SITE_A);
- storeDestinationSiteMappingViaSouthbound(SITE_B);
- storeDestinationSiteMappingViaSouthbound(SITE_C);
- storeDestinationSiteMappingViaSouthbound(SITE_D4);
- storeDestinationSiteMappingViaSouthbound(SITE_D5);
+ void storeSouthboundMappings(final boolean merge, final Site ... sites) {
+ for (Site site : sites) {
+ storeDestinationSiteMappingViaSouthbound(site, merge);
+ }
}
boolean isPossibleAssertPingResultImmediately(final boolean expectedPingWorks, final boolean isPartialyWorking,
- final
- String msg) {
+ final String msg) {
//ping fail is unwanted. ping definitely failed
if (expectedPingWorks && !isPartialyWorking) {
fail(msg);
return false;
}
- boolean checkActionAndRloc(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex,
- boolean expectedPingWorks, MapReply mapReplyFromSrcToDst) {
+ boolean checkActionAndRloc(final Site dstSite, boolean expectedPingWorks, MapReply mapReplyFromSrcToDst, final
+ Site ... additionalSitesFromMapping) {
final MappingRecord mappingRecord = verifyMappingRecord(mapReplyFromSrcToDst);
final boolean isNotDroppendSrcDst = !MappingRecord.Action.Drop.equals(mappingRecord.getAction());
if (isPossibleAssertPingResultImmediately(expectedPingWorks, isNotDroppendSrcDst, "Drop action has appeared " +
- "during ping" )) {
+ "during ping")) {
return true;
}
+ final List<LocatorRecord> locatorRecords = verifyLocatorRecordExists(mappingRecord);
+ for (Site expectedTargetSite : concatenateSites(dstSite, additionalSitesFromMapping)) {
+ boolean expectedTargetFound = false;
+ for (LocatorRecord locatorRecord : locatorRecords) {
+ if (expectedTargetSite.getRloc().equals(rlocToString(locatorRecord))) {
+ final byte[] ipv4AddressSrcDst = verifyIpv4Address(locatorRecord).getValue();
+ final byte[] rloc = InetAddresses.forString((expectedTargetSite.getRloc())).getAddress();
+ final boolean isRlocSrcDstEqual = Arrays.equals(ipv4AddressSrcDst, rloc);
+ if (isPossibleAssertPingResultImmediately(expectedPingWorks, isRlocSrcDstEqual, "Unexpected RLOC." +
+ "Expected value " + rloc + ". Real value " + ipv4AddressSrcDst +
+ ".")) {
+ return true;
+ }
+
+ final boolean isWeightEquals = expectedTargetSite.getWeight() == locatorRecord.getWeight();
+ if (isPossibleAssertPingResultImmediately(expectedPingWorks, isWeightEquals, "Weight isn't equal." +
+ "Expected value " + expectedTargetSite.getWeight() + ". Value from mapping" +
+ locatorRecord.getWeight() + ".")) {
+ return true;
+ }
+
+ final boolean isPriorityEquals = expectedTargetSite.getPriority() == locatorRecord.getPriority();
+ if (isPossibleAssertPingResultImmediately(expectedPingWorks, isPriorityEquals, "Priority isn't " +
+ "equal. Expected value " + expectedTargetSite.getPriority() + ". Value from mapping" +
+ locatorRecord.getPriority() + ".")) {
+ return true;
+ }
+
+ expectedTargetFound = true;
+ break;
+ }
+ }
+ if (isPossibleAssertPingResultImmediately(expectedPingWorks, expectedTargetFound, "Mapping for " +
+ expectedTargetSite.getRloc() + " was expected but wasn't returned from mapping service." +
+ expectedTargetFound)) {
+ return true;
+ }
- final Ipv4Address ipv4AddressSrcDst = verifyIpv4Address(mappingRecord);
- final boolean isRlocSrcDstEqual = ipv4AddressSrcDst.getValue().equals(dstSite.getRloc());
-
- if (isPossibleAssertPingResultImmediately(expectedPingWorks, isRlocSrcDstEqual, "Unexpected RLOC. Expected " +
- "value " + dstSite.getRloc() + ". Real value " + ipv4AddressSrcDst.getValue() + ".")) {
- return true;
}
+
return false;
+ }
+ private String rlocToString(final LocatorRecord locatorRecord) {
+ return LispAddressStringifier.getString(locatorRecord.getRloc());
+ }
+
+ private Iterable<Site> concatenateSites(final Site dstSite, final Site... additionalSitesFromMapping) {
+ final List<Site> sites = new ArrayList<>();
+ sites.add(dstSite);
+ for (Site additionalSite : additionalSitesFromMapping) {
+ sites.add(additionalSite);
+ }
+ return sites;
}
private void assertPing(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex,
- boolean expectedPingWorks) {
+ boolean expectedPingWorks, final Site ... additionalSitesFromMapping) {
final MapReply mapReplyFromSrcToDst = emitMapRequestMessage(srcSite.getHost(srcHostIndex), dstSite.getHost
(dstHostIndex), dstSite.getVNI());
- if (checkActionAndRloc(srcSite, srcHostIndex, dstSite, dstHostIndex, expectedPingWorks, mapReplyFromSrcToDst)) {
+ if (checkActionAndRloc(dstSite, expectedPingWorks, mapReplyFromSrcToDst, additionalSitesFromMapping)) {
return;
}
final MapReply mapReplyFromDstToSrc = emitMapRequestMessage(dstSite.getHost(dstHostIndex), srcSite.getHost
(srcHostIndex), srcSite.getVNI());
- if (checkActionAndRloc(dstSite, dstHostIndex, srcSite, srcHostIndex, expectedPingWorks, mapReplyFromDstToSrc)) {
+ if (checkActionAndRloc(srcSite, expectedPingWorks, mapReplyFromDstToSrc)) {
return;
}
}
}
- void assertPingWorks(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex) {
- assertPing(srcSite, srcHostIndex, dstSite, dstHostIndex, true);
+ void assertPingWorks(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex,
+ final Site ... additionalSitesFromMapping) {
+ assertPing(srcSite, srcHostIndex, dstSite, dstHostIndex, true, additionalSitesFromMapping);
}
void assertPingFails(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex) {
assertPing(srcSite, srcHostIndex, dstSite, dstHostIndex, false);
}
- void assertPingFailsBecauseActionDrop(final Site srcSite, final int srcHostIndex, final Site dstSite, final int
- dstHostIndex) {
- final MapReply mapReplyFromSrcToDst = emitMapRequestMessage(srcSite.getHost(srcHostIndex), dstSite.getHost
- (dstHostIndex), dstSite.getVNI());
- verifyIpv4Address(mapReplyFromSrcToDst, MappingRecord.Action.Drop);
- }
-
private void sleepForSeconds(int seconds) {
try {
Thread.sleep(seconds * 1000);
}
}
+
+ private List<MapRequest> translateBuffersToMapRequest(byte[][] buffers) {
+ final List<MapRequest> mapRequests = new ArrayList<>();
+ for (byte[] buffer : buffers) {
+ final MapRequest mapRequest = MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(buffer));
+ assertNotNull(mapRequest);
+ mapRequests.add(mapRequest);
+ }
+ return mapRequests;
+ }
+
+ private Set<Eid> prepareExpectedEid(final String ... hosts) {
+ final Set<Eid> eids = new HashSet<>();
+ for (String host : hosts) {
+ eids.add(LispAddressUtil.asIpv4PrefixBinaryEid(host + "/" + IP_MASK,
+ new InstanceIdType(MultiSiteScenarioUtil.VNI2)));
+ }
+ return eids;
+ }
+
+ private SourceEid prepareSourceEid(final String eidPrefix) {
+ final SourceEidBuilder sourceEidBuilder = new SourceEidBuilder();
+ final Eid eid = LispAddressUtil.asIpv4Eid(eidPrefix, MultiSiteScenarioUtil.VNI2);
+ return sourceEidBuilder.setEid(eid).build();
+ }
+
+ void checkSMR(final SocketReader socketReader, final String site, final String ... hosts) {
+ List<MapRequest> mapRequests = translateBuffersToMapRequest(socketReader.getBuffers(hosts.length));
+ final Set<Eid> eids = prepareExpectedEid(hosts);
+ final SourceEid expectedSourceEid = prepareSourceEid(site);
+ for(MapRequest mapRequest : mapRequests) {
+ assertTrue(mapRequest.isSmr());
+ final SourceEid receivedSourceEid = mapRequest.getSourceEid();
+ assertEquals(expectedSourceEid, receivedSourceEid);
+ final List<EidItem> currentEidItems = mapRequest.getEidItem();
+ assertNotNull(currentEidItems);
+ assertTrue(SMRContainsExpectedEid(eids, currentEidItems));
+ }
+ //all expected eids should be after looping via mapRequests matched.
+ assertTrue("Expected eids wasn't/weren't found " + eids, eids.isEmpty());
+ }
+
+ private boolean SMRContainsExpectedEid(Set<Eid> eids, List<EidItem> currentEidItems) {
+ for (EidItem eidItem : currentEidItems) {
+ //if eid from map request is matched then it is removed from set of expected eids
+ if (!eids.remove(eidItem.getEid())) {
+ fail("SMR contained " + eidItem.getEid() + " which wasn't expected.");
+ }
+ }
+ return true;
+ }
+
}
Code Review / lispflowmapping.git / blobdiff