NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.5: NDN, CCN, CCNx, content centric networks
API Documentation
ndn-stack-helper.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
20 #include "ndn-stack-helper.hpp"
21 
22 #include "ns3/log.h"
23 #include "ns3/names.h"
24 #include "ns3/string.h"
25 #include "ns3/point-to-point-net-device.h"
26 #include "ns3/point-to-point-channel.h"
27 
30 #include "utils/ndn-time.hpp"
31 #include "utils/dummy-keychain.hpp"
33 
34 #include <limits>
35 #include <map>
36 #include <boost/lexical_cast.hpp>
37 
38 #include "ns3/ndnSIM/NFD/daemon/face/generic-link-service.hpp"
39 #include "ns3/ndnSIM/NFD/daemon/table/cs-policy-priority-fifo.hpp"
40 #include "ns3/ndnSIM/NFD/daemon/table/cs-policy-lru.hpp"
41 
42 NS_LOG_COMPONENT_DEFINE("ndn.StackHelper");
43 
44 namespace ns3 {
45 namespace ndn {
46 
48  : m_isRibManagerDisabled(false)
49  // , m_isFaceManagerDisabled(false)
50  , m_isForwarderStatusManagerDisabled(false)
51  , m_isStrategyChoiceManagerDisabled(false)
52  , m_needSetDefaultRoutes(false)
53  , m_maxCsSize(100)
54 {
56 
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 
62  m_ndnFactory.SetTypeId("ns3::ndn::L3Protocol");
63  m_contentStoreFactory.SetTypeId("ns3::ndn::cs::Lru");
64 
65  m_netDeviceCallbacks.push_back(
66  std::make_pair(PointToPointNetDevice::GetTypeId(),
67  MakeCallback(&StackHelper::PointToPointNetDeviceCallback, this)));
68  // default callback will be fired if non of others callbacks fit or did the job
69 }
70 
72 {
73 }
74 
75 KeyChain&
77 {
78  static ::ndn::KeyChain keyChain("pib-dummy", "tpm-dummy");
79  return keyChain;
80 }
81 
82 void
84 {
85  ::ndn::time::setCustomClocks(make_shared<ns3::ndn::time::CustomSteadyClock>(),
86  make_shared<ns3::ndn::time::CustomSystemClock>());
87 }
88 
89 void
91 {
92  NS_LOG_FUNCTION(this << needSet);
93  m_needSetDefaultRoutes = needSet;
94 }
95 
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
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)
118 {
119  m_maxCsSize = 0;
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
133 StackHelper::setCsSize(size_t maxSize)
134 {
135  m_maxCsSize = maxSize;
136 }
137 
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 
154 Ptr<FaceContainer>
155 StackHelper::Install(const NodeContainer& c) const
156 {
157  Ptr<FaceContainer> faces = Create<FaceContainer>();
158  for (NodeContainer::Iterator i = c.Begin(); i != c.End(); ++i) {
159  faces->AddAll(Install(*i));
160  }
161  return faces;
162 }
163 
164 Ptr<FaceContainer>
166 {
167  return Install(NodeContainer::GetGlobal());
168 }
169 
170 Ptr<FaceContainer>
171 StackHelper::Install(Ptr<Node> node) const
172 {
173  Ptr<FaceContainer> faces = Create<FaceContainer>();
174 
175  if (node->GetObject<L3Protocol>() != 0) {
176  NS_FATAL_ERROR("Cannot re-install NDN stack on node "
177  << node->GetId());
178  return 0;
179  }
180 
181  Ptr<L3Protocol> ndn = m_ndnFactory.Create<L3Protocol>();
182 
183  if (m_isRibManagerDisabled) {
184  ndn->getConfig().put("ndnSIM.disable_rib_manager", true);
185  }
186 
187  // if (m_isFaceManagerDisabled) {
188  // ndn->getConfig().put("ndnSIM.disable_face_manager", true);
189  // }
190 
191  if (m_isForwarderStatusManagerDisabled) {
192  ndn->getConfig().put("ndnSIM.disable_forwarder_status_manager", true);
193  }
194 
195  if (m_isStrategyChoiceManagerDisabled) {
196  ndn->getConfig().put("ndnSIM.disable_strategy_choice_manager", true);
197  }
198 
199  ndn->getConfig().put("tables.cs_max_packets", (m_maxCsSize == 0) ? 1 : m_maxCsSize);
200 
201  // Create and aggregate content store if NFD's contest store has been disabled
202  if (m_maxCsSize == 0) {
203  ndn->AggregateObject(m_contentStoreFactory.Create<ContentStore>());
204  }
205  // if NFD's CS is enabled, check if a replacement policy has been specified
206  else {
207  ndn->setCsReplacementPolicy(m_csPolicyCreationFunc);
208  }
209 
210  // Aggregate L3Protocol on node (must be after setting ndnSIM CS)
211  node->AggregateObject(ndn);
212 
213  for (uint32_t index = 0; index < node->GetNDevices(); index++) {
214  Ptr<NetDevice> device = node->GetDevice(index);
215  // This check does not make sense: LoopbackNetDevice is installed only if IP stack is installed,
216  // Normally, ndnSIM works without IP stack, so no reason to check
217  // if (DynamicCast<LoopbackNetDevice> (device) != 0)
218  // continue; // don't create face for a LoopbackNetDevice
219 
220  faces->Add(this->createAndRegisterFace(node, ndn, device));
221  }
222 
223  return faces;
224 }
225 
226 void
229 {
230  m_netDeviceCallbacks.push_back(std::make_pair(netDeviceType, callback));
231 }
232 
233 void
235  FaceCreateCallback callback)
236 {
237  for (auto& i : m_netDeviceCallbacks) {
238  if (i.first == netDeviceType) {
239  i.second = callback;
240  return;
241  }
242  }
243 }
244 
245 void
247  FaceCreateCallback callback)
248 {
249  m_netDeviceCallbacks.remove_if([&] (const std::pair<TypeId, FaceCreateCallback>& i) {
250  return (i.first == netDeviceType);
251  });
252 }
253 
254 std::string
255 constructFaceUri(Ptr<NetDevice> netDevice)
256 {
257  std::string uri = "netdev://";
258  Address address = netDevice->GetAddress();
259  if (Mac48Address::IsMatchingType(address)) {
260  uri += "[" + boost::lexical_cast<std::string>(Mac48Address::ConvertFrom(address)) + "]";
261  }
262 
263  return uri;
264 }
265 
266 
267 shared_ptr<Face>
268 StackHelper::DefaultNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn,
269  Ptr<NetDevice> netDevice) const
270 {
271  NS_LOG_DEBUG("Creating default Face on node " << node->GetId());
272 
273  // Create an ndnSIM-specific transport instance
275  opts.allowFragmentation = true;
276  opts.allowReassembly = true;
277  opts.allowCongestionMarking = true;
278 
279  auto linkService = make_unique<::nfd::face::GenericLinkService>(opts);
280 
281  auto transport = make_unique<NetDeviceTransport>(node, netDevice,
282  constructFaceUri(netDevice),
283  "netdev://[ff:ff:ff:ff:ff:ff]");
284 
285  auto face = std::make_shared<Face>(std::move(linkService), std::move(transport));
286  face->setMetric(1);
287 
288  ndn->addFace(face);
289  NS_LOG_LOGIC("Node " << node->GetId() << ": added Face as face #"
290  << face->getLocalUri());
291 
292  return face;
293 }
294 
295 shared_ptr<Face>
296 StackHelper::PointToPointNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn,
297  Ptr<NetDevice> device) const
298 {
299  NS_LOG_DEBUG("Creating point-to-point Face on node " << node->GetId());
300 
301  Ptr<PointToPointNetDevice> netDevice = DynamicCast<PointToPointNetDevice>(device);
302  NS_ASSERT(netDevice != nullptr);
303 
304  // access the other end of the link
305  Ptr<PointToPointChannel> channel = DynamicCast<PointToPointChannel>(netDevice->GetChannel());
306  NS_ASSERT(channel != nullptr);
307 
308  Ptr<NetDevice> remoteNetDevice = channel->GetDevice(0);
309  if (remoteNetDevice->GetNode() == node)
310  remoteNetDevice = channel->GetDevice(1);
311 
312  // Create an ndnSIM-specific transport instance
314  opts.allowFragmentation = true;
315  opts.allowReassembly = true;
316  opts.allowCongestionMarking = true;
317 
318  auto linkService = make_unique<::nfd::face::GenericLinkService>(opts);
319 
320  auto transport = make_unique<NetDeviceTransport>(node, netDevice,
321  constructFaceUri(netDevice),
322  constructFaceUri(remoteNetDevice));
323 
324  auto face = std::make_shared<Face>(std::move(linkService), std::move(transport));
325  face->setMetric(1);
326 
327  ndn->addFace(face);
328  NS_LOG_LOGIC("Node " << node->GetId() << ": added Face as face #"
329  << face->getLocalUri());
330 
331  return face;
332 }
333 
334 Ptr<FaceContainer>
335 StackHelper::Install(const std::string& nodeName) const
336 {
337  Ptr<Node> node = Names::Find<Node>(nodeName);
338  return Install(node);
339 }
340 
341 void
342 StackHelper::Update(Ptr<Node> node)
343 {
344  if (node->GetObject<L3Protocol>() == 0) {
345  Install(node);
346  return;
347  }
348 
349  Ptr<L3Protocol> ndn = node->GetObject<L3Protocol>();
350 
351  for (uint32_t index = 0; index < node->GetNDevices(); index++) {
352 
353  Ptr<NetDevice> device = node->GetDevice(index);
354 
355  if (ndn->getFaceByNetDevice(device) == nullptr) {
356  this->createAndRegisterFace(node, ndn, device);
357  }
358  }
359 }
360 
361 void
362 StackHelper::Update(const NodeContainer& c)
363 {
364  for (NodeContainer::Iterator i = c.Begin(); i != c.End(); ++i) {
365  Update(*i);
366  }
367 }
368 
369 void
370 StackHelper::Update(const std::string& nodeName)
371 {
372  Ptr<Node> node = Names::Find<Node>(nodeName);
373  Update(node);
374 }
375 
376 void
378 {
379  Update(NodeContainer::GetGlobal());
380 }
381 
382 shared_ptr<Face>
383 StackHelper::createAndRegisterFace(Ptr<Node> node, Ptr<L3Protocol> ndn, Ptr<NetDevice> device) const
384 {
385  shared_ptr<Face> face;
386 
387  for (const auto& item : m_netDeviceCallbacks) {
388  if (device->GetInstanceTypeId() == item.first ||
389  device->GetInstanceTypeId().IsChildOf(item.first)) {
390  face = item.second(node, ndn, device);
391  if (face != 0)
392  break;
393  }
394  }
395 
396  if (face == 0) {
397  face = DefaultNetDeviceCallback(node, ndn, device);
398  }
399 
400  if (m_needSetDefaultRoutes) {
401  // default route with lowest priority possible
402  FibHelper::AddRoute(node, "/", face, std::numeric_limits<int32_t>::max());
403  }
404  return face;
405 }
406 
407 void
409 {
410  m_isRibManagerDisabled = true;
411 }
412 
413 // void
414 // StackHelper::disableFaceManager()
415 // {
416 // m_isFaceManagerDisabled = true;
417 // }
418 
419 void
421 {
422  m_isStrategyChoiceManagerDisabled = true;
423 }
424 
425 void
427 {
428  m_isForwarderStatusManagerDisabled = true;
429 }
430 
431 } // namespace ndn
432 } // namespace ns3
virtual ~StackHelper()
Destroy the NdnStackHelper.
Copyright (c) 2011-2015 Regents of the University of California.
void setPolicy(const std::string &policy)
Set the cache replacement policy for NFD&#39;s Content Store.
StackHelper()
Create a new NdnStackHelper with a default NDN_FLOODING forwarding stategy.
void RemoveFaceCreateCallback(TypeId netDeviceType, FaceCreateCallback callback)
Remove callback to create and configure instance of the face, based on supplied Ptr<Node> and Ptr<Net...
void setCsSize(size_t maxSize)
Set maximum size for NFD&#39;s Content Store (in number of packets)
void SetDefaultRoutes(bool needSet)
Set flag indicating necessity to install default routes in FIB.
void SetStackAttributes(const std::string &attr1="", const std::string &value1="", const std::string &attr2="", const std::string &value2="", const std::string &attr3="", const std::string &value3="", const std::string &attr4="", const std::string &value4="")
Set parameters of NdnL3Protocol.
static void AddRoute(Ptr< Node > node, const Name &prefix, shared_ptr< Face > face, int32_t metric)
Add forwarding entry to FIB.
void disableForwarderStatusManager()
Disable Forwarder Status Manager.
std::string constructFaceUri(Ptr< NetDevice > netDevice)
Ptr< FaceContainer > Install(const std::string &nodeName) const
Install Ndn stack on the node.
bool allowCongestionMarking
enables send queue congestion detection and marking
Callback< shared_ptr< Face >, Ptr< Node >, Ptr< L3Protocol >, Ptr< NetDevice > > FaceCreateCallback
Copyright (c) 2011-2015 Regents of the University of California.
void AddFaceCreateCallback(TypeId netDeviceType, FaceCreateCallback callback)
Add callback to create and configure instance of the face, based on supplied Ptr<Node> and Ptr<NetDev...
void disableRibManager()
Disable the RIB manager of NFD.
void SetOldContentStore(const std::string &contentStoreClass, const std::string &attr1="", const std::string &value1="", const std::string &attr2="", const std::string &value2="", const std::string &attr3="", const std::string &value3="", const std::string &attr4="", const std::string &value4="")
Set ndnSIM 1.0 content store implementation and its attributes.
Ptr< FaceContainer > InstallAll() const
Install Ndn stack on all nodes in the simulation.
Implementation network-layer of NDN stack.
void setCustomClocks(shared_ptr< CustomSteadyClock > steadyClock=nullptr, shared_ptr< CustomSystemClock > systemClock=nullptr)
Set custom system and steady clocks.
Definition: time.cpp:36
Options that control the behavior of GenericLinkService.
void UpdateAll()
Update Ndn stack on all the nodes (Add faces for new devices)
static KeyChain & getKeyChain()
void UpdateFaceCreateCallback(TypeId netDeviceType, FaceCreateCallback callback)
Update callback to create and configure instance of the face, based on supplied Ptr<Node> and Ptr<Net...
void Update(Ptr< Node > node)
Update Ndn stack on a given node (Add faces for new devices)
ndn security v2 KeyChain
Definition: key-chain.cpp:70
void disableStrategyChoiceManager()
Disable Face Manager.
Base class for NDN content store.