To implement the rapid fault handling in ns3 has needs to reduce the disruption by classifying and responding the network failures rapidly. This is usually contains the fault detection, rerouting, and recovery mechanisms.
Now we are going to provide the brief implementation procedures to achieve this process in ns3:
Step-by-Step Guide:
Step 1: Setup ns3 Environment
Make sure ns3 is installed in the computer and verify it is properly configured.
git clone https://gitlab.com/nsnam/ns-3-dev.git
cd ns-3-dev
./waf configure
./waf build
Step 2: Create the Fault Handling Simulation Script
We will generate a script that sets up a network and execute a simple fault detection and rerouting mechanism.
#include “ns3/core-module.h”
#include “ns3/network-module.h”
#include “ns3/internet-module.h”
#include “ns3/point-to-point-module.h”
#include “ns3/applications-module.h”
#include “ns3/flow-monitor-module.h”
using namespace ns3;
NS_LOG_COMPONENT_DEFINE(“RapidFaultHandlingExample”);
void LinkFailureCallback(Ptr<Node> src, Ptr<Node> dst, Time detectionTime)
{
NS_LOG_UNCOND(Simulator::Now().GetSeconds() << “s: Link failure detected between Node ” << src->GetId() << ” and Node ” << dst->GetId());
// Example recovery action: disabling the device on src
for (uint32_t i = 0; i < src->GetNDevices(); ++i)
{
Ptr<NetDevice> device = src->GetDevice(i);
if (device->GetChannel() && device->GetChannel()->GetDevice(1)->GetNode() == dst)
{
device->SetAttribute(“ReceiveErrorModel”, PointerValue());
NS_LOG_UNCOND(“Device ” << device->GetIfIndex() << ” on Node ” << src->GetId() << ” disabled for recovery.”);
}
}
// Schedule the repair (re-enable the device) after detectionTime
Simulator::Schedule(detectionTime, [src, dst]() {
NS_LOG_UNCOND(Simulator::Now().GetSeconds() << “s: Link recovered between Node ” << src->GetId() << ” and Node ” << dst->GetId());
for (uint32_t i = 0; i < src->GetNDevices(); ++i)
{
Ptr<NetDevice> device = src->GetDevice(i);
if (device->GetChannel() && device->GetChannel()->GetDevice(1)->GetNode() == dst)
{
device->SetAttribute(“ReceiveErrorModel”, PointerValue());
NS_LOG_UNCOND(“Device ” << device->GetIfIndex() << ” on Node ” << src->GetId() << ” re-enabled.”);
}
}
});
}
int main(int argc, char *argv[])
{
CommandLine cmd;
cmd.Parse(argc, argv);
// Create nodes
NodeContainer nodes;
nodes.Create(4); // Four nodes in a simple line
// Create point-to-point links
PointToPointHelper p2p;
p2p.SetDeviceAttribute(“DataRate”, StringValue(“10Mbps”));
p2p.SetChannelAttribute(“Delay”, StringValue(“2ms”));
NetDeviceContainer devices;
devices = p2p.Install(nodes.Get(0), nodes.Get(1));
devices.Add(p2p.Install(nodes.Get(1), nodes.Get(2)));
devices.Add(p2p.Install(nodes.Get(2), nodes.Get(3)));
// Install the internet stack
InternetStackHelper stack;
stack.Install(nodes);
// Assign IP addresses
Ipv4AddressHelper address;
address.SetBase(“10.1.1.0”, “255.255.255.0”);
Ipv4InterfaceContainer interfaces = address.Assign(devices);
// Install applications to generate traffic
uint16_t port = 9;
// Client on node 0 will establish a path to server on node 3
OnOffHelper onoff(“ns3::UdpSocketFactory”, Address(InetSocketAddress(interfaces.GetAddress(3), port)));
onoff.SetConstantRate(DataRate(“1Mbps”));
ApplicationContainer clientApps = onoff.Install(nodes.Get(0));
clientApps.Start(Seconds(1.0));
clientApps.Stop(Seconds(10.0));
// Install packet sink on the last node to receive packets
PacketSinkHelper sink(“ns3::UdpSocketFactory”, Address(InetSocketAddress(Ipv4Address::GetAny(), port)));
ApplicationContainer serverApps = sink.Install(nodes.Get(3));
serverApps.Start(Seconds(0.0));
serverApps.Stop(Seconds(10.0));
// Enable FlowMonitor to measure performance metrics
FlowMonitorHelper flowmon;
Ptr<FlowMonitor> monitor = flowmon.InstallAll();
// Simulate a link failure and recovery
Simulator::Schedule(Seconds(3.0), &LinkFailureCallback, nodes.Get(1), nodes.Get(2), Seconds(2.0));
// Run the simulation
Simulator::Stop(Seconds(10.0));
Simulator::Run();
// Print per-flow statistics
monitor->CheckForLostPackets();
Ptr<Ipv4FlowClassifier> classifier = DynamicCast<Ipv4FlowClassifier>(flowmon.GetClassifier());
std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats();
for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator i = stats.begin(); i != stats.end(); ++i)
{
Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow(i->first);
NS_LOG_UNCOND(“Flow ” << i->first << ” (” << t.sourceAddress << ” -> ” << t.destinationAddress << “)”);
NS_LOG_UNCOND(” Tx Packets: ” << i->second.txPackets);
NS_LOG_UNCOND(” Tx Bytes: ” << i->second.txBytes);
NS_LOG_UNCOND(” Rx Packets: ” << i->second.rxPackets);
NS_LOG_UNCOND(” Rx Bytes: ” << i->second.rxBytes);
NS_LOG_UNCOND(” Lost Packets: ” << i->second.lostPackets);
NS_LOG_UNCOND(” Throughput: ” << i->second.rxBytes * 8.0 / (i->second.timeLastRxPacket.GetSeconds() – i->second.timeFirstTxPacket.GetSeconds()) / 1024 / 1024 << ” Mbps”);
}
// Clean up
Simulator::Destroy();
return 0;
}
Step 3: Compile and Run the Simulation
- Compile the Simulation:
./waf configure –enable-examples
./waf build
Run the Simulation:
./waf –run scratch/rapid-fault-handling-example
Step 4: Analyse Results
The simulation script sets up a network and simulates a link failure between nodes 1 and 2. The LinkFailureCallback function disables the link and then re-enables it after a specified detection time. FlowMonitor collects and prints out statistics about the traffic flows, such as packet loss, throughput, and delay.
Additional Considerations
To extend the functionality of your rapid fault handling simulation, consider the following:
1. Advanced Fault Detection
To execute more sophisticated fault detection mechanisms like heartbeat messages, link monitoring or SNMP-based monitoring.
2. Dynamic Routing
To automatically reroute traffic around failed links incorporate the dynamic routing protocols such as OSPF, BGP.
3. Fault Recovery
To execute the numerous fault recovery strategies like fast reroute, load balancing, and redundant paths.
4. Performance Metrics
Gather and evaluate additional metrics like jitter, packet delay variation, and mean time to repair (MTTR) to evaluate the network performance more comprehensively.
5. Fault Injection
To simulate different types of faults (e.g., link failure, node failure) and study their impact on the network executes a more flexible fault injection mechanism.
At the last, we entirely understand how the rapid fault handling is implemented in ns3 and that is used to reduce the disruption by classifying and responding the network failures rapidly. More information will be shared in further about rapid fault handling and its execution in different simulations.
Sometimes you may face difficulty in Implementing rapid fault handling in a network using ns-3, then you can get our help.