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