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