mappingservice/integrationtest/src/test/java/org/opendaylight/lispflowmapping/integrationtest/MappingServiceIntegrationTest.java

   1 /*
   2  * Copyright (c) 2014 Contextream, 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.ops4j.pax.exam.CoreOptions.options;
  15
  16 import java.io.BufferedReader;
  17 import java.io.IOException;
  18 import java.io.InputStream;
  19 import java.io.InputStreamReader;
  20 import java.io.OutputStreamWriter;
  21 import java.net.DatagramPacket;
  22 import java.net.DatagramSocket;
  23 import java.net.HttpURLConnection;
  24 import java.net.InetAddress;
  25 import java.net.InetSocketAddress;
  26 import java.net.MalformedURLException;
  27 import java.net.SocketException;
  28 import java.net.SocketTimeoutException;
  29 import java.net.URL;
  30 import java.net.UnknownHostException;
  31 import java.nio.ByteBuffer;
  32 import java.nio.charset.Charset;
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.concurrent.TimeUnit;
  36
  37 import javax.inject.Inject;
  38
  39 import org.apache.commons.codec.binary.Base64;
  40 import org.codehaus.jettison.json.JSONException;
  41 import org.codehaus.jettison.json.JSONObject;
  42 import org.codehaus.jettison.json.JSONTokener;
  43 import org.junit.After;
  44 import org.junit.Before;
  45 import org.junit.Test;
  46 import org.junit.runner.RunWith;
  47 import org.opendaylight.controller.sal.binding.api.NotificationListener;
  48 import org.opendaylight.lispflowmapping.clusterdao.ClusterDAOService;
  49 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  50 import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
  51 import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
  52 import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
  53 import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
  54 import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
  55 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
  56 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  57 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
  58 import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
  59 import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
  60 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSegmentAddress;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispIpv4Address;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispMacAddress;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.ReencapHop;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.XtrRequestMapping;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.ValueBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.Addresses;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.AddressesBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.SrcAddressBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.Hops;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.HopsBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddrBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaflist.LcafListAddrBuilder;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaftrafficengineering.LcafTrafficEngineeringAddrBuilder;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.Hop;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.HopBuilder;
 109 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
 110 import org.ops4j.pax.exam.Configuration;
 111 import org.ops4j.pax.exam.Option;
 112 import org.ops4j.pax.exam.junit.PaxExam;
 113 import org.osgi.framework.Bundle;
 114 import org.osgi.framework.BundleContext;
 115 import org.osgi.framework.InvalidSyntaxException;
 116 import org.osgi.framework.ServiceReference;
 117 import org.slf4j.Logger;
 118 import org.slf4j.LoggerFactory;
 119
 120 @RunWith(PaxExam.class)
 121 public class MappingServiceIntegrationTest {
 122
 123     private IFlowMapping lms;
 124     private ClusterDAOService clusterService;
 125     protected static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
 126     private byte[] mapRequestPacket;
 127     private byte[] mapRegisterPacketWithNotify;
 128     private byte[] mapRegisterPacketWithoutNotify;
 129     private IConfigLispSouthboundPlugin configLispPlugin;
 130     String lispBindAddress = "127.0.0.1";
 131     String ourAddress = "127.0.0.2";
 132     private LispAFIAddress locatorEid;
 133     private DatagramSocket socket;
 134     private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
 135
 136     public static final String ODL = "org.opendaylight.controller";
 137     public static final String YANG = "org.opendaylight.yangtools";
 138     public static final String JERSEY = "com.sun.jersey";
 139     private static final int MAX_SERVICE_LOAD_RETRIES = 45;
 140     private static final int MAX_NOTIFICATION_RETRYS = 20;
 141
 142     @After
 143     public void after() {
 144         if (socket != null) {
 145             socket.close();
 146         }
 147         if (connection != null) {
 148             connection.disconnect();
 149         }
 150     }
 151
 152     @Before
 153     public void before() throws Exception {
 154         areWeReady();
 155         locatorEid = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 156         socket = initSocket(socket, LispMessage.PORT_NUM);
 157
 158         // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
 159         // LISP(Type = 8 - Encapsulated)
 160         // IP: 192.168.136.10 -> 153.16.254.1
 161         // UDP: 56756
 162         // LISP(Type = 1 Map-Request
 163         // Record Count: 1
 164         // ITR-RLOC count: 0
 165         // Source EID AFI: 0
 166         // Source EID not present
 167         // Nonce: 0x3d8d2acd39c8d608
 168         // ITR-RLOC AFI=1 Address=192.168.136.10
 169         // Record 1: 153.16.254.1/32
 170         mapRequestPacket = extractWSUdpByteArray(new String("0000   00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
 171                 + "0010   00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
 172                 + "0020   00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
 173                 + "0030   00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
 174                 + "0040   fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
 175                 + "0050   2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
 176                 + "0060   00 01 99 10 fe 01"));
 177
 178         // IP: 192.168.136.10 -> 128.223.156.35
 179         // UDP: 49289 -> 4342
 180         // LISP(Type = 3 Map-Register, P=1, M=1
 181         // Record Counter: 1
 182         // Nonce: 0
 183         // Key ID: 0x0001
 184         // AuthDataLength: 20 Data:
 185         // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
 186         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 187         // No-Action
 188         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 189         // Priority/Weight: 1/100, Multicast Priority/Weight:
 190         // 255/0
 191         //
 192
 193         mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String("0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 194                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 195                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 196                 + "0030   00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
 197                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 198                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 199                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 200
 201         // IP: 192.168.136.10 -> 128.223.156.35
 202         // UDP: 49289 -> 4342
 203         // LISP(Type = 3 Map-Register, P=1, M=1
 204         // Record Counter: 1
 205         // Nonce: 7
 206         // Key ID: 0x0000 NO AUTHENTICATION!!
 207         // AuthDataLength: 00 Data:
 208         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 209         // No-Action
 210         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 211         // Priority/Weight: 1/100, Multicast Priority/Weight:
 212         // 255/0
 213         //
 214
 215         mapRegisterPacketWithNotify = extractWSUdpByteArray(new String("0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 216                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 217                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 218                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 219                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 220                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 221                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 222
 223         // IP: 192.168.136.10 -> 128.223.156.35
 224         // UDP: 49289 -> 4342
 225         // LISP(Type = 3 Map-Register, P=1, M=1
 226         // Record Counter: 1
 227         // Nonce: 7
 228         // Key ID: 0x0000 NO AUTHENTICATION!!
 229         // AuthDataLength: 00 Data:
 230         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 231         // No-Action
 232         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 233         // Priority/Weight: 1/100, Multicast Priority/Weight:
 234         // 255/0
 235         //
 236
 237         mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String("0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 238                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 239                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
 240                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 241                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 242                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 243                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 244     }
 245
 246     @Inject
 247     private BundleContext bc;
 248     private HttpURLConnection connection;
 249     protected static boolean notificationCalled;
 250
 251     // Configure the OSGi container
 252     @Configuration
 253     public Option[] config() {
 254         return options(MappingServiceTestHelper.mappingServiceBundlesWithClusterDAO());
 255     }
 256
 257     @Test
 258     public void testSimpleUsage() throws Exception {
 259         mapRequestSimple();
 260         mapRegisterWithMapNotify();
 261         mapRegisterWithMapNotifyAndMapRequest();
 262         registerAndQuery__MAC();
 263         mapRequestMapRegisterAndMapRequest();
 264         mapRegisterWithAuthenticationWithoutConfiguringAKey();
 265         mapRegisterWithoutMapNotify();
 266     }
 267
 268     @Test
 269     public void testLCAFs() throws Exception {
 270         registerAndQuery__SrcDestLCAF();
 271         registerAndQuery__KeyValueLCAF();
 272         registerAndQuery__ListLCAF();
 273         registerAndQuery__ApplicationData();
 274         //registerAndQuery__TrafficEngineering();
 275         registerAndQuery__SegmentLCAF();
 276     }
 277
 278     @Test
 279     public void testMask() throws Exception {
 280         testPasswordExactMatch();
 281         testPasswordMaskMatch();
 282         eidPrefixLookupIPv4();
 283         eidPrefixLookupIPv6();
 284     }
 285
 286     @Test
 287     public void testNorthbound() throws Exception {
 288         northboundAddKey();
 289         northboundAddMapping();
 290         northboundDeleteMapping();
 291         northboundRetrieveKey();
 292         northboundRetrieveMapping();
 293         northboundRetrieveSourceDestKey();
 294         northboundRetrieveSourceDestMapping();
 295     }
 296
 297     @Test
 298     public void testOverWriting() throws Exception {
 299         testMapRegisterDosntOverwritesOtherSubKeys();
 300         testMapRegisterOverwritesSameSubkey();
 301         testMapRegisterOverwritesNoSubkey();
 302         testMapRegisterDoesntOverwritesNoSubkey();
 303     }
 304
 305     @Test
 306     public void testTimeOuts() throws Exception {
 307         mapRequestMapRegisterAndMapRequestTestTimeout();
 308         mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse();
 309     }
 310
 311     @Test
 312     public void testNonProxy() throws Throwable {
 313         testSimpleNonProxy();
 314         //testNonProxyOtherPort();
 315         //testRecievingNonProxyOnXtrPort();
 316     }
 317
 318     @Test
 319     public void testSmr() throws Exception {
 320         registerQueryRegisterWithSmr();
 321     }
 322
 323     // ------------------------------- Simple Tests ---------------------------
 324
 325     public void mapRequestSimple() throws SocketTimeoutException {
 326         cleanUP();
 327
 328         // This Map-Request is sent from a source port different from 4342
 329         // We close and bind the socket on the correct port
 330         if (socket != null) {
 331             socket.close();
 332         }
 333         socket = initSocket(socket, 56756);
 334
 335         sendPacket(mapRequestPacket);
 336         ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
 337         MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
 338         assertEquals(4435248268955932168L, reply.getNonce().longValue());
 339
 340     }
 341
 342     public void mapRegisterWithMapNotify() throws SocketTimeoutException {
 343         cleanUP();
 344         sendPacket(mapRegisterPacketWithNotify);
 345         MapNotify reply = receiveMapNotify();
 346         assertEquals(7, reply.getNonce().longValue());
 347     }
 348
 349     public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
 350         cleanUP();
 351         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 352
 353         MapReply mapReply = registerAddressAndQuery(eid, 32);
 354
 355         assertEquals(4, mapReply.getNonce().longValue());
 356         assertEquals(LispAFIConvertor.toContainer(locatorEid), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 357                 .getLispAddressContainer());
 358
 359     }
 360
 361     public void registerAndQuery__MAC() throws SocketTimeoutException {
 362         cleanUP();
 363         String macAddress = "01:02:03:04:05:06";
 364
 365         MapReply reply = registerAddressAndQuery(LispAFIConvertor.asMacAfiAddress(macAddress));
 366
 367         assertTrue(true);
 368         LispAFIAddress addressFromNetwork = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
 369         assertTrue(addressFromNetwork instanceof LispMacAddress);
 370         String macAddressFromReply = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.mac.MacAddress) addressFromNetwork).getMacAddress().getValue();
 371
 372         assertEquals(macAddress, macAddressFromReply);
 373     }
 374
 375     public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
 376         cleanUP();
 377         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 378         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 379         mapRequestBuilder.setNonce((long) 4);
 380         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
 381                 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
 382         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
 383         mapRequestBuilder.getEidRecord().add(
 384                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
 385         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
 386         mapRequestBuilder.getItrRloc().add(
 387                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
 388         sendMapRequest(mapRequestBuilder.build());
 389         MapReply mapReply = receiveMapReply();
 390         assertEquals(4, mapReply.getNonce().longValue());
 391         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 392         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
 393         mapRegisterbuilder.setWantMapNotify(true);
 394         mapRegisterbuilder.setNonce((long) 8);
 395         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
 396         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 397         etlrBuilder.setMaskLength((short) 32);
 398         etlrBuilder.setRecordTtl(254);
 399         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
 400         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
 401         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
 402         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
 403         mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 404         mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
 405         sendMapRegister(mapRegisterbuilder.build());
 406         MapNotify mapNotify = receiveMapNotify();
 407         assertEquals(8, mapNotify.getNonce().longValue());
 408         sendMapRequest(mapRequestBuilder.build());
 409         mapReply = receiveMapReply();
 410         assertEquals(4, mapReply.getNonce().longValue());
 411         assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 412                 .getLispAddressContainer());
 413
 414     }
 415
 416     public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
 417         cleanUP();
 418         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 419         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 420         LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey1", LispAFIConvertor.toPrimitive(rloc1Value));
 421         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 422         LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey2", LispAFIConvertor.toPrimitive(rloc2Value));
 423         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
 424         assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 425         assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 426         assertEquals(LispAFIConvertor.toContainer(rloc1), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer());
 427     }
 428
 429     public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
 430         cleanUP();
 431         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 432         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 433         LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc1Value));
 434         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 435         LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc2Value));
 436         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
 437         assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 438         assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 439     }
 440
 441     public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
 442         cleanUP();
 443         lms.setOverwrite(true);
 444         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 445         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 446         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 447         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
 448         assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 449         assertEquals(LispAFIConvertor.toContainer(rloc2Value), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 450                 .getLispAddressContainer());
 451     }
 452
 453     public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
 454         cleanUP();
 455         lms.setOverwrite(false);
 456         LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 457         LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
 458         LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
 459         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
 460         assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 461         LispAddressContainer rloc1ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer();
 462         LispAddressContainer rloc2ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer();
 463         assertTrue((LispAFIConvertor.toContainer(rloc1Value).equals(rloc1ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
 464                 rloc2ReturnValueContainer))
 465                 || (LispAFIConvertor.toContainer(rloc1Value).equals(rloc2ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
 466                         rloc1ReturnValueContainer)));
 467     }
 468
 469     private MapReply sendMapRegisterTwiceWithDiffrentValues(LispAFIAddress eid, LispAFIAddress rloc1, LispAFIAddress rloc2)
 470             throws SocketTimeoutException {
 471         MapRegister mb = createMapRegister(eid, rloc1);
 472         MapNotify mapNotify = lms.handleMapRegister(mb, false);
 473         MapRequest mr = createMapRequest(eid);
 474         MapReply mapReply = lms.handleMapRequest(mr);
 475         assertEquals(mb.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0)
 476                 .getLocatorRecord().get(0).getLispAddressContainer());
 477         mb = createMapRegister(eid, rloc2);
 478         mapNotify = lms.handleMapRegister(mb, false);
 479         assertEquals(8, mapNotify.getNonce().longValue());
 480         mr = createMapRequest(eid);
 481         sendMapRequest(mr);
 482         mapReply = lms.handleMapRequest(mr);
 483         return mapReply;
 484     }
 485
 486     public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
 487         cleanUP();
 488         sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
 489         try {
 490             receivePacket(3000);
 491             // If didn't timeout then fail:
 492             fail();
 493         } catch (SocketTimeoutException ste) {
 494         }
 495     }
 496
 497     public void mapRegisterWithoutMapNotify() {
 498         cleanUP();
 499         sendPacket(mapRegisterPacketWithoutNotify);
 500         try {
 501             receivePacket(3000);
 502             // If didn't timeout then fail:
 503             fail();
 504         } catch (SocketTimeoutException ste) {
 505         }
 506     }
 507
 508     public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
 509         cleanUP();
 510         lms.setShouldUseSmr(true);
 511
 512         sendPacket(mapRegisterPacketWithNotify);
 513         receiveMapNotify();
 514
 515         sendPacket(mapRequestPacket);
 516         try {
 517             Thread.sleep(1000);
 518         } catch (InterruptedException e) {
 519         }
 520
 521         mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
 522         sendPacket(mapRegisterPacketWithoutNotify);
 523
 524         ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
 525         MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
 526         assertTrue(smr.isSmr());
 527         LispAddressContainer smrEid = smr.getEidRecord().get(0).getLispAddressContainer();
 528         assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")).equals(smrEid));
 529     }
 530
 531     // --------------------- Northbound Tests ---------------------------
 532
 533     private void northboundAddKey() throws Exception {
 534         cleanUP();
 535         LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
 536         int mask = 32;
 537         String pass = "asdf";
 538
 539         URL url = createPutURL("key");
 540         String authKeyJSON = createAuthKeyJSON(pass, address, mask);
 541         callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
 542
 543         String retrievedKey = lms.getAuthenticationKey(LispAFIConvertor.toContainer(address), mask);
 544
 545         // Check stored password matches the one sent
 546         assertEquals(pass, retrievedKey);
 547
 548     }
 549
 550     private void northboundRetrieveSourceDestKey() throws Exception {
 551         cleanUP();
 552         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 553                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
 554         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 555                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
 556         int mask1 = 32;
 557         int mask2 = 32;
 558         LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
 559                 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
 560                 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
 561                 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
 562         String pass = "asdf";
 563
 564         lms.addAuthenticationKey(LispAFIConvertor.toContainer(sourceDestAddress), mask1, pass);
 565
 566         // URL url = createGetKeyIPv4URL(address1, mask1);
 567         URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
 568                 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
 569                 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
 570         String reply = callURL("GET", null, "application/json", null, url);
 571         JSONTokener jt = new JSONTokener(reply);
 572         JSONObject json = new JSONObject(jt);
 573
 574         // test that the password matches what was we expected.
 575         assertEquals(pass, json.get("key"));
 576
 577     }
 578
 579     private void northboundRetrieveKey() throws Exception {
 580         cleanUP();
 581         LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 582         int mask = 32;
 583         String pass = "asdf";
 584
 585         lms.addAuthenticationKey(LispAFIConvertor.toContainer(address), mask, pass);
 586
 587         URL url = createGetKeyIPv4URL(address, mask);
 588         String reply = callURL("GET", null, "application/json", null, url);
 589         JSONTokener jt = new JSONTokener(reply);
 590         JSONObject json = new JSONObject(jt);
 591
 592         // test that the password matches what was we expected.
 593         assertEquals(pass, json.get("key"));
 594
 595     }
 596
 597     private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
 598         return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
 599                 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
 600     }
 601
 602     private void northboundAddMapping() throws Exception {
 603         cleanUP();
 604         String pass = "asdf";
 605         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 606         int mask = 32;
 607         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 608
 609         // NB add mapping always checks the key
 610         lms.addAuthenticationKey(LispAFIConvertor.toContainer(eid), mask, pass);
 611
 612         URL url = createPutURL("mapping");
 613         String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
 614         callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
 615
 616         // Retrieve the RLOC from the database
 617         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 618         mapRequestBuilder.setPitr(false);
 619         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
 620         mapRequestBuilder.getEidRecord().add(
 621                 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
 622         MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
 623
 624         LispIpv4Address retrievedRloc = (LispIpv4Address) LispAFIConvertor.toAFI(
 625                 mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 626
 627         assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
 628
 629     }
 630
 631     private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
 632         String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ " + "\"proxyMapReply\" : false, "
 633                 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : " + "{ " + "\"ipAddress\" : \""
 634                 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "}," + "\"mapVersion\" : 0,"
 635                 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ " + "\"multicastPriority\" : 1,"
 636                 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\"," + "\"afi\" : "
 637                 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50," + "\"rlocProbed\" : false, "
 638                 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], " + "\"recordTtl\" : 100" + "} " + "], "
 639                 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
 640
 641         return jsonString;
 642     }
 643
 644     private void northboundRetrieveMapping() throws Exception {
 645         cleanUP();
 646         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 647         int mask = 32;
 648         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 649         // Insert mapping in the database
 650         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 651         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 652         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 653         etlr.setMaskLength((short) mask);
 654         etlr.setRecordTtl(254);
 655         etlr.setAuthoritative(false);
 656         etlr.setAction(Action.NoAction);
 657         LocatorRecordBuilder record = new LocatorRecordBuilder();
 658         record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 659         record.setRouted(true);
 660         record.setRlocProbed(false);
 661         record.setLocalLocator(false);
 662         record.setPriority((short) 1);
 663         record.setWeight((short) 50);
 664         record.setMulticastPriority((short) 1);
 665         record.setMulticastWeight((short) 1);
 666         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 667         etlr.getLocatorRecord().add(record.build());
 668         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 669         mapRegister.getEidToLocatorRecord().add(etlr.build());
 670         lms.handleMapRegister(mapRegister.build(), false);
 671
 672         // Get mapping using NB interface. No IID used
 673         URL url = createGetMappingIPv4URL(0, eid, mask);
 674         String reply = callURL("GET", null, "application/json", null, url);
 675         JSONTokener jt = new JSONTokener(reply);
 676         JSONObject json = new JSONObject(jt);
 677
 678         // With just one locator, locators is not a JSONArray
 679         String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
 680
 681         assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
 682
 683     }
 684
 685     private void northboundDeleteMapping() throws Exception {
 686         cleanUP();
 687         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
 688         int mask = 32;
 689         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 690         // Insert mapping in the database
 691         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 692         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 693         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 694         etlr.setMaskLength((short) mask);
 695         etlr.setRecordTtl(254);
 696         etlr.setAuthoritative(false);
 697         etlr.setAction(Action.NoAction);
 698         LocatorRecordBuilder record = new LocatorRecordBuilder();
 699         record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 700         record.setRouted(true);
 701         record.setRlocProbed(false);
 702         record.setLocalLocator(false);
 703         record.setPriority((short) 1);
 704         record.setWeight((short) 50);
 705         record.setMulticastPriority((short) 1);
 706         record.setMulticastWeight((short) 1);
 707         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 708         etlr.getLocatorRecord().add(record.build());
 709         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 710         mapRegister.getEidToLocatorRecord().add(etlr.build());
 711         lms.handleMapRegister(mapRegister.build(), false);
 712
 713         // Delete mapping using NB interface. No IID used
 714         URL url = createDeleteMappingIPv4URL(0, eid, mask);
 715         String reply = callURL("DELETE", null, "application/json", null, url);
 716
 717         // Get mapping using NB interface. No IID used
 718         url = createGetMappingIPv4URL(0, eid, mask);
 719         reply = callURL("GET", null, "application/json", null, url);
 720         JSONTokener jt = new JSONTokener(reply);
 721         JSONObject json = new JSONObject(jt);
 722
 723         // With just one locator, locators is not a JSONArray
 724         assertEquals(json.getJSONArray("locators").length(), 0);
 725     }
 726
 727     private void northboundRetrieveSourceDestMapping() throws Exception {
 728         cleanUP();
 729         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 730                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
 731         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
 732                 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
 733         int mask1 = 32;
 734         int mask2 = 32;
 735         LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
 736                 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
 737                 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
 738                 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
 739         LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
 740
 741         // Insert mapping in the database
 742         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 743         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 744         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(sourceDestAddress));
 745         etlr.setMaskLength((short) mask1);
 746         etlr.setRecordTtl(254);
 747         etlr.setAuthoritative(false);
 748         etlr.setAction(Action.NoAction);
 749         LocatorRecordBuilder record = new LocatorRecordBuilder();
 750         record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 751         record.setRouted(true);
 752         record.setRlocProbed(false);
 753         record.setLocalLocator(false);
 754         record.setPriority((short) 1);
 755         record.setWeight((short) 50);
 756         record.setMulticastPriority((short) 1);
 757         record.setMulticastWeight((short) 1);
 758         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 759         etlr.getLocatorRecord().add(record.build());
 760         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 761         mapRegister.getEidToLocatorRecord().add(etlr.build());
 762         lms.handleMapRegister(mapRegister.build(), false);
 763
 764         // Get mapping using NB interface. No IID used
 765         URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
 766                 address1.getIpv4Address().getIpv4Address().getValue(),
 767                 mask1,
 768                 address2.getIpv4Address().getIpv4Address().getValue(),
 769                 mask2);
 770         String reply = callURL("GET", null, "application/json", null, url);
 771         JSONTokener jt = new JSONTokener(reply);
 772         JSONObject json = new JSONObject(jt);
 773
 774         // With just one locator, locators is not a JSONArray
 775         String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
 776
 777         assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
 778
 779     }
 780
 781     private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
 782         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key", address.getAfi().shortValue(),
 783                 address.getIpv4Address().getValue(), mask);
 784         URL url = new URL(restUrl);
 785         return url;
 786     }
 787
 788     private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
 789         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "key", afi, srcAddress, srcMask,
 790                 dstAddress, dstMask);
 791         URL url = new URL(restUrl);
 792         return url;
 793     }
 794
 795     private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
 796         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "mapping", afi, srcAddress,
 797                 srcMask, dstAddress, dstMask);
 798         URL url = new URL(restUrl);
 799         return url;
 800     }
 801
 802     private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
 803         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
 804                 .shortValue(), address.getIpv4Address().getValue(), mask);
 805         URL url = new URL(restUrl);
 806         return url;
 807     }
 808
 809     private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
 810         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
 811                 .shortValue(), address.getIpv4Address().getValue(), mask);
 812         URL url = new URL(restUrl);
 813         return url;
 814     }
 815
 816     private URL createPutURL(String resource) throws MalformedURLException {
 817
 818         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
 819
 820         URL url = new URL(restUrl);
 821         return url;
 822     }
 823
 824     private String createAuthenticationString() {
 825         String authString = "admin:admin";
 826         byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
 827         String authStringEnc = new String(authEncBytes);
 828         return authStringEnc;
 829     }
 830
 831     private String callURL(String method, String content, String accept, String body, URL url) throws IOException, JSONException {
 832         String authStringEnc = createAuthenticationString();
 833         connection = (HttpURLConnection) url.openConnection();
 834         connection.setRequestMethod(method);
 835         connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
 836         if (content != null) {
 837             connection.setRequestProperty("Content-Type", content);
 838         }
 839         if (accept != null) {
 840             connection.setRequestProperty("Accept", accept);
 841         }
 842         if (body != null) {
 843             // now add the request body
 844             connection.setDoOutput(true);
 845             OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
 846             wr.write(body);
 847             wr.flush();
 848         }
 849         connection.connect();
 850
 851         // getting the result, first check response code
 852         Integer httpResponseCode = connection.getResponseCode();
 853
 854         if (httpResponseCode > 299) {
 855             LOG.trace("HTTP Address: " + url);
 856             LOG.trace("HTTP Response Code: " + httpResponseCode);
 857             fail();
 858         }
 859
 860         InputStream is = connection.getInputStream();
 861         BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
 862         StringBuilder sb = new StringBuilder();
 863         int cp;
 864         while ((cp = rd.read()) != -1) {
 865             sb.append((char) cp);
 866         }
 867         is.close();
 868         connection.disconnect();
 869         return (sb.toString());
 870     }
 871
 872     // timePeriod - in ms
 873     public void assertNoPacketReceived(int timePeriod) {
 874         try {
 875             receivePacket(timePeriod);
 876             // If didn't timeout then fail:
 877             fail();
 878         } catch (SocketTimeoutException ste) {
 879         }
 880     }
 881
 882     // ------------------------------- Mask Tests ---------------------------
 883
 884     public void eidPrefixLookupIPv4() throws SocketTimeoutException {
 885         cleanUP();
 886         runPrefixTest(LispAFIConvertor.asIPAfiAddress("1.2.3.4"), 16, LispAFIConvertor.asIPAfiAddress("1.2.3.2"),
 887                 LispAFIConvertor.asIPAfiAddress("1.1.1.1"), (byte) 32);
 888     }
 889
 890     public void eidPrefixLookupIPv6() throws SocketTimeoutException {
 891         cleanUP();
 892         runPrefixTest(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8"), 64, LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:1:2:3"),
 893                 LispAFIConvertor.asIPv6AfiAddress("1:2:3:1:2:3:1:2"), 128);
 894     }
 895
 896     private void runPrefixTest(LispAFIAddress registerEID, int registerdMask, LispAFIAddress matchedAddress, LispAFIAddress unMatchedAddress, int mask)
 897             throws SocketTimeoutException {
 898
 899         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 900         mapRegister.setWantMapNotify(true);
 901         mapRegister.setNonce((long) 8);
 902         mapRegister.setWantMapNotify(true);
 903         mapRegister.setKeyId((short) 0);
 904         mapRegister.setAuthenticationData(new byte[0]);
 905         mapRegister.setNonce((long) 8);
 906         mapRegister.setProxyMapReply(false);
 907         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 908         etlr.setRecordTtl(254);
 909         etlr.setAction(Action.NoAction);
 910         etlr.setAuthoritative(false);
 911         etlr.setMapVersion((short) 0);
 912         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(registerEID));
 913         etlr.setMaskLength((short) registerdMask);
 914         etlr.setRecordTtl(254);
 915         LocatorRecordBuilder record = new LocatorRecordBuilder();
 916         record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
 917         record.setLocalLocator(false);
 918         record.setRlocProbed(false);
 919         record.setRouted(true);
 920         record.setMulticastPriority((short) 0);
 921         record.setMulticastWeight((short) 0);
 922         record.setPriority((short) 0);
 923         record.setWeight((short) 0);
 924         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 925         etlr.getLocatorRecord().add(record.build());
 926         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 927         mapRegister.getEidToLocatorRecord().add(etlr.build());
 928         sendMapRegister(mapRegister.build());
 929         MapNotify mapNotify = receiveMapNotify();
 930         assertEquals(8, mapNotify.getNonce().longValue());
 931         MapRequestBuilder mapRequest = new MapRequestBuilder();
 932         mapRequest.setNonce((long) 4);
 933         mapRequest.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
 934         mapRequest.setEidRecord(new ArrayList<EidRecord>());
 935         mapRequest.setAuthoritative(false);
 936         mapRequest.setMapDataPresent(false);
 937         mapRequest.setPitr(false);
 938         mapRequest.setProbe(false);
 939         mapRequest.setSmr(false);
 940         mapRequest.setSmrInvoked(false);
 941         mapRequest.getEidRecord().add(
 942                 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(matchedAddress)).build());
 943         mapRequest.setItrRloc(new ArrayList<ItrRloc>());
 944         mapRequest.getItrRloc().add(
 945                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
 946         sendMapRequest(mapRequest.build());
 947         MapReply mapReply = receiveMapReply();
 948         assertEquals(4, mapReply.getNonce().longValue());
 949         assertEquals(record.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
 950         mapRequest.setEidRecord(new ArrayList<EidRecord>());
 951         mapRequest.getEidRecord().add(
 952                 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(unMatchedAddress)).build());
 953         sendMapRequest(mapRequest.build());
 954         mapReply = receiveMapReply();
 955         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
 956     }
 957
 958     // This registers an IP with a MapRegister, then adds a password via the
 959     // northbound REST API
 960     // and checks that the password works
 961     public void testPasswordExactMatch() throws Exception {
 962         cleanUP();
 963         String ipString = "10.0.0.1";
 964         LispIpv4Address address = LispAFIConvertor.asIPAfiAddress(ipString);
 965         int mask = 32;
 966         String pass = "pass";
 967
 968         URL url = createPutURL("key");
 969
 970         String jsonAuthData = createAuthKeyJSON(pass, address, mask);
 971
 972         LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
 973         LOG.trace("Address: " + address);
 974
 975         byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232, (byte) 31, (byte) 249, (byte) 87,
 976                 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53, (byte) 196, (byte) 62 };
 977
 978         byte[] zeros = new byte[20];
 979
 980         callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
 981
 982         // build a MapRegister
 983         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 984         mapRegister.setWantMapNotify(true);
 985         mapRegister.setNonce((long) 8);
 986         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 987         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(address));
 988         etlr.setMaskLength((short) mask);
 989         etlr.setRecordTtl(254);
 990         LocatorRecordBuilder record = new LocatorRecordBuilder();
 991         record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
 992         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 993         etlr.getLocatorRecord().add(record.build());
 994         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 995         mapRegister.getEidToLocatorRecord().add(etlr.build());
 996
 997         mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
 998         mapRegister.setAuthenticationData(zeros);
 999
1000         sendMapRegister(mapRegister.build());
1001         assertNoPacketReceived(3000);
1002
1003         mapRegister.setAuthenticationData(expectedSha);
1004
1005         sendMapRegister(mapRegister.build());
1006
1007         assertMapNotifyRecieved();
1008     }
1009
1010     public void testPasswordMaskMatch() throws Exception {
1011         cleanUP();
1012         LispIpv4Address addressInRange = LispAFIConvertor.asIPAfiAddress("10.20.30.40");
1013         LispIpv4Address addressOutOfRange = LispAFIConvertor.asIPAfiAddress("20.40.30.40");
1014         LispIpv4Address range = LispAFIConvertor.asIPAfiAddress("10.20.30.0");
1015
1016         int mask = 32;
1017         String pass = "pass";
1018
1019         URL url = createPutURL("key");
1020         String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1021
1022         callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1023         // build a MapRegister
1024         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1025
1026         mapRegister.setWantMapNotify(true);
1027         mapRegister.setNonce((long) 8);
1028         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1029         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressInRange));
1030         etlr.setMaskLength((short) mask);
1031         etlr.setRecordTtl(254);
1032         LocatorRecordBuilder record = new LocatorRecordBuilder();
1033         record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1034         record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1035         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1036         etlr.getLocatorRecord().add(record.build());
1037         mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1038         mapRegister.getEidToLocatorRecord().add(etlr.build());
1039
1040         mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1041         mapRegister
1042                 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4, -67, -113, 104, -110, -71 });
1043
1044         sendMapRegister(mapRegister.build());
1045
1046         assertMapNotifyRecieved();
1047
1048         etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressOutOfRange));
1049         mapRegister
1050                 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123, -71, -14, -99, 67, -23, -73 });
1051
1052         sendMapRegister(mapRegister.build());
1053         assertNoPacketReceived(3000);
1054     }
1055
1056     private MapReply registerAddressAndQuery(LispAFIAddress eid) throws SocketTimeoutException {
1057         return registerAddressAndQuery(eid, -1);
1058     }
1059
1060     // takes an address, packs it in a MapRegister, sends it, returns the
1061     // MapReply
1062     private MapReply registerAddressAndQuery(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1063         MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1064         mapRegisterBuilder.setWantMapNotify(true);
1065         mapRegisterBuilder.setKeyId((short) 0);
1066         mapRegisterBuilder.setAuthenticationData(new byte[0]);
1067         mapRegisterBuilder.setNonce((long) 8);
1068         mapRegisterBuilder.setProxyMapReply(false);
1069         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1070         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1071         if (maskLength != -1) {
1072             etlrBuilder.setMaskLength((short) maskLength);
1073         } else {
1074             etlrBuilder.setMaskLength((short) 0);
1075         }
1076         etlrBuilder.setRecordTtl(254);
1077         etlrBuilder.setAction(Action.NoAction);
1078         etlrBuilder.setAuthoritative(false);
1079         etlrBuilder.setMapVersion((short) 0);
1080         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1081         recordBuilder.setLocalLocator(false);
1082         recordBuilder.setRlocProbed(false);
1083         recordBuilder.setRouted(true);
1084         recordBuilder.setMulticastPriority((short) 0);
1085         recordBuilder.setMulticastWeight((short) 0);
1086         recordBuilder.setPriority((short) 0);
1087         recordBuilder.setWeight((short) 0);
1088         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1089         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1090         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1091         mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1092         mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1093         sendMapRegister(mapRegisterBuilder.build());
1094         MapNotify mapNotify = receiveMapNotify();
1095         assertEquals(8, mapNotify.getNonce().longValue());
1096         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1097         mapRequestBuilder.setNonce((long) 4);
1098         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1099         mapRequestBuilder.getEidRecord().add(
1100                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1101         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1102         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress)))
1103                 .build());
1104         mapRequestBuilder.getItrRloc().add(
1105                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1106         mapRequestBuilder.setAuthoritative(false);
1107         mapRequestBuilder.setMapDataPresent(false);
1108         mapRequestBuilder.setPitr(false);
1109         mapRequestBuilder.setProbe(false);
1110         mapRequestBuilder.setSmr(false);
1111         mapRequestBuilder.setSmrInvoked(false);
1112         sendMapRequest(mapRequestBuilder.build());
1113         return receiveMapReply();
1114     }
1115
1116     // ------------------------------- LCAF Tests ---------------------------
1117
1118     public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1119         cleanUP();
1120         String ipString = "10.20.30.200";
1121         String macString = "01:02:03:04:05:06";
1122         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1123         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1124         LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1125         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1126         builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1127         builder.setSrcMaskLength((short) 0);
1128         builder.setDstMaskLength((short) 0);
1129         builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1130         builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1131
1132         MapReply reply = registerAddressAndQuery(builder.build());
1133
1134         LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1135         assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1136         LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1137
1138         LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1139         LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1140
1141         assertTrue(receivedAddr1 instanceof LispIpv4Address);
1142         assertTrue(receivedAddr2 instanceof LispMacAddress);
1143
1144         LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1145         LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1146
1147         assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1148         assertEquals(macString, receivedMAC.getMacAddress().getValue());
1149     }
1150
1151     @Test
1152     public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1153         cleanUP();
1154         String ipString = "10.20.30.200";
1155         String macString = "01:02:03:04:05:06";
1156         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1157         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1158         LcafKeyValueAddressAddrBuilder builder = new LcafKeyValueAddressAddrBuilder();
1159         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1160         builder.setLcafType((short) LispCanonicalAddressFormatEnum.KEY_VALUE.getLispCode());
1161         builder.setKey(new KeyBuilder().setPrimitiveAddress(addrToSend1).build());
1162         builder.setValue(new ValueBuilder().setPrimitiveAddress(addrToSend2).build());
1163
1164         MapReply reply = registerAddressAndQuery(builder.build());
1165
1166         LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1167         assertTrue(fromNetwork.getAddress() instanceof LcafKeyValue);
1168         LcafKeyValue keyValueFromNetwork = (LcafKeyValue) fromNetwork.getAddress();
1169
1170         LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress());
1171         LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getValue().getPrimitiveAddress());
1172
1173         assertTrue(receivedAddr1 instanceof LispIpv4Address);
1174         assertTrue(receivedAddr2 instanceof LispMacAddress);
1175
1176         LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1177         LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1178
1179         assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1180         assertEquals(macString, receivedMAC.getMacAddress().getValue());
1181     }
1182
1183     public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1184         cleanUP();
1185         String macString = "01:02:03:04:05:06";
1186         String ipString = "10.20.255.30";
1187         LcafListAddrBuilder listbuilder = new LcafListAddrBuilder();
1188         listbuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.LIST.getLispCode());
1189         listbuilder.setAddresses(new ArrayList<Addresses>());
1190         listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1191         listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString))).build());
1192
1193         MapReply reply = registerAddressAndQuery(listbuilder.build());
1194
1195         LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1196
1197         assertTrue(receivedAddress instanceof LcafListAddress);
1198
1199         LcafListAddress listAddrFromNetwork = (LcafListAddress) receivedAddress;
1200         LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(0).getPrimitiveAddress());
1201         LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(1).getPrimitiveAddress());
1202
1203         assertTrue(receivedAddr1 instanceof LispIpv4Address);
1204         assertTrue(receivedAddr2 instanceof LispMacAddress);
1205
1206         assertEquals(macString, ((LispMacAddress) receivedAddr2).getMacAddress().getValue());
1207         assertEquals(ipString, ((LispIpv4Address) receivedAddr1).getIpv4Address().getValue());
1208     }
1209
1210     public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1211         cleanUP();
1212         String ipString = "10.20.255.30";
1213         int instanceId = 6;
1214         LcafSegmentAddrBuilder builder = new LcafSegmentAddrBuilder();
1215         builder.setInstanceId((long) instanceId);
1216         builder.setIidMaskLength((short) 32);
1217         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.SEGMENT.getLispCode());
1218         builder.setAddress(new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1219
1220         MapReply reply = registerAddressAndQuery(builder.build());
1221
1222         LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1223         assertTrue(receivedAddress instanceof LcafSegmentAddress);
1224
1225         LcafSegmentAddress segmentfromNetwork = (LcafSegmentAddress) receivedAddress;
1226         LispAFIAddress addrFromSegment = LispAFIConvertor.toAFIfromPrimitive(segmentfromNetwork.getAddress().getPrimitiveAddress());
1227         assertTrue(addrFromSegment instanceof LispIpv4Address);
1228         assertEquals(ipString, ((LispIpv4Address) addrFromSegment).getIpv4Address().getValue());
1229
1230         assertEquals(instanceId, segmentfromNetwork.getInstanceId().intValue());
1231     }
1232
1233     public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1234         cleanUP();
1235         String macString = "01:02:03:04:05:06";
1236         String ipString = "10.20.255.30";
1237         HopBuilder hopBuilder = new HopBuilder();
1238         hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString)));
1239         Hop hop1 = hopBuilder.build();
1240         hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString)));
1241         Hop hop2 = hopBuilder.build();
1242         HopsBuilder hb = new HopsBuilder();
1243         hb.setHop(hop1);
1244         hb.setLookup(true);
1245         hb.setRLOCProbe(false);
1246         hb.setStrict(true);
1247         HopsBuilder hb2 = new HopsBuilder();
1248         hb2.setHop(hop2);
1249         hb2.setLookup(false);
1250         hb2.setRLOCProbe(true);
1251         hb2.setStrict(false);
1252         Hops hops1 = hb.build();
1253         Hops hops2 = hb2.build();
1254         LcafTrafficEngineeringAddrBuilder trafficBuilder = new LcafTrafficEngineeringAddrBuilder();
1255         trafficBuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType(
1256                 (short) LispCanonicalAddressFormatEnum.TRAFFIC_ENGINEERING.getLispCode());
1257         trafficBuilder.setHops(new ArrayList<Hops>());
1258         trafficBuilder.getHops().add(hb.build());
1259         trafficBuilder.getHops().add(hb2.build());
1260
1261         MapReply reply = registerAddressAndQuery(trafficBuilder.build());
1262
1263         assertTrue(LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer()) instanceof LcafTrafficEngineeringAddress);
1264
1265         LcafTrafficEngineeringAddress receivedAddress = (LcafTrafficEngineeringAddress) LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0)
1266                 .getLispAddressContainer());
1267
1268         ReencapHop receivedHop1 = receivedAddress.getHops().get(0);
1269         ReencapHop receivedHop2 = receivedAddress.getHops().get(1);
1270
1271         assertEquals(true, hops1.isLookup());
1272         assertEquals(false, hops1.isRLOCProbe());
1273         assertEquals(true, hops1.isStrict());
1274
1275         assertEquals(false, hops2.isLookup());
1276         assertEquals(true, hops2.isRLOCProbe());
1277         assertEquals(false, hops2.isStrict());
1278
1279         assertTrue(receivedHop1.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4);
1280         assertTrue(receivedHop2.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac);
1281
1282         assertEquals(ipString, ((LispIpv4Address) receivedHop1.getHop().getPrimitiveAddress()).getIpv4Address().getValue());
1283         assertEquals(macString, ((LispMacAddress) receivedHop2.getHop().getPrimitiveAddress()).getMacAddress().getValue());
1284     }
1285
1286     public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1287         cleanUP();
1288         String ipString = "1.2.3.4";
1289         short protocol = 1;
1290         int ipTOs = 2;
1291         int localPort = 3;
1292         int remotePort = 4;
1293
1294         LcafApplicationDataAddrBuilder builder = new LcafApplicationDataAddrBuilder();
1295         builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode());
1296         builder.setIpTos(ipTOs);
1297         builder.setProtocol(protocol);
1298         builder.setLocalPort(new PortNumber(localPort));
1299         builder.setRemotePort(new PortNumber(remotePort));
1300         builder.setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder()
1301                 .setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1302
1303         LcafApplicationDataAddress addressToSend = builder.build();
1304
1305         MapReply reply = registerAddressAndQuery(addressToSend);
1306
1307         LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1308
1309         assertTrue(receivedAddress instanceof LcafApplicationDataAddress);
1310
1311         LcafApplicationDataAddress receivedApplicationDataAddress = (LcafApplicationDataAddress) receivedAddress;
1312         assertEquals(protocol, receivedApplicationDataAddress.getProtocol().intValue());
1313         assertEquals(ipTOs, receivedApplicationDataAddress.getIpTos().intValue());
1314         assertEquals(localPort, receivedApplicationDataAddress.getLocalPort().getValue().intValue());
1315         assertEquals(remotePort, receivedApplicationDataAddress.getRemotePort().getValue().intValue());
1316
1317         LispIpv4Address ipAddressReceived = (LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(receivedApplicationDataAddress.getAddress().getPrimitiveAddress());
1318         assertEquals(ipString, ipAddressReceived.getIpv4Address().getValue());
1319     }
1320
1321     // ------------------- TimeOut Tests -----------
1322
1323     public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1324         cleanUP();
1325         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1326         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1327         mapRequestBuilder.setNonce((long) 4);
1328         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1329                 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1330         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1331         mapRequestBuilder.getEidRecord().add(
1332                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1333         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1334         mapRequestBuilder.getItrRloc().add(
1335                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1336         sendMapRequest(mapRequestBuilder.build());
1337         MapReply mapReply = receiveMapReply();
1338         assertEquals(4, mapReply.getNonce().longValue());
1339         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1340         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1341         mapRegisterbuilder.setWantMapNotify(true);
1342         mapRegisterbuilder.setNonce((long) 8);
1343         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1344         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1345         etlrBuilder.setMaskLength((short) 32);
1346         etlrBuilder.setRecordTtl(254);
1347         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1348         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
1349         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1350         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1351         mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1352         mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1353         sendMapRegister(mapRegisterbuilder.build());
1354         MapNotify mapNotify = receiveMapNotify();
1355         assertEquals(8, mapNotify.getNonce().longValue());
1356         sendMapRequest(mapRequestBuilder.build());
1357         mapReply = receiveMapReply();
1358         assertEquals(4, mapReply.getNonce().longValue());
1359         assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1360                 .getLispAddressContainer());
1361         causeEntryToBeCleaned();
1362         sendMapRequest(mapRequestBuilder.build());
1363         mapReply = receiveMapReply();
1364         assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1365     }
1366
1367     public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1368         cleanUP();
1369         LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1370         MapRequest mapRequest = createMapRequest(eid);
1371
1372         testTTLBeforeRegister(mapRequest);
1373
1374         registerForTTL(eid);
1375
1376         testTTLAfterRegister(mapRequest);
1377
1378         causeEntryToBeCleaned();
1379         testTTLAfterClean(mapRequest);
1380
1381         northboundAddKey();
1382         testTTLAfterAutherize(mapRequest);
1383
1384     }
1385
1386     private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1387         MapReply mapReply;
1388         sendMapRequest(mapRequest);
1389         mapReply = receiveMapReply();
1390         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1391     }
1392
1393     private void causeEntryToBeCleaned() {
1394         clusterService.setTimeUnit(TimeUnit.NANOSECONDS);
1395         clusterService.cleanOld();
1396     }
1397
1398     private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1399         MapReply mapReply;
1400         sendMapRequest(mapRequest);
1401         mapReply = receiveMapReply();
1402         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1403                 .getLispAddressContainer());
1404         assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1405     }
1406
1407     private void registerForTTL(LispIpv4Address eid) throws SocketTimeoutException {
1408         MapRegister mapRegister = createMapRegister(eid);
1409         sendMapRegister(mapRegister);
1410         assertMapNotifyRecieved();
1411     }
1412
1413     private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1414         MapReply mapReply;
1415         sendMapRequest(mapRequest);
1416         mapReply = receiveMapReply();
1417         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1418     }
1419
1420     private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1421         MapReply mapReply;
1422         sendMapRequest(mapRequest);
1423         mapReply = receiveMapReply();
1424         assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1425     }
1426
1427     private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1428         assertEquals(expectedTTL, mapReply.getEidToLocatorRecord().get(0).getRecordTtl().intValue());
1429         assertEquals(expectedAction, mapReply.getEidToLocatorRecord().get(0).getAction());
1430     }
1431
1432     private MapRegister createMapRegister(LispAFIAddress eid, LispAFIAddress rloc) {
1433         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1434         mapRegisterbuilder.setWantMapNotify(true);
1435         mapRegisterbuilder.setNonce((long) 8);
1436         mapRegisterbuilder.setKeyId((short) 0);
1437         EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1438         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1439         etlrBuilder.setMaskLength((short) 24);
1440         etlrBuilder.setRecordTtl(254);
1441         etlrBuilder.setAuthoritative(false);
1442         etlrBuilder.setAction(Action.NoAction);
1443         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1444         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
1445         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1446         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1447         mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1448         mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1449         MapRegister mapRegister = mapRegisterbuilder.build();
1450         return mapRegister;
1451     }
1452
1453     private MapRegister createMapRegister(LispIpv4Address eid) {
1454         return createMapRegister(eid, LispAFIConvertor.asIPAfiAddress("4.3.2.1"));
1455     }
1456
1457     private MapRequest createMapRequest(LispAFIAddress eid) {
1458         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1459         mapRequestBuilder.setNonce((long) 4);
1460         mapRequestBuilder.setPitr(false);
1461         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1462                 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1463         mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1464         mapRequestBuilder.getEidRecord().add(
1465                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1466         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1467         mapRequestBuilder.getItrRloc().add(
1468                 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1469         MapRequest mr = mapRequestBuilder.build();
1470         return mr;
1471     }
1472
1473     public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1474         cleanUP();
1475         String rloc = "127.0.0.3";
1476         int port = LispMessage.PORT_NUM;
1477         LispAFIAddress ipRloc = LispAFIConvertor.asIPAfiAddress(rloc);
1478         sendProxyMapRequest(rloc, port, ipRloc);
1479
1480     }
1481
1482     public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1483         cleanUP();
1484         String rloc = "127.0.0.3";
1485         int port = 4350;
1486         LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1487                 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1488                 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1489                 .setAddress(
1490                         new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1491                                 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1492         LOG.info("testNonProxyOtherPort:" + adLcaf.toString());
1493         sendProxyMapRequest(rloc, port, adLcaf);
1494
1495     }
1496
1497     public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
1498         cleanUP();
1499         configLispPlugin.shouldListenOnXtrPort(true);
1500         notificationCalled = false;
1501         final String eid = "10.10.10.10";
1502         String rloc = "127.0.0.3";
1503         int port = LispMessage.XTR_PORT_NUM;
1504         LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1505                 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1506                 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1507                 .setAddress(
1508                         new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1509                                 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1510         final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1511         ((LispMappingService) lms).registerNotificationListener(XtrRequestMapping.class, new NotificationListener<XtrRequestMapping>() {
1512
1513             @Override
1514             public void onNotification(XtrRequestMapping notification) {
1515                 assertEquals(((LispIpv4Address) mapRequest.getEidRecord().get(0).getLispAddressContainer().getAddress()).getIpv4Address().getValue(),
1516                         eid);
1517                 notificationCalled = true;
1518                 LOG.warn("notification arrived");
1519             }
1520         });
1521         sendMapRequest(mapRequest, port);
1522         for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
1523             if (notificationCalled) {
1524                 return;
1525             } else {
1526                 LOG.warn("notification hasn't arrived, sleeping...");
1527                 Thread.sleep(500);
1528             }
1529         }
1530
1531         fail("Notification hasn't arrived");
1532
1533     }
1534
1535     private void sendProxyMapRequest(String rloc, int port, LispAFIAddress adLcaf) throws SocketTimeoutException, SocketException {
1536         String eid = "10.1.0.1";
1537         MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1538         sendMapRequest(mapRequest);
1539         DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
1540         MapRequest recievedMapRequest = receiveMapRequest(nonProxySocket);
1541         assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
1542         assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
1543         assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
1544         assertEquals(mapRequest.getEidRecord(), recievedMapRequest.getEidRecord());
1545         nonProxySocket.close();
1546     }
1547
1548     private MapRequest createNonProxyMapRequest(String eid, LispAFIAddress adLcaf) throws SocketTimeoutException {
1549         MapRegister mr = createMapRegister(LispAFIConvertor.asIPAfiAddress(eid));
1550         LocatorRecord record = new LocatorRecordBuilder(mr.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)).setLispAddressContainer(
1551                 LispAFIConvertor.toContainer(adLcaf)).build();
1552         mr.getEidToLocatorRecord().get(0).getLocatorRecord().set(0, record);
1553         sendMapRegister(mr);
1554         assertMapNotifyRecieved();
1555         MapRequest mapRequest = createMapRequest(LispAFIConvertor.asIPAfiAddress(eid));
1556         MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
1557         builder.setPitr(true);
1558         mapRequest = builder.build();
1559         return mapRequest;
1560     }
1561
1562     private void assertMapNotifyRecieved() throws SocketTimeoutException {
1563         receiveMapNotify();
1564     }
1565
1566     private MapReply receiveMapReply() throws SocketTimeoutException {
1567         return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1568     }
1569
1570     private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
1571         return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(datagramSocket, 30000).getData()));
1572     }
1573
1574     private MapNotify receiveMapNotify() throws SocketTimeoutException {
1575         return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1576     }
1577
1578     private void sendMapRequest(MapRequest mapRequest) {
1579         sendMapRequest(mapRequest, LispMessage.PORT_NUM);
1580     }
1581
1582     private void sendMapRequest(MapRequest mapRequest, int port) {
1583         sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
1584     }
1585
1586     private void sendMapRegister(MapRegister mapRegister) {
1587         sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
1588     }
1589
1590     private void sendPacket(byte[] bytesToSend) {
1591         sendPacket(bytesToSend, LispMessage.PORT_NUM);
1592     }
1593
1594     private void sendPacket(byte[] bytesToSend, int port) {
1595         try {
1596             DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
1597             initPacketAddress(packet, port);
1598             LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
1599             socket.send(packet);
1600         } catch (Throwable t) {
1601             fail();
1602         }
1603     }
1604
1605     private DatagramPacket receivePacket() throws SocketTimeoutException {
1606         return receivePacket(6000);
1607     }
1608
1609     private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
1610         return receivePacket(socket, timeout);
1611     }
1612
1613     private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
1614         try {
1615             byte[] buffer = new byte[4096];
1616             DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
1617             LOG.trace("Waiting for packet from socket...");
1618             receivedSocket.setSoTimeout(timeout);
1619             receivedSocket.receive(receivePacket);
1620             LOG.trace("Recieved packet from socket!");
1621             return receivePacket;
1622         } catch (SocketTimeoutException ste) {
1623             throw ste;
1624         } catch (Throwable t) {
1625             fail();
1626             return null;
1627         }
1628     }
1629
1630     private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
1631         packet.setAddress(InetAddress.getByName(lispBindAddress));
1632         packet.setPort(port);
1633     }
1634
1635     private DatagramSocket initSocket(DatagramSocket socket, int port) {
1636         try {
1637             socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
1638         } catch (SocketException e) {
1639             e.printStackTrace();
1640             fail();
1641         }
1642         return socket;
1643     }
1644
1645     private byte[] extractWSUdpByteArray(String wiresharkHex) {
1646         final int HEADER_LEN = 42;
1647         byte[] res = new byte[1000];
1648         String[] split = wiresharkHex.split(" ");
1649         int counter = 0;
1650         for (String cur : split) {
1651             cur = cur.trim();
1652             if (cur.length() == 2) {
1653                 ++counter;
1654                 if (counter > HEADER_LEN) {
1655                     res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
1656                 }
1657
1658             }
1659         }
1660         return Arrays.copyOf(res, counter - HEADER_LEN);
1661     }
1662
1663     private String stateToString(int state) {
1664         switch (state) {
1665         case Bundle.ACTIVE:
1666             return "ACTIVE";
1667         case Bundle.INSTALLED:
1668             return "INSTALLED";
1669         case Bundle.RESOLVED:
1670             return "RESOLVED";
1671         case Bundle.UNINSTALLED:
1672             return "UNINSTALLED";
1673         default:
1674             return "Not CONVERTED";
1675         }
1676     }
1677
1678     @SuppressWarnings({ "rawtypes", "unchecked" })
1679     private void areWeReady() throws InvalidSyntaxException {
1680         assertNotNull(bc);
1681         boolean debugit = false;
1682         Bundle b[] = bc.getBundles();
1683         for (Bundle element : b) {
1684             int state = element.getState();
1685             LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v" + element.getVersion() + ", state:"
1686                     + stateToString(state));
1687             if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
1688                 LOG.trace("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
1689
1690                 // try {
1691                 // String host = element.getHeaders().get("FRAGMENT-HOST");
1692                 // if (host != null) {
1693                 // LOG.warn("Bundle " + element.getSymbolicName() +
1694                 // " is a fragment which is part of: " + host);
1695                 // LOG.warn("Required imports are: " +
1696                 // element.getHeaders().get("IMPORT-PACKAGE"));
1697                 // } else {
1698                 // element.start();
1699                 // }
1700                 // } catch (BundleException e) {
1701                 // LOG.error("BundleException:", e);
1702                 // fail();
1703                 // }
1704
1705                 debugit = true;
1706
1707             }
1708         }
1709         if (debugit) {
1710             LOG.warn(("Do some debugging because some bundle is unresolved"));
1711         }
1712         // assertNotNull(broker);
1713
1714         int retry = 0;
1715         ServiceReference r = null;
1716         while (this.lms == null && retry < MAX_SERVICE_LOAD_RETRIES) {
1717
1718             r = bc.getServiceReference(IFlowMapping.class.getName());
1719             // r.getPropertyKeys();
1720             if (r != null) {
1721                 this.lms = (IFlowMapping) bc.getService(r);
1722             } else {
1723                 try {
1724                     Thread.sleep(1000);
1725                 } catch (InterruptedException e) {
1726                 }
1727             }
1728             retry += 1;
1729         }
1730
1731         assertNotNull(IFlowMapping.class.getName() + " service wasn't found in bundle context ", this.lms);
1732
1733         r = bc.getServiceReference(ILispDAO.class.getName());
1734         if (r != null) {
1735             this.clusterService = (ClusterDAOService) bc.getService(r);
1736         }
1737
1738         assertNotNull(ILispDAO.class.getName() + " service wasn't found in bundle context ", this.clusterService);
1739         r = bc.getServiceReference(IConfigLispSouthboundPlugin.class.getName());
1740         if (r != null) {
1741             this.configLispPlugin = (IConfigLispSouthboundPlugin) bc.getService(r);
1742         }
1743
1744         assertNotNull(IConfigLispSouthboundPlugin.class.getName() + " service wasn't found in bundle context ", this.configLispPlugin);
1745         configLispPlugin.setLispAddress(lispBindAddress);
1746
1747         // Uncomment this code to Know which services were actually loaded to
1748         // BundleContext
1749         /*
1750          * for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
1751          * LOG.trace(sr.getBundle().getSymbolicName());
1752          * LOG.trace(sr.toString()); }
1753          */
1754         try {
1755             Thread.sleep(1000);
1756         } catch (InterruptedException e) {
1757         }
1758     }
1759
1760     private void cleanUP() {
1761         after();
1762         lms.clean();
1763         configLispPlugin.shouldListenOnXtrPort(false);
1764         socket = initSocket(socket, LispMessage.PORT_NUM);
1765
1766     }
1767
1768 }