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