2 * Copyright (c) 2014, 2017 Contextream, Inc. and others. All rights reserved.
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
8 package org.opendaylight.lispflowmapping.integrationtest;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertNull;
13 import static org.junit.Assert.assertTrue;
14 import static org.junit.Assert.fail;
15 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A;
16 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A_SB;
17 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B;
18 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B_SB;
19 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C;
20 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_NEGATIVE;
21 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_RLOC_10;
22 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_SB;
23 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_100_1_SB;
24 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_50_2_SB;
25 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D4;
26 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D5;
27 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_DELETE_SB;
28 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_100_1_SB;
29 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_50_2_SB;
30 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_E_SB;
31 import static org.ops4j.pax.exam.CoreOptions.composite;
32 import static org.ops4j.pax.exam.CoreOptions.maven;
33 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.configureConsole;
34 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
35 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.keepRuntimeFolder;
37 import com.google.common.collect.Lists;
38 import com.google.common.collect.Sets;
40 import java.io.IOException;
41 import java.net.DatagramSocket;
42 import java.net.InetAddress;
43 import java.net.InetSocketAddress;
44 import java.net.SocketException;
45 import java.net.SocketTimeoutException;
46 import java.net.UnknownHostException;
47 import java.nio.ByteBuffer;
48 import java.util.ArrayList;
49 import java.util.Arrays;
50 import java.util.HashSet;
51 import java.util.List;
53 import javax.inject.Inject;
54 import org.junit.After;
55 import org.junit.Assert;
56 import org.junit.Before;
57 import org.junit.Test;
58 import org.junit.runner.RunWith;
59 import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
60 import org.opendaylight.lispflowmapping.config.ConfigIni;
61 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
62 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
63 import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
64 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
65 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
66 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
67 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
68 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
69 import org.opendaylight.lispflowmapping.lisp.type.MappingData;
70 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
71 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
72 import org.opendaylight.lispflowmapping.lisp.util.MappingRecordUtil;
73 import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
74 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
75 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
76 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
77 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
78 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
79 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AfiListLcaf;
80 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ApplicationDataLcaf;
81 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
82 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
83 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
84 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.KeyValueAddressLcaf;
85 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
86 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
87 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SourceDestKeyLcaf;
88 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
89 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.AfiList;
90 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationData;
91 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
92 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix;
93 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder;
94 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.KeyValueAddress;
95 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
96 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
97 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.afi.list.AfiListBuilder;
98 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.application.data.ApplicationDataBuilder;
99 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.ExplicitLocatorPathBuilder;
100 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;
101 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;
102 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;
103 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
104 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4PrefixBinaryAfi;
107 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4PrefixBinaryBuilder;
108 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
109 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
110 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
111 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
112 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
113 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
114 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
115 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MappingKeepAlive;
116 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MessageType;
117 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.OdlLispProtoListener;
118 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
119 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
120 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
121 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
122 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
123 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItem;
124 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
125 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
126 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
127 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
128 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
129 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
130 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
131 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
132 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
133 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
134 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
135 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
136 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
137 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
138 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
139 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
140 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
141 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
142 import org.ops4j.io.FileUtils;
143 import org.ops4j.pax.exam.Option;
144 import org.ops4j.pax.exam.junit.PaxExam;
145 import org.ops4j.pax.exam.karaf.options.LogLevelOption.LogLevel;
146 import org.ops4j.pax.exam.options.MavenUrlReference;
147 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
148 import org.ops4j.pax.exam.spi.reactors.PerClass;
149 import org.ops4j.pax.exam.util.Filter;
150 import org.osgi.framework.Bundle;
151 import org.osgi.framework.BundleContext;
152 import org.osgi.framework.InvalidSyntaxException;
153 import org.slf4j.Logger;
154 import org.slf4j.LoggerFactory;
156 @RunWith(PaxExam.class)
157 @ExamReactorStrategy(PerClass.class)
158 public class MappingServiceIntegrationTest extends AbstractMdsalTestBase {
159 private static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
161 private byte[] mapRequestPacket;
162 private byte[] mapRegisterPacketWithNotify;
163 private byte[] mapRegisterPacketWithoutNotify;
164 String lispBindAddress = "127.0.0.1";
165 static final String ourAddress = "127.0.0.2";
166 private Rloc locatorEid;
167 private DatagramSocket socket;
168 private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
170 public static final String ODL = "org.opendaylight.controller";
171 public static final String YANG = "org.opendaylight.yangtools";
172 private static final int MULTI_SITE_SLEEP_TIME = 2;
173 private static final int MAX_NOTIFICATION_RETRYS = 20;
174 private static final MappingAuthkey NULL_AUTH_KEY = new MappingAuthkeyBuilder().setKeyType(0).build();
176 // This is temporary, since the properties in the pom file are not picked up
178 public String getKarafDistro() {
180 .groupId("org.opendaylight.lispflowmapping")
181 .artifactId("lispflowmapping-karaf")
182 .versionAsInProject()
188 public MavenUrlReference getFeatureRepo() {
190 .groupId("org.opendaylight.lispflowmapping")
191 .artifactId("features-lispflowmapping")
192 .classifier("features")
194 .versionAsInProject();
198 public String getFeatureName() {
199 return "odl-lispflowmapping-msmr";
203 public Option getLoggingOption() {
204 Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
205 "log4j2.logger.lispflowmapping.name",
206 "org.opendaylight.lispflowmapping");
207 option = composite(option, editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
208 "log4j2.logger.lispflowmapping.level",
209 LogLevel.TRACE.name()));
210 option = composite(option, super.getLoggingOption());
215 protected Option[] getAdditionalOptions() {
216 return new Option[] {
218 configureConsole().ignoreLocalConsole().ignoreRemoteShell()
223 public void testLispFlowMappingFeatureLoad() {
224 Assert.assertTrue(true);
228 public void after() {
229 if (socket != null) {
235 public void before() throws Exception {
236 File paxExamDirectory = new File("target/exam/");
237 FileUtils.delete(paxExamDirectory);
240 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_FIRST);
241 mapService.setMappingMerge(false);
242 ConfigIni.getInstance().setSmrRetryCount(1);
244 socket = MappingServiceIntegrationTestUtil.initSocket(LispMessage.PORT_NUM);
246 // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
247 // LISP(Type = 8 - Encapsulated)
248 // IP: 192.168.136.10 -> 153.16.254.1
250 // LISP(Type = 1 Map-Request
254 // Source EID 1.2.3.4
255 // Nonce: 0x3d8d2acd39c8d608
256 // ITR-RLOC AFI=1 Address=192.168.136.10
257 // Record 1: 153.16.254.1/32
258 mapRequestPacket = extractWSUdpByteArray("0000 00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 "
259 + "0010 00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
260 + "0020 00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
261 + "0030 00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
262 + "0040 fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
263 + "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 "
264 + "0060 00 01 99 10 fe 01");
266 // IP: 192.168.136.10 -> 128.223.156.35
267 // UDP: 49289 -> 4342
268 // LISP(Type = 3 Map-Register, P=1, M=1
272 // AuthDataLength: 20 Data:
273 // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
274 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
276 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
277 // Priority/Weight: 1/100, Multicast Priority/Weight:
281 mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(
282 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 "
283 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
284 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
285 + "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
286 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
287 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 "
288 + "0060 ff 00 00 05 00 01 c0 a8 88 0a");
290 // IP: 192.168.136.10 -> 128.223.156.35
291 // UDP: 49289 -> 4342
292 // LISP(Type = 3 Map-Register, P=1, M=1
295 // Key ID: 0x0000 NO AUTHENTICATION!!
296 // AuthDataLength: 00 Data:
297 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
299 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
300 // Priority/Weight: 1/100, Multicast Priority/Weight:
304 mapRegisterPacketWithNotify = extractWSUdpByteArray(
305 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 "
306 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
307 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
308 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
309 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
310 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 "
311 + "0060 ff 00 00 05 00 01 c0 a8 88 0a");
313 // IP: 192.168.136.10 -> 128.223.156.35
314 // UDP: 49289 -> 4342
315 // LISP(Type = 3 Map-Register, P=1, M=1
318 // Key ID: 0x0000 NO AUTHENTICATION!!
319 // AuthDataLength: 00 Data:
320 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
322 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
323 // Priority/Weight: 1/100, Multicast Priority/Weight:
327 mapRegisterPacketWithoutNotify = extractWSUdpByteArray(
328 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 "
329 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
330 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
331 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
332 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
333 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 "
334 + "0060 ff 00 00 05 00 01 c0 a8 88 0a");
338 private BundleContext bc;
339 //private HttpURLConnection connection;
340 protected static boolean notificationCalled;
342 @Inject @Filter(timeout=60000)
343 private IFlowMapping lms;
345 @Inject @Filter(timeout=60000)
346 private IMappingService mapService;
348 @Inject @Filter(timeout=10000)
349 private IConfigLispSouthboundPlugin configLispPlugin;
352 public void testSimpleUsage() throws Exception {
354 mapRegisterWithMapNotify();
355 mapRegisterWithMapNotifyAndMapRequest();
356 registerAndQuery__MAC();
357 mapRequestMapRegisterAndMapRequest();
358 mapRegisterWithAuthenticationWithoutConfiguringAKey();
359 mapRegisterWithoutMapNotify();
363 public void testLCAFs() throws Exception {
364 registerAndQuery__SrcDestLCAF();
365 registerAndQuery__SrcDestLCAFOverlap();
366 registerAndQuery__KeyValueLCAF();
367 //registerAndQuery__ListLCAF();
368 //registerAndQuery__ApplicationData();
369 //registerAndQuery__TrafficEngineering();
370 //registerAndQuery__SegmentLCAF();
374 public void testMask() throws Exception {
375 //testPasswordExactMatch(); TODO commented because it needs NB
376 //testPasswordMaskMatch(); TODO commented because it needs NB
377 eidPrefixLookupIPv4();
378 eidPrefixLookupIPv6();
382 public void testNorthbound() throws Exception {
384 northboundAddMapping();
385 northboundDeleteMapping();
386 northboundRetrieveKey();
387 northboundRetrieveMapping();
388 northboundRetrieveSourceDestKey();
389 northboundRetrieveSourceDestMapping();
393 public void testTimeOuts() throws Exception {
394 timedOutMappingRecord();
395 mapRequestMapRegisterAndMapRequestTestTimeout();
396 //mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse(); TODO commented because it needs NB
400 // public void testNonProxy() throws Throwable {
401 // testSimpleNonProxy();
402 // testNonProxyOtherPort();
403 // testRecievingNonProxyOnXtrPort();
407 public void testSmr() throws Exception {
408 registerQueryRegisterWithSmr();
413 public void testMultiSite() throws Exception {
414 testMultiSiteScenarioA();
415 testMultiSiteScenarioB();
419 public void testNbAndSbNegativePrefix() throws UnknownHostException {
421 testGapIntersection();
424 testMultipleMappings();
428 public void testExplicitSbNegativePrefixes() {
429 // https://bugs.opendaylight.org/show_bug.cgi?id=8679
430 testNegativePrefix();
432 // https://bugs.opendaylight.org/show_bug.cgi?id=9023
433 testPositiveMappingRemoval();
435 // https://bugs.opendaylight.org/show_bug.cgi?id=9037
436 testPositivePrefixOverlappingNegativePrefix_moreSpecific();
438 // https://bugs.opendaylight.org/show_bug.cgi?id=9116
439 testPositivePrefixOverlappingNegativePrefix_lessSpecific();
443 public void testMappingChangeCases() {
444 // Test numbers described in the below Google Sheet:
445 // https://docs.google.com/spreadsheets/d/1we3eBBilS-HoAZgtHH3jtmvq4-6lBvVX2yMgxfF48w0/edit?usp=sharing
450 test4NBtoNBmoreSpecific();
451 test5NBtoNBexactMatch();
452 test6NBtoNBlessSpecific();
453 test7NBtoSBmoreSpecific();
454 test8NBtoSBexactMatch();
455 test9NBtoSBlessSpecific();
456 test10deleteSBpositive();
457 test11SBpositiveToNBmoreSpecific();
458 test12SBpositiveToNBexactMatch();
459 test13SBtoNBlessSpecific();
460 test14SBpositiveToSBmoreSpecific();
461 test15SBpositiveToSBexactMatch();
462 test16SBpositiveToSBlessSpecific();
463 test17deleteSBnegative();
464 test18SBnegativeToNBmoreSpecific();
465 test19SBnegativeToNBexactMatch();
466 test20SBnegativeToNBlessSpecific();
467 test21SBnegativeToSBmoreSpecific();
468 test22SBnegativeToSBexactMatch();
469 test23SBnegativeToSBlessSpecific();
476 private void testRepeatedSmr() throws SocketTimeoutException, UnknownHostException {
478 long timeout = ConfigIni.getInstance().getSmrTimeout();
479 ConfigIni.getInstance().setSmrRetryCount(5);
481 final InstanceIdType iid = new InstanceIdType(1L);
482 final Eid eid1 = LispAddressUtil.asIpv4Eid("1.1.1.1", 1L);
483 final Eid subscriberEid = LispAddressUtil.asIpv4Eid("2.2.2.2", 1L);
484 final int expectedSmrs1 = 2;
485 final int expectedSmrs2 = 3;
488 final Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", iid);
489 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
491 /* add subscribers */
492 final String subscriberSrcRloc1 = "127.0.0.3";
493 final String subscriberSrcRloc2 = "127.0.0.4";
494 final Set<Subscriber> subscriberSet1 = Sets.newHashSet(newSubscriber(subscriberEid, subscriberSrcRloc1),
495 newSubscriber(subscriberEid, subscriberSrcRloc2));
496 mapService.addData(MappingOrigin.Southbound, eid1, SubKeys.SUBSCRIBERS, subscriberSet1);
498 final SocketReader reader1 = startSocketReader(subscriberSrcRloc1, 15000);
499 final SocketReader reader2 = startSocketReader(subscriberSrcRloc2, 15000);
503 final MappingRecord mapping1 = new MappingRecordBuilder()
504 .setEid(eid1).setTimestamp(System.currentTimeMillis()).setRecordTtl(1440).build();
505 mapService.addMapping(MappingOrigin.Northbound, eid1, null, new MappingData(mapping1));
507 sleepForMilliseconds((timeout * expectedSmrs1) - (timeout / 2));
508 final List<MapRequest> requests1 = processSmrPackets(reader1, subscriberSrcRloc1, expectedSmrs1);
509 final MapReply mapReply1 = lms.handleMapRequest(
510 new MapRequestBuilder(requests1.get(0))
511 .setSourceEid(new SourceEidBuilder().setEid(subscriberEid).build())
512 .setItrRloc(Lists.newArrayList(new ItrRlocBuilder()
513 .setRloc(LispAddressUtil.asIpv4Rloc(subscriberSrcRloc1)).build()))
514 .setEidItem(Lists.newArrayList(new EidItemBuilder().setEid(eid1).build()))
516 .setSmr(false).build());
518 // sleep to get 1 extra smr request
519 sleepForMilliseconds(timeout * 1);
520 final List<MapRequest> requests2 = processSmrPackets(reader2, subscriberSrcRloc2, expectedSmrs2);
521 final MapReply mapReply2 = lms.handleMapRequest(
522 new MapRequestBuilder(requests2.get(0))
523 .setSourceEid(new SourceEidBuilder().setEid(subscriberEid).build())
524 .setItrRloc(Lists.newArrayList(new ItrRlocBuilder()
525 .setRloc(LispAddressUtil.asIpv4Rloc(subscriberSrcRloc2)).build()))
526 .setEidItem(Lists.newArrayList(new EidItemBuilder().setEid(eid1).build()))
528 .setSmr(false).build());
531 assertEquals(expectedSmrs1, requests1.size());
532 assertEquals(expectedSmrs2, requests2.size());
533 assertEquals((long) mapReply1.getNonce(), (long) requests1.get(0).getNonce());
534 assertEquals((long) mapReply2.getNonce(), (long) requests2.get(0).getNonce());
535 assertNextBufferEmpty(reader1);
536 assertNextBufferEmpty(reader2);
538 reader1.stopReading();
539 reader2.stopReading();
542 private SocketReader startSocketReader(String address, int timeout) {
543 DatagramSocket receivingSocket = null;
546 receivingSocket = new DatagramSocket(new InetSocketAddress(address, LispMessage.PORT_NUM));
547 } catch (SocketException e) {
548 LOG.error("Can't initialize socket for {}", address, e);
550 return SocketReader.startReadingInStandaloneThread(receivingSocket, timeout);
553 private List<MapRequest> processSmrPackets(SocketReader reader, String address, int expectedSmrs) {
554 InetAddress inetAddress = null;
556 inetAddress = InetAddress.getByName(address);
557 } catch (UnknownHostException e) {
558 LOG.error("Unknown address {}.", address, e);
561 final List<MapRequest> requests = Lists.newArrayList();
562 byte[][] buffers = reader.getBuffers(expectedSmrs);
563 for (byte[] buf : buffers) {
564 ByteBuffer packet = ByteBuffer.wrap(buf);
565 if (MappingServiceIntegrationTestUtil.checkType(packet, MessageType.MapRequest)) {
566 MapRequest request = MapRequestSerializer.getInstance().deserialize(packet, inetAddress);
567 requests.add(request);
573 private void assertNextBufferEmpty(SocketReader socketReader) {
574 assertTrue(MultiSiteScenario.areBuffersEmpty(socketReader.getBuffers(1)));
577 private static Subscriber newSubscriber(Eid srcEid, String srcRlocIp) {
578 final int timeout = 5;
579 final Rloc srcRloc = LispAddressUtil.asIpv4Rloc(srcRlocIp);
580 return new Subscriber(srcRloc, srcEid, timeout);
583 private void testMultipleMappings() throws UnknownHostException {
584 final InstanceIdType iid = new InstanceIdType(1L);
585 final String prefix1 = "1.1.127.10/32"; // prefix from the intersection of NB and SB gaps
586 final String prefix2 = "1.1.200.255/32"; // prefix with existing mapping in NB
587 final String prefix3 = "1.3.255.255/32";
589 final MapRequest mapRequest = new MapRequestBuilder().setSmrInvoked(false).setEidItem(Lists.newArrayList(
590 new EidItemBuilder().setEid(LispAddressUtil.asIpv4PrefixBinaryEid(prefix1, iid))
592 new EidItemBuilder().setEid(LispAddressUtil.asIpv4PrefixBinaryEid(prefix2, iid))
594 new EidItemBuilder().setEid(LispAddressUtil.asIpv4PrefixBinaryEid(prefix3, iid))
597 final MapReply mapReply = lms.handleMapRequest(mapRequest);
600 final String resultPrefix1 = "1.1.64.0";
601 final Address resultNegMapping1 = new Ipv4PrefixBinaryBuilder()
602 .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName(resultPrefix1).getAddress()))
603 .setIpv4MaskLength((short) 18).build();
605 final String resultPrefix2 = "1.1.128.0";
606 final Address resultMapping2 = new Ipv4PrefixBinaryBuilder()
607 .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName(resultPrefix2).getAddress()))
608 .setIpv4MaskLength((short) 17).build();
610 final String resultPrefix3 = "1.3.0.0";
611 final Address resultNegMapping3 = new Ipv4PrefixBinaryBuilder()
612 .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName(resultPrefix3).getAddress()))
613 .setIpv4MaskLength((short) 16).build();
615 assertEquals(resultNegMapping1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getEid()
617 assertEquals(resultMapping2, mapReply.getMappingRecordItem().get(1).getMappingRecord().getEid()
619 assertEquals(resultNegMapping3, mapReply.getMappingRecordItem().get(2).getMappingRecord().getEid()
624 * Tests a negative mapping from an intersection of gaps in northbound and southbound.
626 private void testGapIntersection() throws UnknownHostException {
627 // request an Eid from a gap between mappings
628 final MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "1.1.127.10/32"));
630 // expected negative mapping
631 final Address resultNegMapping = new Ipv4PrefixBinaryBuilder()
632 .setIpv4AddressBinary(new Ipv4AddressBinary(InetAddress.getByName("1.1.64.0").getAddress()))
633 .setIpv4MaskLength((short) 18).build();
634 assertEquals(resultNegMapping, mapReply.getMappingRecordItem().get(0).getMappingRecord().getEid()
638 private void testNegativePrefix() {
639 // First, we test with one mapping in NB and one mapping in SB
641 allowNullAuthenticationForAllIPv4(1L);
643 insertNBMappings(1L, "192.0.2.0/24");
644 insertSBMappings(false, 1L, "10.0.0.0/32");
649 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "11.1.1.1/32"));
650 Eid expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "11.0.0.0/8");
651 assertEquals(expectedNegativePrefix, mapReply.getMappingRecordItem().get(0).getMappingRecord().getEid());
652 assertTrue(MappingRecordUtil.isNegativeMapping(mapReply.getMappingRecordItem().get(0).getMappingRecord()));
654 // Second, we test with two mappings in NB only
657 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
662 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
663 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
664 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
665 assertEquals(expectedNegativePrefix, mr.getEid());
666 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
669 private void testPositiveMappingRemoval() {
671 allowNullAuthenticationForAllIPv4(1L);
673 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
674 insertSBMappings(false, 1L, "192.168.32.0/19");
676 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
677 Eid expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/19");
678 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
679 assertEquals(expectedNegativePrefix, mr.getEid());
680 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
682 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.64.1/32"));
683 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.64.0/18");
684 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
685 assertEquals(expectedNegativePrefix, mr.getEid());
686 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
688 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.128.1/32"));
689 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.128.0/17");
690 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
691 assertEquals(expectedNegativePrefix, mr.getEid());
692 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
694 MappingServiceIntegrationTestUtil.printMapCacheState(mapService);
696 mapService.removeMapping(MappingOrigin.Southbound, LispAddressUtil.asIpv4PrefixBinaryEid(
697 1L, "192.168.32.0/19"));
699 MappingServiceIntegrationTestUtil.printMapCacheState(mapService);
701 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.32.1/32"));
702 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
703 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
704 assertEquals(expectedNegativePrefix, mr.getEid());
705 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
707 MappingServiceIntegrationTestUtil.printMapCacheState(mapService);
710 private void testPositivePrefixOverlappingNegativePrefix_moreSpecific() {
713 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
715 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
716 Eid expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
717 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
718 assertEquals(expectedNegativePrefix, mr.getEid());
719 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
721 insertNBMappings(1L, "192.168.1.0/24");
722 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
724 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
725 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/24");
726 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
727 assertEquals(expectedNegativePrefix, mr.getEid());
728 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
731 private void testPositivePrefixOverlappingNegativePrefix_lessSpecific() {
734 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
736 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
737 Eid expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
738 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
739 assertEquals(expectedNegativePrefix, mr.getEid());
740 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
742 insertNBMappings(1L, "192.0.0.0/8");
743 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
745 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
746 Eid expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.0.0.0/8");
747 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
748 assertEquals(expectedPositivePrefix, mr.getEid());
749 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
753 * Mapping change: NO old mapping, new mapping is from northbound
754 * Support status: SUPPORTED
755 * Description: If no mappings exists in either NB or SB, that means no subscriptions exist either, so
756 * this is just a simple case of adding a new mapping, no SMR required.
758 private void test1nullToNB() {
761 insertNBMappings(1L, "192.168.0.0/16");
762 MappingServiceIntegrationTestUtil.assertNoMoreSMRs(socket, mapService);
766 * Mapping change: NO old mapping, new mapping is from southbound
767 * Support status: SUPPORTED
768 * Description: If no mappings exists in either NB or SB, that means no subscriptions exist either, so
769 * this is just a simple case of adding a new mapping, no SMR required.
771 private void test2nullToSB() {
773 allowNullAuthenticationForAllIPv4(1L);
775 registerSBMapping(1L, "192.168.0.0/16", "10.10.10.10");
776 MappingServiceIntegrationTestUtil.assertNoMoreSMRs(socket, mapService);
780 * Mapping change: deleting a mapping from northbound
781 * Support status: SUPPORTED
782 * Description: When a NB mapping is deleted, its subscribers, and the subscribers of its children are notified.
784 private void test3deleteNB() {
786 allowNullAuthenticationForAllIPv4(1L);
788 // Overlapping SB mapping, which will stay
789 insertSBMappings(false, 1L, "192.168.255.0/24");
790 // Subscribe to the overlapping SB mapping
791 lms.handleMapRequest(newMapRequest(1L, "192.168.255.1/32"));
792 // NB mapping which will be removed
793 insertNBMappings(1L, "192.168.0.0/16");
794 // The child prefix is notified of the change
795 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.255.0");
796 // The above SMR will result in a SMR-invoked Map-Request for 192.168.255.0/32, which in turn will result in
797 // subscribing to the new NB mapping
800 removeNBMapping(1L, "192.168.0.0/16");
801 // The removed prefix and the child prefix are both notified of the change
802 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0", "192.168.255.0");
806 * Mapping change: adding a more specific northbound mapping overlapping a less specific one
807 * Support status: PARTIALLY SUPPORTED (?)
808 * Description: Overlapping prefixes in general are not "officially" supported in NB and should not be used.
809 * That said, adding a more specific does result in an SMR, but adding a less specific does not (see
812 private void test4NBtoNBmoreSpecific() {
815 // Original (less specific) NB mapping
816 insertNBMappings(1L, "192.168.0.0/16");
817 // Subscribe, by sending a Map-Request
818 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
819 // Add the more specific new overlapping mapping
820 insertNBMapping(1L, "192.168.1.0/24", "10.10.10.10");
821 // No notification is sent
822 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
826 * Mapping change: updating a northbound mapping
827 * Support status: SUPPORTED
828 * Description: Simple case of updating an exact match NB prefix.
830 private void test5NBtoNBexactMatch() {
833 // Original NB mapping
834 insertNBMappings(1L, "192.168.0.0/16");
835 // Subscribe, by sending a Map-Request
836 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
837 // Updated NB mapping with different locator set for the same exact prefix
838 insertNBMapping(1L, "192.168.0.0/16", "10.10.10.10");
839 // Notification is sent for the prefix
840 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
844 * Mapping change: adding a less specific northbound mapping overlapping a more specific one
845 * Support status: NOT SUPPORTED
846 * Description: Overlapping prefixes in general are not "officially" supported in NB and should not be used.
847 * That said, adding a more specific does result in an SMR (see test 4 above), but adding a less
850 private void test6NBtoNBlessSpecific() {
853 // Original (more specific) NB mapping
854 insertNBMappings(1L, "192.168.0.0/16");
855 // Subscribe, by sending a Map-Request
856 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
857 // Add the less specific new overlapping mapping
858 insertNBMapping(1L, "192.0.0.0/8", "10.10.10.10");
859 // No notification is sent
860 MappingServiceIntegrationTestUtil.assertNoMoreSMRs(socket, mapService);
864 * Mapping change: adding a more specific southbound mapping overlapping a less specific northbound mapping
865 * Support status: SUPPORTED
866 * Description: This is not an issue for NB_FIRST, since there is no change in the resolved mappings for the
867 * prefix range covered by the existing NB mapping. For NB_AND_SB it does make a difference, and that
870 private void test7NBtoSBmoreSpecific() {
872 allowNullAuthenticationForAllIPv4(1L);
873 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_AND_SB);
875 // Original (less specific) NB mapping
876 insertNBMapping(1L, "192.168.0.0/16", "172.16.0.1", "10.10.10.10");
877 // Subscribe, by sending a Map-Request
878 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
879 // Add the more specific new overlapping SB mapping
880 registerSBMapping(1L, "192.168.1.0/24", "10.10.10.10");
881 // Notification is sent for the original prefix
882 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
886 * Mapping change: adding a southbound mapping matching a northbound mapping
887 * Support status: SUPPORTED
888 * Description: When a SB mapping is added that has an existing exact match NB counterpart the subscribers of the
889 * prefix are notified. This is not strictly necessary for the NB_FIRST policy, but it is still useful
890 * for the NB_AND_SB policy.
892 private void test8NBtoSBexactMatch() {
894 allowNullAuthenticationForAllIPv4(1L);
895 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_AND_SB);
897 // Original NB mapping
898 insertNBMapping(1L, "192.168.0.0/16", "172.16.0.1", "10.10.10.10");
899 // Subscribe, by sending a Map-Request
900 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
901 // Add a mapping with the same EID but different locator set in SB
902 registerSBMapping(1L, "192.168.0.0/16", "10.10.10.10");
903 // Notification is sent for the prefix
904 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
908 * Mapping change: adding a less specific southbound mapping overlapping a more specific northbound mapping
909 * Support status: PARTIALLY SUPPORTED (?)
910 * Description: When a less specific SB mapping is added no SMR is sent, but for the NB mapping subscribers there
911 * is no actual change in the mapping. Part of the southbound prefix is not covered by the existing NB,
912 * and queries for that part will resolve to the full SB prefix, shadowing the NB prefix. This is a
913 * general problem with overlapping prefixes, but this particular combination is pretty bad.
915 private void test9NBtoSBlessSpecific() {
917 allowNullAuthenticationForAllIPv4(1L);
919 // Original (more specific) NB mapping
920 insertNBMappings(1L, "192.168.0.0/16");
921 // Subscribe, by sending a Map-Request
922 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
923 // Add the less specific new overlapping SB mapping
924 registerSBMapping(1L, "192.0.0.0/8", "10.10.10.10");
925 // No notification is sent
926 MappingServiceIntegrationTestUtil.assertNoMoreSMRs(socket, mapService);
930 * Mapping change: deleting a positive mapping from southbound
931 * Support status: SUPPORTED
932 * Description: When a positive SB mapping is deleted, its subscribers, and the subscribers of its children are
935 private void test10deleteSBpositive() {
937 allowNullAuthenticationForAllIPv4(1L);
939 // Overlapping SB mapping, which will stay
940 insertSBMappings(false, 1L, "192.168.255.0/24");
941 // Subscribe to the overlapping SB mapping
942 lms.handleMapRequest(newMapRequest(1L, "192.168.255.1/32"));
943 // Overlapping negative mapping
944 insertSBMappings(true, 1L, "192.168.127.0/24");
945 // Subscribe to the overlapping negative SB mapping
946 lms.handleMapRequest(newMapRequest(1L, "192.168.127.1/32"));
947 // Positive SB mapping which will be removed
948 insertSBMappings(false, 1L, "192.168.0.0/16");
949 // The child prefix is notified of the change
950 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.127.0", "192.168.255.0");
951 // The above SMR will result in a SMR-invoked Map-Request for 192.168.255.0/32 and 192.168.255.0/32, which in
952 // turn will result in subscribing to the new SB mapping
954 // Remove positive SB mapping
955 removeSBMapping(1L, "192.168.0.0/16");
956 // The removed prefix and the child prefix are both notified of the change
957 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0", "192.168.255.0");
961 * Mapping change: adding a more specific northbound mapping overlapping a less specific southbound mapping
962 * Support status: PARTIALLY SUPPORTED (?)
963 * Description: This mapping change is detected and an SMR is sent, but the EID prefix in it is for the base address
964 * of the old prefix. When xTRs query for that, they won't actually install the new mapping. This is
965 * one of those cases where saving the original request causing the subscription would help the xTR get
966 * the correct mapping. Additionally, similar to case 9 above, this combination will shadow the NB
967 * mapping for new requests into the non-overlapping part.
969 private void test11SBpositiveToNBmoreSpecific() {
971 allowNullAuthenticationForAllIPv4(1L);
973 // Original (less specific) SB mapping
974 insertSBMappings(false, 1L, "192.168.0.0/16");
975 // Subscribe, by sending a Map-Request
976 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
977 // Add the more specific new overlapping NB mapping
978 insertNBMappings(1L, "192.168.1.0/24");
979 // Notification is sent for the original prefix
980 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
984 * Mapping change: adding a northbound mapping matching a southbound mapping
985 * Support status: SUPPORTED
986 * Description: When a NB mapping is added that has an existing exact match SB counterpart, the subscribers of the
987 * prefix are notified.
989 private void test12SBpositiveToNBexactMatch() {
991 allowNullAuthenticationForAllIPv4(1L);
993 // Original SB mapping
994 insertSBMappings(false, 1L, "192.168.0.0/16");
995 // Subscribe, by sending a Map-Request
996 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
997 // Add a mapping with the same EID but different locator set in NB
998 insertNBMappings(1L, "192.168.0.0/16");
999 // Notification is sent for the prefix
1000 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1004 * Mapping change: adding a less specific northbound mapping overlapping a more specific southbound mapping
1005 * Support status: PARTIALLY SUPPORTED (?)
1006 * Description: No SMR is sent, but the NB mapping takes precedence for new requests.
1008 private void test13SBtoNBlessSpecific() {
1010 allowNullAuthenticationForAllIPv4(1L);
1012 // Original (more specific) SB mapping
1013 insertNBMappings(1L, "192.168.0.0/16");
1014 // Subscribe, by sending a Map-Request
1015 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1016 // Add the less specific new overlapping SB mapping
1017 registerSBMapping(1L, "192.0.0.0/8", "10.10.10.10");
1018 // No notification is sent
1019 MappingServiceIntegrationTestUtil.assertNoMoreSMRs(socket, mapService);
1023 * Mapping change: adding a more specific southbound mapping overlapping a less specific one
1024 * Support status: SUPPORTED
1025 * Description: When a more specific SB mapping is added, the subscribers of the overlapping less specific existing
1026 * SB mapping are notified.
1028 private void test14SBpositiveToSBmoreSpecific() {
1030 allowNullAuthenticationForAllIPv4(1L);
1032 insertSBMappings(false, 1L, "192.168.0.0/16");
1034 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1035 Eid expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
1036 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1037 assertEquals(expectedPositivePrefix, mr.getEid());
1038 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
1040 registerSBMapping(1L, "192.168.254.0/24", "10.10.10.10");
1041 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1043 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1044 expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
1045 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1046 assertEquals(expectedPositivePrefix, mr.getEid());
1047 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
1049 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.254.1/32"));
1050 expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.254.0/24");
1051 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1052 assertEquals(expectedPositivePrefix, mr.getEid());
1053 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
1057 * Mapping change: updating a southbound mapping
1058 * Support status: SUPPORTED
1059 * Description: Simple case of updating an exact match SB prefix.
1061 private void test15SBpositiveToSBexactMatch() {
1063 allowNullAuthenticationForAllIPv4(1L);
1065 // Original SB mapping
1066 insertSBMappings(false, 1L, "192.168.0.0/16");
1067 // Subscribe, by sending a Map-Request
1068 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1069 // Updated SB mapping with different locator set for the same exact prefix
1070 registerSBMapping(1L, "192.168.0.0/16", "10.10.10.10");
1071 // Notification is sent for the prefix
1072 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1076 * Mapping change: adding a less specific southbound mapping overlapping a more specific one
1077 * Support status: SUPPORTED
1078 * Description: When a less specific SB mapping is added, all child prefixes with subscribers are notified.
1080 private void test16SBpositiveToSBlessSpecific() {
1082 allowNullAuthenticationForAllIPv4(1L);
1084 // Original (more specific) SB mapping
1085 insertSBMappings(false, 1L, "192.168.0.0/16");
1086 // Subscribe, by sending a Map-Request
1087 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1088 // Add the less specific new overlapping SB mapping
1089 registerSBMapping(1L, "192.0.0.0/8", "10.10.10.10");
1090 // Notification is sent for the original prefix
1091 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1095 * Mapping change: deleting a negative mapping from southbound
1096 * Support status: SUPPORTED
1097 * Description: When a negative SB mapping is deleted, its subscribers are notified.
1099 private void test17deleteSBnegative() {
1101 allowNullAuthenticationForAllIPv4(1L);
1103 // First we add two negative mappings to NB with a hole between them
1104 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
1105 // We query for the hole, adding a negative SB mapping for 192.168.0.0/16 with a subscriber in the process
1106 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1107 // Remove positive SB mapping
1108 removeSBMapping(1L, "192.168.0.0/16");
1109 // Notification is sent for the prefix
1110 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1114 * Mapping change: adding a more specific northbound mapping overlapping a less specific negative southbound mapping
1115 * Support status: SUPPORTED
1116 * Description: When a more specific NB mapping is added, the overlapping negative prefix is deleted, its
1117 * subscribers notified, and then more specific negatives are created when requested.
1119 private void test18SBnegativeToNBmoreSpecific() {
1122 // First we add two negative mappings to NB with a hole between them
1123 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
1124 // We query for the hole, adding a negative SB mapping for 192.168.0.0/16 with a subscriber in the process
1125 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1126 Eid expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
1127 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1128 assertEquals(expectedNegativePrefix, mr.getEid());
1129 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
1131 // Add the more specific new overlapping NB mapping
1132 insertNBMappings(1L, "192.168.1.0/24");
1133 // Notification is sent for the original prefix
1134 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1136 // The original negative should now be broken up
1137 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1138 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/24");
1139 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1140 assertEquals(expectedNegativePrefix, mr.getEid());
1141 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
1143 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.64.1/32"));
1144 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.64.0/18");
1145 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1146 assertEquals(expectedNegativePrefix, mr.getEid());
1147 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
1149 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.1.1/32"));
1150 Eid expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.1.0/24");
1151 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1152 assertEquals(expectedPositivePrefix, mr.getEid());
1153 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
1157 * Mapping change: adding a northbound mapping matching a negative southbound mapping
1158 * Support status: SUPPORTED
1159 * Description: When a NB mapping is added that has an existing exact match negative SB counterpart,
1160 * the subscribers of the prefix are notified, and the negative is deleted.
1162 private void test19SBnegativeToNBexactMatch() {
1165 // First we add two negative mappings to NB with a hole between them
1166 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
1167 // We query for the hole, adding a negative SB mapping for 192.168.0.0/16 with a subscriber in the process
1168 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1169 insertNBMappings(1L, "192.168.0.0/16");
1170 // Notification is sent for the prefix
1171 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0", "192.168.0.0");
1175 * Mapping change: adding a less specific northbound mapping overlapping a more specific negative southbound mapping
1176 * Support status: PARTIALLY SUPPORTED (?)
1177 * Description: When a less specific NB mapping covering a more specific negative SB mapping is added, the negative
1178 * is deleted and its subscribers notified. Depending on the particular xTR map-cache implementation,
1179 * the negative prefix may or may not stay cached (hence partially supported).
1181 private void test20SBnegativeToNBlessSpecific() {
1183 allowNullAuthenticationForAllIPv4(1L);
1185 // Add a negative mapping
1186 insertSBMappings(true, 1L, "192.168.0.0/16");
1187 // Subscribe for the mapping
1188 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1189 // Add less specific northbound mapping
1190 insertNBMappings(1L, "192.0.0.0/8");
1191 // Notification is sent for the negative prefix
1192 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1196 * Mapping change: adding a more specific southbound mapping overlapping a less specific negative mapping
1197 * Support status: SUPPORTED
1198 * Description: When a more specific SB mapping is added, the subscribers of the overlapping less specific existing
1199 * negative SB mapping are notified, the negative is deleted, and then more specific negatives are
1200 * created when requested.
1202 private void test21SBnegativeToSBmoreSpecific() {
1204 allowNullAuthenticationForAllIPv4(1L);
1206 // First we add two negative mappings to NB with a hole between them
1207 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
1208 // We query for the hole, adding a negative SB mapping for 192.168.0.0/16 with a subscriber in the process
1209 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1210 Eid expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
1211 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1212 assertEquals(expectedNegativePrefix, mr.getEid());
1213 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
1215 // Add the more specific new overlapping SB mapping
1216 registerSBMapping(1L, "192.168.254.0/24", "10.10.10.10");
1217 // Notification is sent for the original prefix
1218 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L,"192.168.0.0");
1220 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1221 expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/17");
1222 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1223 assertEquals(expectedNegativePrefix, mr.getEid());
1224 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
1226 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.254.1/32"));
1227 Eid expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.254.0/24");
1228 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1229 assertEquals(expectedPositivePrefix, mr.getEid());
1230 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
1234 * Mapping change: updating a negative southbound mapping with a positive one
1235 * Support status: SUPPORTED
1236 * Description: Simple case of updating an exact match SB prefix.
1238 private void test22SBnegativeToSBexactMatch() {
1240 allowNullAuthenticationForAllIPv4(1L);
1242 // First we add two negative mappings to NB with a hole between them
1243 insertNBMappings(1L, "192.167.0.0/16", "192.169.0.0/16");
1244 // We query for the hole, adding a negative SB mapping for 192.168.0.0/16 with a subscriber in the process
1245 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1246 Eid expectedNegativePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
1247 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1248 assertEquals(expectedNegativePrefix, mr.getEid());
1249 assertTrue(MappingRecordUtil.isNegativeMapping(mr));
1250 // Updated SB mapping with different locator set for the same exact prefix
1251 registerSBMapping(1L, "192.168.0.0/16", "10.10.10.10");
1252 // Notification is sent for the prefix
1253 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1255 mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1256 Eid expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
1257 mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1258 assertEquals(expectedPositivePrefix, mr.getEid());
1259 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
1263 * Mapping change: adding a less specific southbound mapping overlapping a more specific negative mapping
1264 * Support status: SUPPORTED
1265 * Description: When a less specific SB mapping is added, all child prefixes with subscribers are notified. In this
1266 * case, the overlapping more specific negative is removed.
1268 private void test23SBnegativeToSBlessSpecific() {
1270 allowNullAuthenticationForAllIPv4(1L);
1272 // Add a negative mapping
1273 insertSBMappings(true, 1L, "192.168.0.0/16");
1274 // Subscribe for the mapping
1275 lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1276 // Add less specific southbound mapping
1277 registerSBMapping(1L, "192.0.0.0/8", "10.10.10.10");
1278 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1281 private void testNbSourceDest() {
1284 insertNBMappingSourceDest(1L, "192.0.2.0/24", "192.168.0.0/16",
1285 MappingServiceIntegrationTestUtil.DEFAULT_IPV4_RLOC_STRING);
1287 MapReply mapReply = lms.handleMapRequest(newMapRequest(1L, "192.168.0.1/32"));
1288 Eid expectedPositivePrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "192.168.0.0/16");
1289 MappingRecord mr = mapReply.getMappingRecordItem().get(0).getMappingRecord();
1290 assertEquals(expectedPositivePrefix, mr.getEid());
1291 assertTrue(MappingRecordUtil.isPositiveMapping(mr));
1293 insertNBMapping(1L, "192.168.0.0/16", "10.10.10.10");
1294 MappingServiceIntegrationTestUtil.checkSmr(socket, lms, mapService, 1L, "192.168.0.0");
1297 private void testSubtree() {
1299 allowNullAuthenticationForAllIPv4(1L);
1301 insertSBMappings(false, 1L, "10.0.0.0/8",
1302 "10.0.0.0/16", "10.2.0.0/16", "10.255.0.0/16");
1303 Eid queryPrefix = LispAddressUtil.asIpv4PrefixBinaryEid(1L, "10.0.0.0/9");
1304 Set<Eid> subtreePrefixes = mapService.getSubtree(MappingOrigin.Southbound, queryPrefix);
1305 LOG.debug("Subtree prefix set for EID {}: {}", LispAddressStringifier.getString(queryPrefix),
1306 LispAddressStringifier.getString(subtreePrefixes));
1307 Set<Eid> expectedSubtreePrefixes = new HashSet<>();
1308 expectedSubtreePrefixes.add(LispAddressUtil.asIpv4PrefixBinaryEid(1L, "10.0.0.0/16"));
1309 expectedSubtreePrefixes.add(LispAddressUtil.asIpv4PrefixBinaryEid(1L, "10.2.0.0/16"));
1310 assertEquals(expectedSubtreePrefixes, subtreePrefixes);
1313 private void insertMappings() {
1315 allowNullAuthenticationForAllIPv4(1L);
1316 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_AND_SB);
1318 insertNBMappings(1L, "1.2.0.0/16", "1.1.128.0/17");
1319 insertSBMappings(false, 1L, "1.1.32.0/19", "1.0.0.0/8");
1325 private void insertNBMappings(long iid, String ... prefixes) {
1326 LOG.debug("Adding Northbound mappings in VNI {} for prefixes: {}", iid, prefixes);
1327 final InstanceIdType iiType = new InstanceIdType(iid);
1328 for (String prefix : prefixes) {
1329 MappingRecord record = newMappingRecord(prefix, iiType);
1330 mapService.addMapping(MappingOrigin.Northbound, record.getEid(), null, new MappingData(record));
1332 sleepForMilliseconds(100);
1333 MappingServiceIntegrationTestUtil.printMapCacheState(mapService);
1336 private void removeNBMapping(long iid, String prefix) {
1337 LOG.debug("Removing Northbound mapping in VNI {} for prefix {}", iid, prefix);
1338 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid(iid, prefix);
1339 mapService.removeMapping(MappingOrigin.Northbound, eid);
1342 private void insertNBMapping(long iid, String prefix, String ... locators) {
1343 LOG.debug("Adding Northbound mapping in VNI {} for prefix {}, locators {}", iid, prefix, locators);
1344 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid(iid, prefix);
1345 List<Rloc> rlocs = new ArrayList<>();
1346 for (String locator : locators) {
1347 rlocs.add(LispAddressUtil.asIpv4Rloc(locator));
1349 insertNBMapping(eid, rlocs);
1352 private void insertNBMappingSourceDest(long iid, String src, String dst, String locator) {
1353 String srcAddress = MaskUtil.getPrefixAddress(src);
1354 String dstAddress = MaskUtil.getPrefixAddress(dst);
1355 int srcMask = Integer.parseInt(MaskUtil.getPrefixMask(src));
1356 int dstMask = Integer.parseInt(MaskUtil.getPrefixMask(dst));
1357 LOG.debug("Adding Northbound mapping in VNI {} for prefix {}|{}, locator {}", iid, src, dst, locator);
1358 Eid eid = LispAddressUtil.asSrcDstEid(srcAddress, dstAddress, srcMask, dstMask, iid);
1359 List<Rloc> rlocs = Arrays.asList(LispAddressUtil.asIpv4Rloc(locator));
1360 insertNBMapping(eid, rlocs);
1363 private void insertNBMapping(Eid eid, List<Rloc> rlocs) {
1364 MappingRecord record = MappingServiceIntegrationTestUtil.getDefaultMappingRecordBuilder(eid, rlocs).build();
1365 mapService.addMapping(MappingOrigin.Northbound, record.getEid(), null, new MappingData(record));
1366 sleepForMilliseconds(100);
1367 MappingServiceIntegrationTestUtil.printMapCacheState(mapService);
1370 private void allowNullAuthenticationForAllIPv4(long iid) {
1371 final InstanceIdType iiType = new InstanceIdType(iid);
1372 Eid allIPs = LispAddressUtil.asIpv4PrefixBinaryEid("0.0.0.0/0", iiType);
1373 mapService.addAuthenticationKey(allIPs, NULL_AUTH_KEY);
1376 private void insertSBMappings(boolean negative, long iid, String... prefixes) {
1377 LOG.debug("Adding Southbound mappings in VNI {} for prefixes: {}", iid, prefixes);
1378 final InstanceIdType iiType = new InstanceIdType(iid);
1380 for (String prefix : prefixes) {
1381 MappingRecord record;
1383 record = newMappingRecordNegative(prefix, iiType);
1385 record = newMappingRecord(prefix, iiType);
1387 mapService.addMapping(MappingOrigin.Southbound, record.getEid(), null,
1388 new MappingData(record, System.currentTimeMillis()));
1390 MappingServiceIntegrationTestUtil.printMapCacheState(mapService);
1393 private void registerSBMapping(long iid, String prefix, String locator) {
1394 LOG.debug("Registering Southbound mapping in VNI {} for prefix {}, locator {}" +
1395 " via simulated Map-Register a.k.a. handleMapRegister()", iid, prefix, locator);
1397 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid(iid, prefix);
1398 Rloc rloc = LispAddressUtil.asIpv4Rloc(locator);
1399 MapRegister mr = MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid, rloc).build();
1400 lms.handleMapRegister(mr);
1401 sleepForMilliseconds(100);
1402 MappingServiceIntegrationTestUtil.printMapCacheState(mapService);
1405 private void removeSBMapping(long iid, String prefix) {
1406 LOG.debug("Removing Southbound mapping in VNI {} for prefix {}", iid, prefix);
1407 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid(iid, prefix);
1408 mapService.removeMapping(MappingOrigin.Southbound, eid);
1411 private MappingRecord newMappingRecord(String prefix, InstanceIdType iid) {
1412 final Eid prefixBinary = LispAddressUtil.asIpv4PrefixBinaryEid(prefix, iid);
1413 return MappingServiceIntegrationTestUtil.getDefaultMappingRecordBuilder(prefixBinary).build();
1416 private MappingRecord newMappingRecordNegative(String prefix, InstanceIdType iid) {
1417 final Eid prefixBinary = LispAddressUtil.asIpv4PrefixBinaryEid(prefix, iid);
1418 return MappingServiceIntegrationTestUtil.getDefaultMappingRecordBuilder(prefixBinary, (List<Rloc>) null)
1419 .setAction(Action.NativelyForward).build();
1422 private MapRequest newMapRequest(long iid, String prefix) {
1423 final Eid prefixBinary = LispAddressUtil.asIpv4PrefixBinaryEid(prefix, new InstanceIdType(iid));
1424 return MappingServiceIntegrationTestUtil.getDefaultMapRequestBuilder(prefixBinary).build();
1430 public void testMultiSiteScenarioA() throws IOException {
1432 ConfigIni.getInstance().setSmrRetryCount(1);
1433 ConfigIni.getInstance().setSmrTimeout(30000L);
1435 final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
1436 multiSiteScenario.setCommonAuthentication();
1439 final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
1442 multiSiteScenario.storeSouthboundMappings(false, SITE_A, SITE_B, SITE_C, SITE_D4, SITE_D5);
1443 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
1444 multiSiteScenario.storeNorthMappingNegative(SITE_C_NEGATIVE, Action.Drop);
1445 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1446 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
1447 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
1448 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
1451 //following action should trigger generating of SMR messages:
1454 multiSiteScenario.storeNorthMappingSrcDst(SITE_A, SITE_C);
1455 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1456 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1));
1457 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
1458 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
1459 multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
1462 // following action should trigger generating of SMR messages:
1467 multiSiteScenario.deleteNorthMappingNegative(SITE_C);
1468 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1469 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1), SITE_A
1471 SITE_D4.getHost(5));
1472 multiSiteScenario.assertPingWorks(SITE_D4, 5, SITE_C, 4);
1475 // following action should trigger generating of SMR messages:
1480 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C_RLOC_10);
1481 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1482 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1),
1483 SITE_A.getHost(5), SITE_D4.getHost(5));
1484 //way of testing ping - get RLOC for mapping src-dst and compare it with awaited value doesn't test
1485 //that ping won't be successfull
1486 multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
1489 // following action should trigger generating of SMR messages:
1494 multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
1495 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1496 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1),
1497 SITE_A.getHost(5), SITE_D4.getHost(5));
1498 multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
1501 multiSiteScenario.assertPingFails(SITE_D5, 5, SITE_C, 3);
1504 // following action should trigger generating of SMR messages:
1510 multiSiteScenario.deleteNorthMapingSrcDst(SITE_A, SITE_C);
1511 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1512 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
1513 SITE_B.getHost(5), SITE_A.getHost(1), SITE_A.getHost(5));
1515 // following action should trigger generating of SMR messages:
1521 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
1522 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1523 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
1524 SITE_B.getHost(5), SITE_A.getHost(1), SITE_A.getHost(5));
1526 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
1527 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
1528 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
1531 // following action should trigger generating of SMR messages:
1537 multiSiteScenario.deleteNorthMapingSrcDst(SITE_B, SITE_C);
1538 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1539 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
1540 SITE_B.getHost(5), SITE_A.getHost(1), SITE_A.getHost(5));
1541 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
1542 multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
1543 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
1546 // following action should trigger generating of SMR messages:
1552 multiSiteScenario.deleteNorthMappingNegative(SITE_C);
1553 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1554 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
1555 SITE_B.getHost(5), SITE_A.getHost(1), SITE_A.getHost(5));
1556 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
1557 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
1558 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
1560 socketReader.stopReading();
1567 public void testMultiSiteScenarioB() throws IOException {
1571 final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
1572 multiSiteScenario.setCommonAuthentication();
1575 final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
1577 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_AND_SB);
1578 mapService.setMappingMerge(true);
1581 multiSiteScenario.storeSouthboundMappings(true, SITE_A_SB, SITE_B_SB, SITE_C_WP_100_1_SB, SITE_D_WP_100_1_SB,
1583 multiSiteScenario.storeNorthMappingIpPrefix(SITE_A_SB);
1584 multiSiteScenario.storeNorthMappingIpPrefix(SITE_B_SB);
1585 multiSiteScenario.storeNorthMappingIpPrefix(SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
1586 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1587 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
1588 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
1591 // following action should trigger generating of SMR messages:
1594 multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
1595 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1596 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
1598 // following action should trigger generating of SMR messages:
1601 multiSiteScenario.storeNorthMappingNegative(SITE_C_SB, Action.Drop);
1602 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1603 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
1605 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
1606 multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_SB, 4);
1610 // following action should trigger generating of SMR messages:
1613 multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
1614 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1615 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
1616 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4);
1619 multiSiteScenario.storeNorthMappingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
1620 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1621 // following action should trigger generating of SMR messages:
1624 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
1625 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
1628 multiSiteScenario.deleteSouthboundMappings(SITE_D_DELETE_SB);
1629 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1630 // following action should trigger generating of SMR messages:
1633 //multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
1635 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
1638 multiSiteScenario.deleteNorthMapingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
1639 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1640 // following action should trigger generating of SMR messages:
1643 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
1645 multiSiteScenario.deleteNorthMapingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB);
1646 sleepForSeconds(MULTI_SITE_SLEEP_TIME);
1647 multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
1649 socketReader.stopReading();
1653 // ------------------------------- Simple Tests ---------------------------
1655 public void mapRequestSimple() throws SocketTimeoutException {
1658 // This Map-Request is sent from a source port different from 4342
1659 // We close and bind the socket on the correct port
1660 if (socket != null) {
1663 socket = MappingServiceIntegrationTestUtil.initSocket(56756);
1665 sendPacket(mapRequestPacket);
1666 MapReply reply = receiveMapReply();
1667 assertEquals(4435248268955932168L, reply.getNonce().longValue());
1671 public void mapRegisterWithMapNotify() throws SocketTimeoutException {
1673 mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixBinaryEid("153.16.254.1/32"), NULL_AUTH_KEY);
1676 sendPacket(mapRegisterPacketWithNotify);
1677 MapNotify reply = receiveMapNotify();
1678 assertEquals(7, reply.getNonce().longValue());
1681 public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
1683 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
1685 MapReply mapReply = registerAddressAndQuery(eid);
1687 assertEquals(4, mapReply.getNonce().longValue());
1688 assertEquals(MappingServiceIntegrationTestUtil.DEFAULT_IPV4_RLOC,
1689 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
1693 public void registerAndQuery__MAC() throws SocketTimeoutException {
1695 String macAddress = "01:02:03:04:05:06";
1697 MapReply reply = registerAddressAndQuery(LispAddressUtil.asMacEid(macAddress));
1700 Eid addressFromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1701 assertEquals(MacAfi.class, addressFromNetwork.getAddressType());
1702 String macAddressFromReply = ((Mac) addressFromNetwork.getAddress()).getMac().getValue();
1704 assertEquals(macAddress, macAddressFromReply);
1707 public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
1709 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
1710 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1713 MapRequest mapRequest = MappingServiceIntegrationTestUtil.getDefaultMapRequestBuilder(eid).build();
1714 sendMapRequest(mapRequest);
1715 MapReply mapReply = receiveMapReply();
1716 assertEquals(4, mapReply.getNonce().longValue());
1717 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1718 MapRegister mapRegister = MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid).build();
1719 sendMapRegister(mapRegister);
1720 MapNotify mapNotify = receiveMapNotify();
1721 assertEquals(8, mapNotify.getNonce().longValue());
1723 sendMapRequest(mapRequest);
1724 mapReply = receiveMapReply();
1725 assertEquals(4, mapReply.getNonce().longValue());
1726 assertEquals(MappingServiceIntegrationTestUtil.DEFAULT_IPV4_RLOC,
1727 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
1731 public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
1733 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
1734 SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
1735 Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
1736 SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
1737 Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
1738 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
1739 assertEquals(2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1740 assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
1742 assertEquals(rloc1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(1)
1746 public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
1748 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
1749 SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
1750 Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
1751 SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
1752 Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
1753 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
1754 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1755 assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
1759 public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
1761 mapService.setMappingMerge(false);
1762 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
1763 Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
1764 Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
1765 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
1766 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1767 assertEquals(rloc2Value, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
1771 public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
1773 mapService.setMappingMerge(true);
1774 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
1775 Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
1776 Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
1777 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
1778 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1779 Rloc rloc1ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
1781 Rloc rloc2ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
1783 assertTrue((rloc1Value.equals(rloc1ReturnValueContainer) && rloc2Value.equals(rloc2ReturnValueContainer))
1784 || (rloc1Value.equals(rloc2ReturnValueContainer) && rloc2Value.equals(rloc1ReturnValueContainer)));
1787 private MapReply sendMapRegisterTwiceWithDiffrentValues(Eid eid, Rloc rloc1, Rloc rloc2)
1788 throws SocketTimeoutException {
1789 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1791 MapRegister mb = createMapRegister(eid, rloc1);
1792 MapNotify mapNotify = lms.handleMapRegister(mb).getLeft();
1793 MapRequest mr = createMapRequest(eid);
1794 MapReply mapReply = lms.handleMapRequest(mr);
1795 assertEquals(mb.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc(),
1796 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
1797 mb = createMapRegister(eid, rloc2);
1798 mapNotify = lms.handleMapRegister(mb).getLeft();
1799 assertEquals(8, mapNotify.getNonce().longValue());
1800 mr = createMapRequest(eid);
1802 mapReply = lms.handleMapRequest(mr);
1806 public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
1808 sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
1810 receivePacket(3000);
1811 // If didn't timeout then fail:
1813 } catch (SocketTimeoutException ste) {
1817 public void mapRegisterWithoutMapNotify() {
1819 sendPacket(mapRegisterPacketWithoutNotify);
1821 receivePacket(3000);
1822 // If didn't timeout then fail:
1824 } catch (SocketTimeoutException ste) {
1828 public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
1830 lms.setShouldUseSmr(true);
1831 mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixBinaryEid("153.16.254.1/32"), NULL_AUTH_KEY);
1834 sendPacket(mapRegisterPacketWithNotify);
1838 sendPacket(mapRequestPacket);
1841 mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
1842 sendPacket(mapRegisterPacketWithoutNotify);
1844 MapRequest smr = receiveMapRequest();
1845 assertTrue(smr.isSmr());
1846 Eid sourceEid = smr.getSourceEid().getEid();
1847 assertTrue(LispAddressUtil.asIpv4Eid("153.16.254.1").equals(sourceEid));
1848 Eid smrEid = smr.getEidItem().get(0).getEid();
1849 assertTrue(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32").equals(smrEid));
1852 // --------------------- Northbound Tests ---------------------------
1854 private void northboundAddKey() throws Exception {
1856 LispIpv4Address address = LispAddressUtil.asIPAfiAddress("1.2.3.4");
1858 String pass = "asdf";
1860 URL url = createPutURL("key");
1861 String authKeyJSON = createAuthKeyJSON(pass, address, mask);
1862 callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
1864 String retrievedKey = lms.getAuthenticationKey(LispAddressUtil.toContainer(address), mask);
1866 // Check stored password matches the one sent
1867 assertEquals(pass, retrievedKey);
1871 private void northboundRetrieveSourceDestKey() throws Exception {
1873 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1874 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1875 .primitiveaddress.Ipv4) LispAddressUtil
1876 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
1877 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1878 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1879 .primitiveaddress.Ipv4) LispAddressUtil
1880 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
1883 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
1884 AddressFamilyNumberEnum.LCAF.getIanaCode())
1885 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
1886 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build())
1887 .setSrcMaskLength((short) mask1)
1888 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build())
1889 .setDstMaskLength((short) mask2).build();
1890 String pass = "asdf";
1892 lms.addAuthenticationKey(LispAddressUtil.toContainer(sourceDestAddress), mask1, pass);
1894 // URL url = createGetKeyIPv4URL(address1, mask1);
1895 URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
1896 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getSrcAddress()
1897 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
1898 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getDstAddress()
1899 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
1900 String reply = callURL("GET", null, "application/json", null, url);
1901 JSONTokener jt = new JSONTokener(reply);
1902 JSONObject json = new JSONObject(jt);
1904 // test that the password matches what was we expected.
1905 assertEquals(pass, json.get("key"));
1909 private void northboundRetrieveKey() throws Exception {
1911 LispIpv4Address address = LispAddressUtil.asIPAfiAddress("10.0.0.1");
1913 String pass = "asdf";
1915 lms.addAuthenticationKey(LispAddressUtil.toContainer(address), mask, pass);
1917 URL url = createGetKeyIPv4URL(address, mask);
1918 String reply = callURL("GET", null, "application/json", null, url);
1919 JSONTokener jt = new JSONTokener(reply);
1920 JSONObject json = new JSONObject(jt);
1922 // test that the password matches what was we expected.
1923 assertEquals(pass, json.get("key"));
1927 private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
1928 return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
1929 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
1932 private void northboundAddMapping() throws Exception {
1934 String pass = "asdf";
1935 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
1937 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1939 // NB add mapping always checks the key
1940 lms.addAuthenticationKey(LispAddressUtil.toContainer(eid), mask, pass);
1942 URL url = createPutURL("mapping");
1943 String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
1944 callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
1946 // Retrieve the RLOC from the database
1947 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1948 mapRequestBuilder.setPitr(false);
1949 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1950 mapRequestBuilder.getEidItem().add(
1951 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(
1952 LispAddressUtil.toContainer(eid)).build());
1953 MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
1955 LispIpv4Address retrievedRloc = (LispIpv4Address) LispAddressUtil.toAFI(
1956 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
1957 .getLispAddressContainer());
1959 assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
1963 private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
1964 String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ "
1965 + "\"proxyMapReply\" : false, "
1966 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : "
1967 + "{ " + "\"ipAddress\" : \""
1968 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "},"
1969 + "\"mapVersion\" : 0,"
1970 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ "
1971 + "\"multicastPriority\" : 1,"
1972 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\","
1974 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50,"
1975 + "\"rlocProbed\" : false, "
1976 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], "
1977 + "\"recordTtl\" : 100" + "} " + "], "
1978 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
1983 private void northboundRetrieveMapping() throws Exception {
1985 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
1987 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1988 // Insert mapping in the database
1989 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1990 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1991 etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
1992 etlr.setMaskLength((short) mask);
1993 etlr.setRecordTtl(254);
1994 etlr.setAuthoritative(false);
1995 etlr.setAction(Action.NoAction);
1996 LocatorRecordBuilder record = new LocatorRecordBuilder();
1997 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
1998 record.setRouted(true);
1999 record.setRlocProbed(false);
2000 record.setLocalLocator(false);
2001 record.setPriority((short) 1);
2002 record.setWeight((short) 50);
2003 record.setMulticastPriority((short) 1);
2004 record.setMulticastWeight((short) 1);
2005 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
2006 etlr.getLocatorRecord().add(record.build());
2007 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
2008 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
2009 lms.handleMapRegister(mapRegister.build());
2011 // Get mapping using NB interface. No IID used
2012 URL url = createGetMappingIPv4URL(0, eid, mask);
2013 String reply = callURL("GET", null, "application/json", null, url);
2014 JSONTokener jt = new JSONTokener(reply);
2015 JSONObject json = new JSONObject(jt);
2017 // With just one locator, locators is not a JSONArray
2018 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
2019 .getString("ipAddress");
2021 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
2025 private void northboundDeleteMapping() throws Exception {
2027 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
2029 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
2030 // Insert mapping in the database
2031 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
2032 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
2033 etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
2034 etlr.setMaskLength((short) mask);
2035 etlr.setRecordTtl(254);
2036 etlr.setAuthoritative(false);
2037 etlr.setAction(Action.NoAction);
2038 LocatorRecordBuilder record = new LocatorRecordBuilder();
2039 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
2040 record.setRouted(true);
2041 record.setRlocProbed(false);
2042 record.setLocalLocator(false);
2043 record.setPriority((short) 1);
2044 record.setWeight((short) 50);
2045 record.setMulticastPriority((short) 1);
2046 record.setMulticastWeight((short) 1);
2047 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
2048 etlr.getLocatorRecord().add(record.build());
2049 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
2050 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
2051 lms.handleMapRegister(mapRegister.build());
2053 // Delete mapping using NB interface. No IID used
2054 URL url = createDeleteMappingIPv4URL(0, eid, mask);
2055 String reply = callURL("DELETE", null, "application/json", null, url);
2057 // Get mapping using NB interface. No IID used
2058 url = createGetMappingIPv4URL(0, eid, mask);
2059 reply = callURL("GET", null, "application/json", null, url);
2060 JSONTokener jt = new JSONTokener(reply);
2061 JSONObject json = new JSONObject(jt);
2063 // With just one locator, locators is not a JSONArray
2064 assertEquals(json.getJSONArray("locators").length(), 0);
2067 private void northboundRetrieveSourceDestMapping() throws Exception {
2069 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
2070 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
2071 .primitiveaddress.Ipv4) LispAddressUtil
2072 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
2073 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
2074 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
2075 .primitiveaddress.Ipv4) LispAddressUtil
2076 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
2079 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
2080 AddressFamilyNumberEnum.LCAF.getIanaCode())
2081 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
2082 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(
2083 address1).build()).setSrcMaskLength((short) mask1)
2084 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(
2085 address2).build()).setDstMaskLength((short) mask2).build();
2086 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
2088 // Insert mapping in the database
2089 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
2090 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
2091 etlr.setLispAddressContainer(LispAddressUtil.toContainer(sourceDestAddress));
2092 etlr.setMaskLength((short) mask1);
2093 etlr.setRecordTtl(254);
2094 etlr.setAuthoritative(false);
2095 etlr.setAction(Action.NoAction);
2096 LocatorRecordBuilder record = new LocatorRecordBuilder();
2097 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
2098 record.setRouted(true);
2099 record.setRlocProbed(false);
2100 record.setLocalLocator(false);
2101 record.setPriority((short) 1);
2102 record.setWeight((short) 50);
2103 record.setMulticastPriority((short) 1);
2104 record.setMulticastWeight((short) 1);
2105 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
2106 etlr.getLocatorRecord().add(record.build());
2107 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
2108 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
2109 lms.handleMapRegister(mapRegister.build());
2111 // Get mapping using NB interface. No IID used
2112 URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
2113 address1.getIpv4Address().getIpv4Address().getValue(),
2115 address2.getIpv4Address().getIpv4Address().getValue(),
2117 String reply = callURL("GET", null, "application/json", null, url);
2118 JSONTokener jt = new JSONTokener(reply);
2119 JSONObject json = new JSONObject(jt);
2121 // With just one locator, locators is not a JSONArray
2122 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
2123 .getString("ipAddress");
2125 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
2129 private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
2130 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key",
2131 address.getAfi().shortValue(),
2132 address.getIpv4Address().getValue(), mask);
2133 URL url = new URL(restUrl);
2137 private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
2138 throws MalformedURLException {
2139 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
2140 "key", afi, srcAddress, srcMask,
2141 dstAddress, dstMask);
2142 URL url = new URL(restUrl);
2146 private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
2147 throws MalformedURLException {
2148 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
2149 "mapping", afi, srcAddress,
2150 srcMask, dstAddress, dstMask);
2151 URL url = new URL(restUrl);
2155 private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
2156 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
2157 iid, address.getAfi()
2158 .shortValue(), address.getIpv4Address().getValue(), mask);
2159 URL url = new URL(restUrl);
2163 private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
2164 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
2165 iid, address.getAfi()
2166 .shortValue(), address.getIpv4Address().getValue(), mask);
2167 URL url = new URL(restUrl);
2171 private URL createPutURL(String resource) throws MalformedURLException {
2173 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
2175 URL url = new URL(restUrl);
2179 private String createAuthenticationString() {
2180 String authString = "admin:admin";
2181 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
2182 String authStringEnc = new String(authEncBytes);
2183 return authStringEnc;
2186 private String callURL(String method, String content, String accept, String body, URL url) throws IOException,
2188 String authStringEnc = createAuthenticationString();
2189 connection = (HttpURLConnection) url.openConnection();
2190 connection.setRequestMethod(method);
2191 connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
2192 if (content != null) {
2193 connection.setRequestProperty("Content-Type", content);
2195 if (accept != null) {
2196 connection.setRequestProperty("Accept", accept);
2199 // now add the request body
2200 connection.setDoOutput(true);
2201 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
2205 connection.connect();
2207 // getting the result, first check response code
2208 Integer httpResponseCode = connection.getResponseCode();
2210 if (httpResponseCode > 299) {
2211 LOG.trace("HTTP Address: " + url);
2212 LOG.trace("HTTP Response Code: " + httpResponseCode);
2216 InputStream is = connection.getInputStream();
2217 BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
2218 StringBuilder sb = new StringBuilder();
2220 while ((cp = rd.read()) != -1) {
2221 sb.append((char) cp);
2224 connection.disconnect();
2225 return (sb.toString());
2228 // timePeriod - in ms
2229 public void assertNoPacketReceived(int timePeriod) {
2231 receivePacket(timePeriod);
2232 // If didn't timeout then fail:
2234 } catch (SocketTimeoutException ste) {
2238 // ------------------------------- Mask Tests ---------------------------
2240 public void eidPrefixLookupIPv4() throws SocketTimeoutException {
2242 runPrefixTest(LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/16"),
2243 LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.2/32"),
2244 LispAddressUtil.asIpv4PrefixBinaryEid("1.1.1.1/32"));
2247 public void eidPrefixLookupIPv6() throws SocketTimeoutException {
2249 runPrefixTest(LispAddressUtil.asIpv6PrefixBinaryEid("1:2:3:4:5:6:7:8/64"),
2250 LispAddressUtil.asIpv6PrefixBinaryEid("1:2:3:4:5:1:2:3/128"),
2251 LispAddressUtil.asIpv6PrefixBinaryEid("1:2:3:1:2:3:1:2/128"));
2254 private void runPrefixTest(Eid registerEID, Eid matchedAddress, Eid unMatchedAddress)
2255 throws SocketTimeoutException {
2256 mapService.addAuthenticationKey(registerEID, NULL_AUTH_KEY);
2259 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
2260 mapRegister.setWantMapNotify(true);
2261 mapRegister.setNonce((long) 8);
2262 mapRegister.setWantMapNotify(true);
2263 mapRegister.setKeyId((short) 0);
2264 mapRegister.setAuthenticationData(new byte[0]);
2265 mapRegister.setNonce((long) 8);
2266 mapRegister.setProxyMapReply(false);
2267 MappingRecordBuilder etlr = new MappingRecordBuilder();
2268 etlr.setRecordTtl(254);
2269 etlr.setAction(Action.NoAction);
2270 etlr.setAuthoritative(false);
2271 etlr.setMapVersion((short) 0);
2272 etlr.setEid(registerEID);
2273 etlr.setRecordTtl(254);
2274 LocatorRecordBuilder record = new LocatorRecordBuilder();
2275 record.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
2276 record.setLocalLocator(false);
2277 record.setRlocProbed(false);
2278 record.setRouted(true);
2279 record.setMulticastPriority((short) 0);
2280 record.setMulticastWeight((short) 0);
2281 record.setPriority((short) 0);
2282 record.setWeight((short) 0);
2283 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
2284 etlr.getLocatorRecord().add(record.build());
2285 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
2286 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
2287 sendMapRegister(mapRegister.build());
2288 MapNotify mapNotify = receiveMapNotify();
2289 assertEquals(8, mapNotify.getNonce().longValue());
2291 MapRequestBuilder mapRequest = new MapRequestBuilder();
2292 mapRequest.setNonce((long) 4);
2293 mapRequest.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
2294 mapRequest.setEidItem(new ArrayList<EidItem>());
2295 mapRequest.setAuthoritative(false);
2296 mapRequest.setMapDataPresent(false);
2297 mapRequest.setPitr(false);
2298 mapRequest.setProbe(false);
2299 mapRequest.setSmr(false);
2300 mapRequest.setSmrInvoked(false);
2301 mapRequest.getEidItem().add(new EidItemBuilder().setEid(matchedAddress).build());
2302 mapRequest.setItrRloc(new ArrayList<ItrRloc>());
2303 mapRequest.getItrRloc().add(
2304 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
2305 sendMapRequest(mapRequest.build());
2306 MapReply mapReply = receiveMapReply();
2307 assertEquals(4, mapReply.getNonce().longValue());
2308 assertEquals(record.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
2310 mapRequest.setEidItem(new ArrayList<EidItem>());
2311 mapRequest.getEidItem().add(new EidItemBuilder().setEid(unMatchedAddress).build());
2312 sendMapRequest(mapRequest.build());
2313 mapReply = receiveMapReply();
2314 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
2317 // This registers an IP with a MapRegister, then adds a password via the
2318 // northbound REST API
2319 // and checks that the password works
2320 public void testPasswordExactMatch() throws Exception {
2322 String ipString = "10.0.0.1";
2323 LispIpv4Address address = LispAddressUtil.asIPAfiAddress(ipString);
2325 String pass = "pass";
2327 URL url = createPutURL("key");
2329 String jsonAuthData = createAuthKeyJSON(pass, address, mask);
2331 LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
2332 LOG.trace("Address: " + address);
2334 byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232,
2335 (byte) 31, (byte) 249, (byte) 87,
2336 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53,
2337 (byte) 196, (byte) 62 };
2339 byte[] zeros = new byte[20];
2341 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
2343 // build a MapRegister
2344 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
2345 mapRegister.setWantMapNotify(true);
2346 mapRegister.setNonce((long) 8);
2347 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
2348 etlr.setLispAddressContainer(LispAddressUtil.toContainer(address));
2349 etlr.setMaskLength((short) mask);
2350 etlr.setRecordTtl(254);
2351 LocatorRecordBuilder record = new LocatorRecordBuilder();
2352 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
2353 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
2354 etlr.getLocatorRecord().add(record.build());
2355 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
2356 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
2358 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
2359 mapRegister.setAuthenticationData(zeros);
2361 sendMapRegister(mapRegister.build());
2362 assertNoPacketReceived(3000);
2364 mapRegister.setAuthenticationData(expectedSha);
2366 sendMapRegister(mapRegister.build());
2368 assertMapNotifyReceived();
2371 public void testPasswordMaskMatch() throws Exception {
2373 LispIpv4Address addressInRange = LispAddressUtil.asIPAfiAddress("10.20.30.40");
2374 LispIpv4Address addressOutOfRange = LispAddressUtil.asIPAfiAddress("20.40.30.40");
2375 LispIpv4Address range = LispAddressUtil.asIPAfiAddress("10.20.30.0");
2378 String pass = "pass";
2380 URL url = createPutURL("key");
2381 String jsonAuthData = createAuthKeyJSON(pass, range, 8);
2383 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
2384 // build a MapRegister
2385 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
2387 mapRegister.setWantMapNotify(true);
2388 mapRegister.setNonce((long) 8);
2389 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
2390 etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressInRange));
2391 etlr.setMaskLength((short) mask);
2392 etlr.setRecordTtl(254);
2393 LocatorRecordBuilder record = new LocatorRecordBuilder();
2394 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
2395 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
2396 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
2397 etlr.getLocatorRecord().add(record.build());
2398 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
2399 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
2401 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
2403 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4,
2404 -67, -113, 104, -110, -71 });
2406 sendMapRegister(mapRegister.build());
2408 assertMapNotifyReceived();
2410 etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressOutOfRange));
2412 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123,
2413 -71, -14, -99, 67, -23, -73 });
2415 sendMapRegister(mapRegister.build());
2416 assertNoPacketReceived(3000);
2419 // takes an address, packs it in a MapRegister and sends it
2420 private void registerAddress(Eid eid) throws SocketTimeoutException {
2421 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
2423 MapRegister mapRegister = MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid).build();
2424 sendMapRegister(mapRegister);
2425 MapNotify mapNotify = receiveMapNotify();
2426 assertEquals(8, mapNotify.getNonce().longValue());
2429 private MapReply queryForAddress(Eid eid, String srcEid) throws SocketTimeoutException {
2430 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
2431 mapRequestBuilder.setNonce((long) 4);
2432 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
2433 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
2434 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
2435 if (srcEid != null) {
2436 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(srcEid)).build());
2438 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress))
2441 mapRequestBuilder.getItrRloc().add(
2442 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
2443 mapRequestBuilder.setAuthoritative(false);
2444 mapRequestBuilder.setMapDataPresent(false);
2445 mapRequestBuilder.setPitr(false);
2446 mapRequestBuilder.setProbe(false);
2447 mapRequestBuilder.setSmr(false);
2448 mapRequestBuilder.setSmrInvoked(false);
2449 sendMapRequest(mapRequestBuilder.build());
2450 return receiveMapReply();
2453 // takes an address, packs it in a MapRegister, sends it, returns the
2455 private MapReply registerAddressAndQuery(Eid eid) throws SocketTimeoutException {
2456 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
2458 MapRegister mapRegister = MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid).build();
2459 LOG.trace("Sending Map-Register via socket: {}", mapRegister);
2460 sendMapRegister(mapRegister);
2461 MapNotify mapNotify = receiveMapNotify();
2462 LOG.trace("Received Map-Notify via socket: {}", mapNotify);
2463 assertEquals(8, mapNotify.getNonce().longValue());
2464 // wait for the notifications to propagate
2466 MapRequest mapRequest = MappingServiceIntegrationTestUtil.getDefaultMapRequestBuilder(eid).build();
2467 sendMapRequest(mapRequest);
2468 return receiveMapReply();
2471 // ------------------------------- LCAF Tests ---------------------------
2473 public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
2475 String ipPrefix = "10.20.30.200/32";
2476 String macString = "01:02:03:04:05:06";
2478 SourceDestKeyBuilder builder = new SourceDestKeyBuilder();
2479 builder.setSource(new SimpleAddress(new IpPrefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
2480 .ietf.inet.types.rev130715.Ipv4Prefix(ipPrefix))));
2481 builder.setDest(new SimpleAddress(new MacAddress(macString)));
2483 EidBuilder eb = new EidBuilder();
2484 eb.setAddressType(SourceDestKeyLcaf.class);
2485 eb.setVirtualNetworkId(null);
2486 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2487 .lisp.address.address.SourceDestKeyBuilder().setSourceDestKey(builder.build()).build());
2489 MapReply reply = registerAddressAndQuery(eb.build());
2491 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2492 assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
2493 SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
2495 SimpleAddress receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource();
2496 SimpleAddress receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest();
2498 assertNotNull(receivedAddr1.getIpPrefix().getIpv4Prefix());
2499 assertNotNull(receivedAddr2.getMacAddress());
2501 IpPrefix receivedIP = receivedAddr1.getIpPrefix();
2502 MacAddress receivedMAC = receivedAddr2.getMacAddress();
2504 assertEquals(ipPrefix, receivedIP.getIpv4Prefix().getValue());
2505 assertEquals(macString, receivedMAC.getValue());
2508 public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
2510 String ipString1 = "10.10.10.0";
2511 String ipString2 = "20.20.20.0";
2512 String ipPrefix1 = ipString1 + "/24";
2513 String ipPrefix2 = ipString2 + "/24";
2515 Eid srcDst = LispAddressUtil.asSrcDstEid(ipString1, ipString2, 24, 24, 0);
2516 registerAddress(LispAddressUtil.asIpv4PrefixBinaryEid(ipPrefix2));
2517 registerAddress(srcDst);
2520 MapReply reply = queryForAddress(srcDst, null);
2522 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2523 assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
2524 SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
2526 IpPrefix receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource().getIpPrefix();
2527 IpPrefix receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest().getIpPrefix();
2529 assertNotNull(receivedAddr1.getIpv4Prefix());
2530 assertNotNull(receivedAddr2.getIpv4Prefix());
2532 assertEquals(ipPrefix1, receivedAddr1.getIpv4Prefix().getValue());
2533 assertEquals(ipPrefix2, receivedAddr2.getIpv4Prefix().getValue());
2535 // srcEid/dstEid match
2536 reply = queryForAddress(LispAddressUtil.asIpv4PrefixBinaryEid("20.20.20.1/32"), "10.10.10.1");
2537 fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2538 assertEquals(Ipv4PrefixBinaryAfi.class, fromNetwork.getAddressType());
2540 assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid(ipPrefix2), fromNetwork);
2542 // dstEid match only
2543 reply = queryForAddress(LispAddressUtil.asIpv4PrefixBinaryEid("20.20.20.1/32"), "1.2.3.4");
2544 fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2545 assertEquals(Ipv4PrefixBinaryAfi.class, fromNetwork.getAddressType());
2547 assertEquals(LispAddressUtil.asIpv4PrefixBinaryEid(ipPrefix2), fromNetwork);
2550 public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
2552 String ipString = "10.20.30.200";
2553 String macString = "01:02:03:04:05:06";
2554 SimpleAddress addrToSend1 = new SimpleAddress(new IpAddress(new Ipv4Address(ipString)));
2555 SimpleAddress addrToSend2 = new SimpleAddress(new MacAddress(macString));
2556 Eid kv = LispAddressUtil.asKeyValueAddressEid(addrToSend1, addrToSend2);
2558 MapReply reply = registerAddressAndQuery(kv);
2560 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2561 assertEquals(KeyValueAddressLcaf.class, fromNetwork.getAddressType());
2562 KeyValueAddress keyValueFromNetwork = (KeyValueAddress) fromNetwork.getAddress();
2564 SimpleAddress receivedAddr1 = keyValueFromNetwork.getKeyValueAddress().getKey();
2565 SimpleAddress receivedAddr2 = keyValueFromNetwork.getKeyValueAddress().getValue();
2567 assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
2568 assertNotNull(receivedAddr2.getMacAddress());
2570 Ipv4Address receivedIP = receivedAddr1.getIpAddress().getIpv4Address();
2571 MacAddress receivedMAC = receivedAddr2.getMacAddress();
2573 assertEquals(ipString, receivedIP.getValue());
2574 assertEquals(macString, receivedMAC.getValue());
2577 public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
2579 String macString = "01:02:03:04:05:06";
2580 String ipString = "10.20.255.30";
2581 List<SimpleAddress> addresses = new ArrayList<SimpleAddress>();
2582 addresses.add(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
2583 addresses.add(new SimpleAddress(new MacAddress(macString)));
2584 AfiListBuilder listbuilder = new AfiListBuilder();
2585 listbuilder.setAddressList(addresses);
2587 EidBuilder eb = new EidBuilder();
2588 eb.setAddressType(AfiListLcaf.class);
2589 eb.setVirtualNetworkId(null);
2590 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2591 .lisp.address.address.AfiListBuilder().setAfiList(listbuilder.build()).build());
2593 MapReply reply = registerAddressAndQuery(eb.build());
2595 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2597 assertEquals(AfiListLcaf.class, receivedAddress.getAddressType());
2599 AfiList listAddrFromNetwork = (AfiList) receivedAddress.getAddress();
2600 SimpleAddress receivedAddr1 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(0);
2601 SimpleAddress receivedAddr2 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(1);
2603 assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
2604 assertNotNull(receivedAddr2.getMacAddress());
2606 assertEquals(macString, receivedAddr2.getMacAddress().getValue());
2607 assertEquals(ipString, receivedAddr1.getIpAddress().getIpv4Address().getValue());
2610 public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
2612 String ipString = "10.20.255.30";
2615 EidBuilder eb = new EidBuilder();
2616 eb.setAddressType(Ipv4PrefixAfi.class);
2617 eb.setVirtualNetworkId(new InstanceIdType((long) instanceId));
2618 eb.setAddress(new Ipv4PrefixBuilder().setIpv4Prefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
2619 .yang.ietf.inet.types.rev130715.Ipv4Prefix(ipString)).build());
2621 MapReply reply = registerAddressAndQuery(eb.build());
2623 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2624 assertEquals(Ipv4PrefixAfi.class, receivedAddress.getAddressType());
2626 assertEquals(ipString, ((Ipv4Prefix) receivedAddress.getAddress()).getIpv4Prefix().getValue());
2628 assertEquals(instanceId, receivedAddress.getVirtualNetworkId().getValue().intValue());
2631 public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
2633 String macString = "01:02:03:04:05:06";
2634 String ipString = "10.20.255.30";
2635 HopBuilder hopBuilder = new HopBuilder();
2636 hopBuilder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
2637 hopBuilder.setLrsBits(new LrsBits(true, false, true));
2638 Hop hop1 = hopBuilder.build();
2639 hopBuilder.setAddress(new SimpleAddress(new MacAddress(macString)));
2640 hopBuilder.setLrsBits(new LrsBits(false, true, false));
2641 Hop hop2 = hopBuilder.build();
2642 ExplicitLocatorPathBuilder elpBuilder = new ExplicitLocatorPathBuilder();
2643 elpBuilder.setHop(new ArrayList<Hop>());
2644 elpBuilder.getHop().add(hop1);
2645 elpBuilder.getHop().add(hop2);
2647 EidBuilder eb = new EidBuilder();
2648 eb.setAddressType(ExplicitLocatorPathLcaf.class);
2649 eb.setVirtualNetworkId(null);
2650 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2651 .lisp.address.address.ExplicitLocatorPathBuilder().setExplicitLocatorPath(elpBuilder.build()).build());
2653 MapReply reply = registerAddressAndQuery(eb.build());
2655 assertEquals(ExplicitLocatorPathLcaf.class, reply.getMappingRecordItem().get(0).getMappingRecord().getEid()
2658 ExplicitLocatorPath receivedAddress = (ExplicitLocatorPath) reply.getMappingRecordItem().get(0)
2659 .getMappingRecord().getEid().getAddress();
2661 Hop receivedHop1 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(0);
2662 Hop receivedHop2 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(1);
2664 assertEquals(true, receivedHop1.getLrsBits().isLookup());
2665 assertEquals(false, receivedHop1.getLrsBits().isRlocProbe());
2666 assertEquals(true, receivedHop1.getLrsBits().isStrict());
2668 assertEquals(false, receivedHop2.getLrsBits().isLookup());
2669 assertEquals(true, receivedHop2.getLrsBits().isRlocProbe());
2670 assertEquals(false, receivedHop2.getLrsBits().isStrict());
2672 assertNotNull(receivedHop1.getAddress().getIpAddress().getIpv4Address());
2673 assertNotNull(receivedHop2.getAddress().getMacAddress());
2675 assertEquals(ipString, receivedHop1.getAddress().getIpAddress().getIpv4Address().getValue());
2676 assertEquals(macString, receivedHop2.getAddress().getMacAddress().getValue());
2679 public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
2681 String ipString = "1.2.3.4";
2684 int localPortLow = 3;
2685 int localPortHigh = 4;
2686 int remotePortLow = 4;
2687 int remotePortHigh = 5;
2689 ApplicationDataBuilder builder = new ApplicationDataBuilder();
2690 builder.setIpTos(ipTOs);
2691 builder.setProtocol(protocol);
2692 builder.setLocalPortLow(new PortNumber(localPortLow));
2693 builder.setLocalPortHigh(new PortNumber(localPortHigh));
2694 builder.setRemotePortLow(new PortNumber(remotePortLow));
2695 builder.setRemotePortHigh(new PortNumber(remotePortHigh));
2696 builder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
2698 EidBuilder eb = new EidBuilder();
2699 eb.setAddressType(ApplicationDataLcaf.class);
2700 eb.setVirtualNetworkId(null);
2701 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2702 .lisp.address.address.ApplicationDataBuilder().setApplicationData(builder.build()).build());
2703 Eid addressToSend = eb.build();
2705 MapReply reply = registerAddressAndQuery(addressToSend);
2707 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
2709 assertEquals(ApplicationDataLcaf.class, receivedAddress.getAddressType());
2711 ApplicationData receivedApplicationDataAddress = (ApplicationData) receivedAddress.getAddress();
2712 assertEquals(protocol, receivedApplicationDataAddress.getApplicationData().getProtocol().intValue());
2713 assertEquals(ipTOs, receivedApplicationDataAddress.getApplicationData().getIpTos().intValue());
2714 assertEquals(localPortLow, receivedApplicationDataAddress.getApplicationData().getLocalPortLow().getValue()
2716 assertEquals(localPortHigh, receivedApplicationDataAddress.getApplicationData().getLocalPortHigh().getValue()
2718 assertEquals(remotePortLow, receivedApplicationDataAddress.getApplicationData().getRemotePortLow().getValue()
2720 assertEquals(remotePortHigh, receivedApplicationDataAddress.getApplicationData().getRemotePortHigh().getValue()
2723 SimpleAddress ipAddressReceived = receivedApplicationDataAddress.getApplicationData().getAddress();
2724 assertEquals(ipString, ipAddressReceived.getIpAddress().getIpv4Address().getValue());
2727 // ------------------- TimeOut Tests -----------
2729 public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
2731 ConfigIni.getInstance().setSmrRetryCount(0);
2732 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
2733 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
2736 MapRequest mapRequest = MappingServiceIntegrationTestUtil.getDefaultMapRequestBuilder(eid).build();
2737 sendMapRequest(mapRequest);
2738 MapReply mapReply = receiveMapReply();
2739 assertEquals(4, mapReply.getNonce().longValue());
2740 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
2742 MapRegister mapRegister = MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid).build();
2743 sendMapRegister(mapRegister);
2744 MapNotify mapNotify = receiveMapNotify();
2745 assertEquals(8, mapNotify.getNonce().longValue());
2748 sendMapRequest(mapRequest);
2749 mapReply = receiveMapReply();
2750 assertEquals(4, mapReply.getNonce().longValue());
2751 assertEquals(MappingServiceIntegrationTestUtil.DEFAULT_IPV4_RLOC,
2752 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
2754 causeEntryToBeCleaned();
2755 sendMapRequest(mapRequest);
2756 mapReply = receiveMapReply();
2757 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
2760 public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
2762 Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32");
2763 MapRequest mapRequest = createMapRequest(eid);
2765 testTTLBeforeRegister(mapRequest);
2767 registerForTTL(eid);
2769 testTTLAfterRegister(mapRequest);
2771 causeEntryToBeCleaned();
2772 testTTLAfterClean(mapRequest);
2774 //northboundAddKey();
2775 //testTTLAfterAutherize(mapRequest);
2779 private void timedOutMappingRecord() {
2781 mapService.setMappingMerge(true);
2782 // mapping expires after 1 second
2783 ConfigIni.getInstance().setRegistrationValiditySb(1000L);
2785 final Eid eid = LispAddressUtil.asIpv4PrefixBinaryEid("1.2.3.4/32", new InstanceIdType(10L));
2786 final MappingRecord mappingRecord = MappingServiceIntegrationTestUtil.getDefaultMappingRecordBuilder(eid)
2787 .setRecordTtl(1000).build();
2789 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
2790 mapService.addMapping(MappingOrigin.Southbound, eid, MappingServiceIntegrationTestUtil.DEFAULT_SITE_ID,
2791 new MappingData(mappingRecord, System.currentTimeMillis()));
2794 MappingRecord resultRecord = (MappingRecord) mapService.getMapping(MappingOrigin.Southbound, eid);
2795 assertNull(resultRecord);
2796 ConfigIni.getInstance().setRegistrationValiditySb(ConfigIni.getInstance().getDefaultRegistrationValiditySb());
2799 private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
2801 sendMapRequest(mapRequest);
2802 mapReply = receiveMapReply();
2803 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
2806 private void causeEntryToBeCleaned() {
2807 // TODO XXX for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
2808 // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
2809 // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
2810 mapService.cleanCachedMappings();
2813 private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
2815 sendMapRequest(mapRequest);
2816 mapReply = receiveMapReply();
2817 assertEquals(LispAddressUtil.asIpv4Rloc("4.3.2.1"), mapReply.getMappingRecordItem().get(0).getMappingRecord()
2818 .getLocatorRecord().get(0).getRloc());
2819 assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
2822 private void registerForTTL(Eid eid) throws SocketTimeoutException {
2823 MapRegister mapRegister = createMapRegister(eid);
2824 sendMapRegister(mapRegister);
2825 assertMapNotifyReceived();
2828 private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
2830 sendMapRequest(mapRequest);
2831 mapReply = receiveMapReply();
2832 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
2835 private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
2837 sendMapRequest(mapRequest);
2838 mapReply = receiveMapReply();
2839 assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
2842 private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
2843 assertEquals(expectedTTL, mapReply.getMappingRecordItem().get(0).getMappingRecord().getRecordTtl().intValue());
2844 assertEquals(expectedAction, mapReply.getMappingRecordItem().get(0).getMappingRecord().getAction());
2847 private MapRegister createMapRegister(Eid eid, Rloc rloc) {
2848 return MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid, rloc).build();
2851 private MapRegister createMapRegister(Eid eid) {
2852 return MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid).build();
2855 private MapRequest createMapRequest(Eid eid) {
2856 return MappingServiceIntegrationTestUtil.getDefaultMapRequestBuilder(eid).build();
2859 public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
2861 String rloc = "127.0.0.3";
2862 int port = LispMessage.PORT_NUM;
2863 Rloc ipRloc = LispAddressUtil.asIpv4Rloc(rloc);
2864 sendProxyMapRequest(rloc, port, ipRloc);
2868 public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
2870 String rloc = "127.0.0.3";
2873 RlocBuilder rb = new RlocBuilder();
2874 rb.setAddressType(ApplicationDataLcaf.class);
2875 rb.setVirtualNetworkId(null);
2876 rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2877 .lisp.address.address.ApplicationDataBuilder()
2878 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
2879 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
2880 Rloc adLcaf = rb.build();
2882 LOG.info("testNonProxyOtherPort:" + LispAddressStringifier.getString(adLcaf));
2883 sendProxyMapRequest(rloc, port, adLcaf);
2887 private class XtrRequestMappingListener implements OdlLispProtoListener {
2890 public void onGotMapReply(GotMapReply notification) {
2894 public void onAddMapping(AddMapping notification) {
2898 public void onXtrReplyMapping(XtrReplyMapping notification) {
2902 public void onRequestMapping(RequestMapping notification) {
2906 public void onGotMapNotify(GotMapNotify notification) {
2910 public void onXtrRequestMapping(XtrRequestMapping notification) {
2914 public void onMappingKeepAlive(MappingKeepAlive notification) {
2919 public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
2921 configLispPlugin.shouldListenOnXtrPort(true);
2922 notificationCalled = false;
2923 final String eid = "10.10.10.10/32";
2924 String rloc = "127.0.0.3";
2925 int port = LispMessage.XTR_PORT_NUM;
2927 RlocBuilder rb = new RlocBuilder();
2928 rb.setAddressType(ApplicationDataLcaf.class);
2929 rb.setVirtualNetworkId(null);
2930 rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2931 .lisp.address.address.ApplicationDataBuilder()
2932 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
2933 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
2934 Rloc adLcaf = rb.build();
2936 final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2937 ((LispMappingService) lms).getNotificationService().registerNotificationListener(
2938 new XtrRequestMappingListener() {
2941 public void onXtrRequestMapping(XtrRequestMapping notification) {
2942 assertEquals(((Ipv4Prefix) mapRequest.getEidItem().get(0).getEid().getAddress())
2943 .getIpv4Prefix().getValue(), eid);
2944 notificationCalled = true;
2945 LOG.warn("notification arrived");
2948 sendMapRequest(mapRequest, port);
2949 for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
2950 if (notificationCalled) {
2953 LOG.warn("notification hasn't arrived, sleeping...");
2958 fail("Notification hasn't arrived");
2962 private void sendProxyMapRequest(String rloc, int port, Rloc adLcaf) throws SocketTimeoutException,
2964 String eid = "10.1.0.1/32";
2965 MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2966 sendMapRequest(mapRequest);
2967 DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
2968 MapRequest receivedMapRequest = MappingServiceIntegrationTestUtil.receiveMapRequest(
2969 nonProxySocket, MappingServiceIntegrationTestUtil.DEFAULT_SOCKET_TIMEOUT);
2970 assertEquals(mapRequest.getNonce(), receivedMapRequest.getNonce());
2971 assertEquals(mapRequest.getSourceEid(), receivedMapRequest.getSourceEid());
2972 assertEquals(mapRequest.getItrRloc(), receivedMapRequest.getItrRloc());
2973 assertEquals(mapRequest.getEidItem(), receivedMapRequest.getEidItem());
2974 nonProxySocket.close();
2977 private MapRequest createNonProxyMapRequest(String eid, Rloc adLcaf) throws SocketTimeoutException {
2978 MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixBinaryEid(eid));
2979 LocatorRecord record = new LocatorRecordBuilder(mr.getMappingRecordItem().get(0).getMappingRecord()
2980 .getLocatorRecord().get(0)).setRloc(adLcaf).build();
2981 mr.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().set(0, record);
2982 sendMapRegister(mr);
2983 assertMapNotifyReceived();
2984 MapRequest mapRequest = createMapRequest(LispAddressUtil.asIpv4PrefixBinaryEid(eid));
2985 MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
2986 builder.setPitr(true);
2987 mapRequest = builder.build();
2991 private void sendMapRequest(MapRequest mapRequest) {
2992 sendMapRequest(mapRequest, LispMessage.PORT_NUM);
2995 private void sendMapRequest(MapRequest mapRequest, int port) {
2996 sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
2999 private void sendMapRegister(MapRegister mapRegister) {
3000 sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
3003 private void sendPacket(byte[] bytesToSend) {
3004 sendPacket(bytesToSend, LispMessage.PORT_NUM);
3007 private void sendPacket(byte[] bytesToSend, int port) {
3008 MappingServiceIntegrationTestUtil.sendPacket(socket, bytesToSend, port);
3011 private ByteBuffer receivePacket() throws SocketTimeoutException {
3012 return MappingServiceIntegrationTestUtil.receivePacket(socket); }
3014 private ByteBuffer receivePacket(int timeout) throws SocketTimeoutException {
3015 return MappingServiceIntegrationTestUtil.receivePacket(socket, timeout);
3018 private void assertMapNotifyReceived() throws SocketTimeoutException {
3019 MappingServiceIntegrationTestUtil.receiveMapNotify(
3020 socket, MappingServiceIntegrationTestUtil.DEFAULT_SOCKET_TIMEOUT);
3023 private MapRequest receiveMapRequest() throws SocketTimeoutException {
3024 return MappingServiceIntegrationTestUtil.receiveMapRequest(
3025 socket, MappingServiceIntegrationTestUtil.DEFAULT_SOCKET_TIMEOUT);
3028 private MapReply receiveMapReply() throws SocketTimeoutException {
3029 return MappingServiceIntegrationTestUtil.receiveMapReply(
3030 socket, MappingServiceIntegrationTestUtil.DEFAULT_SOCKET_TIMEOUT);
3033 private MapNotify receiveMapNotify() throws SocketTimeoutException {
3034 return MappingServiceIntegrationTestUtil.receiveMapNotify(
3035 socket, MappingServiceIntegrationTestUtil.DEFAULT_SOCKET_TIMEOUT);
3038 private void sleepForSeconds(int seconds) {
3040 Thread.sleep(seconds*1000);
3041 } catch (InterruptedException e) {
3042 LOG.warn("Interrupted while sleeping", e);
3046 private void sleepForMilliseconds(long milliseconds) {
3048 Thread.sleep(milliseconds);
3049 } catch (InterruptedException e) {
3050 LOG.warn("Interrupted while sleeping", e);
3054 private byte[] extractWSUdpByteArray(String wiresharkHex) {
3055 final int HEADER_LEN = 42;
3056 byte[] res = new byte[1000];
3057 String[] split = wiresharkHex.split(" ");
3059 for (String cur : split) {
3061 if (cur.length() == 2) {
3063 if (counter > HEADER_LEN) {
3064 res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
3069 return Arrays.copyOf(res, counter - HEADER_LEN);
3072 private String stateToString(int state) {
3076 case Bundle.INSTALLED:
3078 case Bundle.RESOLVED:
3080 case Bundle.UNINSTALLED:
3081 return "UNINSTALLED";
3083 return "Not CONVERTED";
3087 private void areWeReady() throws InvalidSyntaxException {
3091 boolean debugit = false;
3092 Bundle b[] = bc.getBundles();
3093 for (Bundle element : b) {
3094 int state = element.getState();
3095 LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v"
3096 + element.getVersion() + ", state:" + stateToString(state));
3097 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
3098 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
3101 // String host = element.getHeaders().get("FRAGMENT-HOST");
3102 // if (host != null) {
3103 // LOG.warn("Bundle " + element.getSymbolicName() +
3104 // " is a fragment which is part of: " + host);
3105 // LOG.warn("Required imports are: " +
3106 // element.getHeaders().get("IMPORT-PACKAGE"));
3110 // } catch (BundleException e) {
3111 // LOG.error("BundleException:", e);
3120 LOG.warn(("Do some debugging because some bundle is unresolved"));
3122 // assertNotNull(broker);
3124 configLispPlugin.setLispAddress(lispBindAddress);
3126 // Uncomment this code to Know which services were actually loaded to
3130 for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
3131 LOG.info(sr.getBundle().getSymbolicName());
3132 LOG.info(sr.toString());
3139 private void cleanUP() {
3140 LOG.debug("\n\n\nCleaning up...\n\n");
3141 mapService.cleanCachedMappings();
3142 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_FIRST);
3143 configLispPlugin.shouldListenOnXtrPort(false);
3144 MappingServiceIntegrationTestUtil.drainSocket(socket);
3145 LOG.debug("\n\n\n... finished cleaning up!\n\n");
3148 private void restartSocket() {
3150 socket = MappingServiceIntegrationTestUtil.initSocket(LispMessage.PORT_NUM);
3151 MappingServiceIntegrationTestUtil.drainSocket(socket);