def test_custom_node_routers(self): RoutingHelper("rip", [self.n0, self.n1], [self.r0, self.r1]).populate_routing_tables() status = self.n0.ping("10.0.3.4", verbose=False) self.assertTrue(status) status = self.n1.ping("10.0.1.1", verbose=False) self.assertTrue(status) with self.assertRaises(TypeError): RoutingHelper("rip", self.n1, self.r1).populate_routing_tables() with self.assertRaises(ValueError): RoutingHelper("rip", ["n1"], ["r1"]).populate_routing_tables()
def test_isis(self): RoutingHelper("isis").populate_routing_tables() status = self.n0.ping("10.0.3.4", verbose=False) self.assertTrue(status) status = self.n1.ping("10.0.1.1", verbose=False) self.assertTrue(status)
def test_ospf(self): RoutingHelper("ospf").populate_routing_tables() status = self.n0.ping("10::3:4", verbose=False) self.assertTrue(status) status = self.n1.ping("10::1:1", verbose=False) self.assertTrue(status)
def test_logs(self): config.set_value("routing_logs", True) RoutingHelper("rip").populate_routing_tables() self.assertTrue( len(glob(f"{config.get_value('routing_suite')}-logs_*")) > 0) config.set_value("routing_logs", False)
def test_logs(self): config.set_value("routing_logs", True) RoutingHelper("rip").populate_routing_tables() self.assertTrue( os.path.isdir( f"{config.get_value('routing_suite')}-logs_{IdGen.topology_id}" )) config.set_value("routing_logs", False)
def test_prrp(self): # pylint: disable=invalid-name r1 = Node("r") r2 = Node("r") r1.enable_ip_forwarding() r2.enable_ip_forwarding() with self.net1: (n0_r1, r1_n0) = connect(self.n0, r1) (r1_r2, r2_r1) = connect(r1, r2, network=self.net2) (r2_n1, n1_r2) = connect(r2, self.n1) AddressHelper.assign_addresses() r2_n1.set_address("10.1.3.2/24") n1_r2.set_address("10.1.3.1/24") RoutingHelper(protocol="rip").populate_routing_tables() status = self.n0.ping(n1_r2.get_address(), verbose=False) self.assertTrue(status)
# Set the IPv4 address for the networks, and not the interfaces. # We will use the `AddressHelper` later to assign addresses to the interfaces. # Note: this example has two networks, one each on either side of `r1`. n1 = Network("192.168.1.0/24") # network on the left side of `r1` n2 = Network("192.168.2.0/24") # network on the right side of `r1` # Connect `h1` to `r1` (left side), and then `r1` (right side) to `h2`. # `eth1` and `eth2` are the interfaces at `h1` and `h2`, respectively. # `etr1a` is the first interface at `r1` which connects it with `h1` # `etr1b` is the second interface at `r1` which connects it with `h2` (eth1, etr1a) = connect(h1, r1, network=n1) (etr1b, eth2) = connect(r1, h2, network=n2) # Assign IPv4 addresses to all the interfaces in the network. AddressHelper.assign_addresses() # Set the link attributes: `h1` --> `r1` --> `h2` eth1.set_attributes("5mbit", "5ms") # from `h1` to `r1` etr1b.set_attributes("5mbit", "5ms") # from `r1` to `h2` # Set the link attributes: `h2` --> `r1` --> `h1` eth2.set_attributes("10mbit", "100ms") # from `h2` to `r1` etr1a.set_attributes("10mbit", "100ms") # from `r1` to `h1` # Use RIP to form routes. RoutingHelper(protocol="rip").populate_routing_tables() # `Ping` from `h1` to `h2`. h1.ping(eth2.address)
# Assign IPv4 addresses to all the interfaces in the network. AddressHelper.assign_addresses() # Enable MPLS on the required interfaces in the network. etpe1b.enable_mpls() etpa.enable_mpls() etpb.enable_mpls() etpe2a.enable_mpls() # Use LDP to auto-assign labels on MPLS enabled interfaces. LDP requires an IP # based dynamic routing protocol to be already in place for it to find out the # IP addresses. In this program, we use Open Shortest Path First (OSPF). # Initially, the OSPF routing protocol runs as usual, and then LDP runs on # the MPLS enabled routers: `pe` and `p`. RoutingHelper("ospf", ldp_routers=[pe1, p, pe2]).populate_routing_tables() # Add `sleep` time to allow LDP to install routes. Depending on the size of the # topology, the amount of time specified for `sleep` may vary. The following # two lines may be added as topology grows in size and complexity. Note: this # example does not require `sleep` time as the topology is simple and small. # # from time import sleep # sleep(20) # Set the link attributes: `ce1` --> `pe1` --> `p` --> `pe2` --> `ce2` etce1.set_attributes("50mbit", "5ms") # from `ce1` to `pe1` etpe1b.set_attributes("10mbit", "10ms") # from `pe1` to `p` etpb.set_attributes("10mbit", "10ms") # from `p` to `pe2` etpe2b.set_attributes("50mbit", "5ms") # from `pe2` to `ce2`