2 * Copyright (c) 2014 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.assertTrue;
13 import static org.junit.Assert.fail;
14 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A;
15 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_A_SB;
16 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B;
17 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_B_SB;
18 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C;
19 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_RLOC_10;
20 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_SB;
21 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_100_1_SB;
22 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_C_WP_50_2_SB;
23 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D4;
24 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D5;
25 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_DELETE_SB;
26 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_100_1_SB;
27 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_D_WP_50_2_SB;
28 import static org.opendaylight.lispflowmapping.integrationtest.MultiSiteScenarioUtil.SITE_E_SB;
29 import static org.ops4j.pax.exam.CoreOptions.composite;
30 import static org.ops4j.pax.exam.CoreOptions.maven;
31 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
33 import java.io.IOException;
34 import java.net.DatagramPacket;
35 import java.net.DatagramSocket;
36 import java.net.InetAddress;
37 import java.net.InetSocketAddress;
38 import java.net.SocketException;
39 import java.net.SocketTimeoutException;
40 import java.net.UnknownHostException;
41 import java.nio.ByteBuffer;
42 import java.util.ArrayList;
43 import java.util.Arrays;
44 import java.util.List;
46 import javax.inject.Inject;
48 //import org.codehaus.jettison.json.JSONException;
49 //import org.codehaus.jettison.json.JSONObject;
50 //import org.codehaus.jettison.json.JSONTokener;
51 import org.junit.After;
52 import org.junit.Assert;
53 import org.junit.Before;
54 import org.junit.Test;
55 import org.junit.runner.RunWith;
56 import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
57 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
58 import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
59 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
60 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
61 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
62 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
63 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
64 import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
65 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
66 import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
67 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
68 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.OdlLispProtoListener;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItem;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkey;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container.MappingAuthkeyBuilder;
99 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
100 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
101 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
102 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
103 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AfiListLcaf;
104 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ApplicationDataLcaf;
105 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
106 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
107 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
108 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.KeyValueAddressLcaf;
109 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
110 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
111 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SourceDestKeyLcaf;
112 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.AfiList;
113 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ApplicationData;
114 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
115 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix;
116 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder;
117 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.KeyValueAddress;
118 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
119 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
120 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.afi.list.AfiListBuilder;
121 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.application.data.ApplicationDataBuilder;
122 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.ExplicitLocatorPathBuilder;
123 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
124 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop.LrsBits;
125 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.HopBuilder;
126 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
127 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
128 import org.ops4j.pax.exam.Option;
129 import org.ops4j.pax.exam.junit.PaxExam;
130 import org.ops4j.pax.exam.util.Filter;
131 import org.ops4j.pax.exam.karaf.options.LogLevelOption.LogLevel;
132 import org.ops4j.pax.exam.options.MavenUrlReference;
133 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
134 import org.ops4j.pax.exam.spi.reactors.PerClass;
135 import org.osgi.framework.Bundle;
136 import org.osgi.framework.BundleContext;
137 import org.osgi.framework.InvalidSyntaxException;
138 import org.slf4j.Logger;
139 import org.slf4j.LoggerFactory;
141 @RunWith(PaxExam.class)
142 @ExamReactorStrategy(PerClass.class)
143 public class MappingServiceIntegrationTest extends AbstractMdsalTestBase {
144 private static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
146 private byte[] mapRequestPacket;
147 private byte[] mapRegisterPacketWithNotify;
148 private byte[] mapRegisterPacketWithoutNotify;
149 String lispBindAddress = "127.0.0.1";
150 static final String ourAddress = "127.0.0.2";
151 private Rloc locatorEid;
152 private DatagramSocket socket;
153 private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
155 public static final String ODL = "org.opendaylight.controller";
156 public static final String YANG = "org.opendaylight.yangtools";
157 public static final String JERSEY = "com.sun.jersey";
158 private static final int MAX_NOTIFICATION_RETRYS = 20;
159 private static final MappingAuthkey NULL_AUTH_KEY = new MappingAuthkeyBuilder().setKeyType(0).build();
160 private static final MappingAuthkey AUTH_KEY =
161 new MappingAuthkeyBuilder().setKeyType(1).setKeyString("password").build();
164 public String getModuleName() {
165 return "mappingservice-impl";
169 public String getInstanceName() {
170 return "mappingservice-default";
173 // This is temporary, since the properties in the pom file are not picked up
175 public String getKarafDistro() {
177 .groupId("org.opendaylight.lispflowmapping")
178 .artifactId("distribution-karaf")
179 .versionAsInProject()
185 public MavenUrlReference getFeatureRepo() {
187 .groupId("org.opendaylight.lispflowmapping")
188 .artifactId("features-lispflowmapping")
189 .classifier("features")
191 .versionAsInProject();
195 public String getFeatureName() {
196 return "odl-lispflowmapping-msmr";
200 public Option getLoggingOption() {
201 Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
202 "log4j.logger.org.opendaylight.lispflowmapping",
203 LogLevel.DEBUG.name());
204 option = composite(option, super.getLoggingOption());
209 public void testLispFlowMappingFeatureLoad() {
210 Assert.assertTrue(true);
214 public void after() {
215 if (socket != null) {
218 // if (connection != null) {
219 // connection.disconnect();
224 public void before() throws Exception {
226 mapService.setLookupPolicy(ConfigIni.NB_FIRST);
227 mapService.setMappingOverwrite(true);
229 locatorEid = LispAddressUtil.asIpv4Rloc("4.3.2.1");
230 socket = initSocket(socket, LispMessage.PORT_NUM);
232 // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
233 // LISP(Type = 8 - Encapsulated)
234 // IP: 192.168.136.10 -> 153.16.254.1
236 // LISP(Type = 1 Map-Request
240 // Source EID 1.2.3.4
241 // Nonce: 0x3d8d2acd39c8d608
242 // ITR-RLOC AFI=1 Address=192.168.136.10
243 // Record 1: 153.16.254.1/32
244 mapRequestPacket = extractWSUdpByteArray(new String("0000 00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
245 + "0010 00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
246 + "0020 00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
247 + "0030 00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
248 + "0040 fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
249 + "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
250 + "0060 00 01 99 10 fe 01"));
252 // IP: 192.168.136.10 -> 128.223.156.35
253 // UDP: 49289 -> 4342
254 // LISP(Type = 3 Map-Register, P=1, M=1
258 // AuthDataLength: 20 Data:
259 // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
260 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
262 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
263 // Priority/Weight: 1/100, Multicast Priority/Weight:
267 mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String(
268 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
269 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
270 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
271 + "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
272 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
273 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
274 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
276 // IP: 192.168.136.10 -> 128.223.156.35
277 // UDP: 49289 -> 4342
278 // LISP(Type = 3 Map-Register, P=1, M=1
281 // Key ID: 0x0000 NO AUTHENTICATION!!
282 // AuthDataLength: 00 Data:
283 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
285 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
286 // Priority/Weight: 1/100, Multicast Priority/Weight:
290 mapRegisterPacketWithNotify = extractWSUdpByteArray(new String(
291 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
292 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
293 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
294 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
295 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
296 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
297 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
299 // IP: 192.168.136.10 -> 128.223.156.35
300 // UDP: 49289 -> 4342
301 // LISP(Type = 3 Map-Register, P=1, M=1
304 // Key ID: 0x0000 NO AUTHENTICATION!!
305 // AuthDataLength: 00 Data:
306 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
308 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
309 // Priority/Weight: 1/100, Multicast Priority/Weight:
313 mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String(
314 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
315 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
316 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
317 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
318 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
319 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
320 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
324 private BundleContext bc;
325 //private HttpURLConnection connection;
326 protected static boolean notificationCalled;
328 @Inject @Filter(timeout=60000)
329 private IFlowMapping lms;
331 @Inject @Filter(timeout=60000)
332 private IMappingService mapService;
334 @Inject @Filter(timeout=10000)
335 private IConfigLispSouthboundPlugin configLispPlugin;
338 public void testSimpleUsage() throws Exception {
340 mapRegisterWithMapNotify();
341 mapRegisterWithMapNotifyAndMapRequest();
342 registerAndQuery__MAC();
343 mapRequestMapRegisterAndMapRequest();
344 mapRegisterWithAuthenticationWithoutConfiguringAKey();
345 mapRegisterWithoutMapNotify();
349 public void testLCAFs() throws Exception {
350 //registerAndQuery__SrcDestLCAF();
351 //registerAndQuery__SrcDestLCAFOverlap();
352 //registerAndQuery__KeyValueLCAF();
353 //registerAndQuery__ListLCAF();
354 //registerAndQuery__ApplicationData();
355 //registerAndQuery__TrafficEngineering();
356 //registerAndQuery__SegmentLCAF();
360 public void testMask() throws Exception {
361 //testPasswordExactMatch(); TODO commented because it needs NB
362 //testPasswordMaskMatch(); TODO commented because it needs NB
363 eidPrefixLookupIPv4();
364 eidPrefixLookupIPv6();
368 public void testNorthbound() throws Exception {
370 northboundAddMapping();
371 northboundDeleteMapping();
372 northboundRetrieveKey();
373 northboundRetrieveMapping();
374 northboundRetrieveSourceDestKey();
375 northboundRetrieveSourceDestMapping();
379 public void testOverWriting() throws Exception {
380 //testMapRegisterDosntOverwritesOtherSubKeys(); TODO weird failure, needs debug
382 // TODO: remove, we don't support overwrite flag any longer and RLOCs are not saved as independent RLOC groups
383 // testMapRegisterOverwritesSameSubkey();
384 // testMapRegisterOverwritesNoSubkey();
385 // testMapRegisterDoesntOverwritesNoSubkey();
389 public void testTimeOuts() throws Exception {
390 mapRequestMapRegisterAndMapRequestTestTimeout();
391 //mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse(); TODO commented because it needs NB
395 // public void testNonProxy() throws Throwable {
396 // testSimpleNonProxy();
397 // testNonProxyOtherPort();
398 // testRecievingNonProxyOnXtrPort();
402 public void testSmr() throws Exception {
403 registerQueryRegisterWithSmr();
411 public void testMultiSiteScenarioA() throws IOException {
414 final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
415 multiSiteScenario.setCommonAuthentication();
418 final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
421 multiSiteScenario.storeSouthboundMappings(SITE_A, SITE_B, SITE_C, SITE_D4, SITE_D5);
422 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
423 multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
425 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
426 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
427 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
430 //following action should trigger generatting of SMR messages:
433 multiSiteScenario.storeNorthMappingSrcDst(SITE_A, SITE_C);
435 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1));
436 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
437 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
438 multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
441 // following action should trigger generatting of SMR messages:
446 multiSiteScenario.deleteNorthMappingNegative(SITE_C);
448 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1), SITE_A
451 multiSiteScenario.assertPingWorks(SITE_D4, 5, SITE_C, 4);
454 // following action should trigger generatting of SMR messages:
456 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C_RLOC_10);
458 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5));
459 //way of testing ping - get RLOC for mapping src-dst and compare it with awaited value doesn't test
460 //that ping won't be successfull
461 multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
464 // following action should trigger generatting of SMR messages:
467 multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
469 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5), SITE_B.getHost(5));
470 multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
473 multiSiteScenario.assertPingFails(SITE_D5, 5, SITE_C, 3);
476 multiSiteScenario.deleteNorthMapingSrcDst(SITE_A, SITE_C);
478 // following action should trigger generatting of SMR messages:
482 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
485 // following action should trigger generatting of SMR messages:
489 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
491 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
494 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
495 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
496 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
499 // following action should trigger generatting of SMR messages:
504 multiSiteScenario.deleteNorthMapingSrcDst(SITE_B, SITE_C);
506 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
509 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
510 multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
511 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
514 // following action should trigger generatting of SMR messages:
519 multiSiteScenario.deleteNorthMappingNegative(SITE_C);
521 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
524 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
525 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
526 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
528 socketReader.stopReading();
536 public void testMultiSiteScenarioB() throws IOException {
539 final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
540 multiSiteScenario.setCommonAuthentication();
543 final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
545 mapService.setLookupPolicy(ConfigIni.NB_AND_SB);
546 mapService.setMappingOverwrite(false);
549 multiSiteScenario.storeSouthboundMappings(SITE_A_SB, SITE_B_SB, SITE_C_WP_100_1_SB, SITE_D_WP_100_1_SB,
551 multiSiteScenario.storeNorthMappingIpPrefix(SITE_A_SB);
552 multiSiteScenario.storeNorthMappingIpPrefix(SITE_B_SB);
553 multiSiteScenario.storeNorthMappingIpPrefix(SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
555 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
556 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
559 // following action should trigger generatting of SMR messages:
562 multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
564 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
566 // following action should trigger generatting of SMR messages:
569 multiSiteScenario.storeNorthMappingNegative(SITE_C_SB, Action.Drop);
571 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
573 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
574 multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_SB, 4);
578 // following action should trigger generatting of SMR messages:
581 multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
583 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
584 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4);
587 multiSiteScenario.storeNorthMappingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
589 // following action should trigger generatting of SMR messages:
592 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
593 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
596 multiSiteScenario.deleteSouthboundMappings(SITE_D_DELETE_SB);
598 // following action should trigger generatting of SMR messages:
601 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
603 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
606 multiSiteScenario.deleteNorthMapingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
608 // following action should trigger generatting of SMR messages:
611 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
613 multiSiteScenario.deleteNorthMapingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB);
615 multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
617 socketReader.stopReading();
621 // ------------------------------- Simple Tests ---------------------------
623 public void mapRequestSimple() throws SocketTimeoutException {
626 // This Map-Request is sent from a source port different from 4342
627 // We close and bind the socket on the correct port
628 if (socket != null) {
631 socket = initSocket(socket, 56756);
633 sendPacket(mapRequestPacket);
634 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
635 MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
636 assertEquals(4435248268955932168L, reply.getNonce().longValue());
640 public void mapRegisterWithMapNotify() throws SocketTimeoutException {
642 mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), NULL_AUTH_KEY);
644 sendPacket(mapRegisterPacketWithNotify);
645 MapNotify reply = receiveMapNotify();
646 assertEquals(7, reply.getNonce().longValue());
649 public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
651 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
653 MapReply mapReply = registerAddressAndQuery(eid);
655 assertEquals(4, mapReply.getNonce().longValue());
656 assertEquals(locatorEid, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
661 public void registerAndQuery__MAC() throws SocketTimeoutException {
663 String macAddress = "01:02:03:04:05:06";
665 MapReply reply = registerAddressAndQuery(LispAddressUtil.asMacEid(macAddress));
668 Eid addressFromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
669 assertEquals(MacAfi.class, addressFromNetwork.getAddressType());
670 String macAddressFromReply = ((Mac) addressFromNetwork.getAddress()).getMac().getValue();
672 assertEquals(macAddress, macAddressFromReply);
675 public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
677 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
678 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
681 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
682 mapRequestBuilder.setNonce((long) 4);
683 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
684 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
685 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
686 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
687 mapRequestBuilder.getItrRloc().add(
688 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
689 sendMapRequest(mapRequestBuilder.build());
690 MapReply mapReply = receiveMapReply();
691 assertEquals(4, mapReply.getNonce().longValue());
692 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
693 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
694 mapRegisterbuilder.setWantMapNotify(true);
695 mapRegisterbuilder.setNonce((long) 8);
696 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
697 etlrBuilder.setEid(eid);
698 etlrBuilder.setRecordTtl(254);
699 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
700 recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
701 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
702 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
703 mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
704 mapRegisterbuilder.getMappingRecordItem().add(
705 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
706 sendMapRegister(mapRegisterbuilder.build());
707 MapNotify mapNotify = receiveMapNotify();
708 assertEquals(8, mapNotify.getNonce().longValue());
710 sendMapRequest(mapRequestBuilder.build());
711 mapReply = receiveMapReply();
712 assertEquals(4, mapReply.getNonce().longValue());
713 assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
714 .getLocatorRecord().get(0).getRloc());
718 public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
720 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
721 SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
722 Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
723 SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
724 Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
725 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
726 assertEquals(2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
727 assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
729 assertEquals(rloc1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(1)
733 public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
735 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
736 SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
737 Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
738 SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
739 Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
740 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
741 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
742 assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
746 public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
748 mapService.setMappingOverwrite(true);
749 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
750 Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
751 Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
752 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
753 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
754 assertEquals(rloc2Value, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
758 public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
760 mapService.setMappingOverwrite(false);
761 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
762 Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
763 Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
764 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
765 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
766 Rloc rloc1ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
768 Rloc rloc2ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
770 assertTrue((rloc1Value.equals(rloc1ReturnValueContainer) && rloc2Value.equals(rloc2ReturnValueContainer))
771 || (rloc1Value.equals(rloc2ReturnValueContainer) && rloc2Value.equals(rloc1ReturnValueContainer)));
774 private MapReply sendMapRegisterTwiceWithDiffrentValues(Eid eid, Rloc rloc1, Rloc rloc2)
775 throws SocketTimeoutException {
776 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
778 MapRegister mb = createMapRegister(eid, rloc1);
779 MapNotify mapNotify = lms.handleMapRegister(mb).getLeft();
780 MapRequest mr = createMapRequest(eid);
781 MapReply mapReply = lms.handleMapRequest(mr);
782 assertEquals(mb.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc(),
783 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
784 mb = createMapRegister(eid, rloc2);
785 mapNotify = lms.handleMapRegister(mb).getLeft();
786 assertEquals(8, mapNotify.getNonce().longValue());
787 mr = createMapRequest(eid);
789 mapReply = lms.handleMapRequest(mr);
793 public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
795 sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
798 // If didn't timeout then fail:
800 } catch (SocketTimeoutException ste) {
804 public void mapRegisterWithoutMapNotify() {
806 sendPacket(mapRegisterPacketWithoutNotify);
809 // If didn't timeout then fail:
811 } catch (SocketTimeoutException ste) {
815 public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
817 lms.setShouldUseSmr(true);
818 mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), NULL_AUTH_KEY);
821 sendPacket(mapRegisterPacketWithNotify);
825 sendPacket(mapRequestPacket);
828 mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
829 sendPacket(mapRegisterPacketWithoutNotify);
831 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
832 MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
833 assertTrue(smr.isSmr());
834 Eid sourceEid = smr.getSourceEid().getEid();
835 assertTrue(LispAddressUtil.asIpv4Eid("153.16.254.1").equals(sourceEid));
836 Eid smrEid = smr.getEidItem().get(0).getEid();
837 assertTrue(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32").equals(smrEid));
840 // --------------------- Northbound Tests ---------------------------
842 private void northboundAddKey() throws Exception {
844 LispIpv4Address address = LispAddressUtil.asIPAfiAddress("1.2.3.4");
846 String pass = "asdf";
848 URL url = createPutURL("key");
849 String authKeyJSON = createAuthKeyJSON(pass, address, mask);
850 callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
852 String retrievedKey = lms.getAuthenticationKey(LispAddressUtil.toContainer(address), mask);
854 // Check stored password matches the one sent
855 assertEquals(pass, retrievedKey);
859 private void northboundRetrieveSourceDestKey() throws Exception {
861 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
862 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
863 .primitiveaddress.Ipv4) LispAddressUtil
864 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
865 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
866 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
867 .primitiveaddress.Ipv4) LispAddressUtil
868 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
871 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
872 AddressFamilyNumberEnum.LCAF.getIanaCode())
873 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
874 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build())
875 .setSrcMaskLength((short) mask1)
876 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build())
877 .setDstMaskLength((short) mask2).build();
878 String pass = "asdf";
880 lms.addAuthenticationKey(LispAddressUtil.toContainer(sourceDestAddress), mask1, pass);
882 // URL url = createGetKeyIPv4URL(address1, mask1);
883 URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
884 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getSrcAddress()
885 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
886 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getDstAddress()
887 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
888 String reply = callURL("GET", null, "application/json", null, url);
889 JSONTokener jt = new JSONTokener(reply);
890 JSONObject json = new JSONObject(jt);
892 // test that the password matches what was we expected.
893 assertEquals(pass, json.get("key"));
897 private void northboundRetrieveKey() throws Exception {
899 LispIpv4Address address = LispAddressUtil.asIPAfiAddress("10.0.0.1");
901 String pass = "asdf";
903 lms.addAuthenticationKey(LispAddressUtil.toContainer(address), mask, pass);
905 URL url = createGetKeyIPv4URL(address, mask);
906 String reply = callURL("GET", null, "application/json", null, url);
907 JSONTokener jt = new JSONTokener(reply);
908 JSONObject json = new JSONObject(jt);
910 // test that the password matches what was we expected.
911 assertEquals(pass, json.get("key"));
915 private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
916 return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
917 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
920 private void northboundAddMapping() throws Exception {
922 String pass = "asdf";
923 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
925 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
927 // NB add mapping always checks the key
928 lms.addAuthenticationKey(LispAddressUtil.toContainer(eid), mask, pass);
930 URL url = createPutURL("mapping");
931 String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
932 callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
934 // Retrieve the RLOC from the database
935 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
936 mapRequestBuilder.setPitr(false);
937 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
938 mapRequestBuilder.getEidItem().add(
939 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(
940 LispAddressUtil.toContainer(eid)).build());
941 MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
943 LispIpv4Address retrievedRloc = (LispIpv4Address) LispAddressUtil.toAFI(
944 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
945 .getLispAddressContainer());
947 assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
951 private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
952 String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ "
953 + "\"proxyMapReply\" : false, "
954 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : "
955 + "{ " + "\"ipAddress\" : \""
956 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "},"
957 + "\"mapVersion\" : 0,"
958 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ "
959 + "\"multicastPriority\" : 1,"
960 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\","
962 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50,"
963 + "\"rlocProbed\" : false, "
964 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], "
965 + "\"recordTtl\" : 100" + "} " + "], "
966 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
971 private void northboundRetrieveMapping() throws Exception {
973 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
975 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
976 // Insert mapping in the database
977 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
978 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
979 etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
980 etlr.setMaskLength((short) mask);
981 etlr.setRecordTtl(254);
982 etlr.setAuthoritative(false);
983 etlr.setAction(Action.NoAction);
984 LocatorRecordBuilder record = new LocatorRecordBuilder();
985 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
986 record.setRouted(true);
987 record.setRlocProbed(false);
988 record.setLocalLocator(false);
989 record.setPriority((short) 1);
990 record.setWeight((short) 50);
991 record.setMulticastPriority((short) 1);
992 record.setMulticastWeight((short) 1);
993 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
994 etlr.getLocatorRecord().add(record.build());
995 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
996 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
997 lms.handleMapRegister(mapRegister.build(), false);
999 // Get mapping using NB interface. No IID used
1000 URL url = createGetMappingIPv4URL(0, eid, mask);
1001 String reply = callURL("GET", null, "application/json", null, url);
1002 JSONTokener jt = new JSONTokener(reply);
1003 JSONObject json = new JSONObject(jt);
1005 // With just one locator, locators is not a JSONArray
1006 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
1007 .getString("ipAddress");
1009 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
1013 private void northboundDeleteMapping() throws Exception {
1015 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
1017 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1018 // Insert mapping in the database
1019 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1020 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1021 etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
1022 etlr.setMaskLength((short) mask);
1023 etlr.setRecordTtl(254);
1024 etlr.setAuthoritative(false);
1025 etlr.setAction(Action.NoAction);
1026 LocatorRecordBuilder record = new LocatorRecordBuilder();
1027 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
1028 record.setRouted(true);
1029 record.setRlocProbed(false);
1030 record.setLocalLocator(false);
1031 record.setPriority((short) 1);
1032 record.setWeight((short) 50);
1033 record.setMulticastPriority((short) 1);
1034 record.setMulticastWeight((short) 1);
1035 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1036 etlr.getLocatorRecord().add(record.build());
1037 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1038 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1039 lms.handleMapRegister(mapRegister.build(), false);
1041 // Delete mapping using NB interface. No IID used
1042 URL url = createDeleteMappingIPv4URL(0, eid, mask);
1043 String reply = callURL("DELETE", null, "application/json", null, url);
1045 // Get mapping using NB interface. No IID used
1046 url = createGetMappingIPv4URL(0, eid, mask);
1047 reply = callURL("GET", null, "application/json", null, url);
1048 JSONTokener jt = new JSONTokener(reply);
1049 JSONObject json = new JSONObject(jt);
1051 // With just one locator, locators is not a JSONArray
1052 assertEquals(json.getJSONArray("locators").length(), 0);
1055 private void northboundRetrieveSourceDestMapping() throws Exception {
1057 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1058 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1059 .primitiveaddress.Ipv4) LispAddressUtil
1060 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
1061 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1062 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1063 .primitiveaddress.Ipv4) LispAddressUtil
1064 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
1067 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
1068 AddressFamilyNumberEnum.LCAF.getIanaCode())
1069 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
1070 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(
1071 address1).build()).setSrcMaskLength((short) mask1)
1072 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(
1073 address2).build()).setDstMaskLength((short) mask2).build();
1074 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1076 // Insert mapping in the database
1077 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1078 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1079 etlr.setLispAddressContainer(LispAddressUtil.toContainer(sourceDestAddress));
1080 etlr.setMaskLength((short) mask1);
1081 etlr.setRecordTtl(254);
1082 etlr.setAuthoritative(false);
1083 etlr.setAction(Action.NoAction);
1084 LocatorRecordBuilder record = new LocatorRecordBuilder();
1085 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
1086 record.setRouted(true);
1087 record.setRlocProbed(false);
1088 record.setLocalLocator(false);
1089 record.setPriority((short) 1);
1090 record.setWeight((short) 50);
1091 record.setMulticastPriority((short) 1);
1092 record.setMulticastWeight((short) 1);
1093 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1094 etlr.getLocatorRecord().add(record.build());
1095 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1096 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1097 lms.handleMapRegister(mapRegister.build(), false);
1099 // Get mapping using NB interface. No IID used
1100 URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
1101 address1.getIpv4Address().getIpv4Address().getValue(),
1103 address2.getIpv4Address().getIpv4Address().getValue(),
1105 String reply = callURL("GET", null, "application/json", null, url);
1106 JSONTokener jt = new JSONTokener(reply);
1107 JSONObject json = new JSONObject(jt);
1109 // With just one locator, locators is not a JSONArray
1110 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
1111 .getString("ipAddress");
1113 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
1117 private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
1118 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key",
1119 address.getAfi().shortValue(),
1120 address.getIpv4Address().getValue(), mask);
1121 URL url = new URL(restUrl);
1125 private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
1126 throws MalformedURLException {
1127 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
1128 "key", afi, srcAddress, srcMask,
1129 dstAddress, dstMask);
1130 URL url = new URL(restUrl);
1134 private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
1135 throws MalformedURLException {
1136 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
1137 "mapping", afi, srcAddress,
1138 srcMask, dstAddress, dstMask);
1139 URL url = new URL(restUrl);
1143 private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
1144 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
1145 iid, address.getAfi()
1146 .shortValue(), address.getIpv4Address().getValue(), mask);
1147 URL url = new URL(restUrl);
1151 private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
1152 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
1153 iid, address.getAfi()
1154 .shortValue(), address.getIpv4Address().getValue(), mask);
1155 URL url = new URL(restUrl);
1159 private URL createPutURL(String resource) throws MalformedURLException {
1161 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
1163 URL url = new URL(restUrl);
1167 private String createAuthenticationString() {
1168 String authString = "admin:admin";
1169 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
1170 String authStringEnc = new String(authEncBytes);
1171 return authStringEnc;
1174 private String callURL(String method, String content, String accept, String body, URL url) throws IOException,
1176 String authStringEnc = createAuthenticationString();
1177 connection = (HttpURLConnection) url.openConnection();
1178 connection.setRequestMethod(method);
1179 connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
1180 if (content != null) {
1181 connection.setRequestProperty("Content-Type", content);
1183 if (accept != null) {
1184 connection.setRequestProperty("Accept", accept);
1187 // now add the request body
1188 connection.setDoOutput(true);
1189 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
1193 connection.connect();
1195 // getting the result, first check response code
1196 Integer httpResponseCode = connection.getResponseCode();
1198 if (httpResponseCode > 299) {
1199 LOG.trace("HTTP Address: " + url);
1200 LOG.trace("HTTP Response Code: " + httpResponseCode);
1204 InputStream is = connection.getInputStream();
1205 BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
1206 StringBuilder sb = new StringBuilder();
1208 while ((cp = rd.read()) != -1) {
1209 sb.append((char) cp);
1212 connection.disconnect();
1213 return (sb.toString());
1216 // timePeriod - in ms
1217 public void assertNoPacketReceived(int timePeriod) {
1219 receivePacket(timePeriod);
1220 // If didn't timeout then fail:
1222 } catch (SocketTimeoutException ste) {
1226 // ------------------------------- Mask Tests ---------------------------
1228 public void eidPrefixLookupIPv4() throws SocketTimeoutException {
1230 runPrefixTest(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/16"), LispAddressUtil.asIpv4PrefixEid("1.2.3.2/32"),
1231 LispAddressUtil.asIpv4PrefixEid("1.1.1.1/32"));
1234 public void eidPrefixLookupIPv6() throws SocketTimeoutException {
1236 runPrefixTest(LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:6:7:8/64"),
1237 LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:1:2:3/128"),
1238 LispAddressUtil.asIpv6PrefixEid("1:2:3:1:2:3:1:2/128"));
1241 private void runPrefixTest(Eid registerEID, Eid matchedAddress, Eid unMatchedAddress)
1242 throws SocketTimeoutException {
1243 mapService.addAuthenticationKey(registerEID, NULL_AUTH_KEY);
1246 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1247 mapRegister.setWantMapNotify(true);
1248 mapRegister.setNonce((long) 8);
1249 mapRegister.setWantMapNotify(true);
1250 mapRegister.setKeyId((short) 0);
1251 mapRegister.setAuthenticationData(new byte[0]);
1252 mapRegister.setNonce((long) 8);
1253 mapRegister.setProxyMapReply(false);
1254 MappingRecordBuilder etlr = new MappingRecordBuilder();
1255 etlr.setRecordTtl(254);
1256 etlr.setAction(Action.NoAction);
1257 etlr.setAuthoritative(false);
1258 etlr.setMapVersion((short) 0);
1259 etlr.setEid(registerEID);
1260 etlr.setRecordTtl(254);
1261 LocatorRecordBuilder record = new LocatorRecordBuilder();
1262 record.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1263 record.setLocalLocator(false);
1264 record.setRlocProbed(false);
1265 record.setRouted(true);
1266 record.setMulticastPriority((short) 0);
1267 record.setMulticastWeight((short) 0);
1268 record.setPriority((short) 0);
1269 record.setWeight((short) 0);
1270 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1271 etlr.getLocatorRecord().add(record.build());
1272 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1273 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1274 sendMapRegister(mapRegister.build());
1275 MapNotify mapNotify = receiveMapNotify();
1276 assertEquals(8, mapNotify.getNonce().longValue());
1278 MapRequestBuilder mapRequest = new MapRequestBuilder();
1279 mapRequest.setNonce((long) 4);
1280 mapRequest.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
1281 mapRequest.setEidItem(new ArrayList<EidItem>());
1282 mapRequest.setAuthoritative(false);
1283 mapRequest.setMapDataPresent(false);
1284 mapRequest.setPitr(false);
1285 mapRequest.setProbe(false);
1286 mapRequest.setSmr(false);
1287 mapRequest.setSmrInvoked(false);
1288 mapRequest.getEidItem().add(new EidItemBuilder().setEid(matchedAddress).build());
1289 mapRequest.setItrRloc(new ArrayList<ItrRloc>());
1290 mapRequest.getItrRloc().add(
1291 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1292 sendMapRequest(mapRequest.build());
1293 MapReply mapReply = receiveMapReply();
1294 assertEquals(4, mapReply.getNonce().longValue());
1295 assertEquals(record.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
1297 mapRequest.setEidItem(new ArrayList<EidItem>());
1298 mapRequest.getEidItem().add(new EidItemBuilder().setEid(unMatchedAddress).build());
1299 sendMapRequest(mapRequest.build());
1300 mapReply = receiveMapReply();
1301 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1304 // This registers an IP with a MapRegister, then adds a password via the
1305 // northbound REST API
1306 // and checks that the password works
1307 public void testPasswordExactMatch() throws Exception {
1309 String ipString = "10.0.0.1";
1310 LispIpv4Address address = LispAddressUtil.asIPAfiAddress(ipString);
1312 String pass = "pass";
1314 URL url = createPutURL("key");
1316 String jsonAuthData = createAuthKeyJSON(pass, address, mask);
1318 LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
1319 LOG.trace("Address: " + address);
1321 byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232,
1322 (byte) 31, (byte) 249, (byte) 87,
1323 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53,
1324 (byte) 196, (byte) 62 };
1326 byte[] zeros = new byte[20];
1328 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1330 // build a MapRegister
1331 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1332 mapRegister.setWantMapNotify(true);
1333 mapRegister.setNonce((long) 8);
1334 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1335 etlr.setLispAddressContainer(LispAddressUtil.toContainer(address));
1336 etlr.setMaskLength((short) mask);
1337 etlr.setRecordTtl(254);
1338 LocatorRecordBuilder record = new LocatorRecordBuilder();
1339 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1340 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1341 etlr.getLocatorRecord().add(record.build());
1342 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1343 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1345 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1346 mapRegister.setAuthenticationData(zeros);
1348 sendMapRegister(mapRegister.build());
1349 assertNoPacketReceived(3000);
1351 mapRegister.setAuthenticationData(expectedSha);
1353 sendMapRegister(mapRegister.build());
1355 assertMapNotifyReceived();
1358 public void testPasswordMaskMatch() throws Exception {
1360 LispIpv4Address addressInRange = LispAddressUtil.asIPAfiAddress("10.20.30.40");
1361 LispIpv4Address addressOutOfRange = LispAddressUtil.asIPAfiAddress("20.40.30.40");
1362 LispIpv4Address range = LispAddressUtil.asIPAfiAddress("10.20.30.0");
1365 String pass = "pass";
1367 URL url = createPutURL("key");
1368 String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1370 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1371 // build a MapRegister
1372 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1374 mapRegister.setWantMapNotify(true);
1375 mapRegister.setNonce((long) 8);
1376 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1377 etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressInRange));
1378 etlr.setMaskLength((short) mask);
1379 etlr.setRecordTtl(254);
1380 LocatorRecordBuilder record = new LocatorRecordBuilder();
1381 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1382 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1383 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1384 etlr.getLocatorRecord().add(record.build());
1385 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1386 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1388 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1390 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4,
1391 -67, -113, 104, -110, -71 });
1393 sendMapRegister(mapRegister.build());
1395 assertMapNotifyReceived();
1397 etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressOutOfRange));
1399 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123,
1400 -71, -14, -99, 67, -23, -73 });
1402 sendMapRegister(mapRegister.build());
1403 assertNoPacketReceived(3000);
1406 // takes an address, packs it in a MapRegister and sends it
1407 private void registerAddress(Eid eid) throws SocketTimeoutException {
1408 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1410 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1411 mapRegisterBuilder.setWantMapNotify(true);
1412 mapRegisterBuilder.setKeyId((short) 0);
1413 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1414 mapRegisterBuilder.setNonce((long) 8);
1415 mapRegisterBuilder.setProxyMapReply(false);
1416 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1417 etlrBuilder.setEid(eid);
1418 etlrBuilder.setRecordTtl(254);
1419 etlrBuilder.setAction(Action.NoAction);
1420 etlrBuilder.setAuthoritative(false);
1421 etlrBuilder.setMapVersion((short) 0);
1422 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1423 recordBuilder.setLocalLocator(false);
1424 recordBuilder.setRlocProbed(false);
1425 recordBuilder.setRouted(true);
1426 recordBuilder.setMulticastPriority((short) 0);
1427 recordBuilder.setMulticastWeight((short) 0);
1428 recordBuilder.setPriority((short) 0);
1429 recordBuilder.setWeight((short) 0);
1430 recordBuilder.setRloc(locatorEid);
1431 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1432 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1433 mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1434 mapRegisterBuilder.getMappingRecordItem().add(
1435 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1436 sendMapRegister(mapRegisterBuilder.build());
1437 MapNotify mapNotify = receiveMapNotify();
1438 assertEquals(8, mapNotify.getNonce().longValue());
1441 private MapReply queryForAddress(Eid eid, String srcEid) throws SocketTimeoutException {
1442 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1443 mapRequestBuilder.setNonce((long) 4);
1444 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1445 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1446 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1447 if (srcEid != null) {
1448 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(srcEid)).build());
1450 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress))
1453 mapRequestBuilder.getItrRloc().add(
1454 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1455 mapRequestBuilder.setAuthoritative(false);
1456 mapRequestBuilder.setMapDataPresent(false);
1457 mapRequestBuilder.setPitr(false);
1458 mapRequestBuilder.setProbe(false);
1459 mapRequestBuilder.setSmr(false);
1460 mapRequestBuilder.setSmrInvoked(false);
1461 sendMapRequest(mapRequestBuilder.build());
1462 return receiveMapReply();
1465 // takes an address, packs it in a MapRegister, sends it, returns the
1467 private MapReply registerAddressAndQuery(Eid eid) throws SocketTimeoutException {
1468 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1470 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1471 mapRegisterBuilder.setWantMapNotify(true);
1472 mapRegisterBuilder.setKeyId((short) 0);
1473 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1474 mapRegisterBuilder.setNonce((long) 8);
1475 mapRegisterBuilder.setProxyMapReply(false);
1476 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1477 etlrBuilder.setEid(eid);
1478 etlrBuilder.setRecordTtl(254);
1479 etlrBuilder.setAction(Action.NoAction);
1480 etlrBuilder.setAuthoritative(false);
1481 etlrBuilder.setMapVersion((short) 0);
1482 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1483 recordBuilder.setLocalLocator(false);
1484 recordBuilder.setRlocProbed(false);
1485 recordBuilder.setRouted(true);
1486 recordBuilder.setMulticastPriority((short) 0);
1487 recordBuilder.setMulticastWeight((short) 0);
1488 recordBuilder.setPriority((short) 0);
1489 recordBuilder.setWeight((short) 0);
1490 recordBuilder.setRloc(locatorEid);
1491 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1492 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1493 mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1494 mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
1495 etlrBuilder.build()).build());
1496 sendMapRegister(mapRegisterBuilder.build());
1497 MapNotify mapNotify = receiveMapNotify();
1498 assertEquals(8, mapNotify.getNonce().longValue());
1499 // wait for the notifications to propagate
1501 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1502 mapRequestBuilder.setNonce((long) 4);
1503 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1504 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1505 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1506 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
1507 mapRequestBuilder.getItrRloc().add(
1508 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1509 mapRequestBuilder.setAuthoritative(false);
1510 mapRequestBuilder.setMapDataPresent(false);
1511 mapRequestBuilder.setPitr(false);
1512 mapRequestBuilder.setProbe(false);
1513 mapRequestBuilder.setSmr(false);
1514 mapRequestBuilder.setSmrInvoked(false);
1515 sendMapRequest(mapRequestBuilder.build());
1516 return receiveMapReply();
1519 // ------------------------------- LCAF Tests ---------------------------
1522 public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1524 String ipPrefix = "10.20.30.200/32";
1525 String macString = "01:02:03:04:05:06";
1527 SourceDestKeyBuilder builder = new SourceDestKeyBuilder();
1528 builder.setSource(new SimpleAddress(new IpPrefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
1529 .ietf.inet.types.rev100924.Ipv4Prefix(ipPrefix))));
1530 builder.setDest(new SimpleAddress(new MacAddress(macString)));
1532 EidBuilder eb = new EidBuilder();
1533 eb.setAddressType(SourceDestKeyLcaf.class);
1534 eb.setVirtualNetworkId(null);
1535 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1536 .lisp.address.address.SourceDestKeyBuilder().setSourceDestKey(builder.build()).build());
1538 MapReply reply = registerAddressAndQuery(eb.build());
1540 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1541 assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
1542 SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
1544 SimpleAddress receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource();
1545 SimpleAddress receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest();
1547 assertNotNull(receivedAddr1.getIpPrefix().getIpv4Prefix());
1548 assertNotNull(receivedAddr2.getMacAddress());
1550 IpPrefix receivedIP = receivedAddr1.getIpPrefix();
1551 MacAddress receivedMAC = receivedAddr2.getMacAddress();
1553 assertEquals(ipPrefix, receivedIP.getIpv4Prefix().getValue());
1554 assertEquals(macString, receivedMAC.getValue());
1558 public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1560 String ipString1 = "10.10.10.0";
1561 String ipString2 = "20.20.20.0";
1562 String ipPrefix1 = ipString1 + "/24";
1563 String ipPrefix2 = ipString2 + "/24";
1565 Eid srcDst = LispAddressUtil.asSrcDstEid(ipString1, ipString2, 24, 24, 0);
1566 registerAddress(LispAddressUtil.asIpv4PrefixEid(ipPrefix2));
1567 registerAddress(srcDst);
1570 MapReply reply = queryForAddress(srcDst, null);
1572 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1573 assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
1574 SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
1576 IpPrefix receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource().getIpPrefix();
1577 IpPrefix receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest().getIpPrefix();
1579 assertNotNull(receivedAddr1.getIpv4Prefix());
1580 assertNotNull(receivedAddr2.getIpv4Prefix());
1582 assertEquals(ipPrefix1, receivedAddr1.getIpv4Prefix().getValue());
1583 assertEquals(ipPrefix2, receivedAddr2.getIpv4Prefix().getValue());
1585 // srcEid/dstEid match
1586 reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "10.10.10.1");
1587 fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1588 assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
1590 Ipv4Prefix ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
1591 assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
1593 // dstEid match only
1594 reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "1.2.3.4");
1595 fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1596 assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
1598 ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
1599 assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
1603 public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1605 String ipString = "10.20.30.200";
1606 String macString = "01:02:03:04:05:06";
1607 SimpleAddress addrToSend1 = new SimpleAddress(new IpAddress(new Ipv4Address(ipString)));
1608 SimpleAddress addrToSend2 = new SimpleAddress(new MacAddress(macString));
1609 Eid kv = LispAddressUtil.asKeyValueAddressEid(addrToSend1, addrToSend2);
1611 MapReply reply = registerAddressAndQuery(kv);
1613 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1614 assertEquals(KeyValueAddressLcaf.class, fromNetwork.getAddressType());
1615 KeyValueAddress keyValueFromNetwork = (KeyValueAddress) fromNetwork.getAddress();
1617 SimpleAddress receivedAddr1 = keyValueFromNetwork.getKeyValueAddress().getKey();
1618 SimpleAddress receivedAddr2 = keyValueFromNetwork.getKeyValueAddress().getValue();
1620 assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
1621 assertNotNull(receivedAddr2.getMacAddress());
1623 Ipv4Address receivedIP = receivedAddr1.getIpAddress().getIpv4Address();
1624 MacAddress receivedMAC = receivedAddr2.getMacAddress();
1626 assertEquals(ipString, receivedIP.getValue());
1627 assertEquals(macString, receivedMAC.getValue());
1630 public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1632 String macString = "01:02:03:04:05:06";
1633 String ipString = "10.20.255.30";
1634 List<SimpleAddress> addresses = new ArrayList<SimpleAddress>();
1635 addresses.add(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1636 addresses.add(new SimpleAddress(new MacAddress(macString)));
1637 AfiListBuilder listbuilder = new AfiListBuilder();
1638 listbuilder.setAddressList(addresses);
1640 EidBuilder eb = new EidBuilder();
1641 eb.setAddressType(AfiListLcaf.class);
1642 eb.setVirtualNetworkId(null);
1643 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1644 .lisp.address.address.AfiListBuilder().setAfiList(listbuilder.build()).build());
1646 MapReply reply = registerAddressAndQuery(eb.build());
1648 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1650 assertEquals(AfiListLcaf.class, receivedAddress.getAddressType());
1652 AfiList listAddrFromNetwork = (AfiList) receivedAddress.getAddress();
1653 SimpleAddress receivedAddr1 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(0);
1654 SimpleAddress receivedAddr2 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(1);
1656 assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
1657 assertNotNull(receivedAddr2.getMacAddress());
1659 assertEquals(macString, receivedAddr2.getMacAddress().getValue());
1660 assertEquals(ipString, receivedAddr1.getIpAddress().getIpv4Address().getValue());
1663 public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1665 String ipString = "10.20.255.30";
1668 EidBuilder eb = new EidBuilder();
1669 eb.setAddressType(Ipv4PrefixAfi.class);
1670 eb.setVirtualNetworkId(new InstanceIdType((long) instanceId));
1671 eb.setAddress(new Ipv4PrefixBuilder().setIpv4Prefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
1672 .yang.ietf.inet.types.rev100924.Ipv4Prefix(ipString)).build());
1674 MapReply reply = registerAddressAndQuery(eb.build());
1676 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1677 assertEquals(Ipv4PrefixAfi.class, receivedAddress.getAddressType());
1679 assertEquals(ipString, ((Ipv4Prefix) receivedAddress.getAddress()).getIpv4Prefix().getValue());
1681 assertEquals(instanceId, receivedAddress.getVirtualNetworkId().getValue().intValue());
1684 public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1686 String macString = "01:02:03:04:05:06";
1687 String ipString = "10.20.255.30";
1688 HopBuilder hopBuilder = new HopBuilder();
1689 hopBuilder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1690 hopBuilder.setLrsBits(new LrsBits(true, false, true));
1691 Hop hop1 = hopBuilder.build();
1692 hopBuilder.setAddress(new SimpleAddress(new MacAddress(macString)));
1693 hopBuilder.setLrsBits(new LrsBits(false, true, false));
1694 Hop hop2 = hopBuilder.build();
1695 ExplicitLocatorPathBuilder elpBuilder = new ExplicitLocatorPathBuilder();
1696 elpBuilder.setHop(new ArrayList<Hop>());
1697 elpBuilder.getHop().add(hop1);
1698 elpBuilder.getHop().add(hop2);
1700 EidBuilder eb = new EidBuilder();
1701 eb.setAddressType(ExplicitLocatorPathLcaf.class);
1702 eb.setVirtualNetworkId(null);
1703 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1704 .lisp.address.address.ExplicitLocatorPathBuilder().setExplicitLocatorPath(elpBuilder.build()).build());
1706 MapReply reply = registerAddressAndQuery(eb.build());
1708 assertEquals(ExplicitLocatorPathLcaf.class, reply.getMappingRecordItem().get(0).getMappingRecord().getEid()
1711 ExplicitLocatorPath receivedAddress = (ExplicitLocatorPath) reply.getMappingRecordItem().get(0)
1712 .getMappingRecord().getEid().getAddress();
1714 Hop receivedHop1 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(0);
1715 Hop receivedHop2 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(1);
1717 assertEquals(true, receivedHop1.getLrsBits().isLookup());
1718 assertEquals(false, receivedHop1.getLrsBits().isRlocProbe());
1719 assertEquals(true, receivedHop1.getLrsBits().isStrict());
1721 assertEquals(false, receivedHop2.getLrsBits().isLookup());
1722 assertEquals(true, receivedHop2.getLrsBits().isRlocProbe());
1723 assertEquals(false, receivedHop2.getLrsBits().isStrict());
1725 assertNotNull(receivedHop1.getAddress().getIpAddress().getIpv4Address());
1726 assertNotNull(receivedHop2.getAddress().getMacAddress());
1728 assertEquals(ipString, receivedHop1.getAddress().getIpAddress().getIpv4Address().getValue());
1729 assertEquals(macString, receivedHop2.getAddress().getMacAddress().getValue());
1732 public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1734 String ipString = "1.2.3.4";
1737 int localPortLow = 3;
1738 int localPortHigh = 4;
1739 int remotePortLow = 4;
1740 int remotePortHigh = 5;
1742 ApplicationDataBuilder builder = new ApplicationDataBuilder();
1743 builder.setIpTos(ipTOs);
1744 builder.setProtocol(protocol);
1745 builder.setLocalPortLow(new PortNumber(localPortLow));
1746 builder.setLocalPortHigh(new PortNumber(localPortHigh));
1747 builder.setRemotePortLow(new PortNumber(remotePortLow));
1748 builder.setRemotePortHigh(new PortNumber(remotePortHigh));
1749 builder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1751 EidBuilder eb = new EidBuilder();
1752 eb.setAddressType(ApplicationDataLcaf.class);
1753 eb.setVirtualNetworkId(null);
1754 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1755 .lisp.address.address.ApplicationDataBuilder().setApplicationData(builder.build()).build());
1756 Eid addressToSend = eb.build();
1758 MapReply reply = registerAddressAndQuery(addressToSend);
1760 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1762 assertEquals(ApplicationDataLcaf.class, receivedAddress.getAddressType());
1764 ApplicationData receivedApplicationDataAddress = (ApplicationData) receivedAddress.getAddress();
1765 assertEquals(protocol, receivedApplicationDataAddress.getApplicationData().getProtocol().intValue());
1766 assertEquals(ipTOs, receivedApplicationDataAddress.getApplicationData().getIpTos().intValue());
1767 assertEquals(localPortLow, receivedApplicationDataAddress.getApplicationData().getLocalPortLow().getValue()
1769 assertEquals(localPortHigh, receivedApplicationDataAddress.getApplicationData().getLocalPortHigh().getValue()
1771 assertEquals(remotePortLow, receivedApplicationDataAddress.getApplicationData().getRemotePortLow().getValue()
1773 assertEquals(remotePortHigh, receivedApplicationDataAddress.getApplicationData().getRemotePortHigh().getValue()
1776 SimpleAddress ipAddressReceived = receivedApplicationDataAddress.getApplicationData().getAddress();
1777 assertEquals(ipString, ipAddressReceived.getIpAddress().getIpv4Address().getValue());
1780 // ------------------- TimeOut Tests -----------
1782 public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1784 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
1785 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1787 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1788 mapRequestBuilder.setNonce((long) 4);
1789 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
1790 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1791 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1792 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1793 mapRequestBuilder.getItrRloc().add(
1794 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1796 sendMapRequest(mapRequestBuilder.build());
1797 MapReply mapReply = receiveMapReply();
1798 assertEquals(4, mapReply.getNonce().longValue());
1799 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1801 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1802 mapRegisterbuilder.setWantMapNotify(true);
1803 mapRegisterbuilder.setNonce((long) 8);
1805 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1806 etlrBuilder.setEid(eid);
1807 etlrBuilder.setMaskLength((short) 32);
1808 etlrBuilder.setRecordTtl(254);
1810 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1811 recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1812 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1813 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1814 mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1815 mapRegisterbuilder.getMappingRecordItem().add(
1816 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1818 sendMapRegister(mapRegisterbuilder.build());
1819 MapNotify mapNotify = receiveMapNotify();
1820 assertEquals(8, mapNotify.getNonce().longValue());
1823 sendMapRequest(mapRequestBuilder.build());
1824 mapReply = receiveMapReply();
1825 assertEquals(4, mapReply.getNonce().longValue());
1826 assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1827 .getLocatorRecord().get(0).getRloc());
1829 causeEntryToBeCleaned();
1830 sendMapRequest(mapRequestBuilder.build());
1831 mapReply = receiveMapReply();
1832 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1835 public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1837 Eid eid = LispAddressUtil.asIpv6PrefixEid("1.2.3.4/32");
1838 MapRequest mapRequest = createMapRequest(eid);
1840 testTTLBeforeRegister(mapRequest);
1842 registerForTTL(eid);
1844 testTTLAfterRegister(mapRequest);
1846 causeEntryToBeCleaned();
1847 testTTLAfterClean(mapRequest);
1849 //northboundAddKey();
1850 //testTTLAfterAutherize(mapRequest);
1854 private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1856 sendMapRequest(mapRequest);
1857 mapReply = receiveMapReply();
1858 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1861 private void causeEntryToBeCleaned() {
1862 // TODO XXX for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1863 // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1864 // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1865 mapService.cleanCachedMappings();
1868 private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1870 sendMapRequest(mapRequest);
1871 mapReply = receiveMapReply();
1872 assertEquals(LispAddressUtil.asIpv4Rloc("4.3.2.1"), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1873 .getLocatorRecord().get(0).getRloc());
1874 assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1877 private void registerForTTL(Eid eid) throws SocketTimeoutException {
1878 MapRegister mapRegister = createMapRegister(eid);
1879 sendMapRegister(mapRegister);
1880 assertMapNotifyReceived();
1883 private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1885 sendMapRequest(mapRequest);
1886 mapReply = receiveMapReply();
1887 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1890 private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1892 sendMapRequest(mapRequest);
1893 mapReply = receiveMapReply();
1894 assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1897 private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1898 assertEquals(expectedTTL, mapReply.getMappingRecordItem().get(0).getMappingRecord().getRecordTtl().intValue());
1899 assertEquals(expectedAction, mapReply.getMappingRecordItem().get(0).getMappingRecord().getAction());
1902 private MapRegister createMapRegister(Eid eid, Rloc rloc) {
1903 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1904 mapRegisterbuilder.setWantMapNotify(true);
1905 mapRegisterbuilder.setNonce((long) 8);
1906 mapRegisterbuilder.setKeyId((short) 0);
1907 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1908 etlrBuilder.setEid(eid);
1909 etlrBuilder.setMaskLength((short) 24);
1910 etlrBuilder.setRecordTtl(254);
1911 etlrBuilder.setAuthoritative(false);
1912 etlrBuilder.setAction(Action.NoAction);
1913 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1914 recordBuilder.setRloc(rloc);
1915 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1916 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1917 mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1918 mapRegisterbuilder.getMappingRecordItem().add(
1919 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1920 MapRegister mapRegister = mapRegisterbuilder.build();
1924 private MapRegister createMapRegister(Eid eid) {
1925 return createMapRegister(eid, LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1928 private MapRequest createMapRequest(Eid eid) {
1929 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1930 mapRequestBuilder.setNonce((long) 4);
1931 mapRequestBuilder.setPitr(false);
1932 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
1933 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1934 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1935 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1936 mapRequestBuilder.getItrRloc().add(
1937 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1938 MapRequest mr = mapRequestBuilder.build();
1942 public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1944 String rloc = "127.0.0.3";
1945 int port = LispMessage.PORT_NUM;
1946 Rloc ipRloc = LispAddressUtil.asIpv4Rloc(rloc);
1947 sendProxyMapRequest(rloc, port, ipRloc);
1951 public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1953 String rloc = "127.0.0.3";
1956 RlocBuilder rb = new RlocBuilder();
1957 rb.setAddressType(ApplicationDataLcaf.class);
1958 rb.setVirtualNetworkId(null);
1959 rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1960 .lisp.address.address.ApplicationDataBuilder()
1961 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
1962 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
1963 Rloc adLcaf = rb.build();
1965 LOG.info("testNonProxyOtherPort:" + LispAddressStringifier.getString(adLcaf));
1966 sendProxyMapRequest(rloc, port, adLcaf);
1970 private class XtrRequestMappingListener implements OdlLispProtoListener {
1973 public void onGotMapReply(GotMapReply notification) {
1977 public void onAddMapping(AddMapping notification) {
1981 public void onXtrReplyMapping(XtrReplyMapping notification) {
1985 public void onRequestMapping(RequestMapping notification) {
1989 public void onGotMapNotify(GotMapNotify notification) {
1993 public void onXtrRequestMapping(XtrRequestMapping notification) {
1998 public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
2000 configLispPlugin.shouldListenOnXtrPort(true);
2001 notificationCalled = false;
2002 final String eid = "10.10.10.10/32";
2003 String rloc = "127.0.0.3";
2004 int port = LispMessage.XTR_PORT_NUM;
2006 RlocBuilder rb = new RlocBuilder();
2007 rb.setAddressType(ApplicationDataLcaf.class);
2008 rb.setVirtualNetworkId(null);
2009 rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2010 .lisp.address.address.ApplicationDataBuilder()
2011 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
2012 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
2013 Rloc adLcaf = rb.build();
2015 final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2016 ((LispMappingService) lms).getNotificationService().registerNotificationListener(
2017 new XtrRequestMappingListener() {
2020 public void onXtrRequestMapping(XtrRequestMapping notification) {
2021 assertEquals(((Ipv4Prefix) mapRequest.getEidItem().get(0).getEid().getAddress())
2022 .getIpv4Prefix().getValue(), eid);
2023 notificationCalled = true;
2024 LOG.warn("notification arrived");
2027 sendMapRequest(mapRequest, port);
2028 for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
2029 if (notificationCalled) {
2032 LOG.warn("notification hasn't arrived, sleeping...");
2037 fail("Notification hasn't arrived");
2041 private void sendProxyMapRequest(String rloc, int port, Rloc adLcaf) throws SocketTimeoutException,
2043 String eid = "10.1.0.1/32";
2044 MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2045 sendMapRequest(mapRequest);
2046 DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
2047 MapRequest receivedMapRequest = receiveMapRequest(nonProxySocket);
2048 assertEquals(mapRequest.getNonce(), receivedMapRequest.getNonce());
2049 assertEquals(mapRequest.getSourceEid(), receivedMapRequest.getSourceEid());
2050 assertEquals(mapRequest.getItrRloc(), receivedMapRequest.getItrRloc());
2051 assertEquals(mapRequest.getEidItem(), receivedMapRequest.getEidItem());
2052 nonProxySocket.close();
2055 private MapRequest createNonProxyMapRequest(String eid, Rloc adLcaf) throws SocketTimeoutException {
2056 MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixEid(eid));
2057 LocatorRecord record = new LocatorRecordBuilder(mr.getMappingRecordItem().get(0).getMappingRecord()
2058 .getLocatorRecord().get(0)).setRloc(adLcaf).build();
2059 mr.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().set(0, record);
2060 sendMapRegister(mr);
2061 assertMapNotifyReceived();
2062 MapRequest mapRequest = createMapRequest(LispAddressUtil.asIpv4PrefixEid(eid));
2063 MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
2064 builder.setPitr(true);
2065 mapRequest = builder.build();
2069 private void assertMapNotifyReceived() throws SocketTimeoutException {
2073 private MapReply receiveMapReply() throws SocketTimeoutException {
2074 return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2077 private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
2078 return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(
2079 datagramSocket, 30000).getData()));
2082 private MapNotify receiveMapNotify() throws SocketTimeoutException {
2083 return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2086 private void sendMapRequest(MapRequest mapRequest) {
2087 sendMapRequest(mapRequest, LispMessage.PORT_NUM);
2090 private void sendMapRequest(MapRequest mapRequest, int port) {
2091 sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
2094 private void sendMapRegister(MapRegister mapRegister) {
2095 sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
2098 private void sendPacket(byte[] bytesToSend) {
2099 sendPacket(bytesToSend, LispMessage.PORT_NUM);
2102 private void sendPacket(byte[] bytesToSend, int port) {
2104 DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
2105 initPacketAddress(packet, port);
2106 LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
2107 socket.send(packet);
2108 } catch (Throwable t) {
2113 private DatagramPacket receivePacket() throws SocketTimeoutException {
2114 return receivePacket(6000);
2117 private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
2118 return receivePacket(socket, timeout);
2121 private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
2123 byte[] buffer = new byte[4096];
2124 DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
2125 LOG.trace("Waiting for packet from socket...");
2126 receivedSocket.setSoTimeout(timeout);
2127 receivedSocket.receive(receivePacket);
2128 LOG.trace("Received packet from socket!");
2129 return receivePacket;
2130 } catch (SocketTimeoutException ste) {
2132 } catch (Throwable t) {
2138 private void sleepForSeconds(int seconds) {
2140 Thread.sleep(seconds*1000);
2141 } catch (InterruptedException e) {
2142 LOG.warn("Interrupted while sleeping", e);
2146 private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
2147 packet.setAddress(InetAddress.getByName(lispBindAddress));
2148 packet.setPort(port);
2151 private DatagramSocket initSocket(DatagramSocket socket, int port) {
2153 socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
2154 } catch (SocketException e) {
2155 e.printStackTrace();
2161 private byte[] extractWSUdpByteArray(String wiresharkHex) {
2162 final int HEADER_LEN = 42;
2163 byte[] res = new byte[1000];
2164 String[] split = wiresharkHex.split(" ");
2166 for (String cur : split) {
2168 if (cur.length() == 2) {
2170 if (counter > HEADER_LEN) {
2171 res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
2176 return Arrays.copyOf(res, counter - HEADER_LEN);
2179 private String stateToString(int state) {
2183 case Bundle.INSTALLED:
2185 case Bundle.RESOLVED:
2187 case Bundle.UNINSTALLED:
2188 return "UNINSTALLED";
2190 return "Not CONVERTED";
2194 private void areWeReady() throws InvalidSyntaxException {
2198 boolean debugit = false;
2199 Bundle b[] = bc.getBundles();
2200 for (Bundle element : b) {
2201 int state = element.getState();
2202 LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v"
2203 + element.getVersion() + ", state:" + stateToString(state));
2204 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
2205 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
2208 // String host = element.getHeaders().get("FRAGMENT-HOST");
2209 // if (host != null) {
2210 // LOG.warn("Bundle " + element.getSymbolicName() +
2211 // " is a fragment which is part of: " + host);
2212 // LOG.warn("Required imports are: " +
2213 // element.getHeaders().get("IMPORT-PACKAGE"));
2217 // } catch (BundleException e) {
2218 // LOG.error("BundleException:", e);
2227 LOG.warn(("Do some debugging because some bundle is unresolved"));
2229 // assertNotNull(broker);
2231 configLispPlugin.setLispAddress(lispBindAddress);
2233 // Uncomment this code to Know which services were actually loaded to
2237 for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
2238 LOG.info(sr.getBundle().getSymbolicName());
2239 LOG.info(sr.toString());
2246 private void cleanUP() {
2248 mapService.cleanCachedMappings();
2249 configLispPlugin.shouldListenOnXtrPort(false);
2250 socket = initSocket(socket, LispMessage.PORT_NUM);
2254 private void restartSocket() {
2256 socket = initSocket(socket, LispMessage.PORT_NUM);