def build(self, *args, **kwargs):
"""
+----------+ +--------+
| |
AS1 | AS2 | AS3
| |
| |
+-------+ eBGP | +-------+ iBGP +-------+ | eBGP +-------+
| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+-------+ | +-------+ +-------+ | +-------+
| |
| |
| |
+------------+ +--------+
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as2r1 = self.bgp('as2r1')
as2r2 = self.bgp('as2r2')
as3r1 = self.bgp('as3r1')
self.addLinks((as1r1, as2r1), (as2r1, as2r2), (as3r1, as2r2))
# Set AS-ownerships
self.addAS(1, (as1r1, ))
self.addiBGPFullMesh(2, (as2r1, as2r2))
self.addAS(3, (as3r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1)
ebgp_session(self, as3r1, as2r2)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
def add_daemon(*routers):
for r in routers:
r.addDaemon(BGP, address_families=families, **kwargs)
r.addDaemon(OSPF)
r.addDaemon(OSPF6)
return routers
server_ip = ["10.10.10.10", "10::10"]
""" Routers """
as1_r1, as1_r2, as1_rr = self.addRouters("as1_r1", "as1_r2", "as1_rr")
as2_r1 = self.addRouter("as2_r1", config=RouterConfig)
""" Hosts """
as1_h1, as1_h2 = [self.addHost(n) for n in ("as1_h1", "as1_h2")]
as2_h = self.addHost("as2_h")
""" Servers """
master = self.addHost("master")
serv1 = self.addHost("s1")
serv2 = self.addHost("s2")
""" AS """
self.addAS(1, [as1_r1, as1_r2, as1_rr])
self.addAS(2, [as2_r1])
""" Daemons """
serv1.addDaemon(Named)
serv2.addDaemon(Named)
records = [
ARecord(serv1, server_ip[0], ttl=240),
AAAARecord(serv1, server_ip[1])
]
self.addDNSZone(
name="group10",
dns_master=master,
dns_slaves=[],
nodes=[serv2, serv1],
)
#add_daemon(serv1, serv2)
add_daemon(as1_r1, as1_r2, as1_rr)
add_daemon(as2_r1)
""" Links """
self.addLinks((as1_r1, serv1), (as1_r2, serv2))
self.addLink(as1_r1, master)
self.addLink(as1_rr, as1_r1, igp_metric=2)
self.addLinks((as1_rr, as1_r2), (as1_rr, as2_r1))
self.addLinks((as1_r1, as1_h1), (as1_rr, as1_h2), (as2_r1, as2_h))
set_rr(self, rr=as1_rr, peers=[as1_r1, as1_r2])
ebgp_session(self, as1_rr, as2_r1, link_type=SHARE)
super().build(*args, **kwargs)
def _connect_ases(self, as1, as2):
if as1 == None or as2 == None:
error("You are trying to make a connection with an inexisting AS!")
if as1.nodes.count == 0 or as2.nodes.count == 0:
error("You are trying to connect to an AS without any router.")
self.addLink(as1.nodes[0], as2.nodes[0])
ebgp_session(self, as1.nodes[0], as2.nodes[0])
def build(self, *args, **kwargs):
"""
+----------+ +--------+
| |
AS1 | AS2 | AS3
| |
| iBGP |
+-------+ eBGP | +-------+ +-------+ | eBGP +-------+
| as1r1 +------------+ as2r1 +--X-as2r3-Y--+ as2r2 +------------+ as3r1 |
+-------+ | +-------+ OSPF +-------+ | +-------+
1.2.3.0/24 | | 1.2.3.0/24
| |
| |
+------------+ +--------+
"""
# Add all routers
as1r1, as2r1, as2r2, as2r3, x, y, as3r1 = \
self.addRouters('as1r1', 'as2r1', 'as2r2', 'as2r3', 'x', 'y',
'as3r1', config=RouterConfig)
as1r1.addDaemon(
BGP, address_families=(_bgp.AF_INET(networks=('1.2.3.0/24', )), ))
as2r1.addDaemon(BGP, routerid='1.1.1.1')
as2r1.addDaemon(OSPF)
as2r2.addDaemon(BGP, routerid='1.1.1.2')
as2r2.addDaemon(OSPF)
as2r3.addDaemon(BGP)
as2r3.addDaemon(OSPF)
x.addDaemon(OSPF)
y.addDaemon(OSPF)
as3r1.addDaemon(
BGP, address_families=(_bgp.AF_INET(networks=('1.2.3.0/24', )), ))
self.addLink(as1r1, as2r1)
self.addLink(as2r1, x, igp_metric=1)
self.addLink(x, as2r3, igp_metric=10)
# as2r1 has preferred routerid but higher IGP cost
self.addLink(as2r3, y, igp_metric=1)
self.addLink(y, as2r2, igp_metric=self.other_cost)
self.addLink(as3r1, as2r2)
# Set AS-ownerships
self.addAS(1, (as1r1, ))
self.addiBGPFullMesh(2, (as2r1, as2r2, as2r3))
self.addAS(3, (as3r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1)
ebgp_session(self, as3r1, as2r2)
# h1 = self.addHost("h1");
# h2 = self.addHost("h2");
# self.addSubnet((as1r1,h1), subnets=('1.1.1.0/24',));
# self.addSubnet((as2r1,as3r1,h2), subnets=('1.2.3.0/24',));
# self.addLink(as1r1,h1)
# self.addLink(as2r1,h2)
# self.addLink(as3r1,h2)
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+---+---+---+ +---+---+---+
| | | |
| as1 | | as2 |
| ExaBGP +-----+ FRR BGP |
| | | |
+---+---+---+ +---+---+---+
"""
af4 = AF_INET(routes=self.routes['ipv4'])
af6 = AF_INET6(routes=self.routes['ipv6'])
# Add all routers
as1r1 = self.addRouter('as1', config=RouterConfig, use_v4=True, use_v6=True)
as1r1.addDaemon(ExaBGPDaemon, address_families=(af4, af6))
as2r1 = self.bgp('as2')
# Add links
las12 = self.addLink(as1r1, as2r1)
las12[as1r1].addParams(ip=(str(self.addr['as1']['ipv4']), str(self.addr['as1']['ipv6'])))
las12[as2r1].addParams(ip=(str(self.addr['as2']['ipv4']), str(self.addr['as2']['ipv6'])))
# Set AS-ownerships
self.addAS(self.exabgp_asn, (as1r1,))
self.addAS(self.frr_asn, (as2r1,))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
=
+----------------------+
+--+--+ |
| as4 +-------+ |
+-----+ $ | |
v |
+--+--+ +--+--+
| as2 +-----+ as3 |
+--+--+ = +--+--+
^ ^
+-----+ $ | |
| as1 +-------+ |
+--+--+ $ |
+----------------------+
"""
# Add all routers
as1r1 = self.bgp('as1')
as2r1 = self.bgp('as2')
as3r1 = self.bgp('as3')
as4r1 = self.bgp('as4')
# Add links
las12 = self.addLink(as1r1, as2r1)
las12[as1r1].addParams(ip=("fd00:12::1/64", ))
las12[as2r1].addParams(ip=("fd00:12::2/64", ))
las23 = self.addLink(as2r1, as3r1)
las23[as2r1].addParams(ip=("fd00:23::2/64", ))
las23[as3r1].addParams(ip=("fd00:23::3/64", ))
las13 = self.addLink(as1r1, as3r1)
las13[as1r1].addParams(ip=("fd00:13::1/64", ))
las13[as3r1].addParams(ip=("fd00:13::3/64", ))
las34 = self.addLink(as3r1, as4r1)
las34[as3r1].addParams(ip=("fd00:34::3/64", ))
las34[as4r1].addParams(ip=("fd00:34::4/64", ))
las24 = self.addLink(as2r1, as4r1)
las24[as2r1].addParams(ip=("fd00:24::2/64", ))
las24[as4r1].addParams(ip=("fd00:24::4/64", ))
# Set AS-ownerships
self.addAS(1, (as1r1, ))
self.addAS(2, (as2r1, ))
self.addAS(3, (as3r1, ))
self.addAS(4, (as4r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1, link_type=CLIENT_PROVIDER)
ebgp_session(self, as3r1, as2r1, link_type=SHARE)
ebgp_session(self, as4r1, as2r1, link_type=CLIENT_PROVIDER)
ebgp_session(self, as1r1, as3r1, link_type=CLIENT_PROVIDER)
ebgp_session(self, as4r1, as3r1, link_type=SHARE)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+-------+
+------+ as2r +-------+
| +-------+ |
| = = |
| |
+---+---+ $ +---+---+
| as1r +<-------------+ as3r |
+---+---+ +---+---+
| |
| $ $ |
| +-------+ |
+----->+ as4r +<------+
+-------+
"""
# Add all routers
as1r = self.addRouter('as1r')
as2r = self.addRouter('as2r')
as3r = self.addRouter('as3r')
as4r = self.addRouter('as4r')
routers = self.routers()
prefix = {routers[i]: '2001:db:%04x::/48' % i
for i in range(len(routers))}
as1r.addDaemon(BGP,
address_families=(AF_INET6(networks=(prefix[as1r],)),))
as2r.addDaemon(BGP,
address_families=(AF_INET6(networks=(prefix[as2r],)),))
as3r.addDaemon(BGP,
address_families=(AF_INET6(networks=(prefix[as3r],)),))
as4r.addDaemon(BGP,
address_families=(AF_INET6(networks=(prefix[as4r],)),))
# Add links
self.addLink(as1r, as2r)
self.addLink(as1r, as3r)
self.addLink(as1r, as4r)
self.addLink(as2r, as3r)
self.addLink(as3r, as4r)
# Set AS-ownerships
self.addAS(1, (as1r,))
self.addAS(2, (as2r,))
self.addAS(3, (as3r,))
self.addAS(4, (as4r,))
# Add BGP peering
ebgp_session(self, as1r, as2r, link_type=SHARE)
ebgp_session(self, as3r, as2r, link_type=SHARE)
ebgp_session(self, as3r, as1r, link_type=CLIENT_PROVIDER)
ebgp_session(self, as1r, as4r, link_type=CLIENT_PROVIDER)
ebgp_session(self, as3r, as4r, link_type=CLIENT_PROVIDER)
# Add test hosts
for r in self.routers():
link = self.addLink(r, self.addHost('h%s' % r))
self.addSubnet(links=[link], subnets=[prefix[r]])
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+----------+ +--------+
| |
AS1 | AS2 | AS3
| |
| iBGP |
+-------+ eBGP | +-------+ +-------+ | eBGP +-------+
| as1r1 +------------+ as2r1 +--X-as2r3-Y--+ as2r2 +------------+ as3r1 |
+-------+ | +-------+ OSPF +-------+ | +-------+
1.2.3.0/24 | | 1.2.3.0/24
| |
| |
+------------+ +--------+
"""
# Add all routers
as1r1 = self.addRouter('as1r1')
as1r1.addDaemon(BGP, address_families=(
_bgp.AF_INET(networks=('1.2.3.0/24',)),))
as2r1 = self.addRouter('as2r1')
as2r1.addDaemon(BGP, routerid='1.1.1.1')
as2r1.addDaemon(OSPF)
as2r2 = self.addRouter('as2r2')
as2r2.addDaemon(BGP, routerid='1.1.1.2')
as2r2.addDaemon(OSPF)
as2r3 = self.addRouter('as2r3')
as2r3.addDaemon(BGP)
as2r3.addDaemon(OSPF)
x = self.addRouter('x')
x.addDaemon(OSPF)
y = self.addRouter('y')
y.addDaemon(OSPF)
as3r1 = self.addRouter('as3r1')
as3r1.addDaemon(BGP, address_families=(
_bgp.AF_INET(networks=('1.2.3.0/24',)),))
self.addLink(as1r1, as2r1)
self.addLink(as2r1, x, igp_metric=1)
self.addLink(x, as2r3, igp_metric=10)
# as2r1 has preferred routerid but higher IGP cost
self.addLink(as2r3, y, igp_metric=1)
self.addLink(y, as2r2, igp_metric=self.other_cost)
self.addLink(as3r1, as2r2)
# Set AS-ownerships
self.addOverlay(AS(1, (as1r1,)))
self.addOverlay(iBGPFullMesh(2, (as2r1, as2r2, as2r3)))
self.addOverlay(AS(3, (as3r1,)))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1)
ebgp_session(self, as3r1, as2r2)
super(BGPDecisionProcess, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+----------+ +--------+
| |
AS1 | AS2 | AS3
| |
| iBGP |
+-------+ eBGP | +-------+ +-------+ | eBGP +-------+
| as1r1 +------------+ as2r1 +--X-as2r3-Y--+ as2r2 +------------+ as3r1 |
+-------+ | +-------+ OSPF +-------+ | +-------+
1.2.3.0/24 | | 1.2.3.0/24
| |
| |
+------------+ +--------+
"""
# Add all routers
as1r1 = self.addRouter('as1r1')
as1r1.addDaemon(
BGP, address_families=(_bgp.AF_INET(networks=('1.2.3.0/24', )), ))
as2r1 = self.addRouter('as2r1')
as2r1.addDaemon(BGP, routerid='1.1.1.1')
as2r1.addDaemon(OSPF)
as2r2 = self.addRouter('as2r2')
as2r2.addDaemon(BGP, routerid='1.1.1.2')
as2r2.addDaemon(OSPF)
as2r3 = self.addRouter('as2r3')
as2r3.addDaemon(BGP)
as2r3.addDaemon(OSPF)
x = self.addRouter('x')
x.addDaemon(OSPF)
y = self.addRouter('y')
y.addDaemon(OSPF)
as3r1 = self.addRouter('as3r1')
as3r1.addDaemon(
BGP, address_families=(_bgp.AF_INET(networks=('1.2.3.0/24', )), ))
self.addLink(as1r1, as2r1)
self.addLink(as2r1, x, igp_metric=1)
self.addLink(x, as2r3, igp_metric=10)
# as2r1 has preferred routerid but higher IGP cost
self.addLink(as2r3, y, igp_metric=1)
self.addLink(y, as2r2, igp_metric=self.other_cost)
self.addLink(as3r1, as2r2)
# Set AS-ownerships
self.addAS(1, (as1r1, ))
self.addiBGPFullMesh(2, (as2r1, as2r2, as2r3))
self.addAS(3, (as3r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1)
ebgp_session(self, as3r1, as2r2)
super(BGPDecisionProcess, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+----------------------+
+--+--+ $ = |
| as4 +-------+ |
+-----+ | |
v |
+--+--+ +--+--+
| as2 +-----+ as3 |
+--+--+ = +--+--+
^ ^
+-----+ $ | |
| as1 +-------+ |
+--+--+ $ |
+----------------------+
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as2r1 = self.bgp('as2r1')
as3r1 = self.bgp('as3r1')
as4r1 = self.bgp('as4r1')
self.addLink(as1r1,
as2r1,
params1={"ip": ("fd00:12::1/64", )},
params2={"ip": ("fd00:12::2/64", )})
self.addLink(as2r1,
as3r1,
params1={"ip": ("fd00:23::2/64")},
params2={"ip": ("fd00:23::3/64")})
self.addLink(as1r1,
as3r1,
params1={"ip": ("fd00:13::1/64", )},
params2={"ip": ("fd00:13::3/64")})
self.addLink(as3r1,
as4r1,
params1={"ip": ("fd00:34::3/64")},
params2={"ip": ("fd00:34::4/64")})
self.addLink(as2r1,
as4r1,
params1={"ip": ("fd00:24::2/64")},
params2={"ip": ("fd00:24::4/64")})
# Set AS-ownerships
self.addAS(1, (as1r1, ))
self.addAS(2, (as2r1, ))
self.addAS(3, (as3r1, ))
self.addAS(4, (as4r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1, CLIENT_PROVIDER)
ebgp_session(self, as3r1, as2r1, SHARE)
ebgp_session(self, as4r1, as2r1, CLIENT_PROVIDER)
ebgp_session(self, as1r1, as3r1, CLIENT_PROVIDER)
ebgp_session(self, as4r1, as3r1, SHARE)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super(BGPCentralized, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+-------+
+------+ as2r +-------+
| +-------+ |
| = = |
| |
+---+---+ $ +---+---+
| as1r +<-------------+ as3r |
+---+---+ +---+---+
| |
| $ $ |
| +-------+ |
+----->+ as4r +<------+
+-------+
"""
# Add all routers
as1r = self.addRouter('as1r')
as2r = self.addRouter('as2r')
as3r = self.addRouter('as3r')
as4r = self.addRouter('as4r')
as1r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:1::/48', )), ))
as2r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:2::/48', )), ))
as3r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:3::/48', )), ))
as4r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:4::/48', )), ))
# Add links
self.addLink(as1r, as2r)
self.addLink(as1r, as3r)
self.addLink(as1r, as4r)
self.addLink(as2r, as3r)
self.addLink(as3r, as4r)
# Set AS-ownerships
self.addAS(1, (as1r, ))
self.addAS(2, (as2r, ))
self.addAS(3, (as3r, ))
self.addAS(4, (as4r, ))
# Add BGP peering
ebgp_session(self, as1r, as2r, SHARE)
ebgp_session(self, as3r, as2r, SHARE)
ebgp_session(self, as3r, as1r, CLIENT_PROVIDER)
ebgp_session(self, as1r, as4r, CLIENT_PROVIDER)
ebgp_session(self, as3r, as4r, CLIENT_PROVIDER)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super(BGPPrefixConnectedTopo, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
Topo from slide 27 BGP-RR-TE
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as1r3 = self.bgp('as1r3')
as1r5 = self.bgp('as1r5')
as1r6 = self.bgp('as1r6')
as6r1 = self.addRouter('as6r1')
as6r1.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/32', )), ))
as6r2 = self.addRouter('as6r2')
as6r2.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/32', )), ))
h1 = self.addHost('h1')
h2 = self.addHost('h2')
h3 = self.addHost('h3')
h4 = self.addHost('h4')
# Add Links
self.addLink(as1r1, as1r6, ipg_cost=1)
self.addLink(as1r5, as1r6, igp_cost=1)
self.addLink(as1r3, as1r5, igp_cost=1)
self.addLink(as1r1, as1r3, igp_cost=5)
self.addLink(as6r1, as1r1)
self.addLink(as6r2, as1r3)
self.addLink(as6r1,
h1,
params1={"ip": "dead:beef::/48"},
params2={"ip": "dead:beef::1/48"})
self.addLink(as6r2,
h2,
params1={"ip": "dead:beef::2/48"},
params2={"ip": "dead:beef::3/48"})
self.addLink(as1r5, h3)
self.addLink(as1r6, h4)
set_rr(self, rr=as1r1, peers=[as1r3, as1r5])
set_rr(self, rr=as1r3, peers=[as1r1, as1r6])
# Add full mesh
self.addAS(6, (as6r1, as6r2))
self.addAS(1, (as1r1, as1r3, as1r5, as1r6))
# Add eBGP session
ebgp_session(self, as1r1, as6r1)
ebgp_session(self, as1r3, as6r2)
super(SimpleBGPTopoErr, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
Topo from slide 38 iBGP
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as1r2 = self.bgp('as1r2')
as1r3 = self.bgp('as1r3')
as1r4 = self.bgp('as1r4')
as1r5 = self.bgp('as1r5')
as1r6 = self.bgp('as1r6')
as4r1 = self.addRouter('as4r1')
as4r1.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/48', )), ))
as4r2 = self.addRouter('as4r2')
as4r2.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/48', )), ))
h1 = self.addHost('h1')
# Add Links
self.addLink(as1r1, as1r6)
self.addLink(as1r1, as1r3)
self.addLink(as1r3, as1r2)
self.addLink(as1r3, as1r6)
self.addLink(as1r2, as1r4)
self.addLink(as1r4, as1r5)
self.addLink(as1r5, as1r6)
self.addLink(as4r1, as1r6)
self.addLink(as4r2, as1r5)
self.addLink(as4r1,
h1,
params1={"ip": "dead:beef::/48"},
params2={"ip": "dead:beef::1/48"})
self.addLink(as4r2,
h1,
params1={"ip": "dead:beef::2/48"},
params2={"ip": "dead:beef::3/48"})
set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
# Add full mesh
self.addAS(4, (as4r1, as4r2))
self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
# Add eBGP session
ebgp_session(self, as1r6, as4r1)
ebgp_session(self, as1r5, as4r2)
super(SimpleBGPTopoRR, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
def add_daemon(*routers, ospf=True, bgp=True):
for r in routers:
if bgp:
r.addDaemon(BGP, address_families=families, **kwargs)
if ospf:
r.addDaemon(OSPF)
r.addDaemon(OSPF6)
return routers
server_ip = ["10.10.10.10/32", "10::10/128"]
""" Routers """
as1_r1, as1_r2, as1_rr = self.addRouters("as1_r1", "as1_r2", "as1_rr")
as2_r1 = self.addRouter("as2_r1", config=RouterConfig)
""" Hosts """
as1_h1, as1_h2 = [self.addHost(n) for n in ("as1_h1", "as1_h2")]
as2_h = self.addHost("as2_h")
""" Servers """
serv1 = self.addRouter("s1", lo_addresses=server_ip)
serv2 = self.addRouter("s2", lo_addresses=server_ip)
""" AS """
self.addAS(1, [as1_r1, as1_r2, as1_rr, serv1, serv2])
self.addAS(2, [as2_r1])
""" Daemons """
add_daemon(serv1, serv2, ospf=False)
add_daemon(as1_r1, as1_r2, as1_rr)
add_daemon(as2_r1)
""" Links """
self.addLinks((as1_r1, serv1), (as1_r2, serv2))
self.addLink(as1_rr, as1_r1, igp_metric=2)
self.addLinks((as1_rr, as1_r2), (as1_rr, as2_r1))
self.addLinks((as1_r1, as1_h1), (as1_rr, as1_h2), (as2_r1, as2_h))
set_rr(self, rr=as1_rr, peers=[as1_r1, as1_r2])
set_rr(self, rr=as1_r1, peers=[serv1])
set_rr(self, rr=as1_r2, peers=[serv2])
ebgp_session(self, as1_rr, as2_r1, link_type=SHARE)
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+----------+ +--------+
| |
AS1 | AS2 | AS3
| |
| |
+-------+ eBGP | +-------+ iBGP +-------+ | eBGP +-------+
| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+-------+ | +-------+ +-------+ | +-------+
| |
| |
| |
+------------+ +--------+
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as2r1 = self.bgp('as2r1')
as2r2 = self.bgp('as2r2')
as3r1 = self.bgp('as3r1')
# as2r3 = self.addRouter('as2r3')
# as2r3.addDaemon(BGP, route_reflector_client=True)
self.addLink(as1r1, as2r1)
self.addLink(as2r1, as2r2)
self.addLink(as3r1, as2r2)
# Set AS-ownerships
self.addAS(1, (as1r1, ))
# self.addAS(2, (as2r1, as2r2, as2r3))
self.addiBGPFullMesh(2, (as2r1, as2r2))
self.addAS(3, (as3r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1)
ebgp_session(self, as3r1, as2r2)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super(SimpleBGPTopo, self).build(*args, **kwargs)
def build(self, * args, ** kwargs):
def add_daemon(r):
r.addDaemon(BGP, address_families=families)
r.addDaemon(OSPF)
r.addDaemon(OSPF6)
return r
as1_r1 = self.addRouter("as1_r1", config = RouterConfig)
as2_r1 = self.addRouter("as2_r1", config = RouterConfig)
as1_r2 = self.addRouter("as1_r2", config = RouterConfig)
as2_r2 = self.addRouter("as2_r2", config = RouterConfig)
as1_h = self.addHost("as1_h")
as2_h = self.addHost("as2_h")
self.addAS(1, [as1_r1, as1_r2])
self.addAS(2, [as2_r1, as2_r2])
add_daemon(as1_r1)
add_daemon(as2_r1)
add_daemon(as1_r2)
add_daemon(as2_r2)
self.addLink(as1_r2, as1_h)
self.addLink(as1_r2, as1_r1)
self.addLink(as1_r1, as2_r1)
self.addLink(as2_r2, as2_r1)
self.addLink(as2_r1, as2_h)
set_rr(self, rr = as1_r1, peers = [as1_r2])
set_rr(self, rr = as2_r1, peers = [as2_r2])
ebgp_session(self, as1_r1, as2_r1, link_type=CLIENT_PROVIDER)
super().build(*args, **kwargs)
def add_ebgp_session(self, node, voisin, as_1, as_2, link_type='share'):
self.__bgp_sessions['ebgp'].setdefault(as_1, {})
self.__bgp_sessions['ebgp'][as_1].setdefault(as_2, [])
self.__bgp_sessions['ebgp'].setdefault(as_2, {})
self.__bgp_sessions['ebgp'][as_2].setdefault(as_1, [])
self.__bgp_sessions['ebgp'][as_1][as_2].append(
[node, voisin, link_type])
self.__bgp_sessions['ebgp'][as_2][as_1].append(
[voisin, node, link_type])
if self.debug:
print(
"{} and {} have different AS ({} vs {}), creating an eBGP connection with {} link"
.format(node, voisin, as_1, as_2, link_type))
return ebgp_session(self, node, voisin,
link_type=None) #_link_types.get(link_type, None))
def build(self, *args, **kwargs):
"""
Build the topology of our OVH network and set up it by adding routers, links, protocols, setting up routers
reflectors, etc.
"""
# Adding routers
fra1_g1 = self.addRouter("fra1_g1", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 1, IPV4_LO_PREFIX).__str__()
])
fra1_g2 = self.addRouter("fra1_g2", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "2",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 2, IPV4_LO_PREFIX).__str__()
])
fra_sbb1 = self.addRouter("fra_sbb1", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "3",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 3, IPV4_LO_PREFIX).__str__()
])
fra_sbb2 = self.addRouter("fra_sbb2", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "4",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 4, IPV4_LO_PREFIX).__str__()
])
fra_1 = self.addRouter("fra_1", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "5",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 5, IPV4_LO_PREFIX).__str__()
])
fra_5 = self.addRouter("fra_5", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "6",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 6, IPV4_LO_PREFIX).__str__()
])
rbx_g1 = self.addRouter("rbx_g1", [
IPv6Address("2023", "a", "d", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 7, IPV4_LO_PREFIX).__str__()
])
rbx_g2 = self.addRouter("rbx_g2", [
IPv6Address("2023", "a", "d", "0", "0", "0", "0", "2",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 8, IPV4_LO_PREFIX).__str__()
])
sbg_g1 = self.addRouter("sbg_g1", [
IPv6Address("2023", "a", "e", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 9, IPV4_LO_PREFIX).__str__()
])
sbg_g2 = self.addRouter("sbg_g2", [
IPv6Address("2023", "a", "e", "0", "0", "0", "0", "2",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 10, IPV4_LO_PREFIX).__str__()
])
par_th2 = self.addRouter("par_th2", [
IPv6Address("2023", "a", "f", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 11, IPV4_LO_PREFIX).__str__()
])
par_gsw = self.addRouter("par_gsw", [
IPv6Address("2023", "a", "f", "0", "0", "0", "0", "2",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 12, IPV4_LO_PREFIX).__str__()
])
telia = self.addRouter("telia", [
IPv6Address("2299", "a", "5", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(123, 3, 2, 1, IPV4_LO_PREFIX).__str__()
])
google = self.addRouter("google", [
IPv6Address("2169", "a", "6", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(124, 3, 2, 1, IPV4_LO_PREFIX).__str__()
])
cogent = self.addRouter("cogent", [
IPv6Address("2174", "a", "7", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(125, 3, 2, 1, IPV4_LO_PREFIX).__str__()
])
level3 = self.addRouter("level3", [
IPv6Address("2356", "a", "8", "0", "0", "0", "0", "1",
IPV6_LO_PREFIX).__str__(),
IPv4Address(126, 3, 2, 1, IPV4_LO_PREFIX).__str__()
])
all_routers = [
fra1_g1, fra1_g2, fra_sbb1, fra_sbb2, fra_1, fra_5, rbx_g1, rbx_g2,
sbg_g1, sbg_g2, par_th2, par_gsw, telia, google, cogent, level3
]
fra_routers = [fra1_g1, fra1_g2, fra_sbb1, fra_sbb2, fra_1,
fra_5] # In Frankfurt
rbx_routers = [rbx_g1, rbx_g2] # In Roubaix
sbg_routers = [sbg_g1, sbg_g2] # In Strasbourg
par_routers = [par_th2, par_gsw] # In Paris
ovh_routers = fra_routers + rbx_routers + sbg_routers + par_routers
external_routers = [telia, google, cogent, level3]
# Adding physical links
self.add_physical_link(fra1_g1, fra1_g2, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "0",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 0, IPV4_LINK_PREFIX)))
self.add_physical_link(fra1_g1, fra_sbb1, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "2",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 2, IPV4_LINK_PREFIX)))
self.add_physical_link(fra1_g2, fra_sbb2, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "4",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 4, IPV4_LINK_PREFIX)))
self.add_physical_link(fra_sbb1, fra_sbb2, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "6",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 6, IPV4_LINK_PREFIX)))
self.add_physical_link(fra_sbb1, fra_5, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "8",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 8, IPV4_LINK_PREFIX)))
self.add_physical_link(fra_sbb1, fra_1, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "a",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 10, IPV4_LINK_PREFIX)))
self.add_physical_link(
fra_sbb1,
sbg_g1, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "c",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 12, IPV4_LINK_PREFIX)),
igp_cost_value=2)
self.add_physical_link(
fra_sbb1,
rbx_g1, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "e",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 14, IPV4_LINK_PREFIX)),
igp_cost_value=5)
self.add_physical_link(fra_sbb2, fra_1, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "10",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 16, IPV4_LINK_PREFIX)))
self.add_physical_link(fra_sbb2, fra_5, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "12",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 18, IPV4_LINK_PREFIX)))
self.add_physical_link(
fra_sbb2,
rbx_g2, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "14",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 20, IPV4_LINK_PREFIX)),
igp_cost_value=5)
self.add_physical_link(
fra_sbb2,
sbg_g2, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "16",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 22, IPV4_LINK_PREFIX)),
igp_cost_value=2)
self.add_physical_link(fra_1, telia, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "18",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 24, IPV4_LINK_PREFIX)))
self.add_physical_link(fra_5, telia, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "1a",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 26, IPV4_LINK_PREFIX)))
self.add_physical_link(fra_5, level3, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "1c",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 28, IPV4_LINK_PREFIX)))
self.add_physical_link(rbx_g1, rbx_g2, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "1e",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 30, IPV4_LINK_PREFIX)))
self.add_physical_link(
rbx_g1,
par_th2, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "20",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 32, IPV4_LINK_PREFIX)),
igp_cost_value=3)
self.add_physical_link(rbx_g2, par_gsw, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "22",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 34, IPV4_LINK_PREFIX)))
self.add_physical_link(sbg_g1, sbg_g2, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "24",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 36, IPV4_LINK_PREFIX)))
self.add_physical_link(
sbg_g1,
par_th2, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "26",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 38, IPV4_LINK_PREFIX)),
igp_cost_value=5)
self.add_physical_link(par_th2, par_gsw, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "28",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 40, IPV4_LINK_PREFIX)))
self.add_physical_link(
par_th2,
google, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "2a",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 42, IPV4_LINK_PREFIX)),
igp_cost_value=2)
self.add_physical_link(par_th2, cogent, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "2c",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 44, IPV4_LINK_PREFIX)))
self.add_physical_link(
par_gsw,
sbg_g2, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "2e",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 46, IPV4_LINK_PREFIX)),
igp_cost_value=5)
self.add_physical_link(par_gsw, level3, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "30",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 48, IPV4_LINK_PREFIX)))
self.add_physical_link(par_gsw, cogent, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "32",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 50, IPV4_LINK_PREFIX)))
self.add_physical_link(
par_gsw,
google, (IPv6Address("2023", "b", "0", "0", "0", "0", "0", "34",
IPV6_LINK_PREFIX),
IPv4Address(12, 16, 217, 52, IPV4_LINK_PREFIX)),
igp_cost_value=2)
# Adding OSPF and BGP daemons to routers
self.add_ospf(all_routers)
self.add_bgp(ovh_routers, external_routers)
# Adding AS ownerships
self.addAS(OVH_AS, (fra1_g1, fra1_g2, fra_sbb1, fra_sbb2, fra_1, fra_5,
rbx_g1, rbx_g2, sbg_g1, par_th2, par_gsw, sbg_g2))
self.addAS(TELIA_AS, (telia, ))
self.addAS(COGENT_AS, (cogent, ))
self.addAS(LEVEL3_AS, (level3, ))
self.addAS(GOOGLE_AS, (google, ))
# Configuring RRs/iBGP sessions
peers_fra_fr5_sbb1 = peers_fra_5 = [fra1_g1, fra1_g2, fra_sbb2, fra_1]
peers_rbx_g1 = peers_rbx_g2 = [sbg_g1, par_th2, par_gsw, sbg_g2]
set_rr(self, rr=fra_sbb1, peers=peers_fra_fr5_sbb1)
set_rr(self, rr=fra_5, peers=peers_fra_5)
set_rr(self, rr=rbx_g1, peers=peers_rbx_g1)
set_rr(self, rr=rbx_g2, peers=peers_rbx_g2)
self.addiBGPFullMesh(16276, routers=[fra_sbb1, fra_5, rbx_g1,
rbx_g2]) # (4*3)/2 iBGP sessions
# Adding eBGP sessions
ebgp_session(self, telia, fra_1, link_type=CLIENT_PROVIDER)
ebgp_session(self, telia, fra_5, link_type=CLIENT_PROVIDER)
ebgp_session(self, level3, fra_5, link_type=CLIENT_PROVIDER)
ebgp_session(self, google, par_gsw, link_type=CLIENT_PROVIDER)
ebgp_session(self, cogent, par_gsw, link_type=CLIENT_PROVIDER)
ebgp_session(self, level3, par_gsw, link_type=CLIENT_PROVIDER)
ebgp_session(self, cogent, par_th2, link_type=CLIENT_PROVIDER)
ebgp_session(self, google, par_th2, link_type=CLIENT_PROVIDER)
# DNS anycast
sbg_web = self.addHost("sbg_web")
fra_server = self.addRouter("fra_server", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "7",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 13, IPV4_LO_PREFIX).__str__()
])
rbx_server = self.addRouter("rbx_server", [
IPv6Address("2023", "a", "c", "0", "0", "0", "0", "7",
IPV6_LO_PREFIX).__str__(),
IPv4Address(12, 16, 216, 13, IPV4_LO_PREFIX).__str__()
])
fra_server.addDaemon(
BGP,
address_families=(AF_INET(redistribute=("connected", )),
AF_INET6(redistribute=("connected", ))))
rbx_server.addDaemon(
BGP,
address_families=(AF_INET(redistribute=("connected", )),
AF_INET6(redistribute=("connected", ))))
self.addAS(64512, (fra_server, )) # private ASN
self.addAS(64513, (rbx_server, ))
self.add_physical_link(rbx_g1, rbx_server, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "36",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 54, IPV4_LINK_PREFIX)))
self.add_physical_link(fra_sbb2, fra_server, (IPv6Address(
"2023", "b", "0", "0", "0", "0", "0", "36",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 217, 54, IPV4_LINK_PREFIX)))
self.add_physical_link(sbg_g2, sbg_web, (IPv6Address(
"2023", "e", "2", "0", "0", "0", "0", "3",
IPV6_LINK_PREFIX), IPv4Address(12, 16, 218, 71, IPV4_LINK_PREFIX)))
ebgp_session(self, fra_server, fra_sbb2, link_type=CLIENT_PROVIDER)
ebgp_session(self, rbx_server, rbx_g1, link_type=CLIENT_PROVIDER)
fra_server.addDaemon(Named)
rbx_server.addDaemon(Named)
self.addDNSZone(name=DOMAIN,
dns_master=fra_server,
dns_slaves=[rbx_server],
nodes=[sbg_web])
reverse_domain_name_ipv6 = ip_address("2023::").reverse_pointer[
-10:] # adding a missing PTR record
ptr_record_ipv6 = PTRRecord(
IPv6Address("2023", "b", "0", "0", "0", "0", "0", "38",
IPV6_LINK_PREFIX).__str__()[:-4],
sbg_web + f".{DOMAIN}")
self.addDNSZone(name=reverse_domain_name_ipv6,
dns_master=fra_server,
dns_slaves=[rbx_server],
ns_domain_name=DOMAIN,
records=[ptr_record_ipv6])
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+
AS1 | AS4
+-------+ |
| as1r1 +--------+ |
+---+---+ | |
2 | | |
+---+---+ +---+---+ | +-------+
| as1r3 +----+ as1r6 +-------+ as4r1 +--------+
+---+---+ +---+---+ | +-------+ |
| | | |
+---+---+ | | +--+--+ +-------+
| as1r2 | | | | s4 +-----+ as4h1 |
+---+---+ | | +--+--+ +-------+
4 | | | |
+---+---+ +---+---+ | +-------+ |
| as1r4 +----+ as1r5 +-------+ as4r2 +--------+
+-------+ +-------+ | +-------+
|
+
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as1r2 = self.bgp('as1r2')
as1r3 = self.bgp('as1r3')
as1r4 = self.bgp('as1r4')
as1r5 = self.bgp('as1r5',
family=AF_INET6(redistribute=('ospf6', 'connected')))
as1r6 = self.bgp('as1r6',
family=AF_INET6(redistribute=('ospf6', 'connected')))
as4r1 = self.bgp('as4r1',
family=AF_INET6(networks=('dead:beef::/32', )))
as4r2 = self.bgp('as4r2',
family=AF_INET6(networks=('dead:beef::/32', )))
# Add the host and the switch
as4h1 = self.addHost('as4h1')
switch = self.addSwitch('s4')
# Add Links
self.addLink(as1r1, as1r6)
self.addLink(as1r1, as1r3, igp_metric=2)
self.addLinks((as1r3, as1r2), (as1r3, as1r6))
self.addLink(as1r2, as1r4, igp_metric=4)
self.addLinks((as1r4, as1r5), (as1r5, as1r6), (as4r1, as1r6),
(as4r2, as1r5), (as4r1, switch), (as4r2, switch),
(switch, as4h1))
self.addSubnet((as4r1, as4r2, as4h1), subnets=('dead:beef::/32', ))
al = AccessList(name='all', entries=('any', ))
as1r6.get_config(BGP).set_local_pref(99,
from_peer=as4r1,
matching=(al, ))
as1r5.get_config(BGP).set_local_pref(50,
from_peer=as4r2,
matching=(al, ))
# Add full mesh
self.addAS(4, (as4r1, as4r2))
self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
# Add eBGP session
ebgp_session(self, as1r6, as4r1)
ebgp_session(self, as1r5, as4r2)
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
r"""
+-----+ +-----+
+---+as4r | |as3r +---+
| +--+--+ +--+--+ |
| | \ = / = | = | =
| | \ / | |
| | \ / | |
| $ | $ \ | |
| | / \ | |
| | / \ | |
| V / \ | |
| +-----+ +--+--+ |
| |as2r | |as5r | |
| +--+--+ +-----+ |
| | = |
| | |
| | |
| | |
| | |
| +--+--+ |
+-->+as1r +-----------------+
+-----+
"""
# Add all routers
as1r, as2r, as3r, as4r, as5r = self.addRouters('as1r', 'as2r', 'as3r',
'as4r', 'as5r')
routers = self.routers()
prefix = {
routers[i]: '2001:db:%04x::/48' % i
for i in range(len(routers))
}
as1r.addDaemon(
BGP, address_families=(AF_INET6(networks=(prefix[as1r], )), ))
as2r.addDaemon(
BGP, address_families=(AF_INET6(networks=(prefix[as2r], )), ))
as3r.addDaemon(
BGP, address_families=(AF_INET6(networks=(prefix[as3r], )), ))
as4r.addDaemon(
BGP, address_families=(AF_INET6(networks=(prefix[as4r], )), ))
as5r.addDaemon(
BGP, address_families=(AF_INET6(networks=(prefix[as5r], )), ))
# Add links
self.addLinks((as1r, as2r), (as1r, as3r), (as1r, as4r), (as2r, as3r),
(as2r, as4r), (as3r, as5r), (as4r, as5r))
# Set AS-ownerships
self.addAS(1, (as1r, ))
self.addAS(2, (as2r, ))
self.addAS(3, (as3r, ))
self.addAS(4, (as4r, ))
self.addAS(5, (as5r, ))
# Add BGP peering
ebgp_session(self, as1r, as2r, link_type=SHARE)
ebgp_session(self, as1r, as3r, link_type=SHARE)
ebgp_session(self, as2r, as3r, link_type=SHARE)
ebgp_session(self, as3r, as5r, link_type=SHARE)
ebgp_session(self, as4r, as5r, link_type=SHARE)
ebgp_session(self, as4r, as1r, link_type=CLIENT_PROVIDER)
ebgp_session(self, as4r, as2r, link_type=CLIENT_PROVIDER)
# Check extra link parameters
self.check_extra_link()
# Add custom link
if self.as_start is not None:
self.addLink(self.as_start, self.as_end)
ebgp_session(self,
self.as_start,
self.as_end,
link_type=self.bgp_policy)
# Add test hosts
for r in self.routers():
link = self.addLink(r, self.addHost('h%s' % r))
self.addSubnet(links=[link], subnets=[prefix[r]])
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
TODO
+----------+ +--------+
| |
AS1 | AS2 | AS3
| |
| |
+-------+ eBGP | +-------+ iBGP +-------+ | eBGP +-------+
| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+-------+ | +-------+ +-------+ | +-------+
| |
| |
| |
+------------+ +--------+
"""
# Add all routers
as1r1 = self.addRouter('as1r1')
as1r1.addDaemon(
BGP, address_families=(AF_INET6(redistribute=('connected', )), ))
as1r2 = self.addRouter('as1r2')
as1r2.addDaemon(
BGP, address_families=(AF_INET6(redistribute=('connected', )), ))
as1r3 = self.addRouter('as1r3')
as1r3.addDaemon(
BGP, address_families=(AF_INET6(redistribute=('connected', )), ))
as1r4 = self.addRouter('as1r4')
as1r4.addDaemon(
BGP, address_families=(AF_INET6(redistribute=('connected', )), ))
as1r5 = self.addRouter('as1r5')
as1r5.addDaemon(
BGP, address_families=(AF_INET6(redistribute=('connected', )), ))
as1r6 = self.addRouter('as1r6')
as1r6.addDaemon(
BGP, address_families=(AF_INET6(redistribute=('connected', )), ))
as4r1 = self.addRouter('as4r1')
as4r1.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/32', )), ))
as4r2 = self.addRouter('as4r2')
as4r2.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/32', )), ))
as4h1 = self.addHost("as4h1")
# Add Links
self.addLink(as1r1, as1r6)
self.addLink(as1r1, as1r3)
self.addLink(as1r3, as1r2)
self.addLink(as1r3, as1r6)
self.addLink(as1r2, as1r4)
self.addLink(as1r4, as1r5)
self.addLink(as1r5, as1r6)
self.addLink(as4r1, as1r6)
self.addLink(as4r2, as1r5)
self.addLink(as4r1, as4h1)
self.addLink(as4r2, as4h1)
self.addSubnet((as4r1, as4h1), subnets=('dead:beef::/32', ))
self.addSubnet((as4h1, as4r2), subnets=('dead:beef::/32', ))
al = new_access_list(name='all', entries=('any', ))
set_local_pref(self, as1r6, as4r1, 99, filter_list=(al, ))
set_local_pref(self, as1r5, as4r2, 50, filter_list=(al, ))
# Add full mesh
self.addAS(4, (as4r1, as4r2))
self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
# Add eBGP session
ebgp_session(self, as1r6, as4r1)
ebgp_session(self, as1r5, as4r2)
super(BGPTopoLocalPref, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
Topo from slide 23 iBGP
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as1r2 = self.bgp('as1r2')
as1r3 = self.bgp('as1r3')
as1r4 = self.bgp('as1r4')
as1r5 = self.bgp('as1r5')
as1r6 = self.bgp('as1r6')
as4r1 = self.bgp('as4r1')
as4r2 = self.bgp('as4r2')
as5r1 = self.bgp('as5r1')
as3r1 = self.bgp('as3r1')
as2r1 = self.addRouter('as2r1')
as2r1.addDaemon(BGP, address_families=(AF_INET6(networks=('dead:beef::/32',)),))
h1 = self.addHost('h1')
# Add Links
self.addLink(as1r1, as1r6)
self.addLink(as1r1, as1r3)
self.addLink(as1r3, as1r2)
self.addLink(as1r3, as1r6)
self.addLink(as1r2, as1r4)
self.addLink(as1r4, as1r5)
self.addLink(as1r5, as1r6)
self.addLink(as4r1, as1r5)
self.addLink(as4r2, as1r4)
self.addLink(as3r1, as1r1)
self.addLink(as5r1, as1r6)
self.addLink(as3r1, as5r1)
self.addLink(as5r1, as2r1)
self.addLink(as2r1, as4r1)
self.addLink(as4r1, as4r2)
self.addLink(as2r1, h1, params1={"ip": "dead:beef::/48"}, params2={"ip": "dead:beef::1/48"})
# Add full mesh
self.addAS(2, (as2r1,))
self.addAS(3, (as3r1,))
self.addAS(5, (as5r1,))
self.addiBGPFullMesh(4, routers=[as4r1, as4r2])
self.addiBGPFullMesh(1, routers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6])
# Add eBGP session
ebgp_session(self, as1r6, as5r1)
ebgp_session(self, as1r1, as3r1)
ebgp_session(self, as1r4, as4r2)
ebgp_session(self, as1r5, as4r1)
ebgp_session(self, as3r1, as5r1)
ebgp_session(self, as5r1, as2r1)
ebgp_session(self, as2r1, as4r1)
super(SimpleBGPTopoAS, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+-----+ = +-----+
| as2r+-----------------+ as5r|
+--+--+ +--+--+
| \ / |
| \ / |
| \$ /= |
| \ / |
| ⅃ / |
| +-----+ |
|$ | as3r| |$
| +-----+ |
| / \ |
| / \ |
| /= \$ |
| / \ |
v / ⅃ v
+--+--+ $ +--+--+
| as1r+---------------->+ as4r|
+-----+ +-----+
"""
self.register_hosts = True
# Add all routers
as1r = self.bgp('as1r')
as2r = self.bgp('as2r')
as3r = self.bgp('as3r')
as4r = self.bgp('as4r')
as5r = self.bgp('as5r')
self.addLink(as1r,
as2r,
params1={"ip": ("fd00:12::1/64", )},
params2={"ip": ("fd00:12::2/64", )})
self.addLink(as1r,
as3r,
params1={"ip": ("fd00:13::1/64", )},
params2={"ip": ("fd00:13::3/64")})
self.addLink(as1r,
as4r,
params1={"ip": "fd00:14::1/64"},
params2={"ip": "fd00:14::4/64"})
self.addLink(as2r,
as3r,
params1={"ip": ("fd00:23::2/64")},
params2={"ip": ("fd00:23::3/64")})
self.addLink(as2r,
as5r,
params1={"ip": ("fd00:25::2/64")},
params2={"ip": ("fd00:25::5/64")})
self.addLink(as3r,
as4r,
params1={"ip": ("fd00:34::3/64")},
params2={"ip": ("fd00:34::4/64")})
self.addLink(as3r,
as5r,
params1={"ip": ("fd00:35::3/64")},
params2={"ip": ("fd00:35::5/64")})
self.addLink(as4r,
as5r,
params1={"ip": "fd00:45::4/64"},
params2={"ip": "fd00:45::5/64"})
# Set AS-ownerships
self.addAS(1, (as1r, ))
self.addAS(2, (as2r, ))
self.addAS(3, (as3r, ))
self.addAS(4, (as4r, ))
self.addAS(5, (as5r, ))
# Add eBGP peering
ebgp_session(self, as1r, as4r, CLIENT_PROVIDER)
ebgp_session(self, as2r, as1r, CLIENT_PROVIDER)
ebgp_session(self, as2r, as3r, CLIENT_PROVIDER)
ebgp_session(self, as3r, as4r, CLIENT_PROVIDER)
ebgp_session(self, as5r, as4r, CLIENT_PROVIDER)
ebgp_session(self, as1r, as3r, SHARE)
ebgp_session(self, as2r, as5r, SHARE)
ebgp_session(self, as3r, as5r, SHARE)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super(BGPFailure, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
Topo from slide 26 iBGP
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as1r2 = self.bgp('as1r2')
as1r3 = self.bgp('as1r3')
as1r4 = self.bgp('as1r4')
as1r5 = self.bgp('as1r5')
as1r6 = self.bgp('as1r6')
as4r1 = self.bgp('as4r1')
as4r2 = self.bgp('as4r2')
as3r1 = self.bgp('as3r1')
as3r2 = self.bgp('as3r2')
as2r1 = self.addRouter('as2r1')
as2r1.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/32', )), ))
as2h1 = self.addHost("as2h1")
as1h1 = self.addHost("as1h1")
as1h2 = self.addHost("as1h2")
as1h3 = self.addHost("as1h3")
as1h4 = self.addHost("as1h4")
as1h5 = self.addHost("as1h5")
as1h6 = self.addHost("as1h6")
# Add Links
self.addLink(as1r1,
as1r6,
params1={"ip": ("fd00:1:1::1/48", )},
params2={"ip": ("fd00:1:1::2/48", )})
self.addLink(as1r1,
as1r3,
params1={"ip": ("fd00:1:2::1/48", )},
params2={"ip": ("fd00:1:2::2/48", )})
self.addLink(as1r3,
as1r2,
params1={"ip": ("fd00:1:4::1/48", )},
params2={"ip": ("fd00:1:4::2/48", )})
self.addLink(as1r3,
as1r6,
params1={"ip": ("fd00:1:3::1/48", )},
params2={"ip": ("fd00:1:3::2/48", )})
self.addLink(as1r2,
as1r4,
params1={"ip": ("fd00:1:5::1/48", )},
params2={"ip": ("fd00:1:5::2/48", )})
self.addLink(as1r4,
as1r5,
params1={"ip": ("fd00:1:6::1/48", )},
params2={"ip": ("fd00:1:6::2/48", )})
self.addLink(as1r5,
as1r6,
params1={"ip": ("fd00:1:7::1/48", )},
params2={"ip": ("fd00:1:7::2/48", )})
self.addLink(as4r1,
as1r5,
params1={"ip": ("fd00:4:2::1/48", )},
params2={"ip": ("fd00:4:2::2/48", )})
self.addLink(as4r2,
as1r4,
params1={"ip": ("fd00:4:1::1/48", )},
params2={"ip": ("fd00:4:1::2/48", )})
self.addLink(as3r2,
as1r1,
params1={"ip": ("fd00:3:1::1/48", )},
params2={"ip": ("fd00:3:1::2/48", )})
self.addLink(as3r1,
as1r6,
params1={"ip": ("fd00:3:2::1/48", )},
params2={"ip": ("fd00:3:2::2/48", )})
self.addLink(as3r1,
as3r2,
params1={"ip": ("fd00:3:3::1/48", )},
params2={"ip": ("fd00:3:3::2/48", )},
igp_cost=7)
self.addLink(as3r1,
as2r1,
params1={"ip": ("fd00:2:1::1/48", )},
params2={"ip": ("fd00:2:1::2/48", )})
self.addLink(as2r1,
as4r1,
params1={"ip": ("fd00:2:2::1/48", )},
params2={"ip": ("fd00:2:2::2/48", )})
self.addLink(as4r1,
as4r2,
params1={"ip": ("fd00:4:3::1/48", )},
params2={"ip": ("fd00:4:3::2/48", )},
igp_cost=2)
self.addLink(as2r1,
as2h1,
params1={"ip": ("dead:beef::1/32", )},
params2={"ip": ("dead:beef::2/32", )})
self.addLink(as1r1, as1h1)
self.addLink(as1r2, as1h2)
self.addLink(as1r3, as1h3)
self.addLink(as1r4, as1h4)
self.addLink(as1r5, as1h5)
self.addLink(as1r6, as1h6)
# Set Med
al = AccessList(name='all', entries=('any', ))
as3r2.get_config(BGP).set_med(7, to_peer=as1r1, matching=(al, ))
as3r1.get_config(BGP).set_med(0, to_peer=as1r6, matching=(al, ))
as4r1.get_config(BGP).set_med(0, to_peer=as1r5, matching=(al, ))
as4r2.get_config(BGP).set_med(2, to_peer=as1r4, matching=(al, ))
# Add full mesh
self.addAS(2, (as2r1, ))
self.addiBGPFullMesh(3, routers=[as3r1, as3r2])
self.addiBGPFullMesh(4, routers=[as4r1, as4r2])
self.addiBGPFullMesh(
1, routers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6])
# Add eBGP session
ebgp_session(self, as1r6, as3r1)
ebgp_session(self, as1r1, as3r2)
ebgp_session(self, as1r4, as4r2)
ebgp_session(self, as1r5, as4r1)
ebgp_session(self, as3r1, as2r1)
ebgp_session(self, as2r1, as4r1)
super(MedBGPTopo, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+
AS1 | AS3
+----------------------------+
| | |
+---+---+ | +---+---+
| as1r1 +--------+ | | as3r1 |
+---+---+ | | +---+---+
| | | |
2 | | +-------|------------+
| | | | AS5
+---+---+ +---+---+ | +---+---+
| as1r3 +----+ as1r6 +-------+ as5r1 +
+---+---+ +---+---+ | +---+---+
| | | |
| | +-------|------------+
| | | | AS2
+---+---+ | | +---+---+ +---+---+
| as1r2 | | | | as2r1 +----+ as2h1 |
+---+---+ | | +---+---+ +---+---+
| | | |
4 | | +-------|------------+
| | | | AS4
+---+---+ +---+---+ | +---+---+
| as1r4 +----+ as1r5 +-------+ as4r1 +
+---+---+ +-------+ | +---+---+
| | |
| | +---+---+
+------------------------+ as4r2 +
| +-------+
|
+
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as1r2 = self.bgp('as1r2')
as1r3 = self.bgp('as1r3')
as1r4 = self.bgp('as1r4')
as1r5 = self.bgp('as1r5',
family=AF_INET6(redistribute=('ospf6', 'connected')))
as1r6 = self.bgp('as1r6',
family=AF_INET6(redistribute=('ospf6', 'connected')))
as4r1 = self.bgp('as4r1',
family=AF_INET6(redistribute=('ospf6', 'connected')))
as4r2 = self.bgp('as4r2',
family=AF_INET6(redistribute=('ospf6', 'connected')))
as5r1 = self.bgp('as5r1',
family=AF_INET6(redistribute=('connected',)))
as3r1 = self.bgp('as3r1',
family=AF_INET6(redistribute=('connected',)))
as2r1 = self.bgp('as2r1',
family=AF_INET6(networks=('dead:beef::/32',)))
# Add host
as2h1 = self.addHost('as2h1')
# Add Links
self.addLink(as1r1, as1r6)
self.addLink(as1r1, as1r3, igp_metric=2)
self.addLinks((as1r3, as1r2), (as1r3, as1r6))
self.addLink(as1r2, as1r4, igp_metric=4)
self.addLinks((as1r4, as1r5), (as1r5, as1r6), (as4r1, as1r5),
(as4r2, as1r4), (as3r1, as1r1), (as5r1, as1r6),
(as3r1, as5r1), (as5r1, as2r1), (as2r1, as4r1),
(as4r1, as4r2), (as2r1, as2h1))
self.addSubnet((as2r1, as2h1), subnets=('dead:beef::/32',))
set_rr(self, rr=as1r1, peers=[as1r3, as1r2, as1r4, as1r5, as1r6])
set_rr(self, rr=as1r5, peers=[as1r1, as1r2, as1r4, as1r3, as1r6])
# Add full mesh
self.addAS(2, (as2r1,))
self.addAS(3, (as3r1,))
self.addAS(5, (as5r1,))
self.addiBGPFullMesh(4, routers=[as4r1, as4r2])
self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
# Add eBGP session
ebgp_session(self, as1r6, as5r1)
ebgp_session(self, as1r1, as3r1)
ebgp_session(self, as1r4, as4r2)
ebgp_session(self, as1r5, as4r1)
ebgp_session(self, as3r1, as5r1)
ebgp_session(self, as5r1, as2r1)
ebgp_session(self, as2r1, as4r1)
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+-----+ +-----+
+---+as4r | |as3r +---+
| +--+--+ +--+--+ |
| | \ = / = | = | =
| | \ / | |
| | \ / | |
| $ | $ \ | |
| | / \ | |
| | / \ | |
| V / \ | |
| +-----+ +--+--+ |
| |as2r | |as5r | |
| +--+--+ +-----+ |
| | = |
| | |
| | |
| | |
| | |
| +--+--+ |
+-->+as1r +-----------------+
+-----+
"""
list_as_name = ["as1r", "as2r", "as3r", "as4r", "as5r"]
link_type_name = ["SHARE", "CLIENT_PROVIDER"]
link_type_object = [SHARE, CLIENT_PROVIDER]
expected_format = '[AS1] [AS2] [LINK]'
link = input(
"Please enter the link you wish to add or 'ok' to let the network as it is\n"
"To add a link between 2 AS, type '" + expected_format +
"' where\n"
" - [AS1] is the first AS (e.g. 'as1r')\n"
"- [AS2] is the second AS (e.g. "
"'as2r')\n "
" - [LINK] is the type of link, i.e.\n"
" * 'SHARE' for a shared-cost link\n"
" * 'CLIENT_PROVIDER' for a "
"client-provider link\n")
while True:
try:
l, change = check_correct_link(link, list_as_name,
link_type_name)
break
except Exception as e:
link = input("Error: {}\n Try again: '".format(str(e)) +
expected_format + "'\n")
# Add all routers
as1r = self.addRouter('as1r')
as2r = self.addRouter('as2r')
as3r = self.addRouter('as3r')
as4r = self.addRouter('as4r')
as5r = self.addRouter('as5r')
list_as_object = [as1r, as2r, as3r, as4r, as5r]
as1r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:1::/48', )), ))
as2r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:2::/48', )), ))
as3r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:3::/48', )), ))
as4r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:4::/48', )), ))
as5r.addDaemon(
BGP, address_families=(AF_INET6(networks=('2001:db:5::/48', )), ))
# Add links
self.addLink(as1r, as2r)
self.addLink(as1r, as3r)
self.addLink(as1r, as4r)
self.addLink(as2r, as3r)
self.addLink(as2r, as4r)
self.addLink(as3r, as5r)
self.addLink(as4r, as5r)
# Set AS-ownerships
self.addAS(1, (as1r, ))
self.addAS(2, (as2r, ))
self.addAS(3, (as3r, ))
self.addAS(4, (as4r, ))
self.addAS(5, (as5r, ))
# Add BGP peering
ebgp_session(self, as1r, as2r, SHARE)
ebgp_session(self, as1r, as3r, SHARE)
ebgp_session(self, as2r, as3r, SHARE)
ebgp_session(self, as3r, as5r, SHARE)
ebgp_session(self, as4r, as5r, SHARE)
ebgp_session(self, as4r, as1r, CLIENT_PROVIDER)
ebgp_session(self, as4r, as2r, CLIENT_PROVIDER)
# Add custom link
if change:
src_as = None
dst_as = None
link_chosen = None
for i in range(len(list_as_object)):
if l[0] == list_as_name[i]:
src_as = list_as_object[i]
if dst_as is not None:
break
if l[1] == list_as_name[i]:
dst_as = list_as_object[i]
if src_as is not None:
break
for i in range(len(link_type_object)):
if l[2] == link_type_name[i]:
link_chosen = link_type_object[i]
break
self.addLink(src_as, dst_as)
ebgp_session(self, src_as, dst_as, link_chosen)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super(BGPAdjust, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
# Routers AS4
as4r1 = self.bgp('as4r1')
as4r2 = self.bgp('as4r2')
as4r3 = self.bgp('as4r3')
as4r4 = self.bgp('as4r4')
as4r5 = self.bgp('as4r5')
h1 = self.addHost('h1')
# Routers AS3
as3r1 = self.bgp('as3r1')
as3r2 = self.bgp('as3r2')
as3r3 = self.bgp('as3r3')
# Routers AS2
as2r1 = self.bgp('as2r1')
as2r2 = self.bgp('as2r2')
as2r3 = self.bgp('as2r3')
# Routers AS1
as1r1 = self.bgp('as1r1')
as1r2 = self.bgp('as1r2')
as1r3 = self.bgp('as1r3')
as1r4 = self.bgp('as1r4')
as1r5 = self.bgp('as1r5')
h2 = self.addHost('h2')
# Links AS4
self.addLink(as4r1,
as4r5,
params1={"ip": "2001:4:1::1/64"},
params2={"ip": "2001:4:1::5/64"},
igp_metric=5)
self.addLink(as4r2,
as4r5,
params1={"ip": "2001:4:2::2/64"},
params2={"ip": "2001:4:2::5/64"},
igp_metric=5)
self.addLink(as4r3,
as4r5,
params1={"ip": "2001:4:3::3/64"},
params2={"ip": "2001:4:3::5/64"},
igp_metric=5)
self.addLink(as4r4,
as4r5,
params1={"ip": "2001:4:4::4/64"},
params2={"ip": "2001:4:4::5/64"},
igp_metric=5)
self.addLink(as4r5,
h1,
params1={"ip": "dead:beef::/48"},
params2={"ip": "dead:beef::1/48"})
# Links AS3
self.addLink(as3r1,
as3r2,
params1={"ip": "2001:3:1::1/64"},
params2={"ip": "2001:3:1::2/64"},
igp_metric=5)
self.addLink(as3r1,
as3r3,
params1={"ip": "2001:3:2::1/64"},
params2={"ip": "2001:3:2::3/64"},
igp_metric=5)
self.addLink(as3r2,
as3r3,
params1={"ip": "2001:3:3::2/64"},
params2={"ip": "2001:3:3::3/64"},
igp_metric=5)
# Links AS2
self.addLink(as2r1,
as2r2,
params1={"ip": "2001:2:1::1/64"},
params2={"ip": "2001:2:1::2/64"},
igp_metric=15)
self.addLink(as2r1,
as2r3,
params1={"ip": "2001:2:2::1/64"},
params2={"ip": "2001:2:2::3/64"},
igp_metric=5)
# Links AS1
self.addLink(as1r1,
as1r4,
params1={"ip": "2001:1:1::1/64"},
params2={"ip": "2001:1:1::4/64"},
igp_metric=10,
igp_area='1.1.1.1')
self.addLink(as1r1,
as1r5,
params1={"ip": "2001:1:2::1/64"},
params2={"ip": "2001:1:2::5/64"},
igp_metric=2,
igp_area='1.1.1.1')
self.addLink(as1r4,
as1r2,
params1={"ip": "2001:1:4::4/64"},
params2={"ip": "2001:1:4::2/64"},
igp_metric=10,
igp_area='1.1.1.1')
self.addLink(as1r5,
as1r3,
params1={"ip": "2001:1:5::5/64"},
params2={"ip": "2001:1:5::3/64"},
igp_metric=3,
igp_area='1.1.1.1')
self.addLink(as1r1,
h2,
params1={"ip": "cafe:deca::/48"},
params2={"ip": "cafe:deca::2/48"})
# Inter-AS Links
self.addLink(as4r4,
as2r1,
params1={"ip": "2001:4:2::14/64"},
params2={"ip": "2001:4:2::11/64"})
self.addLink(as4r3,
as2r3,
params1={"ip": "2001:4:2::13/64"},
params2={"ip": "2001:4:2::12/64"})
self.addLink(as4r2,
as3r2,
params1={"ip": "2001:4:3::12/64"},
params2={"ip": "2001:4:3::13/64"})
self.addLink(as4r1,
as3r1,
params1={"ip": "2001:4:3::14/64"},
params2={"ip": "2001:4:3::15/64"})
self.addLink(as3r3,
as1r3,
params1={"ip": "2001:3:1::13/64"},
params2={"ip": "2001:3:1::11/64"})
self.addLink(as2r2,
as1r2,
params1={"ip": "2001:2:1::12/64"},
params2={"ip": "2001:2:1::11/64"})
self.addLink(as2r3,
as1r3,
params1={"ip": "2001:2:1::13/64"},
params2={"ip": "2001:2:1::14/64"},
igp_metric=4)
#filter
al_filter = AccessList(name='all', entries=('dead:beef::1/48', ))
as4r2.get_config(BGP).filter('h1filter',
to_peer=as3r2,
matching=(al_filter, ))
as4r1.get_config(BGP).filter('h1filter',
to_peer=as3r1,
matching=(al_filter, ))
# Set AS-ownerships
self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5))
self.addAS(2, (as2r1, as2r2, as2r3))
self.addAS(3, (as3r1, as3r2, as3r3))
self.addAS(4, (as4r1, as4r2, as4r3, as4r4, as4r5))
# Add iBGP full mesh
self.addiBGPFullMesh(1, routers=[as1r1, as1r2, as1r3, as1r4, as1r5])
self.addiBGPFullMesh(2, routers=[as2r1, as2r2, as2r3])
self.addiBGPFullMesh(3, routers=[as3r1, as3r2, as3r3])
self.addiBGPFullMesh(4, routers=[as4r1, as4r2, as4r3, as4r4, as4r5])
# Add eBGP session
ebgp_session(self, as4r4, as2r1)
ebgp_session(self, as4r3, as2r3)
ebgp_session(self, as4r2, as3r2)
ebgp_session(self, as4r1, as3r1)
ebgp_session(self, as3r3, as1r3)
ebgp_session(self, as2r2, as1r2)
ebgp_session(self, as2r3, as1r3)
super(BGP_FilterOut, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+-------+ $
| as1r1 +-------------+
+---+---+ |
| = |
+-------|--------+ |
| AS2 | v
+---+---+ | $ +---+---+
| as2r1 +-------->+ as5r1 |
+---+---+ | +--++---+
| | ^^
+---+---+ | ||
| as2r2 | | ||
+---+---+ | ||
| | $ || $
+-------|--------+ ||
| = ||
+---+---+ ||
| as3r1 +------------+|
+---+---+ |
| = |
+---+---+ |
| as4r1 +-------------+
+-------+
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as2r1 = self.bgp('as2r1')
as2r2 = self.bgp('as2r2')
as3r1 = self.bgp('as3r1')
as4r1 = self.bgp('as4r1')
as5r1 = self.bgp('as5r1')
self.addLinks((as1r1, as2r1), (as2r1, as2r2), (as3r1, as2r2),
(as3r1, as4r1), (as5r1, as1r1), (as5r1, as2r1),
(as5r1, as3r1), (as5r1, as4r1))
# Set AS-ownerships
self.addAS(1, (as1r1, ))
self.addiBGPFullMesh(2, (as2r1, as2r2))
self.addAS(3, (as3r1, ))
self.addAS(4, (as4r1, ))
self.addAS(5, (as5r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1, link_type=SHARE)
ebgp_session(self, as3r1, as2r2, link_type=SHARE)
ebgp_session(self, as3r1, as4r1, link_type=SHARE)
ebgp_session(self, as1r1, as5r1, link_type=CLIENT_PROVIDER)
ebgp_session(self, as2r1, as5r1, link_type=CLIENT_PROVIDER)
ebgp_session(self, as3r1, as5r1, link_type=CLIENT_PROVIDER)
ebgp_session(self, as4r1, as5r1, link_type=CLIENT_PROVIDER)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super().build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
+----------+ +--------+
| |
AS1 | AS2 | AS3
| |
| |
+-------+ eBGP | +-------+ iBGP +-------+ | eBGP +-------+
| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+-------+ | +-------+ +-------+ | +-------+
| |
| |
| |
+------------+ +--------+
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as2r1 = self.bgp('as2r1')
as2r2 = self.bgp('as2r2')
as3r1 = self.bgp('as3r1')
as4r1 = self.bgp('as4r1')
as5r1 = self.bgp('as5r1')
self.addLink(as1r1, as2r1)
self.addLink(as2r1, as2r2)
self.addLink(as3r1, as2r2)
self.addLink(as3r1, as4r1)
self.addLink(as5r1, as1r1)
self.addLink(as5r1, as2r1)
self.addLink(as5r1, as3r1)
self.addLink(as5r1, as4r1)
# Set AS-ownerships
self.addAS(1, (as1r1, ))
self.addiBGPFullMesh(2, (as2r1, as2r2))
self.addAS(3, (as3r1, ))
self.addAS(4, (as4r1, ))
self.addAS(5, (as5r1, ))
# Add eBGP peering
ebgp_session(self, as1r1, as2r1, SHARE)
ebgp_session(self, as3r1, as2r2, SHARE)
ebgp_session(self, as3r1, as4r1, SHARE)
ebgp_session(self, as1r1, as5r1, CLIENT_PROVIDER)
ebgp_session(self, as2r1, as5r1, CLIENT_PROVIDER)
ebgp_session(self, as3r1, as5r1, CLIENT_PROVIDER)
ebgp_session(self, as4r1, as5r1, CLIENT_PROVIDER)
# Add test hosts
for r in self.routers():
self.addLink(r, self.addHost('h%s' % r))
super(SimpleBGPASTopo, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
Topo from slide 42 iBGP RED config
"""
# Add all routers
as1r1 = self.bgp('as1r1')
as1r2 = self.bgp('as1r2')
as1r3 = self.bgp('as1r3')
as1r4 = self.bgp('as1r4')
as1r5 = self.bgp('as1r5')
as1r6 = self.bgp('as1r6')
as4r1 = self.bgp('as4r1')
as4r2 = self.bgp('as4r2')
as5r1 = self.bgp('as5r1')
as3r1 = self.bgp('as3r1')
as2r1 = self.addRouter('as2r1')
as2r1.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/32', )), ))
as2h1 = self.addHost("as2h1")
as1h1 = self.addHost("as1h1")
as1h2 = self.addHost("as1h2")
as1h3 = self.addHost("as1h3")
as1h4 = self.addHost("as1h4")
as1h5 = self.addHost("as1h5")
as1h6 = self.addHost("as1h6")
# Add Links
self.addLink(as1r1, as1r6)
self.addLink(as1r1, as1r3)
self.addLink(as1r3, as1r2)
self.addLink(as1r3, as1r6)
self.addLink(as1r2, as1r4)
self.addLink(as1r4, as1r5)
self.addLink(as1r5, as1r6)
self.addLink(as4r1, as1r5)
self.addLink(as4r2, as1r4)
self.addLink(as3r1, as1r1)
self.addLink(as5r1, as1r6)
self.addLink(as3r1, as5r1)
self.addLink(as5r1, as2r1)
self.addLink(as2r1, as4r1)
self.addLink(as4r1, as4r2)
self.addLink(as2r1, as2h1)
self.addSubnet((as2r1, as2h1), subnets=('dead:beef::/32', ))
self.addLink(as1r1, as1h1)
self.addLink(as1r2, as1h2)
self.addLink(as1r3, as1h3)
self.addLink(as1r4, as1h4)
self.addLink(as1r5, as1h5)
self.addLink(as1r6, as1h6)
set_rr(self, rr=as1r1, peers=[as1r3, as1r2, as1r4, as1r5, as1r6])
set_rr(self, rr=as1r5, peers=[as1r1, as1r2, as1r4, as1r3, as1r6])
# Add full mesh
self.addAS(2, (as2r1, ))
self.addAS(3, (as3r1, ))
self.addAS(5, (as5r1, ))
self.addiBGPFullMesh(4, routers=[as4r1, as4r2])
self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
# Add eBGP session
ebgp_session(self, as1r6, as5r1)
ebgp_session(self, as1r1, as3r1)
ebgp_session(self, as1r4, as4r2)
ebgp_session(self, as1r5, as4r1)
ebgp_session(self, as3r1, as5r1)
ebgp_session(self, as5r1, as2r1)
ebgp_session(self, as2r1, as4r1)
super(BGPTopo2RR2, self).build(*args, **kwargs)
def build(self, *args, **kwargs):
"""
Topo from slide 30 iBGP
"""
# Add all routers
as1r1 = self.addRouter('as1r1')
as1r1.addDaemon(BGP,
address_families=(AF_INET6(networks=('1:1::/48', )), ))
as1r2 = self.addRouter('as1r2')
as1r2.addDaemon(BGP,
address_families=(AF_INET6(networks=('1:1::/48', )), ))
as1r3 = self.addRouter('as1r3')
as1r3.addDaemon(BGP,
address_families=(AF_INET6(networks=('1:1::/48', )), ))
as1r4 = self.addRouter('as1r4')
as1r4.addDaemon(BGP,
address_families=(AF_INET6(networks=('1:1::/48', )), ))
as2r1 = self.addRouter('as2r1')
as2r1.addDaemon(
BGP, address_families=(AF_INET6(networks=('dead:beef::/48', )), ))
h1 = self.addHost('h1')
as3r1 = self.addRouter('as3r1')
as3r1.addDaemon(
BGP, address_families=(AF_INET6(networks=('beef:dead::/48', )), ))
as3r2 = self.addRouter('as3r2')
as3r2.addDaemon(
BGP, address_families=(AF_INET6(networks=('beef:dead::/48', )), ))
h2 = self.addHost('h2')
# Add links
self.addLink(as1r1, as1r2)
self.addLink(as1r1, as1r3)
self.addLink(as1r3, as1r4)
self.addLink(as1r2, as1r4)
self.addLink(as1r3, as2r1)
self.addLink(as1r2, as3r1)
self.addLink(as3r1, as3r2)
self.addLink(as3r2, as2r1)
self.addLink(as2r1,
h1,
params1={"ip": "dead:beef::/48"},
params2={"ip": "dead:beef::1/48"})
self.addLink(as3r1,
h2,
params1={"ip": "dead:beef::4/48"},
params2={"ip": "dead:beef::5/48"})
self.addLink(as3r2,
h2,
params1={"ip": "dead:beef::2/48"},
params2={"ip": "dead:beef::3/48"})
# Add AS and fullmeshes
self.addAS(2, (as2r1, ))
self.addiBGPFullMesh(1, routers=[as1r1, as1r2, as1r3, as1r4])
self.addiBGPFullMesh(3, routers=[as3r1, as3r2])
# Add eBGP sessions
ebgp_session(self, as1r2, as3r1)
ebgp_session(self, as3r2, as2r1)
ebgp_session(self, as2r1, as1r3)
super(SimpleBGPTopoRoutes, self).build(*args, **kwargs)
