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.interfaces.lisp.IFlowMapping;
59 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
60 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
61 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
62 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
63 import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
64 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
65 import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
66 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
67 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MappingKeepAlive;
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 private static final int MAX_NOTIFICATION_RETRYS = 20;
158 private static final MappingAuthkey NULL_AUTH_KEY = new MappingAuthkeyBuilder().setKeyType(0).build();
159 private static final MappingAuthkey AUTH_KEY =
160 new MappingAuthkeyBuilder().setKeyType(1).setKeyString("password").build();
163 public String getModuleName() {
164 return "mappingservice-impl";
168 public String getInstanceName() {
169 return "mappingservice-default";
172 // This is temporary, since the properties in the pom file are not picked up
174 public String getKarafDistro() {
176 .groupId("org.opendaylight.lispflowmapping")
177 .artifactId("distribution-karaf")
178 .versionAsInProject()
184 public MavenUrlReference getFeatureRepo() {
186 .groupId("org.opendaylight.lispflowmapping")
187 .artifactId("features-lispflowmapping")
188 .classifier("features")
190 .versionAsInProject();
194 public String getFeatureName() {
195 return "odl-lispflowmapping-msmr";
199 public Option getLoggingOption() {
200 Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
201 "log4j.logger.org.opendaylight.lispflowmapping",
202 LogLevel.DEBUG.name());
203 option = composite(option, super.getLoggingOption());
208 public void testLispFlowMappingFeatureLoad() {
209 Assert.assertTrue(true);
213 public void after() {
214 if (socket != null) {
217 // if (connection != null) {
218 // connection.disconnect();
223 public void before() throws Exception {
225 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_FIRST);
226 mapService.setMappingOverwrite(true);
228 locatorEid = LispAddressUtil.asIpv4Rloc("4.3.2.1");
229 socket = initSocket(socket, LispMessage.PORT_NUM);
231 // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
232 // LISP(Type = 8 - Encapsulated)
233 // IP: 192.168.136.10 -> 153.16.254.1
235 // LISP(Type = 1 Map-Request
239 // Source EID 1.2.3.4
240 // Nonce: 0x3d8d2acd39c8d608
241 // ITR-RLOC AFI=1 Address=192.168.136.10
242 // Record 1: 153.16.254.1/32
243 mapRequestPacket = extractWSUdpByteArray(new String("0000 00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
244 + "0010 00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
245 + "0020 00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
246 + "0030 00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
247 + "0040 fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
248 + "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
249 + "0060 00 01 99 10 fe 01"));
251 // IP: 192.168.136.10 -> 128.223.156.35
252 // UDP: 49289 -> 4342
253 // LISP(Type = 3 Map-Register, P=1, M=1
257 // AuthDataLength: 20 Data:
258 // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
259 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
261 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
262 // Priority/Weight: 1/100, Multicast Priority/Weight:
266 mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String(
267 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
268 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
269 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
270 + "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
271 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
272 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
273 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
275 // IP: 192.168.136.10 -> 128.223.156.35
276 // UDP: 49289 -> 4342
277 // LISP(Type = 3 Map-Register, P=1, M=1
280 // Key ID: 0x0000 NO AUTHENTICATION!!
281 // AuthDataLength: 00 Data:
282 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
284 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
285 // Priority/Weight: 1/100, Multicast Priority/Weight:
289 mapRegisterPacketWithNotify = extractWSUdpByteArray(new String(
290 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
291 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
292 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
293 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
294 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
295 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
296 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
298 // IP: 192.168.136.10 -> 128.223.156.35
299 // UDP: 49289 -> 4342
300 // LISP(Type = 3 Map-Register, P=1, M=1
303 // Key ID: 0x0000 NO AUTHENTICATION!!
304 // AuthDataLength: 00 Data:
305 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
307 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
308 // Priority/Weight: 1/100, Multicast Priority/Weight:
312 mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String(
313 "0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
314 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
315 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
316 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
317 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
318 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
319 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
323 private BundleContext bc;
324 //private HttpURLConnection connection;
325 protected static boolean notificationCalled;
327 @Inject @Filter(timeout=60000)
328 private IFlowMapping lms;
330 @Inject @Filter(timeout=60000)
331 private IMappingService mapService;
333 @Inject @Filter(timeout=10000)
334 private IConfigLispSouthboundPlugin configLispPlugin;
337 public void testSimpleUsage() throws Exception {
339 mapRegisterWithMapNotify();
340 mapRegisterWithMapNotifyAndMapRequest();
341 registerAndQuery__MAC();
342 mapRequestMapRegisterAndMapRequest();
343 mapRegisterWithAuthenticationWithoutConfiguringAKey();
344 mapRegisterWithoutMapNotify();
348 public void testLCAFs() throws Exception {
349 //registerAndQuery__SrcDestLCAF();
350 //registerAndQuery__SrcDestLCAFOverlap();
351 //registerAndQuery__KeyValueLCAF();
352 //registerAndQuery__ListLCAF();
353 //registerAndQuery__ApplicationData();
354 //registerAndQuery__TrafficEngineering();
355 //registerAndQuery__SegmentLCAF();
359 public void testMask() throws Exception {
360 //testPasswordExactMatch(); TODO commented because it needs NB
361 //testPasswordMaskMatch(); TODO commented because it needs NB
362 eidPrefixLookupIPv4();
363 eidPrefixLookupIPv6();
367 public void testNorthbound() throws Exception {
369 northboundAddMapping();
370 northboundDeleteMapping();
371 northboundRetrieveKey();
372 northboundRetrieveMapping();
373 northboundRetrieveSourceDestKey();
374 northboundRetrieveSourceDestMapping();
378 public void testOverWriting() throws Exception {
379 //testMapRegisterDosntOverwritesOtherSubKeys(); TODO weird failure, needs debug
381 // TODO: remove, we don't support overwrite flag any longer and RLOCs are not saved as independent RLOC groups
382 // testMapRegisterOverwritesSameSubkey();
383 // testMapRegisterOverwritesNoSubkey();
384 // testMapRegisterDoesntOverwritesNoSubkey();
388 public void testTimeOuts() throws Exception {
389 mapRequestMapRegisterAndMapRequestTestTimeout();
390 //mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse(); TODO commented because it needs NB
394 // public void testNonProxy() throws Throwable {
395 // testSimpleNonProxy();
396 // testNonProxyOtherPort();
397 // testRecievingNonProxyOnXtrPort();
401 public void testSmr() throws Exception {
402 registerQueryRegisterWithSmr();
410 public void testMultiSiteScenarioA() throws IOException {
413 final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
414 multiSiteScenario.setCommonAuthentication();
417 final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
420 multiSiteScenario.storeSouthboundMappings(false, SITE_A, SITE_B, SITE_C, SITE_D4, SITE_D5);
421 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
422 multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
424 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
425 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
426 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
429 //following action should trigger generatting of SMR messages:
432 multiSiteScenario.storeNorthMappingSrcDst(SITE_A, SITE_C);
434 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1));
435 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
436 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
437 multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
440 // following action should trigger generatting of SMR messages:
445 multiSiteScenario.deleteNorthMappingNegative(SITE_C);
447 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B.getHost(5), SITE_A.getHost(1), SITE_A
450 multiSiteScenario.assertPingWorks(SITE_D4, 5, SITE_C, 4);
453 // following action should trigger generatting of SMR messages:
455 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C_RLOC_10);
457 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5));
458 //way of testing ping - get RLOC for mapping src-dst and compare it with awaited value doesn't test
459 //that ping won't be successfull
460 multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
463 // following action should trigger generatting of SMR messages:
466 multiSiteScenario.storeNorthMappingNegative(SITE_C, Action.Drop);
468 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D4.getHost(5), SITE_B.getHost(5));
469 multiSiteScenario.assertPingFails(SITE_D4, 5, SITE_C, 4);
472 multiSiteScenario.assertPingFails(SITE_D5, 5, SITE_C, 3);
475 multiSiteScenario.deleteNorthMapingSrcDst(SITE_A, SITE_C);
477 // following action should trigger generatting of SMR messages:
481 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
484 // following action should trigger generatting of SMR messages:
488 multiSiteScenario.storeNorthMappingSrcDst(SITE_B, SITE_C);
490 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
493 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
494 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
495 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
498 // following action should trigger generatting of SMR messages:
503 multiSiteScenario.deleteNorthMapingSrcDst(SITE_B, SITE_C);
505 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
508 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
509 multiSiteScenario.assertPingFails(SITE_B, 5, SITE_C, 4);
510 multiSiteScenario.assertPingFails(SITE_A, 1, SITE_C, 4);
513 // following action should trigger generatting of SMR messages:
518 multiSiteScenario.deleteNorthMappingNegative(SITE_C);
520 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_D5.getHost(5), SITE_D4.getHost(5),
523 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_B, 4);
524 multiSiteScenario.assertPingWorks(SITE_B, 5, SITE_C, 4);
525 multiSiteScenario.assertPingWorks(SITE_A, 5, SITE_C, 4);
527 socketReader.stopReading();
535 public void testMultiSiteScenarioB() throws IOException {
538 final MultiSiteScenario multiSiteScenario = new MultiSiteScenario(mapService, lms);
539 multiSiteScenario.setCommonAuthentication();
542 final SocketReader socketReader = SocketReader.startReadingInStandaloneThread(socket);
544 mapService.setLookupPolicy(IMappingService.LookupPolicy.NB_AND_SB);
545 mapService.setMappingOverwrite(false);
548 multiSiteScenario.storeSouthboundMappings(true, SITE_A_SB, SITE_B_SB, SITE_C_WP_100_1_SB, SITE_D_WP_100_1_SB,
550 multiSiteScenario.storeNorthMappingIpPrefix(SITE_A_SB);
551 multiSiteScenario.storeNorthMappingIpPrefix(SITE_B_SB);
552 multiSiteScenario.storeNorthMappingIpPrefix(SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
554 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
555 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
558 // following action should trigger generatting of SMR messages:
561 multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
563 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
565 // following action should trigger generatting of SMR messages:
568 multiSiteScenario.storeNorthMappingNegative(SITE_C_SB, Action.Drop);
570 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
572 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
573 multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_SB, 4);
577 // following action should trigger generatting of SMR messages:
580 multiSiteScenario.storeNorthMappingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
582 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
583 multiSiteScenario.assertPingWorks(SITE_A_SB, 5, SITE_C_WP_50_2_SB, 4);
586 multiSiteScenario.storeNorthMappingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB, SITE_D_WP_50_2_SB);
588 // following action should trigger generatting of SMR messages:
591 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
592 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4, SITE_D_WP_50_2_SB);
595 multiSiteScenario.deleteSouthboundMappings(SITE_D_DELETE_SB);
597 // following action should trigger generatting of SMR messages:
600 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
602 multiSiteScenario.assertPingWorks(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
605 multiSiteScenario.deleteNorthMapingSrcDst(SITE_A_SB, SITE_C_WP_50_2_SB);
607 // following action should trigger generatting of SMR messages:
610 multiSiteScenario.checkSMR(socketReader, SITE_C.getEidPrefix(), SITE_B_SB.getHost(5), SITE_A_SB.getHost(5));
612 multiSiteScenario.deleteNorthMapingSrcDst(SITE_B_SB, SITE_C_WP_50_2_SB);
614 multiSiteScenario.assertPingFails(SITE_B_SB, 5, SITE_C_WP_50_2_SB, 4);
616 socketReader.stopReading();
620 // ------------------------------- Simple Tests ---------------------------
622 public void mapRequestSimple() throws SocketTimeoutException {
625 // This Map-Request is sent from a source port different from 4342
626 // We close and bind the socket on the correct port
627 if (socket != null) {
630 socket = initSocket(socket, 56756);
632 sendPacket(mapRequestPacket);
633 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
634 MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
635 assertEquals(4435248268955932168L, reply.getNonce().longValue());
639 public void mapRegisterWithMapNotify() throws SocketTimeoutException {
641 mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), NULL_AUTH_KEY);
643 sendPacket(mapRegisterPacketWithNotify);
644 MapNotify reply = receiveMapNotify();
645 assertEquals(7, reply.getNonce().longValue());
648 public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
650 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
652 MapReply mapReply = registerAddressAndQuery(eid);
654 assertEquals(4, mapReply.getNonce().longValue());
655 assertEquals(locatorEid, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
660 public void registerAndQuery__MAC() throws SocketTimeoutException {
662 String macAddress = "01:02:03:04:05:06";
664 MapReply reply = registerAddressAndQuery(LispAddressUtil.asMacEid(macAddress));
667 Eid addressFromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
668 assertEquals(MacAfi.class, addressFromNetwork.getAddressType());
669 String macAddressFromReply = ((Mac) addressFromNetwork.getAddress()).getMac().getValue();
671 assertEquals(macAddress, macAddressFromReply);
674 public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
676 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
677 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
680 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
681 mapRequestBuilder.setNonce((long) 4);
682 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
683 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
684 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
685 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
686 mapRequestBuilder.getItrRloc().add(
687 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
688 sendMapRequest(mapRequestBuilder.build());
689 MapReply mapReply = receiveMapReply();
690 assertEquals(4, mapReply.getNonce().longValue());
691 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
692 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
693 mapRegisterbuilder.setWantMapNotify(true);
694 mapRegisterbuilder.setNonce((long) 8);
695 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
696 etlrBuilder.setEid(eid);
697 etlrBuilder.setRecordTtl(254);
698 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
699 recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
700 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
701 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
702 mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
703 mapRegisterbuilder.getMappingRecordItem().add(
704 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
705 sendMapRegister(mapRegisterbuilder.build());
706 MapNotify mapNotify = receiveMapNotify();
707 assertEquals(8, mapNotify.getNonce().longValue());
709 sendMapRequest(mapRequestBuilder.build());
710 mapReply = receiveMapReply();
711 assertEquals(4, mapReply.getNonce().longValue());
712 assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
713 .getLocatorRecord().get(0).getRloc());
717 public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
719 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
720 SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
721 Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
722 SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
723 Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
724 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
725 assertEquals(2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
726 assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
728 assertEquals(rloc1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(1)
732 public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
734 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
735 SimpleAddress rloc1Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.1")));
736 Rloc rloc1 = LispAddressUtil.asKeyValueAddress("subkey1", rloc1Value);
737 SimpleAddress rloc2Value = new SimpleAddress(new IpAddress(new Ipv4Address("4.3.2.2")));
738 Rloc rloc2 = LispAddressUtil.asKeyValueAddress("subkey2", rloc2Value);
739 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
740 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
741 assertEquals(rloc2, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
745 public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
747 mapService.setMappingOverwrite(true);
748 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
749 Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
750 Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
751 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
752 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
753 assertEquals(rloc2Value, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
757 public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
759 mapService.setMappingOverwrite(false);
760 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
761 Rloc rloc1Value = LispAddressUtil.asIpv4Rloc("4.3.2.1");
762 Rloc rloc2Value = LispAddressUtil.asIpv4Rloc("4.3.2.2");
763 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
764 assertEquals(1, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
765 Rloc rloc1ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
767 Rloc rloc2ReturnValueContainer = mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
769 assertTrue((rloc1Value.equals(rloc1ReturnValueContainer) && rloc2Value.equals(rloc2ReturnValueContainer))
770 || (rloc1Value.equals(rloc2ReturnValueContainer) && rloc2Value.equals(rloc1ReturnValueContainer)));
773 private MapReply sendMapRegisterTwiceWithDiffrentValues(Eid eid, Rloc rloc1, Rloc rloc2)
774 throws SocketTimeoutException {
775 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
777 MapRegister mb = createMapRegister(eid, rloc1);
778 MapNotify mapNotify = lms.handleMapRegister(mb).getLeft();
779 MapRequest mr = createMapRequest(eid);
780 MapReply mapReply = lms.handleMapRequest(mr);
781 assertEquals(mb.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc(),
782 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0).getRloc());
783 mb = createMapRegister(eid, rloc2);
784 mapNotify = lms.handleMapRegister(mb).getLeft();
785 assertEquals(8, mapNotify.getNonce().longValue());
786 mr = createMapRequest(eid);
788 mapReply = lms.handleMapRequest(mr);
792 public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
794 sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
797 // If didn't timeout then fail:
799 } catch (SocketTimeoutException ste) {
803 public void mapRegisterWithoutMapNotify() {
805 sendPacket(mapRegisterPacketWithoutNotify);
808 // If didn't timeout then fail:
810 } catch (SocketTimeoutException ste) {
814 public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
816 lms.setShouldUseSmr(true);
817 mapService.addAuthenticationKey(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), NULL_AUTH_KEY);
820 sendPacket(mapRegisterPacketWithNotify);
824 sendPacket(mapRequestPacket);
827 mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
828 sendPacket(mapRegisterPacketWithoutNotify);
830 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
831 MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
832 assertTrue(smr.isSmr());
833 Eid sourceEid = smr.getSourceEid().getEid();
834 assertTrue(LispAddressUtil.asIpv4Eid("153.16.254.1").equals(sourceEid));
835 Eid smrEid = smr.getEidItem().get(0).getEid();
836 assertTrue(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32").equals(smrEid));
839 // --------------------- Northbound Tests ---------------------------
841 private void northboundAddKey() throws Exception {
843 LispIpv4Address address = LispAddressUtil.asIPAfiAddress("1.2.3.4");
845 String pass = "asdf";
847 URL url = createPutURL("key");
848 String authKeyJSON = createAuthKeyJSON(pass, address, mask);
849 callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
851 String retrievedKey = lms.getAuthenticationKey(LispAddressUtil.toContainer(address), mask);
853 // Check stored password matches the one sent
854 assertEquals(pass, retrievedKey);
858 private void northboundRetrieveSourceDestKey() throws Exception {
860 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
861 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
862 .primitiveaddress.Ipv4) LispAddressUtil
863 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
864 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
865 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
866 .primitiveaddress.Ipv4) LispAddressUtil
867 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
870 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
871 AddressFamilyNumberEnum.LCAF.getIanaCode())
872 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
873 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build())
874 .setSrcMaskLength((short) mask1)
875 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build())
876 .setDstMaskLength((short) mask2).build();
877 String pass = "asdf";
879 lms.addAuthenticationKey(LispAddressUtil.toContainer(sourceDestAddress), mask1, pass);
881 // URL url = createGetKeyIPv4URL(address1, mask1);
882 URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
883 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getSrcAddress()
884 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
885 ((LispIpv4Address) LispAddressUtil.toAFIfromPrimitive(sourceDestAddress.getDstAddress()
886 .getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
887 String reply = callURL("GET", null, "application/json", null, url);
888 JSONTokener jt = new JSONTokener(reply);
889 JSONObject json = new JSONObject(jt);
891 // test that the password matches what was we expected.
892 assertEquals(pass, json.get("key"));
896 private void northboundRetrieveKey() throws Exception {
898 LispIpv4Address address = LispAddressUtil.asIPAfiAddress("10.0.0.1");
900 String pass = "asdf";
902 lms.addAuthenticationKey(LispAddressUtil.toContainer(address), mask, pass);
904 URL url = createGetKeyIPv4URL(address, mask);
905 String reply = callURL("GET", null, "application/json", null, url);
906 JSONTokener jt = new JSONTokener(reply);
907 JSONObject json = new JSONObject(jt);
909 // test that the password matches what was we expected.
910 assertEquals(pass, json.get("key"));
914 private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
915 return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
916 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
919 private void northboundAddMapping() throws Exception {
921 String pass = "asdf";
922 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
924 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
926 // NB add mapping always checks the key
927 lms.addAuthenticationKey(LispAddressUtil.toContainer(eid), mask, pass);
929 URL url = createPutURL("mapping");
930 String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
931 callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
933 // Retrieve the RLOC from the database
934 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
935 mapRequestBuilder.setPitr(false);
936 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
937 mapRequestBuilder.getEidItem().add(
938 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(
939 LispAddressUtil.toContainer(eid)).build());
940 MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
942 LispIpv4Address retrievedRloc = (LispIpv4Address) LispAddressUtil.toAFI(
943 mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
944 .getLispAddressContainer());
946 assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
950 private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
951 String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ "
952 + "\"proxyMapReply\" : false, "
953 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : "
954 + "{ " + "\"ipAddress\" : \""
955 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "},"
956 + "\"mapVersion\" : 0,"
957 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ "
958 + "\"multicastPriority\" : 1,"
959 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\","
961 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50,"
962 + "\"rlocProbed\" : false, "
963 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], "
964 + "\"recordTtl\" : 100" + "} " + "], "
965 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
970 private void northboundRetrieveMapping() throws Exception {
972 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
974 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
975 // Insert mapping in the database
976 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
977 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
978 etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
979 etlr.setMaskLength((short) mask);
980 etlr.setRecordTtl(254);
981 etlr.setAuthoritative(false);
982 etlr.setAction(Action.NoAction);
983 LocatorRecordBuilder record = new LocatorRecordBuilder();
984 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
985 record.setRouted(true);
986 record.setRlocProbed(false);
987 record.setLocalLocator(false);
988 record.setPriority((short) 1);
989 record.setWeight((short) 50);
990 record.setMulticastPriority((short) 1);
991 record.setMulticastWeight((short) 1);
992 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
993 etlr.getLocatorRecord().add(record.build());
994 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
995 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
996 lms.handleMapRegister(mapRegister.build());
998 // Get mapping using NB interface. No IID used
999 URL url = createGetMappingIPv4URL(0, eid, mask);
1000 String reply = callURL("GET", null, "application/json", null, url);
1001 JSONTokener jt = new JSONTokener(reply);
1002 JSONObject json = new JSONObject(jt);
1004 // With just one locator, locators is not a JSONArray
1005 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
1006 .getString("ipAddress");
1008 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
1012 private void northboundDeleteMapping() throws Exception {
1014 LispIpv4Address eid = LispAddressUtil.asIPAfiAddress("10.0.0.1");
1016 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1017 // Insert mapping in the database
1018 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1019 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1020 etlr.setLispAddressContainer(LispAddressUtil.toContainer(eid));
1021 etlr.setMaskLength((short) mask);
1022 etlr.setRecordTtl(254);
1023 etlr.setAuthoritative(false);
1024 etlr.setAction(Action.NoAction);
1025 LocatorRecordBuilder record = new LocatorRecordBuilder();
1026 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
1027 record.setRouted(true);
1028 record.setRlocProbed(false);
1029 record.setLocalLocator(false);
1030 record.setPriority((short) 1);
1031 record.setWeight((short) 50);
1032 record.setMulticastPriority((short) 1);
1033 record.setMulticastWeight((short) 1);
1034 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1035 etlr.getLocatorRecord().add(record.build());
1036 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1037 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1038 lms.handleMapRegister(mapRegister.build());
1040 // Delete mapping using NB interface. No IID used
1041 URL url = createDeleteMappingIPv4URL(0, eid, mask);
1042 String reply = callURL("DELETE", null, "application/json", null, url);
1044 // Get mapping using NB interface. No IID used
1045 url = createGetMappingIPv4URL(0, eid, mask);
1046 reply = callURL("GET", null, "application/json", null, url);
1047 JSONTokener jt = new JSONTokener(reply);
1048 JSONObject json = new JSONObject(jt);
1050 // With just one locator, locators is not a JSONArray
1051 assertEquals(json.getJSONArray("locators").length(), 0);
1054 private void northboundRetrieveSourceDestMapping() throws Exception {
1056 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1057 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1058 .primitiveaddress.Ipv4) LispAddressUtil
1059 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.1"));
1060 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispsimpleaddress.primitiveaddress.Ipv4
1061 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress
1062 .primitiveaddress.Ipv4) LispAddressUtil
1063 .toPrimitive(LispAddressUtil.asIPAfiAddress("10.0.0.2"));
1066 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(
1067 AddressFamilyNumberEnum.LCAF.getIanaCode())
1068 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
1069 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(
1070 address1).build()).setSrcMaskLength((short) mask1)
1071 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(
1072 address2).build()).setDstMaskLength((short) mask2).build();
1073 LispIpv4Address rloc = LispAddressUtil.asIPAfiAddress("20.0.0.2");
1075 // Insert mapping in the database
1076 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1077 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1078 etlr.setLispAddressContainer(LispAddressUtil.toContainer(sourceDestAddress));
1079 etlr.setMaskLength((short) mask1);
1080 etlr.setRecordTtl(254);
1081 etlr.setAuthoritative(false);
1082 etlr.setAction(Action.NoAction);
1083 LocatorRecordBuilder record = new LocatorRecordBuilder();
1084 record.setLispAddressContainer(LispAddressUtil.toContainer(rloc));
1085 record.setRouted(true);
1086 record.setRlocProbed(false);
1087 record.setLocalLocator(false);
1088 record.setPriority((short) 1);
1089 record.setWeight((short) 50);
1090 record.setMulticastPriority((short) 1);
1091 record.setMulticastWeight((short) 1);
1092 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1093 etlr.getLocatorRecord().add(record.build());
1094 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1095 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1096 lms.handleMapRegister(mapRegister.build());
1098 // Get mapping using NB interface. No IID used
1099 URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
1100 address1.getIpv4Address().getIpv4Address().getValue(),
1102 address2.getIpv4Address().getIpv4Address().getValue(),
1104 String reply = callURL("GET", null, "application/json", null, url);
1105 JSONTokener jt = new JSONTokener(reply);
1106 JSONObject json = new JSONObject(jt);
1108 // With just one locator, locators is not a JSONArray
1109 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric")
1110 .getString("ipAddress");
1112 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
1116 private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
1117 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key",
1118 address.getAfi().shortValue(),
1119 address.getIpv4Address().getValue(), mask);
1120 URL url = new URL(restUrl);
1124 private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
1125 throws MalformedURLException {
1126 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
1127 "key", afi, srcAddress, srcMask,
1128 dstAddress, dstMask);
1129 URL url = new URL(restUrl);
1133 private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask)
1134 throws MalformedURLException {
1135 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d",
1136 "mapping", afi, srcAddress,
1137 srcMask, dstAddress, dstMask);
1138 URL url = new URL(restUrl);
1142 private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
1143 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
1144 iid, address.getAfi()
1145 .shortValue(), address.getIpv4Address().getValue(), mask);
1146 URL url = new URL(restUrl);
1150 private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
1151 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping",
1152 iid, address.getAfi()
1153 .shortValue(), address.getIpv4Address().getValue(), mask);
1154 URL url = new URL(restUrl);
1158 private URL createPutURL(String resource) throws MalformedURLException {
1160 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
1162 URL url = new URL(restUrl);
1166 private String createAuthenticationString() {
1167 String authString = "admin:admin";
1168 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
1169 String authStringEnc = new String(authEncBytes);
1170 return authStringEnc;
1173 private String callURL(String method, String content, String accept, String body, URL url) throws IOException,
1175 String authStringEnc = createAuthenticationString();
1176 connection = (HttpURLConnection) url.openConnection();
1177 connection.setRequestMethod(method);
1178 connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
1179 if (content != null) {
1180 connection.setRequestProperty("Content-Type", content);
1182 if (accept != null) {
1183 connection.setRequestProperty("Accept", accept);
1186 // now add the request body
1187 connection.setDoOutput(true);
1188 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
1192 connection.connect();
1194 // getting the result, first check response code
1195 Integer httpResponseCode = connection.getResponseCode();
1197 if (httpResponseCode > 299) {
1198 LOG.trace("HTTP Address: " + url);
1199 LOG.trace("HTTP Response Code: " + httpResponseCode);
1203 InputStream is = connection.getInputStream();
1204 BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
1205 StringBuilder sb = new StringBuilder();
1207 while ((cp = rd.read()) != -1) {
1208 sb.append((char) cp);
1211 connection.disconnect();
1212 return (sb.toString());
1215 // timePeriod - in ms
1216 public void assertNoPacketReceived(int timePeriod) {
1218 receivePacket(timePeriod);
1219 // If didn't timeout then fail:
1221 } catch (SocketTimeoutException ste) {
1225 // ------------------------------- Mask Tests ---------------------------
1227 public void eidPrefixLookupIPv4() throws SocketTimeoutException {
1229 runPrefixTest(LispAddressUtil.asIpv4PrefixEid("1.2.3.4/16"), LispAddressUtil.asIpv4PrefixEid("1.2.3.2/32"),
1230 LispAddressUtil.asIpv4PrefixEid("1.1.1.1/32"));
1233 public void eidPrefixLookupIPv6() throws SocketTimeoutException {
1235 runPrefixTest(LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:6:7:8/64"),
1236 LispAddressUtil.asIpv6PrefixEid("1:2:3:4:5:1:2:3/128"),
1237 LispAddressUtil.asIpv6PrefixEid("1:2:3:1:2:3:1:2/128"));
1240 private void runPrefixTest(Eid registerEID, Eid matchedAddress, Eid unMatchedAddress)
1241 throws SocketTimeoutException {
1242 mapService.addAuthenticationKey(registerEID, NULL_AUTH_KEY);
1245 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1246 mapRegister.setWantMapNotify(true);
1247 mapRegister.setNonce((long) 8);
1248 mapRegister.setWantMapNotify(true);
1249 mapRegister.setKeyId((short) 0);
1250 mapRegister.setAuthenticationData(new byte[0]);
1251 mapRegister.setNonce((long) 8);
1252 mapRegister.setProxyMapReply(false);
1253 MappingRecordBuilder etlr = new MappingRecordBuilder();
1254 etlr.setRecordTtl(254);
1255 etlr.setAction(Action.NoAction);
1256 etlr.setAuthoritative(false);
1257 etlr.setMapVersion((short) 0);
1258 etlr.setEid(registerEID);
1259 etlr.setRecordTtl(254);
1260 LocatorRecordBuilder record = new LocatorRecordBuilder();
1261 record.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1262 record.setLocalLocator(false);
1263 record.setRlocProbed(false);
1264 record.setRouted(true);
1265 record.setMulticastPriority((short) 0);
1266 record.setMulticastWeight((short) 0);
1267 record.setPriority((short) 0);
1268 record.setWeight((short) 0);
1269 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1270 etlr.getLocatorRecord().add(record.build());
1271 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1272 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1273 sendMapRegister(mapRegister.build());
1274 MapNotify mapNotify = receiveMapNotify();
1275 assertEquals(8, mapNotify.getNonce().longValue());
1277 MapRequestBuilder mapRequest = new MapRequestBuilder();
1278 mapRequest.setNonce((long) 4);
1279 mapRequest.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
1280 mapRequest.setEidItem(new ArrayList<EidItem>());
1281 mapRequest.setAuthoritative(false);
1282 mapRequest.setMapDataPresent(false);
1283 mapRequest.setPitr(false);
1284 mapRequest.setProbe(false);
1285 mapRequest.setSmr(false);
1286 mapRequest.setSmrInvoked(false);
1287 mapRequest.getEidItem().add(new EidItemBuilder().setEid(matchedAddress).build());
1288 mapRequest.setItrRloc(new ArrayList<ItrRloc>());
1289 mapRequest.getItrRloc().add(
1290 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1291 sendMapRequest(mapRequest.build());
1292 MapReply mapReply = receiveMapReply();
1293 assertEquals(4, mapReply.getNonce().longValue());
1294 assertEquals(record.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord()
1296 mapRequest.setEidItem(new ArrayList<EidItem>());
1297 mapRequest.getEidItem().add(new EidItemBuilder().setEid(unMatchedAddress).build());
1298 sendMapRequest(mapRequest.build());
1299 mapReply = receiveMapReply();
1300 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1303 // This registers an IP with a MapRegister, then adds a password via the
1304 // northbound REST API
1305 // and checks that the password works
1306 public void testPasswordExactMatch() throws Exception {
1308 String ipString = "10.0.0.1";
1309 LispIpv4Address address = LispAddressUtil.asIPAfiAddress(ipString);
1311 String pass = "pass";
1313 URL url = createPutURL("key");
1315 String jsonAuthData = createAuthKeyJSON(pass, address, mask);
1317 LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
1318 LOG.trace("Address: " + address);
1320 byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232,
1321 (byte) 31, (byte) 249, (byte) 87,
1322 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53,
1323 (byte) 196, (byte) 62 };
1325 byte[] zeros = new byte[20];
1327 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1329 // build a MapRegister
1330 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1331 mapRegister.setWantMapNotify(true);
1332 mapRegister.setNonce((long) 8);
1333 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1334 etlr.setLispAddressContainer(LispAddressUtil.toContainer(address));
1335 etlr.setMaskLength((short) mask);
1336 etlr.setRecordTtl(254);
1337 LocatorRecordBuilder record = new LocatorRecordBuilder();
1338 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1339 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1340 etlr.getLocatorRecord().add(record.build());
1341 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1342 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1344 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1345 mapRegister.setAuthenticationData(zeros);
1347 sendMapRegister(mapRegister.build());
1348 assertNoPacketReceived(3000);
1350 mapRegister.setAuthenticationData(expectedSha);
1352 sendMapRegister(mapRegister.build());
1354 assertMapNotifyReceived();
1357 public void testPasswordMaskMatch() throws Exception {
1359 LispIpv4Address addressInRange = LispAddressUtil.asIPAfiAddress("10.20.30.40");
1360 LispIpv4Address addressOutOfRange = LispAddressUtil.asIPAfiAddress("20.40.30.40");
1361 LispIpv4Address range = LispAddressUtil.asIPAfiAddress("10.20.30.0");
1364 String pass = "pass";
1366 URL url = createPutURL("key");
1367 String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1369 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1370 // build a MapRegister
1371 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1373 mapRegister.setWantMapNotify(true);
1374 mapRegister.setNonce((long) 8);
1375 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1376 etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressInRange));
1377 etlr.setMaskLength((short) mask);
1378 etlr.setRecordTtl(254);
1379 LocatorRecordBuilder record = new LocatorRecordBuilder();
1380 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1381 record.setLispAddressContainer(LispAddressUtil.toContainer(locatorEid));
1382 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1383 etlr.getLocatorRecord().add(record.build());
1384 mapRegister.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1385 mapRegister.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(etlr.build()).build());
1387 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1389 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4,
1390 -67, -113, 104, -110, -71 });
1392 sendMapRegister(mapRegister.build());
1394 assertMapNotifyReceived();
1396 etlr.setLispAddressContainer(LispAddressUtil.toContainer(addressOutOfRange));
1398 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123,
1399 -71, -14, -99, 67, -23, -73 });
1401 sendMapRegister(mapRegister.build());
1402 assertNoPacketReceived(3000);
1405 // takes an address, packs it in a MapRegister and sends it
1406 private void registerAddress(Eid eid) throws SocketTimeoutException {
1407 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1409 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1410 mapRegisterBuilder.setWantMapNotify(true);
1411 mapRegisterBuilder.setKeyId((short) 0);
1412 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1413 mapRegisterBuilder.setNonce((long) 8);
1414 mapRegisterBuilder.setProxyMapReply(false);
1415 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1416 etlrBuilder.setEid(eid);
1417 etlrBuilder.setRecordTtl(254);
1418 etlrBuilder.setAction(Action.NoAction);
1419 etlrBuilder.setAuthoritative(false);
1420 etlrBuilder.setMapVersion((short) 0);
1421 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1422 recordBuilder.setLocalLocator(false);
1423 recordBuilder.setRlocProbed(false);
1424 recordBuilder.setRouted(true);
1425 recordBuilder.setMulticastPriority((short) 0);
1426 recordBuilder.setMulticastWeight((short) 0);
1427 recordBuilder.setPriority((short) 0);
1428 recordBuilder.setWeight((short) 0);
1429 recordBuilder.setRloc(locatorEid);
1430 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1431 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1432 mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1433 mapRegisterBuilder.getMappingRecordItem().add(
1434 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1435 sendMapRegister(mapRegisterBuilder.build());
1436 MapNotify mapNotify = receiveMapNotify();
1437 assertEquals(8, mapNotify.getNonce().longValue());
1440 private MapReply queryForAddress(Eid eid, String srcEid) throws SocketTimeoutException {
1441 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1442 mapRequestBuilder.setNonce((long) 4);
1443 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1444 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1445 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1446 if (srcEid != null) {
1447 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(srcEid)).build());
1449 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress))
1452 mapRequestBuilder.getItrRloc().add(
1453 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1454 mapRequestBuilder.setAuthoritative(false);
1455 mapRequestBuilder.setMapDataPresent(false);
1456 mapRequestBuilder.setPitr(false);
1457 mapRequestBuilder.setProbe(false);
1458 mapRequestBuilder.setSmr(false);
1459 mapRequestBuilder.setSmrInvoked(false);
1460 sendMapRequest(mapRequestBuilder.build());
1461 return receiveMapReply();
1464 // takes an address, packs it in a MapRegister, sends it, returns the
1466 private MapReply registerAddressAndQuery(Eid eid) throws SocketTimeoutException {
1467 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1469 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1470 mapRegisterBuilder.setWantMapNotify(true);
1471 mapRegisterBuilder.setKeyId((short) 0);
1472 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1473 mapRegisterBuilder.setNonce((long) 8);
1474 mapRegisterBuilder.setProxyMapReply(false);
1475 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1476 etlrBuilder.setEid(eid);
1477 etlrBuilder.setRecordTtl(254);
1478 etlrBuilder.setAction(Action.NoAction);
1479 etlrBuilder.setAuthoritative(false);
1480 etlrBuilder.setMapVersion((short) 0);
1481 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1482 recordBuilder.setLocalLocator(false);
1483 recordBuilder.setRlocProbed(false);
1484 recordBuilder.setRouted(true);
1485 recordBuilder.setMulticastPriority((short) 0);
1486 recordBuilder.setMulticastWeight((short) 0);
1487 recordBuilder.setPriority((short) 0);
1488 recordBuilder.setWeight((short) 0);
1489 recordBuilder.setRloc(locatorEid);
1490 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1491 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1492 mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1493 mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
1494 etlrBuilder.build()).build());
1495 sendMapRegister(mapRegisterBuilder.build());
1496 MapNotify mapNotify = receiveMapNotify();
1497 assertEquals(8, mapNotify.getNonce().longValue());
1498 // wait for the notifications to propagate
1500 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1501 mapRequestBuilder.setNonce((long) 4);
1502 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1503 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1504 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1505 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(ourAddress)).build());
1506 mapRequestBuilder.getItrRloc().add(
1507 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1508 mapRequestBuilder.setAuthoritative(false);
1509 mapRequestBuilder.setMapDataPresent(false);
1510 mapRequestBuilder.setPitr(false);
1511 mapRequestBuilder.setProbe(false);
1512 mapRequestBuilder.setSmr(false);
1513 mapRequestBuilder.setSmrInvoked(false);
1514 sendMapRequest(mapRequestBuilder.build());
1515 return receiveMapReply();
1518 // ------------------------------- LCAF Tests ---------------------------
1521 public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1523 String ipPrefix = "10.20.30.200/32";
1524 String macString = "01:02:03:04:05:06";
1526 SourceDestKeyBuilder builder = new SourceDestKeyBuilder();
1527 builder.setSource(new SimpleAddress(new IpPrefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
1528 .ietf.inet.types.rev100924.Ipv4Prefix(ipPrefix))));
1529 builder.setDest(new SimpleAddress(new MacAddress(macString)));
1531 EidBuilder eb = new EidBuilder();
1532 eb.setAddressType(SourceDestKeyLcaf.class);
1533 eb.setVirtualNetworkId(null);
1534 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1535 .lisp.address.address.SourceDestKeyBuilder().setSourceDestKey(builder.build()).build());
1537 MapReply reply = registerAddressAndQuery(eb.build());
1539 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1540 assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
1541 SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
1543 SimpleAddress receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource();
1544 SimpleAddress receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest();
1546 assertNotNull(receivedAddr1.getIpPrefix().getIpv4Prefix());
1547 assertNotNull(receivedAddr2.getMacAddress());
1549 IpPrefix receivedIP = receivedAddr1.getIpPrefix();
1550 MacAddress receivedMAC = receivedAddr2.getMacAddress();
1552 assertEquals(ipPrefix, receivedIP.getIpv4Prefix().getValue());
1553 assertEquals(macString, receivedMAC.getValue());
1557 public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1559 String ipString1 = "10.10.10.0";
1560 String ipString2 = "20.20.20.0";
1561 String ipPrefix1 = ipString1 + "/24";
1562 String ipPrefix2 = ipString2 + "/24";
1564 Eid srcDst = LispAddressUtil.asSrcDstEid(ipString1, ipString2, 24, 24, 0);
1565 registerAddress(LispAddressUtil.asIpv4PrefixEid(ipPrefix2));
1566 registerAddress(srcDst);
1569 MapReply reply = queryForAddress(srcDst, null);
1571 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1572 assertEquals(SourceDestKeyLcaf.class, fromNetwork.getAddressType());
1573 SourceDestKey sourceDestFromNetwork = (SourceDestKey) fromNetwork.getAddress();
1575 IpPrefix receivedAddr1 = sourceDestFromNetwork.getSourceDestKey().getSource().getIpPrefix();
1576 IpPrefix receivedAddr2 = sourceDestFromNetwork.getSourceDestKey().getDest().getIpPrefix();
1578 assertNotNull(receivedAddr1.getIpv4Prefix());
1579 assertNotNull(receivedAddr2.getIpv4Prefix());
1581 assertEquals(ipPrefix1, receivedAddr1.getIpv4Prefix().getValue());
1582 assertEquals(ipPrefix2, receivedAddr2.getIpv4Prefix().getValue());
1584 // srcEid/dstEid match
1585 reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "10.10.10.1");
1586 fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1587 assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
1589 Ipv4Prefix ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
1590 assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
1592 // dstEid match only
1593 reply = queryForAddress(LispAddressUtil.asIpv4PrefixEid("20.20.20.1/32"), "1.2.3.4");
1594 fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1595 assertEquals(Ipv4PrefixAfi.class, fromNetwork.getAddressType());
1597 ipAddr2 = (Ipv4Prefix) fromNetwork.getAddress();
1598 assertEquals(ipPrefix2, ipAddr2.getIpv4Prefix().getValue());
1602 public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1604 String ipString = "10.20.30.200";
1605 String macString = "01:02:03:04:05:06";
1606 SimpleAddress addrToSend1 = new SimpleAddress(new IpAddress(new Ipv4Address(ipString)));
1607 SimpleAddress addrToSend2 = new SimpleAddress(new MacAddress(macString));
1608 Eid kv = LispAddressUtil.asKeyValueAddressEid(addrToSend1, addrToSend2);
1610 MapReply reply = registerAddressAndQuery(kv);
1612 Eid fromNetwork = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1613 assertEquals(KeyValueAddressLcaf.class, fromNetwork.getAddressType());
1614 KeyValueAddress keyValueFromNetwork = (KeyValueAddress) fromNetwork.getAddress();
1616 SimpleAddress receivedAddr1 = keyValueFromNetwork.getKeyValueAddress().getKey();
1617 SimpleAddress receivedAddr2 = keyValueFromNetwork.getKeyValueAddress().getValue();
1619 assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
1620 assertNotNull(receivedAddr2.getMacAddress());
1622 Ipv4Address receivedIP = receivedAddr1.getIpAddress().getIpv4Address();
1623 MacAddress receivedMAC = receivedAddr2.getMacAddress();
1625 assertEquals(ipString, receivedIP.getValue());
1626 assertEquals(macString, receivedMAC.getValue());
1629 public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1631 String macString = "01:02:03:04:05:06";
1632 String ipString = "10.20.255.30";
1633 List<SimpleAddress> addresses = new ArrayList<SimpleAddress>();
1634 addresses.add(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1635 addresses.add(new SimpleAddress(new MacAddress(macString)));
1636 AfiListBuilder listbuilder = new AfiListBuilder();
1637 listbuilder.setAddressList(addresses);
1639 EidBuilder eb = new EidBuilder();
1640 eb.setAddressType(AfiListLcaf.class);
1641 eb.setVirtualNetworkId(null);
1642 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1643 .lisp.address.address.AfiListBuilder().setAfiList(listbuilder.build()).build());
1645 MapReply reply = registerAddressAndQuery(eb.build());
1647 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1649 assertEquals(AfiListLcaf.class, receivedAddress.getAddressType());
1651 AfiList listAddrFromNetwork = (AfiList) receivedAddress.getAddress();
1652 SimpleAddress receivedAddr1 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(0);
1653 SimpleAddress receivedAddr2 = (SimpleAddress) listAddrFromNetwork.getAfiList().getAddressList().get(1);
1655 assertNotNull(receivedAddr1.getIpAddress().getIpv4Address());
1656 assertNotNull(receivedAddr2.getMacAddress());
1658 assertEquals(macString, receivedAddr2.getMacAddress().getValue());
1659 assertEquals(ipString, receivedAddr1.getIpAddress().getIpv4Address().getValue());
1662 public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1664 String ipString = "10.20.255.30";
1667 EidBuilder eb = new EidBuilder();
1668 eb.setAddressType(Ipv4PrefixAfi.class);
1669 eb.setVirtualNetworkId(new InstanceIdType((long) instanceId));
1670 eb.setAddress(new Ipv4PrefixBuilder().setIpv4Prefix(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
1671 .yang.ietf.inet.types.rev100924.Ipv4Prefix(ipString)).build());
1673 MapReply reply = registerAddressAndQuery(eb.build());
1675 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1676 assertEquals(Ipv4PrefixAfi.class, receivedAddress.getAddressType());
1678 assertEquals(ipString, ((Ipv4Prefix) receivedAddress.getAddress()).getIpv4Prefix().getValue());
1680 assertEquals(instanceId, receivedAddress.getVirtualNetworkId().getValue().intValue());
1683 public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1685 String macString = "01:02:03:04:05:06";
1686 String ipString = "10.20.255.30";
1687 HopBuilder hopBuilder = new HopBuilder();
1688 hopBuilder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1689 hopBuilder.setLrsBits(new LrsBits(true, false, true));
1690 Hop hop1 = hopBuilder.build();
1691 hopBuilder.setAddress(new SimpleAddress(new MacAddress(macString)));
1692 hopBuilder.setLrsBits(new LrsBits(false, true, false));
1693 Hop hop2 = hopBuilder.build();
1694 ExplicitLocatorPathBuilder elpBuilder = new ExplicitLocatorPathBuilder();
1695 elpBuilder.setHop(new ArrayList<Hop>());
1696 elpBuilder.getHop().add(hop1);
1697 elpBuilder.getHop().add(hop2);
1699 EidBuilder eb = new EidBuilder();
1700 eb.setAddressType(ExplicitLocatorPathLcaf.class);
1701 eb.setVirtualNetworkId(null);
1702 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1703 .lisp.address.address.ExplicitLocatorPathBuilder().setExplicitLocatorPath(elpBuilder.build()).build());
1705 MapReply reply = registerAddressAndQuery(eb.build());
1707 assertEquals(ExplicitLocatorPathLcaf.class, reply.getMappingRecordItem().get(0).getMappingRecord().getEid()
1710 ExplicitLocatorPath receivedAddress = (ExplicitLocatorPath) reply.getMappingRecordItem().get(0)
1711 .getMappingRecord().getEid().getAddress();
1713 Hop receivedHop1 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(0);
1714 Hop receivedHop2 = (Hop) receivedAddress.getExplicitLocatorPath().getHop().get(1);
1716 assertEquals(true, receivedHop1.getLrsBits().isLookup());
1717 assertEquals(false, receivedHop1.getLrsBits().isRlocProbe());
1718 assertEquals(true, receivedHop1.getLrsBits().isStrict());
1720 assertEquals(false, receivedHop2.getLrsBits().isLookup());
1721 assertEquals(true, receivedHop2.getLrsBits().isRlocProbe());
1722 assertEquals(false, receivedHop2.getLrsBits().isStrict());
1724 assertNotNull(receivedHop1.getAddress().getIpAddress().getIpv4Address());
1725 assertNotNull(receivedHop2.getAddress().getMacAddress());
1727 assertEquals(ipString, receivedHop1.getAddress().getIpAddress().getIpv4Address().getValue());
1728 assertEquals(macString, receivedHop2.getAddress().getMacAddress().getValue());
1731 public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1733 String ipString = "1.2.3.4";
1736 int localPortLow = 3;
1737 int localPortHigh = 4;
1738 int remotePortLow = 4;
1739 int remotePortHigh = 5;
1741 ApplicationDataBuilder builder = new ApplicationDataBuilder();
1742 builder.setIpTos(ipTOs);
1743 builder.setProtocol(protocol);
1744 builder.setLocalPortLow(new PortNumber(localPortLow));
1745 builder.setLocalPortHigh(new PortNumber(localPortHigh));
1746 builder.setRemotePortLow(new PortNumber(remotePortLow));
1747 builder.setRemotePortHigh(new PortNumber(remotePortHigh));
1748 builder.setAddress(new SimpleAddress(new IpAddress(new Ipv4Address(ipString))));
1750 EidBuilder eb = new EidBuilder();
1751 eb.setAddressType(ApplicationDataLcaf.class);
1752 eb.setVirtualNetworkId(null);
1753 eb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1754 .lisp.address.address.ApplicationDataBuilder().setApplicationData(builder.build()).build());
1755 Eid addressToSend = eb.build();
1757 MapReply reply = registerAddressAndQuery(addressToSend);
1759 Eid receivedAddress = reply.getMappingRecordItem().get(0).getMappingRecord().getEid();
1761 assertEquals(ApplicationDataLcaf.class, receivedAddress.getAddressType());
1763 ApplicationData receivedApplicationDataAddress = (ApplicationData) receivedAddress.getAddress();
1764 assertEquals(protocol, receivedApplicationDataAddress.getApplicationData().getProtocol().intValue());
1765 assertEquals(ipTOs, receivedApplicationDataAddress.getApplicationData().getIpTos().intValue());
1766 assertEquals(localPortLow, receivedApplicationDataAddress.getApplicationData().getLocalPortLow().getValue()
1768 assertEquals(localPortHigh, receivedApplicationDataAddress.getApplicationData().getLocalPortHigh().getValue()
1770 assertEquals(remotePortLow, receivedApplicationDataAddress.getApplicationData().getRemotePortLow().getValue()
1772 assertEquals(remotePortHigh, receivedApplicationDataAddress.getApplicationData().getRemotePortHigh().getValue()
1775 SimpleAddress ipAddressReceived = receivedApplicationDataAddress.getApplicationData().getAddress();
1776 assertEquals(ipString, ipAddressReceived.getIpAddress().getIpv4Address().getValue());
1779 // ------------------- TimeOut Tests -----------
1781 public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1783 Eid eid = LispAddressUtil.asIpv4PrefixEid("1.2.3.4/32");
1784 mapService.addAuthenticationKey(eid, NULL_AUTH_KEY);
1786 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1787 mapRequestBuilder.setNonce((long) 4);
1788 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
1789 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1790 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1791 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1792 mapRequestBuilder.getItrRloc().add(
1793 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1795 sendMapRequest(mapRequestBuilder.build());
1796 MapReply mapReply = receiveMapReply();
1797 assertEquals(4, mapReply.getNonce().longValue());
1798 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1800 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1801 mapRegisterbuilder.setWantMapNotify(true);
1802 mapRegisterbuilder.setNonce((long) 8);
1804 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1805 etlrBuilder.setEid(eid);
1806 etlrBuilder.setRecordTtl(254);
1808 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1809 recordBuilder.setRloc(LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1810 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1811 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1812 mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1813 mapRegisterbuilder.getMappingRecordItem().add(
1814 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1816 sendMapRegister(mapRegisterbuilder.build());
1817 MapNotify mapNotify = receiveMapNotify();
1818 assertEquals(8, mapNotify.getNonce().longValue());
1821 sendMapRequest(mapRequestBuilder.build());
1822 mapReply = receiveMapReply();
1823 assertEquals(4, mapReply.getNonce().longValue());
1824 assertEquals(recordBuilder.getRloc(), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1825 .getLocatorRecord().get(0).getRloc());
1827 causeEntryToBeCleaned();
1828 sendMapRequest(mapRequestBuilder.build());
1829 mapReply = receiveMapReply();
1830 assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
1833 public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1835 Eid eid = LispAddressUtil.asIpv6PrefixEid("1.2.3.4/32");
1836 MapRequest mapRequest = createMapRequest(eid);
1838 testTTLBeforeRegister(mapRequest);
1840 registerForTTL(eid);
1842 testTTLAfterRegister(mapRequest);
1844 causeEntryToBeCleaned();
1845 testTTLAfterClean(mapRequest);
1847 //northboundAddKey();
1848 //testTTLAfterAutherize(mapRequest);
1852 private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1854 sendMapRequest(mapRequest);
1855 mapReply = receiveMapReply();
1856 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1859 private void causeEntryToBeCleaned() {
1860 // TODO XXX for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1861 // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1862 // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1863 mapService.cleanCachedMappings();
1866 private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1868 sendMapRequest(mapRequest);
1869 mapReply = receiveMapReply();
1870 assertEquals(LispAddressUtil.asIpv4Rloc("4.3.2.1"), mapReply.getMappingRecordItem().get(0).getMappingRecord()
1871 .getLocatorRecord().get(0).getRloc());
1872 assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1875 private void registerForTTL(Eid eid) throws SocketTimeoutException {
1876 MapRegister mapRegister = createMapRegister(eid);
1877 sendMapRegister(mapRegister);
1878 assertMapNotifyReceived();
1881 private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1883 sendMapRequest(mapRequest);
1884 mapReply = receiveMapReply();
1885 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1888 private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1890 sendMapRequest(mapRequest);
1891 mapReply = receiveMapReply();
1892 assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1895 private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1896 assertEquals(expectedTTL, mapReply.getMappingRecordItem().get(0).getMappingRecord().getRecordTtl().intValue());
1897 assertEquals(expectedAction, mapReply.getMappingRecordItem().get(0).getMappingRecord().getAction());
1900 private MapRegister createMapRegister(Eid eid, Rloc rloc) {
1901 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1902 mapRegisterbuilder.setWantMapNotify(true);
1903 mapRegisterbuilder.setNonce((long) 8);
1904 mapRegisterbuilder.setKeyId((short) 0);
1905 MappingRecordBuilder etlrBuilder = new MappingRecordBuilder();
1906 etlrBuilder.setEid(eid);
1907 etlrBuilder.setRecordTtl(254);
1908 etlrBuilder.setAuthoritative(false);
1909 etlrBuilder.setAction(Action.NoAction);
1910 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1911 recordBuilder.setRloc(rloc);
1912 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1913 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1914 mapRegisterbuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
1915 mapRegisterbuilder.getMappingRecordItem().add(
1916 new MappingRecordItemBuilder().setMappingRecord(etlrBuilder.build()).build());
1917 MapRegister mapRegister = mapRegisterbuilder.build();
1921 private MapRegister createMapRegister(Eid eid) {
1922 return createMapRegister(eid, LispAddressUtil.asIpv4Rloc("4.3.2.1"));
1925 private MapRequest createMapRequest(Eid eid) {
1926 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1927 mapRequestBuilder.setNonce((long) 4);
1928 mapRequestBuilder.setPitr(false);
1929 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.getNoAddressEid()).build());
1930 mapRequestBuilder.setEidItem(new ArrayList<EidItem>());
1931 mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(eid).build());
1932 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1933 mapRequestBuilder.getItrRloc().add(
1934 new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(ourAddress)).build());
1935 MapRequest mr = mapRequestBuilder.build();
1939 public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1941 String rloc = "127.0.0.3";
1942 int port = LispMessage.PORT_NUM;
1943 Rloc ipRloc = LispAddressUtil.asIpv4Rloc(rloc);
1944 sendProxyMapRequest(rloc, port, ipRloc);
1948 public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1950 String rloc = "127.0.0.3";
1953 RlocBuilder rb = new RlocBuilder();
1954 rb.setAddressType(ApplicationDataLcaf.class);
1955 rb.setVirtualNetworkId(null);
1956 rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1957 .lisp.address.address.ApplicationDataBuilder()
1958 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
1959 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
1960 Rloc adLcaf = rb.build();
1962 LOG.info("testNonProxyOtherPort:" + LispAddressStringifier.getString(adLcaf));
1963 sendProxyMapRequest(rloc, port, adLcaf);
1967 private class XtrRequestMappingListener implements OdlLispProtoListener {
1970 public void onGotMapReply(GotMapReply notification) {
1974 public void onAddMapping(AddMapping notification) {
1978 public void onXtrReplyMapping(XtrReplyMapping notification) {
1982 public void onRequestMapping(RequestMapping notification) {
1986 public void onGotMapNotify(GotMapNotify notification) {
1990 public void onXtrRequestMapping(XtrRequestMapping notification) {
1994 public void onMappingKeepAlive(MappingKeepAlive notification) {
1999 public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
2001 configLispPlugin.shouldListenOnXtrPort(true);
2002 notificationCalled = false;
2003 final String eid = "10.10.10.10/32";
2004 String rloc = "127.0.0.3";
2005 int port = LispMessage.XTR_PORT_NUM;
2007 RlocBuilder rb = new RlocBuilder();
2008 rb.setAddressType(ApplicationDataLcaf.class);
2009 rb.setVirtualNetworkId(null);
2010 rb.setAddress(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
2011 .lisp.address.address.ApplicationDataBuilder()
2012 .setApplicationData(new ApplicationDataBuilder().setAddress(new SimpleAddress(new IpAddress(
2013 new Ipv4Address(rloc)))).setLocalPortLow(new PortNumber(port)).build()).build());
2014 Rloc adLcaf = rb.build();
2016 final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2017 ((LispMappingService) lms).getNotificationService().registerNotificationListener(
2018 new XtrRequestMappingListener() {
2021 public void onXtrRequestMapping(XtrRequestMapping notification) {
2022 assertEquals(((Ipv4Prefix) mapRequest.getEidItem().get(0).getEid().getAddress())
2023 .getIpv4Prefix().getValue(), eid);
2024 notificationCalled = true;
2025 LOG.warn("notification arrived");
2028 sendMapRequest(mapRequest, port);
2029 for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
2030 if (notificationCalled) {
2033 LOG.warn("notification hasn't arrived, sleeping...");
2038 fail("Notification hasn't arrived");
2042 private void sendProxyMapRequest(String rloc, int port, Rloc adLcaf) throws SocketTimeoutException,
2044 String eid = "10.1.0.1/32";
2045 MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
2046 sendMapRequest(mapRequest);
2047 DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
2048 MapRequest receivedMapRequest = receiveMapRequest(nonProxySocket);
2049 assertEquals(mapRequest.getNonce(), receivedMapRequest.getNonce());
2050 assertEquals(mapRequest.getSourceEid(), receivedMapRequest.getSourceEid());
2051 assertEquals(mapRequest.getItrRloc(), receivedMapRequest.getItrRloc());
2052 assertEquals(mapRequest.getEidItem(), receivedMapRequest.getEidItem());
2053 nonProxySocket.close();
2056 private MapRequest createNonProxyMapRequest(String eid, Rloc adLcaf) throws SocketTimeoutException {
2057 MapRegister mr = createMapRegister(LispAddressUtil.asIpv4PrefixEid(eid));
2058 LocatorRecord record = new LocatorRecordBuilder(mr.getMappingRecordItem().get(0).getMappingRecord()
2059 .getLocatorRecord().get(0)).setRloc(adLcaf).build();
2060 mr.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().set(0, record);
2061 sendMapRegister(mr);
2062 assertMapNotifyReceived();
2063 MapRequest mapRequest = createMapRequest(LispAddressUtil.asIpv4PrefixEid(eid));
2064 MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
2065 builder.setPitr(true);
2066 mapRequest = builder.build();
2070 private void assertMapNotifyReceived() throws SocketTimeoutException {
2074 private MapReply receiveMapReply() throws SocketTimeoutException {
2075 return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2078 private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
2079 return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(
2080 datagramSocket, 30000).getData()));
2083 private MapNotify receiveMapNotify() throws SocketTimeoutException {
2084 return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
2087 private void sendMapRequest(MapRequest mapRequest) {
2088 sendMapRequest(mapRequest, LispMessage.PORT_NUM);
2091 private void sendMapRequest(MapRequest mapRequest, int port) {
2092 sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
2095 private void sendMapRegister(MapRegister mapRegister) {
2096 sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
2099 private void sendPacket(byte[] bytesToSend) {
2100 sendPacket(bytesToSend, LispMessage.PORT_NUM);
2103 private void sendPacket(byte[] bytesToSend, int port) {
2105 DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
2106 initPacketAddress(packet, port);
2107 LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
2108 socket.send(packet);
2109 } catch (Throwable t) {
2114 private DatagramPacket receivePacket() throws SocketTimeoutException {
2115 return receivePacket(6000);
2118 private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
2119 return receivePacket(socket, timeout);
2122 private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
2124 byte[] buffer = new byte[4096];
2125 DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
2126 LOG.trace("Waiting for packet from socket...");
2127 receivedSocket.setSoTimeout(timeout);
2128 receivedSocket.receive(receivePacket);
2129 LOG.trace("Received packet from socket!");
2130 return receivePacket;
2131 } catch (SocketTimeoutException ste) {
2133 } catch (Throwable t) {
2139 private void sleepForSeconds(int seconds) {
2141 Thread.sleep(seconds*1000);
2142 } catch (InterruptedException e) {
2143 LOG.warn("Interrupted while sleeping", e);
2147 private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
2148 packet.setAddress(InetAddress.getByName(lispBindAddress));
2149 packet.setPort(port);
2152 private DatagramSocket initSocket(DatagramSocket socket, int port) {
2154 socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
2155 } catch (SocketException e) {
2156 e.printStackTrace();
2162 private byte[] extractWSUdpByteArray(String wiresharkHex) {
2163 final int HEADER_LEN = 42;
2164 byte[] res = new byte[1000];
2165 String[] split = wiresharkHex.split(" ");
2167 for (String cur : split) {
2169 if (cur.length() == 2) {
2171 if (counter > HEADER_LEN) {
2172 res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
2177 return Arrays.copyOf(res, counter - HEADER_LEN);
2180 private String stateToString(int state) {
2184 case Bundle.INSTALLED:
2186 case Bundle.RESOLVED:
2188 case Bundle.UNINSTALLED:
2189 return "UNINSTALLED";
2191 return "Not CONVERTED";
2195 private void areWeReady() throws InvalidSyntaxException {
2199 boolean debugit = false;
2200 Bundle b[] = bc.getBundles();
2201 for (Bundle element : b) {
2202 int state = element.getState();
2203 LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v"
2204 + element.getVersion() + ", state:" + stateToString(state));
2205 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
2206 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
2209 // String host = element.getHeaders().get("FRAGMENT-HOST");
2210 // if (host != null) {
2211 // LOG.warn("Bundle " + element.getSymbolicName() +
2212 // " is a fragment which is part of: " + host);
2213 // LOG.warn("Required imports are: " +
2214 // element.getHeaders().get("IMPORT-PACKAGE"));
2218 // } catch (BundleException e) {
2219 // LOG.error("BundleException:", e);
2228 LOG.warn(("Do some debugging because some bundle is unresolved"));
2230 // assertNotNull(broker);
2232 configLispPlugin.setLispAddress(lispBindAddress);
2234 // Uncomment this code to Know which services were actually loaded to
2238 for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
2239 LOG.info(sr.getBundle().getSymbolicName());
2240 LOG.info(sr.toString());
2247 private void cleanUP() {
2249 mapService.cleanCachedMappings();
2250 configLispPlugin.shouldListenOnXtrPort(false);
2251 socket = initSocket(socket, LispMessage.PORT_NUM);
2255 private void restartSocket() {
2257 socket = initSocket(socket, LispMessage.PORT_NUM);