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