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