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.implementation.serializer.LispMessage;
54 import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
55 import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
56 import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
57 import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
58 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
59 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
60 import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
61 import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
62 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSegmentAddress;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispIpv4Address;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispMacAddress;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.ReencapHop;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.XtrRequestMapping;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.ValueBuilder;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.Addresses;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.AddressesBuilder;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.SrcAddressBuilder;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.Hops;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.HopsBuilder;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddrBuilder;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaflist.LcafListAddrBuilder;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaftrafficengineering.LcafTrafficEngineeringAddrBuilder;
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
107 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
108 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
109 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
110 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.Hop;
111 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.HopBuilder;
112 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
113 import org.ops4j.pax.exam.Option;
114 import org.ops4j.pax.exam.junit.PaxExam;
115 import org.ops4j.pax.exam.util.Filter;
116 import org.ops4j.pax.exam.karaf.options.LogLevelOption.LogLevel;
117 import org.ops4j.pax.exam.options.MavenUrlReference;
118 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
119 import org.ops4j.pax.exam.spi.reactors.PerClass;
120 import org.osgi.framework.Bundle;
121 import org.osgi.framework.BundleContext;
122 import org.osgi.framework.InvalidSyntaxException;
123 import org.osgi.framework.ServiceReference;
124 import org.slf4j.Logger;
125 import org.slf4j.LoggerFactory;
127 @RunWith(PaxExam.class)
128 @ExamReactorStrategy(PerClass.class)
129 public class MappingServiceIntegrationTest extends AbstractMdsalTestBase {
130 private static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
132 private byte[] mapRequestPacket;
133 private byte[] mapRegisterPacketWithNotify;
134 private byte[] mapRegisterPacketWithoutNotify;
135 String lispBindAddress = "127.0.0.1";
136 String ourAddress = "127.0.0.2";
137 private LispAFIAddress locatorEid;
138 private DatagramSocket socket;
139 private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
141 public static final String ODL = "org.opendaylight.controller";
142 public static final String YANG = "org.opendaylight.yangtools";
143 public static final String JERSEY = "com.sun.jersey";
144 private static final int MAX_NOTIFICATION_RETRYS = 20;
147 public String getModuleName() {
148 return "lfm-mappingservice-impl";
152 public String getInstanceName() {
153 return "lfm-mappingservice-default";
156 // This is temporary, since the properties in the pom file are not picked up
157 // .versionAsInProject() doesn't work here, and this makes version bumping difficult
159 public String getKarafDistro() {
161 .groupId("org.opendaylight.lispflowmapping")
162 .artifactId("distribution-karaf")
163 .version("1.3.0-SNAPSHOT")
169 public MavenUrlReference getFeatureRepo() {
171 .groupId("org.opendaylight.lispflowmapping")
172 .artifactId("features-lispflowmapping")
173 .classifier("features")
175 .versionAsInProject();
179 public String getFeatureName() {
180 return "odl-lispflowmapping-all";
184 public Option getLoggingOption() {
185 Option option = editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
186 logConfiguration(MappingServiceIntegrationTest.class),
187 LogLevel.DEBUG.name());
188 option = composite(option, super.getLoggingOption());
193 public void testLispFlowMappingFeatureLoad() {
194 Assert.assertTrue(true);
198 public void after() {
199 if (socket != null) {
202 // if (connection != null) {
203 // connection.disconnect();
208 public void before() throws Exception {
210 locatorEid = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
211 socket = initSocket(socket, LispMessage.PORT_NUM);
213 // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
214 // LISP(Type = 8 - Encapsulated)
215 // IP: 192.168.136.10 -> 153.16.254.1
217 // LISP(Type = 1 Map-Request
221 // Source EID 1.2.3.4
222 // Nonce: 0x3d8d2acd39c8d608
223 // ITR-RLOC AFI=1 Address=192.168.136.10
224 // Record 1: 153.16.254.1/32
225 mapRequestPacket = extractWSUdpByteArray(new String("0000 00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
226 + "0010 00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
227 + "0020 00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
228 + "0030 00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
229 + "0040 fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
230 + "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
231 + "0060 00 01 99 10 fe 01"));
233 // IP: 192.168.136.10 -> 128.223.156.35
234 // UDP: 49289 -> 4342
235 // LISP(Type = 3 Map-Register, P=1, M=1
239 // AuthDataLength: 20 Data:
240 // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
241 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
243 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
244 // Priority/Weight: 1/100, Multicast Priority/Weight:
248 mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
249 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
250 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
251 + "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
252 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
253 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
254 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
256 // IP: 192.168.136.10 -> 128.223.156.35
257 // UDP: 49289 -> 4342
258 // LISP(Type = 3 Map-Register, P=1, M=1
261 // Key ID: 0x0000 NO AUTHENTICATION!!
262 // AuthDataLength: 00 Data:
263 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
265 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
266 // Priority/Weight: 1/100, Multicast Priority/Weight:
270 mapRegisterPacketWithNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
271 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
272 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
273 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
274 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
275 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
276 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
278 // IP: 192.168.136.10 -> 128.223.156.35
279 // UDP: 49289 -> 4342
280 // LISP(Type = 3 Map-Register, P=1, M=1
283 // Key ID: 0x0000 NO AUTHENTICATION!!
284 // AuthDataLength: 00 Data:
285 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
287 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
288 // Priority/Weight: 1/100, Multicast Priority/Weight:
292 mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
293 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
294 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
295 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
296 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
297 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
298 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
302 private BundleContext bc;
303 private HttpURLConnection connection;
304 protected static boolean notificationCalled;
306 @Inject @Filter(timeout=60000)
307 private IFlowMapping lms;
309 @Inject @Filter(timeout=10000)
310 private IConfigLispSouthboundPlugin configLispPlugin;
313 public void testSimpleUsage() throws Exception {
315 mapRegisterWithMapNotify();
316 mapRegisterWithMapNotifyAndMapRequest();
317 registerAndQuery__MAC();
318 mapRequestMapRegisterAndMapRequest();
319 mapRegisterWithAuthenticationWithoutConfiguringAKey();
320 mapRegisterWithoutMapNotify();
324 public void testLCAFs() throws Exception {
325 //registerAndQuery__SrcDestLCAF();
326 //registerAndQuery__SrcDestLCAFOverlap();
327 //registerAndQuery__KeyValueLCAF();
328 registerAndQuery__ListLCAF();
329 registerAndQuery__ApplicationData();
330 registerAndQuery__TrafficEngineering();
331 registerAndQuery__SegmentLCAF();
335 public void testMask() throws Exception {
336 //testPasswordExactMatch(); TODO commented because it needs NB
337 //testPasswordMaskMatch(); TODO commented because it needs NB
338 eidPrefixLookupIPv4();
339 eidPrefixLookupIPv6();
343 public void testNorthbound() throws Exception {
345 northboundAddMapping();
346 northboundDeleteMapping();
347 northboundRetrieveKey();
348 northboundRetrieveMapping();
349 northboundRetrieveSourceDestKey();
350 northboundRetrieveSourceDestMapping();
354 public void testOverWriting() throws Exception {
355 //testMapRegisterDosntOverwritesOtherSubKeys(); TODO weird failure, needs debug
356 testMapRegisterOverwritesSameSubkey();
357 testMapRegisterOverwritesNoSubkey();
358 testMapRegisterDoesntOverwritesNoSubkey();
362 public void testTimeOuts() throws Exception {
363 mapRequestMapRegisterAndMapRequestTestTimeout();
364 //mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse(); TODO commented because it needs NB
368 // public void testNonProxy() throws Throwable {
369 // testSimpleNonProxy();
370 // testNonProxyOtherPort();
371 // testRecievingNonProxyOnXtrPort();
375 public void testSmr() throws Exception {
376 registerQueryRegisterWithSmr();
379 // ------------------------------- Simple Tests ---------------------------
381 public void mapRequestSimple() throws SocketTimeoutException {
384 // This Map-Request is sent from a source port different from 4342
385 // We close and bind the socket on the correct port
386 if (socket != null) {
389 socket = initSocket(socket, 56756);
391 sendPacket(mapRequestPacket);
392 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
393 MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
394 assertEquals(4435248268955932168L, reply.getNonce().longValue());
398 public void mapRegisterWithMapNotify() throws SocketTimeoutException {
400 sendPacket(mapRegisterPacketWithNotify);
401 MapNotify reply = receiveMapNotify();
402 assertEquals(7, reply.getNonce().longValue());
405 public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
407 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
409 MapReply mapReply = registerAddressAndQuery(eid, 32);
411 assertEquals(4, mapReply.getNonce().longValue());
412 assertEquals(LispAFIConvertor.toContainer(locatorEid), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
413 .getLispAddressContainer());
417 public void registerAndQuery__MAC() throws SocketTimeoutException {
419 String macAddress = "01:02:03:04:05:06";
421 MapReply reply = registerAddressAndQuery(LispAFIConvertor.asMacAfiAddress(macAddress));
424 LispAFIAddress addressFromNetwork = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
425 assertTrue(addressFromNetwork instanceof LispMacAddress);
426 String macAddressFromReply = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.mac.MacAddress) addressFromNetwork).getMacAddress().getValue();
428 assertEquals(macAddress, macAddressFromReply);
431 public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
433 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
434 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
435 mapRequestBuilder.setNonce((long) 4);
436 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
437 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
438 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
439 mapRequestBuilder.getEidRecord().add(
440 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
441 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
442 mapRequestBuilder.getItrRloc().add(
443 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
444 sendMapRequest(mapRequestBuilder.build());
445 MapReply mapReply = receiveMapReply();
446 assertEquals(4, mapReply.getNonce().longValue());
447 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
448 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
449 mapRegisterbuilder.setWantMapNotify(true);
450 mapRegisterbuilder.setNonce((long) 8);
451 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
452 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
453 etlrBuilder.setMaskLength((short) 32);
454 etlrBuilder.setRecordTtl(254);
455 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
456 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
457 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
458 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
459 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
460 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
461 sendMapRegister(mapRegisterbuilder.build());
462 MapNotify mapNotify = receiveMapNotify();
463 assertEquals(8, mapNotify.getNonce().longValue());
464 sendMapRequest(mapRequestBuilder.build());
465 mapReply = receiveMapReply();
466 assertEquals(4, mapReply.getNonce().longValue());
467 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
468 .getLispAddressContainer());
472 public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
474 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
475 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
476 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey1", LispAFIConvertor.toPrimitive(rloc1Value));
477 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
478 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey2", LispAFIConvertor.toPrimitive(rloc2Value));
479 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
480 assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
481 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
482 assertEquals(LispAFIConvertor.toContainer(rloc1), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer());
485 public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
487 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
488 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
489 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc1Value));
490 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
491 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc2Value));
492 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
493 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
494 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
497 public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
499 lms.setOverwrite(true);
500 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
501 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
502 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
503 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
504 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
505 assertEquals(LispAFIConvertor.toContainer(rloc2Value), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
506 .getLispAddressContainer());
509 public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
511 lms.setOverwrite(false);
512 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
513 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
514 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
515 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
516 assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
517 LispAddressContainer rloc1ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer();
518 LispAddressContainer rloc2ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer();
519 assertTrue((LispAFIConvertor.toContainer(rloc1Value).equals(rloc1ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
520 rloc2ReturnValueContainer))
521 || (LispAFIConvertor.toContainer(rloc1Value).equals(rloc2ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
522 rloc1ReturnValueContainer)));
525 private MapReply sendMapRegisterTwiceWithDiffrentValues(LispAFIAddress eid, LispAFIAddress rloc1, LispAFIAddress rloc2)
526 throws SocketTimeoutException {
527 MapRegister mb = createMapRegister(eid, rloc1);
528 MapNotify mapNotify = lms.handleMapRegister(mb, false);
529 MapRequest mr = createMapRequest(eid);
530 MapReply mapReply = lms.handleMapRequest(mr);
531 assertEquals(mb.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0)
532 .getLocatorRecord().get(0).getLispAddressContainer());
533 mb = createMapRegister(eid, rloc2);
534 mapNotify = lms.handleMapRegister(mb, false);
535 assertEquals(8, mapNotify.getNonce().longValue());
536 mr = createMapRequest(eid);
538 mapReply = lms.handleMapRequest(mr);
542 public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
544 sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
547 // If didn't timeout then fail:
549 } catch (SocketTimeoutException ste) {
553 public void mapRegisterWithoutMapNotify() {
555 sendPacket(mapRegisterPacketWithoutNotify);
558 // If didn't timeout then fail:
560 } catch (SocketTimeoutException ste) {
564 public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
566 lms.setShouldUseSmr(true);
568 sendPacket(mapRegisterPacketWithNotify);
571 sendPacket(mapRequestPacket);
574 } catch (InterruptedException e) {
577 mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
578 sendPacket(mapRegisterPacketWithoutNotify);
580 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
581 MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
582 assertTrue(smr.isSmr());
583 LispAddressContainer sourceEid = smr.getSourceEid().getLispAddressContainer();
584 assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")).equals(sourceEid));
585 LispAddressContainer smrEid = smr.getEidRecord().get(0).getLispAddressContainer();
586 assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.2.3.4")).equals(smrEid));
589 // --------------------- Northbound Tests ---------------------------
591 private void northboundAddKey() throws Exception {
593 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
595 String pass = "asdf";
597 URL url = createPutURL("key");
598 String authKeyJSON = createAuthKeyJSON(pass, address, mask);
599 callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
601 String retrievedKey = lms.getAuthenticationKey(LispAFIConvertor.toContainer(address), mask);
603 // Check stored password matches the one sent
604 assertEquals(pass, retrievedKey);
608 private void northboundRetrieveSourceDestKey() throws Exception {
610 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
611 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
612 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
613 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
616 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
617 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
618 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
619 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
620 String pass = "asdf";
622 lms.addAuthenticationKey(LispAFIConvertor.toContainer(sourceDestAddress), mask1, pass);
624 // URL url = createGetKeyIPv4URL(address1, mask1);
625 URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
626 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
627 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
628 String reply = callURL("GET", null, "application/json", null, url);
629 JSONTokener jt = new JSONTokener(reply);
630 JSONObject json = new JSONObject(jt);
632 // test that the password matches what was we expected.
633 assertEquals(pass, json.get("key"));
637 private void northboundRetrieveKey() throws Exception {
639 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
641 String pass = "asdf";
643 lms.addAuthenticationKey(LispAFIConvertor.toContainer(address), mask, pass);
645 URL url = createGetKeyIPv4URL(address, mask);
646 String reply = callURL("GET", null, "application/json", null, url);
647 JSONTokener jt = new JSONTokener(reply);
648 JSONObject json = new JSONObject(jt);
650 // test that the password matches what was we expected.
651 assertEquals(pass, json.get("key"));
655 private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
656 return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
657 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
660 private void northboundAddMapping() throws Exception {
662 String pass = "asdf";
663 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
665 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
667 // NB add mapping always checks the key
668 lms.addAuthenticationKey(LispAFIConvertor.toContainer(eid), mask, pass);
670 URL url = createPutURL("mapping");
671 String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
672 callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
674 // Retrieve the RLOC from the database
675 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
676 mapRequestBuilder.setPitr(false);
677 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
678 mapRequestBuilder.getEidRecord().add(
679 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
680 MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
682 LispIpv4Address retrievedRloc = (LispIpv4Address) LispAFIConvertor.toAFI(
683 mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
685 assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
689 private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
690 String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ " + "\"proxyMapReply\" : false, "
691 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : " + "{ " + "\"ipAddress\" : \""
692 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "}," + "\"mapVersion\" : 0,"
693 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ " + "\"multicastPriority\" : 1,"
694 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\"," + "\"afi\" : "
695 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50," + "\"rlocProbed\" : false, "
696 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], " + "\"recordTtl\" : 100" + "} " + "], "
697 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
702 private void northboundRetrieveMapping() throws Exception {
704 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
706 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
707 // Insert mapping in the database
708 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
709 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
710 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
711 etlr.setMaskLength((short) mask);
712 etlr.setRecordTtl(254);
713 etlr.setAuthoritative(false);
714 etlr.setAction(Action.NoAction);
715 LocatorRecordBuilder record = new LocatorRecordBuilder();
716 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
717 record.setRouted(true);
718 record.setRlocProbed(false);
719 record.setLocalLocator(false);
720 record.setPriority((short) 1);
721 record.setWeight((short) 50);
722 record.setMulticastPriority((short) 1);
723 record.setMulticastWeight((short) 1);
724 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
725 etlr.getLocatorRecord().add(record.build());
726 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
727 mapRegister.getEidToLocatorRecord().add(etlr.build());
728 lms.handleMapRegister(mapRegister.build(), false);
730 // Get mapping using NB interface. No IID used
731 URL url = createGetMappingIPv4URL(0, eid, mask);
732 String reply = callURL("GET", null, "application/json", null, url);
733 JSONTokener jt = new JSONTokener(reply);
734 JSONObject json = new JSONObject(jt);
736 // With just one locator, locators is not a JSONArray
737 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
739 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
743 private void northboundDeleteMapping() throws Exception {
745 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
747 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
748 // Insert mapping in the database
749 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
750 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
751 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
752 etlr.setMaskLength((short) mask);
753 etlr.setRecordTtl(254);
754 etlr.setAuthoritative(false);
755 etlr.setAction(Action.NoAction);
756 LocatorRecordBuilder record = new LocatorRecordBuilder();
757 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
758 record.setRouted(true);
759 record.setRlocProbed(false);
760 record.setLocalLocator(false);
761 record.setPriority((short) 1);
762 record.setWeight((short) 50);
763 record.setMulticastPriority((short) 1);
764 record.setMulticastWeight((short) 1);
765 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
766 etlr.getLocatorRecord().add(record.build());
767 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
768 mapRegister.getEidToLocatorRecord().add(etlr.build());
769 lms.handleMapRegister(mapRegister.build(), false);
771 // Delete mapping using NB interface. No IID used
772 URL url = createDeleteMappingIPv4URL(0, eid, mask);
773 String reply = callURL("DELETE", null, "application/json", null, url);
775 // Get mapping using NB interface. No IID used
776 url = createGetMappingIPv4URL(0, eid, mask);
777 reply = callURL("GET", null, "application/json", null, url);
778 JSONTokener jt = new JSONTokener(reply);
779 JSONObject json = new JSONObject(jt);
781 // With just one locator, locators is not a JSONArray
782 assertEquals(json.getJSONArray("locators").length(), 0);
785 private void northboundRetrieveSourceDestMapping() throws Exception {
787 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address1 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
788 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
789 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 address2 = (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) LispAFIConvertor
790 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
793 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
794 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
795 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
796 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
797 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
799 // Insert mapping in the database
800 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
801 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
802 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(sourceDestAddress));
803 etlr.setMaskLength((short) mask1);
804 etlr.setRecordTtl(254);
805 etlr.setAuthoritative(false);
806 etlr.setAction(Action.NoAction);
807 LocatorRecordBuilder record = new LocatorRecordBuilder();
808 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
809 record.setRouted(true);
810 record.setRlocProbed(false);
811 record.setLocalLocator(false);
812 record.setPriority((short) 1);
813 record.setWeight((short) 50);
814 record.setMulticastPriority((short) 1);
815 record.setMulticastWeight((short) 1);
816 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
817 etlr.getLocatorRecord().add(record.build());
818 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
819 mapRegister.getEidToLocatorRecord().add(etlr.build());
820 lms.handleMapRegister(mapRegister.build(), false);
822 // Get mapping using NB interface. No IID used
823 URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
824 address1.getIpv4Address().getIpv4Address().getValue(),
826 address2.getIpv4Address().getIpv4Address().getValue(),
828 String reply = callURL("GET", null, "application/json", null, url);
829 JSONTokener jt = new JSONTokener(reply);
830 JSONObject json = new JSONObject(jt);
832 // With just one locator, locators is not a JSONArray
833 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
835 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
839 private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
840 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key", address.getAfi().shortValue(),
841 address.getIpv4Address().getValue(), mask);
842 URL url = new URL(restUrl);
846 private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
847 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "key", afi, srcAddress, srcMask,
848 dstAddress, dstMask);
849 URL url = new URL(restUrl);
853 private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
854 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "mapping", afi, srcAddress,
855 srcMask, dstAddress, dstMask);
856 URL url = new URL(restUrl);
860 private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
861 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
862 .shortValue(), address.getIpv4Address().getValue(), mask);
863 URL url = new URL(restUrl);
867 private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
868 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
869 .shortValue(), address.getIpv4Address().getValue(), mask);
870 URL url = new URL(restUrl);
874 private URL createPutURL(String resource) throws MalformedURLException {
876 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
878 URL url = new URL(restUrl);
882 private String createAuthenticationString() {
883 String authString = "admin:admin";
884 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
885 String authStringEnc = new String(authEncBytes);
886 return authStringEnc;
889 private String callURL(String method, String content, String accept, String body, URL url) throws IOException, JSONException {
890 String authStringEnc = createAuthenticationString();
891 connection = (HttpURLConnection) url.openConnection();
892 connection.setRequestMethod(method);
893 connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
894 if (content != null) {
895 connection.setRequestProperty("Content-Type", content);
897 if (accept != null) {
898 connection.setRequestProperty("Accept", accept);
901 // now add the request body
902 connection.setDoOutput(true);
903 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
907 connection.connect();
909 // getting the result, first check response code
910 Integer httpResponseCode = connection.getResponseCode();
912 if (httpResponseCode > 299) {
913 LOG.trace("HTTP Address: " + url);
914 LOG.trace("HTTP Response Code: " + httpResponseCode);
918 InputStream is = connection.getInputStream();
919 BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
920 StringBuilder sb = new StringBuilder();
922 while ((cp = rd.read()) != -1) {
923 sb.append((char) cp);
926 connection.disconnect();
927 return (sb.toString());
930 // timePeriod - in ms
931 public void assertNoPacketReceived(int timePeriod) {
933 receivePacket(timePeriod);
934 // If didn't timeout then fail:
936 } catch (SocketTimeoutException ste) {
940 // ------------------------------- Mask Tests ---------------------------
942 public void eidPrefixLookupIPv4() throws SocketTimeoutException {
944 runPrefixTest(LispAFIConvertor.asIPAfiAddress("1.2.3.4"), 16, LispAFIConvertor.asIPAfiAddress("1.2.3.2"),
945 LispAFIConvertor.asIPAfiAddress("1.1.1.1"), (byte) 32);
948 public void eidPrefixLookupIPv6() throws SocketTimeoutException {
950 runPrefixTest(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8"), 64, LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:1:2:3"),
951 LispAFIConvertor.asIPv6AfiAddress("1:2:3:1:2:3:1:2"), 128);
954 private void runPrefixTest(LispAFIAddress registerEID, int registerdMask, LispAFIAddress matchedAddress, LispAFIAddress unMatchedAddress, int mask)
955 throws SocketTimeoutException {
957 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
958 mapRegister.setWantMapNotify(true);
959 mapRegister.setNonce((long) 8);
960 mapRegister.setWantMapNotify(true);
961 mapRegister.setKeyId((short) 0);
962 mapRegister.setAuthenticationData(new byte[0]);
963 mapRegister.setNonce((long) 8);
964 mapRegister.setProxyMapReply(false);
965 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
966 etlr.setRecordTtl(254);
967 etlr.setAction(Action.NoAction);
968 etlr.setAuthoritative(false);
969 etlr.setMapVersion((short) 0);
970 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(registerEID));
971 etlr.setMaskLength((short) registerdMask);
972 etlr.setRecordTtl(254);
973 LocatorRecordBuilder record = new LocatorRecordBuilder();
974 record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
975 record.setLocalLocator(false);
976 record.setRlocProbed(false);
977 record.setRouted(true);
978 record.setMulticastPriority((short) 0);
979 record.setMulticastWeight((short) 0);
980 record.setPriority((short) 0);
981 record.setWeight((short) 0);
982 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
983 etlr.getLocatorRecord().add(record.build());
984 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
985 mapRegister.getEidToLocatorRecord().add(etlr.build());
986 sendMapRegister(mapRegister.build());
987 MapNotify mapNotify = receiveMapNotify();
988 assertEquals(8, mapNotify.getNonce().longValue());
989 MapRequestBuilder mapRequest = new MapRequestBuilder();
990 mapRequest.setNonce((long) 4);
991 mapRequest.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
992 mapRequest.setEidRecord(new ArrayList<EidRecord>());
993 mapRequest.setAuthoritative(false);
994 mapRequest.setMapDataPresent(false);
995 mapRequest.setPitr(false);
996 mapRequest.setProbe(false);
997 mapRequest.setSmr(false);
998 mapRequest.setSmrInvoked(false);
999 mapRequest.getEidRecord().add(
1000 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(matchedAddress)).build());
1001 mapRequest.setItrRloc(new ArrayList<ItrRloc>());
1002 mapRequest.getItrRloc().add(
1003 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1004 sendMapRequest(mapRequest.build());
1005 MapReply mapReply = receiveMapReply();
1006 assertEquals(4, mapReply.getNonce().longValue());
1007 assertEquals(record.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
1008 mapRequest.setEidRecord(new ArrayList<EidRecord>());
1009 mapRequest.getEidRecord().add(
1010 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(unMatchedAddress)).build());
1011 sendMapRequest(mapRequest.build());
1012 mapReply = receiveMapReply();
1013 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1016 // This registers an IP with a MapRegister, then adds a password via the
1017 // northbound REST API
1018 // and checks that the password works
1019 public void testPasswordExactMatch() throws Exception {
1021 String ipString = "10.0.0.1";
1022 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress(ipString);
1024 String pass = "pass";
1026 URL url = createPutURL("key");
1028 String jsonAuthData = createAuthKeyJSON(pass, address, mask);
1030 LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
1031 LOG.trace("Address: " + address);
1033 byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232, (byte) 31, (byte) 249, (byte) 87,
1034 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53, (byte) 196, (byte) 62 };
1036 byte[] zeros = new byte[20];
1038 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1040 // build a MapRegister
1041 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1042 mapRegister.setWantMapNotify(true);
1043 mapRegister.setNonce((long) 8);
1044 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1045 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(address));
1046 etlr.setMaskLength((short) mask);
1047 etlr.setRecordTtl(254);
1048 LocatorRecordBuilder record = new LocatorRecordBuilder();
1049 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1050 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1051 etlr.getLocatorRecord().add(record.build());
1052 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1053 mapRegister.getEidToLocatorRecord().add(etlr.build());
1055 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1056 mapRegister.setAuthenticationData(zeros);
1058 sendMapRegister(mapRegister.build());
1059 assertNoPacketReceived(3000);
1061 mapRegister.setAuthenticationData(expectedSha);
1063 sendMapRegister(mapRegister.build());
1065 assertMapNotifyRecieved();
1068 public void testPasswordMaskMatch() throws Exception {
1070 LispIpv4Address addressInRange = LispAFIConvertor.asIPAfiAddress("10.20.30.40");
1071 LispIpv4Address addressOutOfRange = LispAFIConvertor.asIPAfiAddress("20.40.30.40");
1072 LispIpv4Address range = LispAFIConvertor.asIPAfiAddress("10.20.30.0");
1075 String pass = "pass";
1077 URL url = createPutURL("key");
1078 String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1080 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1081 // build a MapRegister
1082 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1084 mapRegister.setWantMapNotify(true);
1085 mapRegister.setNonce((long) 8);
1086 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1087 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressInRange));
1088 etlr.setMaskLength((short) mask);
1089 etlr.setRecordTtl(254);
1090 LocatorRecordBuilder record = new LocatorRecordBuilder();
1091 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1092 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1093 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1094 etlr.getLocatorRecord().add(record.build());
1095 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1096 mapRegister.getEidToLocatorRecord().add(etlr.build());
1098 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1100 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4, -67, -113, 104, -110, -71 });
1102 sendMapRegister(mapRegister.build());
1104 assertMapNotifyRecieved();
1106 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressOutOfRange));
1108 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123, -71, -14, -99, 67, -23, -73 });
1110 sendMapRegister(mapRegister.build());
1111 assertNoPacketReceived(3000);
1114 private MapReply registerAddressAndQuery(LispAFIAddress eid) throws SocketTimeoutException {
1115 return registerAddressAndQuery(eid, -1);
1118 // takes an address, packs it in a MapRegister and sends it
1119 private void registerAddress(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1120 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1121 mapRegisterBuilder.setWantMapNotify(true);
1122 mapRegisterBuilder.setKeyId((short) 0);
1123 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1124 mapRegisterBuilder.setNonce((long) 8);
1125 mapRegisterBuilder.setProxyMapReply(false);
1126 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1127 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1128 if (maskLength != -1) {
1129 etlrBuilder.setMaskLength((short) maskLength);
1131 etlrBuilder.setMaskLength((short) 0);
1133 etlrBuilder.setRecordTtl(254);
1134 etlrBuilder.setAction(Action.NoAction);
1135 etlrBuilder.setAuthoritative(false);
1136 etlrBuilder.setMapVersion((short) 0);
1137 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1138 recordBuilder.setLocalLocator(false);
1139 recordBuilder.setRlocProbed(false);
1140 recordBuilder.setRouted(true);
1141 recordBuilder.setMulticastPriority((short) 0);
1142 recordBuilder.setMulticastWeight((short) 0);
1143 recordBuilder.setPriority((short) 0);
1144 recordBuilder.setWeight((short) 0);
1145 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1146 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1147 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1148 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1149 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1150 sendMapRegister(mapRegisterBuilder.build());
1151 MapNotify mapNotify = receiveMapNotify();
1152 assertEquals(8, mapNotify.getNonce().longValue());
1155 private MapReply queryForAddress(LispAFIAddress eid, String srcEid) throws SocketTimeoutException {
1156 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1157 mapRequestBuilder.setNonce((long) 4);
1158 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1159 mapRequestBuilder.getEidRecord().add(
1160 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1161 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1162 if (srcEid != null) {
1163 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1164 toContainer(LispAFIConvertor.asIPAfiAddress(srcEid))).build());
1166 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1167 toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1169 mapRequestBuilder.getItrRloc().add(
1170 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1171 mapRequestBuilder.setAuthoritative(false);
1172 mapRequestBuilder.setMapDataPresent(false);
1173 mapRequestBuilder.setPitr(false);
1174 mapRequestBuilder.setProbe(false);
1175 mapRequestBuilder.setSmr(false);
1176 mapRequestBuilder.setSmrInvoked(false);
1177 sendMapRequest(mapRequestBuilder.build());
1178 return receiveMapReply();
1181 // takes an address, packs it in a MapRegister, sends it, returns the
1183 private MapReply registerAddressAndQuery(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1184 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1185 mapRegisterBuilder.setWantMapNotify(true);
1186 mapRegisterBuilder.setKeyId((short) 0);
1187 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1188 mapRegisterBuilder.setNonce((long) 8);
1189 mapRegisterBuilder.setProxyMapReply(false);
1190 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1191 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1192 if (maskLength != -1) {
1193 etlrBuilder.setMaskLength((short) maskLength);
1195 etlrBuilder.setMaskLength((short) 0);
1197 etlrBuilder.setRecordTtl(254);
1198 etlrBuilder.setAction(Action.NoAction);
1199 etlrBuilder.setAuthoritative(false);
1200 etlrBuilder.setMapVersion((short) 0);
1201 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1202 recordBuilder.setLocalLocator(false);
1203 recordBuilder.setRlocProbed(false);
1204 recordBuilder.setRouted(true);
1205 recordBuilder.setMulticastPriority((short) 0);
1206 recordBuilder.setMulticastWeight((short) 0);
1207 recordBuilder.setPriority((short) 0);
1208 recordBuilder.setWeight((short) 0);
1209 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1210 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1211 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1212 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1213 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1214 sendMapRegister(mapRegisterBuilder.build());
1215 MapNotify mapNotify = receiveMapNotify();
1216 assertEquals(8, mapNotify.getNonce().longValue());
1217 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1218 mapRequestBuilder.setNonce((long) 4);
1219 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1220 mapRequestBuilder.getEidRecord().add(
1221 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1222 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1223 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress)))
1225 mapRequestBuilder.getItrRloc().add(
1226 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1227 mapRequestBuilder.setAuthoritative(false);
1228 mapRequestBuilder.setMapDataPresent(false);
1229 mapRequestBuilder.setPitr(false);
1230 mapRequestBuilder.setProbe(false);
1231 mapRequestBuilder.setSmr(false);
1232 mapRequestBuilder.setSmrInvoked(false);
1233 sendMapRequest(mapRequestBuilder.build());
1234 return receiveMapReply();
1237 // ------------------------------- LCAF Tests ---------------------------
1240 public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1242 String ipString = "10.20.30.200";
1243 String macString = "01:02:03:04:05:06";
1244 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1245 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1246 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1247 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1248 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1249 builder.setSrcMaskLength((short) 32);
1250 builder.setDstMaskLength((short) 0);
1251 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1252 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1254 MapReply reply = registerAddressAndQuery(builder.build());
1256 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1257 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1258 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1260 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1261 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1263 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1264 assertTrue(receivedAddr2 instanceof LispMacAddress);
1266 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1267 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1269 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1270 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1274 public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1276 String ipString1 = "10.10.10.0";
1277 String ipString2 = "20.20.20.0";
1278 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString1);
1279 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend2 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString2);
1280 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1281 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1282 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1283 builder.setSrcMaskLength((short) 24);
1284 builder.setDstMaskLength((short) 24);
1285 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1286 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1288 LcafSourceDestAddr srcDst = builder.build();
1289 registerAddress(LispAFIConvertor.asIPAfiAddress(ipString2), 24);
1290 registerAddress(srcDst, -1);
1293 MapReply reply = queryForAddress(srcDst, null);
1295 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1296 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1297 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1299 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1300 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1302 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1303 assertTrue(receivedAddr2 instanceof LispIpv4Address);
1305 LispIpv4Address receivedIP1 = (LispIpv4Address) receivedAddr1;
1306 LispIpv4Address receivedIP2 = (LispIpv4Address) receivedAddr2;
1308 assertEquals(ipString1, receivedIP1.getIpv4Address().getValue());
1309 assertEquals(ipString2, receivedIP2.getIpv4Address().getValue());
1311 // srcEid/dstEid match
1312 reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "10.10.10.1");
1313 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1314 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1316 Ipv4Address ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1317 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1319 // dstEid match only
1320 reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "1.2.3.4");
1321 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1322 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1324 ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1325 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1329 public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1331 String ipString = "10.20.30.200";
1332 String macString = "01:02:03:04:05:06";
1333 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1334 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1335 LcafKeyValueAddressAddrBuilder builder = new LcafKeyValueAddressAddrBuilder();
1336 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1337 builder.setLcafType((short) LispCanonicalAddressFormatEnum.KEY_VALUE.getLispCode());
1338 builder.setKey(new KeyBuilder().setPrimitiveAddress(addrToSend1).build());
1339 builder.setValue(new ValueBuilder().setPrimitiveAddress(addrToSend2).build());
1341 MapReply reply = registerAddressAndQuery(builder.build());
1343 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1344 assertTrue(fromNetwork.getAddress() instanceof LcafKeyValue);
1345 LcafKeyValue keyValueFromNetwork = (LcafKeyValue) fromNetwork.getAddress();
1347 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress());
1348 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getValue().getPrimitiveAddress());
1350 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1351 assertTrue(receivedAddr2 instanceof LispMacAddress);
1353 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1354 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1356 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1357 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1360 public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1362 String macString = "01:02:03:04:05:06";
1363 String ipString = "10.20.255.30";
1364 LcafListAddrBuilder listbuilder = new LcafListAddrBuilder();
1365 listbuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.LIST.getLispCode());
1366 listbuilder.setAddresses(new ArrayList<Addresses>());
1367 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1368 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString))).build());
1370 MapReply reply = registerAddressAndQuery(listbuilder.build());
1372 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1374 assertTrue(receivedAddress instanceof LcafListAddress);
1376 LcafListAddress listAddrFromNetwork = (LcafListAddress) receivedAddress;
1377 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(0).getPrimitiveAddress());
1378 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(1).getPrimitiveAddress());
1380 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1381 assertTrue(receivedAddr2 instanceof LispMacAddress);
1383 assertEquals(macString, ((LispMacAddress) receivedAddr2).getMacAddress().getValue());
1384 assertEquals(ipString, ((LispIpv4Address) receivedAddr1).getIpv4Address().getValue());
1387 public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1389 String ipString = "10.20.255.30";
1391 LcafSegmentAddrBuilder builder = new LcafSegmentAddrBuilder();
1392 builder.setInstanceId((long) instanceId);
1393 builder.setIidMaskLength((short) 32);
1394 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.SEGMENT.getLispCode());
1395 builder.setAddress(new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1397 MapReply reply = registerAddressAndQuery(builder.build());
1399 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1400 assertTrue(receivedAddress instanceof LcafSegmentAddress);
1402 LcafSegmentAddress segmentfromNetwork = (LcafSegmentAddress) receivedAddress;
1403 LispAFIAddress addrFromSegment = LispAFIConvertor.toAFIfromPrimitive(segmentfromNetwork.getAddress().getPrimitiveAddress());
1404 assertTrue(addrFromSegment instanceof LispIpv4Address);
1405 assertEquals(ipString, ((LispIpv4Address) addrFromSegment).getIpv4Address().getValue());
1407 assertEquals(instanceId, segmentfromNetwork.getInstanceId().intValue());
1410 public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1412 String macString = "01:02:03:04:05:06";
1413 String ipString = "10.20.255.30";
1414 HopBuilder hopBuilder = new HopBuilder();
1415 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString)));
1416 Hop hop1 = hopBuilder.build();
1417 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString)));
1418 Hop hop2 = hopBuilder.build();
1419 HopsBuilder hb = new HopsBuilder();
1422 hb.setRLOCProbe(false);
1424 HopsBuilder hb2 = new HopsBuilder();
1426 hb2.setLookup(false);
1427 hb2.setRLOCProbe(true);
1428 hb2.setStrict(false);
1429 Hops hops1 = hb.build();
1430 Hops hops2 = hb2.build();
1431 LcafTrafficEngineeringAddrBuilder trafficBuilder = new LcafTrafficEngineeringAddrBuilder();
1432 trafficBuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType(
1433 (short) LispCanonicalAddressFormatEnum.TRAFFIC_ENGINEERING.getLispCode());
1434 trafficBuilder.setHops(new ArrayList<Hops>());
1435 trafficBuilder.getHops().add(hb.build());
1436 trafficBuilder.getHops().add(hb2.build());
1438 MapReply reply = registerAddressAndQuery(trafficBuilder.build());
1440 assertTrue(LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer()) instanceof LcafTrafficEngineeringAddress);
1442 LcafTrafficEngineeringAddress receivedAddress = (LcafTrafficEngineeringAddress) LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0)
1443 .getLispAddressContainer());
1445 ReencapHop receivedHop1 = receivedAddress.getHops().get(0);
1446 ReencapHop receivedHop2 = receivedAddress.getHops().get(1);
1448 assertEquals(true, hops1.isLookup());
1449 assertEquals(false, hops1.isRLOCProbe());
1450 assertEquals(true, hops1.isStrict());
1452 assertEquals(false, hops2.isLookup());
1453 assertEquals(true, hops2.isRLOCProbe());
1454 assertEquals(false, hops2.isStrict());
1456 assertTrue(receivedHop1.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4);
1457 assertTrue(receivedHop2.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac);
1459 assertEquals(ipString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) receivedHop1.getHop().getPrimitiveAddress()).getIpv4Address().getIpv4Address().getValue());
1460 assertEquals(macString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac) receivedHop2.getHop().getPrimitiveAddress()).getMacAddress().getMacAddress().getValue());
1463 public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1465 String ipString = "1.2.3.4";
1468 int localPortLow = 3;
1469 int localPortHigh = 4;
1470 int remotePortLow = 4;
1471 int remotePortHigh = 5;
1473 LcafApplicationDataAddrBuilder builder = new LcafApplicationDataAddrBuilder();
1474 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode());
1475 builder.setIpTos(ipTOs);
1476 builder.setProtocol(protocol);
1477 builder.setLocalPortLow(new PortNumber(localPortLow));
1478 builder.setLocalPortHigh(new PortNumber(localPortHigh));
1479 builder.setRemotePortLow(new PortNumber(remotePortLow));
1480 builder.setRemotePortHigh(new PortNumber(remotePortHigh));
1481 builder.setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder()
1482 .setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1484 LcafApplicationDataAddress addressToSend = builder.build();
1486 MapReply reply = registerAddressAndQuery(addressToSend);
1488 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1490 assertTrue(receivedAddress instanceof LcafApplicationDataAddress);
1492 LcafApplicationDataAddress receivedApplicationDataAddress = (LcafApplicationDataAddress) receivedAddress;
1493 assertEquals(protocol, receivedApplicationDataAddress.getProtocol().intValue());
1494 assertEquals(ipTOs, receivedApplicationDataAddress.getIpTos().intValue());
1495 assertEquals(localPortLow, receivedApplicationDataAddress.getLocalPortLow().getValue().intValue());
1496 assertEquals(localPortHigh, receivedApplicationDataAddress.getLocalPortHigh().getValue().intValue());
1497 assertEquals(remotePortLow, receivedApplicationDataAddress.getRemotePortLow().getValue().intValue());
1498 assertEquals(remotePortHigh, receivedApplicationDataAddress.getRemotePortHigh().getValue().intValue());
1500 LispIpv4Address ipAddressReceived = (LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(receivedApplicationDataAddress.getAddress().getPrimitiveAddress());
1501 assertEquals(ipString, ipAddressReceived.getIpv4Address().getValue());
1504 // ------------------- TimeOut Tests -----------
1506 public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1508 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1509 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1510 mapRequestBuilder.setNonce((long) 4);
1511 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1512 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1513 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1514 mapRequestBuilder.getEidRecord().add(
1515 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1516 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1517 mapRequestBuilder.getItrRloc().add(
1518 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1519 sendMapRequest(mapRequestBuilder.build());
1520 MapReply mapReply = receiveMapReply();
1521 assertEquals(4, mapReply.getNonce().longValue());
1522 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1523 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1524 mapRegisterbuilder.setWantMapNotify(true);
1525 mapRegisterbuilder.setNonce((long) 8);
1526 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1527 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1528 etlrBuilder.setMaskLength((short) 32);
1529 etlrBuilder.setRecordTtl(254);
1530 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1531 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
1532 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1533 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1534 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1535 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1536 sendMapRegister(mapRegisterbuilder.build());
1537 MapNotify mapNotify = receiveMapNotify();
1538 assertEquals(8, mapNotify.getNonce().longValue());
1539 sendMapRequest(mapRequestBuilder.build());
1540 mapReply = receiveMapReply();
1541 assertEquals(4, mapReply.getNonce().longValue());
1542 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1543 .getLispAddressContainer());
1544 causeEntryToBeCleaned();
1545 sendMapRequest(mapRequestBuilder.build());
1546 mapReply = receiveMapReply();
1547 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1550 public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1552 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1553 MapRequest mapRequest = createMapRequest(eid);
1555 testTTLBeforeRegister(mapRequest);
1557 registerForTTL(eid);
1559 testTTLAfterRegister(mapRequest);
1561 causeEntryToBeCleaned();
1562 testTTLAfterClean(mapRequest);
1564 //northboundAddKey();
1565 //testTTLAfterAutherize(mapRequest);
1569 private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1571 sendMapRequest(mapRequest);
1572 mapReply = receiveMapReply();
1573 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1576 private void causeEntryToBeCleaned() {
1577 // TODO for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1578 // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1579 // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1583 private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1585 sendMapRequest(mapRequest);
1586 mapReply = receiveMapReply();
1587 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1588 .getLispAddressContainer());
1589 assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1592 private void registerForTTL(LispIpv4Address eid) throws SocketTimeoutException {
1593 MapRegister mapRegister = createMapRegister(eid);
1594 sendMapRegister(mapRegister);
1595 assertMapNotifyRecieved();
1598 private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1600 sendMapRequest(mapRequest);
1601 mapReply = receiveMapReply();
1602 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1605 private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1607 sendMapRequest(mapRequest);
1608 mapReply = receiveMapReply();
1609 assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1612 private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1613 assertEquals(expectedTTL, mapReply.getEidToLocatorRecord().get(0).getRecordTtl().intValue());
1614 assertEquals(expectedAction, mapReply.getEidToLocatorRecord().get(0).getAction());
1617 private MapRegister createMapRegister(LispAFIAddress eid, LispAFIAddress rloc) {
1618 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1619 mapRegisterbuilder.setWantMapNotify(true);
1620 mapRegisterbuilder.setNonce((long) 8);
1621 mapRegisterbuilder.setKeyId((short) 0);
1622 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1623 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1624 etlrBuilder.setMaskLength((short) 24);
1625 etlrBuilder.setRecordTtl(254);
1626 etlrBuilder.setAuthoritative(false);
1627 etlrBuilder.setAction(Action.NoAction);
1628 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1629 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
1630 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1631 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1632 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1633 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1634 MapRegister mapRegister = mapRegisterbuilder.build();
1638 private MapRegister createMapRegister(LispIpv4Address eid) {
1639 return createMapRegister(eid, LispAFIConvertor.asIPAfiAddress("4.3.2.1"));
1642 private MapRequest createMapRequest(LispAFIAddress eid) {
1643 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1644 mapRequestBuilder.setNonce((long) 4);
1645 mapRequestBuilder.setPitr(false);
1646 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1647 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1648 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1649 mapRequestBuilder.getEidRecord().add(
1650 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1651 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1652 mapRequestBuilder.getItrRloc().add(
1653 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1654 MapRequest mr = mapRequestBuilder.build();
1658 public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1660 String rloc = "127.0.0.3";
1661 int port = LispMessage.PORT_NUM;
1662 LispAFIAddress ipRloc = LispAFIConvertor.asIPAfiAddress(rloc);
1663 sendProxyMapRequest(rloc, port, ipRloc);
1667 public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1669 String rloc = "127.0.0.3";
1671 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1672 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1673 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1675 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1676 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPortLow(new PortNumber(port)).build();
1677 LOG.info("testNonProxyOtherPort:" + adLcaf.toString());
1678 sendProxyMapRequest(rloc, port, adLcaf);
1682 public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
1684 configLispPlugin.shouldListenOnXtrPort(true);
1685 notificationCalled = false;
1686 final String eid = "10.10.10.10";
1687 String rloc = "127.0.0.3";
1688 int port = LispMessage.XTR_PORT_NUM;
1689 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1690 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1691 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1693 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1694 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPortLow(new PortNumber(port)).build();
1695 final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1696 ((LispMappingService) lms).registerNotificationListener(XtrRequestMapping.class, new NotificationListener<XtrRequestMapping>() {
1699 public void onNotification(XtrRequestMapping notification) {
1700 assertEquals(((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) mapRequest.getEidRecord().get(0).getLispAddressContainer().getAddress()).getIpv4Address().getIpv4Address().getValue(),
1702 notificationCalled = true;
1703 LOG.warn("notification arrived");
1706 sendMapRequest(mapRequest, port);
1707 for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
1708 if (notificationCalled) {
1711 LOG.warn("notification hasn't arrived, sleeping...");
1716 fail("Notification hasn't arrived");
1720 private void sendProxyMapRequest(String rloc, int port, LispAFIAddress adLcaf) throws SocketTimeoutException, SocketException {
1721 String eid = "10.1.0.1";
1722 MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1723 sendMapRequest(mapRequest);
1724 DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
1725 MapRequest recievedMapRequest = receiveMapRequest(nonProxySocket);
1726 assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
1727 assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
1728 assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
1729 assertEquals(mapRequest.getEidRecord(), recievedMapRequest.getEidRecord());
1730 nonProxySocket.close();
1733 private MapRequest createNonProxyMapRequest(String eid, LispAFIAddress adLcaf) throws SocketTimeoutException {
1734 MapRegister mr = createMapRegister(LispAFIConvertor.asIPAfiAddress(eid));
1735 LocatorRecord record = new LocatorRecordBuilder(mr.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)).setLispAddressContainer(
1736 LispAFIConvertor.toContainer(adLcaf)).build();
1737 mr.getEidToLocatorRecord().get(0).getLocatorRecord().set(0, record);
1738 sendMapRegister(mr);
1739 assertMapNotifyRecieved();
1740 MapRequest mapRequest = createMapRequest(LispAFIConvertor.asIPAfiAddress(eid));
1741 MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
1742 builder.setPitr(true);
1743 mapRequest = builder.build();
1747 private void assertMapNotifyRecieved() throws SocketTimeoutException {
1751 private MapReply receiveMapReply() throws SocketTimeoutException {
1752 return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1755 private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
1756 return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(datagramSocket, 30000).getData()));
1759 private MapNotify receiveMapNotify() throws SocketTimeoutException {
1760 return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1763 private void sendMapRequest(MapRequest mapRequest) {
1764 sendMapRequest(mapRequest, LispMessage.PORT_NUM);
1767 private void sendMapRequest(MapRequest mapRequest, int port) {
1768 sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
1771 private void sendMapRegister(MapRegister mapRegister) {
1772 sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
1775 private void sendPacket(byte[] bytesToSend) {
1776 sendPacket(bytesToSend, LispMessage.PORT_NUM);
1779 private void sendPacket(byte[] bytesToSend, int port) {
1781 DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
1782 initPacketAddress(packet, port);
1783 LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
1784 socket.send(packet);
1785 } catch (Throwable t) {
1790 private DatagramPacket receivePacket() throws SocketTimeoutException {
1791 return receivePacket(6000);
1794 private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
1795 return receivePacket(socket, timeout);
1798 private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
1800 byte[] buffer = new byte[4096];
1801 DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
1802 LOG.trace("Waiting for packet from socket...");
1803 receivedSocket.setSoTimeout(timeout);
1804 receivedSocket.receive(receivePacket);
1805 LOG.trace("Recieved packet from socket!");
1806 return receivePacket;
1807 } catch (SocketTimeoutException ste) {
1809 } catch (Throwable t) {
1815 private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
1816 packet.setAddress(InetAddress.getByName(lispBindAddress));
1817 packet.setPort(port);
1820 private DatagramSocket initSocket(DatagramSocket socket, int port) {
1822 socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
1823 } catch (SocketException e) {
1824 e.printStackTrace();
1830 private byte[] extractWSUdpByteArray(String wiresharkHex) {
1831 final int HEADER_LEN = 42;
1832 byte[] res = new byte[1000];
1833 String[] split = wiresharkHex.split(" ");
1835 for (String cur : split) {
1837 if (cur.length() == 2) {
1839 if (counter > HEADER_LEN) {
1840 res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
1845 return Arrays.copyOf(res, counter - HEADER_LEN);
1848 private String stateToString(int state) {
1852 case Bundle.INSTALLED:
1854 case Bundle.RESOLVED:
1856 case Bundle.UNINSTALLED:
1857 return "UNINSTALLED";
1859 return "Not CONVERTED";
1863 @SuppressWarnings({ "rawtypes", "unchecked" })
1864 private void areWeReady() throws InvalidSyntaxException {
1867 } catch (InterruptedException e) {
1871 boolean debugit = false;
1872 Bundle b[] = bc.getBundles();
1873 for (Bundle element : b) {
1874 int state = element.getState();
1875 LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v" + element.getVersion() + ", state:"
1876 + stateToString(state));
1877 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
1878 LOG.debug("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
1881 // String host = element.getHeaders().get("FRAGMENT-HOST");
1882 // if (host != null) {
1883 // LOG.warn("Bundle " + element.getSymbolicName() +
1884 // " is a fragment which is part of: " + host);
1885 // LOG.warn("Required imports are: " +
1886 // element.getHeaders().get("IMPORT-PACKAGE"));
1890 // } catch (BundleException e) {
1891 // LOG.error("BundleException:", e);
1900 LOG.warn(("Do some debugging because some bundle is unresolved"));
1902 // assertNotNull(broker);
1904 ServiceReference r = null;
1905 configLispPlugin.setLispAddress(lispBindAddress);
1907 // Uncomment this code to Know which services were actually loaded to
1911 for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
1912 LOG.info(sr.getBundle().getSymbolicName());
1913 LOG.info(sr.toString());
1919 } catch (InterruptedException e) {
1923 private void cleanUP() {
1926 configLispPlugin.shouldListenOnXtrPort(false);
1927 socket = initSocket(socket, LispMessage.PORT_NUM);