X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=integrationtest%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Flispflowmapping%2Fintegrationtest%2FMultiSiteScenario.java;h=c30478fb20d2a082bd617aaa1db5b95d402a6d14;hb=e66a5c03e00a32846968163ef92d19556435b463;hp=1568d6b4ca9d00acd7f81b260625abb74fe81351;hpb=83cb5177845fc85584bb0f05cad6d8fe272e44e9;p=lispflowmapping.git diff --git a/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java b/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java index 1568d6b4c..c30478fb2 100644 --- a/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java +++ b/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java @@ -13,29 +13,37 @@ import static org.junit.Assert.assertTrue; 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; @@ -43,16 +51,22 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.ma 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; @@ -61,8 +75,6 @@ class MultiSiteScenario { 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; @@ -75,27 +87,28 @@ class MultiSiteScenario { 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 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 verifyLocatorRecordExists(final MappingRecord mappingRecord) { + final List locatorRecords = mappingRecord.getLocatorRecord(); + assertNotNull(locatorRecords); + return locatorRecords; } private MappingRecord verifyMappingRecord(MapReply mapReply) { @@ -110,12 +123,13 @@ class MultiSiteScenario { 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())); @@ -123,16 +137,16 @@ class MultiSiteScenario { } 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); } @@ -162,76 +176,103 @@ class MultiSiteScenario { } 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 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 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 locatorRecords = new ArrayList<>(); - locatorRecords.add(locatorRecordBuilder.build()); - return locatorRecords; + return locatorRecordBuilder.build(); } private MappingRecordBuilder provideCommonMapRecordBuilder() { @@ -239,6 +280,7 @@ class MultiSiteScenario { mappingRecordBuilder.setRecordTtl(TTL); mappingRecordBuilder.setAction(MappingRecord.Action.NoAction); mappingRecordBuilder.setAuthoritative(true); + mappingRecordBuilder.setTimestamp(System.currentTimeMillis()); return mappingRecordBuilder; } @@ -248,22 +290,19 @@ class MultiSiteScenario { 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); @@ -286,39 +325,83 @@ class MultiSiteScenario { 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 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 concatenateSites(final Site dstSite, final Site... additionalSitesFromMapping) { + final List 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; } @@ -334,21 +417,15 @@ class MultiSiteScenario { } } - 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); @@ -357,4 +434,56 @@ class MultiSiteScenario { } } + + private List translateBuffersToMapRequest(byte[][] buffers) { + final List 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 prepareExpectedEid(final String ... hosts) { + final Set 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 mapRequests = translateBuffersToMapRequest(socketReader.getBuffers(hosts.length)); + final Set 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 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 eids, List 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; + } + }