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