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;
35 import java.util.concurrent.TimeUnit;
37 import javax.inject.Inject;
39 import org.apache.commons.codec.binary.Base64;
40 import org.codehaus.jettison.json.JSONException;
41 import org.codehaus.jettison.json.JSONObject;
42 import org.codehaus.jettison.json.JSONTokener;
43 import org.junit.After;
44 import org.junit.Before;
45 import org.junit.Test;
46 import org.junit.runner.RunWith;
47 import org.opendaylight.controller.sal.binding.api.NotificationListener;
48 import org.opendaylight.lispflowmapping.clusterdao.ClusterDAOService;
49 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
50 import org.opendaylight.lispflowmapping.implementation.serializer.LispMessage;
51 import org.opendaylight.lispflowmapping.implementation.serializer.MapNotifySerializer;
52 import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
53 import org.opendaylight.lispflowmapping.implementation.serializer.MapReplySerializer;
54 import org.opendaylight.lispflowmapping.implementation.serializer.MapRequestSerializer;
55 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
56 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
57 import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
58 import org.opendaylight.lispflowmapping.type.AddressFamilyNumberEnum;
59 import org.opendaylight.lispflowmapping.type.LispCanonicalAddressFormatEnum;
60 import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafApplicationDataAddress;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafListAddress;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafSegmentAddress;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LcafTrafficEngineeringAddress;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispIpv4Address;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispMacAddress;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.ReencapHop;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.XtrRequestMapping;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecord;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidrecords.EidRecordBuilder;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.KeyBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafkeyvalueaddress.ValueBuilder;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.Addresses;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaflistaddress.AddressesBuilder;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsegmentaddress.AddressBuilder;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.DstAddressBuilder;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafsourcedestaddress.SrcAddressBuilder;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.Hops;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcaftrafficengineeringaddress.HopsBuilder;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.LispAddressContainer;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafKeyValue;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.LcafSourceDest;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.ipv4.Ipv4Address;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddr;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafapplicationdata.LcafApplicationDataAddrBuilder;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafkeyvalue.LcafKeyValueAddressAddrBuilder;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaflist.LcafListAddrBuilder;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsegment.LcafSegmentAddrBuilder;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddr;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcafsourcedest.LcafSourceDestAddrBuilder;
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.lcaftrafficengineering.LcafTrafficEngineeringAddrBuilder;
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRloc;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.ItrRlocBuilder;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequest.SourceEidBuilder;
107 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.maprequestnotification.MapRequestBuilder;
108 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.Hop;
109 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.reencaphop.HopBuilder;
110 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
111 import org.ops4j.pax.exam.Configuration;
112 import org.ops4j.pax.exam.Option;
113 import org.ops4j.pax.exam.junit.PaxExam;
114 import org.osgi.framework.Bundle;
115 import org.osgi.framework.BundleContext;
116 import org.osgi.framework.InvalidSyntaxException;
117 import org.osgi.framework.ServiceReference;
118 import org.slf4j.Logger;
119 import org.slf4j.LoggerFactory;
121 @RunWith(PaxExam.class)
122 public class MappingServiceIntegrationTest {
124 private IFlowMapping lms;
125 private ClusterDAOService clusterService;
126 protected static final Logger LOG = LoggerFactory.getLogger(MappingServiceIntegrationTest.class);
127 private byte[] mapRequestPacket;
128 private byte[] mapRegisterPacketWithNotify;
129 private byte[] mapRegisterPacketWithoutNotify;
130 private IConfigLispSouthboundPlugin configLispPlugin;
131 String lispBindAddress = "127.0.0.1";
132 String ourAddress = "127.0.0.2";
133 private LispAFIAddress locatorEid;
134 private DatagramSocket socket;
135 private byte[] mapRegisterPacketWithAuthenticationAndMapNotify;
137 public static final String ODL = "org.opendaylight.controller";
138 public static final String YANG = "org.opendaylight.yangtools";
139 public static final String JERSEY = "com.sun.jersey";
140 private static final int MAX_SERVICE_LOAD_RETRIES = 45;
141 private static final int MAX_NOTIFICATION_RETRYS = 20;
144 public void after() {
145 if (socket != null) {
148 if (connection != null) {
149 connection.disconnect();
154 public void before() throws Exception {
156 locatorEid = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
157 socket = initSocket(socket, LispMessage.PORT_NUM);
159 // SRC: 127.0.0.1:58560 to 127.0.0.1:4342
160 // LISP(Type = 8 - Encapsulated)
161 // IP: 192.168.136.10 -> 153.16.254.1
163 // LISP(Type = 1 Map-Request
167 // Source EID not present
168 // Nonce: 0x3d8d2acd39c8d608
169 // ITR-RLOC AFI=1 Address=192.168.136.10
170 // Record 1: 153.16.254.1/32
171 mapRequestPacket = extractWSUdpByteArray(new String("0000 00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 " //
172 + "0010 00 58 00 00 40 00 40 11 3c 93 7f 00 00 01 7f 00 "
173 + "0020 00 01 e4 c0 10 f6 00 44 fe 57 80 00 00 00 45 00 "
174 + "0030 00 3c d4 31 00 00 ff 11 56 f3 7f 00 00 02 99 10 "
175 + "0040 fe 01 dd b4 10 f6 00 28 ef 3a 10 00 00 01 3d 8d "
176 + "0050 2a cd 39 c8 d6 08 00 01 01 02 03 04 00 01 7f 00 00 02 00 20 " //
177 + "0060 00 01 99 10 fe 01"));
179 // IP: 192.168.136.10 -> 128.223.156.35
180 // UDP: 49289 -> 4342
181 // LISP(Type = 3 Map-Register, P=1, M=1
185 // AuthDataLength: 20 Data:
186 // e8:f5:0b:c5:c5:f2:b0:21:27:a8:21:41:04:f3:46:5a:a5:68:89:ec
187 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
189 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
190 // Priority/Weight: 1/100, Multicast Priority/Weight:
194 mapRegisterPacketWithAuthenticationAndMapNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
195 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
196 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
197 + "0030 00 00 00 00 00 00 00 01 00 14 0e a4 c6 d8 a4 06 "
198 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
199 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
200 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
202 // IP: 192.168.136.10 -> 128.223.156.35
203 // UDP: 49289 -> 4342
204 // LISP(Type = 3 Map-Register, P=1, M=1
207 // Key ID: 0x0000 NO AUTHENTICATION!!
208 // AuthDataLength: 00 Data:
209 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
211 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
212 // Priority/Weight: 1/100, Multicast Priority/Weight:
216 mapRegisterPacketWithNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
217 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
218 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 01 01 00 00 "
219 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
220 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
221 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
222 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
224 // IP: 192.168.136.10 -> 128.223.156.35
225 // UDP: 49289 -> 4342
226 // LISP(Type = 3 Map-Register, P=1, M=1
229 // Key ID: 0x0000 NO AUTHENTICATION!!
230 // AuthDataLength: 00 Data:
231 // EID prefix: 153.16.254.1/32 (EID=0x9910FE01), TTL: 10, Authoritative,
233 // Local RLOC: 192.168.136.10 (RLOC=0xC0A8880A), Reachable,
234 // Priority/Weight: 1/100, Multicast Priority/Weight:
238 mapRegisterPacketWithoutNotify = extractWSUdpByteArray(new String("0000 00 50 56 ee d1 4f 00 0c 29 7a ce 79 08 00 45 00 " //
239 + "0010 00 5c 00 00 40 00 40 11 d4 db c0 a8 88 0a 80 df "
240 + "0020 9c 23 d6 40 10 f6 00 48 59 a4 38 00 00 01 00 00 "
241 + "0030 00 00 00 00 00 07 00 00 00 14 0e a4 c6 d8 a4 06 "
242 + "0040 71 7c 33 a4 5c 4a 83 1c de 74 53 03 0c ad 00 00 "
243 + "0050 00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
244 + "0060 ff 00 00 05 00 01 c0 a8 88 0a"));
248 private BundleContext bc;
249 private HttpURLConnection connection;
250 protected static boolean notificationCalled;
252 // Configure the OSGi container
254 public Option[] config() {
255 return options(MappingServiceTestHelper.mappingServiceBundlesWithClusterDAO());
259 public void testSimpleUsage() throws Exception {
261 mapRegisterWithMapNotify();
262 mapRegisterWithMapNotifyAndMapRequest();
263 registerAndQuery__MAC();
264 mapRequestMapRegisterAndMapRequest();
265 mapRegisterWithAuthenticationWithoutConfiguringAKey();
266 mapRegisterWithoutMapNotify();
270 public void testLCAFs() throws Exception {
271 registerAndQuery__SrcDestLCAF();
272 registerAndQuery__SrcDestLCAFOverlap();
273 registerAndQuery__KeyValueLCAF();
274 registerAndQuery__ListLCAF();
275 registerAndQuery__ApplicationData();
276 registerAndQuery__TrafficEngineering();
277 registerAndQuery__SegmentLCAF();
281 public void testMask() throws Exception {
282 testPasswordExactMatch();
283 testPasswordMaskMatch();
284 eidPrefixLookupIPv4();
285 eidPrefixLookupIPv6();
289 public void testNorthbound() throws Exception {
291 northboundAddMapping();
292 northboundDeleteMapping();
293 northboundRetrieveKey();
294 northboundRetrieveMapping();
295 northboundRetrieveSourceDestKey();
296 northboundRetrieveSourceDestMapping();
300 public void testOverWriting() throws Exception {
301 //testMapRegisterDosntOverwritesOtherSubKeys();
302 testMapRegisterOverwritesSameSubkey();
303 testMapRegisterOverwritesNoSubkey();
304 testMapRegisterDoesntOverwritesNoSubkey();
308 public void testTimeOuts() throws Exception {
309 mapRequestMapRegisterAndMapRequestTestTimeout();
310 mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse();
314 public void testNonProxy() throws Throwable {
315 testSimpleNonProxy();
316 testNonProxyOtherPort();
317 testRecievingNonProxyOnXtrPort();
321 public void testSmr() throws Exception {
322 registerQueryRegisterWithSmr();
325 // ------------------------------- Simple Tests ---------------------------
327 public void mapRequestSimple() throws SocketTimeoutException {
330 // This Map-Request is sent from a source port different from 4342
331 // We close and bind the socket on the correct port
332 if (socket != null) {
335 socket = initSocket(socket, 56756);
337 sendPacket(mapRequestPacket);
338 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
339 MapReply reply = MapReplySerializer.getInstance().deserialize(readBuf);
340 assertEquals(4435248268955932168L, reply.getNonce().longValue());
344 public void mapRegisterWithMapNotify() throws SocketTimeoutException {
346 sendPacket(mapRegisterPacketWithNotify);
347 MapNotify reply = receiveMapNotify();
348 assertEquals(7, reply.getNonce().longValue());
351 public void mapRegisterWithMapNotifyAndMapRequest() throws SocketTimeoutException {
353 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
355 MapReply mapReply = registerAddressAndQuery(eid, 32);
357 assertEquals(4, mapReply.getNonce().longValue());
358 assertEquals(LispAFIConvertor.toContainer(locatorEid), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
359 .getLispAddressContainer());
363 public void registerAndQuery__MAC() throws SocketTimeoutException {
365 String macAddress = "01:02:03:04:05:06";
367 MapReply reply = registerAddressAndQuery(LispAFIConvertor.asMacAfiAddress(macAddress));
370 LispAFIAddress addressFromNetwork = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
371 assertTrue(addressFromNetwork instanceof LispMacAddress);
372 String macAddressFromReply = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.mac.MacAddress) addressFromNetwork).getMacAddress().getValue();
374 assertEquals(macAddress, macAddressFromReply);
377 public void mapRequestMapRegisterAndMapRequest() throws SocketTimeoutException {
379 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
380 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
381 mapRequestBuilder.setNonce((long) 4);
382 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
383 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
384 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
385 mapRequestBuilder.getEidRecord().add(
386 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
387 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
388 mapRequestBuilder.getItrRloc().add(
389 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
390 sendMapRequest(mapRequestBuilder.build());
391 MapReply mapReply = receiveMapReply();
392 assertEquals(4, mapReply.getNonce().longValue());
393 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
394 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
395 mapRegisterbuilder.setWantMapNotify(true);
396 mapRegisterbuilder.setNonce((long) 8);
397 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
398 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
399 etlrBuilder.setMaskLength((short) 32);
400 etlrBuilder.setRecordTtl(254);
401 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
402 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
403 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
404 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
405 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
406 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
407 sendMapRegister(mapRegisterbuilder.build());
408 MapNotify mapNotify = receiveMapNotify();
409 assertEquals(8, mapNotify.getNonce().longValue());
410 sendMapRequest(mapRequestBuilder.build());
411 mapReply = receiveMapReply();
412 assertEquals(4, mapReply.getNonce().longValue());
413 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
414 .getLispAddressContainer());
418 public void testMapRegisterDosntOverwritesOtherSubKeys() throws SocketTimeoutException {
420 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
421 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
422 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey1", LispAFIConvertor.toPrimitive(rloc1Value));
423 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
424 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey2", LispAFIConvertor.toPrimitive(rloc2Value));
425 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
426 assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
427 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
428 assertEquals(LispAFIConvertor.toContainer(rloc1), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer());
431 public void testMapRegisterOverwritesSameSubkey() throws SocketTimeoutException {
433 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
434 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
435 LispAFIAddress rloc1 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc1Value));
436 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
437 LispAFIAddress rloc2 = LispAFIConvertor.asKeyValue("subkey", LispAFIConvertor.toPrimitive(rloc2Value));
438 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1, rloc2);
439 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
440 assertEquals(LispAFIConvertor.toContainer(rloc2), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
443 public void testMapRegisterOverwritesNoSubkey() throws SocketTimeoutException {
445 lms.setOverwrite(true);
446 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
447 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
448 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
449 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
450 assertEquals(1, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
451 assertEquals(LispAFIConvertor.toContainer(rloc2Value), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
452 .getLispAddressContainer());
455 public void testMapRegisterDoesntOverwritesNoSubkey() throws SocketTimeoutException {
457 lms.setOverwrite(false);
458 LispAFIAddress eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
459 LispAFIAddress rloc1Value = LispAFIConvertor.asIPAfiAddress("4.3.2.1");
460 LispAFIAddress rloc2Value = LispAFIConvertor.asIPAfiAddress("4.3.2.2");
461 MapReply mapReply = sendMapRegisterTwiceWithDiffrentValues(eid, rloc1Value, rloc2Value);
462 assertEquals(2, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
463 LispAddressContainer rloc1ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer();
464 LispAddressContainer rloc2ReturnValueContainer = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(1).getLispAddressContainer();
465 assertTrue((LispAFIConvertor.toContainer(rloc1Value).equals(rloc1ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
466 rloc2ReturnValueContainer))
467 || (LispAFIConvertor.toContainer(rloc1Value).equals(rloc2ReturnValueContainer) && LispAFIConvertor.toContainer(rloc2Value).equals(
468 rloc1ReturnValueContainer)));
471 private MapReply sendMapRegisterTwiceWithDiffrentValues(LispAFIAddress eid, LispAFIAddress rloc1, LispAFIAddress rloc2)
472 throws SocketTimeoutException {
473 MapRegister mb = createMapRegister(eid, rloc1);
474 MapNotify mapNotify = lms.handleMapRegister(mb, false);
475 MapRequest mr = createMapRequest(eid);
476 MapReply mapReply = lms.handleMapRequest(mr);
477 assertEquals(mb.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0)
478 .getLocatorRecord().get(0).getLispAddressContainer());
479 mb = createMapRegister(eid, rloc2);
480 mapNotify = lms.handleMapRegister(mb, false);
481 assertEquals(8, mapNotify.getNonce().longValue());
482 mr = createMapRequest(eid);
484 mapReply = lms.handleMapRequest(mr);
488 public void mapRegisterWithAuthenticationWithoutConfiguringAKey() throws SocketTimeoutException {
490 sendPacket(mapRegisterPacketWithAuthenticationAndMapNotify);
493 // If didn't timeout then fail:
495 } catch (SocketTimeoutException ste) {
499 public void mapRegisterWithoutMapNotify() {
501 sendPacket(mapRegisterPacketWithoutNotify);
504 // If didn't timeout then fail:
506 } catch (SocketTimeoutException ste) {
510 public void registerQueryRegisterWithSmr() throws SocketTimeoutException {
512 lms.setShouldUseSmr(true);
514 sendPacket(mapRegisterPacketWithNotify);
517 sendPacket(mapRequestPacket);
520 } catch (InterruptedException e) {
523 mapRegisterPacketWithoutNotify[mapRegisterPacketWithoutNotify.length - 1] += 1;
524 sendPacket(mapRegisterPacketWithoutNotify);
526 ByteBuffer readBuf = ByteBuffer.wrap(receivePacket().getData());
527 MapRequest smr = MapRequestSerializer.getInstance().deserialize(readBuf);
528 assertTrue(smr.isSmr());
529 LispAddressContainer smrEid = smr.getEidRecord().get(0).getLispAddressContainer();
530 assertTrue(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("153.16.254.1")).equals(smrEid));
533 // --------------------- Northbound Tests ---------------------------
535 private void northboundAddKey() throws Exception {
537 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
539 String pass = "asdf";
541 URL url = createPutURL("key");
542 String authKeyJSON = createAuthKeyJSON(pass, address, mask);
543 callURL("PUT", "application/json", "text/plain", authKeyJSON, url);
545 String retrievedKey = lms.getAuthenticationKey(LispAFIConvertor.toContainer(address), mask);
547 // Check stored password matches the one sent
548 assertEquals(pass, retrievedKey);
552 private void northboundRetrieveSourceDestKey() throws Exception {
554 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
555 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
556 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
557 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
560 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
561 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
562 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
563 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
564 String pass = "asdf";
566 lms.addAuthenticationKey(LispAFIConvertor.toContainer(sourceDestAddress), mask1, pass);
568 // URL url = createGetKeyIPv4URL(address1, mask1);
569 URL url = createGetKeySourceDestURL(address1.getIpv4Address().getAfi(),
570 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getSrcAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getSrcMaskLength(),
571 ((LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(sourceDestAddress.getDstAddress().getPrimitiveAddress())).getIpv4Address().getValue(), sourceDestAddress.getDstMaskLength());
572 String reply = callURL("GET", null, "application/json", null, url);
573 JSONTokener jt = new JSONTokener(reply);
574 JSONObject json = new JSONObject(jt);
576 // test that the password matches what was we expected.
577 assertEquals(pass, json.get("key"));
581 private void northboundRetrieveKey() throws Exception {
583 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
585 String pass = "asdf";
587 lms.addAuthenticationKey(LispAFIConvertor.toContainer(address), mask, pass);
589 URL url = createGetKeyIPv4URL(address, mask);
590 String reply = callURL("GET", null, "application/json", null, url);
591 JSONTokener jt = new JSONTokener(reply);
592 JSONObject json = new JSONObject(jt);
594 // test that the password matches what was we expected.
595 assertEquals(pass, json.get("key"));
599 private String createAuthKeyJSON(String key, LispIpv4Address address, int mask) {
600 return "{\"key\" : \"" + key + "\",\"maskLength\" : " + mask + ",\"address\" : " + "{\"ipAddress\" : \""
601 + address.getIpv4Address().getValue() + "\",\"afi\" : " + address.getAfi().shortValue() + "}}";
604 private void northboundAddMapping() throws Exception {
606 String pass = "asdf";
607 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
609 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
611 // NB add mapping always checks the key
612 lms.addAuthenticationKey(LispAFIConvertor.toContainer(eid), mask, pass);
614 URL url = createPutURL("mapping");
615 String mapRegisterJSON = createMapRegisterJSON(pass, eid, mask, rloc);
616 callURL("PUT", "application/json", "text/plain", mapRegisterJSON, url);
618 // Retrieve the RLOC from the database
619 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
620 mapRequestBuilder.setPitr(false);
621 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
622 mapRequestBuilder.getEidRecord().add(
623 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
624 MapReply mapReply = lms.handleMapRequest(mapRequestBuilder.build());
626 LispIpv4Address retrievedRloc = (LispIpv4Address) LispAFIConvertor.toAFI(
627 mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
629 assertEquals(rloc.getIpv4Address().getValue(), retrievedRloc.getIpv4Address().getValue());
633 private String createMapRegisterJSON(String key, LispIpv4Address eid, int mask, LispIpv4Address rloc) {
634 String jsonString = "{ " + "\"key\" : \"" + key + "\"," + "\"mapregister\" : " + "{ " + "\"proxyMapReply\" : false, "
635 + "\"eidToLocatorRecords\" : " + "[ " + "{ " + "\"authoritative\" : true," + "\"prefixGeneric\" : " + "{ " + "\"ipAddress\" : \""
636 + eid.getIpv4Address().getValue() + "\"," + "\"afi\" : " + eid.getAfi().shortValue() + "}," + "\"mapVersion\" : 0,"
637 + "\"maskLength\" : " + mask + ", " + "\"action\" : \"NoAction\"," + "\"locators\" : " + "[ " + "{ " + "\"multicastPriority\" : 1,"
638 + "\"locatorGeneric\" : " + "{ " + "\"ipAddress\" : \"" + rloc.getIpv4Address().getValue() + "\"," + "\"afi\" : "
639 + rloc.getAfi().shortValue() + "}, " + "\"routed\" : true," + "\"multicastWeight\" : 50," + "\"rlocProbed\" : false, "
640 + "\"localLocator\" : false, " + "\"priority\" : 1, " + "\"weight\" : 50 " + "} " + "], " + "\"recordTtl\" : 100" + "} " + "], "
641 + "\"nonce\" : 3," + "\"keyId\" : 0 " + "} " + "}";
646 private void northboundRetrieveMapping() throws Exception {
648 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
650 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
651 // Insert mapping in the database
652 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
653 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
654 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
655 etlr.setMaskLength((short) mask);
656 etlr.setRecordTtl(254);
657 etlr.setAuthoritative(false);
658 etlr.setAction(Action.NoAction);
659 LocatorRecordBuilder record = new LocatorRecordBuilder();
660 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
661 record.setRouted(true);
662 record.setRlocProbed(false);
663 record.setLocalLocator(false);
664 record.setPriority((short) 1);
665 record.setWeight((short) 50);
666 record.setMulticastPriority((short) 1);
667 record.setMulticastWeight((short) 1);
668 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
669 etlr.getLocatorRecord().add(record.build());
670 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
671 mapRegister.getEidToLocatorRecord().add(etlr.build());
672 lms.handleMapRegister(mapRegister.build(), false);
674 // Get mapping using NB interface. No IID used
675 URL url = createGetMappingIPv4URL(0, eid, mask);
676 String reply = callURL("GET", null, "application/json", null, url);
677 JSONTokener jt = new JSONTokener(reply);
678 JSONObject json = new JSONObject(jt);
680 // With just one locator, locators is not a JSONArray
681 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
683 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
687 private void northboundDeleteMapping() throws Exception {
689 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("10.0.0.1");
691 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
692 // Insert mapping in the database
693 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
694 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
695 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
696 etlr.setMaskLength((short) mask);
697 etlr.setRecordTtl(254);
698 etlr.setAuthoritative(false);
699 etlr.setAction(Action.NoAction);
700 LocatorRecordBuilder record = new LocatorRecordBuilder();
701 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
702 record.setRouted(true);
703 record.setRlocProbed(false);
704 record.setLocalLocator(false);
705 record.setPriority((short) 1);
706 record.setWeight((short) 50);
707 record.setMulticastPriority((short) 1);
708 record.setMulticastWeight((short) 1);
709 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
710 etlr.getLocatorRecord().add(record.build());
711 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
712 mapRegister.getEidToLocatorRecord().add(etlr.build());
713 lms.handleMapRegister(mapRegister.build(), false);
715 // Delete mapping using NB interface. No IID used
716 URL url = createDeleteMappingIPv4URL(0, eid, mask);
717 String reply = callURL("DELETE", null, "application/json", null, url);
719 // Get mapping using NB interface. No IID used
720 url = createGetMappingIPv4URL(0, eid, mask);
721 reply = callURL("GET", null, "application/json", null, url);
722 JSONTokener jt = new JSONTokener(reply);
723 JSONObject json = new JSONObject(jt);
725 // With just one locator, locators is not a JSONArray
726 assertEquals(json.getJSONArray("locators").length(), 0);
729 private void northboundRetrieveSourceDestMapping() throws Exception {
731 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
732 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.1"));
733 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
734 .toPrimitive(LispAFIConvertor.asIPAfiAddress("10.0.0.2"));
737 LcafSourceDestAddr sourceDestAddress = new LcafSourceDestAddrBuilder().setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
738 .setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode())
739 .setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(address1).build()).setSrcMaskLength((short) mask1)
740 .setDstAddress(new DstAddressBuilder().setPrimitiveAddress(address2).build()).setDstMaskLength((short) mask2).build();
741 LispIpv4Address rloc = LispAFIConvertor.asIPAfiAddress("20.0.0.2");
743 // Insert mapping in the database
744 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
745 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
746 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(sourceDestAddress));
747 etlr.setMaskLength((short) mask1);
748 etlr.setRecordTtl(254);
749 etlr.setAuthoritative(false);
750 etlr.setAction(Action.NoAction);
751 LocatorRecordBuilder record = new LocatorRecordBuilder();
752 record.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
753 record.setRouted(true);
754 record.setRlocProbed(false);
755 record.setLocalLocator(false);
756 record.setPriority((short) 1);
757 record.setWeight((short) 50);
758 record.setMulticastPriority((short) 1);
759 record.setMulticastWeight((short) 1);
760 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
761 etlr.getLocatorRecord().add(record.build());
762 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
763 mapRegister.getEidToLocatorRecord().add(etlr.build());
764 lms.handleMapRegister(mapRegister.build(), false);
766 // Get mapping using NB interface. No IID used
767 URL url = createGetMappingSourceDestURL(address1.getIpv4Address().getAfi(),
768 address1.getIpv4Address().getIpv4Address().getValue(),
770 address2.getIpv4Address().getIpv4Address().getValue(),
772 String reply = callURL("GET", null, "application/json", null, url);
773 JSONTokener jt = new JSONTokener(reply);
774 JSONObject json = new JSONObject(jt);
776 // With just one locator, locators is not a JSONArray
777 String rlocRetrieved = json.getJSONArray("locators").getJSONObject(0).getJSONObject("locatorGeneric").getString("ipAddress");
779 assertEquals(rloc.getIpv4Address().getValue(), rlocRetrieved);
783 private URL createGetKeyIPv4URL(LispIpv4Address address, int mask) throws MalformedURLException {
784 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d", "key", address.getAfi().shortValue(),
785 address.getIpv4Address().getValue(), mask);
786 URL url = new URL(restUrl);
790 private URL createGetKeySourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
791 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "key", afi, srcAddress, srcMask,
792 dstAddress, dstMask);
793 URL url = new URL(restUrl);
797 private URL createGetMappingSourceDestURL(int afi, String srcAddress, int srcMask, String dstAddress, int dstMask) throws MalformedURLException {
798 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/0/%d/%s/%d/%s/%d", "mapping", afi, srcAddress,
799 srcMask, dstAddress, dstMask);
800 URL url = new URL(restUrl);
804 private URL createGetMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
805 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
806 .shortValue(), address.getIpv4Address().getValue(), mask);
807 URL url = new URL(restUrl);
811 private URL createDeleteMappingIPv4URL(int iid, LispIpv4Address address, int mask) throws MalformedURLException {
812 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s/%d/%d/%s/%d", "mapping", iid, address.getAfi()
813 .shortValue(), address.getIpv4Address().getValue(), mask);
814 URL url = new URL(restUrl);
818 private URL createPutURL(String resource) throws MalformedURLException {
820 String restUrl = String.format("http://localhost:8080/lispflowmapping/nb/v2/default/%s", resource);
822 URL url = new URL(restUrl);
826 private String createAuthenticationString() {
827 String authString = "admin:admin";
828 byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
829 String authStringEnc = new String(authEncBytes);
830 return authStringEnc;
833 private String callURL(String method, String content, String accept, String body, URL url) throws IOException, JSONException {
834 String authStringEnc = createAuthenticationString();
835 connection = (HttpURLConnection) url.openConnection();
836 connection.setRequestMethod(method);
837 connection.setRequestProperty("Authorization", "Basic " + authStringEnc);
838 if (content != null) {
839 connection.setRequestProperty("Content-Type", content);
841 if (accept != null) {
842 connection.setRequestProperty("Accept", accept);
845 // now add the request body
846 connection.setDoOutput(true);
847 OutputStreamWriter wr = new OutputStreamWriter(connection.getOutputStream());
851 connection.connect();
853 // getting the result, first check response code
854 Integer httpResponseCode = connection.getResponseCode();
856 if (httpResponseCode > 299) {
857 LOG.trace("HTTP Address: " + url);
858 LOG.trace("HTTP Response Code: " + httpResponseCode);
862 InputStream is = connection.getInputStream();
863 BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
864 StringBuilder sb = new StringBuilder();
866 while ((cp = rd.read()) != -1) {
867 sb.append((char) cp);
870 connection.disconnect();
871 return (sb.toString());
874 // timePeriod - in ms
875 public void assertNoPacketReceived(int timePeriod) {
877 receivePacket(timePeriod);
878 // If didn't timeout then fail:
880 } catch (SocketTimeoutException ste) {
884 // ------------------------------- Mask Tests ---------------------------
886 public void eidPrefixLookupIPv4() throws SocketTimeoutException {
888 runPrefixTest(LispAFIConvertor.asIPAfiAddress("1.2.3.4"), 16, LispAFIConvertor.asIPAfiAddress("1.2.3.2"),
889 LispAFIConvertor.asIPAfiAddress("1.1.1.1"), (byte) 32);
892 public void eidPrefixLookupIPv6() throws SocketTimeoutException {
894 runPrefixTest(LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:6:7:8"), 64, LispAFIConvertor.asIPv6AfiAddress("1:2:3:4:5:1:2:3"),
895 LispAFIConvertor.asIPv6AfiAddress("1:2:3:1:2:3:1:2"), 128);
898 private void runPrefixTest(LispAFIAddress registerEID, int registerdMask, LispAFIAddress matchedAddress, LispAFIAddress unMatchedAddress, int mask)
899 throws SocketTimeoutException {
901 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
902 mapRegister.setWantMapNotify(true);
903 mapRegister.setNonce((long) 8);
904 mapRegister.setWantMapNotify(true);
905 mapRegister.setKeyId((short) 0);
906 mapRegister.setAuthenticationData(new byte[0]);
907 mapRegister.setNonce((long) 8);
908 mapRegister.setProxyMapReply(false);
909 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
910 etlr.setRecordTtl(254);
911 etlr.setAction(Action.NoAction);
912 etlr.setAuthoritative(false);
913 etlr.setMapVersion((short) 0);
914 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(registerEID));
915 etlr.setMaskLength((short) registerdMask);
916 etlr.setRecordTtl(254);
917 LocatorRecordBuilder record = new LocatorRecordBuilder();
918 record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
919 record.setLocalLocator(false);
920 record.setRlocProbed(false);
921 record.setRouted(true);
922 record.setMulticastPriority((short) 0);
923 record.setMulticastWeight((short) 0);
924 record.setPriority((short) 0);
925 record.setWeight((short) 0);
926 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
927 etlr.getLocatorRecord().add(record.build());
928 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
929 mapRegister.getEidToLocatorRecord().add(etlr.build());
930 sendMapRegister(mapRegister.build());
931 MapNotify mapNotify = receiveMapNotify();
932 assertEquals(8, mapNotify.getNonce().longValue());
933 MapRequestBuilder mapRequest = new MapRequestBuilder();
934 mapRequest.setNonce((long) 4);
935 mapRequest.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
936 mapRequest.setEidRecord(new ArrayList<EidRecord>());
937 mapRequest.setAuthoritative(false);
938 mapRequest.setMapDataPresent(false);
939 mapRequest.setPitr(false);
940 mapRequest.setProbe(false);
941 mapRequest.setSmr(false);
942 mapRequest.setSmrInvoked(false);
943 mapRequest.getEidRecord().add(
944 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(matchedAddress)).build());
945 mapRequest.setItrRloc(new ArrayList<ItrRloc>());
946 mapRequest.getItrRloc().add(
947 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
948 sendMapRequest(mapRequest.build());
949 MapReply mapReply = receiveMapReply();
950 assertEquals(4, mapReply.getNonce().longValue());
951 assertEquals(record.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0).getLispAddressContainer());
952 mapRequest.setEidRecord(new ArrayList<EidRecord>());
953 mapRequest.getEidRecord().add(
954 new EidRecordBuilder().setMask((short) mask).setLispAddressContainer(LispAFIConvertor.toContainer(unMatchedAddress)).build());
955 sendMapRequest(mapRequest.build());
956 mapReply = receiveMapReply();
957 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
960 // This registers an IP with a MapRegister, then adds a password via the
961 // northbound REST API
962 // and checks that the password works
963 public void testPasswordExactMatch() throws Exception {
965 String ipString = "10.0.0.1";
966 LispIpv4Address address = LispAFIConvertor.asIPAfiAddress(ipString);
968 String pass = "pass";
970 URL url = createPutURL("key");
972 String jsonAuthData = createAuthKeyJSON(pass, address, mask);
974 LOG.trace("Sending this JSON to LISP server: \n" + jsonAuthData);
975 LOG.trace("Address: " + address);
977 byte[] expectedSha = new byte[] { (byte) 146, (byte) 234, (byte) 52, (byte) 247, (byte) 186, (byte) 232, (byte) 31, (byte) 249, (byte) 87,
978 (byte) 73, (byte) 234, (byte) 54, (byte) 225, (byte) 160, (byte) 129, (byte) 251, (byte) 73, (byte) 53, (byte) 196, (byte) 62 };
980 byte[] zeros = new byte[20];
982 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
984 // build a MapRegister
985 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
986 mapRegister.setWantMapNotify(true);
987 mapRegister.setNonce((long) 8);
988 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
989 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(address));
990 etlr.setMaskLength((short) mask);
991 etlr.setRecordTtl(254);
992 LocatorRecordBuilder record = new LocatorRecordBuilder();
993 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
994 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
995 etlr.getLocatorRecord().add(record.build());
996 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
997 mapRegister.getEidToLocatorRecord().add(etlr.build());
999 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1000 mapRegister.setAuthenticationData(zeros);
1002 sendMapRegister(mapRegister.build());
1003 assertNoPacketReceived(3000);
1005 mapRegister.setAuthenticationData(expectedSha);
1007 sendMapRegister(mapRegister.build());
1009 assertMapNotifyRecieved();
1012 public void testPasswordMaskMatch() throws Exception {
1014 LispIpv4Address addressInRange = LispAFIConvertor.asIPAfiAddress("10.20.30.40");
1015 LispIpv4Address addressOutOfRange = LispAFIConvertor.asIPAfiAddress("20.40.30.40");
1016 LispIpv4Address range = LispAFIConvertor.asIPAfiAddress("10.20.30.0");
1019 String pass = "pass";
1021 URL url = createPutURL("key");
1022 String jsonAuthData = createAuthKeyJSON(pass, range, 8);
1024 callURL("PUT", "application/json", "text/plain", jsonAuthData, url);
1025 // build a MapRegister
1026 MapRegisterBuilder mapRegister = new MapRegisterBuilder();
1028 mapRegister.setWantMapNotify(true);
1029 mapRegister.setNonce((long) 8);
1030 EidToLocatorRecordBuilder etlr = new EidToLocatorRecordBuilder();
1031 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressInRange));
1032 etlr.setMaskLength((short) mask);
1033 etlr.setRecordTtl(254);
1034 LocatorRecordBuilder record = new LocatorRecordBuilder();
1035 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1036 record.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1037 etlr.setLocatorRecord(new ArrayList<LocatorRecord>());
1038 etlr.getLocatorRecord().add(record.build());
1039 mapRegister.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1040 mapRegister.getEidToLocatorRecord().add(etlr.build());
1042 mapRegister.setKeyId((short) 1); // LispKeyIDEnum.SHA1.getKeyID()
1044 .setAuthenticationData(new byte[] { -15, -52, 38, -94, 125, -111, -68, -79, 68, 6, 101, 45, -1, 47, -4, -67, -113, 104, -110, -71 });
1046 sendMapRegister(mapRegister.build());
1048 assertMapNotifyRecieved();
1050 etlr.setLispAddressContainer(LispAFIConvertor.toContainer(addressOutOfRange));
1052 .setAuthenticationData(new byte[] { -54, 68, -58, -91, -23, 22, -88, -31, 113, 39, 115, 78, -68, -123, -71, -14, -99, 67, -23, -73 });
1054 sendMapRegister(mapRegister.build());
1055 assertNoPacketReceived(3000);
1058 private MapReply registerAddressAndQuery(LispAFIAddress eid) throws SocketTimeoutException {
1059 return registerAddressAndQuery(eid, -1);
1062 // takes an address, packs it in a MapRegister and sends it
1063 private void registerAddress(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1064 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1065 mapRegisterBuilder.setWantMapNotify(true);
1066 mapRegisterBuilder.setKeyId((short) 0);
1067 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1068 mapRegisterBuilder.setNonce((long) 8);
1069 mapRegisterBuilder.setProxyMapReply(false);
1070 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1071 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1072 if (maskLength != -1) {
1073 etlrBuilder.setMaskLength((short) maskLength);
1075 etlrBuilder.setMaskLength((short) 0);
1077 etlrBuilder.setRecordTtl(254);
1078 etlrBuilder.setAction(Action.NoAction);
1079 etlrBuilder.setAuthoritative(false);
1080 etlrBuilder.setMapVersion((short) 0);
1081 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1082 recordBuilder.setLocalLocator(false);
1083 recordBuilder.setRlocProbed(false);
1084 recordBuilder.setRouted(true);
1085 recordBuilder.setMulticastPriority((short) 0);
1086 recordBuilder.setMulticastWeight((short) 0);
1087 recordBuilder.setPriority((short) 0);
1088 recordBuilder.setWeight((short) 0);
1089 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1090 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1091 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1092 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1093 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1094 sendMapRegister(mapRegisterBuilder.build());
1095 MapNotify mapNotify = receiveMapNotify();
1096 assertEquals(8, mapNotify.getNonce().longValue());
1099 private MapReply queryForAddress(LispAFIAddress eid, String srcEid) throws SocketTimeoutException {
1100 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1101 mapRequestBuilder.setNonce((long) 4);
1102 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1103 mapRequestBuilder.getEidRecord().add(
1104 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1105 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1106 if (srcEid != null) {
1107 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1108 toContainer(LispAFIConvertor.asIPAfiAddress(srcEid))).build());
1110 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.
1111 toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1113 mapRequestBuilder.getItrRloc().add(
1114 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1115 mapRequestBuilder.setAuthoritative(false);
1116 mapRequestBuilder.setMapDataPresent(false);
1117 mapRequestBuilder.setPitr(false);
1118 mapRequestBuilder.setProbe(false);
1119 mapRequestBuilder.setSmr(false);
1120 mapRequestBuilder.setSmrInvoked(false);
1121 sendMapRequest(mapRequestBuilder.build());
1122 return receiveMapReply();
1125 // takes an address, packs it in a MapRegister, sends it, returns the
1127 private MapReply registerAddressAndQuery(LispAFIAddress eid, int maskLength) throws SocketTimeoutException {
1128 MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder();
1129 mapRegisterBuilder.setWantMapNotify(true);
1130 mapRegisterBuilder.setKeyId((short) 0);
1131 mapRegisterBuilder.setAuthenticationData(new byte[0]);
1132 mapRegisterBuilder.setNonce((long) 8);
1133 mapRegisterBuilder.setProxyMapReply(false);
1134 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1135 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1136 if (maskLength != -1) {
1137 etlrBuilder.setMaskLength((short) maskLength);
1139 etlrBuilder.setMaskLength((short) 0);
1141 etlrBuilder.setRecordTtl(254);
1142 etlrBuilder.setAction(Action.NoAction);
1143 etlrBuilder.setAuthoritative(false);
1144 etlrBuilder.setMapVersion((short) 0);
1145 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1146 recordBuilder.setLocalLocator(false);
1147 recordBuilder.setRlocProbed(false);
1148 recordBuilder.setRouted(true);
1149 recordBuilder.setMulticastPriority((short) 0);
1150 recordBuilder.setMulticastWeight((short) 0);
1151 recordBuilder.setPriority((short) 0);
1152 recordBuilder.setWeight((short) 0);
1153 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(locatorEid));
1154 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1155 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1156 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1157 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1158 sendMapRegister(mapRegisterBuilder.build());
1159 MapNotify mapNotify = receiveMapNotify();
1160 assertEquals(8, mapNotify.getNonce().longValue());
1161 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1162 mapRequestBuilder.setNonce((long) 4);
1163 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1164 mapRequestBuilder.getEidRecord().add(
1165 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1166 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1167 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress)))
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 // ------------------------------- LCAF Tests ---------------------------
1184 public void registerAndQuery__SrcDestLCAF() throws SocketTimeoutException {
1186 String ipString = "10.20.30.200";
1187 String macString = "01:02:03:04:05:06";
1188 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1189 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1190 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1191 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1192 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1193 builder.setSrcMaskLength((short) 32);
1194 builder.setDstMaskLength((short) 0);
1195 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1196 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1198 MapReply reply = registerAddressAndQuery(builder.build());
1200 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1201 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1202 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1204 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1205 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1207 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1208 assertTrue(receivedAddr2 instanceof LispMacAddress);
1210 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1211 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1213 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1214 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1218 public void registerAndQuery__SrcDestLCAFOverlap() throws SocketTimeoutException {
1220 String ipString1 = "10.10.10.0";
1221 String ipString2 = "20.20.20.0";
1222 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString1);
1223 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend2 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString2);
1224 LcafSourceDestAddrBuilder builder = new LcafSourceDestAddrBuilder();
1225 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1226 builder.setLcafType((short) LispCanonicalAddressFormatEnum.SOURCE_DEST.getLispCode());
1227 builder.setSrcMaskLength((short) 24);
1228 builder.setDstMaskLength((short) 24);
1229 builder.setSrcAddress(new SrcAddressBuilder().setPrimitiveAddress(addrToSend1).build());
1230 builder.setDstAddress(new DstAddressBuilder().setPrimitiveAddress(addrToSend2).build());
1232 LcafSourceDestAddr srcDst = builder.build();
1233 registerAddress(LispAFIConvertor.asIPAfiAddress(ipString2), 24);
1234 registerAddress(srcDst, -1);
1237 MapReply reply = queryForAddress(srcDst, null);
1239 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1240 assertTrue(fromNetwork.getAddress() instanceof LcafSourceDest);
1241 LcafSourceDest sourceDestFromNetwork = (LcafSourceDest) fromNetwork.getAddress();
1243 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getSrcAddress().getPrimitiveAddress());
1244 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(sourceDestFromNetwork.getLcafSourceDestAddr().getDstAddress().getPrimitiveAddress());
1246 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1247 assertTrue(receivedAddr2 instanceof LispIpv4Address);
1249 LispIpv4Address receivedIP1 = (LispIpv4Address) receivedAddr1;
1250 LispIpv4Address receivedIP2 = (LispIpv4Address) receivedAddr2;
1252 assertEquals(ipString1, receivedIP1.getIpv4Address().getValue());
1253 assertEquals(ipString2, receivedIP2.getIpv4Address().getValue());
1255 // srcEid/dstEid match
1256 reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "10.10.10.1");
1257 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1258 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1260 Ipv4Address ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1261 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1263 // dstEid match only
1264 reply = queryForAddress(LispAFIConvertor.asIPAfiAddress("20.20.20.1"), "1.2.3.4");
1265 fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1266 assertTrue(fromNetwork.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4);
1268 ipAddr2 = ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.Ipv4) fromNetwork.getAddress()).getIpv4Address();
1269 assertEquals(ipString2, ipAddr2.getIpv4Address().getValue());
1273 public void registerAndQuery__KeyValueLCAF() throws SocketTimeoutException {
1275 String ipString = "10.20.30.200";
1276 String macString = "01:02:03:04:05:06";
1277 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4 addrToSend1 = LispAFIConvertor.asPrimitiveIPAfiAddress(ipString);
1278 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac addrToSend2 = LispAFIConvertor.asPrimitiveMacAfiAddress(macString);
1279 LcafKeyValueAddressAddrBuilder builder = new LcafKeyValueAddressAddrBuilder();
1280 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode());
1281 builder.setLcafType((short) LispCanonicalAddressFormatEnum.KEY_VALUE.getLispCode());
1282 builder.setKey(new KeyBuilder().setPrimitiveAddress(addrToSend1).build());
1283 builder.setValue(new ValueBuilder().setPrimitiveAddress(addrToSend2).build());
1285 MapReply reply = registerAddressAndQuery(builder.build());
1287 LispAddressContainer fromNetwork = reply.getEidToLocatorRecord().get(0).getLispAddressContainer();
1288 assertTrue(fromNetwork.getAddress() instanceof LcafKeyValue);
1289 LcafKeyValue keyValueFromNetwork = (LcafKeyValue) fromNetwork.getAddress();
1291 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getKey().getPrimitiveAddress());
1292 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(keyValueFromNetwork.getLcafKeyValueAddressAddr().getValue().getPrimitiveAddress());
1294 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1295 assertTrue(receivedAddr2 instanceof LispMacAddress);
1297 LispIpv4Address receivedIP = (LispIpv4Address) receivedAddr1;
1298 LispMacAddress receivedMAC = (LispMacAddress) receivedAddr2;
1300 assertEquals(ipString, receivedIP.getIpv4Address().getValue());
1301 assertEquals(macString, receivedMAC.getMacAddress().getValue());
1304 public void registerAndQuery__ListLCAF() throws SocketTimeoutException {
1306 String macString = "01:02:03:04:05:06";
1307 String ipString = "10.20.255.30";
1308 LcafListAddrBuilder listbuilder = new LcafListAddrBuilder();
1309 listbuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.LIST.getLispCode());
1310 listbuilder.setAddresses(new ArrayList<Addresses>());
1311 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1312 listbuilder.getAddresses().add(new AddressesBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString))).build());
1314 MapReply reply = registerAddressAndQuery(listbuilder.build());
1316 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1318 assertTrue(receivedAddress instanceof LcafListAddress);
1320 LcafListAddress listAddrFromNetwork = (LcafListAddress) receivedAddress;
1321 LispAFIAddress receivedAddr1 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(0).getPrimitiveAddress());
1322 LispAFIAddress receivedAddr2 = LispAFIConvertor.toAFIfromPrimitive(listAddrFromNetwork.getAddresses().get(1).getPrimitiveAddress());
1324 assertTrue(receivedAddr1 instanceof LispIpv4Address);
1325 assertTrue(receivedAddr2 instanceof LispMacAddress);
1327 assertEquals(macString, ((LispMacAddress) receivedAddr2).getMacAddress().getValue());
1328 assertEquals(ipString, ((LispIpv4Address) receivedAddr1).getIpv4Address().getValue());
1331 public void registerAndQuery__SegmentLCAF() throws SocketTimeoutException {
1333 String ipString = "10.20.255.30";
1335 LcafSegmentAddrBuilder builder = new LcafSegmentAddrBuilder();
1336 builder.setInstanceId((long) instanceId);
1337 builder.setIidMaskLength((short) 32);
1338 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.SEGMENT.getLispCode());
1339 builder.setAddress(new AddressBuilder().setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1341 MapReply reply = registerAddressAndQuery(builder.build());
1343 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1344 assertTrue(receivedAddress instanceof LcafSegmentAddress);
1346 LcafSegmentAddress segmentfromNetwork = (LcafSegmentAddress) receivedAddress;
1347 LispAFIAddress addrFromSegment = LispAFIConvertor.toAFIfromPrimitive(segmentfromNetwork.getAddress().getPrimitiveAddress());
1348 assertTrue(addrFromSegment instanceof LispIpv4Address);
1349 assertEquals(ipString, ((LispIpv4Address) addrFromSegment).getIpv4Address().getValue());
1351 assertEquals(instanceId, segmentfromNetwork.getInstanceId().intValue());
1354 public void registerAndQuery__TrafficEngineering() throws SocketTimeoutException {
1356 String macString = "01:02:03:04:05:06";
1357 String ipString = "10.20.255.30";
1358 HopBuilder hopBuilder = new HopBuilder();
1359 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString)));
1360 Hop hop1 = hopBuilder.build();
1361 hopBuilder.setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asMacAfiAddress(macString)));
1362 Hop hop2 = hopBuilder.build();
1363 HopsBuilder hb = new HopsBuilder();
1366 hb.setRLOCProbe(false);
1368 HopsBuilder hb2 = new HopsBuilder();
1370 hb2.setLookup(false);
1371 hb2.setRLOCProbe(true);
1372 hb2.setStrict(false);
1373 Hops hops1 = hb.build();
1374 Hops hops2 = hb2.build();
1375 LcafTrafficEngineeringAddrBuilder trafficBuilder = new LcafTrafficEngineeringAddrBuilder();
1376 trafficBuilder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType(
1377 (short) LispCanonicalAddressFormatEnum.TRAFFIC_ENGINEERING.getLispCode());
1378 trafficBuilder.setHops(new ArrayList<Hops>());
1379 trafficBuilder.getHops().add(hb.build());
1380 trafficBuilder.getHops().add(hb2.build());
1382 MapReply reply = registerAddressAndQuery(trafficBuilder.build());
1384 assertTrue(LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer()) instanceof LcafTrafficEngineeringAddress);
1386 LcafTrafficEngineeringAddress receivedAddress = (LcafTrafficEngineeringAddress) LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0)
1387 .getLispAddressContainer());
1389 ReencapHop receivedHop1 = receivedAddress.getHops().get(0);
1390 ReencapHop receivedHop2 = receivedAddress.getHops().get(1);
1392 assertEquals(true, hops1.isLookup());
1393 assertEquals(false, hops1.isRLOCProbe());
1394 assertEquals(true, hops1.isStrict());
1396 assertEquals(false, hops2.isLookup());
1397 assertEquals(true, hops2.isRLOCProbe());
1398 assertEquals(false, hops2.isStrict());
1400 assertTrue(receivedHop1.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4);
1401 assertTrue(receivedHop2.getHop().getPrimitiveAddress() instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac);
1403 assertEquals(ipString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Ipv4) receivedHop1.getHop().getPrimitiveAddress()).getIpv4Address().getIpv4Address().getValue());
1404 assertEquals(macString, ((org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispsimpleaddress.primitiveaddress.Mac) receivedHop2.getHop().getPrimitiveAddress()).getMacAddress().getMacAddress().getValue());
1407 public void registerAndQuery__ApplicationData() throws SocketTimeoutException {
1409 String ipString = "1.2.3.4";
1415 LcafApplicationDataAddrBuilder builder = new LcafApplicationDataAddrBuilder();
1416 builder.setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode()).setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode());
1417 builder.setIpTos(ipTOs);
1418 builder.setProtocol(protocol);
1419 builder.setLocalPort(new PortNumber(localPort));
1420 builder.setRemotePort(new PortNumber(remotePort));
1421 builder.setAddress(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder()
1422 .setPrimitiveAddress(LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPAfiAddress(ipString))).build());
1424 LcafApplicationDataAddress addressToSend = builder.build();
1426 MapReply reply = registerAddressAndQuery(addressToSend);
1428 LispAFIAddress receivedAddress = LispAFIConvertor.toAFI(reply.getEidToLocatorRecord().get(0).getLispAddressContainer());
1430 assertTrue(receivedAddress instanceof LcafApplicationDataAddress);
1432 LcafApplicationDataAddress receivedApplicationDataAddress = (LcafApplicationDataAddress) receivedAddress;
1433 assertEquals(protocol, receivedApplicationDataAddress.getProtocol().intValue());
1434 assertEquals(ipTOs, receivedApplicationDataAddress.getIpTos().intValue());
1435 assertEquals(localPort, receivedApplicationDataAddress.getLocalPort().getValue().intValue());
1436 assertEquals(remotePort, receivedApplicationDataAddress.getRemotePort().getValue().intValue());
1438 LispIpv4Address ipAddressReceived = (LispIpv4Address) LispAFIConvertor.toAFIfromPrimitive(receivedApplicationDataAddress.getAddress().getPrimitiveAddress());
1439 assertEquals(ipString, ipAddressReceived.getIpv4Address().getValue());
1442 // ------------------- TimeOut Tests -----------
1444 public void mapRequestMapRegisterAndMapRequestTestTimeout() throws SocketTimeoutException {
1446 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1447 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1448 mapRequestBuilder.setNonce((long) 4);
1449 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1450 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1451 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1452 mapRequestBuilder.getEidRecord().add(
1453 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1454 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1455 mapRequestBuilder.getItrRloc().add(
1456 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1457 sendMapRequest(mapRequestBuilder.build());
1458 MapReply mapReply = receiveMapReply();
1459 assertEquals(4, mapReply.getNonce().longValue());
1460 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1461 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1462 mapRegisterbuilder.setWantMapNotify(true);
1463 mapRegisterbuilder.setNonce((long) 8);
1464 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1465 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1466 etlrBuilder.setMaskLength((short) 32);
1467 etlrBuilder.setRecordTtl(254);
1468 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1469 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
1470 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1471 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1472 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1473 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1474 sendMapRegister(mapRegisterbuilder.build());
1475 MapNotify mapNotify = receiveMapNotify();
1476 assertEquals(8, mapNotify.getNonce().longValue());
1477 sendMapRequest(mapRequestBuilder.build());
1478 mapReply = receiveMapReply();
1479 assertEquals(4, mapReply.getNonce().longValue());
1480 assertEquals(recordBuilder.getLispAddressContainer(), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1481 .getLispAddressContainer());
1482 causeEntryToBeCleaned();
1483 sendMapRequest(mapRequestBuilder.build());
1484 mapReply = receiveMapReply();
1485 assertEquals(0, mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().size());
1488 public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
1490 LispIpv4Address eid = LispAFIConvertor.asIPAfiAddress("1.2.3.4");
1491 MapRequest mapRequest = createMapRequest(eid);
1493 testTTLBeforeRegister(mapRequest);
1495 registerForTTL(eid);
1497 testTTLAfterRegister(mapRequest);
1499 causeEntryToBeCleaned();
1500 testTTLAfterClean(mapRequest);
1503 testTTLAfterAutherize(mapRequest);
1507 private void testTTLAfterClean(MapRequest mapRequest) throws SocketTimeoutException {
1509 sendMapRequest(mapRequest);
1510 mapReply = receiveMapReply();
1511 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1514 private void causeEntryToBeCleaned() {
1515 clusterService.setTimeUnit(TimeUnit.NANOSECONDS);
1516 clusterService.cleanOld();
1519 private void testTTLAfterRegister(MapRequest mapRequest) throws SocketTimeoutException {
1521 sendMapRequest(mapRequest);
1522 mapReply = receiveMapReply();
1523 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
1524 .getLispAddressContainer());
1525 assertCorrectMapReplyTTLAndAction(mapReply, 254, Action.NoAction);
1528 private void registerForTTL(LispIpv4Address eid) throws SocketTimeoutException {
1529 MapRegister mapRegister = createMapRegister(eid);
1530 sendMapRegister(mapRegister);
1531 assertMapNotifyRecieved();
1534 private void testTTLBeforeRegister(MapRequest mapRequest) throws SocketTimeoutException {
1536 sendMapRequest(mapRequest);
1537 mapReply = receiveMapReply();
1538 assertCorrectMapReplyTTLAndAction(mapReply, 15, Action.NativelyForward);
1541 private void testTTLAfterAutherize(MapRequest mapRequest) throws SocketTimeoutException {
1543 sendMapRequest(mapRequest);
1544 mapReply = receiveMapReply();
1545 assertCorrectMapReplyTTLAndAction(mapReply, 1, Action.NativelyForward);
1548 private void assertCorrectMapReplyTTLAndAction(MapReply mapReply, int expectedTTL, Action expectedAction) {
1549 assertEquals(expectedTTL, mapReply.getEidToLocatorRecord().get(0).getRecordTtl().intValue());
1550 assertEquals(expectedAction, mapReply.getEidToLocatorRecord().get(0).getAction());
1553 private MapRegister createMapRegister(LispAFIAddress eid, LispAFIAddress rloc) {
1554 MapRegisterBuilder mapRegisterbuilder = new MapRegisterBuilder();
1555 mapRegisterbuilder.setWantMapNotify(true);
1556 mapRegisterbuilder.setNonce((long) 8);
1557 mapRegisterbuilder.setKeyId((short) 0);
1558 EidToLocatorRecordBuilder etlrBuilder = new EidToLocatorRecordBuilder();
1559 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
1560 etlrBuilder.setMaskLength((short) 24);
1561 etlrBuilder.setRecordTtl(254);
1562 etlrBuilder.setAuthoritative(false);
1563 etlrBuilder.setAction(Action.NoAction);
1564 LocatorRecordBuilder recordBuilder = new LocatorRecordBuilder();
1565 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
1566 etlrBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
1567 etlrBuilder.getLocatorRecord().add(recordBuilder.build());
1568 mapRegisterbuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
1569 mapRegisterbuilder.getEidToLocatorRecord().add(etlrBuilder.build());
1570 MapRegister mapRegister = mapRegisterbuilder.build();
1574 private MapRegister createMapRegister(LispIpv4Address eid) {
1575 return createMapRegister(eid, LispAFIConvertor.asIPAfiAddress("4.3.2.1"));
1578 private MapRequest createMapRequest(LispAFIAddress eid) {
1579 MapRequestBuilder mapRequestBuilder = new MapRequestBuilder();
1580 mapRequestBuilder.setNonce((long) 4);
1581 mapRequestBuilder.setPitr(false);
1582 mapRequestBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
1583 LispAFIConvertor.toContainer(new NoAddressBuilder().setAfi((short) 0).build())).build());
1584 mapRequestBuilder.setEidRecord(new ArrayList<EidRecord>());
1585 mapRequestBuilder.getEidRecord().add(
1586 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(LispAFIConvertor.toContainer(eid)).build());
1587 mapRequestBuilder.setItrRloc(new ArrayList<ItrRloc>());
1588 mapRequestBuilder.getItrRloc().add(
1589 new ItrRlocBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress(ourAddress))).build());
1590 MapRequest mr = mapRequestBuilder.build();
1594 public void testSimpleNonProxy() throws SocketTimeoutException, SocketException {
1596 String rloc = "127.0.0.3";
1597 int port = LispMessage.PORT_NUM;
1598 LispAFIAddress ipRloc = LispAFIConvertor.asIPAfiAddress(rloc);
1599 sendProxyMapRequest(rloc, port, ipRloc);
1603 public void testNonProxyOtherPort() throws SocketTimeoutException, SocketException {
1605 String rloc = "127.0.0.3";
1607 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1608 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1609 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1611 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1612 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1613 LOG.info("testNonProxyOtherPort:" + adLcaf.toString());
1614 sendProxyMapRequest(rloc, port, adLcaf);
1618 public void testRecievingNonProxyOnXtrPort() throws SocketTimeoutException, SocketException, Throwable {
1620 configLispPlugin.shouldListenOnXtrPort(true);
1621 notificationCalled = false;
1622 final String eid = "10.10.10.10";
1623 String rloc = "127.0.0.3";
1624 int port = LispMessage.XTR_PORT_NUM;
1625 LcafApplicationDataAddr adLcaf = new LcafApplicationDataAddrBuilder()
1626 .setAfi(AddressFamilyNumberEnum.LCAF.getIanaCode())
1627 .setLcafType((short) LispCanonicalAddressFormatEnum.APPLICATION_DATA.getLispCode())
1629 new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lcafapplicationdataaddress.AddressBuilder().setPrimitiveAddress(
1630 LispAFIConvertor.asPrimitiveIPAfiAddress(rloc)).build()).setLocalPort(new PortNumber(port)).build();
1631 final MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1632 ((LispMappingService) lms).registerNotificationListener(XtrRequestMapping.class, new NotificationListener<XtrRequestMapping>() {
1635 public void onNotification(XtrRequestMapping notification) {
1636 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(),
1638 notificationCalled = true;
1639 LOG.warn("notification arrived");
1642 sendMapRequest(mapRequest, port);
1643 for (int i = 0; i < MAX_NOTIFICATION_RETRYS; i++) {
1644 if (notificationCalled) {
1647 LOG.warn("notification hasn't arrived, sleeping...");
1652 fail("Notification hasn't arrived");
1656 private void sendProxyMapRequest(String rloc, int port, LispAFIAddress adLcaf) throws SocketTimeoutException, SocketException {
1657 String eid = "10.1.0.1";
1658 MapRequest mapRequest = createNonProxyMapRequest(eid, adLcaf);
1659 sendMapRequest(mapRequest);
1660 DatagramSocket nonProxySocket = new DatagramSocket(new InetSocketAddress(rloc, port));
1661 MapRequest recievedMapRequest = receiveMapRequest(nonProxySocket);
1662 assertEquals(mapRequest.getNonce(), recievedMapRequest.getNonce());
1663 assertEquals(mapRequest.getSourceEid(), recievedMapRequest.getSourceEid());
1664 assertEquals(mapRequest.getItrRloc(), recievedMapRequest.getItrRloc());
1665 assertEquals(mapRequest.getEidRecord(), recievedMapRequest.getEidRecord());
1666 nonProxySocket.close();
1669 private MapRequest createNonProxyMapRequest(String eid, LispAFIAddress adLcaf) throws SocketTimeoutException {
1670 MapRegister mr = createMapRegister(LispAFIConvertor.asIPAfiAddress(eid));
1671 LocatorRecord record = new LocatorRecordBuilder(mr.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)).setLispAddressContainer(
1672 LispAFIConvertor.toContainer(adLcaf)).build();
1673 mr.getEidToLocatorRecord().get(0).getLocatorRecord().set(0, record);
1674 sendMapRegister(mr);
1675 assertMapNotifyRecieved();
1676 MapRequest mapRequest = createMapRequest(LispAFIConvertor.asIPAfiAddress(eid));
1677 MapRequestBuilder builder = new MapRequestBuilder(mapRequest);
1678 builder.setPitr(true);
1679 mapRequest = builder.build();
1683 private void assertMapNotifyRecieved() throws SocketTimeoutException {
1687 private MapReply receiveMapReply() throws SocketTimeoutException {
1688 return MapReplySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1691 private MapRequest receiveMapRequest(DatagramSocket datagramSocket) throws SocketTimeoutException {
1692 return MapRequestSerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket(datagramSocket, 30000).getData()));
1695 private MapNotify receiveMapNotify() throws SocketTimeoutException {
1696 return MapNotifySerializer.getInstance().deserialize(ByteBuffer.wrap(receivePacket().getData()));
1699 private void sendMapRequest(MapRequest mapRequest) {
1700 sendMapRequest(mapRequest, LispMessage.PORT_NUM);
1703 private void sendMapRequest(MapRequest mapRequest, int port) {
1704 sendPacket(MapRequestSerializer.getInstance().serialize(mapRequest).array(), port);
1707 private void sendMapRegister(MapRegister mapRegister) {
1708 sendPacket(MapRegisterSerializer.getInstance().serialize(mapRegister).array());
1711 private void sendPacket(byte[] bytesToSend) {
1712 sendPacket(bytesToSend, LispMessage.PORT_NUM);
1715 private void sendPacket(byte[] bytesToSend, int port) {
1717 DatagramPacket packet = new DatagramPacket(bytesToSend, bytesToSend.length);
1718 initPacketAddress(packet, port);
1719 LOG.trace("Sending packet to LispPlugin on socket, port {}", port);
1720 socket.send(packet);
1721 } catch (Throwable t) {
1726 private DatagramPacket receivePacket() throws SocketTimeoutException {
1727 return receivePacket(6000);
1730 private DatagramPacket receivePacket(int timeout) throws SocketTimeoutException {
1731 return receivePacket(socket, timeout);
1734 private DatagramPacket receivePacket(DatagramSocket receivedSocket, int timeout) throws SocketTimeoutException {
1736 byte[] buffer = new byte[4096];
1737 DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
1738 LOG.trace("Waiting for packet from socket...");
1739 receivedSocket.setSoTimeout(timeout);
1740 receivedSocket.receive(receivePacket);
1741 LOG.trace("Recieved packet from socket!");
1742 return receivePacket;
1743 } catch (SocketTimeoutException ste) {
1745 } catch (Throwable t) {
1751 private void initPacketAddress(DatagramPacket packet, int port) throws UnknownHostException {
1752 packet.setAddress(InetAddress.getByName(lispBindAddress));
1753 packet.setPort(port);
1756 private DatagramSocket initSocket(DatagramSocket socket, int port) {
1758 socket = new DatagramSocket(new InetSocketAddress(ourAddress, port));
1759 } catch (SocketException e) {
1760 e.printStackTrace();
1766 private byte[] extractWSUdpByteArray(String wiresharkHex) {
1767 final int HEADER_LEN = 42;
1768 byte[] res = new byte[1000];
1769 String[] split = wiresharkHex.split(" ");
1771 for (String cur : split) {
1773 if (cur.length() == 2) {
1775 if (counter > HEADER_LEN) {
1776 res[counter - HEADER_LEN - 1] = (byte) Integer.parseInt(cur, 16);
1781 return Arrays.copyOf(res, counter - HEADER_LEN);
1784 private String stateToString(int state) {
1788 case Bundle.INSTALLED:
1790 case Bundle.RESOLVED:
1792 case Bundle.UNINSTALLED:
1793 return "UNINSTALLED";
1795 return "Not CONVERTED";
1799 @SuppressWarnings({ "rawtypes", "unchecked" })
1800 private void areWeReady() throws InvalidSyntaxException {
1802 boolean debugit = false;
1803 Bundle b[] = bc.getBundles();
1804 for (Bundle element : b) {
1805 int state = element.getState();
1806 LOG.trace("Bundle[" + element.getBundleId() + "]:" + element.getSymbolicName() + ",v" + element.getVersion() + ", state:"
1807 + stateToString(state));
1808 if (state != Bundle.ACTIVE && state != Bundle.RESOLVED) {
1809 LOG.trace("Bundle:" + element.getSymbolicName() + " state:" + stateToString(state));
1812 // String host = element.getHeaders().get("FRAGMENT-HOST");
1813 // if (host != null) {
1814 // LOG.warn("Bundle " + element.getSymbolicName() +
1815 // " is a fragment which is part of: " + host);
1816 // LOG.warn("Required imports are: " +
1817 // element.getHeaders().get("IMPORT-PACKAGE"));
1821 // } catch (BundleException e) {
1822 // LOG.error("BundleException:", e);
1831 LOG.warn(("Do some debugging because some bundle is unresolved"));
1833 // assertNotNull(broker);
1836 ServiceReference r = null;
1837 while (this.lms == null && retry < MAX_SERVICE_LOAD_RETRIES) {
1839 r = bc.getServiceReference(IFlowMapping.class.getName());
1840 // r.getPropertyKeys();
1842 this.lms = (IFlowMapping) bc.getService(r);
1846 } catch (InterruptedException e) {
1852 assertNotNull(IFlowMapping.class.getName() + " service wasn't found in bundle context ", this.lms);
1854 r = bc.getServiceReference(ILispDAO.class.getName());
1856 this.clusterService = (ClusterDAOService) bc.getService(r);
1859 assertNotNull(ILispDAO.class.getName() + " service wasn't found in bundle context ", this.clusterService);
1860 r = bc.getServiceReference(IConfigLispSouthboundPlugin.class.getName());
1862 this.configLispPlugin = (IConfigLispSouthboundPlugin) bc.getService(r);
1865 assertNotNull(IConfigLispSouthboundPlugin.class.getName() + " service wasn't found in bundle context ", this.configLispPlugin);
1866 configLispPlugin.setLispAddress(lispBindAddress);
1868 // Uncomment this code to Know which services were actually loaded to
1871 * for (ServiceReference sr : bc.getAllServiceReferences(null, null)) {
1872 * LOG.trace(sr.getBundle().getSymbolicName());
1873 * LOG.trace(sr.toString()); }
1877 } catch (InterruptedException e) {
1881 private void cleanUP() {
1884 configLispPlugin.shouldListenOnXtrPort(false);
1885 socket = initSocket(socket, LispMessage.PORT_NUM);