How to Begin Implement Network Resiliency in NS3

To implement and examine the Network Resiliency in ns3, we must adhere to these steps. Network resiliency denotes the network’s capability for sustaining functionality otherwise rapidly retrieving from failures like link disruptions, node failures, or attacks. Here’s a simple guidance on how to get started:

Steps to Begin Implement Network Resiliency in NS3

1. Understand Network Resiliency

Network resiliency’s primary features have:

• Fault Tolerance: The capability to redirect the traffic in the course of node or link failures.
• Recovery Time: After a failure, the duration to renovate the network operations.
• Redundancy: To contain alternative routes or resources available to manage the failures.
• Survivability: The capacity to function in partial network outages.

2. Set Up Your Environment

We can install ns3 environment on the system. Make use of components like InternetStackHelper and the routing protocols such as OLSR, AODV for handling the dynamic routing and resiliency.

3. Create the Network Topology

Example: Mesh Network with Redundant Links

NodeContainer nodes;

nodes.Create(6); // Create 6 nodes for a resilient topology

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute(“DataRate”, StringValue(“10Mbps”));

pointToPoint.SetChannelAttribute(“Delay”, StringValue(“2ms”));

// Connect nodes to form a mesh network with redundancy

NetDeviceContainer devices;

devices.Add(pointToPoint.Install(nodes.Get(0), nodes.Get(1)));

devices.Add(pointToPoint.Install(nodes.Get(1), nodes.Get(2)));

devices.Add(pointToPoint.Install(nodes.Get(2), nodes.Get(3)));

devices.Add(pointToPoint.Install(nodes.Get(3), nodes.Get(4)));

devices.Add(pointToPoint.Install(nodes.Get(4), nodes.Get(5)));

devices.Add(pointToPoint.Install(nodes.Get(0), nodes.Get(2))); // Redundant link

devices.Add(pointToPoint.Install(nodes.Get(2), nodes.Get(4))); // Redundant link

4. Install the Internet Stack

For redundancy, we should install the Internet stack and allow dynamic routing protocols:

InternetStackHelper internet;

OlsrHelper olsr; // Use OLSR for proactive routing

internet.SetRoutingHelper(olsr);

internet.Install(nodes);

Ipv4AddressHelper address;

address.SetBase(“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = address.Assign(devices);

5. Generate Traffic

Replicate the traffic, we need to set up applications.

Example: UDP Traffic

UdpEchoServerHelper echoServer(9);

ApplicationContainer serverApps = echoServer.Install(nodes.Get(5)); // Node 5 as the server

serverApps.Start(Seconds(1.0));

serverApps.Stop(Seconds(10.0));

UdpEchoClientHelper echoClient(interfaces.GetAddress(5), 9);

echoClient.SetAttribute(“MaxPackets”, UintegerValue(1000));

echoClient.SetAttribute(“Interval”, TimeValue(Seconds(0.01))); // 10ms interval

echoClient.SetAttribute(“PacketSize”, UintegerValue(1024));    // 1KB packets

ApplicationContainer clientApps = echoClient.Install(nodes.Get(0)); // Node 0 as the client

clientApps.Start(Seconds(2.0));

clientApps.Stop(Seconds(10.0));

6. Introduce Failures

Mimic node or link failures to experiment the network resiliency.

Simulate Link Failure

Detach a link failure on runtime:

Simulator::Schedule(Seconds(4.0), [&devices]() {

Ptr<PointToPointNetDevice> dev = DynamicCast<PointToPointNetDevice>(devices.Get(1).Get(0)); // Example: Node 1 to Node 2

dev->SetReceiveCallback(MakeNullCallback<void, Ptr<NetDevice>, Ptr<const Packet>, uint16_t, const Address &>());

std::cout << “Link between Node 1 and Node 2 failed at time ” << Simulator::Now().GetSeconds() << “s\n”;

});

Simulate Node Failure

Separate a node at the runtime:

Simulator::Schedule(Seconds(6.0), [&nodes]() {

nodes.Get(2)->GetObject<Ipv4>()->SetDown();

std::cout << “Node 2 failed at time ” << Simulator::Now().GetSeconds() << “s\n”;

});

7. Monitor Resiliency Metrics

Measure Recovery Time

Observe when traffic restarts after a failure using callbacks:

uint32_t packetsReceived = 0;

void PacketReceivedCallback(Ptr<const Packet> packet, const Address& src) {

packetsReceived++;

std::cout << “Packet received at time ” << Simulator::Now().GetSeconds() << “s\n”;

}

// Connect the callback to the server

Ptr<Socket> recvSocket = Socket::CreateSocket(nodes.Get(5), UdpSocketFactory::GetTypeId());

recvSocket->SetRecvCallback(MakeCallback(&PacketReceivedCallback));

Measure Packet Loss

Record lost packets by reason of failures:

uint32_t packetsLost = 0;

void PacketDroppedCallback(Ptr<const Packet> packet) {

packetsLost++;

std::cout << “Packet dropped at time ” << Simulator::Now().GetSeconds() << “s\n”;

}

// Connect to a queue on a specific link

Ptr<Queue<Packet>> queue = StaticCast<PointToPointNetDevice>(devices.Get(1))->GetQueue();

queue->TraceConnectWithoutContext(“Drop”, MakeCallback(&PacketDroppedCallback));

Measure Throughput

During and after failures, we can estimate the throughput to leverage FlowMonitor:

FlowMonitorHelper flowmon;

Ptr<FlowMonitor> monitor = flowmon.InstallAll();

Simulator::Stop(Seconds(10.0));

Simulator::Run();

monitor->CheckForLostPackets();

Ptr<Ipv4FlowClassifier> classifier = DynamicCast<Ipv4FlowClassifier>(flowmon.GetClassifier());

std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats();

for (auto& flow : stats) {

double throughput = flow.second.rxBytes * 8.0 / (flow.second.timeLastRxPacket.GetSeconds() – flow.second.timeFirstTxPacket.GetSeconds());

std::cout << “Flow ” << flow.first << ” Throughput: ” << throughput / 1e6 << ” Mbps\n”;

}

8. Enable Tracing

ASCII and PCAP Tracing

Record all events for examining the behaviour of network:

AsciiTraceHelper ascii;

pointToPoint.EnableAsciiAll(ascii.CreateFileStream(“network_resiliency.tr”));

pointToPoint.EnablePcapAll(“network_resiliency”);

XML Animation

Envision failure events and recovery with the support of NetAnim:

AnimationInterface anim(“network_resiliency.xml”);

9. Experiment with Parameters

• Redundancy: Experiment with various amounts of redundant links.
• Traffic Load: Replicate diverse traffic models for monitoring the resiliency in heavy load.
• Routing Protocols: Equate the resiliency through the routing protocols such as OLSR, AODV, and DSDV.

10. Run the Simulation

Finally, execute the simulation and then monitor its outcomes:

Simulator::Run();

Simulator::Destroy();

We’ve outlined stepwise methods with sample coding for implementing and examining the Network Resiliency using NS3 simulation tool. We will add further details relevant to this subject, if required.