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

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