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