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)