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.options;
16 import java.io.BufferedReader;
17 import java.io.IOException;
18 import java.io.InputStream;
19 import java.io.InputStreamReader;
20 import java.io.OutputStreamWriter;
21 import java.net.DatagramPacket;
22 import java.net.DatagramSocket;
23 import java.net.HttpURLConnection;
24 import java.net.InetAddress;
25 import java.net.InetSocketAddress;
26 import java.net.MalformedURLException;
27 import java.net.SocketException;
28 import java.net.SocketTimeoutException;
30 import java.net.UnknownHostException;
31 import java.nio.ByteBuffer;
32 import java.nio.charset.Charset;
33 import java.util.ArrayList;
34 import java.util.Arrays;
36 import javax.inject.Inject;
38 import org.apache.commons.codec.binary.Base64;
39 import org.codehaus.jettison.json.JSONException;
40 import org.codehaus.jettison.json.JSONObject;
41 import org.codehaus.jettison.json.JSONTokener;
42 import org.junit.After;
43 import org.junit.Before;
44 import org.junit.Test;
45 import org.junit.runner.RunWith;
46 import org.opendaylight.controller.sal.binding.api.NotificationListener;
47 import org.opendaylight.lispflowmapping.clusterdao.ClusterDAOService;
48 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
49 import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
50 import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
51 import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
52 import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
53 import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
54 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
55 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
56 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
57 import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
58 import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
59 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSegmentAddress;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispIpv4Address;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispMacAddress;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.ReencapHop;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.XtrRequestMapping;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.ValueBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.Addresses;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.AddressesBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.SrcAddressBuilder;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.Hops;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.HopsBuilder;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddrBuilder;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaflist.LcafListAddrBuilder;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaftrafficengineering.LcafTrafficEngineeringAddrBuilder;
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
107 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.Hop;
108 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.HopBuilder;
109 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
110 import org.ops4j.pax.exam.Configuration;
111 import org.ops4j.pax.exam.Option;
112 import org.ops4j.pax.exam.junit.PaxExam;
113 import org.osgi.framework.Bundle;
114 import org.osgi.framework.BundleContext;
115 import org.osgi.framework.InvalidSyntaxException;
116 import org.osgi.framework.ServiceReference;
117 import org.slf4j.Logger;
118 import org.slf4j.LoggerFactory;
120 @RunWith(PaxExam.class)
121 public class MappingServiceIntegrationTest {
123 private IFlowMapping lms;
124 private ClusterDAOService clusterService;
125 protected static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
126 private byte[] mapRequestPacket;
127 private byte[] mapRegisterPacketWithNotify;
128 private byte[] mapRegisterPacketWithoutNotify;
129 private IConfigLispSouthboundPlugin configLispPlugin;
130 String lispBindAddress = "127.0.0.1";
131 String ourAddress = "127.0.0.2";
132 private LispAFIAddress locatorEid;
133 private DatagramSocket socket;
134 private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
136 public static final String ODL = "org.opendaylight.controller";
137 public static final String YANG = "org.opendaylight.yangtools";
138 public static final String JERSEY = "com.sun.jersey";
139 private static final int MAX_SERVICE_LOAD_RETRIES = 45;
140 private static final int MAX_NOTIFICATION_RETRYS = 20;
143 public void after() {
144 if (socket != null) {
147 if (connection != null) {
148 connection.disconnect();
153 public void before() throws Exception {
155 locatorEid = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
156 socket = initSocket(socket, LispMessage.PORT_NUM);
158 // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
159 // LISP(Type = 8 - Encapsulated)
160 // IP: 192.168.136.10 -> 153.16.254.1
162 // LISP(Type = 1 Map-Request
166 // Source EID not present
167 // Nonce: 0x3d8d2acd39c8d608
168 // ITR-RLOC AFI=1 Address=192.168.136.10
169 // Record 1: 153.16.254.1/32
170 mapRequestPacket = extractWSUdpByteArray(new String("0000 00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
171 + "0010 00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
172 + "0020 00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
173 + "0030 00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
174 + "0040 fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
175 + "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
176 + "0060 00 01 99 10 fe 01"));
178 // IP: 192.168.136.10 -> 128.223.156.35
179 // UDP: 49289 -> 4342
180 // LISP(Type = 3 Map-Register, P=1, M=1
184 // AuthDataLength: 20 Data:
185 // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
186 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
188 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
189 // Priority/Weight: 1/100, Multicast Priority/Weight:
193 mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
194 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
195 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
196 + "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
197 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
198 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
199 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
201 // IP: 192.168.136.10 -> 128.223.156.35
202 // UDP: 49289 -> 4342
203 // LISP(Type = 3 Map-Register, P=1, M=1
206 // Key ID: 0x0000 NO AUTHENTICATION!!
207 // AuthDataLength: 00 Data:
208 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
210 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
211 // Priority/Weight: 1/100, Multicast Priority/Weight:
215 mapRegisterPacketWithNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
216 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
217 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
218 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
219 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
220 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
221 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
223 // IP: 192.168.136.10 -> 128.223.156.35
224 // UDP: 49289 -> 4342
225 // LISP(Type = 3 Map-Register, P=1, M=1
228 // Key ID: 0x0000 NO AUTHENTICATION!!
229 // AuthDataLength: 00 Data:
230 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
232 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
233 // Priority/Weight: 1/100, Multicast Priority/Weight:
237 mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
238 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
239 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
240 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
241 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
242 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
243 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
247 private BundleContext bc;
248 private HttpURLConnection connection;
249 protected static boolean notificationCalled;
251 // Configure the OSGi container
253 public Option[] config() {
254 return options(MappingServiceTestHelper.mappingServiceBundlesWithClusterDAO());
258 public void testSimpleUsage() throws Exception {
260 mapRegisterWithMapNotify();
261 mapRegisterWithMapNotifyAndMapRequest();
262 registerAndQuery__MAC();
263 mapRequestMapRegisterAndMapRequest();
264 mapRegisterWithAuthenticationWithoutConfiguringAKey();
265 mapRegisterWithoutMapNotify();
269 public void testLCAFs() throws Exception {
270 registerAndQuery__SrcDestLCAF();
271 registerAndQuery__SrcDestLCAFOverlap();
272 registerAndQuery__KeyValueLCAF();
273 registerAndQuery__ListLCAF();
274 registerAndQuery__ApplicationData();
275 registerAndQuery__TrafficEngineering();
276 registerAndQuery__SegmentLCAF();
280 public void testMask() throws Exception {
281 testPasswordExactMatch();
282 testPasswordMaskMatch();
283 eidPrefixLookupIPv4();
284 eidPrefixLookupIPv6();
288 public void testNorthbound() throws Exception {
290 northboundAddMapping();
291 northboundDeleteMapping();
292 northboundRetrieveKey();
293 northboundRetrieveMapping();
294 northboundRetrieveSourceDestKey();
295 northboundRetrieveSourceDestMapping();
299 public void testOverWriting() throws Exception {
300 //testMapRegisterDosntOverwritesOtherSubKeys();
301 testMapRegisterOverwritesSameSubkey();
302 testMapRegisterOverwritesNoSubkey();
303 testMapRegisterDoesntOverwritesNoSubkey();
307 public void testTimeOuts() throws Exception {
308 mapRequestMapRegisterAndMapRequestTestTimeout();
309 mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse();
313 public void testNonProxy() throws Throwable {
314 testSimpleNonProxy();
315 testNonProxyOtherPort();
316 testRecievingNonProxyOnXtrPort();
320 public void testSmr() throws Exception {
321 registerQueryRegisterWithSmr();
324 // ------------------------------- Simple Tests ---------------------------
326 public void mapRequestSimple() throws SocketTimeoutException {
329 // This Map-Request is sent from a source port different from 4342
330 // We close and bind the socket on the correct port
331 if (socket != null) {
334 socket = initSocket(socket, 56756);
336 sendPacket(mapRequestPacket);
337 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
338 MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
339 assertEquals(4435248268955932168L, reply.getNonce().longValue());
343 public void mapRegisterWithMapNotify() throws SocketTimeoutException {
345 sendPacket(mapRegisterPacketWithNotify);
346 MapNotify reply = receiveMapNotify();
347 assertEquals(7, reply.getNonce().longValue());
350 public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
352 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
354 MapReply mapReply = registerAddressAndQuery(eid, 32);
356 assertEquals(4, mapReply.getNonce().longValue());
357 assertEquals(LispAFIConvertor.toContainer(locatorEid), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
358 .getLispAddressContainer());
362 public void registerAndQuery__MAC() throws SocketTimeoutException {
364 String macAddress = "01:02:03:04:05:06";
366 MapReply reply = registerAddressAndQuery(LispAFIConvertor.asMacAfiAddress(macAddress));
369 LispAFIAddress addressFromNetwork = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
370 assertTrue(addressFromNetwork instanceof LispMacAddress);
371 String macAddressFromReply = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.mac.MacAddress) addressFromNetwork).getMacAddress().getValue();
373 assertEquals(macAddress, macAddressFromReply);
376 public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
378 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
379 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
380 mapRequestBuilder.setNonce((long) 4);
381 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
382 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
383 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
384 mapRequestBuilder.getEidRecord().add(
385 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
386 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
387 mapRequestBuilder.getItrRloc().add(
388 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
389 sendMapRequest(mapRequestBuilder.build());
390 MapReply mapReply = receiveMapReply();
391 assertEquals(4, mapReply.getNonce().longValue());
392 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
393 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
394 mapRegisterbuilder.setWantMapNotify(true);
395 mapRegisterbuilder.setNonce((long) 8);
396 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
397 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
398 etlrBuilder.setMaskLength((short) 32);
399 etlrBuilder.setRecordTtl(254);
400 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
401 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
402 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
403 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
404 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
405 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
406 sendMapRegister(mapRegisterbuilder.build());
407 MapNotify mapNotify = receiveMapNotify();
408 assertEquals(8, mapNotify.getNonce().longValue());
409 sendMapRequest(mapRequestBuilder.build());
410 mapReply = receiveMapReply();
411 assertEquals(4, mapReply.getNonce().longValue());
412 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
413 .getLispAddressContainer());
417 public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
419 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
420 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
421 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey1", LispAFIConvertor.toPrimitive(rloc1Value));
422 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
423 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey2", LispAFIConvertor.toPrimitive(rloc2Value));
424 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
425 assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
426 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
427 assertEquals(LispAFIConvertor.toContainer(rloc1), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer());
430 public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
432 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
433 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
434 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc1Value));
435 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
436 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc2Value));
437 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
438 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
439 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
442 public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
444 lms.setOverwrite(true);
445 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
446 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
447 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
448 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
449 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
450 assertEquals(LispAFIConvertor.toContainer(rloc2Value), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
451 .getLispAddressContainer());
454 public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
456 lms.setOverwrite(false);
457 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
458 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
459 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
460 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
461 assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
462 LispAddressContainer rloc1ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer();
463 LispAddressContainer rloc2ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer();
464 assertTrue((LispAFIConvertor.toContainer(rloc1Value).equals(rloc1ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
465 rloc2ReturnValueContainer))
466 || (LispAFIConvertor.toContainer(rloc1Value).equals(rloc2ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
467 rloc1ReturnValueContainer)));
470 private MapReply sendMapRegisterTwiceWithDiffrentValues(LispAFIAddress eid, LispAFIAddress rloc1, LispAFIAddress rloc2)
471 throws SocketTimeoutException {
472 MapRegister mb = createMapRegister(eid, rloc1);
473 MapNotify mapNotify = lms.handleMapRegister(mb, false);
474 MapRequest mr = createMapRequest(eid);
475 MapReply mapReply = lms.handleMapRequest(mr);
476 assertEquals(mb.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0)
477 .getLocatorRecord().get(0).getLispAddressContainer());
478 mb = createMapRegister(eid, rloc2);
479 mapNotify = lms.handleMapRegister(mb, false);
480 assertEquals(8, mapNotify.getNonce().longValue());
481 mr = createMapRequest(eid);
483 mapReply = lms.handleMapRequest(mr);
487 public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
489 sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
492 // If didn't timeout then fail:
494 } catch (SocketTimeoutException ste) {
498 public void mapRegisterWithoutMapNotify() {
500 sendPacket(mapRegisterPacketWithoutNotify);
503 // If didn't timeout then fail:
505 } catch (SocketTimeoutException ste) {
509 public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
511 lms.setShouldUseSmr(true);
513 sendPacket(mapRegisterPacketWithNotify);
516 sendPacket(mapRequestPacket);
519 } catch (InterruptedException e) {
522 mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
523 sendPacket(mapRegisterPacketWithoutNotify);
525 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
526 MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
527 assertTrue(smr.isSmr());
528 LispAddressContainer smrEid = smr.getEidRecord().get(0).getLispAddressContainer();
529 assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")).equals(smrEid));
532 // --------------------- Northbound Tests ---------------------------
534 private void northboundAddKey() throws Exception {
536 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
538 String pass = "asdf";
540 URL url = createPutURL("key");
541 String authKeyJSON = createAuthKeyJSON(pass, address, mask);
542 callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
544 String retrievedKey = lms.getAuthenticationKey(LispAFIConvertor.toContainer(address), mask);
546 // Check stored password matches the one sent
547 assertEquals(pass, retrievedKey);
551 private void northboundRetrieveSourceDestKey() throws Exception {
553 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
554 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
555 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
556 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
559 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
560 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
561 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
562 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
563 String pass = "asdf";
565 lms.addAuthenticationKey(LispAFIConvertor.toContainer(sourceDestAddress), mask1, pass);
567 // URL url = createGetKeyIPv4URL(address1, mask1);
568 URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
569 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
570 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
571 String reply = callURL("GET", null, "application/json", null, url);
572 JSONTokener jt = new JSONTokener(reply);
573 JSONObject json = new JSONObject(jt);
575 // test that the password matches what was we expected.
576 assertEquals(pass, json.get("key"));
580 private void northboundRetrieveKey() throws Exception {
582 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
584 String pass = "asdf";
586 lms.addAuthenticationKey(LispAFIConvertor.toContainer(address), mask, pass);
588 URL url = createGetKeyIPv4URL(address, mask);
589 String reply = callURL("GET", null, "application/json", null, url);
590 JSONTokener jt = new JSONTokener(reply);
591 JSONObject json = new JSONObject(jt);
593 // test that the password matches what was we expected.
594 assertEquals(pass, json.get("key"));
598 private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
599 return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
600 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
603 private void northboundAddMapping() throws Exception {
605 String pass = "asdf";
606 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
608 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
610 // NB add mapping always checks the key
611 lms.addAuthenticationKey(LispAFIConvertor.toContainer(eid), mask, pass);
613 URL url = createPutURL("mapping");
614 String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
615 callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
617 // Retrieve the RLOC from the database
618 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
619 mapRequestBuilder.setPitr(false);
620 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
621 mapRequestBuilder.getEidRecord().add(
622 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
623 MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
625 LispIpv4Address retrievedRloc = (LispIpv4Address) LispAFIConvertor.toAFI(
626 mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
628 assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
632 private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
633 String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ " + "\"proxyMapReply\" : false, "
634 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : " + "{ " + "\"ipAddress\" : \""
635 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "}," + "\"mapVersion\" : 0,"
636 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ " + "\"multicastPriority\" : 1,"
637 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\"," + "\"afi\" : "
638 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50," + "\"rlocProbed\" : false, "
639 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], " + "\"recordTtl\" : 100" + "} " + "], "
640 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
645 private void northboundRetrieveMapping() throws Exception {
647 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
649 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
650 // Insert mapping in the database
651 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
652 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
653 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
654 etlr.setMaskLength((short) mask);
655 etlr.setRecordTtl(254);
656 etlr.setAuthoritative(false);
657 etlr.setAction(Action.NoAction);
658 LocatorRecordBuilder record = new LocatorRecordBuilder();
659 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
660 record.setRouted(true);
661 record.setRlocProbed(false);
662 record.setLocalLocator(false);
663 record.setPriority((short) 1);
664 record.setWeight((short) 50);
665 record.setMulticastPriority((short) 1);
666 record.setMulticastWeight((short) 1);
667 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
668 etlr.getLocatorRecord().add(record.build());
669 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
670 mapRegister.getEidToLocatorRecord().add(etlr.build());
671 lms.handleMapRegister(mapRegister.build(), false);
673 // Get mapping using NB interface. No IID used
674 URL url = createGetMappingIPv4URL(0, eid, mask);
675 String reply = callURL("GET", null, "application/json", null, url);
676 JSONTokener jt = new JSONTokener(reply);
677 JSONObject json = new JSONObject(jt);
679 // With just one locator, locators is not a JSONArray
680 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
682 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
686 private void northboundDeleteMapping() throws Exception {
688 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
690 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
691 // Insert mapping in the database
692 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
693 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
694 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
695 etlr.setMaskLength((short) mask);
696 etlr.setRecordTtl(254);
697 etlr.setAuthoritative(false);
698 etlr.setAction(Action.NoAction);
699 LocatorRecordBuilder record = new LocatorRecordBuilder();
700 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
701 record.setRouted(true);
702 record.setRlocProbed(false);
703 record.setLocalLocator(false);
704 record.setPriority((short) 1);
705 record.setWeight((short) 50);
706 record.setMulticastPriority((short) 1);
707 record.setMulticastWeight((short) 1);
708 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
709 etlr.getLocatorRecord().add(record.build());
710 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
711 mapRegister.getEidToLocatorRecord().add(etlr.build());
712 lms.handleMapRegister(mapRegister.build(), false);
714 // Delete mapping using NB interface. No IID used
715 URL url = createDeleteMappingIPv4URL(0, eid, mask);
716 String reply = callURL("DELETE", null, "application/json", null, url);
718 // Get mapping using NB interface. No IID used
719 url = createGetMappingIPv4URL(0, eid, mask);
720 reply = callURL("GET", null, "application/json", null, url);
721 JSONTokener jt = new JSONTokener(reply);
722 JSONObject json = new JSONObject(jt);
724 // With just one locator, locators is not a JSONArray
725 assertEquals(json.getJSONArray("locators").length(), 0);
728 private void northboundRetrieveSourceDestMapping() throws Exception {
730 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
731 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
732 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
733 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
736 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
737 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
738 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
739 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
740 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
742 // Insert mapping in the database
743 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
744 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
745 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(sourceDestAddress));
746 etlr.setMaskLength((short) mask1);
747 etlr.setRecordTtl(254);
748 etlr.setAuthoritative(false);
749 etlr.setAction(Action.NoAction);
750 LocatorRecordBuilder record = new LocatorRecordBuilder();
751 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
752 record.setRouted(true);
753 record.setRlocProbed(false);
754 record.setLocalLocator(false);
755 record.setPriority((short) 1);
756 record.setWeight((short) 50);
757 record.setMulticastPriority((short) 1);
758 record.setMulticastWeight((short) 1);
759 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
760 etlr.getLocatorRecord().add(record.build());
761 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
762 mapRegister.getEidToLocatorRecord().add(etlr.build());
763 lms.handleMapRegister(mapRegister.build(), false);
765 // Get mapping using NB interface. No IID used
766 URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
767 address1.getIpv4Address().getIpv4Address().getValue(),
769 address2.getIpv4Address().getIpv4Address().getValue(),
771 String reply = callURL("GET", null, "application/json", null, url);
772 JSONTokener jt = new JSONTokener(reply);
773 JSONObject json = new JSONObject(jt);
775 // With just one locator, locators is not a JSONArray
776 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
778 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
782 private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
783 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key", address.getAfi().shortValue(),
784 address.getIpv4Address().getValue(), mask);
785 URL url = new URL(restUrl);
789 private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
790 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "key", afi, srcAddress, srcMask,
791 dstAddress, dstMask);
792 URL url = new URL(restUrl);
796 private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
797 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "mapping", afi, srcAddress,
798 srcMask, dstAddress, dstMask);
799 URL url = new URL(restUrl);
803 private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
804 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
805 .shortValue(), address.getIpv4Address().getValue(), mask);
806 URL url = new URL(restUrl);
810 private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
811 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
812 .shortValue(), address.getIpv4Address().getValue(), mask);
813 URL url = new URL(restUrl);
817 private URL createPutURL(String resource) throws MalformedURLException {
819 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
821 URL url = new URL(restUrl);
825 private String createAuthenticationString() {
826 String authString = "admin:admin";
827 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
828 String authStringEnc = new String(authEncBytes);
829 return authStringEnc;
832 private String callURL(String method, String content, String accept, String body, URL url) throws IOException, JSONException {
833 String authStringEnc = createAuthenticationString();
834 connection = (HttpURLConnection) url.openConnection();
835 connection.setRequestMethod(method);
836 connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
837 if (content != null) {
838 connection.setRequestProperty("Content-Type", content);
840 if (accept != null) {
841 connection.setRequestProperty("Accept", accept);
844 // now add the request body
845 connection.setDoOutput(true);
846 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
850 connection.connect();
852 // getting the result, first check response code
853 Integer httpResponseCode = connection.getResponseCode();
855 if (httpResponseCode > 299) {
856 LOG.trace("HTTP Address: " + url);
857 LOG.trace("HTTP Response Code: " + httpResponseCode);
861 InputStream is = connection.getInputStream();
862 BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
863 StringBuilder sb = new StringBuilder();
865 while ((cp = rd.read()) != -1) {
866 sb.append((char) cp);
869 connection.disconnect();
870 return (sb.toString());
873 // timePeriod - in ms
874 public void assertNoPacketReceived(int timePeriod) {
876 receivePacket(timePeriod);
877 // If didn't timeout then fail:
879 } catch (SocketTimeoutException ste) {
883 // ------------------------------- Mask Tests ---------------------------
885 public void eidPrefixLookupIPv4() throws SocketTimeoutException {
887 runPrefixTest(LispAFIConvertor.asIPAfiAddress("1.2.3.4"), 16, LispAFIConvertor.asIPAfiAddress("1.2.3.2"),
888 LispAFIConvertor.asIPAfiAddress("1.1.1.1"), (byte) 32);
891 public void eidPrefixLookupIPv6() throws SocketTimeoutException {
893 runPrefixTest(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8"), 64, LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:1:2:3"),
894 LispAFIConvertor.asIPv6AfiAddress("1:2:3:1:2:3:1:2"), 128);
897 private void runPrefixTest(LispAFIAddress registerEID, int registerdMask, LispAFIAddress matchedAddress, LispAFIAddress unMatchedAddress, int mask)
898 throws SocketTimeoutException {
900 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
901 mapRegister.setWantMapNotify(true);
902 mapRegister.setNonce((long) 8);
903 mapRegister.setWantMapNotify(true);
904 mapRegister.setKeyId((short) 0);
905 mapRegister.setAuthenticationData(new byte[0]);
906 mapRegister.setNonce((long) 8);
907 mapRegister.setProxyMapReply(false);
908 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
909 etlr.setRecordTtl(254);
910 etlr.setAction(Action.NoAction);
911 etlr.setAuthoritative(false);
912 etlr.setMapVersion((short) 0);
913 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(registerEID));
914 etlr.setMaskLength((short) registerdMask);
915 etlr.setRecordTtl(254);
916 LocatorRecordBuilder record = new LocatorRecordBuilder();
917 record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
918 record.setLocalLocator(false);
919 record.setRlocProbed(false);
920 record.setRouted(true);
921 record.setMulticastPriority((short) 0);
922 record.setMulticastWeight((short) 0);
923 record.setPriority((short) 0);
924 record.setWeight((short) 0);
925 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
926 etlr.getLocatorRecord().add(record.build());
927 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
928 mapRegister.getEidToLocatorRecord().add(etlr.build());
929 sendMapRegister(mapRegister.build());
930 MapNotify mapNotify = receiveMapNotify();
931 assertEquals(8, mapNotify.getNonce().longValue());
932 MapRequestBuilder mapRequest = new MapRequestBuilder();
933 mapRequest.setNonce((long) 4);
934 mapRequest.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
935 mapRequest.setEidRecord(new ArrayList<EidRecord>());
936 mapRequest.setAuthoritative(false);
937 mapRequest.setMapDataPresent(false);
938 mapRequest.setPitr(false);
939 mapRequest.setProbe(false);
940 mapRequest.setSmr(false);
941 mapRequest.setSmrInvoked(false);
942 mapRequest.getEidRecord().add(
943 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(matchedAddress)).build());
944 mapRequest.setItrRloc(new ArrayList<ItrRloc>());
945 mapRequest.getItrRloc().add(
946 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
947 sendMapRequest(mapRequest.build());
948 MapReply mapReply = receiveMapReply();
949 assertEquals(4, mapReply.getNonce().longValue());
950 assertEquals(record.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
951 mapRequest.setEidRecord(new ArrayList<EidRecord>());
952 mapRequest.getEidRecord().add(
953 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(unMatchedAddress)).build());
954 sendMapRequest(mapRequest.build());
955 mapReply = receiveMapReply();
956 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
959 // This registers an IP with a MapRegister, then adds a password via the
960 // northbound REST API
961 // and checks that the password works
962 public void testPasswordExactMatch() throws Exception {
964 String ipString = "10.0.0.1";
965 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress(ipString);
967 String pass = "pass";
969 URL url = createPutURL("key");
971 String jsonAuthData = createAuthKeyJSON(pass, address, mask);
973 LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
974 LOG.trace("Address: " + address);
976 byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232, (byte) 31, (byte) 249, (byte) 87,
977 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53, (byte) 196, (byte) 62 };
979 byte[] zeros = new byte[20];
981 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
983 // build a MapRegister
984 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
985 mapRegister.setWantMapNotify(true);
986 mapRegister.setNonce((long) 8);
987 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
988 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(address));
989 etlr.setMaskLength((short) mask);
990 etlr.setRecordTtl(254);
991 LocatorRecordBuilder record = new LocatorRecordBuilder();
992 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
993 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
994 etlr.getLocatorRecord().add(record.build());
995 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
996 mapRegister.getEidToLocatorRecord().add(etlr.build());
998 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
999 mapRegister.setAuthenticationData(zeros);
1001 sendMapRegister(mapRegister.build());
1002 assertNoPacketReceived(3000);
1004 mapRegister.setAuthenticationData(expectedSha);
1006 sendMapRegister(mapRegister.build());
1008 assertMapNotifyRecieved();
1011 public void testPasswordMaskMatch() throws Exception {
1013 LispIpv4Address addressInRange = LispAFIConvertor.asIPAfiAddress("10.20.30.40");
1014 LispIpv4Address addressOutOfRange = LispAFIConvertor.asIPAfiAddress("20.40.30.40");
1015 LispIpv4Address range = LispAFIConvertor.asIPAfiAddress("10.20.30.0");
1018 String pass = "pass";
1020 URL url = createPutURL("key");
1021 String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1023 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1024 // build a MapRegister
1025 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1027 mapRegister.setWantMapNotify(true);
1028 mapRegister.setNonce((long) 8);
1029 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1030 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressInRange));
1031 etlr.setMaskLength((short) mask);
1032 etlr.setRecordTtl(254);
1033 LocatorRecordBuilder record = new LocatorRecordBuilder();
1034 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1035 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1036 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1037 etlr.getLocatorRecord().add(record.build());
1038 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1039 mapRegister.getEidToLocatorRecord().add(etlr.build());
1041 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1043 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4, -67, -113, 104, -110, -71 });
1045 sendMapRegister(mapRegister.build());
1047 assertMapNotifyRecieved();
1049 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressOutOfRange));
1051 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123, -71, -14, -99, 67, -23, -73 });
1053 sendMapRegister(mapRegister.build());
1054 assertNoPacketReceived(3000);
1057 private MapReply registerAddressAndQuery(LispAFIAddress eid) throws SocketTimeoutException {
1058 return registerAddressAndQuery(eid, -1);
1061 // takes an address, packs it in a MapRegister and sends it
1062 private void registerAddress(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1063 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1064 mapRegisterBuilder.setWantMapNotify(true);
1065 mapRegisterBuilder.setKeyId((short) 0);
1066 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1067 mapRegisterBuilder.setNonce((long) 8);
1068 mapRegisterBuilder.setProxyMapReply(false);
1069 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1070 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1071 if (maskLength != -1) {
1072 etlrBuilder.setMaskLength((short) maskLength);
1074 etlrBuilder.setMaskLength((short) 0);
1076 etlrBuilder.setRecordTtl(254);
1077 etlrBuilder.setAction(Action.NoAction);
1078 etlrBuilder.setAuthoritative(false);
1079 etlrBuilder.setMapVersion((short) 0);
1080 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1081 recordBuilder.setLocalLocator(false);
1082 recordBuilder.setRlocProbed(false);
1083 recordBuilder.setRouted(true);
1084 recordBuilder.setMulticastPriority((short) 0);
1085 recordBuilder.setMulticastWeight((short) 0);
1086 recordBuilder.setPriority((short) 0);
1087 recordBuilder.setWeight((short) 0);
1088 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1089 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1090 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1091 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1092 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1093 sendMapRegister(mapRegisterBuilder.build());
1094 MapNotify mapNotify = receiveMapNotify();
1095 assertEquals(8, mapNotify.getNonce().longValue());
1098 private MapReply queryForAddress(LispAFIAddress eid, String srcEid) throws SocketTimeoutException {
1099 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1100 mapRequestBuilder.setNonce((long) 4);
1101 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1102 mapRequestBuilder.getEidRecord().add(
1103 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1104 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1105 if (srcEid != null) {
1106 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1107 toContainer(LispAFIConvertor.asIPAfiAddress(srcEid))).build());
1109 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1110 toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1112 mapRequestBuilder.getItrRloc().add(
1113 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1114 mapRequestBuilder.setAuthoritative(false);
1115 mapRequestBuilder.setMapDataPresent(false);
1116 mapRequestBuilder.setPitr(false);
1117 mapRequestBuilder.setProbe(false);
1118 mapRequestBuilder.setSmr(false);
1119 mapRequestBuilder.setSmrInvoked(false);
1120 sendMapRequest(mapRequestBuilder.build());
1121 return receiveMapReply();
1124 // takes an address, packs it in a MapRegister, sends it, returns the
1126 private MapReply registerAddressAndQuery(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1127 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1128 mapRegisterBuilder.setWantMapNotify(true);
1129 mapRegisterBuilder.setKeyId((short) 0);
1130 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1131 mapRegisterBuilder.setNonce((long) 8);
1132 mapRegisterBuilder.setProxyMapReply(false);
1133 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1134 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1135 if (maskLength != -1) {
1136 etlrBuilder.setMaskLength((short) maskLength);
1138 etlrBuilder.setMaskLength((short) 0);
1140 etlrBuilder.setRecordTtl(254);
1141 etlrBuilder.setAction(Action.NoAction);
1142 etlrBuilder.setAuthoritative(false);
1143 etlrBuilder.setMapVersion((short) 0);
1144 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1145 recordBuilder.setLocalLocator(false);
1146 recordBuilder.setRlocProbed(false);
1147 recordBuilder.setRouted(true);
1148 recordBuilder.setMulticastPriority((short) 0);
1149 recordBuilder.setMulticastWeight((short) 0);
1150 recordBuilder.setPriority((short) 0);
1151 recordBuilder.setWeight((short) 0);
1152 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1153 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1154 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1155 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1156 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1157 sendMapRegister(mapRegisterBuilder.build());
1158 MapNotify mapNotify = receiveMapNotify();
1159 assertEquals(8, mapNotify.getNonce().longValue());
1160 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1161 mapRequestBuilder.setNonce((long) 4);
1162 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1163 mapRequestBuilder.getEidRecord().add(
1164 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1165 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1166 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress)))
1168 mapRequestBuilder.getItrRloc().add(
1169 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1170 mapRequestBuilder.setAuthoritative(false);
1171 mapRequestBuilder.setMapDataPresent(false);
1172 mapRequestBuilder.setPitr(false);
1173 mapRequestBuilder.setProbe(false);
1174 mapRequestBuilder.setSmr(false);
1175 mapRequestBuilder.setSmrInvoked(false);
1176 sendMapRequest(mapRequestBuilder.build());
1177 return receiveMapReply();
1180 // ------------------------------- LCAF Tests ---------------------------
1183 public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1185 String ipString = "10.20.30.200";
1186 String macString = "01:02:03:04:05:06";
1187 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1188 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1189 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1190 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1191 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1192 builder.setSrcMaskLength((short) 32);
1193 builder.setDstMaskLength((short) 0);
1194 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1195 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1197 MapReply reply = registerAddressAndQuery(builder.build());
1199 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1200 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1201 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1203 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1204 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1206 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1207 assertTrue(receivedAddr2 instanceof LispMacAddress);
1209 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1210 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1212 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1213 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1217 public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1219 String ipString1 = "10.10.10.0";
1220 String ipString2 = "20.20.20.0";
1221 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString1);
1222 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend2 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString2);
1223 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1224 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1225 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1226 builder.setSrcMaskLength((short) 24);
1227 builder.setDstMaskLength((short) 24);
1228 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1229 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1231 LcafSourceDestAddr srcDst = builder.build();
1232 registerAddress(LispAFIConvertor.asIPAfiAddress(ipString2), 24);
1233 registerAddress(srcDst, -1);
1236 MapReply reply = queryForAddress(srcDst, null);
1238 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1239 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1240 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1242 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1243 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1245 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1246 assertTrue(receivedAddr2 instanceof LispIpv4Address);
1248 LispIpv4Address receivedIP1 = (LispIpv4Address) receivedAddr1;
1249 LispIpv4Address receivedIP2 = (LispIpv4Address) receivedAddr2;
1251 assertEquals(ipString1, receivedIP1.getIpv4Address().getValue());
1252 assertEquals(ipString2, receivedIP2.getIpv4Address().getValue());
1254 // srcEid/dstEid match
1255 reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "10.10.10.1");
1256 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1257 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1259 Ipv4Address ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1260 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1262 // dstEid match only
1263 reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "1.2.3.4");
1264 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1265 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1267 ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1268 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1272 public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1274 String ipString = "10.20.30.200";
1275 String macString = "01:02:03:04:05:06";
1276 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1277 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1278 LcafKeyValueAddressAddrBuilder builder = new LcafKeyValueAddressAddrBuilder();
1279 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1280 builder.setLcafType((short) LispCanonicalAddressFormatEnum.KEY_VALUE.getLispCode());
1281 builder.setKey(new KeyBuilder().setPrimitiveAddress(addrToSend1).build());
1282 builder.setValue(new ValueBuilder().setPrimitiveAddress(addrToSend2).build());
1284 MapReply reply = registerAddressAndQuery(builder.build());
1286 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1287 assertTrue(fromNetwork.getAddress() instanceof LcafKeyValue);
1288 LcafKeyValue keyValueFromNetwork = (LcafKeyValue) fromNetwork.getAddress();
1290 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress());
1291 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getValue().getPrimitiveAddress());
1293 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1294 assertTrue(receivedAddr2 instanceof LispMacAddress);
1296 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1297 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1299 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1300 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1303 public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1305 String macString = "01:02:03:04:05:06";
1306 String ipString = "10.20.255.30";
1307 LcafListAddrBuilder listbuilder = new LcafListAddrBuilder();
1308 listbuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.LIST.getLispCode());
1309 listbuilder.setAddresses(new ArrayList<Addresses>());
1310 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1311 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString))).build());
1313 MapReply reply = registerAddressAndQuery(listbuilder.build());
1315 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1317 assertTrue(receivedAddress instanceof LcafListAddress);
1319 LcafListAddress listAddrFromNetwork = (LcafListAddress) receivedAddress;
1320 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(0).getPrimitiveAddress());
1321 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(1).getPrimitiveAddress());
1323 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1324 assertTrue(receivedAddr2 instanceof LispMacAddress);
1326 assertEquals(macString, ((LispMacAddress) receivedAddr2).getMacAddress().getValue());
1327 assertEquals(ipString, ((LispIpv4Address) receivedAddr1).getIpv4Address().getValue());
1330 public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1332 String ipString = "10.20.255.30";
1334 LcafSegmentAddrBuilder builder = new LcafSegmentAddrBuilder();
1335 builder.setInstanceId((long) instanceId);
1336 builder.setIidMaskLength((short) 32);
1337 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.SEGMENT.getLispCode());
1338 builder.setAddress(new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1340 MapReply reply = registerAddressAndQuery(builder.build());
1342 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1343 assertTrue(receivedAddress instanceof LcafSegmentAddress);
1345 LcafSegmentAddress segmentfromNetwork = (LcafSegmentAddress) receivedAddress;
1346 LispAFIAddress addrFromSegment = LispAFIConvertor.toAFIfromPrimitive(segmentfromNetwork.getAddress().getPrimitiveAddress());
1347 assertTrue(addrFromSegment instanceof LispIpv4Address);
1348 assertEquals(ipString, ((LispIpv4Address) addrFromSegment).getIpv4Address().getValue());
1350 assertEquals(instanceId, segmentfromNetwork.getInstanceId().intValue());
1353 public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1355 String macString = "01:02:03:04:05:06";
1356 String ipString = "10.20.255.30";
1357 HopBuilder hopBuilder = new HopBuilder();
1358 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString)));
1359 Hop hop1 = hopBuilder.build();
1360 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString)));
1361 Hop hop2 = hopBuilder.build();
1362 HopsBuilder hb = new HopsBuilder();
1365 hb.setRLOCProbe(false);
1367 HopsBuilder hb2 = new HopsBuilder();
1369 hb2.setLookup(false);
1370 hb2.setRLOCProbe(true);
1371 hb2.setStrict(false);
1372 Hops hops1 = hb.build();
1373 Hops hops2 = hb2.build();
1374 LcafTrafficEngineeringAddrBuilder trafficBuilder = new LcafTrafficEngineeringAddrBuilder();
1375 trafficBuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType(
1376 (short) LispCanonicalAddressFormatEnum.TRAFFIC_ENGINEERING.getLispCode());
1377 trafficBuilder.setHops(new ArrayList<Hops>());
1378 trafficBuilder.getHops().add(hb.build());
1379 trafficBuilder.getHops().add(hb2.build());
1381 MapReply reply = registerAddressAndQuery(trafficBuilder.build());
1383 assertTrue(LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer()) instanceof LcafTrafficEngineeringAddress);
1385 LcafTrafficEngineeringAddress receivedAddress = (LcafTrafficEngineeringAddress) LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0)
1386 .getLispAddressContainer());
1388 ReencapHop receivedHop1 = receivedAddress.getHops().get(0);
1389 ReencapHop receivedHop2 = receivedAddress.getHops().get(1);
1391 assertEquals(true, hops1.isLookup());
1392 assertEquals(false, hops1.isRLOCProbe());
1393 assertEquals(true, hops1.isStrict());
1395 assertEquals(false, hops2.isLookup());
1396 assertEquals(true, hops2.isRLOCProbe());
1397 assertEquals(false, hops2.isStrict());
1399 assertTrue(receivedHop1.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4);
1400 assertTrue(receivedHop2.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac);
1402 assertEquals(ipString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) receivedHop1.getHop().getPrimitiveAddress()).getIpv4Address().getIpv4Address().getValue());
1403 assertEquals(macString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac) receivedHop2.getHop().getPrimitiveAddress()).getMacAddress().getMacAddress().getValue());
1406 public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1408 String ipString = "1.2.3.4";
1414 LcafApplicationDataAddrBuilder builder = new LcafApplicationDataAddrBuilder();
1415 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode());
1416 builder.setIpTos(ipTOs);
1417 builder.setProtocol(protocol);
1418 builder.setLocalPort(new PortNumber(localPort));
1419 builder.setRemotePort(new PortNumber(remotePort));
1420 builder.setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder()
1421 .setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1423 LcafApplicationDataAddress addressToSend = builder.build();
1425 MapReply reply = registerAddressAndQuery(addressToSend);
1427 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1429 assertTrue(receivedAddress instanceof LcafApplicationDataAddress);
1431 LcafApplicationDataAddress receivedApplicationDataAddress = (LcafApplicationDataAddress) receivedAddress;
1432 assertEquals(protocol, receivedApplicationDataAddress.getProtocol().intValue());
1433 assertEquals(ipTOs, receivedApplicationDataAddress.getIpTos().intValue());
1434 assertEquals(localPort, receivedApplicationDataAddress.getLocalPort().getValue().intValue());
1435 assertEquals(remotePort, receivedApplicationDataAddress.getRemotePort().getValue().intValue());
1437 LispIpv4Address ipAddressReceived = (LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(receivedApplicationDataAddress.getAddress().getPrimitiveAddress());
1438 assertEquals(ipString, ipAddressReceived.getIpv4Address().getValue());
1441 // ------------------- TimeOut Tests -----------
1443 public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1445 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1446 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1447 mapRequestBuilder.setNonce((long) 4);
1448 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1449 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1450 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1451 mapRequestBuilder.getEidRecord().add(
1452 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1453 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1454 mapRequestBuilder.getItrRloc().add(
1455 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1456 sendMapRequest(mapRequestBuilder.build());
1457 MapReply mapReply = receiveMapReply();
1458 assertEquals(4, mapReply.getNonce().longValue());
1459 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1460 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1461 mapRegisterbuilder.setWantMapNotify(true);
1462 mapRegisterbuilder.setNonce((long) 8);
1463 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1464 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1465 etlrBuilder.setMaskLength((short) 32);
1466 etlrBuilder.setRecordTtl(254);
1467 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1468 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
1469 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1470 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1471 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1472 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1473 sendMapRegister(mapRegisterbuilder.build());
1474 MapNotify mapNotify = receiveMapNotify();
1475 assertEquals(8, mapNotify.getNonce().longValue());
1476 sendMapRequest(mapRequestBuilder.build());
1477 mapReply = receiveMapReply();
1478 assertEquals(4, mapReply.getNonce().longValue());
1479 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1480 .getLispAddressContainer());
1481 causeEntryToBeCleaned();
1482 sendMapRequest(mapRequestBuilder.build());
1483 mapReply = receiveMapReply();
1484 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1487 public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1489 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1490 MapRequest mapRequest = createMapRequest(eid);
1492 testTTLBeforeRegister(mapRequest);
1494 registerForTTL(eid);
1496 testTTLAfterRegister(mapRequest);
1498 causeEntryToBeCleaned();
1499 testTTLAfterClean(mapRequest);
1502 testTTLAfterAutherize(mapRequest);
1506 private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1508 sendMapRequest(mapRequest);
1509 mapReply = receiveMapReply();
1510 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1513 private void causeEntryToBeCleaned() {
1514 // TODO for the time being, to keep master and stable/lithium in sync, we need to remove the forceful
1515 // expiration of DAO entries. Once we're past this, we'll have to expose methods to setTimeUnit(TimeUnit)
1516 // and cleanOld() (expired) entries in IFlowMapping (and perhaps ILispDAO) and use them here.
1520 private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1522 sendMapRequest(mapRequest);
1523 mapReply = receiveMapReply();
1524 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1525 .getLispAddressContainer());
1526 assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1529 private void registerForTTL(LispIpv4Address eid) throws SocketTimeoutException {
1530 MapRegister mapRegister = createMapRegister(eid);
1531 sendMapRegister(mapRegister);
1532 assertMapNotifyRecieved();
1535 private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1537 sendMapRequest(mapRequest);
1538 mapReply = receiveMapReply();
1539 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1542 private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1544 sendMapRequest(mapRequest);
1545 mapReply = receiveMapReply();
1546 assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1549 private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1550 assertEquals(expectedTTL, mapReply.getEidToLocatorRecord().get(0).getRecordTtl().intValue());
1551 assertEquals(expectedAction, mapReply.getEidToLocatorRecord().get(0).getAction());
1554 private MapRegister createMapRegister(LispAFIAddress eid, LispAFIAddress rloc) {
1555 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1556 mapRegisterbuilder.setWantMapNotify(true);
1557 mapRegisterbuilder.setNonce((long) 8);
1558 mapRegisterbuilder.setKeyId((short) 0);
1559 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1560 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1561 etlrBuilder.setMaskLength((short) 24);
1562 etlrBuilder.setRecordTtl(254);
1563 etlrBuilder.setAuthoritative(false);
1564 etlrBuilder.setAction(Action.NoAction);
1565 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1566 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
1567 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1568 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1569 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1570 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1571 MapRegister mapRegister = mapRegisterbuilder.build();
1575 private MapRegister createMapRegister(LispIpv4Address eid) {
1576 return createMapRegister(eid, LispAFIConvertor.asIPAfiAddress("4.3.2.1"));
1579 private MapRequest createMapRequest(LispAFIAddress eid) {
1580 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1581 mapRequestBuilder.setNonce((long) 4);
1582 mapRequestBuilder.setPitr(false);
1583 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1584 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1585 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1586 mapRequestBuilder.getEidRecord().add(
1587 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1588 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1589 mapRequestBuilder.getItrRloc().add(
1590 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1591 MapRequest mr = mapRequestBuilder.build();
1595 public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1597 String rloc = "127.0.0.3";
1598 int port = LispMessage.PORT_NUM;
1599 LispAFIAddress ipRloc = LispAFIConvertor.asIPAfiAddress(rloc);
1600 sendProxyMapRequest(rloc, port, ipRloc);
1604 public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1606 String rloc = "127.0.0.3";
1608 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1609 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1610 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1612 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1613 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1614 LOG.info("testNonProxyOtherPort:" + adLcaf.toString());
1615 sendProxyMapRequest(rloc, port, adLcaf);
1619 public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
1621 configLispPlugin.shouldListenOnXtrPort(true);
1622 notificationCalled = false;
1623 final String eid = "10.10.10.10";
1624 String rloc = "127.0.0.3";
1625 int port = LispMessage.XTR_PORT_NUM;
1626 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1627 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1628 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1630 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1631 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1632 final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1633 ((LispMappingService) lms).registerNotificationListener(XtrRequestMapping.class, new NotificationListener<XtrRequestMapping>() {
1636 public void onNotification(XtrRequestMapping notification) {
1637 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(),
1639 notificationCalled = true;
1640 LOG.warn("notification arrived");
1643 sendMapRequest(mapRequest, port);
1644 for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
1645 if (notificationCalled) {
1648 LOG.warn("notification hasn't arrived, sleeping...");
1653 fail("Notification hasn't arrived");
1657 private void sendProxyMapRequest(String rloc, int port, LispAFIAddress adLcaf) throws SocketTimeoutException, SocketException {
1658 String eid = "10.1.0.1";
1659 MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1660 sendMapRequest(mapRequest);
1661 DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
1662 MapRequest recievedMapRequest = receiveMapRequest(nonProxySocket);
1663 assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
1664 assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
1665 assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
1666 assertEquals(mapRequest.getEidRecord(), recievedMapRequest.getEidRecord());
1667 nonProxySocket.close();
1670 private MapRequest createNonProxyMapRequest(String eid, LispAFIAddress adLcaf) throws SocketTimeoutException {
1671 MapRegister mr = createMapRegister(LispAFIConvertor.asIPAfiAddress(eid));
1672 LocatorRecord record = new LocatorRecordBuilder(mr.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)).setLispAddressContainer(
1673 LispAFIConvertor.toContainer(adLcaf)).build();
1674 mr.getEidToLocatorRecord().get(0).getLocatorRecord().set(0, record);
1675 sendMapRegister(mr);
1676 assertMapNotifyRecieved();
1677 MapRequest mapRequest = createMapRequest(LispAFIConvertor.asIPAfiAddress(eid));
1678 MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
1679 builder.setPitr(true);
1680 mapRequest = builder.build();
1684 private void assertMapNotifyRecieved() throws SocketTimeoutException {
1688 private MapReply receiveMapReply() throws SocketTimeoutException {
1689 return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1692 private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
1693 return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(datagramSocket, 30000).getData()));
1696 private MapNotify receiveMapNotify() throws SocketTimeoutException {
1697 return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1700 private void sendMapRequest(MapRequest mapRequest) {
1701 sendMapRequest(mapRequest, LispMessage.PORT_NUM);
1704 private void sendMapRequest(MapRequest mapRequest, int port) {
1705 sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
1708 private void sendMapRegister(MapRegister mapRegister) {
1709 sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
1712 private void sendPacket(byte[] bytesToSend) {
1713 sendPacket(bytesToSend, LispMessage.PORT_NUM);
1716 private void sendPacket(byte[] bytesToSend, int port) {
1718 DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
1719 initPacketAddress(packet, port);
1720 LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
1721 socket.send(packet);
1722 } catch (Throwable t) {
1727 private DatagramPacket receivePacket() throws SocketTimeoutException {
1728 return receivePacket(6000);
1731 private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
1732 return receivePacket(socket, timeout);
1735 private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
1737 byte[] buffer = new byte[4096];
1738 DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
1739 LOG.trace("Waiting for packet from socket...");
1740 receivedSocket.setSoTimeout(timeout);
1741 receivedSocket.receive(receivePacket);
1742 LOG.trace("Recieved packet from socket!");
1743 return receivePacket;
1744 } catch (SocketTimeoutException ste) {
1746 } catch (Throwable t) {
1752 private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
1753 packet.setAddress(InetAddress.getByName(lispBindAddress));
1754 packet.setPort(port);
1757 private DatagramSocket initSocket(DatagramSocket socket, int port) {
1759 socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
1760 } catch (SocketException e) {
1761 e.printStackTrace();
1767 private byte[] extractWSUdpByteArray(String wiresharkHex) {
1768 final int HEADER_LEN = 42;
1769 byte[] res = new byte[1000];
1770 String[] split = wiresharkHex.split(" ");
1772 for (String cur : split) {
1774 if (cur.length() == 2) {
1776 if (counter > HEADER_LEN) {
1777 res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
1782 return Arrays.copyOf(res, counter - HEADER_LEN);
1785 private String stateToString(int state) {
1789 case Bundle.INSTALLED:
1791 case Bundle.RESOLVED:
1793 case Bundle.UNINSTALLED:
1794 return "UNINSTALLED";
1796 return "Not CONVERTED";
1800 @SuppressWarnings({ "rawtypes", "unchecked" })
1801 private void areWeReady() throws InvalidSyntaxException {
1803 boolean debugit = false;
1804 Bundle b[] = bc.getBundles();
1805 for (Bundle element : b) {
1806 int state = element.getState();
1807 LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v" + element.getVersion() + ", state:"
1808 + stateToString(state));
1809 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
1810 LOG.trace("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
1813 // String host = element.getHeaders().get("FRAGMENT-HOST");
1814 // if (host != null) {
1815 // LOG.warn("Bundle " + element.getSymbolicName() +
1816 // " is a fragment which is part of: " + host);
1817 // LOG.warn("Required imports are: " +
1818 // element.getHeaders().get("IMPORT-PACKAGE"));
1822 // } catch (BundleException e) {
1823 // LOG.error("BundleException:", e);
1832 LOG.warn(("Do some debugging because some bundle is unresolved"));
1834 // assertNotNull(broker);
1837 ServiceReference r = null;
1838 while (this.lms == null && retry < MAX_SERVICE_LOAD_RETRIES) {
1840 r = bc.getServiceReference(IFlowMapping.class.getName());
1841 // r.getPropertyKeys();
1843 this.lms = (IFlowMapping) bc.getService(r);
1847 } catch (InterruptedException e) {
1853 assertNotNull(IFlowMapping.class.getName() + " service wasn't found in bundle context ", this.lms);
1855 r = bc.getServiceReference(ILispDAO.class.getName());
1857 this.clusterService = (ClusterDAOService) bc.getService(r);
1860 assertNotNull(ILispDAO.class.getName() + " service wasn't found in bundle context ", this.clusterService);
1861 r = bc.getServiceReference(IConfigLispSouthboundPlugin.class.getName());
1863 this.configLispPlugin = (IConfigLispSouthboundPlugin) bc.getService(r);
1866 assertNotNull(IConfigLispSouthboundPlugin.class.getName() + " service wasn't found in bundle context ", this.configLispPlugin);
1867 configLispPlugin.setLispAddress(lispBindAddress);
1869 // Uncomment this code to Know which services were actually loaded to
1872 * for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
1873 * LOG.trace(sr.getBundle().getSymbolicName());
1874 * LOG.trace(sr.toString()); }
1878 } catch (InterruptedException e) {
1882 private void cleanUP() {
1885 configLispPlugin.shouldListenOnXtrPort(false);
1886 socket = initSocket(socket, LispMessage.PORT_NUM);