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.ops4j.pax.exam.CoreOptions.composite;
15 import static org.ops4j.pax.exam.CoreOptions.maven;
16 import static org.ops4j.pax.exam.CoreOptions.options;
17 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
19 import java.io.BufferedReader;
20 import java.io.IOException;
21 import java.io.InputStream;
22 import java.io.InputStreamReader;
23 import java.io.OutputStreamWriter;
24 import java.net.DatagramPacket;
25 import java.net.DatagramSocket;
26 import java.net.HttpURLConnection;
27 import java.net.InetAddress;
28 import java.net.InetSocketAddress;
29 import java.net.MalformedURLException;
30 import java.net.SocketException;
31 import java.net.SocketTimeoutException;
33 import java.net.UnknownHostException;
34 import java.nio.ByteBuffer;
35 import java.nio.charset.Charset;
36 import java.util.ArrayList;
37 import java.util.Arrays;
39 import javax.inject.Inject;
41 import org.apache.commons.codec.binary.Base64;
42 //import org.codehaus.jettison.json.JSONException;
43 //import org.codehaus.jettison.json.JSONObject;
44 //import org.codehaus.jettison.json.JSONTokener;
45 import org.junit.After;
46 import org.junit.Assert;
47 import org.junit.Before;
48 import org.junit.Test;
49 import org.junit.runner.RunWith;
50 import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
51 import org.opendaylight.controller.sal.binding.api.NotificationListener;
52 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
53 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
54 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
55 import org.opendaylight.lispflowmapping.lisp.type.AddressFamilyNumberEnum;
56 import org.opendaylight.lispflowmapping.lisp.type.LispCanonicalAddressFormatEnum;
57 import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
58 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
59 import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
60 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
61 import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
62 import org.opendaylight.lispflowmapping.lisp.serializer.MapRequestSerializer;
63 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord.Action;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafApplicationDataAddress;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafListAddress;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafSegmentAddress;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LcafTrafficEngineeringAddress;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispIpv4Address;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispMacAddress;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapNotify;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapReply;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRequest;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.ReencapHop;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.XtrRequestMapping;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecord;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidrecords.EidRecordBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafkeyvalueaddress.KeyBuilder;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafkeyvalueaddress.ValueBuilder;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcaflistaddress.Addresses;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcaflistaddress.AddressesBuilder;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsegmentaddress.AddressBuilder;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.DstAddressBuilder;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafsourcedestaddress.SrcAddressBuilder;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcaftrafficengineeringaddress.Hops;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcaftrafficengineeringaddress.HopsBuilder;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainerBuilder;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafKeyValue;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDest;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.LcafSourceDestBuilder;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder;
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddrBuilder;
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcaflist.LcafListAddrBuilder;
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.lcaftrafficengineering.LcafTrafficEngineeringAddrBuilder;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord;
107 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecordBuilder;
108 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.mapregisternotification.MapRegisterBuilder;
109 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.maprequest.ItrRloc;
110 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.maprequest.ItrRlocBuilder;
111 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.maprequest.SourceEidBuilder;
112 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.maprequestnotification.MapRequestBuilder;
113 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.reencaphop.Hop;
114 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.reencaphop.HopBuilder;
115 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
116 import org.ops4j.pax.exam.Option;
117 import org.ops4j.pax.exam.junit.PaxExam;
118 import org.ops4j.pax.exam.util.Filter;
119 import org.ops4j.pax.exam.karaf.options.LogLevelOption.LogLevel;
120 import org.ops4j.pax.exam.options.MavenUrlReference;
121 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
122 import org.ops4j.pax.exam.spi.reactors.PerClass;
123 import org.osgi.framework.Bundle;
124 import org.osgi.framework.BundleContext;
125 import org.osgi.framework.InvalidSyntaxException;
126 import org.osgi.framework.ServiceReference;
127 import org.slf4j.Logger;
128 import org.slf4j.LoggerFactory;
130 @RunWith(PaxExam.class)
131 @ExamReactorStrategy(PerClass.class)
132 public class MappingServiceIntegrationTest extends AbstractMdsalTestBase {
133 private static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
135 private byte[] mapRequestPacket;
136 private byte[] mapRegisterPacketWithNotify;
137 private byte[] mapRegisterPacketWithoutNotify;
138 String lispBindAddress = "127.0.0.1";
139 String ourAddress = "127.0.0.2";
140 private LispAFIAddress locatorEid;
141 private DatagramSocket socket;
142 private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
144 public static final String ODL = "org.opendaylight.controller";
145 public static final String YANG = "org.opendaylight.yangtools";
146 public static final String JERSEY = "com.sun.jersey";
147 private static final int MAX_NOTIFICATION_RETRYS = 20;
150 public String getModuleName() {
151 return "mappingservice-impl";
155 public String getInstanceName() {
156 return "mappingservice-default";
159 // This is temporary, since the properties in the pom file are not picked up
160 // .versionAsInProject() doesn't work here, and this makes version bumping difficult
162 public String getKarafDistro() {
164 .groupId("org.opendaylight.lispflowmapping")
165 .artifactId("distribution-karaf")
166 .version("1.3.0-SNAPSHOT")
172 public MavenUrlReference getFeatureRepo() {
174 .groupId("org.opendaylight.lispflowmapping")
175 .artifactId("features-lispflowmapping")
176 .classifier("features")
178 .versionAsInProject();
182 public String getFeatureName() {
183 return "odl-lispflowmapping-msmr";
187 public Option getLoggingOption() {
188 Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
189 logConfiguration(MappingServiceIntegrationTest.class),
190 LogLevel.DEBUG.name());
191 option = composite(option, super.getLoggingOption());
196 public void testLispFlowMappingFeatureLoad() {
197 Assert.assertTrue(true);
201 public void after() {
202 if (socket != null) {
205 // if (connection != null) {
206 // connection.disconnect();
211 public void before() throws Exception {
213 locatorEid = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
214 socket = initSocket(socket, LispMessage.PORT_NUM);
216 // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
217 // LISP(Type = 8 - Encapsulated)
218 // IP: 192.168.136.10 -> 153.16.254.1
220 // LISP(Type = 1 Map-Request
224 // Source EID 1.2.3.4
225 // Nonce: 0x3d8d2acd39c8d608
226 // ITR-RLOC AFI=1 Address=192.168.136.10
227 // Record 1: 153.16.254.1/32
228 mapRequestPacket = extractWSUdpByteArray(new String("0000 00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
229 + "0010 00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
230 + "0020 00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
231 + "0030 00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
232 + "0040 fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
233 + "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
234 + "0060 00 01 99 10 fe 01"));
236 // IP: 192.168.136.10 -> 128.223.156.35
237 // UDP: 49289 -> 4342
238 // LISP(Type = 3 Map-Register, P=1, M=1
242 // AuthDataLength: 20 Data:
243 // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
244 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
246 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
247 // Priority/Weight: 1/100, Multicast Priority/Weight:
251 mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
252 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
253 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
254 + "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
255 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
256 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
257 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
259 // IP: 192.168.136.10 -> 128.223.156.35
260 // UDP: 49289 -> 4342
261 // LISP(Type = 3 Map-Register, P=1, M=1
264 // Key ID: 0x0000 NO AUTHENTICATION!!
265 // AuthDataLength: 00 Data:
266 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
268 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
269 // Priority/Weight: 1/100, Multicast Priority/Weight:
273 mapRegisterPacketWithNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
274 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
275 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
276 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
277 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
278 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
279 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
281 // IP: 192.168.136.10 -> 128.223.156.35
282 // UDP: 49289 -> 4342
283 // LISP(Type = 3 Map-Register, P=1, M=1
286 // Key ID: 0x0000 NO AUTHENTICATION!!
287 // AuthDataLength: 00 Data:
288 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
290 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
291 // Priority/Weight: 1/100, Multicast Priority/Weight:
295 mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
296 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
297 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
298 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
299 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
300 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
301 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
305 private BundleContext bc;
306 private HttpURLConnection connection;
307 protected static boolean notificationCalled;
309 @Inject @Filter(timeout=60000)
310 private IFlowMapping lms;
312 @Inject @Filter(timeout=60000)
313 private IMappingService mapService;
315 @Inject @Filter(timeout=10000)
316 private IConfigLispSouthboundPlugin configLispPlugin;
319 public void testSimpleUsage() throws Exception {
321 mapRegisterWithMapNotify();
322 mapRegisterWithMapNotifyAndMapRequest();
323 registerAndQuery__MAC();
324 mapRequestMapRegisterAndMapRequest();
325 mapRegisterWithAuthenticationWithoutConfiguringAKey();
326 mapRegisterWithoutMapNotify();
330 public void testLCAFs() throws Exception {
331 //registerAndQuery__SrcDestLCAF();
332 //registerAndQuery__SrcDestLCAFOverlap();
333 //registerAndQuery__KeyValueLCAF();
334 registerAndQuery__ListLCAF();
335 registerAndQuery__ApplicationData();
336 registerAndQuery__TrafficEngineering();
337 registerAndQuery__SegmentLCAF();
341 public void testMask() throws Exception {
342 //testPasswordExactMatch(); TODO commented because it needs NB
343 //testPasswordMaskMatch(); TODO commented because it needs NB
344 eidPrefixLookupIPv4();
345 eidPrefixLookupIPv6();
349 public void testNorthbound() throws Exception {
351 northboundAddMapping();
352 northboundDeleteMapping();
353 northboundRetrieveKey();
354 northboundRetrieveMapping();
355 northboundRetrieveSourceDestKey();
356 northboundRetrieveSourceDestMapping();
360 public void testOverWriting() throws Exception {
361 //testMapRegisterDosntOverwritesOtherSubKeys(); TODO weird failure, needs debug
363 // TODO: remove, we don't support overwrite flag any longer and RLOCs are not saved as independent RLOC groups
364 // testMapRegisterOverwritesSameSubkey();
365 // testMapRegisterOverwritesNoSubkey();
366 // testMapRegisterDoesntOverwritesNoSubkey();
370 public void testTimeOuts() throws Exception {
371 mapRequestMapRegisterAndMapRequestTestTimeout();
372 //mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse(); TODO commented because it needs NB
376 // public void testNonProxy() throws Throwable {
377 // testSimpleNonProxy();
378 // testNonProxyOtherPort();
379 // testRecievingNonProxyOnXtrPort();
383 public void testSmr() throws Exception {
384 registerQueryRegisterWithSmr();
387 // ------------------------------- Simple Tests ---------------------------
389 public void mapRequestSimple() throws SocketTimeoutException {
392 // This Map-Request is sent from a source port different from 4342
393 // We close and bind the socket on the correct port
394 if (socket != null) {
397 socket = initSocket(socket, 56756);
399 sendPacket(mapRequestPacket);
400 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
401 MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
402 assertEquals(4435248268955932168L, reply.getNonce().longValue());
406 public void mapRegisterWithMapNotify() throws SocketTimeoutException {
408 sendPacket(mapRegisterPacketWithNotify);
409 MapNotify reply = receiveMapNotify();
410 assertEquals(7, reply.getNonce().longValue());
413 public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
415 LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
417 MapReply mapReply = registerAddressAndQuery(eid, 32);
419 assertEquals(4, mapReply.getNonce().longValue());
420 assertEquals(LispAFIConvertor.toContainer(locatorEid), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
421 .getLispAddressContainer());
425 public void registerAndQuery__MAC() throws SocketTimeoutException {
427 String macAddress = "01:02:03:04:05:06";
429 MapReply reply = registerAddressAndQuery(LispAFIConvertor.asMacAfiAddress(macAddress));
432 LispAFIAddress addressFromNetwork = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
433 assertTrue(addressFromNetwork instanceof LispMacAddress);
434 String macAddressFromReply = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.mac.MacAddress) addressFromNetwork).getMacAddress().getValue();
436 assertEquals(macAddress, macAddressFromReply);
439 public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
441 LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
442 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
443 mapRequestBuilder.setNonce((long) 4);
444 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
445 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
446 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
447 mapRequestBuilder.getEidRecord().add(
448 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
449 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
450 mapRequestBuilder.getItrRloc().add(
451 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
452 sendMapRequest(mapRequestBuilder.build());
453 MapReply mapReply = receiveMapReply();
454 assertEquals(4, mapReply.getNonce().longValue());
455 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
456 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
457 mapRegisterbuilder.setWantMapNotify(true);
458 mapRegisterbuilder.setNonce((long) 8);
459 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
460 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
461 etlrBuilder.setMaskLength((short) 32);
462 etlrBuilder.setRecordTtl(254);
463 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
464 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
465 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
466 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
467 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
468 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
469 sendMapRegister(mapRegisterbuilder.build());
470 MapNotify mapNotify = receiveMapNotify();
471 assertEquals(8, mapNotify.getNonce().longValue());
472 sendMapRequest(mapRequestBuilder.build());
473 mapReply = receiveMapReply();
474 assertEquals(4, mapReply.getNonce().longValue());
475 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
476 .getLispAddressContainer());
480 public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
482 LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
483 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
484 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey1", LispAFIConvertor.toPrimitive(rloc1Value));
485 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
486 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey2", LispAFIConvertor.toPrimitive(rloc2Value));
487 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
488 assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
489 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
490 assertEquals(LispAFIConvertor.toContainer(rloc1), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer());
493 public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
495 LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
496 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
497 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc1Value));
498 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
499 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc2Value));
500 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
501 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
502 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
505 public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
507 mapService.setMappingOverwrite(true);
508 LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
509 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
510 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
511 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
512 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
513 assertEquals(LispAFIConvertor.toContainer(rloc2Value), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
514 .getLispAddressContainer());
517 public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
519 mapService.setMappingOverwrite(false);
520 LispAFIAddress eid = LispAFIConvertor.toAFI(LispAFIConvertor.asIPv4Address("1.2.3.4"));
521 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
522 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
523 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
524 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
525 LispAddressContainer rloc1ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer();
526 LispAddressContainer rloc2ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer();
527 assertTrue((LispAFIConvertor.toContainer(rloc1Value).equals(rloc1ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
528 rloc2ReturnValueContainer))
529 || (LispAFIConvertor.toContainer(rloc1Value).equals(rloc2ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
530 rloc1ReturnValueContainer)));
533 private MapReply sendMapRegisterTwiceWithDiffrentValues(LispAFIAddress eid, LispAFIAddress rloc1, LispAFIAddress rloc2)
534 throws SocketTimeoutException {
535 MapRegister mb = createMapRegister(eid, rloc1);
536 MapNotify mapNotify = lms.handleMapRegister(mb);
537 MapRequest mr = createMapRequest(eid);
538 MapReply mapReply = lms.handleMapRequest(mr);
539 assertEquals(mb.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0)
540 .getLocatorRecord().get(0).getLispAddressContainer());
541 mb = createMapRegister(eid, rloc2);
542 mapNotify = lms.handleMapRegister(mb);
543 assertEquals(8, mapNotify.getNonce().longValue());
544 mr = createMapRequest(eid);
546 mapReply = lms.handleMapRequest(mr);
550 public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
552 sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
555 // If didn't timeout then fail:
557 } catch (SocketTimeoutException ste) {
561 public void mapRegisterWithoutMapNotify() {
563 sendPacket(mapRegisterPacketWithoutNotify);
566 // If didn't timeout then fail:
568 } catch (SocketTimeoutException ste) {
572 public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
574 lms.setShouldUseSmr(true);
576 sendPacket(mapRegisterPacketWithNotify);
580 sendPacket(mapRequestPacket);
583 mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
584 sendPacket(mapRegisterPacketWithoutNotify);
586 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
587 MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
588 assertTrue(smr.isSmr());
589 LispAddressContainer sourceEid = smr.getSourceEid().getLispAddressContainer();
590 assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")).equals(sourceEid));
591 LispAddressContainer smrEid = smr.getEidRecord().get(0).getLispAddressContainer();
592 assertTrue(LispAFIConvertor.asIPv4Address("1.2.3.4").equals(smrEid));
595 // --------------------- Northbound Tests ---------------------------
597 private void northboundAddKey() throws Exception {
599 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
601 String pass = "asdf";
603 URL url = createPutURL("key");
604 String authKeyJSON = createAuthKeyJSON(pass, address, mask);
605 callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
607 String retrievedKey = lms.getAuthenticationKey(LispAFIConvertor.toContainer(address), mask);
609 // Check stored password matches the one sent
610 assertEquals(pass, retrievedKey);
614 private void northboundRetrieveSourceDestKey() throws Exception {
616 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
617 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
618 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
619 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
622 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
623 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
624 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
625 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
626 String pass = "asdf";
628 lms.addAuthenticationKey(LispAFIConvertor.toContainer(sourceDestAddress), mask1, pass);
630 // URL url = createGetKeyIPv4URL(address1, mask1);
631 URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
632 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
633 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
634 String reply = callURL("GET", null, "application/json", null, url);
635 JSONTokener jt = new JSONTokener(reply);
636 JSONObject json = new JSONObject(jt);
638 // test that the password matches what was we expected.
639 assertEquals(pass, json.get("key"));
643 private void northboundRetrieveKey() throws Exception {
645 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
647 String pass = "asdf";
649 lms.addAuthenticationKey(LispAFIConvertor.toContainer(address), mask, pass);
651 URL url = createGetKeyIPv4URL(address, mask);
652 String reply = callURL("GET", null, "application/json", null, url);
653 JSONTokener jt = new JSONTokener(reply);
654 JSONObject json = new JSONObject(jt);
656 // test that the password matches what was we expected.
657 assertEquals(pass, json.get("key"));
661 private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
662 return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
663 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
666 private void northboundAddMapping() throws Exception {
668 String pass = "asdf";
669 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
671 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
673 // NB add mapping always checks the key
674 lms.addAuthenticationKey(LispAFIConvertor.toContainer(eid), mask, pass);
676 URL url = createPutURL("mapping");
677 String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
678 callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
680 // Retrieve the RLOC from the database
681 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
682 mapRequestBuilder.setPitr(false);
683 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
684 mapRequestBuilder.getEidRecord().add(
685 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
686 MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
688 LispIpv4Address retrievedRloc = (LispIpv4Address) LispAFIConvertor.toAFI(
689 mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
691 assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
695 private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
696 String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ " + "\"proxyMapReply\" : false, "
697 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : " + "{ " + "\"ipAddress\" : \""
698 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "}," + "\"mapVersion\" : 0,"
699 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ " + "\"multicastPriority\" : 1,"
700 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\"," + "\"afi\" : "
701 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50," + "\"rlocProbed\" : false, "
702 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], " + "\"recordTtl\" : 100" + "} " + "], "
703 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
708 private void northboundRetrieveMapping() throws Exception {
710 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
712 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
713 // Insert mapping in the database
714 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
715 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
716 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
717 etlr.setMaskLength((short) mask);
718 etlr.setRecordTtl(254);
719 etlr.setAuthoritative(false);
720 etlr.setAction(Action.NoAction);
721 LocatorRecordBuilder record = new LocatorRecordBuilder();
722 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
723 record.setRouted(true);
724 record.setRlocProbed(false);
725 record.setLocalLocator(false);
726 record.setPriority((short) 1);
727 record.setWeight((short) 50);
728 record.setMulticastPriority((short) 1);
729 record.setMulticastWeight((short) 1);
730 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
731 etlr.getLocatorRecord().add(record.build());
732 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
733 mapRegister.getEidToLocatorRecord().add(etlr.build());
734 lms.handleMapRegister(mapRegister.build(), false);
736 // Get mapping using NB interface. No IID used
737 URL url = createGetMappingIPv4URL(0, eid, mask);
738 String reply = callURL("GET", null, "application/json", null, url);
739 JSONTokener jt = new JSONTokener(reply);
740 JSONObject json = new JSONObject(jt);
742 // With just one locator, locators is not a JSONArray
743 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
745 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
749 private void northboundDeleteMapping() throws Exception {
751 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
753 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
754 // Insert mapping in the database
755 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
756 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
757 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
758 etlr.setMaskLength((short) mask);
759 etlr.setRecordTtl(254);
760 etlr.setAuthoritative(false);
761 etlr.setAction(Action.NoAction);
762 LocatorRecordBuilder record = new LocatorRecordBuilder();
763 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
764 record.setRouted(true);
765 record.setRlocProbed(false);
766 record.setLocalLocator(false);
767 record.setPriority((short) 1);
768 record.setWeight((short) 50);
769 record.setMulticastPriority((short) 1);
770 record.setMulticastWeight((short) 1);
771 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
772 etlr.getLocatorRecord().add(record.build());
773 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
774 mapRegister.getEidToLocatorRecord().add(etlr.build());
775 lms.handleMapRegister(mapRegister.build(), false);
777 // Delete mapping using NB interface. No IID used
778 URL url = createDeleteMappingIPv4URL(0, eid, mask);
779 String reply = callURL("DELETE", null, "application/json", null, url);
781 // Get mapping using NB interface. No IID used
782 url = createGetMappingIPv4URL(0, eid, mask);
783 reply = callURL("GET", null, "application/json", null, url);
784 JSONTokener jt = new JSONTokener(reply);
785 JSONObject json = new JSONObject(jt);
787 // With just one locator, locators is not a JSONArray
788 assertEquals(json.getJSONArray("locators").length(), 0);
791 private void northboundRetrieveSourceDestMapping() throws Exception {
793 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
794 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
795 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
796 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
799 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
800 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
801 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
802 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
803 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
805 // Insert mapping in the database
806 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
807 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
808 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(sourceDestAddress));
809 etlr.setMaskLength((short) mask1);
810 etlr.setRecordTtl(254);
811 etlr.setAuthoritative(false);
812 etlr.setAction(Action.NoAction);
813 LocatorRecordBuilder record = new LocatorRecordBuilder();
814 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
815 record.setRouted(true);
816 record.setRlocProbed(false);
817 record.setLocalLocator(false);
818 record.setPriority((short) 1);
819 record.setWeight((short) 50);
820 record.setMulticastPriority((short) 1);
821 record.setMulticastWeight((short) 1);
822 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
823 etlr.getLocatorRecord().add(record.build());
824 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
825 mapRegister.getEidToLocatorRecord().add(etlr.build());
826 lms.handleMapRegister(mapRegister.build(), false);
828 // Get mapping using NB interface. No IID used
829 URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
830 address1.getIpv4Address().getIpv4Address().getValue(),
832 address2.getIpv4Address().getIpv4Address().getValue(),
834 String reply = callURL("GET", null, "application/json", null, url);
835 JSONTokener jt = new JSONTokener(reply);
836 JSONObject json = new JSONObject(jt);
838 // With just one locator, locators is not a JSONArray
839 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
841 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
845 private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
846 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key", address.getAfi().shortValue(),
847 address.getIpv4Address().getValue(), mask);
848 URL url = new URL(restUrl);
852 private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
853 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "key", afi, srcAddress, srcMask,
854 dstAddress, dstMask);
855 URL url = new URL(restUrl);
859 private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
860 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "mapping", afi, srcAddress,
861 srcMask, dstAddress, dstMask);
862 URL url = new URL(restUrl);
866 private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
867 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
868 .shortValue(), address.getIpv4Address().getValue(), mask);
869 URL url = new URL(restUrl);
873 private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
874 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
875 .shortValue(), address.getIpv4Address().getValue(), mask);
876 URL url = new URL(restUrl);
880 private URL createPutURL(String resource) throws MalformedURLException {
882 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
884 URL url = new URL(restUrl);
888 private String createAuthenticationString() {
889 String authString = "admin:admin";
890 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
891 String authStringEnc = new String(authEncBytes);
892 return authStringEnc;
895 private String callURL(String method, String content, String accept, String body, URL url) throws IOException, JSONException {
896 String authStringEnc = createAuthenticationString();
897 connection = (HttpURLConnection) url.openConnection();
898 connection.setRequestMethod(method);
899 connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
900 if (content != null) {
901 connection.setRequestProperty("Content-Type", content);
903 if (accept != null) {
904 connection.setRequestProperty("Accept", accept);
907 // now add the request body
908 connection.setDoOutput(true);
909 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
913 connection.connect();
915 // getting the result, first check response code
916 Integer httpResponseCode = connection.getResponseCode();
918 if (httpResponseCode > 299) {
919 LOG.trace("HTTP Address: " + url);
920 LOG.trace("HTTP Response Code: " + httpResponseCode);
924 InputStream is = connection.getInputStream();
925 BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
926 StringBuilder sb = new StringBuilder();
928 while ((cp = rd.read()) != -1) {
929 sb.append((char) cp);
932 connection.disconnect();
933 return (sb.toString());
936 // timePeriod - in ms
937 public void assertNoPacketReceived(int timePeriod) {
939 receivePacket(timePeriod);
940 // If didn't timeout then fail:
942 } catch (SocketTimeoutException ste) {
946 // ------------------------------- Mask Tests ---------------------------
948 public void eidPrefixLookupIPv4() throws SocketTimeoutException {
950 runPrefixTest(LispAFIConvertor.asIPAfiAddress("1.2.3.4"), 16, LispAFIConvertor.asIPAfiAddress("1.2.3.2"),
951 LispAFIConvertor.asIPAfiAddress("1.1.1.1"), (byte) 32);
954 public void eidPrefixLookupIPv6() throws SocketTimeoutException {
956 runPrefixTest(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8"), 64, LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:1:2:3"),
957 LispAFIConvertor.asIPv6AfiAddress("1:2:3:1:2:3:1:2"), 128);
960 private void runPrefixTest(LispAFIAddress registerEID, int registerdMask, LispAFIAddress matchedAddress, LispAFIAddress unMatchedAddress, int mask)
961 throws SocketTimeoutException {
963 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
964 mapRegister.setWantMapNotify(true);
965 mapRegister.setNonce((long) 8);
966 mapRegister.setWantMapNotify(true);
967 mapRegister.setKeyId((short) 0);
968 mapRegister.setAuthenticationData(new byte[0]);
969 mapRegister.setNonce((long) 8);
970 mapRegister.setProxyMapReply(false);
971 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
972 etlr.setRecordTtl(254);
973 etlr.setAction(Action.NoAction);
974 etlr.setAuthoritative(false);
975 etlr.setMapVersion((short) 0);
976 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(registerEID));
977 etlr.setMaskLength((short) registerdMask);
978 etlr.setRecordTtl(254);
979 LocatorRecordBuilder record = new LocatorRecordBuilder();
980 record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
981 record.setLocalLocator(false);
982 record.setRlocProbed(false);
983 record.setRouted(true);
984 record.setMulticastPriority((short) 0);
985 record.setMulticastWeight((short) 0);
986 record.setPriority((short) 0);
987 record.setWeight((short) 0);
988 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
989 etlr.getLocatorRecord().add(record.build());
990 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
991 mapRegister.getEidToLocatorRecord().add(etlr.build());
992 sendMapRegister(mapRegister.build());
993 MapNotify mapNotify = receiveMapNotify();
994 assertEquals(8, mapNotify.getNonce().longValue());
995 MapRequestBuilder mapRequest = new MapRequestBuilder();
996 mapRequest.setNonce((long) 4);
997 mapRequest.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
998 mapRequest.setEidRecord(new ArrayList<EidRecord>());
999 mapRequest.setAuthoritative(false);
1000 mapRequest.setMapDataPresent(false);
1001 mapRequest.setPitr(false);
1002 mapRequest.setProbe(false);
1003 mapRequest.setSmr(false);
1004 mapRequest.setSmrInvoked(false);
1005 mapRequest.getEidRecord().add(
1006 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(matchedAddress)).build());
1007 mapRequest.setItrRloc(new ArrayList<ItrRloc>());
1008 mapRequest.getItrRloc().add(
1009 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1010 sendMapRequest(mapRequest.build());
1011 MapReply mapReply = receiveMapReply();
1012 assertEquals(4, mapReply.getNonce().longValue());
1013 assertEquals(record.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
1014 mapRequest.setEidRecord(new ArrayList<EidRecord>());
1015 mapRequest.getEidRecord().add(
1016 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(unMatchedAddress)).build());
1017 sendMapRequest(mapRequest.build());
1018 mapReply = receiveMapReply();
1019 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1022 // This registers an IP with a MapRegister, then adds a password via the
1023 // northbound REST API
1024 // and checks that the password works
1025 public void testPasswordExactMatch() throws Exception {
1027 String ipString = "10.0.0.1";
1028 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress(ipString);
1030 String pass = "pass";
1032 URL url = createPutURL("key");
1034 String jsonAuthData = createAuthKeyJSON(pass, address, mask);
1036 LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
1037 LOG.trace("Address: " + address);
1039 byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232, (byte) 31, (byte) 249, (byte) 87,
1040 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53, (byte) 196, (byte) 62 };
1042 byte[] zeros = new byte[20];
1044 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1046 // build a MapRegister
1047 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1048 mapRegister.setWantMapNotify(true);
1049 mapRegister.setNonce((long) 8);
1050 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1051 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(address));
1052 etlr.setMaskLength((short) mask);
1053 etlr.setRecordTtl(254);
1054 LocatorRecordBuilder record = new LocatorRecordBuilder();
1055 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1056 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1057 etlr.getLocatorRecord().add(record.build());
1058 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1059 mapRegister.getEidToLocatorRecord().add(etlr.build());
1061 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1062 mapRegister.setAuthenticationData(zeros);
1064 sendMapRegister(mapRegister.build());
1065 assertNoPacketReceived(3000);
1067 mapRegister.setAuthenticationData(expectedSha);
1069 sendMapRegister(mapRegister.build());
1071 assertMapNotifyRecieved();
1074 public void testPasswordMaskMatch() throws Exception {
1076 LispIpv4Address addressInRange = LispAFIConvertor.asIPAfiAddress("10.20.30.40");
1077 LispIpv4Address addressOutOfRange = LispAFIConvertor.asIPAfiAddress("20.40.30.40");
1078 LispIpv4Address range = LispAFIConvertor.asIPAfiAddress("10.20.30.0");
1081 String pass = "pass";
1083 URL url = createPutURL("key");
1084 String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1086 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1087 // build a MapRegister
1088 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1090 mapRegister.setWantMapNotify(true);
1091 mapRegister.setNonce((long) 8);
1092 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1093 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressInRange));
1094 etlr.setMaskLength((short) mask);
1095 etlr.setRecordTtl(254);
1096 LocatorRecordBuilder record = new LocatorRecordBuilder();
1097 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1098 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1099 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1100 etlr.getLocatorRecord().add(record.build());
1101 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1102 mapRegister.getEidToLocatorRecord().add(etlr.build());
1104 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1106 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4, -67, -113, 104, -110, -71 });
1108 sendMapRegister(mapRegister.build());
1110 assertMapNotifyRecieved();
1112 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressOutOfRange));
1114 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123, -71, -14, -99, 67, -23, -73 });
1116 sendMapRegister(mapRegister.build());
1117 assertNoPacketReceived(3000);
1120 private MapReply registerAddressAndQuery(LispAFIAddress eid) throws SocketTimeoutException {
1121 return registerAddressAndQuery(eid, -1);
1124 // takes an address, packs it in a MapRegister and sends it
1125 private void registerAddress(LispAddressContainer eid, int maskLength) throws SocketTimeoutException {
1126 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1127 mapRegisterBuilder.setWantMapNotify(true);
1128 mapRegisterBuilder.setKeyId((short) 0);
1129 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1130 mapRegisterBuilder.setNonce((long) 8);
1131 mapRegisterBuilder.setProxyMapReply(false);
1132 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1133 etlrBuilder.setLispAddressContainer(eid);
1134 if (maskLength != -1) {
1135 etlrBuilder.setMaskLength((short) maskLength);
1137 etlrBuilder.setMaskLength((short) 0);
1139 etlrBuilder.setRecordTtl(254);
1140 etlrBuilder.setAction(Action.NoAction);
1141 etlrBuilder.setAuthoritative(false);
1142 etlrBuilder.setMapVersion((short) 0);
1143 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1144 recordBuilder.setLocalLocator(false);
1145 recordBuilder.setRlocProbed(false);
1146 recordBuilder.setRouted(true);
1147 recordBuilder.setMulticastPriority((short) 0);
1148 recordBuilder.setMulticastWeight((short) 0);
1149 recordBuilder.setPriority((short) 0);
1150 recordBuilder.setWeight((short) 0);
1151 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1152 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1153 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1154 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1155 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1156 sendMapRegister(mapRegisterBuilder.build());
1157 MapNotify mapNotify = receiveMapNotify();
1158 assertEquals(8, mapNotify.getNonce().longValue());
1161 private MapReply queryForAddress(LispAddressContainer eid, String srcEid) throws SocketTimeoutException {
1162 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1163 mapRequestBuilder.setNonce((long) 4);
1164 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1165 mapRequestBuilder.getEidRecord().add(
1166 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(eid).build());
1167 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1168 if (srcEid != null) {
1169 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1170 toContainer(LispAFIConvertor.asIPAfiAddress(srcEid))).build());
1172 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1173 toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1175 mapRequestBuilder.getItrRloc().add(
1176 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1177 mapRequestBuilder.setAuthoritative(false);
1178 mapRequestBuilder.setMapDataPresent(false);
1179 mapRequestBuilder.setPitr(false);
1180 mapRequestBuilder.setProbe(false);
1181 mapRequestBuilder.setSmr(false);
1182 mapRequestBuilder.setSmrInvoked(false);
1183 sendMapRequest(mapRequestBuilder.build());
1184 return receiveMapReply();
1187 // takes an address, packs it in a MapRegister, sends it, returns the
1189 private MapReply registerAddressAndQuery(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1190 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1191 mapRegisterBuilder.setWantMapNotify(true);
1192 mapRegisterBuilder.setKeyId((short) 0);
1193 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1194 mapRegisterBuilder.setNonce((long) 8);
1195 mapRegisterBuilder.setProxyMapReply(false);
1196 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1197 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1198 if (maskLength != -1) {
1199 etlrBuilder.setMaskLength((short) maskLength);
1201 etlrBuilder.setMaskLength((short) 0);
1203 etlrBuilder.setRecordTtl(254);
1204 etlrBuilder.setAction(Action.NoAction);
1205 etlrBuilder.setAuthoritative(false);
1206 etlrBuilder.setMapVersion((short) 0);
1207 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1208 recordBuilder.setLocalLocator(false);
1209 recordBuilder.setRlocProbed(false);
1210 recordBuilder.setRouted(true);
1211 recordBuilder.setMulticastPriority((short) 0);
1212 recordBuilder.setMulticastWeight((short) 0);
1213 recordBuilder.setPriority((short) 0);
1214 recordBuilder.setWeight((short) 0);
1215 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1216 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1217 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1218 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1219 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1220 sendMapRegister(mapRegisterBuilder.build());
1221 MapNotify mapNotify = receiveMapNotify();
1222 assertEquals(8, mapNotify.getNonce().longValue());
1223 // wait for the notifications to propagate
1225 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1226 mapRequestBuilder.setNonce((long) 4);
1227 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1228 mapRequestBuilder.getEidRecord().add(
1229 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1230 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1231 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress)))
1233 mapRequestBuilder.getItrRloc().add(
1234 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1235 mapRequestBuilder.setAuthoritative(false);
1236 mapRequestBuilder.setMapDataPresent(false);
1237 mapRequestBuilder.setPitr(false);
1238 mapRequestBuilder.setProbe(false);
1239 mapRequestBuilder.setSmr(false);
1240 mapRequestBuilder.setSmrInvoked(false);
1241 sendMapRequest(mapRequestBuilder.build());
1242 return receiveMapReply();
1245 // ------------------------------- LCAF Tests ---------------------------
1248 public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1250 String ipString = "10.20.30.200";
1251 String macString = "01:02:03:04:05:06";
1252 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString, 32);
1253 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1254 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1255 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1256 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1257 builder.setSrcMaskLength((short) 32);
1258 builder.setDstMaskLength((short) 0);
1259 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1260 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1262 MapReply reply = registerAddressAndQuery(builder.build());
1264 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1265 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1266 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1268 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1269 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1271 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1272 assertTrue(receivedAddr2 instanceof LispMacAddress);
1274 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1275 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1277 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1278 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1282 public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1284 String ipString1 = "10.10.10.0";
1285 String ipString2 = "20.20.20.0";
1286 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString1, 24);
1287 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend2 = LispAFIConvertor.asPrimitiveIPv4AfiPrefix(ipString2, 24);
1288 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1289 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1290 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1291 builder.setSrcMaskLength((short) 24);
1292 builder.setDstMaskLength((short) 24);
1293 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1294 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1296 LispAddressContainer srcDst = LispAFIConvertor.toContainer(builder.build());
1297 registerAddress(LispAFIConvertor.asIPv4Prefix(ipString2, 24), 24);
1298 registerAddress(srcDst, -1);
1301 MapReply reply = queryForAddress(srcDst, null);
1303 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1304 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1305 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1307 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1308 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1310 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1311 assertTrue(receivedAddr2 instanceof LispIpv4Address);
1313 LispIpv4Address receivedIP1 = (LispIpv4Address) receivedAddr1;
1314 LispIpv4Address receivedIP2 = (LispIpv4Address) receivedAddr2;
1316 assertEquals(ipString1, receivedIP1.getIpv4Address().getValue());
1317 assertEquals(ipString2, receivedIP2.getIpv4Address().getValue());
1319 // srcEid/dstEid match
1320 reply = queryForAddress(LispAFIConvertor.asIPv4Address("20.20.20.1"), "10.10.10.1");
1321 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1322 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4);
1324 Ipv4Address ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1325 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1327 // dstEid match only
1328 reply = queryForAddress(LispAFIConvertor.asIPv4Address("20.20.20.1"), "1.2.3.4");
1329 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1330 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4);
1332 ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1333 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1337 public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1339 String ipString = "10.20.30.200";
1340 String macString = "01:02:03:04:05:06";
1341 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1342 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1343 LcafKeyValueAddressAddrBuilder builder = new LcafKeyValueAddressAddrBuilder();
1344 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1345 builder.setLcafType((short) LispCanonicalAddressFormatEnum.KEY_VALUE.getLispCode());
1346 builder.setKey(new KeyBuilder().setPrimitiveAddress(addrToSend1).build());
1347 builder.setValue(new ValueBuilder().setPrimitiveAddress(addrToSend2).build());
1349 MapReply reply = registerAddressAndQuery(builder.build());
1351 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1352 assertTrue(fromNetwork.getAddress() instanceof LcafKeyValue);
1353 LcafKeyValue keyValueFromNetwork = (LcafKeyValue) fromNetwork.getAddress();
1355 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress());
1356 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getValue().getPrimitiveAddress());
1358 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1359 assertTrue(receivedAddr2 instanceof LispMacAddress);
1361 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1362 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1364 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1365 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1368 public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1370 String macString = "01:02:03:04:05:06";
1371 String ipString = "10.20.255.30";
1372 LcafListAddrBuilder listbuilder = new LcafListAddrBuilder();
1373 listbuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.LIST.getLispCode());
1374 listbuilder.setAddresses(new ArrayList<Addresses>());
1375 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1376 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString))).build());
1378 MapReply reply = registerAddressAndQuery(listbuilder.build());
1380 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1382 assertTrue(receivedAddress instanceof LcafListAddress);
1384 LcafListAddress listAddrFromNetwork = (LcafListAddress) receivedAddress;
1385 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(0).getPrimitiveAddress());
1386 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(1).getPrimitiveAddress());
1388 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1389 assertTrue(receivedAddr2 instanceof LispMacAddress);
1391 assertEquals(macString, ((LispMacAddress) receivedAddr2).getMacAddress().getValue());
1392 assertEquals(ipString, ((LispIpv4Address) receivedAddr1).getIpv4Address().getValue());
1395 public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1397 String ipString = "10.20.255.30";
1399 LcafSegmentAddrBuilder builder = new LcafSegmentAddrBuilder();
1400 builder.setInstanceId((long) instanceId);
1401 builder.setIidMaskLength((short) 32);
1402 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.SEGMENT.getLispCode());
1403 builder.setAddress(new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1405 MapReply reply = registerAddressAndQuery(builder.build());
1407 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1408 assertTrue(receivedAddress instanceof LcafSegmentAddress);
1410 LcafSegmentAddress segmentfromNetwork = (LcafSegmentAddress) receivedAddress;
1411 LispAFIAddress addrFromSegment = LispAFIConvertor.toAFIfromPrimitive(segmentfromNetwork.getAddress().getPrimitiveAddress());
1412 assertTrue(addrFromSegment instanceof LispIpv4Address);
1413 assertEquals(ipString, ((LispIpv4Address) addrFromSegment).getIpv4Address().getValue());
1415 assertEquals(instanceId, segmentfromNetwork.getInstanceId().intValue());
1418 public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1420 String macString = "01:02:03:04:05:06";
1421 String ipString = "10.20.255.30";
1422 HopBuilder hopBuilder = new HopBuilder();
1423 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString)));
1424 Hop hop1 = hopBuilder.build();
1425 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString)));
1426 Hop hop2 = hopBuilder.build();
1427 HopsBuilder hb = new HopsBuilder();
1430 hb.setRLOCProbe(false);
1432 HopsBuilder hb2 = new HopsBuilder();
1434 hb2.setLookup(false);
1435 hb2.setRLOCProbe(true);
1436 hb2.setStrict(false);
1437 Hops hops1 = hb.build();
1438 Hops hops2 = hb2.build();
1439 LcafTrafficEngineeringAddrBuilder trafficBuilder = new LcafTrafficEngineeringAddrBuilder();
1440 trafficBuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType(
1441 (short) LispCanonicalAddressFormatEnum.TRAFFIC_ENGINEERING.getLispCode());
1442 trafficBuilder.setHops(new ArrayList<Hops>());
1443 trafficBuilder.getHops().add(hb.build());
1444 trafficBuilder.getHops().add(hb2.build());
1446 MapReply reply = registerAddressAndQuery(trafficBuilder.build());
1448 assertTrue(LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer()) instanceof LcafTrafficEngineeringAddress);
1450 LcafTrafficEngineeringAddress receivedAddress = (LcafTrafficEngineeringAddress) LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0)
1451 .getLispAddressContainer());
1453 ReencapHop receivedHop1 = receivedAddress.getHops().get(0);
1454 ReencapHop receivedHop2 = receivedAddress.getHops().get(1);
1456 assertEquals(true, hops1.isLookup());
1457 assertEquals(false, hops1.isRLOCProbe());
1458 assertEquals(true, hops1.isStrict());
1460 assertEquals(false, hops2.isLookup());
1461 assertEquals(true, hops2.isRLOCProbe());
1462 assertEquals(false, hops2.isStrict());
1464 assertTrue(receivedHop1.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4);
1465 assertTrue(receivedHop2.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Mac);
1467 assertEquals(ipString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Ipv4) receivedHop1.getHop().getPrimitiveAddress()).getIpv4Address().getIpv4Address().getValue());
1468 assertEquals(macString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispsimpleaddress.primitiveaddress.Mac) receivedHop2.getHop().getPrimitiveAddress()).getMacAddress().getMacAddress().getValue());
1471 public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1473 String ipString = "1.2.3.4";
1476 int localPortLow = 3;
1477 int localPortHigh = 4;
1478 int remotePortLow = 4;
1479 int remotePortHigh = 5;
1481 LcafApplicationDataAddrBuilder builder = new LcafApplicationDataAddrBuilder();
1482 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode());
1483 builder.setIpTos(ipTOs);
1484 builder.setProtocol(protocol);
1485 builder.setLocalPortLow(new PortNumber(localPortLow));
1486 builder.setLocalPortHigh(new PortNumber(localPortHigh));
1487 builder.setRemotePortLow(new PortNumber(remotePortLow));
1488 builder.setRemotePortHigh(new PortNumber(remotePortHigh));
1489 builder.setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafapplicationdataaddress.AddressBuilder()
1490 .setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1492 LcafApplicationDataAddress addressToSend = builder.build();
1494 MapReply reply = registerAddressAndQuery(addressToSend);
1496 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1498 assertTrue(receivedAddress instanceof LcafApplicationDataAddress);
1500 LcafApplicationDataAddress receivedApplicationDataAddress = (LcafApplicationDataAddress) receivedAddress;
1501 assertEquals(protocol, receivedApplicationDataAddress.getProtocol().intValue());
1502 assertEquals(ipTOs, receivedApplicationDataAddress.getIpTos().intValue());
1503 assertEquals(localPortLow, receivedApplicationDataAddress.getLocalPortLow().getValue().intValue());
1504 assertEquals(localPortHigh, receivedApplicationDataAddress.getLocalPortHigh().getValue().intValue());
1505 assertEquals(remotePortLow, receivedApplicationDataAddress.getRemotePortLow().getValue().intValue());
1506 assertEquals(remotePortHigh, receivedApplicationDataAddress.getRemotePortHigh().getValue().intValue());
1508 LispIpv4Address ipAddressReceived = (LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(receivedApplicationDataAddress.getAddress().getPrimitiveAddress());
1509 assertEquals(ipString, ipAddressReceived.getIpv4Address().getValue());
1512 // ------------------- TimeOut Tests -----------
1514 public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1516 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1517 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1518 mapRequestBuilder.setNonce((long) 4);
1519 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1520 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1521 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1522 mapRequestBuilder.getEidRecord().add(
1523 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1524 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1525 mapRequestBuilder.getItrRloc().add(
1526 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1528 sendMapRequest(mapRequestBuilder.build());
1529 MapReply mapReply = receiveMapReply();
1530 assertEquals(4, mapReply.getNonce().longValue());
1531 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1533 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1534 mapRegisterbuilder.setWantMapNotify(true);
1535 mapRegisterbuilder.setNonce((long) 8);
1537 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1538 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1539 etlrBuilder.setMaskLength((short) 32);
1540 etlrBuilder.setRecordTtl(254);
1542 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1543 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
1544 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1545 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1546 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1547 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1549 sendMapRegister(mapRegisterbuilder.build());
1550 MapNotify mapNotify = receiveMapNotify();
1551 assertEquals(8, mapNotify.getNonce().longValue());
1553 sendMapRequest(mapRequestBuilder.build());
1554 mapReply = receiveMapReply();
1555 assertEquals(4, mapReply.getNonce().longValue());
1556 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1557 .getLispAddressContainer());
1559 causeEntryToBeCleaned();
1560 sendMapRequest(mapRequestBuilder.build());
1561 mapReply = receiveMapReply();
1562 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1565 public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1567 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1568 MapRequest mapRequest = createMapRequest(eid);
1570 testTTLBeforeRegister(mapRequest);
1572 registerForTTL(eid);
1574 testTTLAfterRegister(mapRequest);
1576 causeEntryToBeCleaned();
1577 testTTLAfterClean(mapRequest);
1579 //northboundAddKey();
1580 //testTTLAfterAutherize(mapRequest);
1584 private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1586 sendMapRequest(mapRequest);
1587 mapReply = receiveMapReply();
1588 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1591 private void causeEntryToBeCleaned() {
1592 // TODO XXX for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1593 // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1594 // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1595 mapService.cleanCachedMappings();
1598 private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1600 sendMapRequest(mapRequest);
1601 mapReply = receiveMapReply();
1602 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1603 .getLispAddressContainer());
1604 assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1607 private void registerForTTL(LispIpv4Address eid) throws SocketTimeoutException {
1608 MapRegister mapRegister = createMapRegister(eid);
1609 sendMapRegister(mapRegister);
1610 assertMapNotifyRecieved();
1613 private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1615 sendMapRequest(mapRequest);
1616 mapReply = receiveMapReply();
1617 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1620 private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1622 sendMapRequest(mapRequest);
1623 mapReply = receiveMapReply();
1624 assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1627 private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1628 assertEquals(expectedTTL, mapReply.getEidToLocatorRecord().get(0).getRecordTtl().intValue());
1629 assertEquals(expectedAction, mapReply.getEidToLocatorRecord().get(0).getAction());
1632 private MapRegister createMapRegister(LispAFIAddress eid, LispAFIAddress rloc) {
1633 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1634 mapRegisterbuilder.setWantMapNotify(true);
1635 mapRegisterbuilder.setNonce((long) 8);
1636 mapRegisterbuilder.setKeyId((short) 0);
1637 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1638 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1639 etlrBuilder.setMaskLength((short) 24);
1640 etlrBuilder.setRecordTtl(254);
1641 etlrBuilder.setAuthoritative(false);
1642 etlrBuilder.setAction(Action.NoAction);
1643 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1644 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
1645 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1646 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1647 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1648 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1649 MapRegister mapRegister = mapRegisterbuilder.build();
1653 private MapRegister createMapRegister(LispIpv4Address eid) {
1654 return createMapRegister(eid, LispAFIConvertor.asIPAfiAddress("4.3.2.1"));
1657 private MapRequest createMapRequest(LispAFIAddress eid) {
1658 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1659 mapRequestBuilder.setNonce((long) 4);
1660 mapRequestBuilder.setPitr(false);
1661 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1662 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1663 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1664 mapRequestBuilder.getEidRecord().add(
1665 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1666 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1667 mapRequestBuilder.getItrRloc().add(
1668 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1669 MapRequest mr = mapRequestBuilder.build();
1673 public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1675 String rloc = "127.0.0.3";
1676 int port = LispMessage.PORT_NUM;
1677 LispAFIAddress ipRloc = LispAFIConvertor.asIPAfiAddress(rloc);
1678 sendProxyMapRequest(rloc, port, ipRloc);
1682 public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1684 String rloc = "127.0.0.3";
1686 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1687 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1688 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1690 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1691 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPortLow(new PortNumber(port)).build();
1692 LOG.info("testNonProxyOtherPort:" + adLcaf.toString());
1693 sendProxyMapRequest(rloc, port, adLcaf);
1697 public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
1699 configLispPlugin.shouldListenOnXtrPort(true);
1700 notificationCalled = false;
1701 final String eid = "10.10.10.10";
1702 String rloc = "127.0.0.3";
1703 int port = LispMessage.XTR_PORT_NUM;
1704 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1705 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1706 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1708 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1709 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPortLow(new PortNumber(port)).build();
1710 final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1711 ((LispMappingService) lms).registerNotificationListener(XtrRequestMapping.class, new NotificationListener<XtrRequestMapping>() {
1714 public void onNotification(XtrRequestMapping notification) {
1715 assertEquals(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.Ipv4) mapRequest.getEidRecord().get(0).getLispAddressContainer().getAddress()).getIpv4Address().getIpv4Address().getValue(),
1717 notificationCalled = true;
1718 LOG.warn("notification arrived");
1721 sendMapRequest(mapRequest, port);
1722 for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
1723 if (notificationCalled) {
1726 LOG.warn("notification hasn't arrived, sleeping...");
1731 fail("Notification hasn't arrived");
1735 private void sendProxyMapRequest(String rloc, int port, LispAFIAddress adLcaf) throws SocketTimeoutException, SocketException {
1736 String eid = "10.1.0.1";
1737 MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1738 sendMapRequest(mapRequest);
1739 DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
1740 MapRequest recievedMapRequest = receiveMapRequest(nonProxySocket);
1741 assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
1742 assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
1743 assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
1744 assertEquals(mapRequest.getEidRecord(), recievedMapRequest.getEidRecord());
1745 nonProxySocket.close();
1748 private MapRequest createNonProxyMapRequest(String eid, LispAFIAddress adLcaf) throws SocketTimeoutException {
1749 MapRegister mr = createMapRegister(LispAFIConvertor.asIPAfiAddress(eid));
1750 LocatorRecord record = new LocatorRecordBuilder(mr.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)).setLispAddressContainer(
1751 LispAFIConvertor.toContainer(adLcaf)).build();
1752 mr.getEidToLocatorRecord().get(0).getLocatorRecord().set(0, record);
1753 sendMapRegister(mr);
1754 assertMapNotifyRecieved();
1755 MapRequest mapRequest = createMapRequest(LispAFIConvertor.asIPAfiAddress(eid));
1756 MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
1757 builder.setPitr(true);
1758 mapRequest = builder.build();
1762 private void assertMapNotifyRecieved() throws SocketTimeoutException {
1766 private MapReply receiveMapReply() throws SocketTimeoutException {
1767 return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1770 private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
1771 return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(datagramSocket, 30000).getData()));
1774 private MapNotify receiveMapNotify() throws SocketTimeoutException {
1775 return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1778 private void sendMapRequest(MapRequest mapRequest) {
1779 sendMapRequest(mapRequest, LispMessage.PORT_NUM);
1782 private void sendMapRequest(MapRequest mapRequest, int port) {
1783 sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
1786 private void sendMapRegister(MapRegister mapRegister) {
1787 sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
1790 private void sendPacket(byte[] bytesToSend) {
1791 sendPacket(bytesToSend, LispMessage.PORT_NUM);
1794 private void sendPacket(byte[] bytesToSend, int port) {
1796 DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
1797 initPacketAddress(packet, port);
1798 LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
1799 socket.send(packet);
1800 } catch (Throwable t) {
1805 private DatagramPacket receivePacket() throws SocketTimeoutException {
1806 return receivePacket(6000);
1809 private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
1810 return receivePacket(socket, timeout);
1813 private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
1815 byte[] buffer = new byte[4096];
1816 DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
1817 LOG.trace("Waiting for packet from socket...");
1818 receivedSocket.setSoTimeout(timeout);
1819 receivedSocket.receive(receivePacket);
1820 LOG.trace("Recieved packet from socket!");
1821 return receivePacket;
1822 } catch (SocketTimeoutException ste) {
1824 } catch (Throwable t) {
1831 private void sleepForSeconds(int seconds) {
1833 Thread.sleep(seconds*1000);
1834 } catch (InterruptedException e) {
1835 LOG.warn("Interrupted while sleeping");
1836 e.printStackTrace();
1840 private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
1841 packet.setAddress(InetAddress.getByName(lispBindAddress));
1842 packet.setPort(port);
1845 private DatagramSocket initSocket(DatagramSocket socket, int port) {
1847 socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
1848 } catch (SocketException e) {
1849 e.printStackTrace();
1855 private byte[] extractWSUdpByteArray(String wiresharkHex) {
1856 final int HEADER_LEN = 42;
1857 byte[] res = new byte[1000];
1858 String[] split = wiresharkHex.split(" ");
1860 for (String cur : split) {
1862 if (cur.length() == 2) {
1864 if (counter > HEADER_LEN) {
1865 res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
1870 return Arrays.copyOf(res, counter - HEADER_LEN);
1873 private String stateToString(int state) {
1877 case Bundle.INSTALLED:
1879 case Bundle.RESOLVED:
1881 case Bundle.UNINSTALLED:
1882 return "UNINSTALLED";
1884 return "Not CONVERTED";
1888 @SuppressWarnings({ "rawtypes", "unchecked" })
1889 private void areWeReady() throws InvalidSyntaxException {
1892 } catch (InterruptedException e) {
1896 boolean debugit = false;
1897 Bundle b[] = bc.getBundles();
1898 for (Bundle element : b) {
1899 int state = element.getState();
1900 LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v" + element.getVersion() + ", state:"
1901 + stateToString(state));
1902 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
1903 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
1906 // String host = element.getHeaders().get("FRAGMENT-HOST");
1907 // if (host != null) {
1908 // LOG.warn("Bundle " + element.getSymbolicName() +
1909 // " is a fragment which is part of: " + host);
1910 // LOG.warn("Required imports are: " +
1911 // element.getHeaders().get("IMPORT-PACKAGE"));
1915 // } catch (BundleException e) {
1916 // LOG.error("BundleException:", e);
1925 LOG.warn(("Do some debugging because some bundle is unresolved"));
1927 // assertNotNull(broker);
1929 ServiceReference r = null;
1930 configLispPlugin.setLispAddress(lispBindAddress);
1932 // Uncomment this code to Know which services were actually loaded to
1936 for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
1937 LOG.info(sr.getBundle().getSymbolicName());
1938 LOG.info(sr.toString());
1944 } catch (InterruptedException e) {
1948 private void cleanUP() {
1950 mapService.cleanCachedMappings();;
1951 configLispPlugin.shouldListenOnXtrPort(false);
1952 socket = initSocket(socket, LispMessage.PORT_NUM);