def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
# Create switches and hosts
c_switch = self.addSwitch('cs1')
a_switches = [ self.addSwitch('as%s' % s) for s in irange(1,fanout) ]
e_switches = [ self.addSwitch('es%s' % s) for s in irange(1,fanout ** 2)]
hosts = [ self.addHost('h%s' % h) for h in irange( 1, fanout ** 3)]
# Connect between c_switch and a_switches
for a_switch in a_switches:
self.addLink(c_switch,a_switch,**linkopts1)
# Connect between a_switches and e_switches
count = 0
for e_switch in e_switches:
selector = count / fanout
self.addLink(e_switch,a_switches[selector],**linkopts2)
count = count + 1
# Connect between e_switches and hosts
count = 0
for host in hosts:
selector = count / fanout
self.addLink(host,e_switches[selector],**linkopts3)
count = count + 1
def createTopo():
topo=Topo()
swCore1 = topo.addSwitch('s1')
## Ajuste do parametro de fanout da rede
fanout = 2
# Switches counter
lastSW = 2
lastHost = 1
# Aggregation switches loop
for i in irange (1, fanout):
swAggregL = topo.addSwitch('s%s' % lastSW)
topo.addLink(swCore1, swAggregL)
lastSW += 1
# Edge switches loop
for j in irange (1, fanout):
swEdge = topo.addSwitch('s%s' % lastSW)
topo.addLink(swAggregL, swEdge)
lastSW += 1
# Hosts loop
for k in irange (1, fanout):
host = topo.addHost('h%s' % lastHost)
topo.addLink(swEdge, host)
lastHost += 1
return topo
def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
#def __init__(self, fanout=3, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
jj = 1
kk = 1
coreSwitch = self.addSwitch('c1')
for i in irange(1, fanout):
aggSwitch = self.addSwitch('a%s' % i)
self.addLink(aggSwitch,coreSwitch,**linkopts1)
link_ae = 1
for j in irange(jj, fanout * fanout):
edgeSwitch = self.addSwitch('e%s' % j)
if link_ae <= fanout:
self.addLink(edgeSwitch,aggSwitch,**linkopts2)
link_ae += 1
else:
break
link_eh = 1
for k in irange(kk, fanout * fanout * fanout):
host = self.addHost('h%s' % k)
if link_eh <= fanout:
self.addLink(host,edgeSwitch,**linkopts3)
link_eh += 1
else:
break
kk = kk + fanout
jj = jj + fanout
def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
self.fonout = fanout
# Add core switch
cs_switch = self.addSwitch('cs%s' % 1)
# Add aggregation switches
for i in irange(1, fanout):
as_switch = self.addSwitch('as%s' % i)
self.addLink(as_switch, cs_switch, **linkopts1)
as_parent_switch = as_switch
# Add edge switches
for j in irange(1, fanout):
es_num = i * fanout - 2 + j
es_switch = self.addSwitch('es%s' % es_num, **linkopts2)
self.addLink(es_switch, as_parent_switch)
es_parent_switch = es_switch
# Add hosts
for k in irange(1, fanout):
host_num = es_num * fanout - 2 + k
host = self.addHost('h%s' % host_num, cpu=.5/fanout)
self.addLink(host, es_parent_switch, **linkopts3)
def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
aggregation = []
edge = []
host = []
self.linkopts = [ linkopts1, linkopts2, linkopts3 ]
# Create core switch
core = self.addSwitch('c1')
# Aggregation switches
for i in irange(1, fanout):
aggregation.append(self.addSwitch('a%s' % (len(aggregation) + 1)))
self.addLink(core, aggregation[-1], **linkopts1)
# Edge switches
for j in irange(1, fanout):
edge.append(self.addSwitch('e%s' % (len(edge) + 1)))
self.addLink(aggregation[-1], edge[-1], **linkopts2)
# Hosts
for k in irange(1, fanout):
host.append(self.addHost('h%s' % (len(host) + 1)))
self.addLink(host[-1], edge[-1], **linkopts3)
def __init__(self, k=2, n=1, **opts):
"""Init.
k: number of switches
n: number of hosts per switch
hconf: host configuration options
lconf: link configuration options"""
super(LinearTopo, self).__init__(**opts)
self.k = k
self.n = n
lastSwitch = None
for i in irange(1, k):
# Add switch
switch = self.addSwitch('s%s' % i)
# Add hosts to switch
for j in irange(1, n):
hostNum = (i-1)*n + j
host = self.addHost('h%s' % hostNum)
self.addLink(host, switch)
# Connect switch to previous
if lastSwitch:
self.addLink(switch, lastSwitch)
lastSwitch = switch
def __init__(self, k=2, n=1, **opts):
"""Init.
k: number of switches
n: number of hosts per switch
hconf: host configuration options
lconf: link configuration options"""
super(LinearTopo, self).__init__(**opts)
self.k = k
self.n = n
if n == 1:
genHostName = lambda i, j: 'h%s' % i
else:
genHostName = lambda i, j: 'h%ss%d' % (j, i)
lastSwitch = None
for i in irange(1, k):
# Add switch
switch = self.addSwitch('s%s' % i)
# Add hosts to switch
for j in irange(1, n):
host = self.addHost(genHostName(i, j))
self.addLink(host, switch)
# Connect switch to previous
if lastSwitch:
self.addLink(switch, lastSwitch)
lastSwitch = switch
def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
# Add your logic here ...
chooser = lambda dict, para, default: para in dict and dict[para] or default
#add core switch:
core_switch = self.addSwitch('c1')
#add agg switch
for i in irange(1, fanout):
agg_switch = self.addSwitch('a%s'%i)
loss = chooser(linkopts1, 'loss', 1)
max_queue_size = chooser(linkopts1, 'max_queue_size', 1000)
use_htb = chooser(linkopts1, 'use_htb', True)
self.addLink(core_switch, agg_switch, bw=linkopts1['bw'], delay=linkopts1['delay'], loss=loss, max_queue_size=max_queue_size, use_htb=use_htb)
#add edge switches
for j in irange(1, fanout):
edge_switch = self.addSwitch('e%s'%((i-1)*fanout+j))
loss = chooser(linkopts2, 'loss', 1)
max_queue_size = chooser(linkopts2, 'max_queue_size', 1000)
use_htb = chooser(linkopts2, 'use_htb', True)
self.addLink(agg_switch, edge_switch, bw=linkopts2['bw'], delay=linkopts2['delay'], loss=loss, max_queue_size=max_queue_size, use_htb=use_htb)
#add hosts:
for k in irange(1, fanout):
host = self.addHost('h%s'%(((i-1)*fanout+j-1)*fanout+k))
loss = chooser(linkopts3, 'loss', 1)
max_queue_size = chooser(linkopts3, 'max_queue_size', 1000)
use_htb = chooser(linkopts3, 'use_htb', True)
self.addLink(edge_switch, host, bw=linkopts3['bw'], delay=linkopts3['delay'], loss=loss, max_queue_size=max_queue_size, use_htb=use_htb)
def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
# Add your logic here ...
# changed LinearTopo to TreeTopo, not sure what difference this makes)
super(CustomTopo, self).__init__(**opts)
self.fanout = fanout
switchFanOut = fanout
edgeSwitchFanOut = fanout
hostFanOut = fanout
#lastSwitch = None
# create core switch
coreSwitch = self.addSwitch('c1')
#now start logic of creating tree under the root (i.e. core switch)
for asfo in irange(1, switchFanOut):
aggSwitch = self.addSwitch('a%s' % asfo)
for esfo in irange(1+fanout*(asfo-1), edgeSwitchFanOut+fanout*(asfo-1)):
edgeSwitch = self.addSwitch('e%s' % esfo)
for hfo in irange(1+fanout*(esfo-1), hostFanOut+fanout*(esfo-1)):
host = self.addHost('h%s' % hfo)
self.addLink(host, edgeSwitch, **linkopts3)
self.addLink(edgeSwitch, aggSwitch, **linkopts2)
self.addLink(coreSwitch, aggSwitch, **linkopts1)
def __init__( self, N, bw, **params ):
# Initialize topology
Topo.__init__( self, **params )
# Create switches and hosts
hosts = [ self.addHost( 'h%s' % h )
for h in irange( 1, N ) ]
switches = [ self.addSwitch( 's%s' % s )
for s in irange( 1, N - 1 ) ]
# Wire up switches
last = None
for switch in switches:
if last:
self.addLink( last, switch,
bw=bw, delay='1ns', loss=0, use_htb=True)
last = switch
# Wire up hosts
self.addLink( hosts[ 0 ], switches[ 0 ],
bw=bw, delay='1ms', loss=0, use_htb=True)
for host, switch in zip( hosts[ 1: ], switches ):
self.addLink( host, switch,
bw=bw, delay='1ms', loss=0, use_htb=True)
def __init__(self, k, l, **opts):
"""Init.
k: number of switches (and hosts)
hconf: host configuration options
lconf: link configuration options"""
super(dcSpineLeafTopo, self).__init__(**opts)
self.k = k
self.l = l
for i in irange(0, k-1):
spineSwitch = self.addSwitch('s%s%s' % (1,i+1))
spineList.append(spineSwitch)
for i in irange(0, l-1):
leafSwitch = self.addSwitch('l%s%s' % (2, i+1))
leafList.append(leafSwitch)
host1 = self.addHost('h%s' % (i+1))
#host12 = self.addHost('h%s' % (i+1))
#hosts1 = [ net.addHost( 'h%d' % n ) for n in 3, 4 ]
"connection of the hosts to the left tor switch "
self.addLink(host1, leafSwitch, **link_host_leaf)
#self.addLink(host12, leafSwitch)
for i in irange(0, k-1):
for j in irange(0, l-1): #this is to go through the leaf switches
self.addLink(spineList[i], leafList[j], **link_spine_leaf)
def build( self, k=2, n=1,delay=None, **_opts):
"""k: number of switches
n: number of hosts per switch"""
self.k = k
self.n = n
if n == 1:
genHostName = lambda i, j: 'h%s' % i
else:
genHostName = lambda i, j: 'h%ss%d' % ( j, i )
lastSwitch = None
for i in irange( 1, k ):
# Add switch
switch = self.addSwitch( 's%s' % i )
# Add hosts to switch
for j in irange( 1, n ):
host = self.addHost( genHostName( i, j ) )
if delay != None:
self.addLink( host, switch, delay=delay, use_htb=True)
else:
self.addLink( host, switch)
# Connect switch to previous
if lastSwitch:
if delay != None:
self.addLink( switch, lastSwitch, delay=delay, use_htb=True )
else:
self.addLink( switch, lastSwitch )
lastSwitch = switch
def __init__(self, linkopts1, linkopts2,linkopts3,fanout, **opts):
Topo.__init__(self, **opts)
self.linkopts1 = linkopts1
self.linkopts2 = linkopts2
self.linkopts3 = linkopts3
self.fanout = fanout
s=[]
h=[]
l=[1]
a=0
c=0
for i in irange(1,1+fanout+fanout**2):
switch = self.addSwitch('s%s' % i)
s.append(switch)
for i in irange(1,fanout**3):
host = self.addHost('h%s' % i)
h.append(host)
for i in range(fanout-1):
a=a+fanout+1
l.append(a+1)
for i in l:
link = self.addLink(s[0], s[i],**linkopts1)
for i in l:
b=0
for j in irange(1,fanout):
link = self.addLink(s[i],s[b+i+1],**linkopts2)
for k in irange(1,fanout):
link = self.addLink(h[c],s[b+i+1],**linkopts3)
c=c+1
b=b+1
def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
# Add your logic here ...
sw_list_access = []
sw_list_edge = []
core_switch = self.addSwitch('c1')
sw_id = 0
for i in irange (1, fanout):
sw_id = sw_id + 1
access_switch = self.addSwitch('a%s' %sw_id)
self.addLink(core_switch, access_switch, **linkopts1)
sw_list_access.append(access_switch)
sw_id = 0
for sw in sw_list_access:
for i in irange (1, fanout):
sw_id = sw_id + 1
edge_switch = self.addSwitch('e%s' %sw_id)
self.addLink(edge_switch, sw, **linkopts2)
sw_list_edge.append(edge_switch)
h_id = 0
for sw in sw_list_edge:
for i in irange (1, fanout):
h_id = h_id + 1
host = self.addHost('h%s' %h_id)
self.addLink(host, sw, **linkopts3)
def __init__( self, N, **params ):
Topo.__init__( self, **params )
hosts1 = [ self.addHost( 'h%d' % n )
for n in irange( 1, 2 ) ]
hosts2 = [ self.addHost( 'h%d' % n )
for n in irange( 3, 4 ) ]
hosts3 = [ self.addHost( 'h%d' % n )
for n in irange( 5, 6 ) ]
hosts4 = [ self.addHost( 'h%d' % n )
for n in irange( 7, 8 ) ]
switches = [ self.addSwitch( 's%s' % s )
for s in irange( 1, 6 ) ]
for h in hosts1:
self.addLink( s2, h )
for h in hosts2:
self.addLink( s3, h )
for h in hosts3:
self.addLink( s5, h )
for h in hosts4:
net.addLink( s6, h )
self.addLink( s1, s2 )
self.addLink( s1, s4 )
self.addLink( s1, s3 )
self.addLink( s4, s5 )
self.addLink( s4, s6 )
def __init__(self, linkopts1={}, linkopts2={}, linkopts3={}, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
# Add your logic here ...
# Add CORE
core = self.addSwitch('c1')
# Aux variables to count switches and hosts used to assign names
acount = 1
ecount = 1
hcount = 1
# Add Agreggation
for i in irange(1, fanout):
#name = str(acount + int(i))
AggSwitch = self.addSwitch('a%s' % acount)
self.addLink( core, AggSwitch, **linkopts1)
acount += 1
# Add Edge
for j in irange(1,fanout):
#name = str(ecount + int(j))
EdgeSwitch = self.addSwitch('e%s' % ecount)
self.addLink( AggSwitch, EdgeSwitch, **linkopts2)
ecount += 1
# Add hosts
for k in irange(1, fanout):
#name = str(hcount + int(k))
host = self.addHost('h%s' % hcount)
self.addLink( EdgeSwitch, host, **linkopts3)
hcount += 1
def __init__(self, linkopts1, linkopts2, linkopts3, fanout=2, **opts):
# Initialize topology and default options
Topo.__init__(self, **opts)
# Add your logic here ...
self.fanout = fanout
currentHost = 1
currentEdge = 1
currentAgg = 1
# Core Layer
coreSW = self.addSwitch('c1', cpu=.5/fanout)
for a in irange(1, fanout):
# Aggregation Layer
aggSW = self.addSwitch('a%s' % currentAgg)
self.addLink(aggSW, coreSW, bw=linkopts1['bw'], delay=linkopts1['delay'], loss=1, max_queue_size=1000, use_htb=True)
currentAgg += 1
for e in irange(1, fanout):
# Edge Layer
edgeSW = self.addSwitch('e%s' % currentEdge)
self.addLink(edgeSW, aggSW, bw=linkopts2['bw'], delay=linkopts2['delay'], loss=1, max_queue_size=1000, use_htb=True)
currentEdge += 1
for h in irange(1, fanout):
# Host Layer
host = self.addHost('h%s' % currentHost, cpu=.5/fanout)
self.addLink(host, edgeSW, bw=linkopts3['bw'], delay=linkopts3['delay'], loss=1, max_queue_size=1000, use_htb=True)
currentHost += 1
def __init__( self, N, M, **params ):
# Initialize topology
Topo.__init__( self, **params )
print ""
# Create switches and hosts
switches = []
hosts = []
for s in irange(1, N):
print 's%s' % s
switch = self.addSwitch('s%s' % s)
switches.append(switch)
for h in irange(1, M):
print 's%sh%s' % (s, h)
host = self.addHost('s%sh%s' % (s, h))
hosts.append(host)
print 's%sh%s-s%s' % (s, h, s)
# Wire up hosts
self.addLink(switch, host)
print switches
print hosts
# Wire up switches
last = None
for switch in switches:
if last:
self.addLink( last, switch )
self.addLink( last, switch )
print last + "-" + switch
last = switch
def build( self, k=2, **_opts ):
if(emulationEnvironment.isWiFi):
"k: number of hosts"
self.k = k
baseStation = self.addBaseStation( 'ap1' )
for h in irange( 1, k ):
host = self.addHost( 'sta%s' % h )
self.addLink( host, baseStation )
else:
"k: number of hosts"
self.k = k
switch = self.addSwitch( 's1' )
for h in irange( 1, k ):
host = self.addHost( 'h%s' % h )
self.addLink( host, switch )
def build( self, k=2, **_opts ):
if(Node.isWireless):
"k: number of hosts"
self.k = k
baseStation = self.addBaseStation( 'bs1' )
for h in irange( 1, k ):
host = self.addHost( 'sta%s' % h )
self.addLink( host, baseStation )
else:
"k: number of hosts"
self.k = k
switch = self.addSwitch( 's1' )
for h in irange( 1, k ):
host = self.addHost( 'h%s' % h )
self.addLink( host, switch )
def build( self, k=2, n=1, **_opts):
if(Node.isWireless):
"""k: number of switches
n: number of hosts per switch"""
self.k = k
self.n = n
Node.wirelessRadios = k*2
if n == 1:
genHostName = lambda i, j: 'sta%s' % i
else:
genHostName = lambda i, j: 'sta%sap%d' % ( j, i )
lastBaseStation = None
for i in irange( 1, k ):
# Add baseStation
baseStation = self.addBaseStation( 'ap%s' % i, ssid='ssid_ap%s' % i )
# Add hosts to baseStation
for j in irange( 1, n ):
host = self.addHost( genHostName( i, j ) )
self.addLink( host, baseStation )
# Connect baseStation to previous
if lastBaseStation:
self.addLink( baseStation, lastBaseStation )
lastBaseStation = baseStation
else:
"""k: number of switches
n: number of hosts per switch"""
self.k = k
self.n = n
if n == 1:
genHostName = lambda i, j: 'h%s' % i
else:
genHostName = lambda i, j: 'h%ss%d' % ( j, i )
lastSwitch = None
for i in irange( 1, k ):
# Add switch
switch = self.addSwitch( 's%s' % i )
# Add hosts to switch
for j in irange( 1, n ):
host = self.addHost( genHostName( i, j ) )
self.addLink( host, switch )
# Connect switch to previous
if lastSwitch:
self.addLink( switch, lastSwitch )
lastSwitch = switch
def build( self, k=2, **_opts ):
isWiFi = _opts.get('isWiFi')
if isWiFi:
"k: number of hosts"
self.k = k
baseStation = self.addBaseStation( 'ap1' )
for h in irange( 1, k ):
host = self.addHost( 'sta%s' % h )
self.addLink( host, baseStation )
else:
"k: number of hosts"
self.k = k
switch = self.addSwitch( 's1' )
for h in irange( 1, k ):
host = self.addHost( 'h%s' % h )
self.addLink( host, switch )
def __init__(self, k=4, **opts):
"""Init.
k: number of switches (and hosts)
hconf: host configuration options
lconf: link configuration options"""
super(CustomTopo, self).__init__(**opts)
self.k = k
lastSwitch = None
firstSwitch = None
for i in irange(1, k):
j = 1;
host1 = self.addHost('h%s_%s' % (i,j))
j = j + 1;
host2 = self.addHost('h%s_%s' % (i,j))
switch = self.addSwitch('s%s' % i)
if (i == 1):
firstSwitch = switch
self.addLink( host1, switch)
self.addLink( host2, switch)
if lastSwitch:
self.addLink( switch, lastSwitch)
if (i == k):
router = self.addSwitch('r1')
self.addLink(switch, router)
self.addLink(lastSwitch, router)
lastSwitch = switch
self.addLink(switch, firstSwitch)
def __init__(self, n=2, h=1, **opts):
Topo.__init__(self, **opts)
# set up inet switch
inetSwitch = self.addSwitch('s0')
# add inet host
inetHost = self.addHost('h0')
self.addLink(inetSwitch, inetHost)
# add local nets
for i in irange(1, n):
inetIntf = 'nat%d-eth0' % i
localIntf = 'nat%d-eth1' % i
localIP = '192.168.%d.1' % i
localSubnet = '192.168.%d.0/24' % i
natParams = { 'ip' : '%s/24' % localIP }
# add NAT to topology
nat = self.addNode('nat%d' % i, cls=NAT, subnet=localSubnet,
inetIntf=inetIntf, localIntf=localIntf)
switch = self.addSwitch('s%d' % i)
# connect NAT to inet and local switches
self.addLink(nat, inetSwitch, intfName1=inetIntf)
self.addLink(nat, switch, intfName1=localIntf, params1=natParams)
# add host and connect to local switch
host = self.addHost('h%d' % i,
ip='192.168.%d.100/24' % i,
defaultRoute='via %s' % localIP)
self.addLink(host, switch)
def build( self, k=2, **opts ):
"k: number of hosts"
self.k = k
switch = self.addSwitch( 's1' )
for h in irange( 1, k ):
host = self.addHost( 'h%s' % h )
self.addLink( host, switch )
def __init__( self, N, S, **params ):
Topo.__init__( self, **params )
switch = self.addSwitch('s0')
#server host for sample
hs = self.addHost( 'hs%s' % '0' )
self.addLink(hs, switch)
for sw in irange( 1, S):
hosts = [ self.addHost( 'h%s' % h ) for h in irange( (sw-1)*N+1, sw*N ) ]
switchS = self.addSwitch('s'+str(sw))
print(switchS)
self.addLink(switch, switchS)
for host in hosts:
self.addLink(host, switchS)
def __init__(self, k=2, **opts):
"""Init.
k: number of switches (and hosts)
hconf: host configuration options
lconf: link configuration options"""
super(LinearTopo, self).__init__(**opts)
self.k = k
lastSwitch = None
#print "sys argument",sys.argv[2]
host_counter = int(sys.argv[2])
for i in irange(1, k):
#host = self.addHost('h%s' % i)
#self.addLink( host, switch)
if not lastSwitch:
for h in range(host_counter):
host = self.addHost('h%s' %(h+1))
switch = self.addSwitch('s%s' % i)
self.addLink( host, switch)
'''host1 = self.addHost('h%s' % i)
host2 = self.addHost('h%s' % (i+1))
switch = self.addSwitch('s%s' % i)
self.addLink( host1, switch)
self.addLink( host2, switch)'''
else:
host3 = self.addHost('h%s' % (host_counter+1))
switch = self.addSwitch('s%s' % i)
self.addLink( host3, switch)
if lastSwitch:
self.addLink( switch, lastSwitch)
lastSwitch = switch
def servers(hosts):
serverips = []
for i in irange(1,8):
for host in hosts:
if "server%d" % i in host.name.lower():
serverips.append(host.ip)
hosts.remove(host)
def __init__(self, k=Y, **opts):
"""Init.
k: number of switches (and hosts)
hconf: host configuration options
lconf: link configuration options"""
super(LinearTopo, self).__init__(**opts)
self.k =k
lastSwitch =None
t=1
first=None
for i in irange(1, k):
host1 =self.addHost('h%s'%t)
t=t+1
host2=self.addHost('h%s'%t)
t=t+1
switch =self.addSwitch('s%s'%i)
if i==1:
first=switch
self.addLink(host1, switch, bw=1, delay='5ms', loss=1, max_queue_size=1000, use_htb=True)
self.addLink(host2, switch, bw=2)
if lastSwitch:
self.addLink(switch, lastSwitch)
lastSwitch =switch
self.addLink(switch,first)
'''making the circular topology above'''
def __init__(self, k=2, **opts):
"""Init.
k: number of switches (and hosts)
hconf: host configuration options
lconf: link configuration options"""
super(LinearTopo, self).__init__(**opts)
self.k = k
lastSwitch = None
for i in irange(1, k):
host = self.addHost('h%s' % i, cpu=.5 / k)
switch = self.addSwitch('s%s' % i)
# 10 Mbps, 5ms delay, 1% loss, 1000 packet queue
self.addLink(
host,
switch,
bw=10,
delay='5ms',
loss=1,
max_queue_size=1000,
use_htb=True)
if lastSwitch:
self.addLink(
switch,
lastSwitch,
bw=10,
delay='5ms',
loss=1,
max_queue_size=1000,
use_htb=True)
lastSwitch = switch
def __init__(self, k=2, **opts):
super(FatTopo, self).__init__(**opts)
Corek = k
hk = int(k / 2)
Cs = []
As = []
Es = []
Hs = []
# generate the core switches and assign the dpid
for i in irange(1, int(Corek * Corek / 4)):
row = int((i - 1) / hk)
col = (i - 1) % hk
dpid = hk * 10000 + row * 100 + col
Cs.append(self.addSwitch('crSw%s' % (i - 1), dpid=int2dpid(dpid)))
print('crSw%s - %s' % ((i - 1), dpid))
# generate the aggregation switches and assign the dpid
for i in irange(1, Corek):
for j in irange(1, int(Corek / 2)):
pod = (i - 1)
switch = j + hk - 1
dpid = pod * 10000 + switch * 100 + 1
As.append(
self.addSwitch('agSw%s%s' % ((i - 1), (j - 1)),
dpid=int2dpid(dpid)))
print('agSw%s%s - %s' % ((i - 1), (j - 1), dpid))
# generate the edge switches and assign the dpid
for i in irange(1, Corek):
for j in irange(1, int(Corek / 2)):
pod = i - 1
switch = j - 1
dpid = pod * 10000 + switch * 100 + 1
Es.append(
self.addSwitch('edSw%s%s' % ((i - 1), (j - 1)),
dpid=int2dpid(dpid)))
print('EgSw%s%s - %s' % ((i - 1), (j - 1), dpid))
# generate the hosts and assign the ip address
for i in irange(1, int(Corek * Corek * Corek / 4)):
Hs.append(
self.addHost(
'h%s' % (i - 1),
ip='10.%s.%s.%s/8' %
((int((i - 1) / int(Corek * Corek / 4))),
int((i - 1) / int(Corek / 2) % int(Corek / 2)), 2 +
(i - 1) % int(Corek / 2))))
# connect the host with corresponding edge switch
counter = 0
for i in irange(1, int(Corek * Corek / 2)):
connect = 0
while connect < int(Corek / 2):
self.addLink(Es[i - 1], Hs[counter], connect, 0)
counter += 1
connect += 1
# connect the aggregation switch with corresponding edge switch
for i in irange(1, int(Corek * Corek / 2)):
offset = int((i - 1) / int(Corek / 2)) * int(Corek / 2) - 1
for j in irange(1, int(Corek / 2)):
self.addLink(As[i - 1], Es[j + offset], j - 1,
(i - 1) % int(Corek / 2) + int(Corek / 2))
# connect the core switch with corresponding aggregation switch
for i in irange(1, int(Corek * Corek / 4)):
offset = int((i - 1) / int(Corek / 2))
j = 0
counter = 0
while j < (Corek * int(Corek / 2)):
self.addLink(Cs[i - 1], As[j + offset], counter,
(i - 1) % int(Corek / 2) + int(Corek / 2))
j += int(Corek / 2)
counter += 1
def addSwitches():
return [self.addSwitch('s%s' % i) for i in irange(1, n)]
setLogLevel('info')
"Datacenter topology with 4 hosts per rack, 4 racks, and a root switch"
controllerIP = repr(os.environ.get('CONTROLLER_IP'))
self = Containernet(controller=RemoteController)
info('*** Adding controller at '+ controllerIP + '\n')
self.addController('c0', controller=RemoteController, ip=controllerIP, port=6653)
self.racks = []
rootSwitch = self.addSwitch('s1')
for i in irange(1, 2):
rack = self.buildRack(i)
self.racks.append(rack)
for switch in rack:
self.addLink(rootSwitch, switch)
"Build a rack of hosts with a top-of-rack switch"
dpid = (loc * 16) + 1
switch = self.addSwitch('s1r%s' % loc, dpid='%x' % dpid)
for n in irange(1, 5):
#host = self.addHost( 'h%sr%s' % ( n, loc ) )
#host = self.addHost('h%sr%s' % (n, loc), dimage="ubuntu:trusty")
host = self.addDocker('h%sr%s', dimage="acksec/dc26", environment={"CONTROLLER_IP": controllerIP}, working_dir="/root")
def stringBandwidthTest(host_class, controller_class, link_class, size, tdf,
data_file):
"Check bandwidth at various lengths along a switch chain."
topo_class = StringTestTopo(size)
net = Mininet(topo=topo_class,
host=host_class,
switch=OVSKernelSwitch,
controller=controller_class,
waitConnected=True,
link=link_class)
net.start()
src, dst = net.hosts[0], net.hosts[1]
print "*** testing basic connectivity"
net.ping([src, dst])
if tdf == 1:
num_pings = 3
for i in irange(1, num_pings):
ping_result = list(net.pingFull([src, dst]))
rttavg = ping_result[0][2][3]
data_file.write("%s\t" % rttavg)
data_file.flush()
print "*** testing bandwidth"
print "testing", src, "<->", dst
num_rounds = 8
#cli_results = []
ser_results = []
omit = 1
time = 11
start = timeit.default_timer()
for i in irange(1, num_rounds):
bandwidth = net.iperf([src, dst],
l4Type='TCP',
format='m',
time=time,
omit=omit)
flush()
serout = bandwidth[0]
cliout = bandwidth[1]
if len(serout) > 0:
serDataStr, unit = serout.split(" ")
serData = float(serDataStr)
if serData > 0.1:
ser_results.append(serData)
#if len(cliout) > 0:
#cliDataStr, unit = cliout.split(" ")
#cliData = float(cliDataStr)
#if cliData > 0.1:
#cli_results.append( cliData )
end = timeit.default_timer()
elapsed = end - start
print "elapsed: %s\n" % elapsed
# unit = Mbits/sec
#avgCliBw = numpy.mean( cli_results )
#stdevCliBw = numpy.std( cli_results )
maxSerBw = numpy.amax(ser_results)
minSerBw = numpy.amin(ser_results)
if len(ser_results) >= 10:
ser_results.remove(maxSerBw)
ser_results.remove(minSerBw)
avgSerBw = numpy.mean(ser_results)
stdevSerBw = numpy.std(ser_results)
print "Avg = %f" % avgSerBw
print "Std = %f" % stdevSerBw
#data_file.write("%s\t%s\t%s\t%s\t%s\n" % (size, avgCliBw, stdevCliBw, maxCliBw, minCliBw))
data_file.write("%s\t%s\t%s\t%s\n" % (size, avgSerBw, stdevSerBw, elapsed))
data_file.flush()
net.stop()
return avgSerBw, stdevSerBw
def buildRouter(self, network, r, create_edge, create_srs):
r.name = r.name.encode('ascii', 'ignore')
router = network.addSwitch(r.name + '-rtr',
dpid=self.padDpid(r.self_dpid))
nat = network.addSwitch(r.name + '-nat', dpid=self.padDpid(r.nat_dpid))
network.addLink(router, nat, **self.linkopts)
translator = network.addSwitch(r.name + '-tr',
dpid=self.padDpid(r.tr_dpid))
acl_table = network.addSwitch(r.name + '-acl',
dpid=self.padDpid(r.acl_dpid))
vlan = network.addSwitch(r.name + '-vlan',
dpid=self.padDpid(r.vlan_dpid))
for (i, s) in enumerate(r.subnets):
s.gw = s.gw.encode('ascii', 'ignore')
N = i + 1
inPt = 2 * N - 1
outPt = 2 * N
rtrPt = N + 1
network.addLink(vlan,
acl_table,
port1=r.num_physical + N,
port2=inPt,
**self.linkopts)
network.addLink(acl_table,
translator,
port1=outPt,
port2=inPt,
**self.linkopts)
network.addLink(translator,
router,
port1=outPt,
port2=rtrPt,
**self.linkopts)
if not create_srs:
continue
for p in r.ports:
# Not a vlan tag
if p.vlan_type == '':
s = filter(lambda x: p.id in x.physical_portid, r.subnets)[0]
srs = self.subnetRootSwitch[subnetStr(s.addr, s.mask)]
network.addLink(srs, vlan, port2=p.id, **self.linkopts)
# if there's room for hosts, add an edge switch with some hosts!
if s.mask < 30 and create_edge:
self.globalEdgeSwCount += 1
edge_switch = network.addSwitch(
's' + str(self.globalEdgeSwCount))
network.addLink(srs, edge_switch, **self.linkopts)
for h in irange(1, self.numHostsPerSubnet):
self.globalHostCount += 1
name = "host%d" % self.globalHostCount
ip = self.nextSubnetHost(s.addr, s.mask, s.gw)
host = network.addHost(
name,
ip='%s/%d' % (ip, s.mask),
defaultRoute='dev %s-eth0 via %s' % (name, s.gw))
network.addLink(host, edge_switch, **self.linkopts)
elif p.vlan_type.lower() == 'access':
s = filter(lambda x: p.id in x.physical_portid, r.subnets)
if len(s) == 0:
print "Warning! %s:%s is not in a subnet!" % (r.name,
p.name)
continue
s = s[0]
if s.mask < 30 and create_edge:
self.globalHostCount += 1
name = "host%d" % self.globalHostCount
ip = self.nextSubnetHost(s.addr, s.mask, s.gw)
host = network.addHost(name,
ip='%s/%d' % (ip, s.mask),
defaultRoute='dev %s-eth0 via %s' %
(name, s.gw))
network.addLink(host, vlan, port2=p.id, **self.linkopts)
elif p.vlan_type.lower() == 'trunk':
self.trunkPorts[r.name.lower(), p.name.lower()] = p.id
def addHosts():
h = n * k
return [self.addHost('h%s' % i) for i in irange(1, h)]
def run_dasdn_expt(net, n):
"Run experiment"
print 'thread %s is running...' % threading.current_thread().name
# 创建5个节点的可变时间 (n)
if args.time !=-1:
TRANS_SECONDS = [args.time*0.5, args.time, args.time*0.5, args.time*1.5, args.time]
if (len(TRANS_SECONDS) < args.n): # 检查节点时间长度
output("节点可变时间的数据不足，长度 %d < n(%d) , exit ... " %(len(TRANS_SECONDS), args.n))
exit()
else:
TRANS_NUMS = [args.num_mb*0.5, args.num_mb, args.num_mb*1.5, args.num_mb*2, args.num_mb*0.5]
WASTE_TIMES = [0, 0, 5, 0, 0] # 是否存在空闲时间
print 'len: WASTE_TIMES %d' % len(WASTE_TIMES)
print 'len: TRANS_SECONDS %d' % len(TRANS_SECONDS)
# Start the bandwidth and cwnd monitors in the background
monitors = []
monitor = Process(target=monitor_devs_ng,
args=('%s/bwm.txt' % args.dir, 1.0))
monitor.start()
monitors.append(monitor)
monitor = Process(target=monitor_cpu, args=('%s/cpu.txt' % args.dir,))
monitor.start()
monitors.append(monitor)
# monitor = Process(target=monitor_qlen, args=('s1-eth1', 0.01, '%s/qlen_s1-eth1.txt' % (args.dir)))
# monitor.start()
# monitors.append(monitor)
start_tcpprobe()
# Get receiver and clients
recvr = net.getNodeByName('h99')
clients = [net.getNodeByName('h%s' % i)
for i in irange(1, n)]
cprint("Receiver: %s" % recvr, 'magenta')
cprint("Clients: " + ', '.join([str(c) for c in clients]),
'magenta')
# Start the receiver
port = 5001
recvr.cmd('iperf -s -p', port,
'> %s/iperf_server.txt' % args.dir, '&')
waitListening(clients[0], recvr, port)
for i in range(n):
# for c in clients:
c = clients[i]
waste_time = WASTE_TIMES[i]
sleep(1+waste_time)
cmd = ['iperf',
'-c', recvr.IP(),
'-p', port,
'-i', 1, # reporting interval
'-Z reno', # use TCP Reno
#'-yc', # report output as comma-separated values
]
outfile = {}
outfile[c] = '%s/iperf_%s.txt' % (args.dir, c.name)
# Ugh, this is a bit ugly....
redirect = ['>', outfile[c]]
if args.time != -1 :
seconds = TRANS_SECONDS[i]
cmd += ['-t', seconds ] # change -t seconds to -d num_bytes seconds * 75000000
output(cmd , "\n")
c.sendCmd(cmd + redirect, printPid=False) # background cmd
output(' client %s connect with %d seconds, waste %d seconds ..\n' % (c, seconds, waste_time))
#sleep(seconds)
#output(' client %s start ... \n' % c )
progress(seconds) # 读秒等待
else:
num_mb = TRANS_NUMS[i]
cmd += ['-d', "%sM" % (num_mb) ] # change -t seconds to -d num_bytes seconds * 75000000
output(cmd , "\n")
c.cmd(cmd + redirect, printPid=False) # foreground cmd
# Start command line for debug
if args.cli:
CLI(net)
# Count down time
# progress(seconds * n)
# Wait for clients to complete
# If you don't do this, iperfs may keep running!
output('Waiting for clients to complete...\n')
for c in clients:
c.waitOutput(verbose=True)
recvr.cmd('kill %iperf')
# Shut down monitors
for monitor in monitors:
monitor.terminate()
stop_tcpprobe()
def __init__(self, linkopts1, linkopts2, linkopts3, k=2, **opts):
#linkopts1 = performance parameters for the links between core and aggregation switches
#linkopts2 = performance parameters for the links between aggregation and edge switches
#linkopts3 = performance parameters for the links between edge switches and host
super(FatTreeTopology, self).__init__(**opts)
self.fanout = k
self.pods = []
self.cores = []
self.countHosts = 0
self.countSwitch = 0
self.hostForPod = 0
self.switchPerLayer = (self.fanout / 2)
self.edgeHostConn = 0
self.edgeAggConn = 0
self.aggCoreConn = 0
self.numCores = 0
#Creates Core Switches
countCores = (self.fanout / 2)**2
for i in irange(1, countCores):
self.countSwitch += 1
coreSwitch = self.addSwitch("s%s" % (self.countSwitch),
cls=OVSKernelSwitch,
failMode='standalone')
self.cores.append(coreSwitch)
self.numCores += 1
#Creates Pods + Hosts
for i in irange(1, self.fanout):
self.pods.append(self.createPod(i, linkopts2, linkopts3))
#Links Core Switches to Pods
count = 0 #Core switch Position
for i in self.cores:
for j in self.pods:
if count < (self.fanout / 2):
self.addLink(j.layers[0][((self.fanout / 2) / 2) - 1], i,
**linkopts1)
else:
self.addLink(j.layers[0][((self.fanout / 2) / 2)], i,
**linkopts1)
self.aggCoreConn += 1
count += 1
self.corePodConn = self.numCores * k
print("\n---------------------%s-ary fat tree ---------------" %
self.fanout)
print("number of pods : %s" % self.fanout)
print("hosts per pod : %s" %
self.hostForPod)
print("number of switches per layer in pod : %s" %
self.switchPerLayer)
print("number of switch ports in pod : %s" % self.fanout)
print("edge switch-host connections : %s" %
self.edgeHostConn)
print("edge switch-aggregation switch connections: %s" %
self.edgeAggConn)
print("aggregation switch-core switch connections: %s" %
self.aggCoreConn)
print("number of core switches : %s" % self.numCores)
print("number of pods core switches connect to : %s" %
self.corePodConn)
print("total number of hosts : %s" %
self.countHosts)
print("-----------------------------------------------------")
def simple_test():
"""Create and test a simple network"""
topo = MyTopo(num_sws=switches_per_router)
net = Mininet(topo,
link=TCLink,
switch=OVSKernelSwitch,
autoSetMacs=True,
autoStaticArp=False,
controller=lambda name: RemoteController(
name, ip=controllerIP, port=6633))
net.start()
if monitoring == 1:
# --- Monitoring
os.popen('ip link show > ports.txt')
# '''
snmp_dev_proc = subprocess.Popen(
'while sleep %s; do %s; snmpwalk -v 1 -c public -O e localhost 1.3.6.1.2.1.25.2.3.1.6.1;'
' snmpwalk -v 1 -c public -O e localhost 1.3.6.1.2.1.25.3.3.1.2; done>> DevStats.txt 2>> err.txt &'
% (interval, dateCmd),
shell=True)
c0 = net.get('c0')
c0.cmd(
'snmpd -Lsd -Lf /dev/null -u snmp -I -smux -p /var/run/snmpd.pid -c /etc/snmp/snmpd.conf'
)
snmp_con_proc = c0.cmd(
'while sleep %s; do %s; snmpwalk -v 1 -c public -O e %s 1.3.6.1.2.1.25.2.3.1.6.1;'
' snmpwalk -v 1 -c public -O e %s 1.3.6.1.2.1.25.3.3.1.2; done>> ControllerStats.txt 2>> err.txt &'
% (interval, dateCmd, controllerIP, controllerIP))
for r in irange(1, numNetworks):
router = net.get('r%s0' % r)
router.cmd(
'snmpd -Lsd -Lf /dev/null -u snmp -I -smux -p /var/run/snmpd.pid -c /etc/snmp/snmpd.conf'
)
router.cmd(
'while sleep %s; do %s; snmpwalk -v 1 -c public -O e %s 1.3.6.1.2.1.2.2.1.16; '
'done>> Router%sIfOutStats.txt 2>> err.txt &' %
(interval, dateCmd, router.IP(), r)) # .1.3.6.1.2.1.2.2.1.16
# '''
# net.staticArp()
print "Dumping host connections"
dumpNodeConnections(net.hosts)
if CLIon == 1:
CLI(net)
coefficient = get_coeff() if no_time_run == 2 else 1
append_file('coefficients-%s-%s.txt' % (sys.argv[2], sys.argv[3]),
coefficient)
start_time = time.time()
# ------- removed net.pingAll() ----- replaced with net.staticArp()
# ------- removed CLI( net )
n = int(sys.argv[1]) # getting number of IPerf tests from command line
''' ---- Removed 02-01-2018 ---- Invalid after hosts.append()
hpairs = len(net.hosts)/2
if n > hpairs:
print "Number of IPerf tests exceeds host pairs. Reducings tests from %s to %s" %(n,hpairs)
n = hpairs
else:
print "Number of IPerf tests %s" %n
'''
if test_with_data == 1:
t = {}
# Creating n threads, one for each iperf session
for i in range(int(n)):
dt = DataTraffic()
t[i] = threading.Thread(target=DataTraffic.get_perf_metrics,
args=(dt, net, i))
t[i].daemon = True
t[i].start()
time.sleep(interval)
# ----- removed time.sleep(20) ------ replaced with join()
# Making the current thread wait for all the created threads to complete
for i in range(int(n)):
t[i].join()
for r in irange(1, numNetworks):
router = net.get('r%s0' % r)
router.sendInt()
net.stop()
if monitoring == 1:
c0.sendInt()
snmp_dev_proc.kill()
# os.kill(int(snmp_con_proc.split()[1]), signal.CTRL_C_EVENT)
stop_time = time.time()
print_file('blocked.txt', blocked)
print_file('dropped.txt', dropped)
print(stop_time - start_time)
print os.system(
'%s >> log.txt; echo %s >> log.txt' %
(dateCmd, stop_time -
start_time)) # dummy command to print seconds of the clock
def MultipathTreeNet(depth=2, fanout=4, bw=BW, cpu=-1, queue=100):
"Create an empty network and add nodes to it."
host = custom(CPULimitedHost, cpu=cpu)
link = custom(TCLink, bw=bw, max_queue_size=queue)
net = Mininet(host=host,
link=link,
switch=OVSKernelSwitch,
controller=RemoteController,
autoSetMacs=True,
autoStaticArp=False)
info('*** Adding controller\n')
net.addController('c0')
info('*** Adding hosts\n')
switches = []
allHosts = []
i = 1
# Adding hosts
for n in irange(1, pow(depth, fanout)):
print "h%s" % n
host = net.addHost("h%s" % n, ip=("10.0.0.%s/24" % str(i)))
i = i + 1
allHosts.append(host)
info('*** Adding switches\n')
i = 1
# Adding switches
rootSwitches = []
for n in irange(1, 2):
print "s%s" % i
switch = net.addSwitch("s%s" % i)
rootSwitches.append(switch)
i = i + 1
torSwitches = []
for n in irange(1, 4):
print "s%s" % i
switch = net.addSwitch("s%s" % i)
torSwitches.append(switch)
i = i + 1
info('*** Wiring up switches\n')
# Wiring up switches
i = 1
for switch in torSwitches:
for up in rootSwitches:
if i == 1:
bandwidth = bw #10
else:
bandwidth = bw
#bandwidth=50
i = i + 1
link = custom(TCLink, bw=bandwidth, max_queue_size=queue)
linkObj = net.addLink(up, switch, cls=link)
print "link=" + str(linkObj)
info('*** Creating links to hosts\n')
# Creating links to hosts
for n in irange(0, 3):
switch = torSwitches[n]
for m in irange(0, 3):
host = allHosts[(n * 4) + m]
print "linking %s to %s" % (host.name, switch.name)
net.addLink(host, switch)
print ""
return net
def ShamrockNet(numSwitches=2,
numHostsFirstSwitch=12,
numHostsSecondSwitch=4,
L=1,
bw=BW,
cpu=-1,
queue=100,
remoteController=True):
"Create an empty network and add nodes to it."
host = custom(CPULimitedHost, cpu=cpu)
link = custom(TCLink, bw=bw, max_queue_size=queue)
if remoteController is True:
controller = RemoteController
else:
controller = OVSController
net = Mininet(host=host,
link=link,
switch=OVSKernelSwitch,
controller=controller,
autoSetMacs=True,
autoStaticArp=False)
info('*** Adding controller\n')
if remoteController is True:
#net.addController('c0', ip='172.16.2.1', port=6633)
net.addController('c0', ip='127.0.0.1', port=6633)
else:
net.addController('c0')
info('*** Adding hosts\n')
switches = []
allHosts = []
numSwitches = 2
i = 1
# Adding hosts
n = "1"
hosts = []
for m in irange(1, numHostsFirstSwitch):
print "s%sh%s" % (n, m)
host = net.addHost("s%sh%s" % (n, m), ip=("10.0.0.%s/24" % str(i)))
i = i + 1
hosts.append(host)
allHosts.append(hosts)
n = "2"
hosts = []
for m in irange(1, numHostsSecondSwitch):
print "s%sh%s" % (n, m)
host = net.addHost("s%sh%s" % (n, m), ip=("10.0.0.%s/24" % str(i)))
i = i + 1
hosts.append(host)
allHosts.append(hosts)
info('*** Adding switches\n')
# Adding switches
for n in irange(1, numSwitches):
print "s%s" % n
switch = net.addSwitch("s%s" % n)
switches.append(switch)
info('*** Wiring up switches\n')
# Wiring up switches
i = 1
last = None
for switch in switches:
if last:
for l in irange(1, L):
# print "linking %s to %s" % (last.name, switch.name)
# if i == 1:
# bandwidth=10
# else:
# bandwidth=bw
#bandwidth=bw
bandwidth = 1000
i = i + 1
link = custom(TCLink, bw=bandwidth, max_queue_size=queue)
linkObj = net.addLink(last, switch, cls=link)
print "link=" + str(linkObj)
last = switch
info('*** Creating links to hosts\n')
# Creating links to hosts
for n in irange(0, numSwitches - 1):
switch = switches[n]
for host in allHosts[n]:
print "linking %s to %s" % (host.name, switch.name)
net.addLink(host, switch)
print ""
return net
def __init__(self, **opts):
# Initialize object argument
super(SDNTopo, self).__init__(*opts)
self.k = args.nodes
self.switch_list = []
# Create the k switches of the mesh topology
for i in irange(3, self.k + 2):
new_switch = self.addSwitch(f"s{i}", dpid=f"{i}")
self.switch_list.append(new_switch)
# Create the edge switches
e1 = self.addSwitch("edge1", dpid="101")
e2 = self.addSwitch("edge2", dpid="102")
# Create the bridge switches and Links
s1 = self.addSwitch("s1", dpid="1")
s2 = self.addSwitch("s2", dpid="2")
self.addLink(s1, e1, bw=args.bw, loss=args.loss, delay=args.delay)
self.addLink(s2, e2, bw=args.bw, loss=args.loss, delay=args.delay)
# Connect the edge switches with 2 switches
self.addLink(s1, self.switch_list[0], bw=args.bw, loss=args.loss, delay=args.delay)
self.addLink(s2, self.switch_list[-1], bw=args.bw, loss=args.loss, delay=args.delay)
if not self.k % 2 and not args.random:
self.addLink(s2, self.switch_list[-2], bw=args.bw, loss=args.loss, delay=args.delay)
# Make STP links
if not args.random:
# Connect each switch in a defined topology
for i in range(0, len(self.switch_list) - 2, 2):
for j in range(1, 3):
self.addLink(
self.switch_list[i],
self.switch_list[i + j],
bw=args.bw,
loss=args.loss,
delay=args.delay,
)
else:
# Connect each switch with a random previous one
for i in range(1, len(self.switch_list)):
connect_switch = random.choice(self.switch_list[:i])
self.addLink(
self.switch_list[i],
connect_switch,
bw=args.bw,
loss=args.loss,
delay=args.delay,
)
# Add one host to each core switch
for i in range(args.hosts):
new_host = self.addHost(f"h{i}", ip=f"10.10.10.{i+1}/24")
self.addLink(
new_host,
self.switch_list[random.randint(0, len(self.switch_list) - 1)],
bw=args.bw,
loss=args.loss,
delay=args.delay,
)
class dcFatTreeTop( Topo ):
"Linear topology of k switches, with one host per switch."
def __init__(self, k, **opts):
Top.__init__(**opts)
self.k = k
link1 = dict(bw=10, delay='1ms', loss=0, max_queue_size=1000, use_htb=True)
link2 = dict(bw=5, delay='10ms', loss=0, max_queue_size=500, use_htb=True)
link3 = dict(bw=1, delay='15ms', loss=0, max_queue_size=100, use_htb=True)
# Creating an array of core switches
# Adding them in an array so that they can be refered to later
for i in irange(0, k-1):
"core switch"
coreSwitch = self.addSwitch('c%s%s' % (i+1, 0))
#coreList.insert(i, coreSwitch)
coreList.append(coreSwitch)
#lastSwitch = None
print "entering aggregation switches"
for i in irange(1, k):
"aggregation switches"
aggSwitch1 = self.addSwitch('a%s%s' % (i, 1))
aggSwitch2 = self.addSwitch('a%s%s' % (i, 3))
aggList.append(aggSwitch1)
aggList.append(aggSwitch2)
torSwitch1 = self.addSwitch('t%s%s' % (i, 2))
torSwitch2 = self.addSwitch('t%s%s' % (i, 4))
torList.append(torSwitch1)
torList.append(torSwitch2)
"host = self.addHost('h%s%s' % (i, i+1))"
host11 = self.addHost('h%s%s' % (i, 1))
host12 = self.addHost('h%s%s' % (i, 2))
host13 = self.addHost('h%s%s' % (i, 3))
host14 = self.addHost('h%s%s' % (i, 4))
#hosts1 = [ net.addHost( 'h%d' % n ) for n in 3, 4 ]
"connection of the hosts to the left tor switch "
self.addLink(host11, torSwitch1, **link3)
self.addLink(host12, torSwitch1, **link3)
"connection of the hosts to the right tor switch "
self.addLink(host13, torSwitch2, **link3)
self.addLink(host14, torSwitch2, **link3)
"Connection of the the left tor switch to aggregation switches"
self.addLink(torSwitch1, aggSwitch1, **link2)
self.addLink(torSwitch1, aggSwitch2, **link2)
"connection of the the right tor switch to aggregation switches"
self.addLink(torSwitch2, aggSwitch1, **link2)
self.addLink(torSwitch2, aggSwitch2, **link2)
"connect the aggregation switch to top pod core switch"
if k == 1:
for r in irange(0, k): #this is to go through the agg switches
self.addLink(aggList[r], coreList[0])
else:
for r in irange(0, (k*2)-1): #this is to go through the agg switches
if r % 2 == 0: #if agg switch is even then connect to first half
for j in irange(0, ((k/2)-1)): #this is to go through the core switches
self.addLink(aggList[r], coreList[j], **link1)
else:
for j in irange((k/2), k-1): #this is to go through the core switches
self.addLink(aggList[r], coreList[j], **link1)
allList.extend(coreList)
allList.extend(aggList)
allList.extend(torList)
def evenSimpleTest():
for sw in allList:
print allList[sw]
def simpleTest():
# argument to put in either remote or local controller
"Create and test a simple network"
c0 = RemoteController( 'c0', ip='192.168.90.146' )
# the cmap here needs to dynamically take the switch name from the switchLists[] so that it is not static
#cmap = { 'a11': c0, 'a12': c0, 'a21': c0, 'a22': c0, 'a31': c0, 'a32': c0, 'a41': c0, 'a42': c0, 'c11': c0, 'c21': c0, 'c31': c0, 'c41': c0, 't11': c0, 't12': c0, 't21': c0, 't22': c0, 't31': c0, 't32': c0, 't41': c0, 't42': c0}
class MultiSwitch( OVSSwitch ):
"Custom Switch() subclass that connects to different controllers"
def start( self, controllers ):
return OVSSwitch.start( self, [ cmap[ self.name ] ] )
#section for handling the differnt argumetns.... simpleTest(arg1, arg2, ...) will take in arguments from user
# topo = dcFatTreeTopo(k=2)
topo = dcFatTreeTop(k=2)
net = Mininet( topo=topo, switch=MultiSwitch, build=False, link=TCLink )
print "calling Mininet ctor"
print "connecting all SWITCHES to controller with cmap"
cString = "{"
for i in irange(0, len(allList)-1):
if i != len(allList)-1:
tempCString = "'" + allList[i] + "'" + " : c0, "
else:
tempCString = "'" + allList[i] + "'" + " : c0 "
cString += tempCString
cmapString = cString + "}"
#print "wowzer" + cmapString
cmap = cmapString
net.addController(c0)
net.build()
net.start()
print "Dumping host connections"
dumpNodeConnections(net.hosts)
print "Testing network connectivity"
#def perfTest():
# if user test argument is active then pick the correct test
net.pingAll()
net.pingAll()
print "Testing bandwidth between h11 and h12..............."
#h11, h12 = net.get('h11', 'h12')
#net.iperf((h11, h12)
#print "Testing bandwidth between h11 and h14..............."
h11, h14 = net.get('h11', 'h14')
net.iperf((h11, h14))
#print "Testing bandwidth between h11 and h16..............."
h11, h22 = net.get('h11', 'h22')
net.iperf((h11, h22))
#print "Testing bandwidth between h11 and h18..............."
h11, h24 = net.get('h11', 'h24')
net.iperf((h11, h24))
# also argument for generating traffic
# arugment for stat analysis
CLI( net )
net.stop()
