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

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