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

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