integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MultiSiteScenario.java

   1 /**
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.lispflowmapping.integrationtest;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14 import static org.opendaylight.lispflowmapping.integrationtest.MappingServiceIntegrationTest.ourAddress;
  15 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A;
  16 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D5;
  17
  18 import com.google.common.net.InetAddresses;
  19 import java.nio.ByteBuffer;
  20 import java.util.ArrayList;
  21 import java.util.Arrays;
  22 import java.util.Collections;
  23 import java.util.HashSet;
  24 import java.util.List;
  25 import java.util.Set;
  26 import org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.Site;
  27 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
  28 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
  29 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
  30 import org.opendaylight.lispflowmapping.lisp.type.MappingData;
  31 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
  32 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4Binary;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItem;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEid;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 /**
  63  * Contains methods for:
  64  * - checking sites visibility (availability) - simulation of ping command
  65  * - for preparing and processing data structures necessary for creating map request, map register LISP messages.
  66  *
  67  */
  68 class MultiSiteScenario {
  69
  70     private final int DEFAULT_NETWORK_MASK = 24;
  71     private final int IP_MASK = 32;
  72
  73     private final Integer TTL = 1440;
  74     private final String MAP_RECORD_A = "MAP_RECORD_1";
  75
  76     private final Short DEFAULT_MULTICAST_PRIORITY = 255;
  77     private final Short DEFAULT_MULTICAST_WEIGHT = 0;
  78     private final Boolean DEFAULT_LOCAL_LOCATOR = true;
  79     private final Boolean DEFAULT_RLOC_PROBED = false;
  80     private final Boolean DEFAULT_ROUTED = true;
  81     private final byte[] DEFAULT_SITE_ID = new byte[]{0, 0, 0, 0, 0, 0, 0, 0};
  82
  83     private final MappingAuthkey NULL_AUTH_KEY = new MappingAuthkeyBuilder().setKeyType(0).build();
  84     private final IMappingService mapService;
  85     private final IFlowMapping lms;
  86
  87     private static final Logger LOG = LoggerFactory.getLogger(MultiSiteScenario.class);
  88
  89     enum EidType {
  90         EID_SRC_DST, EID_WITH_PREFIX
  91     }
  92
  93     MultiSiteScenario(final IMappingService mapService, final IFlowMapping lms) {
  94         this.mapService = mapService;
  95         this.lms = lms;
  96     }
  97
  98     private Ipv4AddressBinary verifyIpv4Address(final LocatorRecord locatorRecord) {
  99         assertNotNull(locatorRecord);
 100         final Rloc rloc = locatorRecord.getRloc();
 101         assertNotNull(rloc);
 102         final Address address = rloc.getAddress();
 103         assertTrue(address instanceof Ipv4Binary);
 104         return ((Ipv4Binary) address).getIpv4Binary();
 105     }
 106
 107     private List<LocatorRecord> verifyLocatorRecordExists(final MappingRecord mappingRecord) {
 108         final List<LocatorRecord> locatorRecords = mappingRecord.getLocatorRecord();
 109         assertNotNull(locatorRecords);
 110         return locatorRecords;
 111     }
 112
 113     private MappingRecord verifyMappingRecord(MapReply mapReply) {
 114         assertNotNull(mapReply);
 115         final List<MappingRecordItem> mappingRecordItems = mapReply.getMappingRecordItem();
 116         assertNotNull(mappingRecordItems);
 117         assertEquals(1, mappingRecordItems.size());
 118         final MappingRecordItem mappingRecordItem = mappingRecordItems.get(0);
 119         assertNotNull(mappingRecordItem);
 120         final MappingRecord mappingRecord = mappingRecordItem.getMappingRecord();
 121         assertNotNull(mappingRecord);
 122         return mappingRecord;
 123     }
 124
 125     private void emitMapRegisterMessage(final Site dstSite, final boolean merge) {
 126         final MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
 127         mapRegisterBuilder.setXtrSiteIdPresent(true);
 128         mapRegisterBuilder.setXtrId(dstSite.getXtrId());
 129         mapRegisterBuilder.setSiteId(new SiteId(DEFAULT_SITE_ID));
 130         mapRegisterBuilder.setMergeEnabled(merge);
 131         final MappingRecordItemBuilder mappingRecordItemBuilder = new MappingRecordItemBuilder();
 132         mappingRecordItemBuilder.setMappingRecordItemId(MAP_RECORD_A);
 133
 134         final MappingRecordBuilder mrb = prepareMappingRecord(EidType.EID_WITH_PREFIX, null, dstSite);
 135         mappingRecordItemBuilder.setMappingRecord(mrb.build());
 136         mapRegisterBuilder.setMappingRecordItem(Collections.singletonList(mappingRecordItemBuilder.build()));
 137
 138         lms.handleMapRegister(mapRegisterBuilder.build());
 139     }
 140
 141     void setCommonAuthentication() {
 142         Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", SITE_A.getVNI());
 143         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
 144
 145         eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", SITE_D5.getVNI());
 146         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
 147         sleepForSeconds(1);
 148     }
 149
 150     private Eid toEid(final String destSiteEidPrefix, final InstanceIdType vniValue, final int mask) {
 151         return LispAddressUtil.asIpv4PrefixBinaryEid(destSiteEidPrefix + "/" + mask, vniValue);
 152
 153     }
 154
 155     private MapReply emitMapRequestMessage(final String siteFromEidPrefix, final String siteToEidPrefix, final
 156     InstanceIdType vniValue) {
 157         final MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 158         final EidItemBuilder eidItemBuilder = new EidItemBuilder();
 159         Eid dstEid = toEid(siteToEidPrefix, vniValue, IP_MASK);
 160
 161         eidItemBuilder.setEid(dstEid);
 162         eidItemBuilder.setEidItemId(siteFromEidPrefix + siteToEidPrefix);
 163         final List<EidItem> eidItem = Collections.singletonList(eidItemBuilder.build());
 164         final Eid srcEid = toEid(siteFromEidPrefix, vniValue, IP_MASK);
 165         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(srcEid).build());
 166         mapRequestBuilder.setEidItem(eidItem);
 167         mapRequestBuilder.setItrRloc(prepareDummyItrRloc());
 168         mapRequestBuilder.setSmrInvoked(false);
 169         return lms.handleMapRequest(mapRequestBuilder.build());
 170     }
 171
 172     private List<ItrRloc> prepareDummyItrRloc() {
 173         List<ItrRloc> itrRlocs = new ArrayList<>();
 174         final ItrRlocBuilder itrRlocBuilder = new ItrRlocBuilder();
 175         itrRlocBuilder.setItrRlocId(ourAddress);
 176         itrRlocBuilder.setRloc(LispAddressUtil.asIpv4Rloc(ourAddress));
 177         itrRlocs.add(itrRlocBuilder.build());
 178         return itrRlocs;
 179     }
 180
 181     void storeNorthMappingNegative(final Site dstSite, final MappingRecord.Action action) {
 182         final Eid eidAsIpv4Prefix = LispAddressUtil.asIpv4PrefixBinaryEid(
 183                 dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK, dstSite.getVNI());
 184
 185         final MappingRecordBuilder mrbNegative = prepareMappingRecord(EidType.EID_WITH_PREFIX, null, dstSite);
 186         mrbNegative.setEid(eidAsIpv4Prefix);
 187         mrbNegative.setAction(action);
 188
 189         mapService.addMapping(MappingOrigin.Northbound, eidAsIpv4Prefix, new SiteId(DEFAULT_SITE_ID),
 190                 new MappingData(mrbNegative.build()));
 191     }
 192
 193     void deleteNorthMappingNegative(final Site dstSite) {
 194         final Eid eidAsIpv4Prefix = LispAddressUtil.asIpv4PrefixBinaryEid(
 195                 dstSite.getEidPrefix() + "/" + DEFAULT_NETWORK_MASK, dstSite.getVNI());
 196
 197         mapService.removeMapping(MappingOrigin.Northbound, eidAsIpv4Prefix);
 198     }
 199
 200     void storeNorthMappingSrcDst(final Site srcSite, final Site ... dstSite) {
 201         final MappingRecordBuilder mrb = prepareMappingRecord(EidType.EID_SRC_DST, srcSite,
 202                 dstSite);
 203         mapService.addMapping(MappingOrigin.Northbound, mrb.getEid(), new SiteId(DEFAULT_SITE_ID),
 204                 new MappingData(mrb.build()));
 205     }
 206
 207     void storeNorthMappingIpPrefix(final Site... dstSite) {
 208         final MappingRecordBuilder mrb = prepareMappingRecord(EidType.EID_WITH_PREFIX, null, dstSite);
 209         mapService.addMapping(MappingOrigin.Northbound, mrb.getEid(),  new SiteId(DEFAULT_SITE_ID),
 210                 new MappingData(mrb.build()));
 211     }
 212
 213     private void storeDestinationSiteMappingViaSouthbound(final Site dstSite, final boolean merge) {
 214         emitMapRegisterMessage(dstSite, merge);
 215     }
 216
 217     private MappingRecordBuilder prepareMappingRecordGeneral(final EidType eidType,
 218                                                              final Site srcSite, final Site dstSite) {
 219         final MappingRecordBuilder mrb = provideCommonMapRecordBuilder();
 220         mrb.setXtrId(dstSite.getXtrId());
 221
 222         Eid eid = null;
 223         if (EidType.EID_SRC_DST.equals(eidType)) {
 224             if (srcSite != null && dstSite != null && srcSite.getEidPrefix() != null && dstSite.getEidPrefix() !=
 225                     null) {
 226                 eid = LispAddressUtil.asSrcDstEid(srcSite.getEidPrefix(), dstSite.getEidPrefix(), DEFAULT_NETWORK_MASK,
 227                         DEFAULT_NETWORK_MASK, dstSite.getVNI().getValue().intValue());
 228             }
 229         }
 230
 231         mrb.setEid(eid == null ? toEid(dstSite.getEidPrefix(), dstSite.getVNI(), DEFAULT_NETWORK_MASK) : eid);
 232         return mrb;
 233     }
 234
 235     private MappingRecordBuilder prepareMappingRecord(final EidType eidType, final Site srcSite, final Site...
 236             dstSites) {
 237         assertTrue(isEidEquals(dstSites));
 238         final MappingRecordBuilder mrb = prepareMappingRecordGeneral(eidType, srcSite, dstSites[0]);
 239         final List<LocatorRecord> locatorRecords = new ArrayList<>();
 240         if (!dstSites[0].isForDeletion) {
 241             for (Site dstSite : dstSites) {
 242                 if (dstSite.getRloc() != null) {
 243                     locatorRecords.add(provideLocatorRecord(LispAddressUtil.asIpv4Rloc(dstSite.getRloc()),
 244                             dstSite.getRloc(), dstSite.getWeight(), dstSite.getPriority()));
 245                 }
 246             }
 247         }
 248         mrb.setLocatorRecord(locatorRecords);
 249
 250         return mrb;
 251     }
 252
 253     private boolean isEidEquals(final Site... sites) {
 254         String commonEid = null;
 255         for (Site site : sites) {
 256             final String concreteEidPrefix = site.getEidPrefix();
 257             if (!concreteEidPrefix.equals(commonEid)) {
 258                 if (commonEid == null) {
 259                     commonEid = concreteEidPrefix;
 260                 } else {
 261                     return false;
 262                 }
 263             }
 264         }
 265         return true;
 266     }
 267
 268     private LocatorRecord provideLocatorRecord(final Rloc rloc, final String rlocStr, final short weight, final short
 269             priority) {
 270         final LocatorRecordBuilder locatorRecordBuilder = new LocatorRecordBuilder();
 271         locatorRecordBuilder.setRloc(rloc);
 272         locatorRecordBuilder.setLocatorId(rlocStr);
 273         locatorRecordBuilder.setPriority(priority);
 274         locatorRecordBuilder.setWeight(weight);
 275         locatorRecordBuilder.setMulticastPriority(DEFAULT_MULTICAST_PRIORITY);
 276         locatorRecordBuilder.setMulticastWeight(DEFAULT_MULTICAST_WEIGHT);
 277         locatorRecordBuilder.setLocalLocator(DEFAULT_LOCAL_LOCATOR);
 278         locatorRecordBuilder.setRlocProbed(DEFAULT_RLOC_PROBED);
 279         locatorRecordBuilder.setRouted(DEFAULT_ROUTED);
 280         return locatorRecordBuilder.build();
 281     }
 282
 283     private MappingRecordBuilder provideCommonMapRecordBuilder() {
 284         final MappingRecordBuilder mappingRecordBuilder = new MappingRecordBuilder();
 285         mappingRecordBuilder.setRecordTtl(TTL);
 286         mappingRecordBuilder.setAction(MappingRecord.Action.NoAction);
 287         mappingRecordBuilder.setAuthoritative(true);
 288         mappingRecordBuilder.setTimestamp(System.currentTimeMillis());
 289         return mappingRecordBuilder;
 290     }
 291
 292     void deleteNorthMapingSrcDst(final Site srcSite, final Site dstSite) {
 293         final Eid eid = LispAddressUtil.asSrcDstEid(srcSite.getEidPrefix(), dstSite.getEidPrefix(),
 294                 DEFAULT_NETWORK_MASK, DEFAULT_NETWORK_MASK, dstSite.getVNI().getValue().intValue());
 295         mapService.removeMapping(MappingOrigin.Northbound, eid);
 296     }
 297
 298     void deleteSouthboundMappings(final Site dstSite) {
 299         emitMapRegisterMessage(dstSite, false);
 300
 301     }
 302
 303     void storeSouthboundMappings(final boolean merge, final Site ... sites) {
 304         for (Site site : sites) {
 305             storeDestinationSiteMappingViaSouthbound(site, merge);
 306         }
 307     }
 308
 309     boolean isPossibleAssertPingResultImmediately(final boolean expectedPingWorks, final boolean isPartialyWorking,
 310                                                   final String  msg) {
 311         //ping fail is unwanted. ping definitely failed
 312         if (expectedPingWorks && !isPartialyWorking) {
 313             fail(msg);
 314         }
 315
 316         //ping fail is wanted. still can fail later
 317         if (!expectedPingWorks && isPartialyWorking) {
 318             return false;
 319         }
 320
 321         //ping fail is unwanted. still can fail later
 322         if (expectedPingWorks && isPartialyWorking) {
 323             return false;
 324         }
 325
 326         //ping fail is wanted. ping definitely failed.
 327         if (!expectedPingWorks && !isPartialyWorking) {
 328             return true;
 329         }
 330         return false;
 331     }
 332
 333     boolean checkActionAndRloc(final Site dstSite, boolean expectedPingWorks, MapReply mapReplyFromSrcToDst, final
 334                                 Site  ... additionalSitesFromMapping) {
 335         final MappingRecord mappingRecord = verifyMappingRecord(mapReplyFromSrcToDst);
 336         final boolean isNotDroppendSrcDst = !MappingRecord.Action.Drop.equals(mappingRecord.getAction());
 337
 338         if (isPossibleAssertPingResultImmediately(expectedPingWorks, isNotDroppendSrcDst, "Drop action has appeared " +
 339                 "during ping")) {
 340             return true;
 341         }
 342
 343         final List<LocatorRecord> locatorRecords = verifyLocatorRecordExists(mappingRecord);
 344         for (Site expectedTargetSite : concatenateSites(dstSite, additionalSitesFromMapping)) {
 345             boolean expectedTargetFound = false;
 346             for (LocatorRecord locatorRecord : locatorRecords) {
 347                 if (expectedTargetSite.getRloc().equals(rlocToString(locatorRecord))) {
 348                     final byte[] ipv4AddressSrcDst = verifyIpv4Address(locatorRecord).getValue();
 349                     final byte[] rloc = InetAddresses.forString((expectedTargetSite.getRloc())).getAddress();
 350                     final boolean isRlocSrcDstEqual = Arrays.equals(ipv4AddressSrcDst, rloc);
 351                     if (isPossibleAssertPingResultImmediately(expectedPingWorks, isRlocSrcDstEqual, "Unexpected RLOC." +
 352                             "Expected value " + rloc + ". Real value " + ipv4AddressSrcDst +
 353                             ".")) {
 354                         return true;
 355                     }
 356
 357                     final boolean isWeightEquals = expectedTargetSite.getWeight() == locatorRecord.getWeight();
 358                     if (isPossibleAssertPingResultImmediately(expectedPingWorks, isWeightEquals, "Weight isn't equal." +
 359                             "Expected value " + expectedTargetSite.getWeight() + ". Value from mapping" +
 360                             locatorRecord.getWeight() + ".")) {
 361                         return true;
 362                     }
 363
 364                     final boolean isPriorityEquals = expectedTargetSite.getPriority() == locatorRecord.getPriority();
 365                     if (isPossibleAssertPingResultImmediately(expectedPingWorks, isPriorityEquals, "Priority isn't " +
 366                             "equal. Expected value " + expectedTargetSite.getPriority() + ". Value from mapping" +
 367                             locatorRecord.getPriority() + ".")) {
 368                         return true;
 369                     }
 370
 371                     expectedTargetFound = true;
 372                     break;
 373                 }
 374             }
 375             if (isPossibleAssertPingResultImmediately(expectedPingWorks, expectedTargetFound, "Mapping for " +
 376                 expectedTargetSite.getRloc() + " was expected but wasn't returned from mapping service." +
 377                 expectedTargetFound)) {
 378                 return true;
 379             }
 380
 381         }
 382
 383         return false;
 384     }
 385
 386     private String rlocToString(final LocatorRecord locatorRecord) {
 387         return LispAddressStringifier.getString(locatorRecord.getRloc());
 388     }
 389
 390     private Iterable<Site> concatenateSites(final Site dstSite, final Site... additionalSitesFromMapping) {
 391         final List<Site> sites = new ArrayList<>();
 392         sites.add(dstSite);
 393         for (Site additionalSite : additionalSitesFromMapping) {
 394             sites.add(additionalSite);
 395         }
 396         return sites;
 397     }
 398
 399     private void assertPing(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex,
 400                          boolean expectedPingWorks, final Site ... additionalSitesFromMapping) {
 401         final MapReply mapReplyFromSrcToDst = emitMapRequestMessage(srcSite.getHost(srcHostIndex), dstSite.getHost
 402                 (dstHostIndex), dstSite.getVNI());
 403         if (checkActionAndRloc(dstSite, expectedPingWorks, mapReplyFromSrcToDst, additionalSitesFromMapping)) {
 404             return;
 405         }
 406
 407         final MapReply mapReplyFromDstToSrc = emitMapRequestMessage(dstSite.getHost(dstHostIndex), srcSite.getHost
 408                 (srcHostIndex), srcSite.getVNI());
 409         if (checkActionAndRloc(srcSite, expectedPingWorks, mapReplyFromDstToSrc)) {
 410             return;
 411         }
 412
 413         final InstanceIdType iidDst = mapReplyFromSrcToDst.getMappingRecordItem().get(0).getMappingRecord().getEid().
 414                 getVirtualNetworkId();
 415         final InstanceIdType iidSrc = mapReplyFromDstToSrc.getMappingRecordItem().get(0).getMappingRecord().getEid().
 416                 getVirtualNetworkId();
 417
 418         final boolean isIIDEqual = iidDst.equals(iidSrc);
 419
 420         if (expectedPingWorks != isIIDEqual) {
 421             fail("IID problem. Dst value " + iidDst.getValue() + ". Src value " + iidSrc.getValue() + ".");
 422         }
 423     }
 424
 425     void assertPingWorks(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex,
 426                          final Site ... additionalSitesFromMapping) {
 427         assertPing(srcSite, srcHostIndex, dstSite, dstHostIndex, true, additionalSitesFromMapping);
 428     }
 429
 430     void assertPingFails(final Site srcSite, final int srcHostIndex, final Site dstSite, final int dstHostIndex) {
 431         assertPing(srcSite, srcHostIndex, dstSite, dstHostIndex, false);
 432     }
 433
 434     private void sleepForSeconds(int seconds) {
 435         try {
 436             Thread.sleep(seconds * 1000);
 437         } catch (InterruptedException e) {
 438             LOG.trace("Interrupted while sleeping", e);
 439         }
 440     }
 441
 442
 443     private List<MapRequest> translateBuffersToMapRequest(byte[][] buffers) {
 444         final List<MapRequest> mapRequests = new ArrayList<>();
 445         for (byte[] buffer : buffers) {
 446             final MapRequest mapRequest = MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(buffer), null);
 447             assertNotNull(mapRequest);
 448             mapRequests.add(mapRequest);
 449         }
 450         return mapRequests;
 451     }
 452
 453     private Set<Eid> prepareExpectedEid(final String ... hosts) {
 454         final Set<Eid> eids = new HashSet<>();
 455         for (String host : hosts) {
 456             eids.add(LispAddressUtil.asIpv4PrefixBinaryEid(host + "/" + IP_MASK,
 457                     new InstanceIdType(MultiSiteScenarioUtil.VNI2)));
 458         }
 459         return eids;
 460     }
 461
 462     private SourceEid prepareSourceEid(final String eidPrefix) {
 463         final SourceEidBuilder sourceEidBuilder = new SourceEidBuilder();
 464         final Eid eid = LispAddressUtil.asIpv4Eid(eidPrefix, MultiSiteScenarioUtil.VNI2);
 465         return sourceEidBuilder.setEid(eid).build();
 466     }
 467
 468     void checkSMR(final SocketReader socketReader, final String site, final String ... hosts) {
 469         LOG.debug("\n" + mapService.prettyPrintMappings());
 470         byte[][] buffers = socketReader.getBuffers(hosts.length);
 471         if (areBuffersEmpty(buffers)) {
 472             fail("No SMR received!");
 473         }
 474         List<MapRequest> mapRequests = translateBuffersToMapRequest(buffers);
 475         final Set<Eid> eids = prepareExpectedEid(hosts);
 476         final SourceEid expectedSourceEid = prepareSourceEid(site);
 477         for(MapRequest mapRequest : mapRequests) {
 478             assertTrue(mapRequest.isSmr());
 479             final SourceEid receivedSourceEid = mapRequest.getSourceEid();
 480             assertEquals(expectedSourceEid, receivedSourceEid);
 481             final List<EidItem> currentEidItems = mapRequest.getEidItem();
 482             assertNotNull(currentEidItems);
 483             assertTrue(SMRContainsExpectedEid(eids, currentEidItems));
 484         }
 485         //all expected eids should be after looping via mapRequests matched.
 486         assertTrue("Expected eids wasn't/weren't found " + eids, eids.isEmpty());
 487     }
 488
 489     private boolean SMRContainsExpectedEid(Set<Eid> eids, List<EidItem> currentEidItems) {
 490         for (EidItem eidItem : currentEidItems) {
 491             //if eid from map request is matched then it is removed from set of expected eids
 492             if (!eids.remove(eidItem.getEid())) {
 493                  fail("SMR contained EID `" + LispAddressStringifier.getString(eidItem.getEid())
 494                          + "' which wasn't expected.");
 495             }
 496         }
 497         return true;
 498     }
 499
 500     protected static boolean areBuffersEmpty(byte[][] buffers) {
 501         for (byte[] buffer : buffers) {
 502             for (byte b : buffer) {
 503                 if (b != 0) {
 504                     return false;
 505                 }
 506             }
 507         }
 508         return true;
 509     }
 510 }