diff --git a/launch_net.py b/launch_net.py
index 200ddcf..7bdd8ca 100644
--- a/launch_net.py
+++ b/launch_net.py
@@ -2,14 +2,78 @@
 import ipmininet
 from ipmininet.ipnet import IPNet
 from ipmininet.cli import IPCLI
+from mininet.log import lg, LEVELS
 
-importlib.import_module('simple_bgp_network')
+from simple_bgp_network import SimpleBGPTopo
+from simple_topo_2rr import SimpleBGPTopo2RR
+from simple_topo_as import SimpleBGPTopoAS
 from simple_topo_err import SimpleBGPTopoErr
+from simple_topo_local_pref import SimpleBGPTopoLocalPref
+from simple_topo_med import SimpleBGPTopoMed
+from simple_topo_missing1 import SimpleBGPTopoMissing1
+from simple_topo_missing2 import SimpleBGPTopoMissing2
+from simple_topo_missing3 import SimpleBGPTopoMissing3
+from simple_topo import SimpleBGPTopo
+from simple_topo_routes import SimpleBGPTopoRoutes
+from simple_topo_rr import SimpleBGPTopoRR
+from topo_2rr_1 import BGPTopo2RR1
+from topo_2rr_2 import BGPTopo2RR2
+from topo_2rr_3 import BGPTopo2RR3
+from topo_2rr_4 import BGPTopo2RR4
+from topo_2rr_5 import BGPTopo2RR5
+from topo_3rr_1 import BGPTopo3RR1
+from topo_3rr_2 import BGPTopo3RR2
+from topo_3rr_3 import BGPTopo3RR3
+from topo_med import MedBGPTopo
+from topo_te_1 import BGPTopoTE1
+from topo_te_2 import BGPTopoTE2
 
-net = IPNet(topo=SimpleBGPTopoErr())
-ipmininet.DEBUG_FLAG = True
-try:
-	net.start()
-	IPCLI(net)
-finally:
-	net.stop()
+import argparse
+
+TOPOS = {'simple_bgp_network': SimpleBGPTopo,
+         'simple_topo_2rr': SimpleBGPTopo2RR,
+         'simple_topo_as': SimpleBGPTopoAS,
+         'simple_topo_err': SimpleBGPTopoErr,
+         'simple_topo_local_pref': SimpleBGPTopoLocalPref,
+         'simple_topo_med': SimpleBGPTopoMed,
+         'simple_topo_missing1': SimpleBGPTopoMissing1,
+         'simple_topo_missing2': SimpleBGPTopoMissing2,
+         'simple_topo_missing3': SimpleBGPTopoMissing3,
+         'simple_topo': SimpleBGPTopo,
+         'simple_topo_rr': SimpleBGPTopoRR,
+         'topo_2rr_1': BGPTopo2RR1,
+         'topo_2rr_2': BGPTopo2RR2,
+         'topo_2rr_3': BGPTopo2RR3,
+         'topo_2rr_4': BGPTopo2RR4,
+         'topo_2rr_5': BGPTopo2RR5,
+         'topo_med': MedBGPTopo,
+         'topo_te_1': BGPTopoTE1,
+         'simple_topo_routes': SimpleBGPTopoRoutes,
+         'topo_3rr_1': BGPTopo3RR1,
+         'topo_3rr_2': BGPTopo3RR2,
+         'topo_3rr_3': BGPTopo3RR3,
+         'topo_te_2': BGPTopoTE2
+         }
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--topo', choices=TOPOS.keys(), default='simple_bgp_network',
+                        help='the topology that you want to start')
+    parser.add_argument('--log', choices=LEVELS.keys(), default='info',
+                        help='The level of details in the logs')
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    lg.setLogLevel(args.log)
+    if args.log == 'debug':
+        ipmininet.DEBUG_FLAG = True
+    kwargs = {}
+    net = IPNet(topo=TOPOS[args.topo](**kwargs))
+    try:
+        net.start()
+        IPCLI(net)
+    finally:
+        net.stop()
diff --git a/simple_bgp_network.py b/simple_bgp_network.py
index b1c2922..b3d9a1c 100644
--- a/simple_bgp_network.py
+++ b/simple_bgp_network.py
@@ -45,7 +45,7 @@ def build(self, *args, **kwargs):
         super(SimpleBGPTopo, self).build(*args, **kwargs)
 
     def bgp(self, name):
-        r = self.addRouter(name, config=RouterConfig)
+        r = self.addRouter(name)
         r.addDaemon(BGP, address_families=(
             _bgp.AF_INET(redistribute=('connected',)),
             _bgp.AF_INET6(redistribute=('connected',))))
diff --git a/simple_topo.py b/simple_topo.py
index 82ed24e..9c93bf3 100644
--- a/simple_topo.py
+++ b/simple_topo.py
@@ -4,10 +4,10 @@
 
 
 class SimpleBGPTopo(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO
            +----------+                                   +--------+
                       |                                   |
@@ -22,51 +22,48 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        # 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=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as4r2 = self.addRouter('as4r2')
+        as4r2.addDaemon(BGP, address_families=(_bgp.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, as1r6)
-		self.addLink(as4r2, as1r5)
+        # 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"})
 
-		# Add full mesh
-		self.addAS(4, (as4r1, as4r2))
-		self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
+        # 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)
+        # Add eBGP session
+        ebgp_session(self, as1r6, as4r1)
+        ebgp_session(self, as1r5, as4r2)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopo, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopo, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_2rr.py b/simple_topo_2rr.py
index 4c7de6f..fcd251a 100644
--- a/simple_topo_2rr.py
+++ b/simple_topo_2rr.py
@@ -1,12 +1,13 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
 class SimpleBGPTopo2RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 39 iBGP
            +----------+                                   +--------+
                       |                                   |
@@ -21,53 +22,50 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        # 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=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as4r2 = self.addRouter('as4r2')
+        as4r2.addDaemon(BGP, address_families=(_bgp.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, 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])
+        set_rr(self, as1r5, peers=[as1r1, as1r2, as1r4, as1r3, as1r6])
 
-		# 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)
-		set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
-		set_rr(self, as1r5, peers=[as1r1, as1r2, as1r4, as1r3, as1r6])
+        # Add full mesh
+        self.addAS(4, (as4r1, as4r2))
+        self.addAS(1, (as1r1, as1r2, as1r3, 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)
+        # Add eBGP session
+        ebgp_session(self, as1r6, as4r1)
+        ebgp_session(self, as1r5, as4r2)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopo2RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopo2RR, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_as.py b/simple_topo_as.py
index e3fbc13..f293663 100644
--- a/simple_topo_as.py
+++ b/simple_topo_as.py
@@ -4,10 +4,10 @@
 
 
 class SimpleBGPTopoAS(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 23 iBGP
            +----------+                                   +--------+
                       |                                   |
@@ -22,71 +22,63 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        # 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=(_bgp.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)
+        # 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 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoAS, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoAS, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_err.py b/simple_topo_err.py
index 4e24155..4eaf234 100644
--- a/simple_topo_err.py
+++ b/simple_topo_err.py
@@ -4,10 +4,10 @@
 
 
 class SimpleBGPTopoErr(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 27 BGP-RR-TE
            +----------+                                   +--------+
                       |                                   |
@@ -22,57 +22,53 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as6r1 = self.addRouter('as6r1')
-		as6r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as6r2 = self.addRouter('as6r2')
-		as6r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		h1 = self.addHost('h1')
-		h2 = self.addHost('h2')
-		h3 = self.addHost('h3')
-		h4 = self.addHost('h4')
+        # 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=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as6r2 = self.addRouter('as6r2')
+        as6r2.addDaemon(BGP, address_families=(_bgp.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:1::/48"}, params2={"ip": "dead:beef:1:1::/48"})
-		self.addLink(as6r2, h2, params1={"ip": "dead:beef:1:2::/48"}, params2={"ip": "dead:beef:1:3::/48"})
-		self.addLink(as1r5, h3)
-		self.addLink(as1r6, h4)
-		_bgp.set_rr(self, as1r1, peers=[as1r3, as1r5])
-		_bgp.set_rr(self, as1r3, peers=[as1r1, as1r6])
+        # 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)
+        _bgp.set_rr(self, as1r1, peers=[as1r3, as1r5])
+        _bgp.set_rr(self, as1r3, peers=[as1r1, as1r6])
 
-		# Add full mesh
-		self.addAS(6, (as6r1, as6r2))
-		self.addAS(1, (as1r1, as1r3, as1r5, as1r6))
-		bgp_peering(self, as1r1, as1r5)
-		bgp_peering(self, as1r3, as1r6)
-		bgp_peering(self, as1r1, as1r3)
+        # Add full mesh
+        self.addAS(6, (as6r1, as6r2))
+        self.addAS(1, (as1r1, as1r3, as1r5, as1r6))
+        bgp_peering(self, as1r1, as1r5)
+        bgp_peering(self, as1r3, as1r6)
+        bgp_peering(self, as1r1, as1r3)
 
-		# Add eBGP session
-		ebgp_session(self, as1r1, as6r1)
-		ebgp_session(self, as1r3, as6r2)
+        # Add eBGP session
+        ebgp_session(self, as1r1, as6r1)
+        ebgp_session(self, as1r3, as6r2)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoErr, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoErr, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_local_pref.py b/simple_topo_local_pref.py
index 6382137..de7d0b3 100644
--- a/simple_topo_local_pref.py
+++ b/simple_topo_local_pref.py
@@ -1,45 +1,39 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, set_local_pref, new_access_list
-
+import ipmininet.router.config.bgp as _bgp
 
 
 class SimpleBGPTopoLocalPref(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as4h1 = self.addHost("as4h1")
+	TODO
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as4r2 = self.addRouter('as4r2')
+        as4r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as4h1 = self.addHost("as4h1")
         as1h1 = self.addHost("as1h1")
         as1h2 = self.addHost("as1h2")
         as1h3 = self.addHost("as1h3")
@@ -47,28 +41,28 @@ def build(self, *args, **kwargs):
         as1h5 = self.addHost("as1h5")
         as1h6 = self.addHost("as1h6")
 
-		# Add Links
-		self.addLink(as1r1, as1r6, params1={"ip": ("fd00:1:1::1/48",)},
+        # 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",)},
+        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:3:1::1/48",)},
+        self.addLink(as1r3, as1r2, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as1r3, as1r6, params1={"ip": ("fd00:3:2::1/48",)},
+        self.addLink(as1r3, as1r6, params1={"ip": ("fd00:3:2::1/48",)},
                      params2={"ip": ("fd00:3:2::2/48",)})
-		self.addLink(as1r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
+        self.addLink(as1r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as1r4, as1r5, params1={"ip": ("fd00:4:2::1/48",)},
+        self.addLink(as1r4, as1r5, params1={"ip": ("fd00:4:2::1/48",)},
                      params2={"ip": ("fd00:4:2::2/48",)})
-		self.addLink(as1r5, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as1r5, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as4r1, as1r6; params1={"ip": ("fd00:6:1::1/48",)},
+        self.addLink(as4r1, as1r6, params1={"ip": ("fd00:6:1::1/48",)},
                      params2={"ip": ("fd00:6:1::2/48",)})
-		self.addLink(as4r2, as1r5, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as4r2, as1r5, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as4r1, as4h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as4r1, as4h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
-		self.addLink(as4r2, as4h1, params1={"ip": ("dead:beef::2/32",)},
+        self.addLink(as4r2, as4h1, params1={"ip": ("dead:beef::2/32",)},
                      params2={"ip": ("dead:beef::1/32",)})
         self.addLink(as1r1, as1h1)
         self.addLink(as1r2, as1h2)
@@ -77,28 +71,26 @@ def build(self, *args, **kwargs):
         self.addLink(as1r5, as1h5)
         self.addLink(as1r6, as1h6)
 
+        new_access_list(self, (as1r6, as1r5), 'all', ('any',))
+        set_local_pref(self, as1r6, as4r1, 99, filter_type='access-list', filter_names=('all',))
+        set_local_pref(self, as1r5, as4r2, 50, filter_type='access-list', filter_names=('all',))
 
-		new_access_list(self, (as1r6, as1r5, as2r1, as2r2), 'all', ('any',))
-		set_local_pref(self, as1r6, as4r1, 99, filter_type='access-list', filter_names=('all',))
-		set_local_pref(self, as1r5, as4r2, 50, filter_type='access-list', filter_names=('all',))
-
-
-		# Add full mesh
-		self.addAS(4, (as4r1, as4r2))
-		self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
+        # 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)
+        # Add eBGP session
+        ebgp_session(self, as1r6, as4r1)
+        ebgp_session(self, as1r5, as4r2)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoLocalPref, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoLocalPref, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_med.py b/simple_topo_med.py
index 487692c..560e6e2 100644
--- a/simple_topo_med.py
+++ b/simple_topo_med.py
@@ -1,45 +1,39 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, set_med, new_access_list
-
+import ipmininet.router.config.bgp as _bgp
 
 
 class SimpleBGPTopoMed(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 25 iBGP
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as4h1 = self.addHost("as4h1")
+	TODO slide 25 iBGP
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as4r2 = self.addRouter('as4r2')
+        as4r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as4h1 = self.addHost("as4h1")
         as1h1 = self.addHost("as1h1")
         as1h2 = self.addHost("as1h2")
         as1h3 = self.addHost("as1h3")
@@ -47,28 +41,28 @@ def build(self, *args, **kwargs):
         as1h5 = self.addHost("as1h5")
         as1h6 = self.addHost("as1h6")
 
-		# Add Links
-		self.addLink(as1r1, as1r6, params1={"ip": ("fd00:1:1::1/48",)},
+        # 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",)},
+        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:3:1::1/48",)},
+        self.addLink(as1r3, as1r2, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as1r3, as1r6, params1={"ip": ("fd00:3:2::1/48",)},
+        self.addLink(as1r3, as1r6, params1={"ip": ("fd00:3:2::1/48",)},
                      params2={"ip": ("fd00:3:2::2/48",)})
-		self.addLink(as1r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
+        self.addLink(as1r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as1r4, as1r5, params1={"ip": ("fd00:4:2::1/48",)},
+        self.addLink(as1r4, as1r5, params1={"ip": ("fd00:4:2::1/48",)},
                      params2={"ip": ("fd00:4:2::2/48",)})
-		self.addLink(as1r5, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as1r5, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as4r1, as1r6; params1={"ip": ("fd00:6:1::1/48",)},
+        self.addLink(as4r1, as1r6, params1={"ip": ("fd00:6:1::1/48",)},
                      params2={"ip": ("fd00:6:1::2/48",)})
-		self.addLink(as4r2, as1r5, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as4r2, as1r5, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as4r1, as4h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as4r1, as4h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
-		self.addLink(as4r2, as4h1, params1={"ip": ("dead:beef::2/32",)},
+        self.addLink(as4r2, as4h1, params1={"ip": ("dead:beef::2/32",)},
                      params2={"ip": ("dead:beef::1/32",)})
         self.addLink(as1r1, as1h1)
         self.addLink(as1r2, as1h2)
@@ -76,27 +70,27 @@ def build(self, *args, **kwargs):
         self.addLink(as1r4, as1h4)
         self.addLink(as1r5, as1h5)
         self.addLink(as1r6, as1h6)
-		
-		new_access_list(self, (as1r6, as1r5, as2r1, as2r2), 'all', ('any',))
-		set_med(self, as4r1, as1r6, 99, filter_type='access-list', filter_names=('all',))
-		set_med(self, as4r2, as1r5, 50, filter_type='access-list', filter_names=('all',))
 
-		# Add full mesh
-		self.addAS(4, (as4r1, as4r2))
-		self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
+        new_access_list(self, (as1r6, as1r5, as4r1, as4r2), 'all', ('any',))
+        set_med(self, as4r1, as1r6, 99, filter_type='access-list', filter_names=('all',))
+        set_med(self, as4r2, as1r5, 50, filter_type='access-list', filter_names=('all',))
+
+        # 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)
+        # Add eBGP session
+        ebgp_session(self, as1r6, as4r1)
+        ebgp_session(self, as1r5, as4r2)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoMed, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoMed, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_missing1.py b/simple_topo_missing1.py
new file mode 100644
index 0000000..24fa040
--- /dev/null
+++ b/simple_topo_missing1.py
@@ -0,0 +1,82 @@
+from ipmininet.iptopo import IPTopo
+from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering
+import ipmininet.router.config.bgp as _bgp
+
+
+class SimpleBGPTopoMissing1(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
+
+    def build(self, *args, **kwargs):
+        """
+	TODO slide 33 iBGP
+           +----------+                                   +--------+
+                      |                                   |
+         AS1          |                  AS2              |        AS3
+                      |                                   |
+                      |                                   |
+    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+    +-------+         |  +-------+             +-------+  |         +-------+
+                      |                                   |
+                      |                                   |
+                      |                                   |
+         +------------+                                   +--------+
+        """
+        # Add all routers
+        as1r1 = self.bgp('as1r1')
+
+        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=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        h1 = self.addHost('h1')
+
+        # Add Links
+        self.addLink(as1r1, as1r6)
+        self.addLink(as1r1, as1r4, igp_cost=7)
+        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.addAS(1, (as1r1, as1r4, as1r5, as1r6))
+        bgp_peering(self, as1r1, as1r5)
+        bgp_peering(self, as1r1, as1r4)
+        bgp_peering(self, as1r4, as1r5)
+
+        # Add eBGP session
+        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)
+
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoMissing1, self).build(*args, **kwargs)
+
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_missing2.py b/simple_topo_missing2.py
index 9265e5c..a2a6289 100644
--- a/simple_topo_missing2.py
+++ b/simple_topo_missing2.py
@@ -3,11 +3,11 @@
 import ipmininet.router.config.bgp as _bgp
 
 
-class SimpleBGPTopoMissing(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class SimpleBGPTopoMissing2(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 33 iBGP
            +----------+                                   +--------+
                       |                                   |
@@ -22,68 +22,62 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
+        # Add all routers
+        as1r1 = self.bgp('as1r1')
 
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        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=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        h1 = self.addHost('h1')
 
-		# Add Links
-		self.addLink(as1r1, as1r6)
-		self.addLink(as1r1, 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)
+        # Add Links
+        self.addLink(as1r1, as1r6)
+        self.addLink(as1r1, 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.addAS(1, (as1r1, as1r4, as1r5, as1r6))
-		bgp_peering(self, as1r1, as1r6)
-		bgp_peering(self, as1r6, as1r4)
-		bgp_peering(self, as1r4, as1r5)
-		bgp_peering(self, as1r6, as1r5)
+        # 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, as1r4, as1r5, as1r6))
+        bgp_peering(self, as1r1, as1r6)
+        bgp_peering(self, as1r6, as1r4)
+        bgp_peering(self, as1r4, as1r5)
+        bgp_peering(self, as1r6, as1r5)
 
-		# Add eBGP session
-		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)
+        # Add eBGP session
+        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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoMissing, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoMissing2, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_missing3.py b/simple_topo_missing3.py
index aac3741..7a0ea17 100644
--- a/simple_topo_missing3.py
+++ b/simple_topo_missing3.py
@@ -3,11 +3,11 @@
 import ipmininet.router.config.bgp as _bgp
 
 
-class SimpleBGPTopoMissing(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class SimpleBGPTopoMissing3(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 33 iBGP
            +----------+                                   +--------+
                       |                                   |
@@ -22,68 +22,62 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
+        # Add all routers
+        as1r1 = self.bgp('as1r1')
 
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        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=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        h1 = self.addHost('h1')
 
-		# Add Links
-		self.addLink(as1r1, as1r6)
-		self.addLink(as1r1, 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)
+        # Add Links
+        self.addLink(as1r1, as1r6)
+        self.addLink(as1r1, 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.addAS(1, (as1r1, as1r4, as1r5, as1r6))
-		bgp_peering(self, as1r1, as1r6)
-		bgp_peering(self, as1r1, as1r4)
-		bgp_peering(self, as1r4, as1r5)
-		bgp_peering(self, as1r6, as1r5)
+        # 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, as1r4, as1r5, as1r6))
+        bgp_peering(self, as1r1, as1r6)
+        bgp_peering(self, as1r1, as1r4)
+        bgp_peering(self, as1r4, as1r5)
+        bgp_peering(self, as1r6, as1r5)
 
-		# Add eBGP session
-		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)
+        # Add eBGP session
+        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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoMissing, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoMissing3, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_missiong1.py b/simple_topo_missiong1.py
deleted file mode 100644
index 63ccc46..0000000
--- a/simple_topo_missiong1.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from ipmininet.iptopo import IPTopo
-from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering
-import ipmininet.router.config.bgp as _bgp
-
-
-class SimpleBGPTopoMissing(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
-
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 33 iBGP
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
-        """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
-
-		# Add Links
-		self.addLink(as1r1, as1r6)
-		self.addLink(as1r1, as1r4, igp_cost=7)
-		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)
-
-		# 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, as1r4, as1r5, as1r6))
-		bgp_peering(self, as1r1, as1r5)
-		bgp_peering(self, as1r1, as1r4)
-		bgp_peering(self, as1r4, as1r5)
-
-		# Add eBGP session
-		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)
-
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoMissing, self).build(*args, **kwargs)
-
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
diff --git a/simple_topo_routes.py b/simple_topo_routes.py
index aa7edda..c399540 100644
--- a/simple_topo_routes.py
+++ b/simple_topo_routes.py
@@ -4,10 +4,10 @@
 
 
 class SimpleBGPTopoRoutes(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 30 iBGP
            +----------+                                   +--------+
                       |                                   |
@@ -22,50 +22,55 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('beef:dead::/48',)),))
-		as3r2 = self.addRouter('as3r2')
-		as3r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('beef:dead::/48',)),))
+        # Add all routers
+        as1r1 = self.addRouter('as1r1')
+        as1r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
+        as1r2 = self.addRouter('as1r2')
+        as1r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
+        as1r3 = self.addRouter('as1r3')
+        as1r3.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
+        as1r4 = self.addRouter('as1r4')
+        as1r4.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('1:1::/48',)),))
+        as2r1 = self.addRouter('as2r1')
+        as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        h1 = self.addHost('h1')
+        as3r1 = self.addRouter('as3r1')
+        as3r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('beef:dead::/48',)),))
+        as3r2 = self.addRouter('as3r2')
+        as3r2.addDaemon(BGP, address_families=(_bgp.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)
+        # 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 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)
+        # Add eBGP sessions
+        ebgp_session(self, as1r2, as3r1)
+        ebgp_session(self, as3r2, as2r1)
+        ebgp_session(self, as2r1, as1r3)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoRoutes, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoRoutes, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/simple_topo_rr.py b/simple_topo_rr.py
index c57b199..04b8d28 100644
--- a/simple_topo_rr.py
+++ b/simple_topo_rr.py
@@ -1,12 +1,13 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
 class SimpleBGPTopoRR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 38 iBGP
            +----------+                                   +--------+
                       |                                   |
@@ -21,52 +22,49 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        # 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=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        as4r2 = self.addRouter('as4r2')
+        as4r2.addDaemon(BGP, address_families=(_bgp.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)
-		set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
+        # 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 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)
+        # Add eBGP session
+        ebgp_session(self, as1r6, as4r1)
+        ebgp_session(self, as1r5, as4r2)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(SimpleBGPTopoRR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(SimpleBGPTopoRR, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_2rr_1.py b/topo_2rr_1.py
index f2a7f0c..61556a2 100644
--- a/topo_2rr_1.py
+++ b/topo_2rr_1.py
@@ -3,125 +3,114 @@
 import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo2RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo2RR1(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 40 iBGP
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as2h1 = self.addHost("as2h1")
-		as1h1 = self.addHost("as1h1")
+	TODO slide 40 iBGP
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.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",)},
+        # 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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        self.addLink(as4r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
+        self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as5r1, as1r6; params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as5r1, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as5r1, as2r1, params1={"ip": ("fd00:2:1::1/48",)},
+        self.addLink(as5r1, 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",)},
+        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",)},
+        self.addLink(as4r1, as4r2, params1={"ip": ("fd00:4:3::1/48",)},
                      params2={"ip": ("fd00:4:3::2/48",)})
-		self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
 
-		self.addLink(as1r1, as1h1)
+        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, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
+        set_rr(self, as1r5, peers=[as1r1, as1r2, as1r4, as1r3, as1r6])
 
-		set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
-		set_rr(self, 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 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo2RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo2RR1, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_2rr_2.py b/topo_2rr_2.py
index e01613f..dc608c1 100644
--- a/topo_2rr_2.py
+++ b/topo_2rr_2.py
@@ -1,125 +1,116 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo2RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo2RR2(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 42 iBGP RED config
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as2h1 = self.addHost("as2h1")
-		as1h1 = self.addHost("as1h1")
+	TODO slide 42 iBGP RED config
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.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",)},
+        # 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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        self.addLink(as4r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
+        self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as5r1, as1r6; params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as5r1, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as5r1, as2r1, params1={"ip": ("fd00:2:1::1/48",)},
+        self.addLink(as5r1, 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",)},
+        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",)},
+        self.addLink(as4r1, as4r2, params1={"ip": ("fd00:4:3::1/48",)},
                      params2={"ip": ("fd00:4:3::2/48",)})
-		self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
 
-		self.addLink(as1r1, as1h1)
+        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, as1r1, peers=[as1r3, as1r2, as1r4, as1r5, as1r6])
-		set_rr(self, as1r5, peers=[as1r1, as1r2, as1r4, as1r3, as1r6])
+        set_rr(self, as1r1, peers=[as1r3, as1r2, as1r4, as1r5, as1r6])
+        set_rr(self, 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 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo2RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo2RR2, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_2rr_3.py b/topo_2rr_3.py
index 1ee7c46..63446c2 100644
--- a/topo_2rr_3.py
+++ b/topo_2rr_3.py
@@ -1,126 +1,116 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo2RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo2RR3(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 42 iBGP GREEN config
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as2h1 = self.addHost("as2h1")
-		as1h1 = self.addHost("as1h1")
+	TODO slide 42 iBGP GREEN config
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.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",)},
+        # 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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        self.addLink(as4r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
+        self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as5r1, as1r6; params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as5r1, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as5r1, as2r1, params1={"ip": ("fd00:2:1::1/48",)},
+        self.addLink(as5r1, 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",)},
+        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",)},
+        self.addLink(as4r1, as4r2, params1={"ip": ("fd00:4:3::1/48",)},
                      params2={"ip": ("fd00:4:3::2/48",)})
-		self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
 
-		self.addLink(as1r1, as1h1)
+        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, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
-		set_rr(self, as1r6, peers=[as1r1, as1r2, as1r4, as1r3, as1r5])
+        set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
+        set_rr(self, as1r6, peers=[as1r1, as1r2, as1r4, as1r3, as1r5])
 
-		# 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 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo2RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo2RR3, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_2rr_4.py b/topo_2rr_4.py
index d3be670..77dda72 100644
--- a/topo_2rr_4.py
+++ b/topo_2rr_4.py
@@ -1,127 +1,116 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo2RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo2RR4(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 42 iBGP YELLOW config
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as2h1 = self.addHost("as2h1")
-		as1h1 = self.addHost("as1h1")
+	TODO slide 42 iBGP YELLOW config
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.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",)},
+        # 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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        self.addLink(as4r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
+        self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as5r1, as1r6; params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as5r1, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as5r1, as2r1, params1={"ip": ("fd00:2:1::1/48",)},
+        self.addLink(as5r1, 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",)},
+        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",)},
+        self.addLink(as4r1, as4r2, params1={"ip": ("fd00:4:3::1/48",)},
                      params2={"ip": ("fd00:4:3::2/48",)})
-		self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
 
-		self.addLink(as1r1, as1h1)
+        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, as1r4, peers=[as1r1, as1r2, as1r3, as1r5, as1r6])
+        set_rr(self, as1r6, peers=[as1r1, as1r2, as1r4, as1r3, as1r5])
 
-		set_rr(self, as1r4, peers=[as1r1, as1r2, as1r3, as1r5, as1r6])
-		set_rr(self, as1r6, peers=[as1r1, as1r2, as1r4, as1r3, as1r5])
-
-		# 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 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo2RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo2RR4, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_2rr_5.py b/topo_2rr_5.py
index bbf07af..3df7209 100644
--- a/topo_2rr_5.py
+++ b/topo_2rr_5.py
@@ -1,125 +1,116 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo2RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo2RR5(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 42 iBGP BLUE config
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as2h1 = self.addHost("as2h1")
-		as1h1 = self.addHost("as1h1")
+	TODO slide 42 iBGP BLUE config
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.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",)},
+        # 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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        self.addLink(as4r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
+        self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as5r1, as1r6; params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as5r1, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as5r1, as2r1, params1={"ip": ("fd00:2:1::1/48",)},
+        self.addLink(as5r1, 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",)},
+        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",)},
+        self.addLink(as4r1, as4r2, params1={"ip": ("fd00:4:3::1/48",)},
                      params2={"ip": ("fd00:4:3::2/48",)})
-		self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
 
-		self.addLink(as1r1, as1h1)
+        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, as1r2, peers=[as1r1, as1r3, as1r4, as1r5, as1r6])
-		set_rr(self, as1r4, peers=[as1r1, as1r2, as1r5, as1r3, as1r6])
+        set_rr(self, as1r2, peers=[as1r1, as1r3, as1r4, as1r5, as1r6])
+        set_rr(self, as1r4, peers=[as1r1, as1r2, as1r5, 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 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo2RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo2RR5, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_3rr_1.py b/topo_3rr_1.py
index 76a949e..7259bdf 100644
--- a/topo_3rr_1.py
+++ b/topo_3rr_1.py
@@ -1,128 +1,117 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo3RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo3RR1(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 43 iBGP
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as2h1 = self.addHost("as2h1")
-		as1h1 = self.addHost("as1h1")
+	TODO slide 43 iBGP
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
+        # 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=(_bgp.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",)},
+        # 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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        self.addLink(as4r2, as1r4, params1={"ip": ("fd00:4:1::1/48",)},
                      params2={"ip": ("fd00:4:1::2/48",)})
-		self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
+        self.addLink(as3r1, as1r1, params1={"ip": ("fd00:3:1::1/48",)},
                      params2={"ip": ("fd00:3:1::2/48",)})
-		self.addLink(as5r1, as1r6; params1={"ip": ("fd00:5:1::1/48",)},
+        self.addLink(as5r1, as1r6, params1={"ip": ("fd00:5:1::1/48",)},
                      params2={"ip": ("fd00:5:1::2/48",)})
-		self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
+        self.addLink(as3r1, as5r1, params1={"ip": ("fd00:5:2::1/48",)},
                      params2={"ip": ("fd00:5:2::2/48",)})
-		self.addLink(as5r1, as2r1, params1={"ip": ("fd00:2:1::1/48",)},
+        self.addLink(as5r1, 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",)},
+        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",)},
+        self.addLink(as4r1, as4r2, params1={"ip": ("fd00:4:3::1/48",)},
                      params2={"ip": ("fd00:4:3::2/48",)})
-		self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
+        self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
 
-		self.addLink(as1r1, as1h1)
+        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, as1r2, peers=[as1r1, as1r3, as1r4, as1r5, as1r6])
+        set_rr(self, as1r4, peers=[as1r1, as1r2, as1r5, as1r3, as1r6])
+        set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
 
-		set_rr(self, as1r2, peers=[as1r1, as1r3, as1r4, as1r5, as1r6])
-		set_rr(self, as1r4, peers=[as1r1, as1r2, as1r5, as1r3, as1r6])
-		set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, 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 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo3RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo3RR1, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_3rr_2.py b/topo_3rr_2.py
index a93845c..c3e2505 100644
--- a/topo_3rr_2.py
+++ b/topo_3rr_2.py
@@ -1,12 +1,13 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo3RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo3RR2(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 44 iBGP RED config
            +----------+                                   +--------+
                       |                                   |
@@ -21,84 +22,71 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as1r7 = self.addRouter('as1r7')
-		as1r7.addDaemon(BGP)
-		as1r8 = self.addRouter('as1r8')
-		as1r8.addDaemon(BGP)
-		as1r9 = self.addRouter('as1r9')
-		as1r9.addDaemon(BGP)
-		as1ra = self.addRouter('as1ra')
-		as1ra.addDaemon(BGP)
-		as1rb = self.addRouter('as1rb')
-		as1rb.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        # Add 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')
+        as1r7 = self.bgp('as1r7')
+        as1r8 = self.bgp('as1r8')
+        as1r9 = self.bgp('as1r9')
+        as1ra = self.bgp('as1ra')
+        as1rb = self.bgp('as1rb')
+        as5r1 = self.bgp('as5r1')
+        as3r1 = self.bgp('as3r1')
+        as2r1 = self.addRouter('as2r1')
+        as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
 
-		# 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(as1r5, as1r7)
-		self.addLink(as1r5, as1r9)
-		self.addLink(as1r6, as1r7)
-		self.addLink(as1r6, as1r8)
-		self.addLink(as1r8, as1ra)
-		self.addLink(as1r8, as1r9)
-		self.addLink(as1r9, as1rb)
-		self.addLink(as1ra, as2r1)
-		self.addLink(as1ra, as1rb)
-		self.addLink(as1rb, as2r1)
-		self.addLink(as3r1, as1r1)
-		self.addLink(as5r1, as1r6)
-		self.addLink(as3r1, as5r1)
-		self.addLink(as5r1, as2r1)
-		set_rr(self, as1r5, peers=[as1r1, as1r2, as1r3, as1r4, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb])
-		set_rr(self, as1r6, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r7, as1r8, as1r9, as1ra, as1rb])
-		set_rr(self, as1r7, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r8, as1r9, as1ra, as1rb])
+        # 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(as1r5, as1r7)
+        self.addLink(as1r5, as1r9)
+        self.addLink(as1r6, as1r7)
+        self.addLink(as1r6, as1r8)
+        self.addLink(as1r8, as1ra)
+        self.addLink(as1r8, as1r9)
+        self.addLink(as1r9, as1rb)
+        self.addLink(as1ra, as2r1)
+        self.addLink(as1ra, as1rb)
+        self.addLink(as1rb, as2r1)
+        self.addLink(as3r1, as1r1)
+        self.addLink(as5r1, as1r6)
+        self.addLink(as3r1, as5r1)
+        self.addLink(as5r1, as2r1)
+        set_rr(self, as1r5, peers=[as1r1, as1r2, as1r3, as1r4, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb])
+        set_rr(self, as1r6, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r7, as1r8, as1r9, as1ra, as1rb])
+        set_rr(self, as1r7, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r8, as1r9, as1ra, as1rb])
 
-		# Add full mesh
-		self.addAS(2, (as2r1,))
-		self.addAS(3, (as3r1,))
-		self.addAS(5, (as5r1,))
-		self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb))
+        # Add full mesh
+        self.addAS(2, (as2r1,))
+        self.addAS(3, (as3r1,))
+        self.addAS(5, (as5r1,))
+        self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb))
 
-		# Add eBGP session
-		ebgp_session(self, as1r6, as5r1)
-		ebgp_session(self, as1r1, as3r1)
-		ebgp_session(self, as3r1, as5r1)
-		ebgp_session(self, as5r1, as2r1)
-		ebgp_session(self, as1ra, as2r1)
-		ebgp_session(self, as1rb, as2r1)
+        # Add eBGP session
+        ebgp_session(self, as1r6, as5r1)
+        ebgp_session(self, as1r1, as3r1)
+        ebgp_session(self, as3r1, as5r1)
+        ebgp_session(self, as5r1, as2r1)
+        ebgp_session(self, as1ra, as2r1)
+        ebgp_session(self, as1rb, as2r1)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo3RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo3RR2, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_3rr_3.py b/topo_3rr_3.py
index 84759db..85cd2a0 100644
--- a/topo_3rr_3.py
+++ b/topo_3rr_3.py
@@ -1,12 +1,13 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopo3RR(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopo3RR3(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide 44 iBGP BLUE config
            +----------+                                   +--------+
                       |                                   |
@@ -21,86 +22,72 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as1r7 = self.addRouter('as1r7')
-		as1r7.addDaemon(BGP)
-		as1r8 = self.addRouter('as1r8')
-		as1r8.addDaemon(BGP)
-		as1r9 = self.addRouter('as1r9')
-		as1r9.addDaemon(BGP)
-		as1ra = self.addRouter('as1ra')
-		as1ra.addDaemon(BGP)
-		as1rb = self.addRouter('as1rb')
-		as1rb.addDaemon(BGP)
-		as5r1 = self.addRouter('as5r1')
-		as5r1.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
+        # Add 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')
+        as1r7 = self.bgp('as1r7')
+        as1r8 = self.bgp('as1r8')
+        as1r9 = self.bgp('as1r9')
+        as1ra = self.bgp('as1ra')
+        as1rb = self.bgp('as1rb')
+        as5r1 = self.bgp('as5r1')
+        as3r1 = self.bgp('as3r1')
+        as2r1 = self.addRouter('as2r1')
+        as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/48',)),))
 
-		# 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(as1r5, as1r7)
-		self.addLink(as1r5, as1r9)
-		self.addLink(as1r6, as1r7)
-		self.addLink(as1r6, as1r8)
-		self.addLink(as1r8, as1ra)
-		self.addLink(as1r8, as1r9)
-		self.addLink(as1r9, as1rb)
-		self.addLink(as1ra, as2r1)
-		self.addLink(as1ra, as1rb)
-		self.addLink(as1rb, as2r1)
-		self.addLink(as3r1, as1r1)
-		self.addLink(as5r1, as1r6)
-		self.addLink(as3r1, as5r1)
-		self.addLink(as5r1, as2r1)
-		set_rr(self, as1r2, peers=[as1r1, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb])
-		set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb])
-		set_rr(self, as1r8, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r9, as1ra, as1rb])
-		set_rr(self, as1r9, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1ra, as1rb])
+        # 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(as1r5, as1r7)
+        self.addLink(as1r5, as1r9)
+        self.addLink(as1r6, as1r7)
+        self.addLink(as1r6, as1r8)
+        self.addLink(as1r8, as1ra)
+        self.addLink(as1r8, as1r9)
+        self.addLink(as1r9, as1rb)
+        self.addLink(as1ra, as2r1)
+        self.addLink(as1ra, as1rb)
+        self.addLink(as1rb, as2r1)
+        self.addLink(as3r1, as1r1)
+        self.addLink(as5r1, as1r6)
+        self.addLink(as3r1, as5r1)
+        self.addLink(as5r1, as2r1)
+        set_rr(self, as1r2, peers=[as1r1, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb])
+        set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb])
+        set_rr(self, as1r8, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r9, as1ra, as1rb])
+        set_rr(self, as1r9, peers=[as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1ra, as1rb])
 
-		# Add full mesh
-		self.addAS(2, (as2r1,))
-		self.addAS(3, (as3r1,))
-		self.addAS(5, (as5r1,))
-		self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb))
+        # Add full mesh
+        self.addAS(2, (as2r1,))
+        self.addAS(3, (as3r1,))
+        self.addAS(5, (as5r1,))
+        self.addAS(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6, as1r7, as1r8, as1r9, as1ra, as1rb))
 
-		
-		# Add eBGP session
-		ebgp_session(self, as1r6, as5r1)
-		ebgp_session(self, as1r1, as3r1)
-		ebgp_session(self, as3r1, as5r1)
-		ebgp_session(self, as5r1, as2r1)
-		ebgp_session(self, as1ra, as2r1)
-		ebgp_session(self, as1rb, as2r1)
+        # Add eBGP session
+        ebgp_session(self, as1r6, as5r1)
+        ebgp_session(self, as1r1, as3r1)
+        ebgp_session(self, as3r1, as5r1)
+        ebgp_session(self, as5r1, as2r1)
+        ebgp_session(self, as1ra, as2r1)
+        ebgp_session(self, as1rb, as2r1)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopo3RR, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopo3RR3, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_med.py b/topo_med.py
index e5eca3c..4635c8d 100644
--- a/topo_med.py
+++ b/topo_med.py
@@ -1,128 +1,119 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, set_med, new_access_list
+import ipmininet.router.config.bgp as _bgp
 
 
 class MedBGPTopo(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
-	TODO slide 26 iBGP
-           +----------+                                   +--------+
-                      |                                   |
-         AS1          |                  AS2              |        AS3
-                      |                                   |
-                      |                                   |
-    +-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
-    | as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
-    +-------+         |  +-------+             +-------+  |         +-------+
-                      |                                   |
-                      |                                   |
-                      |                                   |
-         +------------+                                   +--------+
+    def build(self, *args, **kwargs):
         """
+	TODO slide 26 iBGP
+		   +----------+                                   +--------+
+					  |                                   |
+		 AS1          |                  AS2              |        AS3
+					  |                                   |
+					  |                                   |
+	+-------+   eBGP  |  +-------+     iBGP    +-------+  |  eBGP   +-------+
+	| as1r1 +------------+ as2r1 +-------------+ as2r2 +------------+ as3r1 |
+	+-------+         |  +-------+             +-------+  |         +-------+
+					  |                                   |
+					  |                                   |
+					  |                                   |
+		 +------------+                                   +--------+
+		"""
 
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as4r1 = self.addRouter('as4r1')
-		as4r1.addDaemon(BGP)
-		as4r2 = self.addRouter('as4r2')
-		as4r2.addDaemon(BGP)
-		as3r1 = self.addRouter('as3r1')
-		as3r1.addDaemon(BGP)
-		as3r2 = self.addRouter('as3r2')
-		as3r2.addDaemon(BGP)
-		as2r1 = self.addRouter('as2r1')
-		as2r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as2h1 = self.addHost("as2h1")
-		as1h1 = self.addHost("as1h1")
+        # 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=(_bgp.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",)},
+        # 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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        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",)},
+        self.addLink(as2r1, as2h1, params1={"ip": ("dead:beef::1/32",)},
                      params2={"ip": ("dead:beef::2/32",)})
 
-		self.addLink(as1r1, as1h1)
+        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
-		new_access_list(self, (as3r2, as1r1, as3r1, as1r6, as4r1, as1r5, as4r2, as1r4), 'all', ('any',))
-		set_med(self, as3r2, as1r1, 7, filter_type='access-list', filter_names=('all',))
-		set_med(self, as3r1, as1r6, 0, filter_type='access-list', filter_names=('all',))
-		set_med(self, as4r1, as1r5, 0, filter_type='access-list', filter_names=('all',))
-		set_med(self, as4r2, as1r4, 2, filter_type='access-list', filter_names=('all',))
-		
-		# 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])
+        # Set Med
+        new_access_list(self, (as3r2, as1r1, as3r1, as1r6, as4r1, as1r5, as4r2, as1r4), 'all', ('any',))
+        set_med(self, as3r2, as1r1, 7, filter_type='access-list', filter_names=('all',))
+        set_med(self, as3r1, as1r6, 0, filter_type='access-list', filter_names=('all',))
+        set_med(self, as4r1, as1r5, 0, filter_type='access-list', filter_names=('all',))
+        set_med(self, as4r2, as1r4, 2, filter_type='access-list', filter_names=('all',))
+
+        # 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)
+        # 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)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(MedBGPTopo, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(MedBGPTopo, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_te_1.py b/topo_te_1.py
index 7bbe504..9b7b77d 100644
--- a/topo_te_1.py
+++ b/topo_te_1.py
@@ -1,12 +1,13 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopoTE(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopoTE1(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide ? BGP_RR_TE with R3 and R6 as RRs
            +----------+                                   +--------+
                       |                                   |
@@ -21,69 +22,69 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as8r1 = self.addRouter('as8r1')
-		as8r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as8r2 = self.addRouter('as8r2')
-		as8r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as7r1 = self.addRouter('as7r1')
-		as7r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
-		as7r2 = self.addRouter('as7r2')
-		as7r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
-		as7r3 = self.addRouter('as7r3')
-		as7r3.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
-
-		# 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(as1r2, as8r1)
-		self.addLink(as1r4, as8r2)
-		self.addLink(as1r1, as7r1)
-		self.addLink(as1r3, as7r2)
-		self.addLink(as1r5, as7r3)
-		self.addLink(as1r6, as7r3)
-		set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
-		set_rr(self, as1r6, peers=[as1r1, as1r2, as1r3, as1r4, as1r5])
+        # 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')
+        as8r1 = self.addRouter('as8r1')
+        as8r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as8r2 = self.addRouter('as8r2')
+        as8r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        h1 = self.addHost('h1')
+        as7r1 = self.addRouter('as7r1')
+        as7r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
+        as7r2 = self.addRouter('as7r2')
+        as7r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
+        as7r3 = self.addRouter('as7r3')
+        as7r3.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
+        h2 = self.addHost('h2')
 
-		# Add full mesh
-		self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
-		self.addAS(7, (as7r1, as7r2, as7r3))
-		self.addAS(8, (as8r1, as8r2))
+        # 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(as1r2, as8r1)
+        self.addLink(as1r4, as8r2)
+        self.addLink(as1r1, as7r1)
+        self.addLink(as1r3, as7r2)
+        self.addLink(as1r5, as7r3)
+        self.addLink(as1r6, as7r3)
+        self.addLink(as8r1, h1, params1={"ip": "dead:beef::/48"}, params2={"ip": "dead:beef::1/48"})
+        self.addLink(as8r2, h1, params1={"ip": "dead:beef::2/48"}, params2={"ip": "dead:beef::3/48"})
+        self.addLink(as7r1, h2, params1={"ip": "feeb:daed::/48"}, params2={"ip": "feeb:daed::1/48"})
+        self.addLink(as7r1, h2, params1={"ip": "feeb:daed::4/48"}, params2={"ip": "feeb:daed::5/48"})
+        self.addLink(as7r2, h2, params1={"ip": "feeb:daed::2/48"}, params2={"ip": "feeb:daed::3/48"})
+        set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
+        set_rr(self, as1r6, peers=[as1r1, as1r2, as1r3, as1r4, as1r5])
 
-		# Add eBGP session
-		ebgp_session(self, as1r2, as8r1)
-		ebgp_session(self, as1r4, as8r2)
-		ebgp_session(self, as1r1, as7r1)
-		ebgp_session(self, as1r3, as7r2)
-		ebgp_session(self, as1r5, as7r3)
-		ebgp_session(self, as1r6, as7r3)
+        # Add full mesh
+        self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
+        self.addAS(7, (as7r1, as7r2, as7r3))
+        self.addAS(8, (as8r1, as8r2))
 
+        # Add eBGP session
+        ebgp_session(self, as1r2, as8r1)
+        ebgp_session(self, as1r4, as8r2)
+        ebgp_session(self, as1r1, as7r1)
+        ebgp_session(self, as1r3, as7r2)
+        ebgp_session(self, as1r5, as7r3)
+        ebgp_session(self, as1r6, as7r3)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopoTE, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopoTE1, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r
diff --git a/topo_te_2.py b/topo_te_2.py
index f233bbc..1f00282 100644
--- a/topo_te_2.py
+++ b/topo_te_2.py
@@ -1,12 +1,13 @@
 from ipmininet.iptopo import IPTopo
 from ipmininet.router.config import RouterConfig, BGP, ebgp_session, bgp_peering, set_rr
+import ipmininet.router.config.bgp as _bgp
 
 
-class BGPTopoTE(IPTopo):
-	"""This topology is composed of two AS connected in dual homing with different local pref"""
+class BGPTopoTE2(IPTopo):
+    """This topology is composed of two AS connected in dual homing with different local pref"""
 
-	def build(self, *args, **kwargs):
-		"""
+    def build(self, *args, **kwargs):
+        """
 	TODO slide ? BGP_RR_TE with R3 and R4 as RRs
            +----------+                                   +--------+
                       |                                   |
@@ -21,68 +22,69 @@ def build(self, *args, **kwargs):
                       |                                   |
          +------------+                                   +--------+
         """
-		# Add all routers
-		as1r1 = self.addRouter('as1r1')
-		as1r1.addDaemon(BGP)
-		as1r2 = self.addRouter('as1r2')
-		as1r2.addDaemon(BGP)
-		as1r3 = self.addRouter('as1r3')
-		as1r3.addDaemon(BGP)
-		as1r4 = self.addRouter('as1r4')
-		as1r4.addDaemon(BGP)
-		as1r5 = self.addRouter('as1r5')
-		as1r5.addDaemon(BGP)
-		as1r6 = self.addRouter('as1r6')
-		as1r6.addDaemon(BGP)
-		as8r1 = self.addRouter('as8r1')
-		as8r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as8r2 = self.addRouter('as8r2')
-		as8r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
-		as7r1 = self.addRouter('as7r1')
-		as7r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
-		as7r2 = self.addRouter('as7r2')
-		as7r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
-		as7r3 = self.addRouter('as7r3')
-		as7r3.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
+        # 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')
+        as8r1 = self.addRouter('as8r1')
+        as8r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        as8r2 = self.addRouter('as8r2')
+        as8r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('dead:beef::/32',)),))
+        h1 = self.addHost('h1')
+        as7r1 = self.addRouter('as7r1')
+        as7r1.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
+        as7r2 = self.addRouter('as7r2')
+        as7r2.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
+        as7r3 = self.addRouter('as7r3')
+        as7r3.addDaemon(BGP, address_families=(_bgp.AF_INET6(networks=('feeb:daed::/32',)),))
+        h2 = self.addHost('h2')
 
-		# 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(as1r2, as8r1)
-		self.addLink(as1r4, as8r2)
-		self.addLink(as1r1, as7r1)
-		self.addLink(as1r3, as7r2)
-		self.addLink(as1r5, as7r3)
-		self.addLink(as1r6, as7r3)
-		set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
-		set_rr(self, as1r4, peers=[as1r1, as1r2, as1r3, as1r5, as1r6])
+        # 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(as1r2, as8r1)
+        self.addLink(as1r4, as8r2)
+        self.addLink(as1r1, as7r1)
+        self.addLink(as1r3, as7r2)
+        self.addLink(as1r5, as7r3)
+        self.addLink(as1r6, as7r3)
+        self.addLink(as8r1, h1, params1={"ip": "dead:beef::/48"}, params2={"ip": "dead:beef::1/48"})
+        self.addLink(as8r2, h1, params1={"ip": "dead:beef::2/48"}, params2={"ip": "dead:beef::3/48"})
+        self.addLink(as7r1, h2, params1={"ip": "feeb:daed::/48"}, params2={"ip": "feeb:daed::1/48"})
+        self.addLink(as7r1, h2, params1={"ip": "feeb:daed::4/48"}, params2={"ip": "feeb:daed::5/48"})
+        self.addLink(as7r2, h2, params1={"ip": "feeb:daed::2/48"}, params2={"ip": "feeb:daed::3/48"})
+        set_rr(self, as1r3, peers=[as1r1, as1r2, as1r4, as1r5, as1r6])
+        set_rr(self, as1r4, peers=[as1r1, as1r2, as1r3, as1r5, as1r6])
 
-		# Add full mesh
-		self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
-		self.addAS(7, (as7r1, as7r2, as7r3))
-		self.addAS(8, (as8r1, as8r2))
+        # Add full mesh
+        self.addiBGPFullMesh(1, (as1r1, as1r2, as1r3, as1r4, as1r5, as1r6))
+        self.addAS(7, (as7r1, as7r2, as7r3))
+        self.addAS(8, (as8r1, as8r2))
 
-		# Add eBGP session
-		ebgp_session(self, as1r2, as8r1)
-		ebgp_session(self, as1r4, as8r2)
-		ebgp_session(self, as1r1, as7r1)
-		ebgp_session(self, as1r3, as7r2)
-		ebgp_session(self, as1r5, as7r3)
-		ebgp_session(self, as1r6, as7r3)
+        # Add eBGP session
+        ebgp_session(self, as1r2, as8r1)
+        ebgp_session(self, as1r4, as8r2)
+        ebgp_session(self, as1r1, as7r1)
+        ebgp_session(self, as1r3, as7r2)
+        ebgp_session(self, as1r5, as7r3)
+        ebgp_session(self, as1r6, as7r3)
 
-		# Add test hosts ?
-		# for r in self.routers():
-		#     self.addLink(r, self.addHost('h%s' % r))
-		super(BGPTopoTE, self).build(*args, **kwargs)
+        # Add test hosts ?
+        # for r in self.routers():
+        #     self.addLink(r, self.addHost('h%s' % r))
+        super(BGPTopoTE2, self).build(*args, **kwargs)
 
-	def bgp(self, name):
-		r = self.addRouter(name, config=RouterConfig)
-		r.addDaemon(BGP, address_families=(
-			_bgp.AF_INET(redistribute=('connected',)),
-			_bgp.AF_INET6(redistribute=('connected',))))
-		return r
+    def bgp(self, name):
+        r = self.addRouter(name)
+        r.addDaemon(BGP, address_families=(
+            _bgp.AF_INET(redistribute=('connected',)),
+            _bgp.AF_INET6(redistribute=('connected',))))
+        return r