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.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A;
  15 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A_SB;
  16 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B;
  17 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B_SB;
  18 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C;
  19 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_RLOC_10;
  20 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_SB;
  21 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_100_1_SB;
  22 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_50_2_SB;
  23 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D4;
  24 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D5;
  25 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_DELETE_SB;
  26 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_100_1_SB;
  27 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_50_2_SB;
  28 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_E_SB;
  29 import static org.ops4j.pax.exam.CoreOptions.composite;
  30 import static org.ops4j.pax.exam.CoreOptions.maven;
  31 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
  32
  33 import java.io.IOException;
  34 import java.net.DatagramPacket;
  35 import java.net.DatagramSocket;
  36 import java.net.InetAddress;
  37 import java.net.InetSocketAddress;
  38 import java.net.SocketException;
  39 import java.net.SocketTimeoutException;
  40 import java.net.UnknownHostException;
  41 import java.nio.ByteBuffer;
  42 import java.util.ArrayList;
  43 import java.util.Arrays;
  44 import java.util.List;
  45
  46 import javax.inject.Inject;
  47
  48 //import org.codehaus.jettison.json.JSONException;
  49 //import org.codehaus.jettison.json.JSONObject;
  50 //import org.codehaus.jettison.json.JSONTokener;
  51 import org.junit.After;
  52 import org.junit.Assert;
  53 import org.junit.Before;
  54 import org.junit.Test;
  55 import org.junit.runner.RunWith;
  56 import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
  57 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  58 import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
  59 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
  60 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
  61 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
  62 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  63 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
  64 import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
  65 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
  66 import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
  67 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
  68 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.OdlLispProtoListener;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItem;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkeyBuilder;
  99 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
 100 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
 101 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
 102 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
 103 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AfiListLcaf;
 104 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ApplicationDataLcaf;
 105 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
 106 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
 107 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
 108 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.KeyValueAddressLcaf;
 109 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
 110 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
 111 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SourceDestKeyLcaf;
 112 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.AfiList;
 113 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationData;
 114 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
 115 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix;
 116 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder;
 117 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.KeyValueAddress;
 118 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
 119 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
 120 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.afi.list.AfiListBuilder;
 121 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.application.data.ApplicationDataBuilder;
 122 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.ExplicitLocatorPathBuilder;
 123 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
 124 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop.LrsBits;
 125 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.HopBuilder;
 126 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
 127 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
 128 import org.ops4j.pax.exam.Option;
 129 import org.ops4j.pax.exam.junit.PaxExam;
 130 import org.ops4j.pax.exam.util.Filter;
 131 import org.ops4j.pax.exam.karaf.options.LogLevelOption.LogLevel;
 132 import org.ops4j.pax.exam.options.MavenUrlReference;
 133 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
 134 import org.ops4j.pax.exam.spi.reactors.PerClass;
 135 import org.osgi.framework.Bundle;
 136 import org.osgi.framework.BundleContext;
 137 import org.osgi.framework.InvalidSyntaxException;
 138 import org.slf4j.Logger;
 139 import org.slf4j.LoggerFactory;
 140
 141 @RunWith(PaxExam.class)
 142 @ExamReactorStrategy(PerClass.class)
 143 public class MappingServiceIntegrationTest extends AbstractMdsalTestBase {
 144     private static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
 145
 146     private byte[] mapRequestPacket;
 147     private byte[] mapRegisterPacketWithNotify;
 148     private byte[] mapRegisterPacketWithoutNotify;
 149     String lispBindAddress = "127.0.0.1";
 150     static final String ourAddress = "127.0.0.2";
 151     private Rloc locatorEid;
 152     private DatagramSocket socket;
 153     private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
 154
 155     public static final String ODL = "org.opendaylight.controller";
 156     public static final String YANG = "org.opendaylight.yangtools";
 157     public static final String JERSEY = "com.sun.jersey";
 158     private static final int MAX_NOTIFICATION_RETRYS = 20;
 159     private static final MappingAuthkey NULL_AUTH_KEY = new MappingAuthkeyBuilder().setKeyType(0).build();
 160     private static final MappingAuthkey AUTH_KEY =
 161             new MappingAuthkeyBuilder().setKeyType(1).setKeyString("password").build();
 162
 163     @Override
 164     public String getModuleName() {
 165         return "mappingservice-impl";
 166     }
 167
 168     @Override
 169     public String getInstanceName() {
 170         return "mappingservice-default";
 171     }
 172
 173     // This is temporary, since the properties in the pom file are not picked up
 174     @Override
 175     public String getKarafDistro() {
 176         return maven()
 177                 .groupId("org.opendaylight.lispflowmapping")
 178                 .artifactId("distribution-karaf")
 179                 .versionAsInProject()
 180                 .type("zip")
 181                 .getURL();
 182     }
 183
 184     @Override
 185     public MavenUrlReference getFeatureRepo() {
 186         return maven()
 187                 .groupId("org.opendaylight.lispflowmapping")
 188                 .artifactId("features-lispflowmapping")
 189                 .classifier("features")
 190                 .type("xml")
 191                 .versionAsInProject();
 192     }
 193
 194     @Override
 195     public String getFeatureName() {
 196         return "odl-lispflowmapping-msmr";
 197     }
 198
 199     @Override
 200     public Option getLoggingOption() {
 201         Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
 202                 "log4j.logger.org.opendaylight.lispflowmapping",
 203                 LogLevel.DEBUG.name());
 204         option = composite(option, super.getLoggingOption());
 205         return option;
 206     }
 207
 208     @Test
 209     public void testLispFlowMappingFeatureLoad() {
 210         Assert.assertTrue(true);
 211     }
 212
 213     @After
 214     public void after() {
 215         if (socket != null) {
 216             socket.close();
 217         }
 218 //        if (connection != null) {
 219 //            connection.disconnect();
 220 //        }
 221     }
 222
 223     @Before
 224     public void before() throws Exception {
 225         areWeReady();
 226         mapService.setLookupPolicy(ConfigIni.NB_FIRST);
 227         mapService.setMappingOverwrite(true);
 228
 229         locatorEid = LispAddressUtil.asIpv4Rloc("4.3.2.1");
 230         socket = initSocket(socket, LispMessage.PORT_NUM);
 231
 232         // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
 233         // LISP(Type = 8 - Encapsulated)
 234         // IP: 192.168.136.10 -> 153.16.254.1
 235         // UDP: 56756
 236         // LISP(Type = 1 Map-Request
 237         // Record Count: 1
 238         // ITR-RLOC count: 0
 239         // Source EID AFI: 1
 240         // Source EID 1.2.3.4
 241         // Nonce: 0x3d8d2acd39c8d608
 242         // ITR-RLOC AFI=1 Address=192.168.136.10
 243         // Record 1: 153.16.254.1/32
 244         mapRequestPacket = extractWSUdpByteArray(new String("0000   00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
 245                 + "0010   00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
 246                 + "0020   00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
 247                 + "0030   00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
 248                 + "0040   fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
 249                 + "0050   2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
 250                 + "0060   00 01 99 10 fe 01"));
 251
 252         // IP: 192.168.136.10 -> 128.223.156.35
 253         // UDP: 49289 -> 4342
 254         // LISP(Type = 3 Map-Register, P=1, M=1
 255         // Record Counter: 1
 256         // Nonce: 0
 257         // Key ID: 0x0001
 258         // AuthDataLength: 20 Data:
 259         // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
 260         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 261         // No-Action
 262         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 263         // Priority/Weight: 1/100, Multicast Priority/Weight:
 264         // 255/0
 265         //
 266
 267         mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String(
 268                   "0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 269                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 270                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 271                 + "0030   00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
 272                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 273                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 274                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 275
 276         // IP: 192.168.136.10 -> 128.223.156.35
 277         // UDP: 49289 -> 4342
 278         // LISP(Type = 3 Map-Register, P=1, M=1
 279         // Record Counter: 1
 280         // Nonce: 7
 281         // Key ID: 0x0000 NO AUTHENTICATION!!
 282         // AuthDataLength: 00 Data:
 283         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 284         // No-Action
 285         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 286         // Priority/Weight: 1/100, Multicast Priority/Weight:
 287         // 255/0
 288         //
 289
 290         mapRegisterPacketWithNotify = extractWSUdpByteArray(new String(
 291                   "0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 292                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 293                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 294                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 295                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 296                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 297                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 298
 299         // IP: 192.168.136.10 -> 128.223.156.35
 300         // UDP: 49289 -> 4342
 301         // LISP(Type = 3 Map-Register, P=1, M=1
 302         // Record Counter: 1
 303         // Nonce: 7
 304         // Key ID: 0x0000 NO AUTHENTICATION!!
 305         // AuthDataLength: 00 Data:
 306         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 307         // No-Action
 308         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 309         // Priority/Weight: 1/100, Multicast Priority/Weight:
 310         // 255/0
 311         //
 312
 313         mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String(
 314                   "0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 315                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 316                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
 317                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 318                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 319                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 320                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 321     }
 322
 323     @Inject
 324     private BundleContext bc;
 325     //private HttpURLConnection connection;
 326     protected static boolean notificationCalled;
 327
 328     @Inject @Filter(timeout=60000)
 329     private IFlowMapping lms;
 330
 331     @Inject @Filter(timeout=60000)
 332     private IMappingService mapService;
 333
 334     @Inject @Filter(timeout=10000)
 335     private IConfigLispSouthboundPlugin configLispPlugin;
 336
 337     @Test
 338     public void testSimpleUsage() throws Exception {
 339         mapRequestSimple();
 340         mapRegisterWithMapNotify();
 341         mapRegisterWithMapNotifyAndMapRequest();
 342         registerAndQuery__MAC();
 343         mapRequestMapRegisterAndMapRequest();
 344         mapRegisterWithAuthenticationWithoutConfiguringAKey();
 345         mapRegisterWithoutMapNotify();
 346     }
 347
 348     @Test
 349     public void testLCAFs() throws Exception {
 350         //registerAndQuery__SrcDestLCAF();
 351         //registerAndQuery__SrcDestLCAFOverlap();
 352         //registerAndQuery__KeyValueLCAF();
 353         //registerAndQuery__ListLCAF();
 354         //registerAndQuery__ApplicationData();
 355         //registerAndQuery__TrafficEngineering();
 356         //registerAndQuery__SegmentLCAF();
 357     }
 358
 359     @Test
 360     public void testMask() throws Exception {
 361         //testPasswordExactMatch();                     TODO commented because it needs NB
 362         //testPasswordMaskMatch();                      TODO commented because it needs NB
 363         eidPrefixLookupIPv4();
 364         eidPrefixLookupIPv6();
 365     }
 366 /*
 367     @Test
 368     public void testNorthbound() throws Exception {
 369         northboundAddKey();
 370         northboundAddMapping();
 371         northboundDeleteMapping();
 372         northboundRetrieveKey();
 373         northboundRetrieveMapping();
 374         northboundRetrieveSourceDestKey();
 375         northboundRetrieveSourceDestMapping();
 376     }
 377 */
 378     @Test
 379     public void testOverWriting() throws Exception {
 380         //testMapRegisterDosntOverwritesOtherSubKeys(); TODO weird failure, needs debug
 381
 382         // TODO: remove, we don't support overwrite flag any longer and RLOCs are not saved as independent RLOC groups
 383         // testMapRegisterOverwritesSameSubkey();
 384         // testMapRegisterOverwritesNoSubkey();
 385         // testMapRegisterDoesntOverwritesNoSubkey();
 386     }
 387
 388     @Test
 389     public void testTimeOuts() throws Exception {
 390         mapRequestMapRegisterAndMapRequestTestTimeout();
 391         //mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse();   TODO commented because it needs NB
 392     }
 393
 394 //    @Test
 395 //    public void testNonProxy() throws Throwable {
 396 //        testSimpleNonProxy();
 397 //        testNonProxyOtherPort();
 398 //        testRecievingNonProxyOnXtrPort();
 399 //    }
 400
 401     @Test
 402     public void testSmr() throws Exception {
 403         registerQueryRegisterWithSmr();
 404     }
 405
 406
 407     /**
 408      * TEST SCENARIO A
 409      */
 410     @Test
 411     public void testMultiSiteScenarioA() throws IOException {
 412         cleanUP();
 413
 414         final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
 415         multiSiteScenario.setCommonAuthentication();
 416
 417         restartSocket();
 418         final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
 419
 420         //TEST CASE 1
 421         multiSiteScenario.storeSouthboundMappings(SITE_A, SITE_B, SITE_C, SITE_D4, SITE_D5);
 422         multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
 423         multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
 424         sleepForSeconds(2);
 425         multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
 426         multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
 427         multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
 428
 429         //TEST CASE 2
 430         //following action should trigger generatting of SMR messages:
 431         // 1) 192.0.2.5/32
 432         // 2) 192.0.1.1/32
 433         multiSiteScenario.storeNorthMappingSrcDst(SITE_A, SITE_C);
 434         sleepForSeconds(2);
 435         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1));
 436         multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
 437         multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
 438         multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
 439
 440         //TEST CASE 3
 441         // following action should trigger generatting of SMR messages:
 442         // 1) 192.0.2.5/32
 443         // 2) 192.0.1.1/32
 444         // 3) 192.0.1.5/32
 445         // 4) 192.0.4.5/32
 446         multiSiteScenario.deleteNorthMappingNegative(SITE_C);
 447         sleepForSeconds(2);
 448         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1), SITE_A
 449                         .getHost(5),
 450                 SITE_D4.getHost(5));
 451         multiSiteScenario.assertPingWorks(SITE_D4, 5, SITE_C, 4);
 452
 453         //TEST CASE 4
 454         // following action should trigger generatting of SMR messages:
 455         // 1) 192.0.4.5/32
 456         multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C_RLOC_10);
 457         sleepForSeconds(2);
 458         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5));
 459         //way of testing ping - get RLOC for mapping src-dst and compare it with awaited value doesn't test
 460         //that ping won't be successfull
 461         multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
 462
 463         //TEST CASE 5
 464         // following action should trigger generatting of SMR messages:
 465         // 1) 192.0.4.5/32
 466         // 2) 192.0.2.5/32
 467         multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
 468         sleepForSeconds(2);
 469         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5), SITE_B.getHost(5));
 470         multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
 471
 472         //TEST CASE 6
 473         multiSiteScenario.assertPingFails(SITE_D5, 5, SITE_C, 3);
 474
 475         //TEST CASE 7
 476         multiSiteScenario.deleteNorthMapingSrcDst(SITE_A, SITE_C);
 477         sleepForSeconds(2);
 478         // following action should trigger generatting of SMR messages:
 479         // 1) 192.0.4.5/32
 480         // 2) 192.0.2.5/32
 481         // 3) 192.0.5.5/32
 482         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
 483                 SITE_B.getHost(5));
 484
 485         // following action should trigger generatting of SMR messages:
 486         // 1) 192.0.4.5/32
 487         // 2) 192.0.2.5/32
 488         // 3) 192.0.5.5/32
 489         multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
 490         sleepForSeconds(2);
 491         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
 492                 SITE_B.getHost(5));
 493
 494         multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
 495         multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
 496         multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
 497
 498         //TEST CASE 8
 499         // following action should trigger generatting of SMR messages:
 500         // 1) 192.0.4.5/32
 501         // 2) 192.0.2.5/32
 502         // 3) 192.0.5.5/32
 503         // 4) 192.0.1.1/32
 504         multiSiteScenario.deleteNorthMapingSrcDst(SITE_B, SITE_C);
 505         sleepForSeconds(2);
 506         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
 507                 SITE_B.getHost(5),
 508                 SITE_A.getHost(1));
 509         multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
 510         multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
 511         multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
 512
 513         //TEST CASE 9
 514         // following action should trigger generatting of SMR messages:
 515         // 1) 192.0.4.5/32
 516         // 2) 192.0.2.5/32
 517         // 3) 192.0.5.5/32
 518         // 4) 192.0.1.1/32
 519         multiSiteScenario.deleteNorthMappingNegative(SITE_C);
 520         sleepForSeconds(2);
 521         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
 522                 SITE_B.getHost(5),
 523                 SITE_A.getHost(1));
 524         multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
 525         multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
 526         multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
 527
 528         socketReader.stopReading();
 529
 530     }
 531
 532     /**
 533      * TEST SCENARIO B
 534      */
 535     @Test
 536     public void testMultiSiteScenarioB() throws IOException {
 537         cleanUP();
 538
 539         final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
 540         multiSiteScenario.setCommonAuthentication();
 541
 542         restartSocket();
 543         final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
 544
 545         mapService.setLookupPolicy(ConfigIni.NB_AND_SB);
 546         mapService.setMappingOverwrite(false);
 547
 548         //TEST CASE 1
 549         multiSiteScenario.storeSouthboundMappings(SITE_A_SB, SITE_B_SB, SITE_C_WP_100_1_SB, SITE_D_WP_100_1_SB,
 550                 SITE_E_SB);
 551         multiSiteScenario.storeNorthMappingIpPrefix(SITE_A_SB);
 552         multiSiteScenario.storeNorthMappingIpPrefix(SITE_B_SB);
 553         multiSiteScenario.storeNorthMappingIpPrefix(SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
 554         sleepForSeconds(2);
 555         multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
 556         multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
 557
 558         //TEST CASE 2
 559         // following action should trigger generatting of SMR messages:
 560         // 1) 192.0.2.5/32
 561         // 2) 192.0.1.5/32
 562         multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
 563         sleepForSeconds(2);
 564         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
 565
 566         // following action should trigger generatting of SMR messages:
 567         // 1) 192.0.2.5/32
 568         // 2) 192.0.1.5/32
 569         multiSiteScenario.storeNorthMappingNegative(SITE_C_SB, Action.Drop);
 570         sleepForSeconds(2);
 571         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
 572
 573         multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
 574         multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_SB, 4);
 575
 576
 577         //TEST CASE 3
 578         // following action should trigger generatting of SMR messages:
 579         // 1) 192.0.2.5/32
 580         // 2) 192.0.1.5/32
 581         multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
 582         sleepForSeconds(2);
 583         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
 584         multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4);
 585
 586         //TEST CASE 4
 587         multiSiteScenario.storeNorthMappingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
 588         sleepForSeconds(2);
 589         // following action should trigger generatting of SMR messages:
 590         // 1) 192.0.2.5/32
 591         // 2) 192.0.1.5/32
 592         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
 593         multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
 594
 595         //TEST CASE 5
 596         multiSiteScenario.deleteSouthboundMappings(SITE_D_DELETE_SB);
 597         sleepForSeconds(2);
 598         // following action should trigger generatting of SMR messages:
 599         // 1) 192.0.2.5/32
 600         // 2) 192.0.1.5/32
 601         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
 602
 603         multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
 604
 605         //TEST CASE 6
 606         multiSiteScenario.deleteNorthMapingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
 607         sleepForSeconds(2);
 608         // following action should trigger generatting of SMR messages:
 609         // 1) 192.0.2.5/32
 610         // 2) 192.0.1.5/32
 611         multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
 612
 613         multiSiteScenario.deleteNorthMapingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB);
 614         sleepForSeconds(2);
 615         multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
 616
 617         socketReader.stopReading();
 618
 619     }
 620
 621     // ------------------------------- Simple Tests ---------------------------
 622
 623     public void mapRequestSimple() throws SocketTimeoutException {
 624         cleanUP();
 625
 626         // This Map-Request is sent from a source port different from 4342
 627         // We close and bind the socket on the correct port
 628         if (socket != null) {
 629             socket.close();
 630         }
 631         socket = initSocket(socket, 56756);
 632
 633         sendPacket(mapRequestPacket);
 634         ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
 635         MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
 636         assertEquals(4435248268955932168L, reply.getNonce().longValue());
 637
 638     }
 639
 640     public void mapRegisterWithMapNotify() throws SocketTimeoutException {
 641         cleanUP();
 642         mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), NULL_AUTH_KEY);
 643         sleepForSeconds(1);
 644         sendPacket(mapRegisterPacketWithNotify);
 645         MapNotify reply = receiveMapNotify();
 646         assertEquals(7, reply.getNonce().longValue());
 647     }
 648
 649     public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
 650         cleanUP();
 651         Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
 652
 653         MapReply mapReply = registerAddressAndQuery(eid);
 654
 655         assertEquals(4, mapReply.getNonce().longValue());
 656         assertEquals(locatorEid, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
 657                 .getRloc());
 658
 659     }
 660
 661     public void registerAndQuery__MAC() throws SocketTimeoutException {
 662         cleanUP();
 663         String macAddress = "01:02:03:04:05:06";
 664
 665         MapReply reply = registerAddressAndQuery(LispAddressUtil.asMacEid(macAddress));
 666
 667         assertTrue(true);
 668         Eid addressFromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
 669         assertEquals(MacAfi.class, addressFromNetwork.getAddressType());
 670         String macAddressFromReply = ((Mac) addressFromNetwork.getAddress()).getMac().getValue();
 671
 672         assertEquals(macAddress, macAddressFromReply);
 673     }
 674
 675     public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
 676         cleanUP();
 677         Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
 678         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
 679         sleepForSeconds(1);
 680
 681         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 682         mapRequestBuilder.setNonce((long) 4);
 683         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
 684         mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
 685         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
 686         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
 687         mapRequestBuilder.getItrRloc().add(
 688                 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
 689         sendMapRequest(mapRequestBuilder.build());
 690         MapReply mapReply = receiveMapReply();
 691         assertEquals(4, mapReply.getNonce().longValue());
 692         assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
 693         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
 694         mapRegisterbuilder.setWantMapNotify(true);
 695         mapRegisterbuilder.setNonce((long) 8);
 696         MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
 697         etlrBuilder.setEid(eid);
 698         etlrBuilder.setRecordTtl(254);
 699         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
 700         recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
 701         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
 702         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
 703         mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
 704         mapRegisterbuilder.getMappingRecordItem().add(
 705                 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
 706         sendMapRegister(mapRegisterbuilder.build());
 707         MapNotify mapNotify = receiveMapNotify();
 708         assertEquals(8, mapNotify.getNonce().longValue());
 709         sleepForSeconds(1);
 710         sendMapRequest(mapRequestBuilder.build());
 711         mapReply = receiveMapReply();
 712         assertEquals(4, mapReply.getNonce().longValue());
 713         assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
 714                 .getLocatorRecord().get(0).getRloc());
 715
 716     }
 717
 718     public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
 719         cleanUP();
 720         Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
 721         SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
 722         Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
 723         SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
 724         Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
 725         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
 726         assertEquals(2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
 727         assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
 728                 .getRloc());
 729         assertEquals(rloc1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(1)
 730                 .getRloc());
 731     }
 732
 733     public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
 734         cleanUP();
 735         Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
 736         SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
 737         Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
 738         SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
 739         Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
 740         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
 741         assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
 742         assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
 743                 .getRloc());
 744     }
 745
 746     public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
 747         cleanUP();
 748         mapService.setMappingOverwrite(true);
 749         Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
 750         Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
 751         Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
 752         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
 753         assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
 754         assertEquals(rloc2Value, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
 755                 .getRloc());
 756     }
 757
 758     public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
 759         cleanUP();
 760         mapService.setMappingOverwrite(false);
 761         Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
 762         Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
 763         Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
 764         MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
 765         assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
 766         Rloc rloc1ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
 767                 .get(0).getRloc();
 768         Rloc rloc2ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
 769                 .get(1).getRloc();
 770         assertTrue((rloc1Value.equals(rloc1ReturnValueContainer) && rloc2Value.equals(rloc2ReturnValueContainer))
 771                 || (rloc1Value.equals(rloc2ReturnValueContainer) && rloc2Value.equals(rloc1ReturnValueContainer)));
 772     }
 773
 774     private MapReply sendMapRegisterTwiceWithDiffrentValues(Eid eid, Rloc rloc1, Rloc rloc2)
 775             throws SocketTimeoutException {
 776         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
 777         sleepForSeconds(1);
 778         MapRegister mb = createMapRegister(eid, rloc1);
 779         MapNotify mapNotify = lms.handleMapRegister(mb).getLeft();
 780         MapRequest mr = createMapRequest(eid);
 781         MapReply mapReply = lms.handleMapRequest(mr);
 782         assertEquals(mb.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc(),
 783                 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
 784         mb = createMapRegister(eid, rloc2);
 785         mapNotify = lms.handleMapRegister(mb).getLeft();
 786         assertEquals(8, mapNotify.getNonce().longValue());
 787         mr = createMapRequest(eid);
 788         sendMapRequest(mr);
 789         mapReply = lms.handleMapRequest(mr);
 790         return mapReply;
 791     }
 792
 793     public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
 794         cleanUP();
 795         sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
 796         try {
 797             receivePacket(3000);
 798             // If didn't timeout then fail:
 799             fail();
 800         } catch (SocketTimeoutException ste) {
 801         }
 802     }
 803
 804     public void mapRegisterWithoutMapNotify() {
 805         cleanUP();
 806         sendPacket(mapRegisterPacketWithoutNotify);
 807         try {
 808             receivePacket(3000);
 809             // If didn't timeout then fail:
 810             fail();
 811         } catch (SocketTimeoutException ste) {
 812         }
 813     }
 814
 815     public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
 816         cleanUP();
 817         lms.setShouldUseSmr(true);
 818         mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), NULL_AUTH_KEY);
 819         sleepForSeconds(1);
 820
 821         sendPacket(mapRegisterPacketWithNotify);
 822         receiveMapNotify();
 823
 824         sleepForSeconds(1);
 825         sendPacket(mapRequestPacket);
 826         sleepForSeconds(1);
 827
 828         mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
 829         sendPacket(mapRegisterPacketWithoutNotify);
 830
 831         ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
 832         MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
 833         assertTrue(smr.isSmr());
 834         Eid sourceEid = smr.getSourceEid().getEid();
 835         assertTrue(LispAddressUtil.asIpv4Eid("153.16.254.1").equals(sourceEid));
 836         Eid smrEid = smr.getEidItem().get(0).getEid();
 837         assertTrue(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32").equals(smrEid));
 838     }
 839
 840     // --------------------- Northbound Tests ---------------------------
 841 /*
 842     private void northboundAddKey() throws Exception {
 843         cleanUP();
 844         LispIpv4Address address = LispAddressUtil.asIPAfiAddress("1.2.3.4");
 845         int mask = 32;
 846         String pass = "asdf";
 847
 848         URL url = createPutURL("key");
 849         String authKeyJSON = createAuthKeyJSON(pass, address, mask);
 850         callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
 851
 852         String retrievedKey = lms.getAuthenticationKey(LispAddressUtil.toContainer(address), mask);
 853
 854         // Check stored password matches the one sent
 855         assertEquals(pass, retrievedKey);
 856
 857     }
 858
 859     private void northboundRetrieveSourceDestKey() throws Exception {
 860         cleanUP();
 861         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
 862                 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
 863                 .primitiveaddress.Ipv4) LispAddressUtil
 864                 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
 865         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
 866                 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
 867                 .primitiveaddress.Ipv4) LispAddressUtil
 868                 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
 869         int mask1 = 32;
 870         int mask2 = 32;
 871         LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
 872                 AddressFamilyNumberEnum.LCAF.getIanaCode())
 873                 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
 874                 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build())
 875                 .setSrcMaskLength((short) mask1)
 876                 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build())
 877                 .setDstMaskLength((short) mask2).build();
 878         String pass = "asdf";
 879
 880         lms.addAuthenticationKey(LispAddressUtil.toContainer(sourceDestAddress), mask1, pass);
 881
 882         // URL url = createGetKeyIPv4URL(address1, mask1);
 883         URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
 884                 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getSrcAddress()
 885                 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
 886                 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getDstAddress()
 887                 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
 888         String reply = callURL("GET", null, "application/json", null, url);
 889         JSONTokener jt = new JSONTokener(reply);
 890         JSONObject json = new JSONObject(jt);
 891
 892         // test that the password matches what was we expected.
 893         assertEquals(pass, json.get("key"));
 894
 895     }
 896
 897     private void northboundRetrieveKey() throws Exception {
 898         cleanUP();
 899         LispIpv4Address address = LispAddressUtil.asIPAfiAddress("10.0.0.1");
 900         int mask = 32;
 901         String pass = "asdf";
 902
 903         lms.addAuthenticationKey(LispAddressUtil.toContainer(address), mask, pass);
 904
 905         URL url = createGetKeyIPv4URL(address, mask);
 906         String reply = callURL("GET", null, "application/json", null, url);
 907         JSONTokener jt = new JSONTokener(reply);
 908         JSONObject json = new JSONObject(jt);
 909
 910         // test that the password matches what was we expected.
 911         assertEquals(pass, json.get("key"));
 912
 913     }
 914
 915     private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
 916         return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
 917                 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
 918     }
 919
 920     private void northboundAddMapping() throws Exception {
 921         cleanUP();
 922         String pass = "asdf";
 923         LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
 924         int mask = 32;
 925         LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
 926
 927         // NB add mapping always checks the key
 928         lms.addAuthenticationKey(LispAddressUtil.toContainer(eid), mask, pass);
 929
 930         URL url = createPutURL("mapping");
 931         String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
 932         callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
 933
 934         // Retrieve the RLOC from the database
 935         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
 936         mapRequestBuilder.setPitr(false);
 937         mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
 938         mapRequestBuilder.getEidItem().add(
 939                 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(
 940                 LispAddressUtil.toContainer(eid)).build());
 941         MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
 942
 943         LispIpv4Address retrievedRloc = (LispIpv4Address) LispAddressUtil.toAFI(
 944                 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
 945                 .getLispAddressContainer());
 946
 947         assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
 948
 949     }
 950
 951     private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
 952         String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ "
 953                 + "\"proxyMapReply\" : false, "
 954                 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : "
 955                 + "{ " + "\"ipAddress\" : \""
 956                 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "},"
 957                 + "\"mapVersion\" : 0,"
 958                 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ "
 959                 + "\"multicastPriority\" : 1,"
 960                 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\","
 961                 + "\"afi\" : "
 962                 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50,"
 963                 + "\"rlocProbed\" : false, "
 964                 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], "
 965                 + "\"recordTtl\" : 100" + "} " + "], "
 966                 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
 967
 968         return jsonString;
 969     }
 970
 971     private void northboundRetrieveMapping() throws Exception {
 972         cleanUP();
 973         LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
 974         int mask = 32;
 975         LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
 976         // Insert mapping in the database
 977         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
 978         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
 979         etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
 980         etlr.setMaskLength((short) mask);
 981         etlr.setRecordTtl(254);
 982         etlr.setAuthoritative(false);
 983         etlr.setAction(Action.NoAction);
 984         LocatorRecordBuilder record = new LocatorRecordBuilder();
 985         record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
 986         record.setRouted(true);
 987         record.setRlocProbed(false);
 988         record.setLocalLocator(false);
 989         record.setPriority((short) 1);
 990         record.setWeight((short) 50);
 991         record.setMulticastPriority((short) 1);
 992         record.setMulticastWeight((short) 1);
 993         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
 994         etlr.getLocatorRecord().add(record.build());
 995         mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
 996         mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
 997         lms.handleMapRegister(mapRegister.build());
 998
 999         // Get mapping using NB interface. No IID used
1000         URL url = createGetMappingIPv4URL(0, eid, mask);
1001         String reply = callURL("GET", null, "application/json", null, url);
1002         JSONTokener jt = new JSONTokener(reply);
1003         JSONObject json = new JSONObject(jt);
1004
1005         // With just one locator, locators is not a JSONArray
1006         String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
1007                 .getString("ipAddress");
1008
1009         assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
1010
1011     }
1012
1013     private void northboundDeleteMapping() throws Exception {
1014         cleanUP();
1015         LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
1016         int mask = 32;
1017         LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1018         // Insert mapping in the database
1019         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1020         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1021         etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
1022         etlr.setMaskLength((short) mask);
1023         etlr.setRecordTtl(254);
1024         etlr.setAuthoritative(false);
1025         etlr.setAction(Action.NoAction);
1026         LocatorRecordBuilder record = new LocatorRecordBuilder();
1027         record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
1028         record.setRouted(true);
1029         record.setRlocProbed(false);
1030         record.setLocalLocator(false);
1031         record.setPriority((short) 1);
1032         record.setWeight((short) 50);
1033         record.setMulticastPriority((short) 1);
1034         record.setMulticastWeight((short) 1);
1035         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1036         etlr.getLocatorRecord().add(record.build());
1037         mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1038         mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1039         lms.handleMapRegister(mapRegister.build());
1040
1041         // Delete mapping using NB interface. No IID used
1042         URL url = createDeleteMappingIPv4URL(0, eid, mask);
1043         String reply = callURL("DELETE", null, "application/json", null, url);
1044
1045         // Get mapping using NB interface. No IID used
1046         url = createGetMappingIPv4URL(0, eid, mask);
1047         reply = callURL("GET", null, "application/json", null, url);
1048         JSONTokener jt = new JSONTokener(reply);
1049         JSONObject json = new JSONObject(jt);
1050
1051         // With just one locator, locators is not a JSONArray
1052         assertEquals(json.getJSONArray("locators").length(), 0);
1053     }
1054
1055     private void northboundRetrieveSourceDestMapping() throws Exception {
1056         cleanUP();
1057         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1058                 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1059                 .primitiveaddress.Ipv4) LispAddressUtil
1060                 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
1061         org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1062                 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1063                 .primitiveaddress.Ipv4) LispAddressUtil
1064                 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
1065         int mask1 = 32;
1066         int mask2 = 32;
1067         LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
1068                 AddressFamilyNumberEnum.LCAF.getIanaCode())
1069                 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
1070                 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(
1071                         address1).build()).setSrcMaskLength((short) mask1)
1072                 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(
1073                         address2).build()).setDstMaskLength((short) mask2).build();
1074         LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1075
1076         // Insert mapping in the database
1077         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1078         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1079         etlr.setLispAddressContainer(LispAddressUtil.toContainer(sourceDestAddress));
1080         etlr.setMaskLength((short) mask1);
1081         etlr.setRecordTtl(254);
1082         etlr.setAuthoritative(false);
1083         etlr.setAction(Action.NoAction);
1084         LocatorRecordBuilder record = new LocatorRecordBuilder();
1085         record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
1086         record.setRouted(true);
1087         record.setRlocProbed(false);
1088         record.setLocalLocator(false);
1089         record.setPriority((short) 1);
1090         record.setWeight((short) 50);
1091         record.setMulticastPriority((short) 1);
1092         record.setMulticastWeight((short) 1);
1093         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1094         etlr.getLocatorRecord().add(record.build());
1095         mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1096         mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1097         lms.handleMapRegister(mapRegister.build());
1098
1099         // Get mapping using NB interface. No IID used
1100         URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
1101                 address1.getIpv4Address().getIpv4Address().getValue(),
1102                 mask1,
1103                 address2.getIpv4Address().getIpv4Address().getValue(),
1104                 mask2);
1105         String reply = callURL("GET", null, "application/json", null, url);
1106         JSONTokener jt = new JSONTokener(reply);
1107         JSONObject json = new JSONObject(jt);
1108
1109         // With just one locator, locators is not a JSONArray
1110         String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
1111         .getString("ipAddress");
1112
1113         assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
1114
1115     }
1116
1117     private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
1118         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key",
1119                 address.getAfi().shortValue(),
1120                 address.getIpv4Address().getValue(), mask);
1121         URL url = new URL(restUrl);
1122         return url;
1123     }
1124
1125     private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
1126             throws MalformedURLException {
1127         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
1128                 "key", afi, srcAddress, srcMask,
1129                 dstAddress, dstMask);
1130         URL url = new URL(restUrl);
1131         return url;
1132     }
1133
1134     private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
1135             throws MalformedURLException {
1136         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
1137                 "mapping", afi, srcAddress,
1138                 srcMask, dstAddress, dstMask);
1139         URL url = new URL(restUrl);
1140         return url;
1141     }
1142
1143     private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
1144         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
1145                 iid, address.getAfi()
1146                 .shortValue(), address.getIpv4Address().getValue(), mask);
1147         URL url = new URL(restUrl);
1148         return url;
1149     }
1150
1151     private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
1152         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
1153                 iid, address.getAfi()
1154                 .shortValue(), address.getIpv4Address().getValue(), mask);
1155         URL url = new URL(restUrl);
1156         return url;
1157     }
1158
1159     private URL createPutURL(String resource) throws MalformedURLException {
1160
1161         String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
1162
1163         URL url = new URL(restUrl);
1164         return url;
1165     }
1166
1167     private String createAuthenticationString() {
1168         String authString = "admin:admin";
1169         byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
1170         String authStringEnc = new String(authEncBytes);
1171         return authStringEnc;
1172     }
1173
1174     private String callURL(String method, String content, String accept, String body, URL url) throws IOException,
1175             JSONException {
1176         String authStringEnc = createAuthenticationString();
1177         connection = (HttpURLConnection) url.openConnection();
1178         connection.setRequestMethod(method);
1179         connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
1180         if (content != null) {
1181             connection.setRequestProperty("Content-Type", content);
1182         }
1183         if (accept != null) {
1184             connection.setRequestProperty("Accept", accept);
1185         }
1186         if (body != null) {
1187             // now add the request body
1188             connection.setDoOutput(true);
1189             OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
1190             wr.write(body);
1191             wr.flush();
1192         }
1193         connection.connect();
1194
1195         // getting the result, first check response code
1196         Integer httpResponseCode = connection.getResponseCode();
1197
1198         if (httpResponseCode > 299) {
1199             LOG.trace("HTTP Address: " + url);
1200             LOG.trace("HTTP Response Code: " + httpResponseCode);
1201             fail();
1202         }
1203
1204         InputStream is = connection.getInputStream();
1205         BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
1206         StringBuilder sb = new StringBuilder();
1207         int cp;
1208         while ((cp = rd.read()) != -1) {
1209             sb.append((char) cp);
1210         }
1211         is.close();
1212         connection.disconnect();
1213         return (sb.toString());
1214     }
1215
1216     // timePeriod - in ms
1217     public void assertNoPacketReceived(int timePeriod) {
1218         try {
1219             receivePacket(timePeriod);
1220             // If didn't timeout then fail:
1221             fail();
1222         } catch (SocketTimeoutException ste) {
1223         }
1224     }
1225 */
1226     // ------------------------------- Mask Tests ---------------------------
1227
1228     public void eidPrefixLookupIPv4() throws SocketTimeoutException {
1229         cleanUP();
1230         runPrefixTest(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/16"), LispAddressUtil.asIpv4PrefixEid("1.2.3.2/32"),
1231                 LispAddressUtil.asIpv4PrefixEid("1.1.1.1/32"));
1232     }
1233
1234     public void eidPrefixLookupIPv6() throws SocketTimeoutException {
1235         cleanUP();
1236         runPrefixTest(LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:6:7:8/64"),
1237                 LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:1:2:3/128"),
1238                 LispAddressUtil.asIpv6PrefixEid("1:2:3:1:2:3:1:2/128"));
1239     }
1240
1241     private void runPrefixTest(Eid registerEID, Eid matchedAddress, Eid unMatchedAddress)
1242             throws SocketTimeoutException {
1243         mapService.addAuthenticationKey(registerEID, NULL_AUTH_KEY);
1244         sleepForSeconds(1);
1245
1246         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1247         mapRegister.setWantMapNotify(true);
1248         mapRegister.setNonce((long) 8);
1249         mapRegister.setWantMapNotify(true);
1250         mapRegister.setKeyId((short) 0);
1251         mapRegister.setAuthenticationData(new byte[0]);
1252         mapRegister.setNonce((long) 8);
1253         mapRegister.setProxyMapReply(false);
1254         MappingRecordBuilder etlr = new MappingRecordBuilder();
1255         etlr.setRecordTtl(254);
1256         etlr.setAction(Action.NoAction);
1257         etlr.setAuthoritative(false);
1258         etlr.setMapVersion((short) 0);
1259         etlr.setEid(registerEID);
1260         etlr.setRecordTtl(254);
1261         LocatorRecordBuilder record = new LocatorRecordBuilder();
1262         record.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1263         record.setLocalLocator(false);
1264         record.setRlocProbed(false);
1265         record.setRouted(true);
1266         record.setMulticastPriority((short) 0);
1267         record.setMulticastWeight((short) 0);
1268         record.setPriority((short) 0);
1269         record.setWeight((short) 0);
1270         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1271         etlr.getLocatorRecord().add(record.build());
1272         mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1273         mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1274         sendMapRegister(mapRegister.build());
1275         MapNotify mapNotify = receiveMapNotify();
1276         assertEquals(8, mapNotify.getNonce().longValue());
1277         sleepForSeconds(1);
1278         MapRequestBuilder mapRequest = new MapRequestBuilder();
1279         mapRequest.setNonce((long) 4);
1280         mapRequest.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
1281         mapRequest.setEidItem(new ArrayList<EidItem>());
1282         mapRequest.setAuthoritative(false);
1283         mapRequest.setMapDataPresent(false);
1284         mapRequest.setPitr(false);
1285         mapRequest.setProbe(false);
1286         mapRequest.setSmr(false);
1287         mapRequest.setSmrInvoked(false);
1288         mapRequest.getEidItem().add(new EidItemBuilder().setEid(matchedAddress).build());
1289         mapRequest.setItrRloc(new ArrayList<ItrRloc>());
1290         mapRequest.getItrRloc().add(
1291                 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1292         sendMapRequest(mapRequest.build());
1293         MapReply mapReply = receiveMapReply();
1294         assertEquals(4, mapReply.getNonce().longValue());
1295         assertEquals(record.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
1296                 .get(0).getRloc());
1297         mapRequest.setEidItem(new ArrayList<EidItem>());
1298         mapRequest.getEidItem().add(new EidItemBuilder().setEid(unMatchedAddress).build());
1299         sendMapRequest(mapRequest.build());
1300         mapReply = receiveMapReply();
1301         assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1302     }
1303 /*
1304     // This registers an IP with a MapRegister, then adds a password via the
1305     // northbound REST API
1306     // and checks that the password works
1307     public void testPasswordExactMatch() throws Exception {
1308         cleanUP();
1309         String ipString = "10.0.0.1";
1310         LispIpv4Address address = LispAddressUtil.asIPAfiAddress(ipString);
1311         int mask = 32;
1312         String pass = "pass";
1313
1314         URL url = createPutURL("key");
1315
1316         String jsonAuthData = createAuthKeyJSON(pass, address, mask);
1317
1318         LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
1319         LOG.trace("Address: " + address);
1320
1321         byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232,
1322                 (byte) 31, (byte) 249, (byte) 87,
1323                 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53,
1324                 (byte) 196, (byte) 62 };
1325
1326         byte[] zeros = new byte[20];
1327
1328         callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1329
1330         // build a MapRegister
1331         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1332         mapRegister.setWantMapNotify(true);
1333         mapRegister.setNonce((long) 8);
1334         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1335         etlr.setLispAddressContainer(LispAddressUtil.toContainer(address));
1336         etlr.setMaskLength((short) mask);
1337         etlr.setRecordTtl(254);
1338         LocatorRecordBuilder record = new LocatorRecordBuilder();
1339         record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1340         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1341         etlr.getLocatorRecord().add(record.build());
1342         mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1343         mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1344
1345         mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1346         mapRegister.setAuthenticationData(zeros);
1347
1348         sendMapRegister(mapRegister.build());
1349         assertNoPacketReceived(3000);
1350
1351         mapRegister.setAuthenticationData(expectedSha);
1352
1353         sendMapRegister(mapRegister.build());
1354
1355         assertMapNotifyReceived();
1356     }
1357
1358     public void testPasswordMaskMatch() throws Exception {
1359         cleanUP();
1360         LispIpv4Address addressInRange = LispAddressUtil.asIPAfiAddress("10.20.30.40");
1361         LispIpv4Address addressOutOfRange = LispAddressUtil.asIPAfiAddress("20.40.30.40");
1362         LispIpv4Address range = LispAddressUtil.asIPAfiAddress("10.20.30.0");
1363
1364         int mask = 32;
1365         String pass = "pass";
1366
1367         URL url = createPutURL("key");
1368         String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1369
1370         callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1371         // build a MapRegister
1372         MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1373
1374         mapRegister.setWantMapNotify(true);
1375         mapRegister.setNonce((long) 8);
1376         EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1377         etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressInRange));
1378         etlr.setMaskLength((short) mask);
1379         etlr.setRecordTtl(254);
1380         LocatorRecordBuilder record = new LocatorRecordBuilder();
1381         record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1382         record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1383         etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1384         etlr.getLocatorRecord().add(record.build());
1385         mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1386         mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1387
1388         mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1389         mapRegister
1390                 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4,
1391                 -67, -113, 104, -110, -71 });
1392
1393         sendMapRegister(mapRegister.build());
1394
1395         assertMapNotifyReceived();
1396
1397         etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressOutOfRange));
1398         mapRegister
1399                 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123,
1400                 -71, -14, -99, 67, -23, -73 });
1401
1402         sendMapRegister(mapRegister.build());
1403         assertNoPacketReceived(3000);
1404     }
1405 */
1406     // takes an address, packs it in a MapRegister and sends it
1407     private void registerAddress(Eid eid) throws SocketTimeoutException {
1408         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1409         sleepForSeconds(1);
1410         MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1411         mapRegisterBuilder.setWantMapNotify(true);
1412         mapRegisterBuilder.setKeyId((short) 0);
1413         mapRegisterBuilder.setAuthenticationData(new byte[0]);
1414         mapRegisterBuilder.setNonce((long) 8);
1415         mapRegisterBuilder.setProxyMapReply(false);
1416         MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1417         etlrBuilder.setEid(eid);
1418         etlrBuilder.setRecordTtl(254);
1419         etlrBuilder.setAction(Action.NoAction);
1420         etlrBuilder.setAuthoritative(false);
1421         etlrBuilder.setMapVersion((short) 0);
1422         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1423         recordBuilder.setLocalLocator(false);
1424         recordBuilder.setRlocProbed(false);
1425         recordBuilder.setRouted(true);
1426         recordBuilder.setMulticastPriority((short) 0);
1427         recordBuilder.setMulticastWeight((short) 0);
1428         recordBuilder.setPriority((short) 0);
1429         recordBuilder.setWeight((short) 0);
1430         recordBuilder.setRloc(locatorEid);
1431         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1432         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1433         mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1434         mapRegisterBuilder.getMappingRecordItem().add(
1435                 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1436         sendMapRegister(mapRegisterBuilder.build());
1437         MapNotify mapNotify = receiveMapNotify();
1438         assertEquals(8, mapNotify.getNonce().longValue());
1439     }
1440
1441     private MapReply queryForAddress(Eid eid, String srcEid) throws SocketTimeoutException {
1442         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1443         mapRequestBuilder.setNonce((long) 4);
1444         mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1445         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1446         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1447         if (srcEid != null) {
1448             mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(srcEid)).build());
1449         } else {
1450             mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress))
1451                     .build());
1452         }
1453         mapRequestBuilder.getItrRloc().add(
1454                 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1455         mapRequestBuilder.setAuthoritative(false);
1456         mapRequestBuilder.setMapDataPresent(false);
1457         mapRequestBuilder.setPitr(false);
1458         mapRequestBuilder.setProbe(false);
1459         mapRequestBuilder.setSmr(false);
1460         mapRequestBuilder.setSmrInvoked(false);
1461         sendMapRequest(mapRequestBuilder.build());
1462         return receiveMapReply();
1463     }
1464
1465     // takes an address, packs it in a MapRegister, sends it, returns the
1466     // MapReply
1467     private MapReply registerAddressAndQuery(Eid eid) throws SocketTimeoutException {
1468         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1469         sleepForSeconds(1);
1470         MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1471         mapRegisterBuilder.setWantMapNotify(true);
1472         mapRegisterBuilder.setKeyId((short) 0);
1473         mapRegisterBuilder.setAuthenticationData(new byte[0]);
1474         mapRegisterBuilder.setNonce((long) 8);
1475         mapRegisterBuilder.setProxyMapReply(false);
1476         MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1477         etlrBuilder.setEid(eid);
1478         etlrBuilder.setRecordTtl(254);
1479         etlrBuilder.setAction(Action.NoAction);
1480         etlrBuilder.setAuthoritative(false);
1481         etlrBuilder.setMapVersion((short) 0);
1482         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1483         recordBuilder.setLocalLocator(false);
1484         recordBuilder.setRlocProbed(false);
1485         recordBuilder.setRouted(true);
1486         recordBuilder.setMulticastPriority((short) 0);
1487         recordBuilder.setMulticastWeight((short) 0);
1488         recordBuilder.setPriority((short) 0);
1489         recordBuilder.setWeight((short) 0);
1490         recordBuilder.setRloc(locatorEid);
1491         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1492         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1493         mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1494         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
1495                 etlrBuilder.build()).build());
1496         sendMapRegister(mapRegisterBuilder.build());
1497         MapNotify mapNotify = receiveMapNotify();
1498         assertEquals(8, mapNotify.getNonce().longValue());
1499         // wait for the notifications to propagate
1500         sleepForSeconds(1);
1501         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1502         mapRequestBuilder.setNonce((long) 4);
1503         mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1504         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1505         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1506         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
1507         mapRequestBuilder.getItrRloc().add(
1508                 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1509         mapRequestBuilder.setAuthoritative(false);
1510         mapRequestBuilder.setMapDataPresent(false);
1511         mapRequestBuilder.setPitr(false);
1512         mapRequestBuilder.setProbe(false);
1513         mapRequestBuilder.setSmr(false);
1514         mapRequestBuilder.setSmrInvoked(false);
1515         sendMapRequest(mapRequestBuilder.build());
1516         return receiveMapReply();
1517     }
1518
1519     // ------------------------------- LCAF Tests ---------------------------
1520
1521     @Test
1522     public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1523         cleanUP();
1524         String ipPrefix = "10.20.30.200/32";
1525         String macString = "01:02:03:04:05:06";
1526
1527         SourceDestKeyBuilder builder = new SourceDestKeyBuilder();
1528         builder.setSource(new SimpleAddress(new IpPrefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
1529                 .ietf.inet.types.rev100924.Ipv4Prefix(ipPrefix))));
1530         builder.setDest(new SimpleAddress(new MacAddress(macString)));
1531
1532         EidBuilder eb = new EidBuilder();
1533         eb.setAddressType(SourceDestKeyLcaf.class);
1534         eb.setVirtualNetworkId(null);
1535         eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1536                 .lisp.address.address.SourceDestKeyBuilder().setSourceDestKey(builder.build()).build());
1537
1538         MapReply reply = registerAddressAndQuery(eb.build());
1539
1540         Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1541         assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
1542         SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
1543
1544         SimpleAddress receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource();
1545         SimpleAddress receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest();
1546
1547         assertNotNull(receivedAddr1.getIpPrefix().getIpv4Prefix());
1548         assertNotNull(receivedAddr2.getMacAddress());
1549
1550         IpPrefix receivedIP = receivedAddr1.getIpPrefix();
1551         MacAddress receivedMAC = receivedAddr2.getMacAddress();
1552
1553         assertEquals(ipPrefix, receivedIP.getIpv4Prefix().getValue());
1554         assertEquals(macString, receivedMAC.getValue());
1555     }
1556
1557     @Test
1558     public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1559         cleanUP();
1560         String ipString1 = "10.10.10.0";
1561         String ipString2 = "20.20.20.0";
1562         String ipPrefix1 = ipString1 + "/24";
1563         String ipPrefix2 = ipString2 + "/24";
1564
1565         Eid srcDst = LispAddressUtil.asSrcDstEid(ipString1, ipString2, 24, 24, 0);
1566         registerAddress(LispAddressUtil.asIpv4PrefixEid(ipPrefix2));
1567         registerAddress(srcDst);
1568
1569         // exact match
1570         MapReply reply = queryForAddress(srcDst, null);
1571
1572         Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1573         assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
1574         SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
1575
1576         IpPrefix receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource().getIpPrefix();
1577         IpPrefix receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest().getIpPrefix();
1578
1579         assertNotNull(receivedAddr1.getIpv4Prefix());
1580         assertNotNull(receivedAddr2.getIpv4Prefix());
1581
1582         assertEquals(ipPrefix1, receivedAddr1.getIpv4Prefix().getValue());
1583         assertEquals(ipPrefix2, receivedAddr2.getIpv4Prefix().getValue());
1584
1585         // srcEid/dstEid match
1586         reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "10.10.10.1");
1587         fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1588         assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
1589
1590         Ipv4Prefix ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
1591         assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
1592
1593         // dstEid match only
1594         reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "1.2.3.4");
1595         fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1596         assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
1597
1598         ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
1599         assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
1600     }
1601
1602     @Test
1603     public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1604         cleanUP();
1605         String ipString = "10.20.30.200";
1606         String macString = "01:02:03:04:05:06";
1607         SimpleAddress addrToSend1 = new SimpleAddress(new IpAddress(new Ipv4Address(ipString)));
1608         SimpleAddress addrToSend2 = new SimpleAddress(new MacAddress(macString));
1609         Eid kv = LispAddressUtil.asKeyValueAddressEid(addrToSend1, addrToSend2);
1610
1611         MapReply reply = registerAddressAndQuery(kv);
1612
1613         Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1614         assertEquals(KeyValueAddressLcaf.class, fromNetwork.getAddressType());
1615         KeyValueAddress keyValueFromNetwork = (KeyValueAddress) fromNetwork.getAddress();
1616
1617         SimpleAddress receivedAddr1 = keyValueFromNetwork.getKeyValueAddress().getKey();
1618         SimpleAddress receivedAddr2 = keyValueFromNetwork.getKeyValueAddress().getValue();
1619
1620         assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
1621         assertNotNull(receivedAddr2.getMacAddress());
1622
1623         Ipv4Address receivedIP = receivedAddr1.getIpAddress().getIpv4Address();
1624         MacAddress receivedMAC = receivedAddr2.getMacAddress();
1625
1626         assertEquals(ipString, receivedIP.getValue());
1627         assertEquals(macString, receivedMAC.getValue());
1628     }
1629
1630     public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1631         cleanUP();
1632         String macString = "01:02:03:04:05:06";
1633         String ipString = "10.20.255.30";
1634         List<SimpleAddress> addresses = new ArrayList<SimpleAddress>();
1635         addresses.add(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1636         addresses.add(new SimpleAddress(new MacAddress(macString)));
1637         AfiListBuilder listbuilder = new AfiListBuilder();
1638         listbuilder.setAddressList(addresses);
1639
1640         EidBuilder eb = new EidBuilder();
1641         eb.setAddressType(AfiListLcaf.class);
1642         eb.setVirtualNetworkId(null);
1643         eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1644                 .lisp.address.address.AfiListBuilder().setAfiList(listbuilder.build()).build());
1645
1646         MapReply reply = registerAddressAndQuery(eb.build());
1647
1648         Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1649
1650         assertEquals(AfiListLcaf.class, receivedAddress.getAddressType());
1651
1652         AfiList listAddrFromNetwork = (AfiList) receivedAddress.getAddress();
1653         SimpleAddress receivedAddr1 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(0);
1654         SimpleAddress receivedAddr2 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(1);
1655
1656         assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
1657         assertNotNull(receivedAddr2.getMacAddress());
1658
1659         assertEquals(macString, receivedAddr2.getMacAddress().getValue());
1660         assertEquals(ipString, receivedAddr1.getIpAddress().getIpv4Address().getValue());
1661     }
1662
1663     public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1664         cleanUP();
1665         String ipString = "10.20.255.30";
1666         int instanceId = 6;
1667
1668         EidBuilder eb = new EidBuilder();
1669         eb.setAddressType(Ipv4PrefixAfi.class);
1670         eb.setVirtualNetworkId(new InstanceIdType((long) instanceId));
1671         eb.setAddress(new Ipv4PrefixBuilder().setIpv4Prefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
1672                 .yang.ietf.inet.types.rev100924.Ipv4Prefix(ipString)).build());
1673
1674         MapReply reply = registerAddressAndQuery(eb.build());
1675
1676         Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1677         assertEquals(Ipv4PrefixAfi.class, receivedAddress.getAddressType());
1678
1679         assertEquals(ipString, ((Ipv4Prefix) receivedAddress.getAddress()).getIpv4Prefix().getValue());
1680
1681         assertEquals(instanceId, receivedAddress.getVirtualNetworkId().getValue().intValue());
1682     }
1683
1684     public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1685         cleanUP();
1686         String macString = "01:02:03:04:05:06";
1687         String ipString = "10.20.255.30";
1688         HopBuilder hopBuilder = new HopBuilder();
1689         hopBuilder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1690         hopBuilder.setLrsBits(new LrsBits(true, false, true));
1691         Hop hop1 = hopBuilder.build();
1692         hopBuilder.setAddress(new SimpleAddress(new MacAddress(macString)));
1693         hopBuilder.setLrsBits(new LrsBits(false, true, false));
1694         Hop hop2 = hopBuilder.build();
1695         ExplicitLocatorPathBuilder elpBuilder = new ExplicitLocatorPathBuilder();
1696         elpBuilder.setHop(new ArrayList<Hop>());
1697         elpBuilder.getHop().add(hop1);
1698         elpBuilder.getHop().add(hop2);
1699
1700         EidBuilder eb = new EidBuilder();
1701         eb.setAddressType(ExplicitLocatorPathLcaf.class);
1702         eb.setVirtualNetworkId(null);
1703         eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1704                 .lisp.address.address.ExplicitLocatorPathBuilder().setExplicitLocatorPath(elpBuilder.build()).build());
1705
1706         MapReply reply = registerAddressAndQuery(eb.build());
1707
1708         assertEquals(ExplicitLocatorPathLcaf.class, reply.getMappingRecordItem().get(0).getMappingRecord().getEid()
1709                 .getAddressType());
1710
1711         ExplicitLocatorPath receivedAddress = (ExplicitLocatorPath) reply.getMappingRecordItem().get(0)
1712                 .getMappingRecord().getEid().getAddress();
1713
1714         Hop receivedHop1 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(0);
1715         Hop receivedHop2 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(1);
1716
1717         assertEquals(true, receivedHop1.getLrsBits().isLookup());
1718         assertEquals(false, receivedHop1.getLrsBits().isRlocProbe());
1719         assertEquals(true, receivedHop1.getLrsBits().isStrict());
1720
1721         assertEquals(false, receivedHop2.getLrsBits().isLookup());
1722         assertEquals(true, receivedHop2.getLrsBits().isRlocProbe());
1723         assertEquals(false, receivedHop2.getLrsBits().isStrict());
1724
1725         assertNotNull(receivedHop1.getAddress().getIpAddress().getIpv4Address());
1726         assertNotNull(receivedHop2.getAddress().getMacAddress());
1727
1728         assertEquals(ipString, receivedHop1.getAddress().getIpAddress().getIpv4Address().getValue());
1729         assertEquals(macString, receivedHop2.getAddress().getMacAddress().getValue());
1730     }
1731
1732     public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1733         cleanUP();
1734         String ipString = "1.2.3.4";
1735         short protocol = 1;
1736         int ipTOs = 2;
1737         int localPortLow = 3;
1738         int localPortHigh = 4;
1739         int remotePortLow = 4;
1740         int remotePortHigh = 5;
1741
1742         ApplicationDataBuilder builder = new ApplicationDataBuilder();
1743         builder.setIpTos(ipTOs);
1744         builder.setProtocol(protocol);
1745         builder.setLocalPortLow(new PortNumber(localPortLow));
1746         builder.setLocalPortHigh(new PortNumber(localPortHigh));
1747         builder.setRemotePortLow(new PortNumber(remotePortLow));
1748         builder.setRemotePortHigh(new PortNumber(remotePortHigh));
1749         builder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1750
1751         EidBuilder eb = new EidBuilder();
1752         eb.setAddressType(ApplicationDataLcaf.class);
1753         eb.setVirtualNetworkId(null);
1754         eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1755                 .lisp.address.address.ApplicationDataBuilder().setApplicationData(builder.build()).build());
1756         Eid addressToSend = eb.build();
1757
1758         MapReply reply = registerAddressAndQuery(addressToSend);
1759
1760         Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1761
1762         assertEquals(ApplicationDataLcaf.class, receivedAddress.getAddressType());
1763
1764         ApplicationData receivedApplicationDataAddress = (ApplicationData) receivedAddress.getAddress();
1765         assertEquals(protocol, receivedApplicationDataAddress.getApplicationData().getProtocol().intValue());
1766         assertEquals(ipTOs, receivedApplicationDataAddress.getApplicationData().getIpTos().intValue());
1767         assertEquals(localPortLow, receivedApplicationDataAddress.getApplicationData().getLocalPortLow().getValue()
1768                 .intValue());
1769         assertEquals(localPortHigh, receivedApplicationDataAddress.getApplicationData().getLocalPortHigh().getValue()
1770                 .intValue());
1771         assertEquals(remotePortLow, receivedApplicationDataAddress.getApplicationData().getRemotePortLow().getValue()
1772                 .intValue());
1773         assertEquals(remotePortHigh, receivedApplicationDataAddress.getApplicationData().getRemotePortHigh().getValue()
1774                 .intValue());
1775
1776         SimpleAddress ipAddressReceived = receivedApplicationDataAddress.getApplicationData().getAddress();
1777         assertEquals(ipString, ipAddressReceived.getIpAddress().getIpv4Address().getValue());
1778     }
1779
1780     // ------------------- TimeOut Tests -----------
1781
1782     public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1783         cleanUP();
1784         Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
1785         mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1786         sleepForSeconds(1);
1787         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1788         mapRequestBuilder.setNonce((long) 4);
1789         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
1790         mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1791         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1792         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1793         mapRequestBuilder.getItrRloc().add(
1794                 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1795
1796         sendMapRequest(mapRequestBuilder.build());
1797         MapReply mapReply = receiveMapReply();
1798         assertEquals(4, mapReply.getNonce().longValue());
1799         assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1800
1801         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1802         mapRegisterbuilder.setWantMapNotify(true);
1803         mapRegisterbuilder.setNonce((long) 8);
1804
1805         MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1806         etlrBuilder.setEid(eid);
1807         etlrBuilder.setMaskLength((short) 32);
1808         etlrBuilder.setRecordTtl(254);
1809
1810         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1811         recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1812         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1813         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1814         mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1815         mapRegisterbuilder.getMappingRecordItem().add(
1816                 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1817
1818         sendMapRegister(mapRegisterbuilder.build());
1819         MapNotify mapNotify = receiveMapNotify();
1820         assertEquals(8, mapNotify.getNonce().longValue());
1821         sleepForSeconds(1);
1822
1823         sendMapRequest(mapRequestBuilder.build());
1824         mapReply = receiveMapReply();
1825         assertEquals(4, mapReply.getNonce().longValue());
1826         assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1827                 .getLocatorRecord().get(0).getRloc());
1828
1829         causeEntryToBeCleaned();
1830         sendMapRequest(mapRequestBuilder.build());
1831         mapReply = receiveMapReply();
1832         assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1833     }
1834
1835     public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1836         cleanUP();
1837         Eid eid = LispAddressUtil.asIpv6PrefixEid("1.2.3.4/32");
1838         MapRequest mapRequest = createMapRequest(eid);
1839
1840         testTTLBeforeRegister(mapRequest);
1841
1842         registerForTTL(eid);
1843
1844         testTTLAfterRegister(mapRequest);
1845
1846         causeEntryToBeCleaned();
1847         testTTLAfterClean(mapRequest);
1848
1849         //northboundAddKey();
1850         //testTTLAfterAutherize(mapRequest);
1851
1852     }
1853
1854     private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1855         MapReply mapReply;
1856         sendMapRequest(mapRequest);
1857         mapReply = receiveMapReply();
1858         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1859     }
1860
1861     private void causeEntryToBeCleaned() {
1862         // TODO XXX for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1863         // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1864         // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1865         mapService.cleanCachedMappings();
1866     }
1867
1868     private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1869         MapReply mapReply;
1870         sendMapRequest(mapRequest);
1871         mapReply = receiveMapReply();
1872         assertEquals(LispAddressUtil.asIpv4Rloc("4.3.2.1"), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1873                 .getLocatorRecord().get(0).getRloc());
1874         assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1875     }
1876
1877     private void registerForTTL(Eid eid) throws SocketTimeoutException {
1878         MapRegister mapRegister = createMapRegister(eid);
1879         sendMapRegister(mapRegister);
1880         assertMapNotifyReceived();
1881     }
1882
1883     private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1884         MapReply mapReply;
1885         sendMapRequest(mapRequest);
1886         mapReply = receiveMapReply();
1887         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1888     }
1889 /*
1890     private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1891         MapReply mapReply;
1892         sendMapRequest(mapRequest);
1893         mapReply = receiveMapReply();
1894         assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1895     }
1896 */
1897     private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1898         assertEquals(expectedTTL, mapReply.getMappingRecordItem().get(0).getMappingRecord().getRecordTtl().intValue());
1899         assertEquals(expectedAction, mapReply.getMappingRecordItem().get(0).getMappingRecord().getAction());
1900     }
1901
1902     private MapRegister createMapRegister(Eid eid, Rloc rloc) {
1903         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1904         mapRegisterbuilder.setWantMapNotify(true);
1905         mapRegisterbuilder.setNonce((long) 8);
1906         mapRegisterbuilder.setKeyId((short) 0);
1907         MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1908         etlrBuilder.setEid(eid);
1909         etlrBuilder.setMaskLength((short) 24);
1910         etlrBuilder.setRecordTtl(254);
1911         etlrBuilder.setAuthoritative(false);
1912         etlrBuilder.setAction(Action.NoAction);
1913         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1914         recordBuilder.setRloc(rloc);
1915         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1916         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1917         mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1918         mapRegisterbuilder.getMappingRecordItem().add(
1919                 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1920         MapRegister mapRegister = mapRegisterbuilder.build();
1921         return mapRegister;
1922     }
1923
1924     private MapRegister createMapRegister(Eid eid) {
1925         return createMapRegister(eid, LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1926     }
1927
1928     private MapRequest createMapRequest(Eid eid) {
1929         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1930         mapRequestBuilder.setNonce((long) 4);
1931         mapRequestBuilder.setPitr(false);
1932         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
1933         mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1934         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1935         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1936         mapRequestBuilder.getItrRloc().add(
1937                 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1938         MapRequest mr = mapRequestBuilder.build();
1939         return mr;
1940     }
1941
1942     public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1943         cleanUP();
1944         String rloc = "127.0.0.3";
1945         int port = LispMessage.PORT_NUM;
1946         Rloc ipRloc = LispAddressUtil.asIpv4Rloc(rloc);
1947         sendProxyMapRequest(rloc, port, ipRloc);
1948
1949     }
1950
1951     public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1952         cleanUP();
1953         String rloc = "127.0.0.3";
1954         int port = 4350;
1955
1956         RlocBuilder rb = new RlocBuilder();
1957         rb.setAddressType(ApplicationDataLcaf.class);
1958         rb.setVirtualNetworkId(null);
1959         rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1960                 .lisp.address.address.ApplicationDataBuilder()
1961                 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
1962                 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
1963         Rloc adLcaf = rb.build();
1964
1965         LOG.info("testNonProxyOtherPort:" + LispAddressStringifier.getString(adLcaf));
1966         sendProxyMapRequest(rloc, port, adLcaf);
1967
1968     }
1969
1970     private class XtrRequestMappingListener implements OdlLispProtoListener {
1971
1972         @Override
1973         public void onGotMapReply(GotMapReply notification) {
1974         }
1975
1976         @Override
1977         public void onAddMapping(AddMapping notification) {
1978         }
1979
1980         @Override
1981         public void onXtrReplyMapping(XtrReplyMapping notification) {
1982         }
1983
1984         @Override
1985         public void onRequestMapping(RequestMapping notification) {
1986         }
1987
1988         @Override
1989         public void onGotMapNotify(GotMapNotify notification) {
1990         }
1991
1992         @Override
1993         public void onXtrRequestMapping(XtrRequestMapping notification) {
1994         }
1995
1996     }
1997
1998     public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
1999         cleanUP();
2000         configLispPlugin.shouldListenOnXtrPort(true);
2001         notificationCalled = false;
2002         final String eid = "10.10.10.10/32";
2003         String rloc = "127.0.0.3";
2004         int port = LispMessage.XTR_PORT_NUM;
2005
2006         RlocBuilder rb = new RlocBuilder();
2007         rb.setAddressType(ApplicationDataLcaf.class);
2008         rb.setVirtualNetworkId(null);
2009         rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2010                 .lisp.address.address.ApplicationDataBuilder()
2011                 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
2012                 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
2013         Rloc adLcaf = rb.build();
2014
2015         final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2016         ((LispMappingService) lms).getNotificationService().registerNotificationListener(
2017                 new XtrRequestMappingListener() {
2018
2019             @Override
2020             public void onXtrRequestMapping(XtrRequestMapping notification) {
2021                 assertEquals(((Ipv4Prefix) mapRequest.getEidItem().get(0).getEid().getAddress())
2022                         .getIpv4Prefix().getValue(), eid);
2023                 notificationCalled = true;
2024                 LOG.warn("notification arrived");
2025             }
2026         });
2027         sendMapRequest(mapRequest, port);
2028         for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
2029             if (notificationCalled) {
2030                 return;
2031             } else {
2032                 LOG.warn("notification hasn't arrived, sleeping...");
2033                 Thread.sleep(500);
2034             }
2035         }
2036
2037         fail("Notification hasn't arrived");
2038
2039     }
2040
2041     private void sendProxyMapRequest(String rloc, int port, Rloc adLcaf) throws SocketTimeoutException,
2042             SocketException {
2043         String eid = "10.1.0.1/32";
2044         MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2045         sendMapRequest(mapRequest);
2046         DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
2047         MapRequest receivedMapRequest = receiveMapRequest(nonProxySocket);
2048         assertEquals(mapRequest.getNonce(), receivedMapRequest.getNonce());
2049         assertEquals(mapRequest.getSourceEid(), receivedMapRequest.getSourceEid());
2050         assertEquals(mapRequest.getItrRloc(), receivedMapRequest.getItrRloc());
2051         assertEquals(mapRequest.getEidItem(), receivedMapRequest.getEidItem());
2052         nonProxySocket.close();
2053     }
2054
2055     private MapRequest createNonProxyMapRequest(String eid, Rloc adLcaf) throws SocketTimeoutException {
2056         MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixEid(eid));
2057         LocatorRecord record = new LocatorRecordBuilder(mr.getMappingRecordItem().get(0).getMappingRecord()
2058                 .getLocatorRecord().get(0)).setRloc(adLcaf).build();
2059         mr.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().set(0, record);
2060         sendMapRegister(mr);
2061         assertMapNotifyReceived();
2062         MapRequest mapRequest = createMapRequest(LispAddressUtil.asIpv4PrefixEid(eid));
2063         MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
2064         builder.setPitr(true);
2065         mapRequest = builder.build();
2066         return mapRequest;
2067     }
2068
2069     private void assertMapNotifyReceived() throws SocketTimeoutException {
2070         receiveMapNotify();
2071     }
2072
2073     private MapReply receiveMapReply() throws SocketTimeoutException {
2074         return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2075     }
2076
2077     private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
2078         return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(
2079                 datagramSocket, 30000).getData()));
2080     }
2081
2082     private MapNotify receiveMapNotify() throws SocketTimeoutException {
2083         return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2084     }
2085
2086     private void sendMapRequest(MapRequest mapRequest) {
2087         sendMapRequest(mapRequest, LispMessage.PORT_NUM);
2088     }
2089
2090     private void sendMapRequest(MapRequest mapRequest, int port) {
2091         sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
2092     }
2093
2094     private void sendMapRegister(MapRegister mapRegister) {
2095         sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
2096     }
2097
2098     private void sendPacket(byte[] bytesToSend) {
2099         sendPacket(bytesToSend, LispMessage.PORT_NUM);
2100     }
2101
2102     private void sendPacket(byte[] bytesToSend, int port) {
2103         try {
2104             DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
2105             initPacketAddress(packet, port);
2106             LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
2107             socket.send(packet);
2108         } catch (Throwable t) {
2109             fail();
2110         }
2111     }
2112
2113     private DatagramPacket receivePacket() throws SocketTimeoutException {
2114         return receivePacket(6000);
2115     }
2116
2117     private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
2118         return receivePacket(socket, timeout);
2119     }
2120
2121     private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
2122         try {
2123             byte[] buffer = new byte[4096];
2124             DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
2125             LOG.trace("Waiting for packet from socket...");
2126             receivedSocket.setSoTimeout(timeout);
2127             receivedSocket.receive(receivePacket);
2128             LOG.trace("Received packet from socket!");
2129             return receivePacket;
2130         } catch (SocketTimeoutException ste) {
2131             throw ste;
2132         } catch (Throwable t) {
2133             fail();
2134             return null;
2135         }
2136     }
2137
2138     private void sleepForSeconds(int seconds) {
2139         try {
2140             Thread.sleep(seconds*1000);
2141         } catch (InterruptedException e) {
2142             LOG.warn("Interrupted while sleeping", e);
2143         }
2144     }
2145
2146     private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
2147         packet.setAddress(InetAddress.getByName(lispBindAddress));
2148         packet.setPort(port);
2149     }
2150
2151     private DatagramSocket initSocket(DatagramSocket socket, int port) {
2152         try {
2153             socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
2154         } catch (SocketException e) {
2155             e.printStackTrace();
2156             fail();
2157         }
2158         return socket;
2159     }
2160
2161     private byte[] extractWSUdpByteArray(String wiresharkHex) {
2162         final int HEADER_LEN = 42;
2163         byte[] res = new byte[1000];
2164         String[] split = wiresharkHex.split(" ");
2165         int counter = 0;
2166         for (String cur : split) {
2167             cur = cur.trim();
2168             if (cur.length() == 2) {
2169                 ++counter;
2170                 if (counter > HEADER_LEN) {
2171                     res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
2172                 }
2173
2174             }
2175         }
2176         return Arrays.copyOf(res, counter - HEADER_LEN);
2177     }
2178
2179     private String stateToString(int state) {
2180         switch (state) {
2181         case Bundle.ACTIVE:
2182             return "ACTIVE";
2183         case Bundle.INSTALLED:
2184             return "INSTALLED";
2185         case Bundle.RESOLVED:
2186             return "RESOLVED";
2187         case Bundle.UNINSTALLED:
2188             return "UNINSTALLED";
2189         default:
2190             return "Not CONVERTED";
2191         }
2192     }
2193
2194     private void areWeReady() throws InvalidSyntaxException {
2195         sleepForSeconds(5);
2196
2197         assertNotNull(bc);
2198         boolean debugit = false;
2199         Bundle b[] = bc.getBundles();
2200         for (Bundle element : b) {
2201             int state = element.getState();
2202             LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v"
2203                     + element.getVersion() + ", state:" + stateToString(state));
2204             if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
2205                 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
2206
2207                 // try {
2208                 // String host = element.getHeaders().get("FRAGMENT-HOST");
2209                 // if (host != null) {
2210                 // LOG.warn("Bundle " + element.getSymbolicName() +
2211                 // " is a fragment which is part of: " + host);
2212                 // LOG.warn("Required imports are: " +
2213                 // element.getHeaders().get("IMPORT-PACKAGE"));
2214                 // } else {
2215                 // element.start();
2216                 // }
2217                 // } catch (BundleException e) {
2218                 // LOG.error("BundleException:", e);
2219                 // fail();
2220                 // }
2221
2222                 debugit = true;
2223
2224             }
2225         }
2226         if (debugit) {
2227             LOG.warn(("Do some debugging because some bundle is unresolved"));
2228         }
2229         // assertNotNull(broker);
2230
2231         configLispPlugin.setLispAddress(lispBindAddress);
2232
2233         // Uncomment this code to Know which services were actually loaded to
2234         // BundleContext
2235
2236         /*
2237         for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
2238             LOG.info(sr.getBundle().getSymbolicName());
2239             LOG.info(sr.toString());
2240         }
2241         */
2242
2243         sleepForSeconds(1);
2244     }
2245
2246     private void cleanUP() {
2247         after();
2248         mapService.cleanCachedMappings();
2249         configLispPlugin.shouldListenOnXtrPort(false);
2250         socket = initSocket(socket, LispMessage.PORT_NUM);
2251
2252     }
2253
2254     private void restartSocket() {
2255         after();
2256         socket = initSocket(socket, LispMessage.PORT_NUM);
2257     }
2258
2259 }