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