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

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