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

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