Alexander Afanasyev | 60a7b62 | 2014-12-20 17:04:07 -0800 | [diff] [blame] | 1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
| 2 | /** |
| 3 | * Copyright (c) 2011-2015 Regents of the University of California. |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 4 | * |
Alexander Afanasyev | 60a7b62 | 2014-12-20 17:04:07 -0800 | [diff] [blame] | 5 | * This file is part of ndnSIM. See AUTHORS for complete list of ndnSIM authors and |
| 6 | * contributors. |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 7 | * |
Alexander Afanasyev | 60a7b62 | 2014-12-20 17:04:07 -0800 | [diff] [blame] | 8 | * ndnSIM is free software: you can redistribute it and/or modify it under the terms |
| 9 | * of the GNU General Public License as published by the Free Software Foundation, |
| 10 | * either version 3 of the License, or (at your option) any later version. |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 11 | * |
Alexander Afanasyev | 60a7b62 | 2014-12-20 17:04:07 -0800 | [diff] [blame] | 12 | * ndnSIM is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; |
| 13 | * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| 14 | * PURPOSE. See the GNU General Public License for more details. |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 15 | * |
Alexander Afanasyev | 60a7b62 | 2014-12-20 17:04:07 -0800 | [diff] [blame] | 16 | * You should have received a copy of the GNU General Public License along with |
| 17 | * ndnSIM, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>. |
| 18 | **/ |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 19 | |
Alexander Afanasyev | 0c39537 | 2014-12-20 15:54:02 -0800 | [diff] [blame] | 20 | #include "ndn-stack-helper.hpp" |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 21 | |
| 22 | #include "ns3/log.h" |
| 23 | #include "ns3/names.h" |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 24 | #include "ns3/string.h" |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 25 | #include "ns3/point-to-point-net-device.h" |
Alexander Afanasyev | a9d889b | 2016-09-08 18:34:25 -0700 | [diff] [blame] | 26 | #include "ns3/point-to-point-channel.h" |
Chavoosh Ghasemi | 58ef861 | 2018-09-12 15:12:49 -0700 | [diff] [blame] | 27 | #include "ns3/node-list.h" |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 28 | #include "ns3/simulator.h" |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 29 | |
| 30 | #include "model/ndn-l3-protocol.hpp" |
Spyridon Mastorakis | 5ea3322 | 2016-12-07 14:33:53 -0800 | [diff] [blame] | 31 | #include "model/ndn-net-device-transport.hpp" |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 32 | #include "utils/ndn-time.hpp" |
Alexander Afanasyev | 34e13f3 | 2014-12-14 15:13:28 -0800 | [diff] [blame] | 33 | #include "utils/dummy-keychain.hpp" |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 34 | #include "model/cs/ndn-content-store.hpp" |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 35 | |
| 36 | #include <limits> |
| 37 | #include <map> |
Alexander Afanasyev | b762684 | 2012-01-12 13:43:33 -0800 | [diff] [blame] | 38 | #include <boost/lexical_cast.hpp> |
Alexander Afanasyev | a5bbe0e | 2011-11-22 17:28:39 -0800 | [diff] [blame] | 39 | |
Spyridon Mastorakis | 5ea3322 | 2016-12-07 14:33:53 -0800 | [diff] [blame] | 40 | #include "ns3/ndnSIM/NFD/daemon/face/generic-link-service.hpp" |
spirosmastorakis | 34eed98 | 2016-11-02 15:20:50 -0700 | [diff] [blame] | 41 | #include "ns3/ndnSIM/NFD/daemon/table/cs-policy-priority-fifo.hpp" |
| 42 | #include "ns3/ndnSIM/NFD/daemon/table/cs-policy-lru.hpp" |
| 43 | |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 44 | NS_LOG_COMPONENT_DEFINE("ndn.StackHelper"); |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 45 | |
| 46 | namespace ns3 { |
Alexander Afanasyev | 2b4c947 | 2012-08-09 15:00:38 -0700 | [diff] [blame] | 47 | namespace ndn { |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 48 | |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 49 | StackHelper::StackHelper() |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 50 | : m_isForwarderStatusManagerDisabled(false) |
spirosmastorakis | 0df15ba | 2015-11-14 08:46:24 -0800 | [diff] [blame] | 51 | , m_isStrategyChoiceManagerDisabled(false) |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 52 | , m_needSetDefaultRoutes(false) |
| 53 | , m_maxCsSize(100) |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 54 | { |
Spyridon Mastorakis | 86edf6f | 2014-11-14 19:27:18 -0800 | [diff] [blame] | 55 | setCustomNdnCxxClocks(); |
| 56 | |
spirosmastorakis | 34eed98 | 2016-11-02 15:20:50 -0700 | [diff] [blame] | 57 | m_csPolicies.insert({"nfd::cs::lru", [] { return make_unique<nfd::cs::LruPolicy>(); }}); |
| 58 | m_csPolicies.insert({"nfd::cs::priority_fifo", [] () { return make_unique<nfd::cs::PriorityFifoPolicy>(); }}); |
| 59 | |
| 60 | m_csPolicyCreationFunc = m_csPolicies["nfd::cs::lru"]; |
| 61 | |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 62 | m_ndnFactory.SetTypeId("ns3::ndn::L3Protocol"); |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 63 | m_contentStoreFactory.SetTypeId("ns3::ndn::cs::Lru"); |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 64 | |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 65 | m_netDeviceCallbacks.push_back( |
| 66 | std::make_pair(PointToPointNetDevice::GetTypeId(), |
| 67 | MakeCallback(&StackHelper::PointToPointNetDeviceCallback, this))); |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 68 | // default callback will be fired if non of others callbacks fit or did the job |
Ilya Moiseenko | 25f7d4d | 2011-09-29 18:41:06 -0700 | [diff] [blame] | 69 | } |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 70 | |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 71 | StackHelper::~StackHelper() |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 72 | { |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 73 | } |
| 74 | |
Alexander Afanasyev | 34e13f3 | 2014-12-14 15:13:28 -0800 | [diff] [blame] | 75 | KeyChain& |
| 76 | StackHelper::getKeyChain() |
| 77 | { |
Alexander Afanasyev | df26b5a | 2015-01-15 23:30:56 -0800 | [diff] [blame] | 78 | static ::ndn::KeyChain keyChain("pib-dummy", "tpm-dummy"); |
Alexander Afanasyev | 34e13f3 | 2014-12-14 15:13:28 -0800 | [diff] [blame] | 79 | return keyChain; |
| 80 | } |
| 81 | |
Alexander Afanasyev | 3a4a0b3 | 2012-06-28 14:14:22 -0700 | [diff] [blame] | 82 | void |
Spyridon Mastorakis | 86edf6f | 2014-11-14 19:27:18 -0800 | [diff] [blame] | 83 | StackHelper::setCustomNdnCxxClocks() |
| 84 | { |
| 85 | ::ndn::time::setCustomClocks(make_shared<ns3::ndn::time::CustomSteadyClock>(), |
| 86 | make_shared<ns3::ndn::time::CustomSystemClock>()); |
| 87 | } |
| 88 | |
Spyridon Mastorakis | 588fd10 | 2014-11-20 19:50:02 -0800 | [diff] [blame] | 89 | void |
| 90 | StackHelper::SetDefaultRoutes(bool needSet) |
| 91 | { |
| 92 | NS_LOG_FUNCTION(this << needSet); |
| 93 | m_needSetDefaultRoutes = needSet; |
| 94 | } |
| 95 | |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 96 | void |
| 97 | StackHelper::SetStackAttributes(const std::string& attr1, const std::string& value1, |
| 98 | const std::string& attr2, const std::string& value2, |
| 99 | const std::string& attr3, const std::string& value3, |
| 100 | const std::string& attr4, const std::string& value4) |
| 101 | { |
| 102 | if (attr1 != "") |
| 103 | m_ndnFactory.Set(attr1, StringValue(value1)); |
| 104 | if (attr2 != "") |
| 105 | m_ndnFactory.Set(attr2, StringValue(value2)); |
| 106 | if (attr3 != "") |
| 107 | m_ndnFactory.Set(attr3, StringValue(value3)); |
| 108 | if (attr4 != "") |
| 109 | m_ndnFactory.Set(attr4, StringValue(value4)); |
| 110 | } |
| 111 | |
| 112 | void |
Alexander Afanasyev | dde1e81 | 2015-01-06 14:26:09 -0800 | [diff] [blame] | 113 | StackHelper::SetOldContentStore(const std::string& contentStore, const std::string& attr1, |
| 114 | const std::string& value1, const std::string& attr2, |
| 115 | const std::string& value2, const std::string& attr3, |
| 116 | const std::string& value3, const std::string& attr4, |
| 117 | const std::string& value4) |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 118 | { |
Alexander Afanasyev | dde1e81 | 2015-01-06 14:26:09 -0800 | [diff] [blame] | 119 | m_maxCsSize = 0; |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 120 | |
| 121 | m_contentStoreFactory.SetTypeId(contentStore); |
| 122 | if (attr1 != "") |
| 123 | m_contentStoreFactory.Set(attr1, StringValue(value1)); |
| 124 | if (attr2 != "") |
| 125 | m_contentStoreFactory.Set(attr2, StringValue(value2)); |
| 126 | if (attr3 != "") |
| 127 | m_contentStoreFactory.Set(attr3, StringValue(value3)); |
| 128 | if (attr4 != "") |
| 129 | m_contentStoreFactory.Set(attr4, StringValue(value4)); |
| 130 | } |
| 131 | |
| 132 | void |
Alexander Afanasyev | dde1e81 | 2015-01-06 14:26:09 -0800 | [diff] [blame] | 133 | StackHelper::setCsSize(size_t maxSize) |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 134 | { |
Alexander Afanasyev | dde1e81 | 2015-01-06 14:26:09 -0800 | [diff] [blame] | 135 | m_maxCsSize = maxSize; |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 136 | } |
| 137 | |
spirosmastorakis | 34eed98 | 2016-11-02 15:20:50 -0700 | [diff] [blame] | 138 | void |
| 139 | StackHelper::setPolicy(const std::string& policy) |
| 140 | { |
| 141 | auto found = m_csPolicies.find(policy); |
| 142 | if (found != m_csPolicies.end()) { |
| 143 | m_csPolicyCreationFunc = found->second; |
| 144 | } |
| 145 | else { |
| 146 | NS_FATAL_ERROR("Cache replacement policy " << policy << " not found"); |
| 147 | NS_LOG_DEBUG("Available cache replacement policies: "); |
| 148 | for (auto it = m_csPolicies.begin(); it != m_csPolicies.end(); it++) { |
| 149 | NS_LOG_DEBUG(" " << it->first); |
| 150 | } |
| 151 | } |
| 152 | } |
| 153 | |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 154 | void |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 155 | StackHelper::Install(const NodeContainer& c) const |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 156 | { |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 157 | for (NodeContainer::Iterator i = c.Begin(); i != c.End(); ++i) { |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 158 | Install(*i); |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 159 | } |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 160 | } |
| 161 | |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 162 | void |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 163 | StackHelper::InstallAll() const |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 164 | { |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 165 | Install(NodeContainer::GetGlobal()); |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 166 | } |
| 167 | |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 168 | void |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 169 | StackHelper::Install(Ptr<Node> node) const |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 170 | { |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 171 | if (node->GetObject<L3Protocol>() != 0) { |
Spyridon Mastorakis | 21226ae | 2015-03-31 18:03:11 -0700 | [diff] [blame] | 172 | NS_FATAL_ERROR("Cannot re-install NDN stack on node " |
| 173 | << node->GetId()); |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 174 | return; |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 175 | } |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 176 | Simulator::ScheduleWithContext(node->GetId(), Seconds(0), &StackHelper::doInstall, this, node); |
| 177 | Simulator::Stop(Seconds(0)); |
| 178 | Simulator::Run(); // to automatically dispatch events on proper nodes |
| 179 | } |
Alexander Afanasyev | 0ab833e | 2011-08-18 15:49:13 -0700 | [diff] [blame] | 180 | |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 181 | void |
| 182 | StackHelper::doInstall(Ptr<Node> node) const |
| 183 | { |
| 184 | // async install to ensure proper context |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 185 | Ptr<L3Protocol> ndn = m_ndnFactory.Create<L3Protocol>(); |
spirosmastorakis | 0df15ba | 2015-11-14 08:46:24 -0800 | [diff] [blame] | 186 | |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 187 | if (m_isForwarderStatusManagerDisabled) { |
| 188 | ndn->getConfig().put("ndnSIM.disable_forwarder_status_manager", true); |
spirosmastorakis | 0df15ba | 2015-11-14 08:46:24 -0800 | [diff] [blame] | 189 | } |
| 190 | |
| 191 | if (m_isStrategyChoiceManagerDisabled) { |
| 192 | ndn->getConfig().put("ndnSIM.disable_strategy_choice_manager", true); |
| 193 | } |
| 194 | |
Alexander Afanasyev | dde1e81 | 2015-01-06 14:26:09 -0800 | [diff] [blame] | 195 | ndn->getConfig().put("tables.cs_max_packets", (m_maxCsSize == 0) ? 1 : m_maxCsSize); |
| 196 | |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 197 | // Create and aggregate content store if NFD's contest store has been disabled |
Alexander Afanasyev | dde1e81 | 2015-01-06 14:26:09 -0800 | [diff] [blame] | 198 | if (m_maxCsSize == 0) { |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 199 | ndn->AggregateObject(m_contentStoreFactory.Create<ContentStore>()); |
Alexander Afanasyev | dde1e81 | 2015-01-06 14:26:09 -0800 | [diff] [blame] | 200 | } |
spirosmastorakis | 34eed98 | 2016-11-02 15:20:50 -0700 | [diff] [blame] | 201 | // if NFD's CS is enabled, check if a replacement policy has been specified |
| 202 | else { |
| 203 | ndn->setCsReplacementPolicy(m_csPolicyCreationFunc); |
| 204 | } |
Spyridon Mastorakis | de1f773 | 2014-12-05 22:43:34 -0800 | [diff] [blame] | 205 | |
| 206 | // Aggregate L3Protocol on node (must be after setting ndnSIM CS) |
| 207 | node->AggregateObject(ndn); |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 208 | |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 209 | for (uint32_t index = 0; index < node->GetNDevices(); index++) { |
| 210 | Ptr<NetDevice> device = node->GetDevice(index); |
| 211 | // This check does not make sense: LoopbackNetDevice is installed only if IP stack is installed, |
| 212 | // Normally, ndnSIM works without IP stack, so no reason to check |
| 213 | // if (DynamicCast<LoopbackNetDevice> (device) != 0) |
| 214 | // continue; // don't create face for a LoopbackNetDevice |
Alexander Afanasyev | 1145314 | 2011-11-25 16:13:33 -0800 | [diff] [blame] | 215 | |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 216 | this->createAndRegisterFace(node, ndn, device); |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 217 | } |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 218 | } |
| 219 | |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 220 | void |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 221 | StackHelper::AddFaceCreateCallback(TypeId netDeviceType, |
| 222 | StackHelper::FaceCreateCallback callback) |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 223 | { |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 224 | m_netDeviceCallbacks.push_back(std::make_pair(netDeviceType, callback)); |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 225 | } |
| 226 | |
Alexander Afanasyev | 2a269f7 | 2013-06-06 22:59:33 -0700 | [diff] [blame] | 227 | void |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 228 | StackHelper::UpdateFaceCreateCallback(TypeId netDeviceType, |
| 229 | FaceCreateCallback callback) |
Alexander Afanasyev | 2a269f7 | 2013-06-06 22:59:33 -0700 | [diff] [blame] | 230 | { |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 231 | for (auto& i : m_netDeviceCallbacks) { |
| 232 | if (i.first == netDeviceType) { |
| 233 | i.second = callback; |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 234 | return; |
Alexander Afanasyev | 2a269f7 | 2013-06-06 22:59:33 -0700 | [diff] [blame] | 235 | } |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 236 | } |
Alexander Afanasyev | 2a269f7 | 2013-06-06 22:59:33 -0700 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | void |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 240 | StackHelper::RemoveFaceCreateCallback(TypeId netDeviceType, |
| 241 | FaceCreateCallback callback) |
Alexander Afanasyev | 2a269f7 | 2013-06-06 22:59:33 -0700 | [diff] [blame] | 242 | { |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 243 | m_netDeviceCallbacks.remove_if([&] (const std::pair<TypeId, FaceCreateCallback>& i) { |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 244 | return (i.first == netDeviceType); |
| 245 | }); |
Alexander Afanasyev | 2a269f7 | 2013-06-06 22:59:33 -0700 | [diff] [blame] | 246 | } |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 247 | |
Alexander Afanasyev | a9d889b | 2016-09-08 18:34:25 -0700 | [diff] [blame] | 248 | std::string |
| 249 | constructFaceUri(Ptr<NetDevice> netDevice) |
| 250 | { |
| 251 | std::string uri = "netdev://"; |
| 252 | Address address = netDevice->GetAddress(); |
| 253 | if (Mac48Address::IsMatchingType(address)) { |
| 254 | uri += "[" + boost::lexical_cast<std::string>(Mac48Address::ConvertFrom(address)) + "]"; |
| 255 | } |
| 256 | |
| 257 | return uri; |
| 258 | } |
| 259 | |
| 260 | |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 261 | shared_ptr<Face> |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 262 | StackHelper::DefaultNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn, |
| 263 | Ptr<NetDevice> netDevice) const |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 264 | { |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 265 | NS_LOG_DEBUG("Creating default Face on node " << node->GetId()); |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 266 | |
Spyridon Mastorakis | 5ea3322 | 2016-12-07 14:33:53 -0800 | [diff] [blame] | 267 | // Create an ndnSIM-specific transport instance |
| 268 | ::nfd::face::GenericLinkService::Options opts; |
| 269 | opts.allowFragmentation = true; |
| 270 | opts.allowReassembly = true; |
schneiderklaus | 5f5c992 | 2018-07-25 20:35:03 -0700 | [diff] [blame] | 271 | opts.allowCongestionMarking = true; |
Spyridon Mastorakis | 5ea3322 | 2016-12-07 14:33:53 -0800 | [diff] [blame] | 272 | |
| 273 | auto linkService = make_unique<::nfd::face::GenericLinkService>(opts); |
| 274 | |
| 275 | auto transport = make_unique<NetDeviceTransport>(node, netDevice, |
| 276 | constructFaceUri(netDevice), |
| 277 | "netdev://[ff:ff:ff:ff:ff:ff]"); |
| 278 | |
| 279 | auto face = std::make_shared<Face>(std::move(linkService), std::move(transport)); |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 280 | face->setMetric(1); |
| 281 | |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 282 | ndn->addFace(face); |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 283 | NS_LOG_LOGIC("Node " << node->GetId() << ": added Face as face #" |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 284 | << face->getLocalUri()); |
Alexander Afanasyev | c17e4bd | 2013-02-17 14:31:56 -0800 | [diff] [blame] | 285 | |
| 286 | return face; |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 287 | } |
| 288 | |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 289 | shared_ptr<Face> |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 290 | StackHelper::PointToPointNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn, |
| 291 | Ptr<NetDevice> device) const |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 292 | { |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 293 | NS_LOG_DEBUG("Creating point-to-point Face on node " << node->GetId()); |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 294 | |
Alexander Afanasyev | a9d889b | 2016-09-08 18:34:25 -0700 | [diff] [blame] | 295 | Ptr<PointToPointNetDevice> netDevice = DynamicCast<PointToPointNetDevice>(device); |
| 296 | NS_ASSERT(netDevice != nullptr); |
| 297 | |
| 298 | // access the other end of the link |
| 299 | Ptr<PointToPointChannel> channel = DynamicCast<PointToPointChannel>(netDevice->GetChannel()); |
| 300 | NS_ASSERT(channel != nullptr); |
| 301 | |
| 302 | Ptr<NetDevice> remoteNetDevice = channel->GetDevice(0); |
| 303 | if (remoteNetDevice->GetNode() == node) |
| 304 | remoteNetDevice = channel->GetDevice(1); |
| 305 | |
Spyridon Mastorakis | 5ea3322 | 2016-12-07 14:33:53 -0800 | [diff] [blame] | 306 | // Create an ndnSIM-specific transport instance |
| 307 | ::nfd::face::GenericLinkService::Options opts; |
| 308 | opts.allowFragmentation = true; |
| 309 | opts.allowReassembly = true; |
schneiderklaus | 5f5c992 | 2018-07-25 20:35:03 -0700 | [diff] [blame] | 310 | opts.allowCongestionMarking = true; |
Alexander Afanasyev | a9d889b | 2016-09-08 18:34:25 -0700 | [diff] [blame] | 311 | |
Spyridon Mastorakis | 5ea3322 | 2016-12-07 14:33:53 -0800 | [diff] [blame] | 312 | auto linkService = make_unique<::nfd::face::GenericLinkService>(opts); |
| 313 | |
| 314 | auto transport = make_unique<NetDeviceTransport>(node, netDevice, |
| 315 | constructFaceUri(netDevice), |
| 316 | constructFaceUri(remoteNetDevice)); |
| 317 | |
| 318 | auto face = std::make_shared<Face>(std::move(linkService), std::move(transport)); |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 319 | face->setMetric(1); |
| 320 | |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 321 | ndn->addFace(face); |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 322 | NS_LOG_LOGIC("Node " << node->GetId() << ": added Face as face #" |
Spyridon Mastorakis | 9760bd0 | 2014-11-12 13:32:55 -0800 | [diff] [blame] | 323 | << face->getLocalUri()); |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 324 | |
Alexander Afanasyev | 122f378 | 2013-02-02 00:04:40 -0800 | [diff] [blame] | 325 | return face; |
| 326 | } |
| 327 | |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 328 | void |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 329 | StackHelper::Install(const std::string& nodeName) const |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 330 | { |
Alexander Afanasyev | be55cf6 | 2014-12-20 17:51:09 -0800 | [diff] [blame] | 331 | Ptr<Node> node = Names::Find<Node>(nodeName); |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 332 | Install(node); |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 333 | } |
| 334 | |
Spyridon Mastorakis | 21226ae | 2015-03-31 18:03:11 -0700 | [diff] [blame] | 335 | void |
| 336 | StackHelper::Update(Ptr<Node> node) |
| 337 | { |
| 338 | if (node->GetObject<L3Protocol>() == 0) { |
| 339 | Install(node); |
| 340 | return; |
| 341 | } |
| 342 | |
| 343 | Ptr<L3Protocol> ndn = node->GetObject<L3Protocol>(); |
| 344 | |
| 345 | for (uint32_t index = 0; index < node->GetNDevices(); index++) { |
| 346 | |
| 347 | Ptr<NetDevice> device = node->GetDevice(index); |
| 348 | |
| 349 | if (ndn->getFaceByNetDevice(device) == nullptr) { |
| 350 | this->createAndRegisterFace(node, ndn, device); |
| 351 | } |
| 352 | } |
| 353 | } |
| 354 | |
| 355 | void |
| 356 | StackHelper::Update(const NodeContainer& c) |
| 357 | { |
| 358 | for (NodeContainer::Iterator i = c.Begin(); i != c.End(); ++i) { |
| 359 | Update(*i); |
| 360 | } |
| 361 | } |
| 362 | |
| 363 | void |
| 364 | StackHelper::Update(const std::string& nodeName) |
| 365 | { |
| 366 | Ptr<Node> node = Names::Find<Node>(nodeName); |
| 367 | Update(node); |
| 368 | } |
| 369 | |
| 370 | void |
| 371 | StackHelper::UpdateAll() |
| 372 | { |
| 373 | Update(NodeContainer::GetGlobal()); |
| 374 | } |
| 375 | |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 376 | shared_ptr<Face> |
Spyridon Mastorakis | 21226ae | 2015-03-31 18:03:11 -0700 | [diff] [blame] | 377 | StackHelper::createAndRegisterFace(Ptr<Node> node, Ptr<L3Protocol> ndn, Ptr<NetDevice> device) const |
| 378 | { |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 379 | shared_ptr<Face> face; |
Spyridon Mastorakis | 21226ae | 2015-03-31 18:03:11 -0700 | [diff] [blame] | 380 | |
| 381 | for (const auto& item : m_netDeviceCallbacks) { |
| 382 | if (device->GetInstanceTypeId() == item.first || |
| 383 | device->GetInstanceTypeId().IsChildOf(item.first)) { |
| 384 | face = item.second(node, ndn, device); |
| 385 | if (face != 0) |
| 386 | break; |
| 387 | } |
| 388 | } |
| 389 | |
| 390 | if (face == 0) { |
| 391 | face = DefaultNetDeviceCallback(node, ndn, device); |
| 392 | } |
| 393 | |
| 394 | if (m_needSetDefaultRoutes) { |
| 395 | // default route with lowest priority possible |
Alexander Afanasyev | dc3c3a3 | 2019-02-17 20:17:32 -0500 | [diff] [blame^] | 396 | Simulator::ScheduleWithContext(node->GetId(), Seconds(0), MakeEvent([=] { |
| 397 | FibHelper::AddRoute(node, "/", face, std::numeric_limits<int32_t>::max()); |
| 398 | })); |
Spyridon Mastorakis | 21226ae | 2015-03-31 18:03:11 -0700 | [diff] [blame] | 399 | } |
| 400 | return face; |
| 401 | } |
| 402 | |
spirosmastorakis | 0df15ba | 2015-11-14 08:46:24 -0800 | [diff] [blame] | 403 | void |
spirosmastorakis | 0df15ba | 2015-11-14 08:46:24 -0800 | [diff] [blame] | 404 | StackHelper::disableStrategyChoiceManager() |
| 405 | { |
| 406 | m_isStrategyChoiceManagerDisabled = true; |
| 407 | } |
| 408 | |
| 409 | void |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 410 | StackHelper::disableForwarderStatusManager() |
spirosmastorakis | 0df15ba | 2015-11-14 08:46:24 -0800 | [diff] [blame] | 411 | { |
Alexander Afanasyev | a91aab4 | 2016-09-08 15:47:38 -0700 | [diff] [blame] | 412 | m_isForwarderStatusManagerDisabled = true; |
spirosmastorakis | 0df15ba | 2015-11-14 08:46:24 -0800 | [diff] [blame] | 413 | } |
| 414 | |
Chavoosh Ghasemi | 58ef861 | 2018-09-12 15:12:49 -0700 | [diff] [blame] | 415 | void |
| 416 | StackHelper::SetLinkDelayAsFaceMetric() |
| 417 | { |
| 418 | for (uint32_t i = 0; i < NodeList::GetNNodes(); ++i) { |
| 419 | auto ndn = NodeList::GetNode(i)->GetObject<L3Protocol>(); |
| 420 | if (ndn == nullptr) |
| 421 | continue; |
| 422 | |
| 423 | for (auto& face : ndn->getForwarder()->getFaceTable()) { |
| 424 | auto transport = dynamic_cast<NetDeviceTransport*>(face.getTransport()); |
| 425 | if (transport == nullptr) |
| 426 | continue; |
| 427 | auto p2p = dynamic_cast<PointToPointChannel*>(&(*(transport->GetNetDevice()->GetChannel()))); |
| 428 | TimeValue currentDelay; |
| 429 | p2p->GetAttribute("Delay", currentDelay); |
| 430 | face.setMetric((currentDelay.Get().ToDouble(Time::S)) * 1000); |
| 431 | |
| 432 | std::cout << "Node " << i << ": Face " << face.getId() |
| 433 | << " with metric " << face.getMetric() << "\n"; |
| 434 | } |
| 435 | } |
| 436 | } |
| 437 | |
Alexander Afanasyev | 2b4c947 | 2012-08-09 15:00:38 -0700 | [diff] [blame] | 438 | } // namespace ndn |
Alexander Afanasyev | 45b92d4 | 2011-08-14 23:11:38 -0700 | [diff] [blame] | 439 | } // namespace ns3 |