NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.0: 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 "model/null-transport.hpp"
31 #include "utils/ndn-time.hpp"
32 #include "utils/dummy-keychain.hpp"
34 
35 #include <limits>
36 #include <map>
37 #include <boost/lexical_cast.hpp>
38 
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  auto netDeviceLink = make_unique<NetDeviceLinkService>(node, netDevice);
274  auto transport = make_unique<NullTransport>(constructFaceUri(netDevice), "netdev://[ff:ff:ff:ff:ff:ff]");
275  auto face = std::make_shared<Face>(std::move(netDeviceLink), std::move(transport));
276  face->setMetric(1);
277 
278  ndn->addFace(face);
279  NS_LOG_LOGIC("Node " << node->GetId() << ": added Face as face #"
280  << face->getLocalUri());
281 
282  return face;
283 }
284 
285 shared_ptr<Face>
286 StackHelper::PointToPointNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn,
287  Ptr<NetDevice> device) const
288 {
289  NS_LOG_DEBUG("Creating point-to-point Face on node " << node->GetId());
290 
291  Ptr<PointToPointNetDevice> netDevice = DynamicCast<PointToPointNetDevice>(device);
292  NS_ASSERT(netDevice != nullptr);
293 
294  // access the other end of the link
295  Ptr<PointToPointChannel> channel = DynamicCast<PointToPointChannel>(netDevice->GetChannel());
296  NS_ASSERT(channel != nullptr);
297 
298  Ptr<NetDevice> remoteNetDevice = channel->GetDevice(0);
299  if (remoteNetDevice->GetNode() == node)
300  remoteNetDevice = channel->GetDevice(1);
301 
302  auto netDeviceLink = make_unique<NetDeviceLinkService>(node, netDevice);
303 
304  auto transport = make_unique<NullTransport>(constructFaceUri(netDevice), constructFaceUri(remoteNetDevice));
305  auto face = std::make_shared<Face>(std::move(netDeviceLink), std::move(transport));
306  face->setMetric(1);
307 
308  ndn->addFace(face);
309  NS_LOG_LOGIC("Node " << node->GetId() << ": added Face as face #"
310  << face->getLocalUri());
311 
312  return face;
313 }
314 
315 Ptr<FaceContainer>
316 StackHelper::Install(const std::string& nodeName) const
317 {
318  Ptr<Node> node = Names::Find<Node>(nodeName);
319  return Install(node);
320 }
321 
322 void
323 StackHelper::Update(Ptr<Node> node)
324 {
325  if (node->GetObject<L3Protocol>() == 0) {
326  Install(node);
327  return;
328  }
329 
330  Ptr<L3Protocol> ndn = node->GetObject<L3Protocol>();
331 
332  for (uint32_t index = 0; index < node->GetNDevices(); index++) {
333 
334  Ptr<NetDevice> device = node->GetDevice(index);
335 
336  if (ndn->getFaceByNetDevice(device) == nullptr) {
337  this->createAndRegisterFace(node, ndn, device);
338  }
339  }
340 }
341 
342 void
343 StackHelper::Update(const NodeContainer& c)
344 {
345  for (NodeContainer::Iterator i = c.Begin(); i != c.End(); ++i) {
346  Update(*i);
347  }
348 }
349 
350 void
351 StackHelper::Update(const std::string& nodeName)
352 {
353  Ptr<Node> node = Names::Find<Node>(nodeName);
354  Update(node);
355 }
356 
357 void
359 {
360  Update(NodeContainer::GetGlobal());
361 }
362 
363 shared_ptr<Face>
364 StackHelper::createAndRegisterFace(Ptr<Node> node, Ptr<L3Protocol> ndn, Ptr<NetDevice> device) const
365 {
366  shared_ptr<Face> face;
367 
368  for (const auto& item : m_netDeviceCallbacks) {
369  if (device->GetInstanceTypeId() == item.first ||
370  device->GetInstanceTypeId().IsChildOf(item.first)) {
371  face = item.second(node, ndn, device);
372  if (face != 0)
373  break;
374  }
375  }
376 
377  if (face == 0) {
378  face = DefaultNetDeviceCallback(node, ndn, device);
379  }
380 
381  if (m_needSetDefaultRoutes) {
382  // default route with lowest priority possible
383  FibHelper::AddRoute(node, "/", face, std::numeric_limits<int32_t>::max());
384  }
385  return face;
386 }
387 
388 void
390 {
391  m_isRibManagerDisabled = true;
392 }
393 
394 // void
395 // StackHelper::disableFaceManager()
396 // {
397 // m_isFaceManagerDisabled = true;
398 // }
399 
400 void
402 {
403  m_isStrategyChoiceManagerDisabled = true;
404 }
405 
406 void
408 {
409  m_isForwarderStatusManagerDisabled = true;
410 }
411 
412 } // namespace ndn
413 } // 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.
nfd::ConfigSection & getConfig()
Get NFD config (boost::property_tree)
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.
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:35
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)
void disableStrategyChoiceManager()
Disable Face Manager.
Base class for NDN content store.