Using the link failure simulator tool

To check the routing configuration of the network, it may be useful to check if the failure of any link in the topology does not break the network. That is, the failure causes the network to recompute the best path for any destination and therefore any destination is still reachable.

To simulate a link failure, IPmininet proposes the following functions:

IPNet.runFailurePlan(failure_plan: List[Tuple[str, str]]) → List[ipmininet.link.IPIntf]

Run a failure plan

Param:A list of pairs of node names: links connecting these two links will be downed Returns:A list of interfaces that were downed

IPNet.randomFailure(n: int, weak_links: Optional[List[ipmininet.link.IPLink]] = None) → List[ipmininet.link.IPIntf]

Randomly down ‘n’ link

Parameters:

• n – the number of link to be downed
• weak_links – the list of links that can be downed; if set to None, every network link can be downed

Returns:

the list of interfaces which were downed

static IPNet.restoreIntfs(interfaces: List[ipmininet.link.IPIntf])

Restore interfaces

Parameters:interfaces – the list of interfaces to restore

The following code shows an example on how using those different tools to simulate failure scenarios. The link failure simulation is started after the network has been built, when calling post_build().

from ipmininet.iptopo import IPTopo
from ipmininet.utils import realIntfList


class MyTopology(IPTopo):
    """

        +-----+                 +------+
        |  r1 +-----------------+  r2  |
        +---+-+                 +---+--+
            |        +-----+        |
            +--------| r3  |--------+
                     +--+--+
                        |
                     +--+--+
                     | r4  |
                     +-----+
    """

    def build(self, *args, **kwargs):
        r1 = self.addRouter("r1")
        r2 = self.addRouter("r2")
        r3 = self.addRouter("r3")
        r4 = self.addRouter("r4")
        self.addLinks((r1, r2), (r2, r3), (r3, r1), (r3, r4))
        super().build(*args, **kwargs)

    def post_build(self, net):
        # Run the failure plan and then, restore the links
        failure_plan = [("r1", "r2"), ("r3", "r4")]
        interfaces_down = net.runFailurePlan(failure_plan)
        net.restoreIntfs(interfaces_down)

        # Run a random failure with 2 link to be downed and then, restore them
        interfaces_down = net.randomFailure(2)
        net.restoreIntfs(interfaces_down)

        # Run a 1 link Failure Random based on a given list of link and then, restore the link
        links = list(map(lambda x: x.link, realIntfList(net["r1"])))
        interfaces_down = net.randomFailure(1, weak_links=links)
        net.restoreIntfs(interfaces_down)
        super().post_build(net)

This is a simple example. It is possible to check if two nodes are still reachable by using basic functions such as pingAll(), or doing more precise tests by starting a basic TCP client/server on the nodes.

We use the post_build() function to use methods related to the simulation of a link failure. However, since those methods are belonging to the IPNet class, they can be used outside post_build() as long as the IPNet object can be accessed.