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