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