Modification of CcnxFace interface and unification of CCNx applications via common CcnxApp class
Moving functionality of interest limits from PIT to Face.
!!! Code compiles, but probably doesn't work !!!
diff --git a/apps/ccnx-app.cc b/apps/ccnx-app.cc
new file mode 100644
index 0000000..a23167e
--- /dev/null
+++ b/apps/ccnx-app.cc
@@ -0,0 +1,140 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2011 University of California, Los Angeles
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ */
+
+#include "ccnx-app.h"
+#include "ns3/log.h"
+#include "ns3/packet.h"
+#include "ns3/ccnx-interest-header.h"
+#include "ns3/ccnx-content-object-header.h"
+
+NS_LOG_COMPONENT_DEFINE ("CcnxApp");
+
+namespace ns3
+{
+
+NS_OBJECT_ENSURE_REGISTERED (CcnxApp);
+
+TypeId
+CcnxConsumer::GetTypeId (void)
+{
+ static TypeId tid = TypeId ("ns3::CcnxApp")
+ .SetParent<Application> ()
+ .AddConstructor<CcnxApp> ()
+ ;
+ return tid;
+}
+
+CcnxApp::CcnxApp ()
+ : m_protocolHandler (0)
+ , m_active (true)
+ , m_face (0)
+{
+}
+
+CcnxApp::~CcnxApp ()
+{
+ StopApplication ();
+}
+
+void
+CcnxProducer::DoDispose (void)
+{
+ NS_LOG_FUNCTION_NOARGS ();
+
+ StopApplication ();
+ CcnxApp::DoDispose ();
+}
+
+void
+CcnxApp::RegisterProtocolHandler (ProtocolHandler handler)
+{
+ m_protocolHandler = handler;
+}
+
+void
+CcnxApp::OnInterest (const Ptr<const CcnxInterestHeader> &interest)
+{
+ NS_LOG_FUNCTION (this << interest);
+}
+
+void
+CcnxApp::OnNack (const Ptr<const CcnxInterestHeader> &interest)
+{
+ NS_LOG_FUNCTION (this << interest);
+}
+
+void
+CcnxApp::OnContentObject (const Ptr<const CcnxContentObjectHeader> &contentObject,
+ const Ptr<const Packet> &payload)
+{
+ NS_LOG_FUNCTION (this << contentObject << payload);
+}
+
+// Application Methods
+void
+CcnxApp::StartApplication () // Called at time specified by Start
+{
+ NS_LOG_FUNCTION_NOARGS ();
+
+ NS_ASSERT (m_active != true);
+ m_active = true;
+
+ NS_ASSERT_MSG (GetObject<Ccnx> () != 0,
+ "Ccnx stack should be installed on the node " << GetNode ());
+ NS_ASSERT_MSG (GetObject<CcnxFib> () != 0);
+
+ // step 1. Create a face
+ m_face = Create<CcnxLocalFace> (/*Ptr<CcnxApp> (this)*/this);
+
+ // step 2. Add face to the CCNx stack
+ GetObject<CcnxFib> ()->Add (m_prefix, m_face, 0);
+ GetObject<Ccnx> ()->AddFace (m_face);
+
+ // step 3. Enable face
+ m_face->SetUp (true);
+}
+
+void
+CcnxApp::StopApplication () // Called at time specified by Stop
+{
+ NS_LOG_FUNCTION_NOARGS ();
+
+ if (!m_active) return; //don't assert here, just return
+
+ NS_ASSERT (GetObject<Ccnx> () != 0);
+ NS_ASSERT (GetObject<CcnxFib> () != 0);
+
+ m_active = false;
+
+ // step 1. Disable face
+ m_face->SetUp (false);
+
+ // step 2. Remove face from CCNx stack
+ GetObject<Ccnx> ()->RemoveFace (m_face);
+ GetObject<CcnxFib> ()->Add (m_prefix, m_face, 0);
+
+ // step 3. Destroy face
+ NS_ASSERT_MSG (m_face->GetReferenceCount ()==1,
+ "At this point, nobody else should have referenced this face");
+ m_face = 0;
+}
+
+
+}
diff --git a/apps/ccnx-app.h b/apps/ccnx-app.h
new file mode 100644
index 0000000..4f2cb83
--- /dev/null
+++ b/apps/ccnx-app.h
@@ -0,0 +1,104 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2011 University of California, Los Angeles
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
+ */
+
+#ifndef CCNX_APP_H
+#define CCNX_APP_H
+
+#include "ns3/application.h"
+#include "ns3/ptr.h"
+#include "ns3/callback.h"
+
+namespace ns3
+{
+
+class Packet;
+class CcnxInterestHeader;
+class CcnxContentObjectHeader;
+
+/**
+ * @ingroup ccnx
+ * @brief Base class that all CCNx applications should be derived from.
+ *
+ * The class implements virtual calls onInterest, onNack, and onContentObject
+ */
+class CcnxApp: public Application
+{
+public:
+ typedef Callback<bool, const Ptr<CcnxFace>&> ProtocolHandler;
+
+ static TypeId GetTypeId ();
+
+ /**
+ * @brief Default constructor
+ */
+ CcnxApp ();
+ virtual ~CcnxApp ();
+
+ /**
+ * @brief Register lower layer callback (to send interests from the application)
+ */
+ void
+ RegisterProtocolHandler (ProtocolHandler handler);
+
+ /**
+ * @brief Method that will be called every time new Interest arrives
+ * @param interest Interest header
+ */
+ virtual void
+ OnInterest (const Ptr<const CcnxInterestHeader> &interest);
+
+ /**
+ * @brief Method that will be called every time new NACK arrives
+ * @param interest Interest header
+ */
+ virtual void
+ OnNack (const Ptr<const CcnxInterestHeader> &interest);
+
+ /**
+ * @brief Method that will be called every time new ContentObject arrives
+ * @param contentObject ContentObject header
+ * @param payload payload (potentially virtual) of the ContentObject packet
+ */
+ virtual void
+ OnContentObject (const Ptr<const CcnxContentObjectHeader> &contentObject,
+ const Ptr<const Packet> &payload);
+
+protected:
+ virtual void
+ DoDispose ();
+
+ // inherited from Application base class.
+ virtual void
+ StartApplication (); // Called at time specified by Start
+
+ virtual void
+ StopApplication (); // Called at time specified by Stop
+
+protected:
+ ProtocolHandler m_protocolHandler;
+ bool m_active;
+
+private:
+ Ptr<CcnxFace> m_face; // local face that is created
+};
+
+} // namespace ns3
+
+#endif // CCNX_APP_H
diff --git a/apps/ccnx-consumer.cc b/apps/ccnx-consumer.cc
index ac3950c..01a5b1d 100644
--- a/apps/ccnx-consumer.cc
+++ b/apps/ccnx-consumer.cc
@@ -36,173 +36,132 @@
TypeId
CcnxConsumer::GetTypeId (void)
{
- static TypeId tid = TypeId ("ns3::CcnxConsumer")
- .SetParent<Application> ()
- .AddConstructor<CcnxConsumer> ()
- .AddAttribute ("OffTime", "Time interval between packets",
- StringValue ("100ms"),
- MakeTimeAccessor (&CcnxConsumer::m_offTime),
- MakeTimeChecker ())
- .AddAttribute ("InterestName","CcnxName of the Interest (use CcnxNameComponents)",
- StringValue ("/"),
- MakeCcnxNameComponentsAccessor (&CcnxConsumer::m_interestName),
- MakeCcnxNameComponentsChecker ())
- .AddAttribute ("LifeTime", "LifeTime fo interest packet",
- StringValue ("2s"),
- MakeTimeAccessor (&CcnxConsumer::m_interestLifeTime),
- MakeTimeChecker ())
- .AddAttribute ("MinSuffixComponents", "MinSuffixComponents",
- IntegerValue(-1),
- MakeIntegerAccessor(&CcnxConsumer::m_minSuffixComponents),
- MakeIntegerChecker<int32_t>())
- .AddAttribute ("MaxSuffixComponents", "MaxSuffixComponents",
- IntegerValue(-1),
- MakeIntegerAccessor(&CcnxConsumer::m_maxSuffixComponents),
- MakeIntegerChecker<int32_t>())
- .AddAttribute ("ChildSelector", "ChildSelector",
- BooleanValue(false),
- MakeBooleanAccessor(&CcnxConsumer::m_childSelector),
- MakeBooleanChecker())
- .AddAttribute ("Exclude", "only simple name matching is supported (use CcnxNameComponents)",
- CcnxNameComponentsValue (),
- MakeCcnxNameComponentsAccessor (&CcnxConsumer::m_exclude),
- MakeCcnxNameComponentsChecker ())
- .AddAttribute ("Initial Nonce", "If 0 then nonce is not used",
- UintegerValue(1),
- MakeUintegerAccessor(&CcnxConsumer::m_initialNonce),
- MakeUintegerChecker<uint32_t>())
- .AddTraceSource ("InterestTrace", "Interests that were sent",
- MakeTraceSourceAccessor (&CcnxConsumer::m_interestsTrace))
- .AddTraceSource ("ContentObjectTrace", "ContentObjects that were received",
- MakeTraceSourceAccessor (&CcnxConsumer::m_contentObjectsTrace))
- ;
+ static TypeId tid = TypeId ("ns3::CcnxConsumer")
+ .SetParent<Application> ()
+ .AddConstructor<CcnxConsumer> ()
+ .AddAttribute ("OffTime", "Time interval between packets",
+ StringValue ("100ms"),
+ MakeTimeAccessor (&CcnxConsumer::m_offTime),
+ MakeTimeChecker ())
+ .AddAttribute ("InterestName","CcnxName of the Interest (use CcnxNameComponents)",
+ StringValue ("/"),
+ MakeCcnxNameComponentsAccessor (&CcnxConsumer::m_interestName),
+ MakeCcnxNameComponentsChecker ())
+ .AddAttribute ("LifeTime", "LifeTime fo interest packet",
+ StringValue ("2s"),
+ MakeTimeAccessor (&CcnxConsumer::m_interestLifeTime),
+ MakeTimeChecker ())
+ .AddAttribute ("MinSuffixComponents", "MinSuffixComponents",
+ IntegerValue(-1),
+ MakeIntegerAccessor(&CcnxConsumer::m_minSuffixComponents),
+ MakeIntegerChecker<int32_t>())
+ .AddAttribute ("MaxSuffixComponents", "MaxSuffixComponents",
+ IntegerValue(-1),
+ MakeIntegerAccessor(&CcnxConsumer::m_maxSuffixComponents),
+ MakeIntegerChecker<int32_t>())
+ .AddAttribute ("ChildSelector", "ChildSelector",
+ BooleanValue(false),
+ MakeBooleanAccessor(&CcnxConsumer::m_childSelector),
+ MakeBooleanChecker())
+ .AddAttribute ("Exclude", "only simple name matching is supported (use CcnxNameComponents)",
+ CcnxNameComponentsValue (),
+ MakeCcnxNameComponentsAccessor (&CcnxConsumer::m_exclude),
+ MakeCcnxNameComponentsChecker ())
+ .AddAttribute ("Initial Nonce", "If 0 then nonce is not used",
+ UintegerValue(1),
+ MakeUintegerAccessor(&CcnxConsumer::m_initialNonce),
+ MakeUintegerChecker<uint32_t>())
+ .AddTraceSource ("InterestTrace", "Interests that were sent",
+ MakeTraceSourceAccessor (&CcnxConsumer::m_interestsTrace))
+ .AddTraceSource ("ContentObjectTrace", "ContentObjects that were received",
+ MakeTraceSourceAccessor (&CcnxConsumer::m_contentObjectsTrace))
+ ;
- return tid;
+ return tid;
}
CcnxConsumer::CcnxConsumer ()
- : m_seq (0)
+ : m_rand (0, std::numeric_limits<uint32_t>::max ())
+ , m_seq (0)
{
- NS_LOG_FUNCTION_NOARGS ();
+ NS_LOG_FUNCTION_NOARGS ();
}
CcnxConsumer::~CcnxConsumer()
{
- NS_LOG_FUNCTION_NOARGS ();
+ NS_LOG_FUNCTION_NOARGS ();
}
void
CcnxConsumer::DoDispose (void)
{
- NS_LOG_FUNCTION_NOARGS ();
+ NS_LOG_FUNCTION_NOARGS ();
- Application::DoDispose ();
+ Application::DoDispose ();
}
// Application Methods
void
CcnxConsumer::StartApplication () // Called at time specified by Start
{
- NS_LOG_FUNCTION_NOARGS ();
+ NS_LOG_FUNCTION_NOARGS ();
- NS_ASSERT_MSG (m_face == 0, "Face should not exist");
- m_face = Create<CcnxLocalFace> ();
-
- // step 1. Set up forwarding from face to application
- m_face->SetNode (GetNode ());
- m_face->SetContentObjectHandler (MakeCallback (&CcnxConsumer::OnContentObject, this));
-
- // step 2. Set up forwarding to and from ccnx
- NS_ASSERT_MSG (GetNode ()->GetObject<Ccnx> () !=0,
- "Ccnx stack should be installed on the node " << GetNode ());
- GetNode ()->GetObject<Ccnx> ()->AddFace (m_face);
-
- // step 3. Enable face
- m_face->SetUp ();
-
- // Send first packet immediately
- m_sendEvent = Simulator::Schedule (Seconds(0.0), &CcnxConsumer::SendPacket, this);
+ // do base stuff
+ CcnxApp::StartApplication ();
+
+ // schedule periodic packet generation
+ m_sendEvent = Simulator::Schedule (Seconds(0.0), &CcnxConsumer::SendPacket, this);
}
void
CcnxConsumer::StopApplication () // Called at time specified by Stop
{
- NS_LOG_FUNCTION_NOARGS ();
-
- CancelEvents ();
+ NS_LOG_FUNCTION_NOARGS ();
- // step 1. Disable face
- m_face->SetDown ();
+ // cancel periodic packet generation
+ Simulator::Cancel (m_sendEvent);
- // step 2. Remove face from ccnx stack
- GetNode ()->GetObject<Ccnx> ()->RemoveFace (m_face);
-
- // step 3. Disable callbacks
- m_face->SetContentObjectHandler (MakeNullCallback<void,
- const Ptr<const CcnxContentObjectHeader> &,
- const Ptr<const Packet> &> ());
-}
-
-void
-CcnxConsumer::CancelEvents ()
-{
- NS_LOG_FUNCTION_NOARGS ();
-
- Simulator::Cancel (m_sendEvent);
+ // cleanup base stuff
+ CcnxApp::StopApplication ();
}
void
CcnxConsumer::SendPacket ()
{
- NS_LOG_FUNCTION_NOARGS ();
- NS_LOG_INFO ("Sending Interest at " << Simulator::Now ());
+ NS_LOG_FUNCTION_NOARGS ();
+ NS_LOG_INFO ("Sending Interest at " << Simulator::Now ());
- UniformVariable rand(1, std::numeric_limits<uint32_t>::max ());
- uint32_t randomNonce = rand.GetValue();
-
- CcnxInterestHeader interestHeader;
- interestHeader.SetNonce(randomNonce);
-
- Ptr<CcnxNameComponents> name = Create<CcnxNameComponents> (m_interestName);
- std::ostringstream os;
- os << m_seq++;
- (*name) (os.str ());
-
- interestHeader.SetName (name);
- interestHeader.SetInterestLifetime(m_interestLifeTime);
- interestHeader.SetChildSelector(m_childSelector);
- interestHeader.SetExclude(Create<CcnxNameComponents> (m_exclude));
- interestHeader.SetMaxSuffixComponents(m_maxSuffixComponents);
- interestHeader.SetMinSuffixComponents(m_minSuffixComponents);
+ //
+ Ptr<CcnxNameComponents> nameWithSequence = Create<CcnxNameComponents> (m_interestName);
+ (*name) (m_seq++);
+ //
+
+ CcnxInterestHeader interestHeader;
+ interestHeader.SetNonce (m_rand.GetValue ());
+ interestHeader.SetName (nameWithSequence);
+ interestHeader.SetInterestLifetime (m_interestLifeTime);
+ interestHeader.SetChildSelector (m_childSelector);
+ interestHeader.SetExclude (Create<CcnxNameComponents> (m_exclude));
+ interestHeader.SetMaxSuffixComponents (m_maxSuffixComponents);
+ interestHeader.SetMinSuffixComponents (m_minSuffixComponents);
- NS_LOG_INFO ("Interest: \n" << interestHeader);
+ NS_LOG_INFO ("Interest: \n" << interestHeader);
- Ptr<Packet> packet = Create<Packet> ();
- packet->AddHeader (interestHeader);
+ Ptr<Packet> packet = Create<Packet> ();
+ packet->AddHeader (interestHeader);
- NS_LOG_INFO ("Packet: " << packet);
- m_face->ReceiveFromApplication (packet);
+ m_protocolHandler (packet);
- m_interestsTrace (m_face,packet);
-
- NS_LOG_INFO("time = " << m_offTime);
- m_sendEvent = Simulator::Schedule (m_offTime, &CcnxConsumer::SendPacket, this);
+ m_sendEvent = Simulator::Schedule (m_offTime, &CcnxConsumer::SendPacket, this);
}
-
-// void
-// CcnxConsumer::OnInterest (const Ptr<const CcnxInterestHeader> &interest)
-// {
-// }
void
CcnxConsumer::OnContentObject (const Ptr<const CcnxContentObjectHeader> &contentObject,
const Ptr<const Packet> &payload)
{
- // do stuff
- NS_LOG_FUNCTION ("Received contentObject " << contentObject );
- NS_LOG_INFO ("Preved!");
- m_contentObjectsTrace (m_face,payload);
+ NS_LOG_FUNCTION (this << contentObject << payload);
+
+ NS_LOG_INFO ("Received content object: " << cref(*contentObject));
}
-
-}
+} // namespace ns3
diff --git a/apps/ccnx-consumer.h b/apps/ccnx-consumer.h
index 16dbaf7..b2c115b 100644
--- a/apps/ccnx-consumer.h
+++ b/apps/ccnx-consumer.h
@@ -21,76 +21,45 @@
#ifndef CCNX_CONSUMER_H
#define CCNX_CONSUMER_H
-#include "ns3/application.h"
-#include "ns3/log.h"
-#include "ns3/random-variable.h"
-#include "ns3/nstime.h"
-#include "ns3/event-id.h"
-#include "ns3/ptr.h"
-#include "ns3/simulator.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-local-face.h"
-#include "ns3/ccnx-name-components.h"
-#include "ns3/packet.h"
-#include "ns3/boolean.h"
-#include "ns3/integer.h"
-#include "ns3/uinteger.h"
-#include "ns3/pointer.h"
-#include "ns3/traced-callback.h"
-#include "ns3/ccnx-header-helper.h"
-
-#include "ns3/packet.h"
-#include "ns3/header.h"
+#include "ccnx-app.h"
namespace ns3
{
-class CcnxConsumer: public Application
+class CcnxConsumer: public CcnxApp
{
public:
static TypeId GetTypeId ();
CcnxConsumer ();
- virtual ~CcnxConsumer ();
void OnContentObject (const Ptr<const CcnxContentObjectHeader> &contentObject,
const Ptr<const Packet> &payload);
-
+
protected:
- virtual void DoDispose (void);
+ // from CcnxApp
+ virtual void
+ StartApplication ();
+
+ virtual void
+ StopApplication ();
private:
- // inherited from Application base class.
- virtual void StartApplication (void); // Called at time specified by Start
- virtual void StopApplication (void); // Called at time specified by Stop
-
//helpers
- void CancelEvents ();
-
- // Event handlers
- // void StartSending ();
- // void StopSending ();
void SendPacket ();
- //typedef Callback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>& > ProtocolHandler;
private:
- TracedCallback<const Ptr<CcnxFace>&,const Ptr<const Packet>& > m_interestsTrace;
- TracedCallback<const Ptr<CcnxFace>&,const Ptr<const Packet>& > m_contentObjectsTrace;
+ UniformVariable m_rand;
+ uint32_t m_seq;
+ EventId m_sendEvent; // Eventid of pending "send packet" event
- Time m_offTime;
+ Time m_offTime;
CcnxNameComponents m_interestName;
- Time m_interestLifeTime;
- int32_t m_minSuffixComponents;
- int32_t m_maxSuffixComponents;
- bool m_childSelector;
+ Time m_interestLifeTime;
+ int32_t m_minSuffixComponents;
+ int32_t m_maxSuffixComponents;
+ bool m_childSelector;
CcnxNameComponents m_exclude;
- uint32_t m_initialNonce;
-
- EventId m_sendEvent; // Eventid of pending "send packet" event
- TypeId m_tid;
- Ptr<CcnxLocalFace> m_face;
-
- uint32_t m_seq;
};
} // namespace ns3
diff --git a/apps/ccnx-producer.cc b/apps/ccnx-producer.cc
index d320a2d..1cec691 100644
--- a/apps/ccnx-producer.cc
+++ b/apps/ccnx-producer.cc
@@ -16,202 +16,67 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
+ * Alexander Afanasyev <alexander.afanasyev@ucla.edu>
*/
#include "ccnx-producer.h"
+#include "ns3/ccnx-interest-header.h"
+#include "ns3/string.h"
+#include "ns3/integer.h"
+#include "ns3/ccnx-local-face.h"
NS_LOG_COMPONENT_DEFINE ("CcnxProducer");
namespace ns3
{
-
+
NS_OBJECT_ENSURE_REGISTERED (CcnxProducer);
TypeId
CcnxProducer::GetTypeId (void)
{
- static TypeId tid = TypeId ("ns3::CcnxProducer")
- .SetParent<Application> ()
+ static TypeId tid = TypeId ("ns3::CcnxProducer")
+ .SetParent<CcnxApp> ()
.AddConstructor<CcnxProducer> ()
- /*.AddAttribute ("Capacity", "Capacity of the ContentStore",
- UintegerValue(100),
- MakeUintegerAccessor(&CcnxProducer::m_storeCapacity),
- MakeUintegerChecker<uint32_t>())*/
.AddAttribute ("Prefix","Prefix, for which producer has the data",
- CcnxNameComponentsValue (),
+ StringValue ("/"),
MakeCcnxNameComponentsAccessor (&CcnxProducer::m_prefix),
MakeCcnxNameComponentsChecker ())
.AddAttribute ("PayloadSize", "Virtual payload size for Content packets",
- UintegerValue(100),
+ UintegerValue (100),
MakeUintegerAccessor(&CcnxProducer::m_virtualPayloadSize),
MakeUintegerChecker<uint32_t>())
- .AddTraceSource ("InterestTrace", "Interests that were received",
- MakeTraceSourceAccessor (&CcnxProducer::m_interestsTrace))
- .AddTraceSource ("ContentObjectTrace", "ContentObjects that were sent",
- MakeTraceSourceAccessor (&CcnxProducer::m_contentObjectsTrace))
+ // .AddTraceSource ("InterestTrace", "Interests that were received",
+ // MakeTraceSourceAccessor (&CcnxProducer::m_interestsTrace))
+ // .AddTraceSource ("ContentObjectTrace", "ContentObjects that were sent",
+ // MakeTraceSourceAccessor (&CcnxProducer::m_contentObjectsTrace))
;
- return tid;
+ return tid;
}
CcnxProducer::CcnxProducer ()
{
- NS_LOG_FUNCTION_NOARGS ();
+ // NS_LOG_FUNCTION_NOARGS ();
}
-
-CcnxProducer::~CcnxProducer()
-{
- NS_LOG_FUNCTION_NOARGS ();
-}
-
+
void
-CcnxProducer::DoDispose (void)
+CcnxProducer::OnInterest (const Ptr<const CcnxInterestHeader> &interest)
{
- NS_LOG_FUNCTION_NOARGS ();
-
- Application::DoDispose ();
-}
-
- // Application Methods
-void
-CcnxProducer::StartApplication () // Called at time specified by Start
-{
- NS_LOG_FUNCTION_NOARGS ();
-
- NS_ASSERT_MSG (m_face == 0, "Face should not exist");
- m_face = Create<CcnxLocalFace> ();
-
- // step 1. Set up forwarding from face to application
- m_face->SetNode (GetNode ());
- m_face->SetInterestHandler (MakeCallback (&CcnxProducer::OnInterest, this));
-
- // step 2. Set up forwarding to and from ccnx
- NS_ASSERT_MSG (GetNode ()->GetObject<Ccnx> () !=0,
- "Ccnx stack should be installed on the node " << GetNode ());
- GetNode ()->GetObject<Ccnx> ()->AddFace (m_face);
- //Add (const CcnxNameComponents &prefix, Ptr<CcnxFace> face, int32_t metric);
- GetNode ()->GetObject<Ccnx> ()->GetObject<CcnxFib> ()->Add(m_prefix, m_face, 0);
- // step 3. Enable face
- m_face->SetUp ();
-}
-
-void
-CcnxProducer::StopApplication () // Called at time specified by Stop
-{
- NS_LOG_FUNCTION_NOARGS ();
-}
-
-void
-CcnxProducer::OnInterest(const Ptr<const CcnxInterestHeader> &interest)
-{
- NS_LOG_FUNCTION (this);
-
-
-
- //Ptr<Packet> data = Lookup (interest);
-
-
-
- Ptr<Packet> incomingPacket = Create<Packet>(m_virtualPayloadSize);
- incomingPacket->AddHeader (*interest);
- m_interestsTrace(m_face,incomingPacket);
-
-
+ NS_LOG_FUNCTION (this << interest);
- static CcnxContentObjectTail tail; ///< \internal for optimization purposes
- Ptr<Packet> outgoingPacket = Create<Packet> (m_virtualPayloadSize);
- Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader>();
- header->SetName(Create<CcnxNameComponents>(interest->GetName()));
- outgoingPacket->AddHeader(*header);
- outgoingPacket->AddTrailer (tail);
+ if (!m_active) return;
- m_contentObjectsTrace(m_face,outgoingPacket);
-
- m_face->ReceiveFromApplication(outgoingPacket);
-
-}
-
-void
-CcnxProducer::CancelEvents ()
-{
- NS_LOG_FUNCTION_NOARGS ();
-
- // Simulator::Cancel (m_sendEvent);
-}
+ static CcnxContentObjectTail tail;
+ Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
+ header->SetName (Create<CcnxNameComponents> (interest->GetName ()));
-CcnxNameComponents
-CcnxProducer::GetPrefix() const
-{
- return m_prefix;
+ Ptr<Packet> packet = Create<Packet> (m_virtualPayloadSize);
+ outgoingPacket->AddHeader (*header);
+ outgoingPacket->AddTrailer (tail);
+
+ m_protocolHandler (outgoingPacket);
}
-
-/*uint32_t
-CcnxProducer::GetStoreCapacity()
-{
- return m_storeCapacity;
-}
-
-void
-CcnxProducer::SetStoreCapacity(uint32_t capacity)
-{
- m_storeCapacity = capacity;
-}
- */
-/*void
-CcnxProducer::HandlePacket(const Ptr<CcnxFace> &face, const Ptr<const Packet> &packet)
-{
- uint8_t type[2];
- uint32_t read = packet->CopyData (type,2);
- if (read!=2)
- {
- NS_LOG_INFO ("Unknown CcnxPacket");
- return;
- }
-
- if (type[0] == INTEREST_BYTE0 && type[1] == INTEREST_BYTE1)
- {
- m_interestsTrace(face,packet);
- }
- else if (type[0] == CONTENT_OBJECT_BYTE0 && type[1] == CONTENT_OBJECT_BYTE1)
- {
- m_contentObjectsTrace(face,packet);
- }
-}*/
-
-/*Ptr<Packet>
-CcnxProducer::Lookup (Ptr<const CcnxInterestHeader> interest)
-{
- NS_LOG_FUNCTION_NOARGS ();
- DataStoreContainer::type::iterator it = m_availableData.get<i_prefix> ().find (interest->GetName ());
-
- if (it != m_availableData.end ())
- {
- // return fully formed CCNx packet
- return it->GetFullyFormedCcnxPacket ();
- }
-
- return 0;
-}
-
-void
-CcnxProducer::Add (Ptr<CcnxContentObjectHeader> header, Ptr<const Packet> packet)
-{
- NS_LOG_FUNCTION_NOARGS ();
- DataStoreContainer::type::iterator it = m_availableData.get<i_prefix> ().find (header->GetName ());
-
- if (it == m_availableData.end ())
- { // add entry to the top
- m_availableData.get<i_mru> ().push_front (DataStoreEntry (header, packet));
-
- if (m_availableData.size () > m_storeCapacity)
- m_availableData.get<i_mru> ().pop_back ();
- }
- else
- {
- // promote entry to the top
- //m_contentStore.get<i_mru> ().relocate (m_contentStore.get<i_mru> ().begin (),
- // m_contentStore.project<i_mru> (it));
- }
-}*/
-}
+
+} // namespace ns3
diff --git a/apps/ccnx-producer.h b/apps/ccnx-producer.h
index 840400b..289c22e 100644
--- a/apps/ccnx-producer.h
+++ b/apps/ccnx-producer.h
@@ -16,194 +16,36 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
+ * Alexander Afanasyev <alexander.afanasyev@ucla.edu>
*/
#ifndef CCNX_PRODUCER_H
#define CCNX_PRODUCER_H
-#include "ns3/application.h"
-#include "ns3/log.h"
-#include "ns3/random-variable.h"
-#include "ns3/nstime.h"
-#include "ns3/event-id.h"
+#include "ccnx-app.h"
+
#include "ns3/ptr.h"
-#include "ns3/simulator.h"
-#include "ns3/ccnx-interest-header.h"
-#include "ns3/ccnx-local-face.h"
#include "ns3/ccnx-name-components.h"
-#include "ns3/packet.h"
-#include "ns3/boolean.h"
-#include "ns3/integer.h"
-#include "ns3/uinteger.h"
-#include "ns3/random-variable.h"
-#include <limits>
-#include "ns3/pointer.h"
-#include "ns3/traced-callback.h"
-#include "ns3/ccnx-header-helper.h"
-
-#include "ns3/packet.h"
-#include "ns3/header.h"
-#include "ns3/ccnx.h"
-#include "ns3/ccnx-content-object-header.h"
-#include "ns3/ccnx-name-components.h"
-#include "ns3/ccnx-fib.h"
-
-#include <boost/multi_index_container.hpp>
-#include <boost/multi_index/tag.hpp>
-#include <boost/multi_index/ordered_index.hpp>
-#include <boost/multi_index/sequenced_index.hpp>
-#include <boost/multi_index/hashed_index.hpp>
-#include <boost/multi_index/mem_fun.hpp>
namespace ns3
{
-
- class DataStoreEntry
- {
- public:
- /**
- * \brief Construct data store entry
- *
- * \param header Parsed CcnxContentObject header
- * \param packet Original CCNx packet
- *
- * The constructor will make a copy of the supplied packet and calls
- * RemoveHeader and RemoveTail on the copy.
- */
- DataStoreEntry (Ptr<CcnxContentObjectHeader> header, Ptr<const Packet> packet);
-
- /**
- * \brief Get prefix of the stored entry
- * \returns prefix of the stored entry
- */
- inline const CcnxNameComponents&
- GetName () const;
-
- /**
- * \brief Get CcnxContentObjectHeader of the stored entry
- * \returns CcnxContentObjectHeader of the stored entry
- */
- inline Ptr<const CcnxContentObjectHeader>
- GetHeader () const;
-
- /**
- * \brief Get content of the stored entry
- * \returns content of the stored entry
- */
- inline Ptr<const Packet>
- GetPacket () const;
-
- /**
- * \brief Convenience method to create a fully formed CCNx packet from stored header and content
- * \returns A read-write copy of the packet with CcnxContentObjectHeader and CcxnContentObjectTail
- */
- Ptr<Packet>
- GetFullyFormedCcnxPacket () const;
-
- // Copy constructor is required by the container. Though, we're
- // storing only two pointers, so shouldn't be a problem
- // private:
- // CcnxContentStoreEntry (const CcnxContentStoreEntry &); ///< disabled copy constructor
- // CcnxContentStoreEntry& operator= (const CcnxContentStoreEntry&); ///< disabled copy operator
-
- private:
- //Ptr<CcnxContentObjectHeader> m_header; ///< \brief non-modifiable CcnxContentObjectHeader
- //Ptr<Packet> m_packet; ///< \brief non-modifiable content of the ContentObject packet
- };
-
-class CcnxProducer: public Application
+class CcnxProducer : public CcnxApp
{
public:
- static TypeId GetTypeId (void);
+ static TypeId
+ GetTypeId (void);
- CcnxProducer ();
-
- virtual ~CcnxProducer ();
-
- //void HandlePacket (const Ptr<CcnxFace> &face, const Ptr<const Packet> &packet);
- //uint32_t GetStoreCapacity();
- //void SetStoreCapacity(uint32_t capacity);
- //void AddContentStoreEntry (Ptr<CcnxContentObjectHeader> header, Ptr<const Packet> packet);
-
- void OnInterest(const Ptr<const CcnxInterestHeader> &interest);
-
- CcnxNameComponents GetPrefix() const;
- /**
- * \brief Add a new content to the data store.
- *
- * \param header Fully parsed CcnxContentObjectHeader
- * \param packet Fully formed CCNx packet to add to content store
- * (will be copied and stripped down of headers)
- *
- * If entry with the same prefix exists, the old entry will be
- * promoted to the top of the MRU hash
- */
- //void
- //Add (Ptr<CcnxContentObjectHeader> header, Ptr<const Packet> packet);
-
-protected:
- virtual void DoDispose (void);
+ CcnxProducer ();
+
+ // inherited from CcnxApp
+ void OnInterest (const Ptr<const CcnxInterestHeader> &interest);
+
private:
- // inherited from Application base class.
- virtual void StartApplication (void); // Called at time specified by Start
- virtual void StopApplication (void); // Called at time specified by Stop
-
- /**
- * \brief Find corresponding CS entry for the given interest
- *
- * \param interest Interest for which matching content store entry
- * will be searched
- *
- * If an entry is found, it is promoted to the top of most recent
- * used entries index, \see m_contentStore
- */
- //Ptr<Packet>
- //Lookup (Ptr<const CcnxInterestHeader> interest);
-
-
- Ptr<Ccnx> m_ccnx;
- Time m_offTime;
-
- //EventId m_sendEvent; // Eventid of pending "send packet" event
- TypeId m_tid;
- Ptr<CcnxLocalFace> m_face;
-
- /*struct DataStoreContainer
- {
- typedef
- boost::multi_index::multi_index_container<
- DataStoreEntry,
- boost::multi_index::indexed_by<
- boost::multi_index::hashed_unique<
- boost::multi_index::tag<__ccnx_private::i_prefix>,
- boost::multi_index::const_mem_fun<DataStoreEntry,
- const CcnxNameComponents&,
- &DataStoreEntry::GetName>,
- CcnxPrefixHash>,
- boost::multi_index::sequenced<boost::multi_index::tag<__ccnx_private::i_mru> >
-#ifdef _DEBUG
- ,
- boost::multi_index::ordered_unique<
- boost::multi_index::tag<__ccnx_private::i_ordered>,
- boost::multi_index::const_mem_fun<DataStoreEntry,
- const CcnxNameComponents&,
- &CcnxContentStoreEntry::GetName>
- >
-#endif
- >
- > type;
- };*/
-
- //helpers
- void CancelEvents ();
-
- //DataStoreContainer::type m_availableData;
- //uint32_t m_storeCapacity;
- uint32_t m_virtualPayloadSize;
- CcnxNameComponents m_prefix;
- TracedCallback<const Ptr<CcnxFace>&,const Ptr<const Packet>& > m_interestsTrace;
- TracedCallback<const Ptr<CcnxFace>&,const Ptr<const Packet>& > m_contentObjectsTrace;
+ CcnxNameComponents m_prefix;
+ uint32_t m_virtualPayloadSize;
};
+
}
-#endif
+
+#endif // CCNX_PRODUCER_H
diff --git a/model/ccnx-bestroute-strategy.cc b/model/ccnx-bestroute-strategy.cc
index 4e592c7..cad2d67 100644
--- a/model/ccnx-bestroute-strategy.cc
+++ b/model/ccnx-bestroute-strategy.cc
@@ -48,8 +48,7 @@
CcnxBestRouteStrategy::PropagateInterest (const CcnxPitEntry &pitEntry,
const Ptr<CcnxFace> &incomingFace,
Ptr<CcnxInterestHeader> &header,
- const Ptr<const Packet> &packet,
- SendCallback sendCallback)
+ const Ptr<const Packet> &packet)
{
NS_LOG_FUNCTION (this);
bool forwardedCount = 0;
@@ -66,11 +65,13 @@
if (pitEntry.m_outgoing.find (bestMetric.m_face) != pitEntry.m_outgoing.end ()) // already forwarded before
continue;
- bool faceAvailable = m_pit->TryAddOutgoing (pitEntry, bestMetric.m_face);
+ bool faceAvailable = bestMetric.m_face->SendWithLimit (packet->Copy ());
if (!faceAvailable) // huh...
continue;
- sendCallback (bestMetric.m_face, header, packet->Copy());
+ m_pit->modify (m_pit->iterator_to (pitEntry),
+ bind(&CcnxPitEntry::AddOutgoing, lambda::_1, bestMetric.m_face));
+
forwardedCount++;
break; // if we succeeded in sending one packet, stop
}
diff --git a/model/ccnx-bestroute-strategy.h b/model/ccnx-bestroute-strategy.h
index 4e5eb6c..f2d591b 100644
--- a/model/ccnx-bestroute-strategy.h
+++ b/model/ccnx-bestroute-strategy.h
@@ -51,8 +51,7 @@
PropagateInterest (const CcnxPitEntry &pitEntry,
const Ptr<CcnxFace> &incomingFace,
Ptr<CcnxInterestHeader> &header,
- const Ptr<const Packet> &packet,
- SendCallback sendCallback);
+ const Ptr<const Packet> &packet);
};
} //namespace ns3
diff --git a/model/ccnx-face.cc b/model/ccnx-face.cc
index 19eb21d..1bb55ab 100644
--- a/model/ccnx-face.cc
+++ b/model/ccnx-face.cc
@@ -34,9 +34,12 @@
* with no IP addresses. Before becoming useable, the user must
* invoke SetUp on them once an Ccnx address and mask have been set.
*/
-CcnxFace::CcnxFace ()
- // : m_metric (1)
- : m_node (0)
+CcnxFace::CcnxFace (Ptr<Node> node)
+ : m_node (Ptr<Node> node)
+ , m_bucket (0.0)
+ , m_bucketMax (-1.0)
+ , m_bucketLeak (0.0)
+ , m_protocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ())
, m_ifup (false)
, m_id ((uint32_t)-1)
{
@@ -57,10 +60,53 @@
return *this;
}
-void
-CcnxFace::SetNode (Ptr<Node> node)
+void
+CcnxFace::RegisterProtocolHandler (ProtocolHandler handler)
{
- m_node = node;
+ m_protocolHandler = handler;
+}
+
+bool
+CcnxFace::SendWithLimit (Ptr<Packet> packet)
+{
+ /// \todo Implement tracing, if requested
+
+ if (!IsUp ())
+ return false;
+
+ if (m_bucketMax > 0)
+ {
+ if (m_bucket+1.0 > m_bucketMax)
+ return false;
+
+ m_bucket += 1.0;
+ }
+
+ SendImpl (packet);
+ return true;
+}
+
+bool
+CcnxFace::SendWithoutLimits (Ptr<Packet> packet)
+{
+ /// \todo Implement tracing, if requested
+
+ if (!IsUp ())
+ return false;
+
+ SendImpl (packet);
+ return true;
+}
+
+bool
+CcnxFace::Receive (Ptr<const Packet> packet)
+{
+ /// \todo Implement tracing, if requested
+
+ if (!IsUp ())
+ return false;
+
+ m_protocolHandler (this, packet);
}
// void
@@ -89,25 +135,11 @@
return m_ifup;
}
-bool
-CcnxFace::IsDown (void) const
-{
- NS_LOG_FUNCTION_NOARGS ();
- return !m_ifup;
-}
-
void
-CcnxFace::SetUp (void)
+CcnxFace::SetUp (bool up/* = true*/)
{
NS_LOG_FUNCTION_NOARGS ();
- m_ifup = true;
-}
-
-void
-CcnxFace::SetDown (void)
-{
- NS_LOG_FUNCTION_NOARGS ();
- m_ifup = false;
+ m_ifup = up;
}
bool
diff --git a/model/ccnx-face.h b/model/ccnx-face.h
index 81700df..bc6769e 100644
--- a/model/ccnx-face.h
+++ b/model/ccnx-face.h
@@ -24,14 +24,12 @@
#include <ostream>
#include "ns3/ptr.h"
-#include "ns3/simple-ref-count.h"
-#include "ns3/callback.h"
+#include "ns3/ccnx.h"
namespace ns3 {
class Packet;
class Node;
-
/**
* \ingroup ccnx
@@ -54,14 +52,14 @@
* \brief Ccnx protocol hanler
*
* \param face Face from which packet has been received
- * \param packet Received packet
+ * \param packet Original packet
*/
typedef Callback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>& > ProtocolHandler;
/**
* \brief Default constructor
*/
- CcnxFace ();
+ CcnxFace (Ptr<Node> node);
virtual ~CcnxFace();
////////////////////////////////////////////////////////////////////
@@ -71,23 +69,43 @@
*
* This method should call protocol-dependent registration function
*/
- virtual void RegisterProtocolHandler (ProtocolHandler handler) = 0;
+ virtual void
+ RegisterProtocolHandler (ProtocolHandler handler);
/**
- * \brief Send packet on a face
+ * \brief Send packet on a face with regard Interest limits
+ *
+ * This method will be called by lower layers to send data to device or application
*
* \param p smart pointer to a packet to send
+ *
+ * @return false if either limit is reached or face is down
*/
- virtual void Send (Ptr<Packet> p) = 0;
-
- ////////////////////////////////////////////////////////////////////
+ bool
+ SendWithLimit (Ptr<Packet> p);
/**
- * \brief Associate Node object with face
+ * \brief Send content packet on a face without regard to limits
*
- * \param node smart pointer to a Node object
+ * This method will be called by lower layers to send data to device or application
+ *
+ * !!! The only difference between this call and SendInterest is that the former check Interest limit !!!
+ *
+ * \param p smart pointer to a packet to send
+ *
+ * @return false if face is down
+ */
+ bool
+ SendWithoutLimits (Ptr<Packet> p);
+
+ /**
+ * \brief Receive packet from application or another node and forward it to the CCNx stack
+ *
+ * \todo The only reason for this call is to handle tracing, if requested
*/
- virtual void SetNode (Ptr<Node> node);
+ void
+ Receive (Ptr<const Packet> p);
+ ////////////////////////////////////////////////////////////////////
// /**
// * \Brief Assign routing/forwarding metric with face
@@ -110,24 +128,16 @@
*/
/**
- * \brief Enable this face
+ * \brief Enable or disable this face
*/
- virtual void SetUp ();
-
- /**
- * \brief Disable this face
- */
- virtual void SetDown (void);
+ virtual void
+ SetUp (bool up = true);
/**
* \brief Returns true if this face is enabled, false otherwise.
*/
- virtual bool IsUp () const;
-
- /**
- * \brief Returns true if this face is disabled, false otherwise.
- */
- virtual bool IsDown () const;
+ virtual bool
+ IsUp () const;
virtual std::ostream&
Print (std::ostream &os) const;
@@ -153,6 +163,22 @@
GetId () const;
/**
+ * @brief Set maximum value for Interest allowance
+ *
+ * @param bucket maximum value for Interest allowance. If < 0, then limit will be disabled
+ */
+ inline void
+ SetBucketMax (double bucket);
+
+ /**
+ * @brief Leak the Interest allowance bucket by (1/interval) * m_bucketMax amount
+ *
+ * @param interval Time interval with which the bucket is leaked
+ */
+ inline void
+ LeakBucket (const Time &interval);
+
+ /**
* \brief Compare two faces. Only two faces on the same node could be compared.
*
* Internal index is used for comparison.
@@ -168,6 +194,15 @@
bool
operator< (const CcnxFace &face) const;
+protected:
+ /**
+ * \brief Send packet on a face (actual implementation)
+ *
+ * \param p smart pointer to a packet to send
+ */
+ virtual void
+ SendImpl (Ptr<Packet> p) = 0;
+
private:
CcnxFace (const CcnxFace &); ///< \brief Disabled copy constructor
CcnxFace& operator= (const CcnxFace &); ///< \brief Disabled copy operator
@@ -175,9 +210,13 @@
protected:
// uint16_t m_metric; ///< \brief Routing/forwarding metric
Ptr<Node> m_node; ///< \brief Smart pointer to Node
- ProtocolHandler m_protocolHandler; ///< Callback via which packets are getting send to CCNx stack
+ double m_bucket; ///< \brief Value representing current size of the Interest allowance for this face
+ double m_bucketMax; ///< \brief Maximum Interest allowance for this face
+ double m_bucketLeak; ///< \brief Normalized amount that should be leaked every second
+
private:
+ ProtocolHandler m_protocolHandler; ///< Callback via which packets are getting send to CCNx stack
bool m_ifup; ///< \brief flag indicating that the interface is UP
uint32_t m_id; ///< \brief id of the interface in CCNx stack (per-node uniqueness)
};
@@ -202,6 +241,20 @@
return m_id;
}
+void
+CcnxFace::SetBucketMax (double bucket)
+{
+ m_bucketMax = bucket;
+}
+
+void
+CcnxFace::LeakBucket (const Time &interval)
+{
+ const double leak = m_bucketLeak * 1.0 / interval.ToDouble (Time::S);
+ m_bucket -= std::max (0, m_bucket-leak);
+}
+
+
} // namespace ns3
#endif //CCNX_FACE_H
diff --git a/model/ccnx-fib.cc b/model/ccnx-fib.cc
index a2d8b4b..bd3cd67 100644
--- a/model/ccnx-fib.cc
+++ b/model/ccnx-fib.cc
@@ -216,6 +216,27 @@
return entry;
}
+void
+CcnxFib::Delete (const CcnxNameComponents &prefix, Ptr<CcnxFace> face)
+{
+ NS_LOG_FUNCTION (this << prefix << face);
+
+ CcnxFibEntryContainer::type::iterator entry = find (prefix);
+ if (entry == end ())
+ return;
+
+ modify (entry,
+ bind (&CcnxFibEntry::RemoveFace, _1, face));
+ if (entry->m_faces.size () == 0)
+ {
+ erase (entry);
+ }
+}
+
+void
+CcnxFib::DeleteFromAll (Ptr<CcnxFace> face)
+{
+}
std::ostream& operator<< (std::ostream& os, const CcnxFib &fib)
{
diff --git a/model/ccnx-fib.h b/model/ccnx-fib.h
index 2bd131c..84d618d 100644
--- a/model/ccnx-fib.h
+++ b/model/ccnx-fib.h
@@ -277,7 +277,19 @@
CcnxFibEntryContainer::type::iterator
Add (const CcnxNameComponents &prefix, Ptr<CcnxFace> face, int32_t metric);
- // void resetProbing(); //reset needsProbing field for every FibEntry
+ /**
+ * @brief Remove reference to a face from the entry for `prefix`. If entry had only this face, the whole
+ * entry will be removed
+ */
+ void
+ Delete (const CcnxNameComponents &prefix, Ptr<CcnxFace> face);
+
+ /**
+ * @brief Remove all references to a face from FIB. If for some enty that face was the only element,
+ * this FIB entry will be removed.
+ */
+ void
+ DeleteFromAll (Ptr<CcnxFace> face);
protected:
// inherited from Object class
diff --git a/model/ccnx-flooding-strategy.cc b/model/ccnx-flooding-strategy.cc
index d7f6827..1fa7a93 100644
--- a/model/ccnx-flooding-strategy.cc
+++ b/model/ccnx-flooding-strategy.cc
@@ -49,8 +49,7 @@
CcnxFloodingStrategy::PropagateInterest (const CcnxPitEntry &pitEntry,
const Ptr<CcnxFace> &incomingFace,
Ptr<CcnxInterestHeader> &header,
- const Ptr<const Packet> &packet,
- SendCallback sendCallback)
+ const Ptr<const Packet> &packet)
{
NS_LOG_FUNCTION (this);
@@ -66,11 +65,13 @@
if (pitEntry.m_outgoing.find (metricFace.m_face) != pitEntry.m_outgoing.end ()) // already forwarded before
continue;
- bool faceAvailable = m_pit->TryAddOutgoing (pitEntry, metricFace.m_face);
+ bool faceAvailable = metricFace.m_face->SendWithLimit (packet->Copy ());
if (!faceAvailable) // huh...
- continue;
+ continue;
+
+ m_pit->modify (m_pit->iterator_to (pitEntry),
+ bind(&CcnxPitEntry::AddOutgoing, lambda::_1, metricFace.m_face));
- sendCallback (metricFace.m_face, header, packet->Copy());
propagatedCount++;
}
diff --git a/model/ccnx-flooding-strategy.h b/model/ccnx-flooding-strategy.h
index 0d43b6a..8be12e9 100644
--- a/model/ccnx-flooding-strategy.h
+++ b/model/ccnx-flooding-strategy.h
@@ -50,8 +50,7 @@
PropagateInterest (const CcnxPitEntry &pitEntry,
const Ptr<CcnxFace> &incomingFace,
Ptr<CcnxInterestHeader> &header,
- const Ptr<const Packet> &packet,
- SendCallback sendCallback);
+ const Ptr<const Packet> &packet);
};
} //namespace ns3
diff --git a/model/ccnx-forwarding-strategy.h b/model/ccnx-forwarding-strategy.h
index b8bbc5b..d7a5ab5 100644
--- a/model/ccnx-forwarding-strategy.h
+++ b/model/ccnx-forwarding-strategy.h
@@ -42,10 +42,6 @@
class CcnxForwardingStrategy : public Object
{
public:
- typedef
- Callback<void, const Ptr<CcnxFace> &, const Ptr<const CcnxInterestHeader> &, const Ptr<Packet> &>
- SendCallback;
-
static TypeId GetTypeId (void);
/**
@@ -69,8 +65,7 @@
PropagateInterest (const CcnxPitEntry &pitEntry,
const Ptr<CcnxFace> &incomingFace,
Ptr<CcnxInterestHeader> &header,
- const Ptr<const Packet> &packet,
- SendCallback sendCallback) = 0;
+ const Ptr<const Packet> &packe) = 0;
/**
* @brief Set link to PIT for the forwarding strategy
diff --git a/model/ccnx-l3-protocol.cc b/model/ccnx-l3-protocol.cc
index b719e99..1d4c548 100644
--- a/model/ccnx-l3-protocol.cc
+++ b/model/ccnx-l3-protocol.cc
@@ -61,20 +61,11 @@
.SetParent<Ccnx> ()
.SetGroupName ("Ccnx")
.AddConstructor<CcnxL3Protocol> ()
- // .AddTraceSource ("Tx", "Send ccnx packet to outgoing interface.",
- // MakeTraceSourceAccessor (&CcnxL3Protocol::m_txTrace))
- // .AddTraceSource ("Rx", "Receive ccnx packet from incoming interface.",
- // MakeTraceSourceAccessor (&CcnxL3Protocol::m_rxTrace))
- // .AddTraceSource ("Drop", "Drop ccnx packet",
- // MakeTraceSourceAccessor (&CcnxL3Protocol::m_dropTrace))
- // .AddAttribute ("InterfaceList", "The set of Ccnx interfaces associated to this Ccnx stack.",
- // ObjectVectorValue (),
- // MakeObjectVectorAccessor (&CcnxL3Protocol::m_faces),
- // MakeObjectVectorChecker<CcnxFace> ())
-
- // .AddTraceSource ("SendOutgoing", "A newly-generated packet by this node is about to be queued for transmission",
- // MakeTraceSourceAccessor (&CcnxL3Protocol::m_sendOutgoingTrace))
-
+ .AddAttribute ("BucketLeakInterval",
+ "Interval to leak buckets",
+ StringValue ("10ms"),
+ MakeTimeAccessor (&CcnxPit::GetBucketLeakInterval, &CcnxPit::SetBucketLeakInterval),
+ MakeTimeChecker ())
;
return tid;
}
@@ -128,6 +119,9 @@
{
NS_LOG_FUNCTION (this);
+ if (m_bucketLeakEvent.IsRunning ())
+ m_bucketLeakEvent.Cancel ();
+
for (CcnxFaceList::iterator i = m_faces.begin (); i != m_faces.end (); ++i)
{
*i = 0;
@@ -171,7 +165,7 @@
face->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this));
m_faces.push_back (face);
- m_faceCounter ++;
+ m_faceCounter++;
return face->GetId ();
}
@@ -180,6 +174,27 @@
{
// ask face to register in lower-layer stack
face->RegisterProtocolHandler (MakeNullCallback<void,const Ptr<CcnxFace>&,const Ptr<const Packet>&> ());
+
+ // just to be on a safe side. Do the process in two steps
+ list<CcnxPitEntryContainer::type::iterator> entriesToRemoves;
+ BOOST_FOREACH (const CcnxPitEntry &pitEntry, *m_pit)
+ {
+ m_pit->modify (m_pit->iterator_to (pitEntry),
+ ll::bind (CcnxPitEntry::RemoveAllReferencesToFace, ll::_1, face));
+
+ // If this face is the only for the associated FIB entry, then FIB entry will be removed soon.
+ // Thus, we have to remove the whole PIT entry
+ if (m_pit->m_fibEntry.size () == 1 &&
+ m_pit->m_fibEntry.m_faces.begin ()->m_face == face)
+ {
+ entriesToRemoves.push_back (m_pit->iterator_to (pitEntry));
+ }
+ }
+ BOOST_FOREACH (CcnxPitEntryContainer::type::iterator entry, entriesToRemoves)
+ {
+ m_pit->erase (entry);
+ }
+
CcnxFaceList::iterator face_it = find (m_faces.begin(), m_faces.end(), face);
NS_ASSERT_MSG (face_it != m_faces.end (), "Attempt to remove face that doesn't exist");
m_faces.erase (face_it);
@@ -216,24 +231,6 @@
return m_faces.size ();
}
-void
-CcnxL3Protocol::TransmittedDataTrace (Ptr<Packet> packet,
- ContentObjectSource type,
- Ptr<Ccnx> ccnx, Ptr<const CcnxFace> face)
-{
- // a "small" inefficiency for logging purposes
- Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
- static CcnxContentObjectTail tail;
- packet->RemoveHeader (*header);
- packet->RemoveTrailer (tail);
-
- m_transmittedDataTrace (header, packet/*payload*/, type, ccnx, face);
-
- packet->AddHeader (*header);
- packet->AddTrailer (tail);
-}
-
-
// Callback from lower layer
void
CcnxL3Protocol::Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p)
@@ -333,7 +330,7 @@
// {
// header->SetNonce(it->m_nonce);
// header->SetNack(true);
- // SendInterest(face.m_face, header, packet->Copy());
+ // face.m_face->SendWithoutLimit (packet->Copy());
// }
// }
// }
@@ -376,7 +373,7 @@
Ptr<Packet> packet = Create<Packet> ();
packet->AddHeader (*header);
- SendInterest (incomingFace, header, packet);
+ incomingFace->SendWithoutLimit (packet);
// //Trace duplicate interest
// m_droppedInterestsTrace (header, NDN_DUPLICATE_INTEREST, m_node->GetObject<Ccnx> (), incomingFace);
@@ -384,19 +381,17 @@
}
Ptr<Packet> contentObject;
- Ptr<const CcnxContentObjectHeader> contentObjectHeader;
+ Ptr<const CcnxContentObjectHeader> contentObjectHeader; // unused for now
tie (contentObject, contentObjectHeader) = m_contentStore->Lookup (header);
if (contentObject != 0)
{
- // NS_ASSERT_MSG (pitEntry.m_incoming.size () == 0,
- // "Something strange. Data is cached, but size of incoming interests is not zero...");
NS_ASSERT (contentObjectHeader != 0);
NS_LOG_LOGIC("Found in cache");
// TransmittedDataTrace (contentObject, CACHED,
// m_node->GetObject<Ccnx> (), incomingFace);
- SendContentObject (incomingFace, contentObjectHeader, contentObject);
+ incomingFace->SendWithoutLimit (contentObject);
// Set pruning timout on PIT entry (instead of deleting the record)
m_pit->modify (m_pit->iterator_to (pitEntry),
@@ -454,9 +449,7 @@
NS_ASSERT_MSG (m_forwardingStrategy != 0, "Need a forwarding protocol object to process packets");
bool propagated = m_forwardingStrategy->
- PropagateInterest (pitEntry, incomingFace, header, packet,
- MakeCallback (&CcnxL3Protocol::SendInterest, this)
- );
+ PropagateInterest (pitEntry, incomingFace, header, packet);
// ForwardingStrategy will try its best to forward packet to at least one interface.
// If no interests was propagated, then there is not other option for forwarding or
@@ -469,7 +462,7 @@
BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry.m_incoming)
{
- SendInterest (incoming.m_face, header, packet->Copy ());
+ incoming.m_face->SendWithoutLimit (packet->Copy ());
// m_droppedInterestsTrace (header, DROP_CONGESTION,
// m_node->GetObject<Ccnx> (), incomingFace);
@@ -537,7 +530,7 @@
BOOST_FOREACH (const CcnxPitEntryIncomingFace &incoming, pitEntry.m_incoming)
{
if (incoming.m_face != incomingFace)
- SendContentObject (incoming.m_face, header, packet->Copy ());
+ incoming.m_face->SendWithoutLimit (packet->Copy ());
// successfull forwarded data trace
}
@@ -562,59 +555,33 @@
}
void
-CcnxL3Protocol::SendInterest (const Ptr<CcnxFace> &face,
- const Ptr<const CcnxInterestHeader> &header,
- const Ptr<Packet> &packet)
+CcnxL3Protocol::SetBucketLeakInterval (Time interval)
{
- NS_LOG_FUNCTION (this << "packet: " << &packet << ", face: "<< &face);
- NS_ASSERT_MSG (face != 0, "Face should never be NULL");
+ m_bucketLeakInterval = interval;
+
+ if (m_bucketLeakEvent.IsRunning ())
+ m_bucketLeakEvent.Cancel ();
- if (face->IsUp ())
- {
- NS_LOG_LOGIC ("Sending via face " << &face); //
- // m_transmittedInterestsTrace (header, m_node->GetObject<Ccnx> (), face);
- face->Send (packet);
- }
- else
- {
- NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << &face);
- // m_droppedInterestsTrace (header, INTERFACE_DOWN, m_node->GetObject<Ccnx> (), face);
- }
+ m_bucketLeakEvent = Simulator::Schedule (m_bucketLeakInterval,
+ &CcnxL3Protocol::LeakBuckets, this);
}
-void
-CcnxL3Protocol::SendContentObject (const Ptr<CcnxFace> &face,
- const Ptr<const CcnxContentObjectHeader> &header,
- const Ptr<Packet> &packet)
+Time
+CcnxL3Protocol::GetBucketLeakInterval () const
{
- NS_LOG_FUNCTION (this << "packet: " << &packet << ", face: "<< &face);
- NS_ASSERT_MSG (face != 0, "Face should never be NULL");
-
- if (face->IsUp ())
- {
- NS_LOG_LOGIC ("Sending via face " << &face); //
- // m_txTrace (packet, m_node->GetObject<Ccnx> (), face);
- face->Send (packet);
- }
- else
- {
- NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << &face);
- // m_dropTrace (packet, INTERFACE_DOWN, m_node->GetObject<Ccnx> (), face);
- }
+ return m_bucketLeakInterval;
}
-Ptr<CcnxPit>
-CcnxL3Protocol::GetPit()
+void
+CcnxPit::LeakBuckets ()
{
- return m_pit;
+ BOOST_FOREACH (const Ptr<CcnxFace> &face, m_faces)
+ {
+ face->LeakBucket (m_bucketLeakInterval);
+ }
+
+ m_bucketLeakEvent = Simulator::Schedule (m_bucketLeakInterval,
+ &CcnxL3Protocol::LeakBuckets, this);
}
-// void
-// CcnxL3Protocol::ScheduleLeakage()
-// {
-// m_pit->LeakBuckets();
-// Time interval = MilliSeconds (NDN_INTEREST_RESET_PERIOD);
-
-// Simulator::Schedule (interval, &CcnxL3Protocol::ScheduleLeakage, this);
-// }
} //namespace ns3
diff --git a/model/ccnx-l3-protocol.h b/model/ccnx-l3-protocol.h
index c470959..272a0be 100644
--- a/model/ccnx-l3-protocol.h
+++ b/model/ccnx-l3-protocol.h
@@ -127,13 +127,12 @@
void SetForwardingStrategy (Ptr<CcnxForwardingStrategy> forwardingStrategy);
Ptr<CcnxForwardingStrategy> GetForwardingStrategy () const;
- virtual void SendInterest (const Ptr<CcnxFace> &face,
- const Ptr<const CcnxInterestHeader> &header,
- const Ptr<Packet> &packet);
- virtual void SendContentObject (const Ptr<CcnxFace> &face,
- const Ptr<const CcnxContentObjectHeader> &header,
- const Ptr<Packet> &packet);
- virtual void Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p);
+ // virtual void SendInterest (const Ptr<CcnxFace> &face,
+ // const Ptr<const CcnxInterestHeader> &header,
+ // const Ptr<Packet> &packet);
+ // virtual void SendContentObject (const Ptr<CcnxFace> &face,
+ // const Ptr<const CcnxContentObjectHeader> &header,
+ // const Ptr<Packet> &packet);
virtual uint32_t
AddFace (const Ptr<CcnxFace> &face);
@@ -153,7 +152,10 @@
Ptr<CcnxPit> GetPit();
// void ScheduleLeakage();
-protected:
+private:
+ void
+ Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p);
+
/**
* \brief Actual processing of incoming CCNx interests. Note, interests do not have payload
*
@@ -162,7 +164,7 @@
* @param header deserialized Interest header
* @param packet original packet
*/
- virtual void
+ void
OnInterest (const Ptr<CcnxFace> &face,
Ptr<CcnxInterestHeader> &header,
const Ptr<const Packet> &p);
@@ -175,7 +177,7 @@
* @param header deserialized Interest header
* @param packet original packet
*/
- virtual void
+ void
OnNack (const Ptr<CcnxFace> &face,
Ptr<CcnxInterestHeader> &header,
const Ptr<const Packet> &p);
@@ -189,7 +191,7 @@
* @param payload data packet payload
* @param packet original packet
*/
- virtual void
+ void
OnData (const Ptr<CcnxFace> &face,
Ptr<CcnxContentObjectHeader> &header,
Ptr<Packet> &payload,
@@ -208,14 +210,17 @@
CcnxL3Protocol(const CcnxL3Protocol &); ///< copy constructor is disabled
CcnxL3Protocol &operator = (const CcnxL3Protocol &); ///< copy operator is disabled
- /**
- * \brief A helper function
- */
- void TransmittedDataTrace (Ptr<Packet>,
- ContentObjectSource,
- Ptr<Ccnx>, Ptr<const CcnxFace>);
+ /// \brief Set buckets leak interval
+ void
+ SetBucketLeakInterval (Time interval);
+
+ /// \brief Get buckets leak interval
+ Time
+ GetBucketLeakInterval () const;
-
+ /// \brief Periodically generate pre-calculated number of tokens (leak buckets)
+ void LeakBuckets( );
+
private:
uint32_t m_faceCounter; ///< \brief counter of faces. Increased every time a new face is added to the stack
typedef std::vector<Ptr<CcnxFace> > CcnxFaceList;
@@ -228,32 +233,29 @@
Ptr<CcnxPit> m_pit; ///< \brief PIT (pending interest table)
Ptr<CcnxFib> m_fib; ///< \brief FIB
Ptr<CcnxContentStore> m_contentStore; ///< \brief Content store (for caching purposes only)
-
- TracedCallback<Ptr<const CcnxInterestHeader>,
- Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedInterestsTrace;
- TracedCallback<Ptr<const CcnxInterestHeader>,
- Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedInterestsTrace;
- TracedCallback<Ptr<const CcnxInterestHeader>,
- DropReason,
- Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedInterestsTrace;
- TracedCallback<Ptr<const CcnxContentObjectHeader>,
- Ptr<const Packet>,/*payload*/
- Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedDataTrace;
- TracedCallback<Ptr<const CcnxContentObjectHeader>,
- Ptr<const Packet>,/*payload*/
- ContentObjectSource,
- Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedDataTrace;
- TracedCallback<Ptr<const CcnxContentObjectHeader>,
- Ptr<const Packet>,/*payload*/
- DropReason,
- Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedDataTrace;
+ Time m_bucketLeakInterval;
+ EventId m_bucketLeakEvent;
- /**
- * \brief Trace of dropped packets, including reason and all headers
- * \internal
- */
- // TracedCallback<Ptr<const Packet>, DropReason, Ptr<const Ccnx>, Ptr<const CcnxFace> > m_dropTrace;
+ // TracedCallback<Ptr<const CcnxInterestHeader>,
+ // Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedInterestsTrace;
+ // TracedCallback<Ptr<const CcnxInterestHeader>,
+ // Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedInterestsTrace;
+ // TracedCallback<Ptr<const CcnxInterestHeader>,
+ // DropReason,
+ // Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedInterestsTrace;
+
+ // TracedCallback<Ptr<const CcnxContentObjectHeader>,
+ // Ptr<const Packet>,/*payload*/
+ // Ptr<Ccnx>, Ptr<const CcnxFace> > m_receivedDataTrace;
+ // TracedCallback<Ptr<const CcnxContentObjectHeader>,
+ // Ptr<const Packet>,/*payload*/
+ // ContentObjectSource,
+ // Ptr<Ccnx>, Ptr<const CcnxFace> > m_transmittedDataTrace;
+ // TracedCallback<Ptr<const CcnxContentObjectHeader>,
+ // Ptr<const Packet>,/*payload*/
+ // DropReason,
+ // Ptr<Ccnx>, Ptr<const CcnxFace> > m_droppedDataTrace;
};
} // Namespace ns3
diff --git a/model/ccnx-local-face.cc b/model/ccnx-local-face.cc
index fc4dd11..4a7c777 100644
--- a/model/ccnx-local-face.cc
+++ b/model/ccnx-local-face.cc
@@ -25,7 +25,6 @@
#include "ns3/log.h"
#include "ns3/packet.h"
#include "ns3/node.h"
-#include "ns3/pointer.h"
#include "ns3/assert.h"
#include "ns3/ccnx-header-helper.h"
@@ -37,23 +36,13 @@
namespace ns3
{
-// NS_OBJECT_ENSURE_REGISTERED (CcnxLocalFace);
-
-// TypeId
-// CcnxLocalFace::GetTypeId (void)
-// {
-// static TypeId tid = TypeId ("ns3::CcnxLocalFace")
-// .SetGroupName ("Ccnx")
-// .SetParent<CcnxFace> ()
-// ;
-// return tid;
-// }
-
-CcnxLocalFace::CcnxLocalFace ()
- : m_onInterest (0)
- , m_onContentObject (0)
+CcnxLocalFace::CcnxLocalFace (Ptr<CcnxApp> app)
+ : CcnxFace (app->GetObject<Node> ())
+ , m_app (app)
{
- NS_LOG_FUNCTION (this);
+ NS_LOG_FUNCTION (this << app);
+
+ NS_ASSERT (app != 0);
}
CcnxLocalFace::~CcnxLocalFace ()
@@ -64,30 +53,17 @@
void
CcnxLocalFace::RegisterProtocolHandler (ProtocolHandler handler)
{
- m_protocolHandler = handler;
-}
+ NS_LOG_FUNCTION (this << handler);
-void
-CcnxLocalFace::SetInterestHandler (InterestHandler onInterest)
-{
- m_onInterest = onInterest;
-}
+ CcnxFace::RegisterProtocolHandler (handler);
-void
-CcnxLocalFace::SetContentObjectHandler (ContentObjectHandler onContentObject)
-{
- m_onContentObject = onContentObject;
+ app->RegisterProtocolHandler (MakeCallback (&CcnxFace::Receive, this));
}
void
-CcnxLocalFace::Send (Ptr<Packet> p)
+CcnxLocalFace::SendImpl (Ptr<Packet> p)
{
- NS_LOG_FUNCTION("Local face send");
- NS_LOG_FUNCTION (*p);
- if (!IsUp ())
- {
- return;
- }
+ NS_LOG_FUNCTION (this << p);
try
{
@@ -99,7 +75,7 @@
{
Ptr<CcnxInterestHeader> header = Create<CcnxInterestHeader> ();
p->RemoveHeader (*header);
- m_onInterest (header);
+ app->OnInterest (header);
}
break;
case CcnxHeaderHelper::CONTENT_OBJECT:
@@ -109,7 +85,7 @@
Ptr<CcnxContentObjectHeader> header = Create<CcnxContentObjectHeader> ();
p->RemoveHeader (*header);
p->RemoveTrailer (tail);
- m_onContentObject (header, p/*payload*/);
+ app->OnContentObject (header, p/*payload*/);
}
break;
}
@@ -120,13 +96,6 @@
}
}
-// propagate interest down to ccnx stack
-void
-CcnxLocalFace::ReceiveFromApplication (Ptr<Packet> p)
-{
- m_protocolHandler (Ptr<CcnxFace>(this), p);
-}
-
std::ostream& CcnxLocalFace::Print (std::ostream& os) const
{
os << "dev=local(" << GetId() << ")";
diff --git a/model/ccnx-local-face.h b/model/ccnx-local-face.h
index 664130c..a7705ed 100644
--- a/model/ccnx-local-face.h
+++ b/model/ccnx-local-face.h
@@ -44,61 +44,32 @@
class CcnxLocalFace : public CcnxFace
{
public:
- typedef Callback<void,const Ptr<const CcnxInterestHeader> &> InterestHandler;
- typedef Callback<void,const Ptr<const CcnxContentObjectHeader> &,
- const Ptr<const Packet> &> ContentObjectHandler;
-
/**
* \brief Default constructor
*/
- CcnxLocalFace ();
+ CcnxLocalFace (Ptr<CcnxApp> app);
virtual ~CcnxLocalFace();
////////////////////////////////////////////////////////////////////
// methods overloaded from CcnxFace
-
- /**
- * \brief This method should be called to establish link with lower layers
- */
virtual void
RegisterProtocolHandler (ProtocolHandler handler);
- /**
- * \brief This method will be called by lower layers to send data to *application*
- */
+protected:
virtual void
- Send (Ptr<Packet> p);
-
+ SendImpl (Ptr<Packet> p);
+
+public:
virtual std::ostream&
Print (std::ostream &os) const;
////////////////////////////////////////////////////////////////////
-
- /**
- * \brief This method will be called by higher layers to send data to *ccnx stack*
- */
- void ReceiveFromApplication (Ptr<Packet> p);
-
- /**
- * \brief Set callback to application
- *
- * \param onInterest InterestHandler to be called when interest arrives on the face. Will be disabled if 0
- */
- void SetInterestHandler (InterestHandler onInterest);
-
- /**
- * \brief Set callback to application
- *
- * \param onContentObject ContentObjectHandler to be called when data arrives. Will be disabled if 0
- */
- void SetContentObjectHandler (ContentObjectHandler onContentObject);
private:
CcnxLocalFace (const CcnxLocalFace &); ///< \brief Disabled copy constructor
CcnxLocalFace& operator= (const CcnxLocalFace &); ///< \brief Disabled copy operator
private:
- InterestHandler m_onInterest;
- ContentObjectHandler m_onContentObject;
+ Ptr<CcnxApp> m_application;
};
std::ostream& operator<< (std::ostream& os, const CcnxLocalFace &localFace);
diff --git a/model/ccnx-name-components.cc b/model/ccnx-name-components.cc
index 438e179..b551733 100644
--- a/model/ccnx-name-components.cc
+++ b/model/ccnx-name-components.cc
@@ -69,25 +69,6 @@
return subComponents;
}
-
-// const ccn_charbuf*
-// Components::GetName () const
-// {
-// return m_value;
-// }
-
-CcnxNameComponents&
-CcnxNameComponents::operator () (const string &s)
-{
- // ccn_name_append_str (m_value,s.c_str());
- m_prefix.push_back (s);
- return *this;
-}
-
-// Components::operator const unsigned char* ()
-// {
-// return m_value->buf;
-// }
void
CcnxNameComponents::Print (std::ostream &os) const
diff --git a/model/ccnx-name-components.h b/model/ccnx-name-components.h
index ea64635..5dafcfc 100644
--- a/model/ccnx-name-components.h
+++ b/model/ccnx-name-components.h
@@ -43,12 +43,14 @@
CcnxNameComponents ();
// CcnxNameComponents (const std::string &s);
CcnxNameComponents (const std::list<boost::reference_wrapper<const std::string> > &components);
-
+
+ template<class T>
inline void
- Add (const std::string &s);
-
- CcnxNameComponents&
- operator () (const std::string &s);
+ Add (const T &value);
+
+ template<class T>
+ inline CcnxNameComponents&
+ operator () (const T &value);
const std::list<std::string> &
GetComponents () const;
@@ -108,11 +110,29 @@
{
return m_prefix.size ();
}
-
-void
-CcnxNameComponents::Add (const std::string &s)
+
+template<class T>
+CcnxNameComponents&
+CcnxNameComponents::operator () (const T &value)
{
- (*this) (s);
+ Add (value);
+ return *this;
+}
+
+template<class T>
+void
+CcnxNameComponents::Add (const T &value)
+{
+ std::ostringstream os;
+ os << value;
+ m_prefix.push_back (os.str ());
+}
+
+template<class T=std::string>
+void
+CcnxNameComponents::Add (const T &string)
+{
+ m_prefix.push_back (string);
}
bool
diff --git a/model/ccnx-net-device-face.cc b/model/ccnx-net-device-face.cc
index 12cb272..72aa14a 100644
--- a/model/ccnx-net-device-face.cc
+++ b/model/ccnx-net-device-face.cc
@@ -36,11 +36,13 @@
* By default, Ccnx face are created in the "down" state. Before
* becoming useable, the user must invoke SetUp on the face
*/
-CcnxNetDeviceFace::CcnxNetDeviceFace (const Ptr<NetDevice> &netDevice)
+CcnxNetDeviceFace::CcnxNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice)
+ : CcnxFace (node)
+ , m_netDevice (netDevice)
{
- NS_LOG_FUNCTION (this);
+ NS_LOG_FUNCTION (this << netDevice);
- m_netDevice = netDevice;
+ NS_ASSERT_MSG (m_netDevice != 0, "CcnxNetDeviceFace needs to be assigned a valid NetDevice");
}
CcnxNetDeviceFace::~CcnxNetDeviceFace ()
@@ -66,11 +68,10 @@
void
CcnxNetDeviceFace::RegisterProtocolHandler (ProtocolHandler handler)
{
- NS_LOG_FUNCTION(this);
- NS_ASSERT_MSG (m_netDevice != 0, "CcnxNetDeviceFace needs to be assigned NetDevice first");
-
- m_protocolHandler = handler;
+ NS_LOG_FUNCTION (this << handler);
+ CcnxFace::RegisterProtocolHandler (handler);
+
m_node->RegisterProtocolHandler (MakeCallback (&CcnxNetDeviceFace::ReceiveFromNetDevice, this),
CcnxL3Protocol::ETHERNET_FRAME_TYPE, m_netDevice, true/*promiscuous mode*/);
}
@@ -78,17 +79,13 @@
void
CcnxNetDeviceFace::Send (Ptr<Packet> packet)
{
+ NS_LOG_FUNCTION (this << packet);
+
NS_ASSERT_MSG (packet->GetSize () <= m_netDevice->GetMtu (),
"Packet size " << packet->GetSize () << " exceeds device MTU "
<< m_netDevice->GetMtu ()
<< " for Ccnx; fragmentation not supported");
- NS_LOG_FUNCTION (*packet);
- if (!IsUp ())
- {
- return;
- }
-
m_netDevice->Send (packet, m_netDevice->GetBroadcast (),
CcnxL3Protocol::ETHERNET_FRAME_TYPE);
}
@@ -102,7 +99,7 @@
const Address &to,
NetDevice::PacketType packetType)
{
- m_protocolHandler (Ptr<CcnxFace>(this), p);
+ Receive (p);
}
diff --git a/model/ccnx-net-device-face.h b/model/ccnx-net-device-face.h
index e6fbc12..482d5d3 100644
--- a/model/ccnx-net-device-face.h
+++ b/model/ccnx-net-device-face.h
@@ -45,31 +45,26 @@
class CcnxNetDeviceFace : public CcnxFace
{
public:
- // /**
- // * \brief Interface ID
- // *
- // * \return interface ID
- // */
- // static TypeId GetTypeId (void);
-
/**
* \brief Constructor
*
* \param netDevice a smart pointer to NetDevice object to which
* this face will be associate
*/
- CcnxNetDeviceFace (const Ptr<NetDevice> &netDevice);
+ CcnxNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice);
virtual ~CcnxNetDeviceFace();
////////////////////////////////////////////////////////////////////
// methods overloaded from CcnxFace
-
virtual void
RegisterProtocolHandler (ProtocolHandler handler);
+protected:
+ // also from CcnxFace
virtual void
- Send (Ptr<Packet> p);
-
+ SendImpl (Ptr<Packet> p);
+
+public:
virtual std::ostream&
Print (std::ostream &os) const;
////////////////////////////////////////////////////////////////////
diff --git a/model/ccnx-pit-entry.cc b/model/ccnx-pit-entry.cc
index 7b8f489..cd6d854 100644
--- a/model/ccnx-pit-entry.cc
+++ b/model/ccnx-pit-entry.cc
@@ -66,27 +66,20 @@
return ret.first;
}
+void
+CcnxPitEntry::RemoveAllReferencesToFace (Ptr<CcnxFace> face)
+{
+ CcnxPitEntryIncomingFaceContainer::type::iterator incoming =
+ m_incoming.find (face);
-// void
-// CcnxPitEntry::UpdateFibStatus::operator() (CcnxPitEntry &entry)
-// {
-// NS_ASSERT_MSG (false, "Broken");
-// m_fib->modify (m_fib->iterator_to (entry.m_fibEntry),
-// CcnxFibEntry::UpdateStatus (m_face, m_status));
-// }
+ if (incoming != m_incoming.end ())
+ m_incoming.erase (incoming);
-// void
-// CcnxPitEntry::EstimateRttAndRemoveFace::operator() (CcnxPitEntry &entry)
-// {
-// // similar to Karn's Algorithm, we don't use RTT measurements for retx packets
-// if (m_outFace->m_retxNum>0)
-// return;
+ CcnxPitEntryOutgoingFaceContainer::type::iterator outgoing =
+ m_outgoing.find (face);
-// m_fib->modify (m_fib->iterator_to (entry.m_fibEntry),
-// CcnxFibEntry::UpdateFaceRtt (m_outFace->m_face,
-// Simulator::Now() - m_outFace->m_sendTime));
-
-// entry.m_outgoing.erase (m_outFace);
-// }
+ if (outgoing != m_outgoing.end ())
+ m_outgoing.erase (outgoing);
+}
}
diff --git a/model/ccnx-pit-entry.h b/model/ccnx-pit-entry.h
index ac1b277..52e7921 100644
--- a/model/ccnx-pit-entry.h
+++ b/model/ccnx-pit-entry.h
@@ -108,36 +108,84 @@
// // Get number of outgoing interests that we're expecting data from
// inline size_t numberOfPromisingInterests( ) const;
- const CcnxNameComponents &
- GetPrefix () const;
+ // const CcnxNameComponents &
+ // GetPrefix () const;
+ /**
+ * @brief Get current expiration time of the record
+ *
+ * @returns current expiration time of the record
+ */
const Time &
GetExpireTime () const
{ return m_expireTime; }
+ /**
+ * @brief Set expiration time on record as `expireTime` (absolute time)
+ *
+ * @param expireTime absolute simulation time of when the record should expire
+ */
void
SetExpireTime (const Time &expireTime)
{
m_expireTime = expireTime;
}
+ /**
+ * @brief Check if nonce `nonce` for the same prefix has already been seen
+ *
+ * @param nonce Nonce to check
+ */
bool
IsNonceSeen (uint32_t nonce) const
{ return m_seenNonces.find (nonce) != m_seenNonces.end (); }
+ /**
+ * @brief Add `nonce` to the list of seen nonces
+ *
+ * @param nonce nonce to add to the list of seen nonces
+ *
+ * All nonces are stored for the lifetime of the PIT entry
+ */
void
AddSeenNonce (uint32_t nonce)
{ m_seenNonces.insert (nonce); }
+ /**
+ * @brief Add `face` to the list of incoming faces
+ *
+ * @param face Face to add to the list of incoming faces
+ * @returns iterator to the added entry
+ */
CcnxPitEntryIncomingFaceContainer::type::iterator
AddIncoming (Ptr<CcnxFace> face);
+ /**
+ * @brief Clear all incoming faces either after all of them were satisfied or NACKed
+ */
void
ClearIncoming ()
{ m_incoming.clear (); }
+ /**
+ * @brief Add `face` to the list of outgoing faces
+ *
+ * @param face Face to add to the list of outgoing faces
+ * @returns iterator to the added entry
+ */
CcnxPitEntryOutgoingFaceContainer::type::iterator
AddOutgoing (Ptr<CcnxFace> face);
+
+ /**
+ * @brief Remove all references to face.
+ *
+ * This method should be called before face is completely removed from the stack.
+ * Face is removed from the lists of incoming and outgoing faces
+ */
+ void
+ RemoveAllReferencesToFace (Ptr<CcnxFace> face);
+
+protected:
private:
friend std::ostream& operator<< (std::ostream& os, const CcnxPitEntry &entry);
diff --git a/model/ccnx-pit.cc b/model/ccnx-pit.cc
index 85b4ecb..63e1db8 100644
--- a/model/ccnx-pit.cc
+++ b/model/ccnx-pit.cc
@@ -48,7 +48,7 @@
.AddConstructor<CcnxPit> ()
.AddAttribute ("CleanupTimeout",
"Timeout defining how frequent RIT should be cleaned up",
- TimeValue (Seconds (1)),
+ StringValue ("1s"),
MakeTimeAccessor (&CcnxPit::GetCleanupTimeout, &CcnxPit::SetCleanupTimeout),
MakeTimeChecker ())
.AddAttribute ("PitEntryPruningTimout",
@@ -72,10 +72,7 @@
CcnxPit::~CcnxPit ()
{
- if (m_cleanupEvent.IsRunning ())
- m_cleanupEvent.Cancel (); // cancel any scheduled cleanup events
-
- clear ();
+ DoDispose ();
}
void
@@ -87,7 +84,10 @@
CcnxPit::DoDispose ()
{
if (m_cleanupEvent.IsRunning ())
- m_cleanupEvent.Cancel (); // cancel any scheduled cleanup events
+ m_cleanupEvent.Cancel ();
+
+ if (m_PitBucketLeakEvent.IsRunning ())
+ m_PitBucketLeakEvent.Cancel ();
clear ();
}
@@ -116,11 +116,11 @@
Time now = Simulator::Now ();
uint32_t count = 0;
- while( !empty() )
+ while (!empty ())
{
- if( get<i_timestamp> ().front ().GetExpireTime () <= now ) // is the record stale?
+ if (get<i_timestamp> ().front ().GetExpireTime () <= now) // is the record stale?
{
- get<i_timestamp> ().pop_front( );
+ get<i_timestamp> ().pop_front ();
count ++;
}
else
@@ -140,26 +140,6 @@
m_fib = fib;
}
-bool
-CcnxPit::TryAddOutgoing (const CcnxPitEntry &pitEntry, Ptr<CcnxFace> face)
-{
- NS_LOG_FUNCTION ("Face has " << m_bucketsPerFace[face->GetId()] <<
- " packets with max allowance " << maxBucketsPerFace[face->GetId()]);
-
- if (m_bucketsPerFace[face->GetId()]+1.0 >= maxBucketsPerFace[face->GetId()])
- {
- NS_LOG_INFO("************ LIMIT **************");
- return false;
- }
-
- m_bucketsPerFace[face->GetId()] = m_bucketsPerFace[face->GetId()] + 1.0;
-
- modify (iterator_to (pitEntry),
- bind(&CcnxPitEntry::AddOutgoing, lambda::_1, face));
-
- return true;
-}
-
const CcnxPitEntry&
CcnxPit::Lookup (const CcnxContentObjectHeader &header) const
{
@@ -217,24 +197,4 @@
return make_tuple (cref(*entry), isNew, isDuplicate);
}
-///////////////////////////////////////////////////////////////////////////////////////////
-
-void
-CcnxPit::LeakBuckets ()
-{
- for (PitBucketIterator it = m_bucketsPerFace.begin();
- it != m_bucketsPerFace.end();
- it++)
- {
- it->second = std::max (0.0, it->second - leakSize[it->first]);
- }
-}
-
-void
-CcnxPit::LeakBucket (Ptr<CcnxFace> face, int amount)
-{
- m_bucketsPerFace[face->GetId()] = std::max (0.0, m_bucketsPerFace[face->GetId()] - amount);
-}
-
-
} // namespace ns3
diff --git a/model/ccnx-pit.h b/model/ccnx-pit.h
index 7c8785c..0d1132e 100644
--- a/model/ccnx-pit.h
+++ b/model/ccnx-pit.h
@@ -92,9 +92,8 @@
// typedef std::map<int,int> PitCounter;
// typedef std::map<int,int>::iterator PitCounterIterator;
- typedef std::map<int,double> PitBucket;
- typedef std::map<int,double>::iterator PitBucketIterator;
-
+typedef std::map<int,double> PitBucket;
+typedef std::map<int,double>::iterator PitBucketIterator;
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
@@ -122,17 +121,6 @@
* \brief Destructor
*/
virtual ~CcnxPit ();
-
- /**
- * @brief Try to add outgoing entry to PIT entry.
- * Will fail if there were too much (other) interests forwarded to this face
- *
- * @param pitEntry PIT entry
- * @param face face
- * @returns false if rate limit is imposed and no outgoing entry was created. True otherwise
- */
- bool
- TryAddOutgoing(const CcnxPitEntry &pitEntry, Ptr<CcnxFace> face);
/**
* \brief Find corresponding PIT entry for the given content name
@@ -155,21 +143,25 @@
boost::tuple<const CcnxPitEntry&, bool, bool>
Lookup (const CcnxInterestHeader &header);
- // remove a PIT entry
- //void erase (const string &contentName);
-
- // Reset pending state in outgoing interests
- // void resetPendingState( PitEntry &pe );
+ Time GetPitEntryPruningTimeout () const
+ {
+ return m_PitEntryPruningTimout;
+ }
+
+ /**
+ * \brief Set FIB table
+ */
+ void SetFib (Ptr<CcnxFib> fib);
- // // Check if there are any interfaces that we haven't sent data to yet
- // bool areFreeInterfaces( PitEntry &pe, int interface );
+protected:
+ // inherited from Object class
+ virtual void NotifyNewAggregate ();
+ virtual void DoDispose ();
+
+private:
+ /** \brief Remove expired records from PIT */
+ void CleanExpired ();
- // Periodically generate pre-calculated number of tokens (leak buckets)
- void LeakBuckets( );
-
- // Selectively leak a bucket
- void LeakBucket (Ptr<CcnxFace> face, int amount);
-
/**
* \brief Set cleanup timeout
*
@@ -186,40 +178,26 @@
*/
Time GetCleanupTimeout () const;
- Time GetPitEntryPruningTimeout () const
- {
- return m_PitEntryPruningTimout;
- }
-
- /**
- * \brief Set FIB table
- */
- void SetFib (Ptr<CcnxFib> fib);
-
-protected:
- // inherited from Object class
- virtual void NotifyNewAggregate ();
- virtual void DoDispose ();
-
-public:
- PitBucket maxBucketsPerFace; // maximum number of buckets. Automatically computed based on link capacity
- // // averaging over 1 second (bandwidth * 1second)
- PitBucket leakSize; // size of a periodic bucket leak
-
-private:
- /** \brief Remove expired records from PIT */
- void CleanExpired ();
-
friend std::ostream& operator<< (std::ostream& os, const CcnxPit &fib);
private:
Time m_cleanupTimeout; ///< \brief Configurable timeout of how often cleanup events are working
EventId m_cleanupEvent; ///< \brief Cleanup event
+
+ // configuration variables. Check implementation of GetTypeId for more details
Time m_PitEntryPruningTimout;
- Time m_PitEntryDefaultLifetime;
+ Time m_PitEntryDefaultLifetime;
Ptr<CcnxFib> m_fib; ///< \brief Link to FIB table
- PitBucket m_bucketsPerFace; ///< \brief pending interface counter per face
+ // PitBucket m_bucketsPerFace; ///< \brief pending interface counter per face
+
+ // /**
+ // * \brief maximum number of buckets. Automatically computed based on link capacity
+ // * averaging over 1 second (bandwidth * 1second)
+ // */
+ // PitBucket maxBucketsPerFace;
+
+ // PitBucket leakSize; ///< size of a periodic bucket leak
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/model/ccnx.h b/model/ccnx.h
index 4d6f636..38c2f74 100644
--- a/model/ccnx.h
+++ b/model/ccnx.h
@@ -22,7 +22,6 @@
#define _CCNX_H_
#include "ns3/object.h"
-#include "ns3/socket.h"
#include "ns3/callback.h"
namespace ns3 {
@@ -80,13 +79,13 @@
class Ccnx : public Object
{
public:
- enum ForwardingStrategy
+ enum ForwardingStrategy
{
- NDN_FLOODING = 1,
- NDN_BESTROUTE = 2,
- NDN_RANKING = 3
+ NDN_FLOODING = 1,
+ NDN_BESTROUTE = 2,
+ NDN_RANKING = 3
};
-
+
/**
* \brief Interface ID
*
@@ -95,47 +94,47 @@
static TypeId GetTypeId ();
virtual ~Ccnx ();
- /**
- * \brief Send an Interest packet to a specified face
- *
- * \param face face where to send this packet
- * \param header Interest header
- * \param packet fully prepared CCNx packet to send
- *
- * Higher-level layers (forwarding strategy in particular) call this
- * method to send a packet down the stack to the MAC and PHY layers.
- */
- virtual void
- SendInterest (const Ptr<CcnxFace> &face,
- const Ptr<const CcnxInterestHeader> &header,
- const Ptr<Packet> &packet) = 0;
+ // /**
+ // * \brief Send an Interest packet to a specified face
+ // *
+ // * \param face face where to send this packet
+ // * \param header Interest header
+ // * \param packet fully prepared CCNx packet to send
+ // *
+ // * Higher-level layers (forwarding strategy in particular) call this
+ // * method to send a packet down the stack to the MAC and PHY layers.
+ // */
+ // virtual void
+ // SendInterest (const Ptr<CcnxFace> &face,
+ // const Ptr<const CcnxInterestHeader> &header,
+ // const Ptr<Packet> &packet) = 0;
- /**
- * \brief Send a ContentObject packet to a specified face
- *
- * \param face face where to send this packet
- * \param header ContentObject header
- * \param packet fully prepared CCNx packet to send
- *
- * Higher-level layers (forwarding strategy in particular) call this
- * method to send a packet down the stack to the MAC and PHY layers.
- */
- virtual void
- SendContentObject (const Ptr<CcnxFace> &face,
- const Ptr<const CcnxContentObjectHeader> &header,
- const Ptr<Packet> &packet) = 0;
+ // /**
+ // * \brief Send a ContentObject packet to a specified face
+ // *
+ // * \param face face where to send this packet
+ // * \param header ContentObject header
+ // * \param packet fully prepared CCNx packet to send
+ // *
+ // * Higher-level layers (forwarding strategy in particular) call this
+ // * method to send a packet down the stack to the MAC and PHY layers.
+ // */
+ // virtual void
+ // SendContentObject (const Ptr<CcnxFace> &face,
+ // const Ptr<const CcnxContentObjectHeader> &header,
+ // const Ptr<Packet> &packet) = 0;
- /**
- * \brief Lower layers calls this method after demultiplexing
- *
- * Lower-layer-dependent implementation of CcnxFace will do actual work
- * to set up demultiplexing and call this function as a callback
- *
- * \param face face from which packet came from
- * \param p the packet
- */
- virtual void
- Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p) = 0;
+ // /**
+ // * \brief Lower layers calls this method after demultiplexing
+ // *
+ // * Lower-layer-dependent implementation of CcnxFace will do actual work
+ // * to set up demultiplexing and call this function as a callback
+ // *
+ // * \param face face from which packet came from
+ // * \param p the packet
+ // */
+ // virtual void
+ // Receive (const Ptr<CcnxFace> &face, const Ptr<const Packet> &p) = 0;
/**
* \brief Register a new forwarding strategy to be used by this Ccnx