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.interfaces.lisp.IFlowMapping;
  59 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
  60 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
  61 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  62 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
  63 import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
  64 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
  65 import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
  66 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
  67 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MappingKeepAlive;
  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     private static final int MAX_NOTIFICATION_RETRYS = 20;
 158     private static final MappingAuthkey NULL_AUTH_KEY = new MappingAuthkeyBuilder().setKeyType(0).build();
 159     private static final MappingAuthkey AUTH_KEY =
 160             new MappingAuthkeyBuilder().setKeyType(1).setKeyString("password").build();
 161
 162     @Override
 163     public String getModuleName() {
 164         return "mappingservice-impl";
 165     }
 166
 167     @Override
 168     public String getInstanceName() {
 169         return "mappingservice-default";
 170     }
 171
 172     // This is temporary, since the properties in the pom file are not picked up
 173     @Override
 174     public String getKarafDistro() {
 175         return maven()
 176                 .groupId("org.opendaylight.lispflowmapping")
 177                 .artifactId("distribution-karaf")
 178                 .versionAsInProject()
 179                 .type("zip")
 180                 .getURL();
 181     }
 182
 183     @Override
 184     public MavenUrlReference getFeatureRepo() {
 185         return maven()
 186                 .groupId("org.opendaylight.lispflowmapping")
 187                 .artifactId("features-lispflowmapping")
 188                 .classifier("features")
 189                 .type("xml")
 190                 .versionAsInProject();
 191     }
 192
 193     @Override
 194     public String getFeatureName() {
 195         return "odl-lispflowmapping-msmr";
 196     }
 197
 198     @Override
 199     public Option getLoggingOption() {
 200         Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
 201                 "log4j.logger.org.opendaylight.lispflowmapping",
 202                 LogLevel.DEBUG.name());
 203         option = composite(option, super.getLoggingOption());
 204         return option;
 205     }
 206
 207     @Test
 208     public void testLispFlowMappingFeatureLoad() {
 209         Assert.assertTrue(true);
 210     }
 211
 212     @After
 213     public void after() {
 214         if (socket != null) {
 215             socket.close();
 216         }
 217 //        if (connection != null) {
 218 //            connection.disconnect();
 219 //        }
 220     }
 221
 222     @Before
 223     public void before() throws Exception {
 224         areWeReady();
 225         mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_FIRST);
 226         mapService.setMappingOverwrite(true);
 227
 228         locatorEid = LispAddressUtil.asIpv4Rloc("4.3.2.1");
 229         socket = initSocket(socket, LispMessage.PORT_NUM);
 230
 231         // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
 232         // LISP(Type = 8 - Encapsulated)
 233         // IP: 192.168.136.10 -> 153.16.254.1
 234         // UDP: 56756
 235         // LISP(Type = 1 Map-Request
 236         // Record Count: 1
 237         // ITR-RLOC count: 0
 238         // Source EID AFI: 1
 239         // Source EID 1.2.3.4
 240         // Nonce: 0x3d8d2acd39c8d608
 241         // ITR-RLOC AFI=1 Address=192.168.136.10
 242         // Record 1: 153.16.254.1/32
 243         mapRequestPacket = extractWSUdpByteArray(new String("0000   00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
 244                 + "0010   00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
 245                 + "0020   00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
 246                 + "0030   00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
 247                 + "0040   fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
 248                 + "0050   2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
 249                 + "0060   00 01 99 10 fe 01"));
 250
 251         // IP: 192.168.136.10 -> 128.223.156.35
 252         // UDP: 49289 -> 4342
 253         // LISP(Type = 3 Map-Register, P=1, M=1
 254         // Record Counter: 1
 255         // Nonce: 0
 256         // Key ID: 0x0001
 257         // AuthDataLength: 20 Data:
 258         // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
 259         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 260         // No-Action
 261         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 262         // Priority/Weight: 1/100, Multicast Priority/Weight:
 263         // 255/0
 264         //
 265
 266         mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String(
 267                   "0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 268                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 269                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 270                 + "0030   00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
 271                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 272                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 273                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 274
 275         // IP: 192.168.136.10 -> 128.223.156.35
 276         // UDP: 49289 -> 4342
 277         // LISP(Type = 3 Map-Register, P=1, M=1
 278         // Record Counter: 1
 279         // Nonce: 7
 280         // Key ID: 0x0000 NO AUTHENTICATION!!
 281         // AuthDataLength: 00 Data:
 282         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 283         // No-Action
 284         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 285         // Priority/Weight: 1/100, Multicast Priority/Weight:
 286         // 255/0
 287         //
 288
 289         mapRegisterPacketWithNotify = extractWSUdpByteArray(new String(
 290                   "0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 291                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 292                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
 293                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 294                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 295                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 296                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 297
 298         // IP: 192.168.136.10 -> 128.223.156.35
 299         // UDP: 49289 -> 4342
 300         // LISP(Type = 3 Map-Register, P=1, M=1
 301         // Record Counter: 1
 302         // Nonce: 7
 303         // Key ID: 0x0000 NO AUTHENTICATION!!
 304         // AuthDataLength: 00 Data:
 305         // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
 306         // No-Action
 307         // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
 308         // Priority/Weight: 1/100, Multicast Priority/Weight:
 309         // 255/0
 310         //
 311
 312         mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String(
 313                   "0000   00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
 314                 + "0010   00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
 315                 + "0020   9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
 316                 + "0030   00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
 317                 + "0040   71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
 318                 + "0050   00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
 319                 + "0060   ff 00 00 05 00 01 c0 a8 88 0a"));
 320     }
 321
 322     @Inject
 323     private BundleContext bc;
 324     //private HttpURLConnection connection;
 325     protected static boolean notificationCalled;
 326
 327     @Inject @Filter(timeout=60000)
 328     private IFlowMapping lms;
 329
 330     @Inject @Filter(timeout=60000)
 331     private IMappingService mapService;
 332
 333     @Inject @Filter(timeout=10000)
 334     private IConfigLispSouthboundPlugin configLispPlugin;
 335
 336     @Test
 337     public void testSimpleUsage() throws Exception {
 338         mapRequestSimple();
 339         mapRegisterWithMapNotify();
 340         mapRegisterWithMapNotifyAndMapRequest();
 341         registerAndQuery__MAC();
 342         mapRequestMapRegisterAndMapRequest();
 343         //TODO uncomment followign test once authentication check will be moved to LispSouthboundHandler
 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(false, 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(IMappingService.LookupPolicy.NB_AND_SB);
 546         mapService.setMappingOverwrite(false);
 547
 548         //TEST CASE 1
 549         multiSiteScenario.storeSouthboundMappings(true, 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.setRecordTtl(254);
1808
1809         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1810         recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1811         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1812         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1813         mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1814         mapRegisterbuilder.getMappingRecordItem().add(
1815                 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1816
1817         sendMapRegister(mapRegisterbuilder.build());
1818         MapNotify mapNotify = receiveMapNotify();
1819         assertEquals(8, mapNotify.getNonce().longValue());
1820         sleepForSeconds(1);
1821
1822         sendMapRequest(mapRequestBuilder.build());
1823         mapReply = receiveMapReply();
1824         assertEquals(4, mapReply.getNonce().longValue());
1825         assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1826                 .getLocatorRecord().get(0).getRloc());
1827
1828         causeEntryToBeCleaned();
1829         sendMapRequest(mapRequestBuilder.build());
1830         mapReply = receiveMapReply();
1831         assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1832     }
1833
1834     public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1835         cleanUP();
1836         Eid eid = LispAddressUtil.asIpv6PrefixEid("1.2.3.4/32");
1837         MapRequest mapRequest = createMapRequest(eid);
1838
1839         testTTLBeforeRegister(mapRequest);
1840
1841         registerForTTL(eid);
1842
1843         testTTLAfterRegister(mapRequest);
1844
1845         causeEntryToBeCleaned();
1846         testTTLAfterClean(mapRequest);
1847
1848         //northboundAddKey();
1849         //testTTLAfterAutherize(mapRequest);
1850
1851     }
1852
1853     private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1854         MapReply mapReply;
1855         sendMapRequest(mapRequest);
1856         mapReply = receiveMapReply();
1857         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1858     }
1859
1860     private void causeEntryToBeCleaned() {
1861         // TODO XXX for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1862         // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1863         // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1864         mapService.cleanCachedMappings();
1865     }
1866
1867     private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1868         MapReply mapReply;
1869         sendMapRequest(mapRequest);
1870         mapReply = receiveMapReply();
1871         assertEquals(LispAddressUtil.asIpv4Rloc("4.3.2.1"), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1872                 .getLocatorRecord().get(0).getRloc());
1873         assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1874     }
1875
1876     private void registerForTTL(Eid eid) throws SocketTimeoutException {
1877         MapRegister mapRegister = createMapRegister(eid);
1878         sendMapRegister(mapRegister);
1879         assertMapNotifyReceived();
1880     }
1881
1882     private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1883         MapReply mapReply;
1884         sendMapRequest(mapRequest);
1885         mapReply = receiveMapReply();
1886         assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1887     }
1888 /*
1889     private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1890         MapReply mapReply;
1891         sendMapRequest(mapRequest);
1892         mapReply = receiveMapReply();
1893         assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1894     }
1895 */
1896     private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1897         assertEquals(expectedTTL, mapReply.getMappingRecordItem().get(0).getMappingRecord().getRecordTtl().intValue());
1898         assertEquals(expectedAction, mapReply.getMappingRecordItem().get(0).getMappingRecord().getAction());
1899     }
1900
1901     private MapRegister createMapRegister(Eid eid, Rloc rloc) {
1902         MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1903         mapRegisterbuilder.setWantMapNotify(true);
1904         mapRegisterbuilder.setNonce((long) 8);
1905         mapRegisterbuilder.setKeyId((short) 0);
1906         MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1907         etlrBuilder.setEid(eid);
1908         etlrBuilder.setRecordTtl(254);
1909         etlrBuilder.setAuthoritative(false);
1910         etlrBuilder.setAction(Action.NoAction);
1911         LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1912         recordBuilder.setRloc(rloc);
1913         etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1914         etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1915         mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1916         mapRegisterbuilder.getMappingRecordItem().add(
1917                 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1918         MapRegister mapRegister = mapRegisterbuilder.build();
1919         return mapRegister;
1920     }
1921
1922     private MapRegister createMapRegister(Eid eid) {
1923         return createMapRegister(eid, LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1924     }
1925
1926     private MapRequest createMapRequest(Eid eid) {
1927         MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1928         mapRequestBuilder.setNonce((long) 4);
1929         mapRequestBuilder.setPitr(false);
1930         mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
1931         mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1932         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1933         mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1934         mapRequestBuilder.getItrRloc().add(
1935                 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1936         MapRequest mr = mapRequestBuilder.build();
1937         return mr;
1938     }
1939
1940     public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1941         cleanUP();
1942         String rloc = "127.0.0.3";
1943         int port = LispMessage.PORT_NUM;
1944         Rloc ipRloc = LispAddressUtil.asIpv4Rloc(rloc);
1945         sendProxyMapRequest(rloc, port, ipRloc);
1946
1947     }
1948
1949     public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1950         cleanUP();
1951         String rloc = "127.0.0.3";
1952         int port = 4350;
1953
1954         RlocBuilder rb = new RlocBuilder();
1955         rb.setAddressType(ApplicationDataLcaf.class);
1956         rb.setVirtualNetworkId(null);
1957         rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1958                 .lisp.address.address.ApplicationDataBuilder()
1959                 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
1960                 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
1961         Rloc adLcaf = rb.build();
1962
1963         LOG.info("testNonProxyOtherPort:" + LispAddressStringifier.getString(adLcaf));
1964         sendProxyMapRequest(rloc, port, adLcaf);
1965
1966     }
1967
1968     private class XtrRequestMappingListener implements OdlLispProtoListener {
1969
1970         @Override
1971         public void onGotMapReply(GotMapReply notification) {
1972         }
1973
1974         @Override
1975         public void onAddMapping(AddMapping notification) {
1976         }
1977
1978         @Override
1979         public void onXtrReplyMapping(XtrReplyMapping notification) {
1980         }
1981
1982         @Override
1983         public void onRequestMapping(RequestMapping notification) {
1984         }
1985
1986         @Override
1987         public void onGotMapNotify(GotMapNotify notification) {
1988         }
1989
1990         @Override
1991         public void onXtrRequestMapping(XtrRequestMapping notification) {
1992         }
1993
1994         @Override
1995         public void onMappingKeepAlive(MappingKeepAlive notification) {
1996         }
1997
1998     }
1999
2000     public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
2001         cleanUP();
2002         configLispPlugin.shouldListenOnXtrPort(true);
2003         notificationCalled = false;
2004         final String eid = "10.10.10.10/32";
2005         String rloc = "127.0.0.3";
2006         int port = LispMessage.XTR_PORT_NUM;
2007
2008         RlocBuilder rb = new RlocBuilder();
2009         rb.setAddressType(ApplicationDataLcaf.class);
2010         rb.setVirtualNetworkId(null);
2011         rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2012                 .lisp.address.address.ApplicationDataBuilder()
2013                 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
2014                 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
2015         Rloc adLcaf = rb.build();
2016
2017         final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2018         ((LispMappingService) lms).getNotificationService().registerNotificationListener(
2019                 new XtrRequestMappingListener() {
2020
2021             @Override
2022             public void onXtrRequestMapping(XtrRequestMapping notification) {
2023                 assertEquals(((Ipv4Prefix) mapRequest.getEidItem().get(0).getEid().getAddress())
2024                         .getIpv4Prefix().getValue(), eid);
2025                 notificationCalled = true;
2026                 LOG.warn("notification arrived");
2027             }
2028         });
2029         sendMapRequest(mapRequest, port);
2030         for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
2031             if (notificationCalled) {
2032                 return;
2033             } else {
2034                 LOG.warn("notification hasn't arrived, sleeping...");
2035                 Thread.sleep(500);
2036             }
2037         }
2038
2039         fail("Notification hasn't arrived");
2040
2041     }
2042
2043     private void sendProxyMapRequest(String rloc, int port, Rloc adLcaf) throws SocketTimeoutException,
2044             SocketException {
2045         String eid = "10.1.0.1/32";
2046         MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2047         sendMapRequest(mapRequest);
2048         DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
2049         MapRequest receivedMapRequest = receiveMapRequest(nonProxySocket);
2050         assertEquals(mapRequest.getNonce(), receivedMapRequest.getNonce());
2051         assertEquals(mapRequest.getSourceEid(), receivedMapRequest.getSourceEid());
2052         assertEquals(mapRequest.getItrRloc(), receivedMapRequest.getItrRloc());
2053         assertEquals(mapRequest.getEidItem(), receivedMapRequest.getEidItem());
2054         nonProxySocket.close();
2055     }
2056
2057     private MapRequest createNonProxyMapRequest(String eid, Rloc adLcaf) throws SocketTimeoutException {
2058         MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixEid(eid));
2059         LocatorRecord record = new LocatorRecordBuilder(mr.getMappingRecordItem().get(0).getMappingRecord()
2060                 .getLocatorRecord().get(0)).setRloc(adLcaf).build();
2061         mr.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().set(0, record);
2062         sendMapRegister(mr);
2063         assertMapNotifyReceived();
2064         MapRequest mapRequest = createMapRequest(LispAddressUtil.asIpv4PrefixEid(eid));
2065         MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
2066         builder.setPitr(true);
2067         mapRequest = builder.build();
2068         return mapRequest;
2069     }
2070
2071     private void assertMapNotifyReceived() throws SocketTimeoutException {
2072         receiveMapNotify();
2073     }
2074
2075     private MapReply receiveMapReply() throws SocketTimeoutException {
2076         return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2077     }
2078
2079     private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
2080         return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(
2081                 datagramSocket, 30000).getData()));
2082     }
2083
2084     private MapNotify receiveMapNotify() throws SocketTimeoutException {
2085         return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2086     }
2087
2088     private void sendMapRequest(MapRequest mapRequest) {
2089         sendMapRequest(mapRequest, LispMessage.PORT_NUM);
2090     }
2091
2092     private void sendMapRequest(MapRequest mapRequest, int port) {
2093         sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
2094     }
2095
2096     private void sendMapRegister(MapRegister mapRegister) {
2097         sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
2098     }
2099
2100     private void sendPacket(byte[] bytesToSend) {
2101         sendPacket(bytesToSend, LispMessage.PORT_NUM);
2102     }
2103
2104     private void sendPacket(byte[] bytesToSend, int port) {
2105         try {
2106             DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
2107             initPacketAddress(packet, port);
2108             LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
2109             socket.send(packet);
2110         } catch (Throwable t) {
2111             fail();
2112         }
2113     }
2114
2115     private DatagramPacket receivePacket() throws SocketTimeoutException {
2116         return receivePacket(6000);
2117     }
2118
2119     private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
2120         return receivePacket(socket, timeout);
2121     }
2122
2123     private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
2124         try {
2125             byte[] buffer = new byte[4096];
2126             DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
2127             LOG.trace("Waiting for packet from socket...");
2128             receivedSocket.setSoTimeout(timeout);
2129             receivedSocket.receive(receivePacket);
2130             LOG.trace("Received packet from socket!");
2131             return receivePacket;
2132         } catch (SocketTimeoutException ste) {
2133             throw ste;
2134         } catch (Throwable t) {
2135             fail();
2136             return null;
2137         }
2138     }
2139
2140     private void sleepForSeconds(int seconds) {
2141         try {
2142             Thread.sleep(seconds*1000);
2143         } catch (InterruptedException e) {
2144             LOG.warn("Interrupted while sleeping", e);
2145         }
2146     }
2147
2148     private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
2149         packet.setAddress(InetAddress.getByName(lispBindAddress));
2150         packet.setPort(port);
2151     }
2152
2153     private DatagramSocket initSocket(DatagramSocket socket, int port) {
2154         try {
2155             socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
2156         } catch (SocketException e) {
2157             e.printStackTrace();
2158             fail();
2159         }
2160         return socket;
2161     }
2162
2163     private byte[] extractWSUdpByteArray(String wiresharkHex) {
2164         final int HEADER_LEN = 42;
2165         byte[] res = new byte[1000];
2166         String[] split = wiresharkHex.split(" ");
2167         int counter = 0;
2168         for (String cur : split) {
2169             cur = cur.trim();
2170             if (cur.length() == 2) {
2171                 ++counter;
2172                 if (counter > HEADER_LEN) {
2173                     res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
2174                 }
2175
2176             }
2177         }
2178         return Arrays.copyOf(res, counter - HEADER_LEN);
2179     }
2180
2181     private String stateToString(int state) {
2182         switch (state) {
2183         case Bundle.ACTIVE:
2184             return "ACTIVE";
2185         case Bundle.INSTALLED:
2186             return "INSTALLED";
2187         case Bundle.RESOLVED:
2188             return "RESOLVED";
2189         case Bundle.UNINSTALLED:
2190             return "UNINSTALLED";
2191         default:
2192             return "Not CONVERTED";
2193         }
2194     }
2195
2196     private void areWeReady() throws InvalidSyntaxException {
2197         sleepForSeconds(5);
2198
2199         assertNotNull(bc);
2200         boolean debugit = false;
2201         Bundle b[] = bc.getBundles();
2202         for (Bundle element : b) {
2203             int state = element.getState();
2204             LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v"
2205                     + element.getVersion() + ", state:" + stateToString(state));
2206             if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
2207                 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
2208
2209                 // try {
2210                 // String host = element.getHeaders().get("FRAGMENT-HOST");
2211                 // if (host != null) {
2212                 // LOG.warn("Bundle " + element.getSymbolicName() +
2213                 // " is a fragment which is part of: " + host);
2214                 // LOG.warn("Required imports are: " +
2215                 // element.getHeaders().get("IMPORT-PACKAGE"));
2216                 // } else {
2217                 // element.start();
2218                 // }
2219                 // } catch (BundleException e) {
2220                 // LOG.error("BundleException:", e);
2221                 // fail();
2222                 // }
2223
2224                 debugit = true;
2225
2226             }
2227         }
2228         if (debugit) {
2229             LOG.warn(("Do some debugging because some bundle is unresolved"));
2230         }
2231         // assertNotNull(broker);
2232
2233         configLispPlugin.setLispAddress(lispBindAddress);
2234
2235         // Uncomment this code to Know which services were actually loaded to
2236         // BundleContext
2237
2238         /*
2239         for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
2240             LOG.info(sr.getBundle().getSymbolicName());
2241             LOG.info(sr.toString());
2242         }
2243         */
2244
2245         sleepForSeconds(1);
2246     }
2247
2248     private void cleanUP() {
2249         after();
2250         mapService.cleanCachedMappings();
2251         configLispPlugin.shouldListenOnXtrPort(false);
2252         socket = initSocket(socket, LispMessage.PORT_NUM);
2253
2254     }
2255
2256     private void restartSocket() {
2257         after();
2258         socket = initSocket(socket, LispMessage.PORT_NUM);
2259     }
2260
2261 }