blob: dc91c735dac279538c7123b98dfb24ea12ba2ed4 [file] [log] [blame]
Vince Lehman09131122014-09-09 17:10:11 -05001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
Junxiao Shi0b1b7d92019-05-22 15:37:18 +00002/*
Davide Pesaventod90338d2021-01-07 17:50:05 -05003 * Copyright (c) 2014-2021, The University of Memphis,
Vince Lehmanc2acdcb2015-04-29 11:14:35 -05004 * Regents of the University of California,
5 * Arizona Board of Regents.
Vince Lehman09131122014-09-09 17:10:11 -05006 *
7 * This file is part of NLSR (Named-data Link State Routing).
8 * See AUTHORS.md for complete list of NLSR authors and contributors.
9 *
10 * NLSR is free software: you can redistribute it and/or modify it under the terms
11 * of the GNU General Public License as published by the Free Software Foundation,
12 * either version 3 of the License, or (at your option) any later version.
13 *
14 * NLSR is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
15 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
16 * PURPOSE. See the GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along with
19 * NLSR, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
Junxiao Shi0b1b7d92019-05-22 15:37:18 +000020 */
Vince Lehman09131122014-09-09 17:10:11 -050021
Ashlesh Gawande3909aa12017-07-28 16:01:35 -050022#include "nlsr.hpp"
Vince Lehman02e32992015-03-11 12:31:20 -050023#include "test-common.hpp"
Vince Lehman199e9cf2015-04-07 13:22:16 -050024#include "control-commands.hpp"
Nick Gordonc0c6bcf2017-08-15 18:11:21 -050025#include "logger.hpp"
Vince Lehman09131122014-09-09 17:10:11 -050026
Junxiao Shi3e5120c2016-09-10 16:58:34 +000027#include <ndn-cxx/mgmt/nfd/face-event-notification.hpp>
Vince Lehman09131122014-09-09 17:10:11 -050028
29namespace nlsr {
30namespace test {
31
Nick Gordond5c1a372016-10-31 13:56:23 -050032class NlsrFixture : public MockNfdMgmtFixture
Vince Lehmanf7eec4f2015-05-08 19:02:31 -050033{
34public:
35 NlsrFixture()
Saurab Dulal427e0122019-11-28 11:58:02 -060036 : conf(m_face, m_keyChain)
Ashlesh Gawande85998a12017-12-07 22:22:13 -060037 , confProcessor(conf)
38 , nlsr(m_face, m_keyChain, conf)
39 , lsdb(nlsr.m_lsdb)
40 , neighbors(conf.getAdjacencyList())
Nick Gordond5c1a372016-10-31 13:56:23 -050041 , nSuccessCallbacks(0)
42 , nFailureCallbacks(0)
Vince Lehmanf7eec4f2015-05-08 19:02:31 -050043 {
Ashlesh Gawande85998a12017-12-07 22:22:13 -060044 addIdentity(conf.getRouterPrefix());
Vince Lehmanf7eec4f2015-05-08 19:02:31 -050045 }
46
47 void
48 receiveHelloData(const ndn::Name& sender, const ndn::Name& receiver)
49 {
50 ndn::Name dataName(sender);
51 dataName.append("NLSR").append("INFO").append(receiver.wireEncode()).appendVersion();
52
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -050053 ndn::Data data(dataName);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -050054
55 nlsr.m_helloProtocol.onContentValidated(data);
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -050056 }
Vince Lehmanf7eec4f2015-05-08 19:02:31 -050057
58public:
Ashlesh Gawande85998a12017-12-07 22:22:13 -060059 ConfParameter conf;
60 DummyConfFileProcessor confProcessor;
Vince Lehmanf7eec4f2015-05-08 19:02:31 -050061 Nlsr nlsr;
62 Lsdb& lsdb;
63 AdjacencyList& neighbors;
Nick Gordond5c1a372016-10-31 13:56:23 -050064 uint32_t nSuccessCallbacks;
65 uint32_t nFailureCallbacks;
Ashlesh Gawande6b388fc2019-09-30 10:14:41 -050066 ndn::util::signal::ScopedConnection connection;
Vince Lehmanf7eec4f2015-05-08 19:02:31 -050067};
68
69BOOST_FIXTURE_TEST_SUITE(TestNlsr, NlsrFixture)
Vince Lehman09131122014-09-09 17:10:11 -050070
71BOOST_AUTO_TEST_CASE(HyperbolicOn_ZeroCostNeighbors)
72{
Vince Lehman09131122014-09-09 17:10:11 -050073 // Simulate loading configuration file
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -050074 Adjacent neighborA("/ndn/neighborA", ndn::FaceUri("udp4://10.0.0.1"), 25,
Nick Gordon727d4832017-10-13 18:04:25 -050075 Adjacent::STATUS_INACTIVE, 0, 0);
Vince Lehman09131122014-09-09 17:10:11 -050076 neighbors.insert(neighborA);
77
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -050078 Adjacent neighborB("/ndn/neighborB", ndn::FaceUri("udp4://10.0.0.2"), 10,
Nick Gordon727d4832017-10-13 18:04:25 -050079 Adjacent::STATUS_INACTIVE, 0, 0);
Vince Lehman09131122014-09-09 17:10:11 -050080 neighbors.insert(neighborB);
81
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -050082 Adjacent neighborC("/ndn/neighborC", ndn::FaceUri("udp4://10.0.0.3"), 17,
Nick Gordon727d4832017-10-13 18:04:25 -050083 Adjacent::STATUS_INACTIVE, 0, 0);
Vince Lehman09131122014-09-09 17:10:11 -050084 neighbors.insert(neighborC);
85
Ashlesh Gawande85998a12017-12-07 22:22:13 -060086 conf.setHyperbolicState(HYPERBOLIC_STATE_ON);
Vince Lehman09131122014-09-09 17:10:11 -050087
88 nlsr.initialize();
89
Davide Pesaventod8d6bbc2020-11-24 21:38:44 -050090 for (const auto& neighbor : neighbors.getAdjList()) {
Ashlesh Gawande57a87172020-05-09 19:47:06 -070091 BOOST_CHECK_EQUAL(neighbor.getLinkCost(), 0);
Vince Lehman09131122014-09-09 17:10:11 -050092 }
93}
94
95BOOST_AUTO_TEST_CASE(HyperbolicOff_LinkStateCost)
96{
Vince Lehman09131122014-09-09 17:10:11 -050097 // Simulate loading configuration file
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -050098 Adjacent neighborA("/ndn/neighborA", ndn::FaceUri("udp4://10.0.0.1"), 25,
Nick Gordon727d4832017-10-13 18:04:25 -050099 Adjacent::STATUS_INACTIVE, 0, 0);
Vince Lehman09131122014-09-09 17:10:11 -0500100 neighbors.insert(neighborA);
101
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500102 Adjacent neighborB("/ndn/neighborB", ndn::FaceUri("udp4://10.0.0.2"), 10,
Nick Gordon727d4832017-10-13 18:04:25 -0500103 Adjacent::STATUS_INACTIVE, 0, 0);
Vince Lehman09131122014-09-09 17:10:11 -0500104 neighbors.insert(neighborB);
105
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500106 Adjacent neighborC("/ndn/neighborC", ndn::FaceUri("udp4://10.0.0.3"), 17,
Nick Gordon727d4832017-10-13 18:04:25 -0500107 Adjacent::STATUS_INACTIVE, 0, 0);
Vince Lehman09131122014-09-09 17:10:11 -0500108 neighbors.insert(neighborC);
109
110 nlsr.initialize();
111
Davide Pesaventod8d6bbc2020-11-24 21:38:44 -0500112 for (const auto& neighbor : neighbors.getAdjList()) {
113 BOOST_CHECK_NE(neighbor.getLinkCost(), 0);
Vince Lehman09131122014-09-09 17:10:11 -0500114 }
115}
116
Vince Lehman7b616582014-10-17 16:25:39 -0500117BOOST_AUTO_TEST_CASE(SetEventIntervals)
118{
Vince Lehman7b616582014-10-17 16:25:39 -0500119 // Simulate loading configuration file
Vince Lehman7b616582014-10-17 16:25:39 -0500120 conf.setAdjLsaBuildInterval(3);
Vince Lehman7b616582014-10-17 16:25:39 -0500121 conf.setRoutingCalcInterval(9);
122
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600123 Nlsr nlsr2(m_face, m_keyChain, conf);
Vince Lehman7b616582014-10-17 16:25:39 -0500124
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600125 const Lsdb& lsdb = nlsr2.m_lsdb;
126 const RoutingTable& rt = nlsr2.m_routingTable;
Vince Lehman7b616582014-10-17 16:25:39 -0500127
Ashlesh Gawande15052402018-12-12 20:20:00 -0600128 BOOST_CHECK_EQUAL(lsdb.m_adjLsaBuildInterval, ndn::time::seconds(3));
Vince Lehman7b616582014-10-17 16:25:39 -0500129 BOOST_CHECK_EQUAL(rt.getRoutingCalcInterval(), ndn::time::seconds(9));
130}
131
Nick Gordond5c1a372016-10-31 13:56:23 -0500132BOOST_AUTO_TEST_CASE(FaceCreateEvent)
133{
134 // Setting constants for the unit test
135 const uint32_t faceId = 1;
136 const std::string faceUri = "udp4://10.0.0.1:6363";
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500137
138 Adjacent neighbor("/ndn/neighborA", ndn::FaceUri(faceUri), 10,
Nick Gordon727d4832017-10-13 18:04:25 -0500139 Adjacent::STATUS_INACTIVE, 0, 0);
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500140
Ashlesh Gawande0db4d4d2020-02-05 20:30:02 -0800141 BOOST_REQUIRE_EQUAL(conf.getAdjacencyList().insert(neighbor), true);
Nick Gordond5c1a372016-10-31 13:56:23 -0500142
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600143 this->advanceClocks(10_ms);
Nick Gordond5c1a372016-10-31 13:56:23 -0500144
145 // Build, sign, and send the Face Event
146 ndn::nfd::FaceEventNotification event;
147 event.setKind(ndn::nfd::FACE_EVENT_CREATED)
148 .setRemoteUri(faceUri)
149 .setFaceId(faceId);
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600150 auto data = std::make_shared<ndn::Data>("/localhost/nfd/faces/events/%FE%00");
Junxiao Shi0b1b7d92019-05-22 15:37:18 +0000151 data->setFreshnessPeriod(1_s);
Nick Gordond5c1a372016-10-31 13:56:23 -0500152 data->setContent(event.wireEncode());
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600153 m_keyChain.sign(*data);
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500154 m_face.receive(*data);
Nick Gordond5c1a372016-10-31 13:56:23 -0500155
156 // Move the clocks forward so that the Face processes the event.
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600157 this->advanceClocks(10_ms);
Nick Gordond5c1a372016-10-31 13:56:23 -0500158
159 // Need to explicitly provide a FaceUri object, because the
160 // conversion will attempt to create Name objects.
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600161 auto iterator = conf.getAdjacencyList().findAdjacent(ndn::FaceUri(faceUri));
162 BOOST_REQUIRE(iterator != conf.getAdjacencyList().end());
Nick Gordond5c1a372016-10-31 13:56:23 -0500163 BOOST_CHECK_EQUAL(iterator->getFaceId(), faceId);
164}
165
166BOOST_AUTO_TEST_CASE(FaceCreateEventNoMatch)
167{
168 // Setting constants for the unit test
169 const uint32_t faceId = 1;
170 const std::string eventUri = "udp4://10.0.0.1:6363";
171 const std::string neighborUri = "udp4://10.0.0.2:6363";
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500172
173 Adjacent neighbor("/ndn/neighborA", ndn::FaceUri(neighborUri), 10,
Nick Gordon727d4832017-10-13 18:04:25 -0500174 Adjacent::STATUS_INACTIVE, 0, 0);
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500175
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600176 conf.getAdjacencyList().insert(neighbor);
Nick Gordond5c1a372016-10-31 13:56:23 -0500177
178 // Build, sign, and send the Face Event
179 ndn::nfd::FaceEventNotification event;
180 event.setKind(ndn::nfd::FACE_EVENT_CREATED)
181 .setRemoteUri(eventUri)
182 .setFaceId(faceId);
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600183 auto data = std::make_shared<ndn::Data>("/localhost/nfd/faces/events/%FE%00");
Junxiao Shi0b1b7d92019-05-22 15:37:18 +0000184 data->setFreshnessPeriod(1_s);
Nick Gordond5c1a372016-10-31 13:56:23 -0500185 data->setContent(event.wireEncode());
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600186 m_keyChain.sign(*data);
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500187 m_face.receive(*data);
Nick Gordond5c1a372016-10-31 13:56:23 -0500188
189 // Move the clocks forward so that the Face processes the event.
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600190 this->advanceClocks(10_ms);
Nick Gordond5c1a372016-10-31 13:56:23 -0500191
192 // The Face URIs did not match, so this neighbor should be unconfigured.
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600193 auto iterator = conf.getAdjacencyList().findAdjacent(ndn::FaceUri(neighborUri));
194 BOOST_REQUIRE(iterator != conf.getAdjacencyList().end());
Nick Gordond5c1a372016-10-31 13:56:23 -0500195 BOOST_CHECK_EQUAL(iterator->getFaceId(), 0);
196}
197
198BOOST_AUTO_TEST_CASE(FaceCreateEventAlreadyConfigured)
199{
Ashlesh Gawande41878572019-09-29 00:16:02 -0500200 // So if NLSR gets the notification and registers prefixes it
201 // will change the Id to 1 and our tests will fail
202 // Need to disable registrationReply in dummy face and have own registration reply in the future
203 const uint32_t neighborFaceId = 1;
Nick Gordond5c1a372016-10-31 13:56:23 -0500204 const std::string faceUri = "udp4://10.0.0.1:6363";
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500205
206 Adjacent neighbor("/ndn/neighborA", ndn::FaceUri(faceUri), 10,
Ashlesh Gawande41878572019-09-29 00:16:02 -0500207 Adjacent::STATUS_ACTIVE, 0, 0);
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600208 conf.getAdjacencyList().insert(neighbor);
Nick Gordond5c1a372016-10-31 13:56:23 -0500209
Ashlesh Gawande41878572019-09-29 00:16:02 -0500210 // Let NLSR start the face monitor
211 this->advanceClocks(10_ms);
212
Nick Gordond5c1a372016-10-31 13:56:23 -0500213 // Build, sign, and send the Face Event
214 ndn::nfd::FaceEventNotification event;
215 event.setKind(ndn::nfd::FACE_EVENT_CREATED)
216 .setRemoteUri(faceUri)
Ashlesh Gawande41878572019-09-29 00:16:02 -0500217 .setFaceId(neighborFaceId); // Does not matter what we set here, dummy face always returns 1
Nick Gordond5c1a372016-10-31 13:56:23 -0500218 std::shared_ptr<ndn::Data> data = std::make_shared<ndn::Data>("/localhost/nfd/faces/events/%FE%00");
Junxiao Shi0b1b7d92019-05-22 15:37:18 +0000219 data->setFreshnessPeriod(1_s);
Nick Gordond5c1a372016-10-31 13:56:23 -0500220 data->setContent(event.wireEncode());
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600221 m_keyChain.sign(*data);
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500222 m_face.receive(*data);
Nick Gordond5c1a372016-10-31 13:56:23 -0500223
224 // Move the clocks forward so that the Face processes the event.
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600225 this->advanceClocks(10_ms);
Nick Gordond5c1a372016-10-31 13:56:23 -0500226
Ashlesh Gawande41878572019-09-29 00:16:02 -0500227 // Check that the neighbor is configured with the face id of 1
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600228 auto iterator = conf.getAdjacencyList().findAdjacent(ndn::FaceUri(faceUri));
229 BOOST_REQUIRE(iterator != conf.getAdjacencyList().end());
Nick Gordond5c1a372016-10-31 13:56:23 -0500230 BOOST_CHECK_EQUAL(iterator->getFaceId(), neighborFaceId);
Ashlesh Gawande41878572019-09-29 00:16:02 -0500231
232 // Resend same event notification again
233 m_face.sentInterests.clear();
234 data->setName("/localhost/nfd/faces/events/%FE%01");
235 m_keyChain.sign(*data);
236 m_face.receive(*data);
237 this->advanceClocks(10_ms);
238
239 for (const auto& interest : m_face.sentInterests) {
240 // Should not re-register prefix since this is the same event notification
241 if (ndn::Name("/localhost/nfd/rib/register").isPrefixOf(interest.getName())) {
242 BOOST_CHECK(false);
243 }
244 }
Nick Gordond5c1a372016-10-31 13:56:23 -0500245}
246
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500247BOOST_AUTO_TEST_CASE(FaceDestroyEvent)
Vince Lehman02e32992015-03-11 12:31:20 -0500248{
Vince Lehman02e32992015-03-11 12:31:20 -0500249 // Add active neighbors
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600250 AdjacencyList& neighbors = conf.getAdjacencyList();
Vince Lehman02e32992015-03-11 12:31:20 -0500251 uint64_t destroyFaceId = 128;
252
253 // Create a neighbor whose Face will be destroyed
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500254 Adjacent failNeighbor("/ndn/neighborA", ndn::FaceUri("udp4://10.0.0.1"),
255 10, Adjacent::STATUS_ACTIVE, 0, destroyFaceId);
Vince Lehman02e32992015-03-11 12:31:20 -0500256 neighbors.insert(failNeighbor);
257
258 // Create an additional neighbor so an adjacency LSA can be built after the face is destroyed
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500259 Adjacent otherNeighbor("/ndn/neighborB", ndn::FaceUri("udp4://10.0.0.2"),
260 10, Adjacent::STATUS_ACTIVE, 0, 256);
Vince Lehman02e32992015-03-11 12:31:20 -0500261 neighbors.insert(otherNeighbor);
262
Ashlesh Gawande6b388fc2019-09-30 10:14:41 -0500263 // Set HelloInterest lifetime as 10 seconds so that neighbors are not marked INACTIVE
264 // upon timeout before this test ends
265 conf.setInterestResendTime(10);
Vince Lehman02e32992015-03-11 12:31:20 -0500266 nlsr.initialize();
267
268 // Simulate successful HELLO responses
Vince Lehman41b173e2015-05-07 14:13:26 -0500269 lsdb.scheduleAdjLsaBuild();
270
271 // Set up adjacency LSAs
272 // This router
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500273 Adjacent thisRouter(conf.getRouterPrefix(), ndn::FaceUri("udp4://10.0.0.3"),
274 10, Adjacent::STATUS_ACTIVE, 0, 256);
Vince Lehman41b173e2015-05-07 14:13:26 -0500275
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500276 AdjLsa ownAdjLsa(conf.getRouterPrefix(), 10,
277 ndn::time::system_clock::now(), 1, neighbors);
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700278 lsdb.installLsa(std::make_shared<AdjLsa>(ownAdjLsa));
Vince Lehman41b173e2015-05-07 14:13:26 -0500279
280 // Router that will fail
281 AdjacencyList failAdjacencies;
282 failAdjacencies.insert(thisRouter);
283
Ashlesh Gawanded02c3882015-12-29 16:02:51 -0600284 AdjLsa failAdjLsa("/ndn/neighborA", 10,
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500285 ndn::time::system_clock::now() + ndn::time::seconds(3600),
286 1, failAdjacencies);
Vince Lehman41b173e2015-05-07 14:13:26 -0500287
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700288 lsdb.installLsa(std::make_shared<AdjLsa>(failAdjLsa));
Vince Lehman41b173e2015-05-07 14:13:26 -0500289
290 // Other router
291 AdjacencyList otherAdjacencies;
292 otherAdjacencies.insert(thisRouter);
293
Ashlesh Gawanded02c3882015-12-29 16:02:51 -0600294 AdjLsa otherAdjLsa("/ndn/neighborB", 10,
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500295 ndn::time::system_clock::now() + ndn::time::seconds(3600),
296 1, otherAdjacencies);
Vince Lehman41b173e2015-05-07 14:13:26 -0500297
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700298 lsdb.installLsa(std::make_shared<AdjLsa>(otherAdjLsa));
Vince Lehman02e32992015-03-11 12:31:20 -0500299
300 // Run the scheduler to build an adjacency LSA
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600301 this->advanceClocks(10_ms);
Vince Lehman02e32992015-03-11 12:31:20 -0500302
303 // Make sure an adjacency LSA was built
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700304 auto lsa = lsdb.findLsa(conf.getRouterPrefix(), Lsa::Type::ADJACENCY);
Vince Lehman02e32992015-03-11 12:31:20 -0500305 BOOST_REQUIRE(lsa != nullptr);
306
Ashlesh Gawande0db4d4d2020-02-05 20:30:02 -0800307 uint32_t lastAdjLsaSeqNo = lsa->getSeqNo();
Ashlesh Gawande15052402018-12-12 20:20:00 -0600308 nlsr.m_lsdb.m_sequencingManager.setAdjLsaSeq(lastAdjLsaSeqNo);
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600309
310 this->advanceClocks(1500_ms, 10);
Vince Lehman02e32992015-03-11 12:31:20 -0500311
312 // Make sure the routing table was calculated
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600313 RoutingTableEntry* rtEntry = nlsr.m_routingTable.findRoutingTableEntry(failNeighbor.getName());
Vince Lehman02e32992015-03-11 12:31:20 -0500314 BOOST_REQUIRE(rtEntry != nullptr);
Nick Gordonff9a6272017-10-12 13:38:29 -0500315 BOOST_REQUIRE_EQUAL(rtEntry->getNexthopList().size(), 1);
Vince Lehman02e32992015-03-11 12:31:20 -0500316
317 // Receive FaceEventDestroyed notification
318 ndn::nfd::FaceEventNotification event;
319 event.setKind(ndn::nfd::FACE_EVENT_DESTROYED)
320 .setFaceId(destroyFaceId);
321
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700322 auto data = std::make_shared<ndn::Data>("/localhost/nfd/faces/events/%FE%00");
Junxiao Shi0b1b7d92019-05-22 15:37:18 +0000323 data->setFreshnessPeriod(1_s);
Vince Lehman02e32992015-03-11 12:31:20 -0500324 data->setContent(event.wireEncode());
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600325 m_keyChain.sign(*data);
Vince Lehman02e32992015-03-11 12:31:20 -0500326
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500327 m_face.receive(*data);
Vince Lehman02e32992015-03-11 12:31:20 -0500328
329 // Run the scheduler to build an adjacency LSA
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600330 this->advanceClocks(10_ms);
Vince Lehman02e32992015-03-11 12:31:20 -0500331
332 Adjacent updatedNeighbor = neighbors.getAdjacent(failNeighbor.getName());
333
334 BOOST_CHECK_EQUAL(updatedNeighbor.getFaceId(), 0);
335 BOOST_CHECK_EQUAL(updatedNeighbor.getInterestTimedOutNo(),
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600336 conf.getInterestRetryNumber());
Vince Lehman02e32992015-03-11 12:31:20 -0500337 BOOST_CHECK_EQUAL(updatedNeighbor.getStatus(), Adjacent::STATUS_INACTIVE);
alvy46ccaae2015-06-25 14:13:39 -0500338
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700339 lsa = lsdb.findLsa<AdjLsa>(conf.getRouterPrefix());
alvy46ccaae2015-06-25 14:13:39 -0500340 BOOST_REQUIRE(lsa != nullptr);
341
Ashlesh Gawande0db4d4d2020-02-05 20:30:02 -0800342 BOOST_CHECK_EQUAL(lsa->getSeqNo(), lastAdjLsaSeqNo + 1);
Vince Lehman02e32992015-03-11 12:31:20 -0500343
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600344 this->advanceClocks(15_s, 10);
345
Vince Lehman02e32992015-03-11 12:31:20 -0500346 // Make sure the routing table was recalculated
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600347 rtEntry = nlsr.m_routingTable.findRoutingTableEntry(failNeighbor.getName());
Vince Lehman02e32992015-03-11 12:31:20 -0500348 BOOST_CHECK(rtEntry == nullptr);
349}
350
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500351BOOST_AUTO_TEST_CASE(BuildAdjLsaAfterHelloResponse)
352{
353 // Configure NLSR
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500354 conf.setAdjLsaBuildInterval(1);
355
356 // Add neighbors
357 // Router A
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500358 ndn::Name neighborAName("/ndn/site/%C1.Router/routerA");
359 Adjacent neighborA(neighborAName, ndn::FaceUri("udp4://10.0.0.1"),
360 0, Adjacent::STATUS_INACTIVE, 0, 0);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500361 neighbors.insert(neighborA);
362
363 // Router B
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500364 ndn::Name neighborBName("/ndn/site/%C1.Router/routerB");
365 Adjacent neighborB(neighborBName, ndn::FaceUri("udp4://10.0.0.1"),
366 0, Adjacent::STATUS_INACTIVE, 0, 0);
367
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500368 neighbors.insert(neighborB);
369
370 nlsr.initialize();
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500371
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600372 this->advanceClocks(10_ms);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500373
374 // Receive HELLO response from Router A
375 receiveHelloData(neighborAName, conf.getRouterPrefix());
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600376 this->advanceClocks(1_s, 10);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500377
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500378 // Adjacency LSA should be built even though other router is INACTIVE
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700379 auto lsa = lsdb.findLsa<AdjLsa>(conf.getRouterPrefix());
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500380 BOOST_REQUIRE(lsa != nullptr);
Nick Gordonff9a6272017-10-12 13:38:29 -0500381 BOOST_CHECK_EQUAL(lsa->getAdl().size(), 1);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500382
383 // Receive HELLO response from Router B
384 receiveHelloData(neighborBName, conf.getRouterPrefix());
385
386 // Both routers become INACTIVE and HELLO Interests have timed out
387 for (Adjacent& adjacency : neighbors.getAdjList()) {
388 adjacency.setStatus(Adjacent::STATUS_INACTIVE);
389 adjacency.setInterestTimedOutNo(HELLO_RETRIES_DEFAULT);
390 }
391
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600392 this->advanceClocks(1_s, 10);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500393
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500394 // Adjacency LSA should have been removed since this router's adjacencies are
395 // INACTIVE and have timed out
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700396 lsa = lsdb.findLsa<AdjLsa>(conf.getRouterPrefix());
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500397 BOOST_CHECK(lsa == nullptr);
398
399 // Receive HELLO response from Router A and B
400 receiveHelloData(neighborAName, conf.getRouterPrefix());
401 receiveHelloData(neighborBName, conf.getRouterPrefix());
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600402 this->advanceClocks(1_s, 10);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500403
404 // Adjacency LSA should be built
Ashlesh Gawande57a87172020-05-09 19:47:06 -0700405 lsa = lsdb.findLsa<AdjLsa>(conf.getRouterPrefix());
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500406 BOOST_REQUIRE(lsa != nullptr);
Nick Gordonff9a6272017-10-12 13:38:29 -0500407 BOOST_CHECK_EQUAL(lsa->getAdl().size(), 2);
Vince Lehmanf7eec4f2015-05-08 19:02:31 -0500408}
409
Nick Gordond5c1a372016-10-31 13:56:23 -0500410BOOST_AUTO_TEST_CASE(FaceDatasetFetchSuccess)
411{
412 bool hasResult = false;
Nick Gordond5c1a372016-10-31 13:56:23 -0500413
414 nlsr.initializeFaces([&hasResult] (const std::vector<ndn::nfd::FaceStatus>& faces) {
415 hasResult = true;
416 BOOST_CHECK_EQUAL(faces.size(), 2);
417 BOOST_CHECK_EQUAL(faces.front().getFaceId(), 25401);
418 BOOST_CHECK_EQUAL(faces.back().getFaceId(), 25402);
419 },
420 [] (uint32_t code, const std::string& reason) {});
421
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600422 this->advanceClocks(100_ms, 5);
Nick Gordond5c1a372016-10-31 13:56:23 -0500423
424 ndn::nfd::FaceStatus payload1;
425 payload1.setFaceId(25401);
426 ndn::nfd::FaceStatus payload2;
427 payload2.setFaceId(25402);
428 this->sendDataset("/localhost/nfd/faces/list", payload1, payload2);
429
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600430 this->advanceClocks(100_ms, 5);
Nick Gordond5c1a372016-10-31 13:56:23 -0500431 BOOST_CHECK(hasResult);
432}
433
434BOOST_AUTO_TEST_CASE(FaceDatasetFetchFailure)
435{
Nick Gordond5c1a372016-10-31 13:56:23 -0500436 nlsr.initializeFaces([](const std::vector<ndn::nfd::FaceStatus>& faces) {},
437 [this](uint32_t code, const std::string& reason){
438 this->nFailureCallbacks++;
439 });
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600440 this->advanceClocks(100_ms, 5);
Nick Gordond5c1a372016-10-31 13:56:23 -0500441
442 ndn::Name payload;
443 this->sendDataset("/localhost/nfd/faces/list", payload);
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600444 this->advanceClocks(100_ms, 5);
Nick Gordond5c1a372016-10-31 13:56:23 -0500445
446 BOOST_CHECK_EQUAL(nFailureCallbacks, 1);
447 BOOST_CHECK_EQUAL(nSuccessCallbacks, 0);
448}
449
450BOOST_AUTO_TEST_CASE(FaceDatasetProcess)
451{
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500452 Adjacent neighborA("/ndn/neighborA", ndn::FaceUri("udp4://192.168.0.100:6363"),
453 25, Adjacent::STATUS_INACTIVE, 0, 0);
Nick Gordond5c1a372016-10-31 13:56:23 -0500454 neighbors.insert(neighborA);
455
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500456 Adjacent neighborB("/ndn/neighborB", ndn::FaceUri("udp4://192.168.0.101:6363"),
457 10, Adjacent::STATUS_INACTIVE, 0, 0);
Nick Gordond5c1a372016-10-31 13:56:23 -0500458 neighbors.insert(neighborB);
459
460 ndn::nfd::FaceStatus payload1;
461 payload1.setFaceId(1)
462 .setRemoteUri("udp4://192.168.0.100:6363");
463 ndn::nfd::FaceStatus payload2;
464 payload2.setFaceId(2)
465 .setRemoteUri("udp4://192.168.0.101:6363");
466 std::vector<ndn::nfd::FaceStatus> faceStatuses = {payload1, payload2};
467
468 nlsr.processFaceDataset(faceStatuses);
Nick Gordond5c1a372016-10-31 13:56:23 -0500469
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600470 AdjacencyList adjList = conf.getAdjacencyList();
Nick Gordond5c1a372016-10-31 13:56:23 -0500471
472 BOOST_CHECK_EQUAL(adjList.getAdjacent("/ndn/neighborA").getFaceId(), payload1.getFaceId());
473 BOOST_CHECK_EQUAL(adjList.getAdjacent("/ndn/neighborB").getFaceId(), payload2.getFaceId());
474}
475
476BOOST_AUTO_TEST_CASE(UnconfiguredNeighbor)
477{
Muktadir Chowdhuryf04f9892017-08-20 20:42:56 -0500478 Adjacent neighborA("/ndn/neighborA", ndn::FaceUri("udp4://192.168.0.100:6363"), 25, Adjacent::STATUS_INACTIVE, 0, 0);
Nick Gordond5c1a372016-10-31 13:56:23 -0500479 neighbors.insert(neighborA);
480
481 ndn::nfd::FaceStatus payload;
482 payload.setFaceId(1)
483 .setRemoteUri("udp4://192.168.0.101:6363"); // Note dissimilar Face URI.
484 std::vector<ndn::nfd::FaceStatus> faceStatuses = {payload};
485
486 nlsr.processFaceDataset(faceStatuses);
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600487 this->advanceClocks(20_ms, 5);
Nick Gordond5c1a372016-10-31 13:56:23 -0500488
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600489 AdjacencyList adjList = conf.getAdjacencyList();
Nick Gordond5c1a372016-10-31 13:56:23 -0500490
491 BOOST_CHECK_EQUAL(adjList.getAdjacent("/ndn/neighborA").getFaceId(), 0);
492}
493
494BOOST_AUTO_TEST_CASE(FaceDatasetPeriodicFetch)
495{
496 int nNameMatches = 0;
497 ndn::Name datasetPrefix("/localhost/nfd/faces/list");
498 ndn::nfd::CommandOptions options;
499 ndn::time::milliseconds defaultTimeout = options.getTimeout();
500
Ashlesh Gawande3909aa12017-07-28 16:01:35 -0500501 int fetchInterval(1);
Nick Gordond5c1a372016-10-31 13:56:23 -0500502 conf.setFaceDatasetFetchInterval(fetchInterval);
503 conf.setFaceDatasetFetchTries(0);
504
Nick Gordond5c1a372016-10-31 13:56:23 -0500505 // Elapse the default timeout time of the interest.
506 this->advanceClocks(defaultTimeout);
507
508 // Check that we have one interest for face list in the sent interests.
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600509 for (const auto& interest : m_face.sentInterests) {
Nick Gordond5c1a372016-10-31 13:56:23 -0500510 if (datasetPrefix.isPrefixOf(interest.getName())) {
511 nNameMatches++;
512 }
513 }
514 BOOST_CHECK_EQUAL(nNameMatches, 1);
515
516 // Elapse the clock by the reschedule time (that we set)
Ashlesh Gawande3909aa12017-07-28 16:01:35 -0500517 this->advanceClocks(ndn::time::seconds(fetchInterval));
Nick Gordond5c1a372016-10-31 13:56:23 -0500518 // Elapse the default timeout on the interest.
519 this->advanceClocks(defaultTimeout);
Nick Gordond5c1a372016-10-31 13:56:23 -0500520
521 // Check that we now have two interests
522 nNameMatches = 0;
Ashlesh Gawande85998a12017-12-07 22:22:13 -0600523 for (const auto& interest : m_face.sentInterests) {
Nick Gordond5c1a372016-10-31 13:56:23 -0500524 if (datasetPrefix.isPrefixOf(interest.getName())) {
525 nNameMatches++;
526 }
527 }
528 BOOST_CHECK_EQUAL(nNameMatches, 2);
529}
530
Vince Lehman09131122014-09-09 17:10:11 -0500531BOOST_AUTO_TEST_SUITE_END()
532
Nick Gordonfad8e252016-08-11 14:21:38 -0500533} // namespace test
534} // namespace nlsr