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

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