344 lines
11 KiB
Python
344 lines
11 KiB
Python
from .parameter import Parameter
|
|
|
|
import math
|
|
|
|
|
|
class NetemAt(object):
|
|
def __init__(self, at, cmd):
|
|
self.at = at
|
|
self.cmd = cmd
|
|
self.delta = 0
|
|
|
|
def __str__(self):
|
|
return "Netem... at " + str(self.at) + "(" + str(self.delta) + \
|
|
") will be " + self.cmd
|
|
|
|
|
|
class LinkCharacteristics(object):
|
|
tcNetemParent = "1:1"
|
|
tcHtbClassid = "10"
|
|
tcNetemHandle = "1:10"
|
|
|
|
def bandwidthDelayProductDividedByMTU(self):
|
|
rtt = 2 * float(self.delay)
|
|
""" Since bandwidth is in Mbps and rtt in ms """
|
|
bandwidthDelayProduct = (float(self.bandwidth) * 125000.0) * (rtt / 1000.0)
|
|
return int(math.ceil(bandwidthDelayProduct * 1.0 / 1500.0))
|
|
|
|
def bufferSize(self):
|
|
return (1500.0 * self.bandwidthDelayProductDividedByMTU()) + (float(self.bandwidth) * 1000.0 * float(self.queuingDelay) / 8)
|
|
|
|
def extractQueuingDelay(self, queueSize, bandwidth, delay, mtu=1500):
|
|
# rtt = 2 * float(delay)
|
|
# bdp_queue_size = int((float(rtt) * float(bandwidth) * 1024 * 1024) / (int(mtu) * 8 * 1000))
|
|
# if int(queueSize) <= bdp_queue_size:
|
|
# Returning 0 seems to bypass everything, then only limited by CPU.
|
|
# This is not what we want...
|
|
# return 1
|
|
|
|
# queuingQueueSize = int(queueSize) - bdp_queue_size
|
|
queuingDelay = (int(queueSize) * int(mtu) * 8.0 * 1000.0) / (float(bandwidth) * 1024 * 1024)
|
|
return max(int(queuingDelay), 1)
|
|
|
|
def __init__(self, id, delay, queueSize, bandwidth, loss, back_up=False):
|
|
self.id = id
|
|
self.delay = delay
|
|
self.queueSize = queueSize
|
|
self.bandwidth = bandwidth
|
|
self.loss = loss
|
|
self.queuingDelay = str(self.extractQueuingDelay(queueSize, bandwidth, delay))
|
|
self.netemAt = []
|
|
self.back_up = back_up
|
|
|
|
def addNetemAt(self, n):
|
|
if len(self.netemAt) == 0:
|
|
n.delta = n.at
|
|
self.netemAt.append(n)
|
|
else:
|
|
if n.at > self.netemAt[-1].at:
|
|
n.delta = n.at - self.netemAt[-1].at
|
|
self.netemAt.append(n)
|
|
else:
|
|
print("Do not take into account " + n.__str__() + \
|
|
"because ooo !")
|
|
pass
|
|
|
|
def buildBwCmd(self, ifname):
|
|
cmd = ""
|
|
for n in self.netemAt:
|
|
cmd = cmd + "sleep {}".format(n.delta)
|
|
cmd = cmd + " && tc qdisc del dev {} root ".format(ifname)
|
|
cmd = cmd + " ; tc qdisc add dev {} root handle 5:0 tbf rate {}mbit burst 15000 limit {} &&".format(ifname, self.bandwidth, int(self.bufferSize()))
|
|
|
|
cmd = cmd + " true &"
|
|
return cmd
|
|
|
|
def buildNetemCmd(self, ifname):
|
|
cmd = ""
|
|
for n in self.netemAt:
|
|
cmd = cmd + "sleep " + str(n.delta)
|
|
cmd = cmd + " && tc qdisc del dev " + ifname + " root "
|
|
cmd = cmd + " ; tc qdisc add dev {} root handle 10: netem {} delay {}ms limit 50000 &&".format(ifname, n.cmd, self.delay)
|
|
|
|
cmd = cmd + " true &"
|
|
return cmd
|
|
|
|
def buildPolicingCmd(self, ifname):
|
|
cmd = ""
|
|
for n in self.netemAt:
|
|
cmd = cmd + "sleep {}".format(n.delta)
|
|
cmd = cmd + " && tc qdisc del dev {} ingress".format(ifname)
|
|
cmd = cmd + " ; tc qdisc add dev {} handle ffff: ingress".format(ifname)
|
|
cmd = cmd + " && tc filter add dev {} parent ffff: u32 match u32 0 0 police rate {}mbit burst {} drop && ".format(ifname, self.bandwidth, int(self.bufferSize() * 1.2))
|
|
|
|
cmd = cmd + " true &"
|
|
return cmd
|
|
|
|
def asDict(self):
|
|
d = {}
|
|
d['bw'] = float(self.bandwidth)
|
|
d['delay'] = self.delay + "ms"
|
|
d['loss'] = float(self.loss)
|
|
d['max_queue_size'] = int(self.queueSize)
|
|
return d
|
|
|
|
def __str__(self):
|
|
s = "Link id : " + str(self.id) + "\n"
|
|
s = s + "\tDelay : " + str(self.delay) + "\n"
|
|
s = s + "\tQueue Size : " + str(self.queueSize) + "\n"
|
|
s = s + "\tBandwidth : " + str(self.bandwidth) + "\n"
|
|
s = s + "\tLoss : " + str(self.loss) + "\n"
|
|
s = s + "\tBack up : " + str(self.back_up) + "\n"
|
|
for l in self.netemAt:
|
|
s = s + "\t" + l.__str__() + "\n"
|
|
return s
|
|
|
|
|
|
class TopoParameter(Parameter):
|
|
LSUBNET = "leftSubnet"
|
|
RSUBNET = "rightSubnet"
|
|
netemAt = "netemAt_"
|
|
changeNetem = "changeNetem"
|
|
defaultValue = {}
|
|
defaultValue[LSUBNET] = "10.1."
|
|
defaultValue[RSUBNET] = "10.2."
|
|
defaultValue[changeNetem] = "false"
|
|
|
|
def __init__(self, paramFile):
|
|
Parameter.__init__(self, paramFile)
|
|
self.linkCharacteristics = []
|
|
self.loadLinkCharacteristics()
|
|
self.loadNetemAt()
|
|
print(self.__str__())
|
|
|
|
def loadNetemAt(self):
|
|
if not self.getParam(TopoParameter.changeNetem) == "yes":
|
|
return
|
|
for k in sorted(self.paramDic):
|
|
if k.startswith(TopoParameter.netemAt):
|
|
i = int(k[len(TopoParameter.netemAt):])
|
|
val = self.paramDic[k]
|
|
if not isinstance(val, list):
|
|
tmp = val
|
|
val = []
|
|
val.append(tmp)
|
|
self.loadNetemAtList(i, val)
|
|
|
|
def loadNetemAtList(self, id, nlist):
|
|
for n in nlist:
|
|
tab = n.split(",")
|
|
if len(tab)==2:
|
|
o = NetemAt(float(tab[0]), tab[1])
|
|
if id < len(self.linkCharacteristics):
|
|
self.linkCharacteristics[id].addNetemAt(o)
|
|
else:
|
|
print("Error can't set netem for link " + str(id))
|
|
else:
|
|
print("Netem wrong line : " + n)
|
|
print(self.linkCharacteristics[id].netemAt)
|
|
|
|
def loadLinkCharacteristics(self):
|
|
i = 0
|
|
for k in sorted(self.paramDic):
|
|
if k.startswith("path"):
|
|
tab = self.paramDic[k].split(",")
|
|
bup = False
|
|
loss = "0.0"
|
|
if len(tab) == 5:
|
|
loss = tab[3]
|
|
bup = tab[4] == 'True'
|
|
if len(tab) == 4:
|
|
try:
|
|
loss = float(tab[3])
|
|
loss = tab[3]
|
|
except ValueError:
|
|
bup = tab[3] == 'True'
|
|
if len(tab) == 3 or len(tab) == 4 or len(tab) == 5:
|
|
path = LinkCharacteristics(i,tab[0],
|
|
tab[1], tab[2], loss, bup)
|
|
self.linkCharacteristics.append(path)
|
|
i = i + 1
|
|
else:
|
|
print("Ignored path :")
|
|
print(self.paramDic[k])
|
|
|
|
def getParam(self, key):
|
|
val = Parameter.getParam(self, key)
|
|
if val is None:
|
|
if key in TopoParameter.defaultValue:
|
|
return TopoParameter.defaultValue[key]
|
|
else:
|
|
raise Exception("Param not found " + key)
|
|
else:
|
|
return val
|
|
|
|
def __str__(self):
|
|
s = Parameter.__str__(self)
|
|
s = s + "\n"
|
|
for p in self.linkCharacteristics[:-1]:
|
|
s = s + p.__str__() + "\n"
|
|
s = s + self.linkCharacteristics[-1].__str__()
|
|
return s
|
|
|
|
class Topo(object):
|
|
mininetBuilder = "mininet"
|
|
multiIfTopo = "MultiIf"
|
|
ECMPLikeTopo = "ECMPLike"
|
|
twoIfCongTopo = "twoIfCong"
|
|
multiIfCongTopo = "MultiIfCong"
|
|
topoAttr = "topoType"
|
|
switchNamePrefix = "s"
|
|
routerNamePrefix = "r"
|
|
clientName = "Client"
|
|
serverName = "Server"
|
|
routerName = "Router"
|
|
cmdLog = "command.log"
|
|
|
|
"""Simple MpTopo"""
|
|
def __init__(self, topoBuilder, topoParam):
|
|
self.topoBuilder = topoBuilder
|
|
self.topoParam = topoParam
|
|
self.changeNetem = topoParam.getParam(TopoParameter.changeNetem)
|
|
self.logFile = open(Topo.cmdLog, 'w')
|
|
|
|
def getLinkCharacteristics(self):
|
|
return self.topoParam.linkCharacteristics
|
|
|
|
def commandTo(self, who, cmd):
|
|
self.logFile.write(who.__str__() + " : " + cmd + "\n")
|
|
return self.topoBuilder.commandTo(who, cmd)
|
|
|
|
def notNSCommand(self, cmd):
|
|
"""
|
|
mainly use for not namespace sysctl.
|
|
"""
|
|
self.logFile.write("Not_NS" + " : " + cmd + "\n")
|
|
return self.topoBuilder.notNSCommand(cmd)
|
|
|
|
def getHost(self, who):
|
|
return self.topoBuilder.getHost(who)
|
|
|
|
def addHost(self, host):
|
|
return self.topoBuilder.addHost(host)
|
|
|
|
def addSwitch(self, switch):
|
|
return self.topoBuilder.addSwitch(switch)
|
|
|
|
def addLink(self, fromA, toB, **kwargs):
|
|
self.topoBuilder.addLink(fromA,toB,**kwargs)
|
|
|
|
def getCLI(self):
|
|
self.topoBuilder.getCLI()
|
|
|
|
def startNetwork(self):
|
|
self.topoBuilder.startNetwork()
|
|
|
|
def closeLogFile(self):
|
|
self.logFile.close()
|
|
|
|
def stopNetwork(self):
|
|
self.topoBuilder.stopNetwork()
|
|
|
|
|
|
class TopoConfig(object):
|
|
|
|
PING_OUTPUT = "ping.log"
|
|
|
|
def __init__(self, topo, param):
|
|
self.topo = topo
|
|
self.param = param
|
|
|
|
def configureNetwork(self):
|
|
print("Configure interfaces....Generic call ?")
|
|
self.configureInterfaces()
|
|
self.configureRoute()
|
|
|
|
def getMidL2RInterface(self, id):
|
|
"get Middle link, left to right interface"
|
|
pass
|
|
|
|
def getMidR2LInterface(self, id):
|
|
pass
|
|
|
|
def getMidLeftName(self, i):
|
|
"get Middle link, left box name"
|
|
pass
|
|
|
|
def getMidRightName(self, i):
|
|
pass
|
|
|
|
def configureInterfaces(self):
|
|
pass
|
|
|
|
def getClientInterfaceCount(self):
|
|
raise Exception("To be implemented")
|
|
|
|
def interfaceBUPCommand(self, interfaceName):
|
|
s = "/home/mininet/git/iproute-mptcp/ip/ip link set dev " + interfaceName + " multipath backup "
|
|
print(s)
|
|
return s
|
|
|
|
def interfaceUpCommand(self, interfaceName, ip, subnet):
|
|
s = "ifconfig " + interfaceName + " " + ip + " netmask " + \
|
|
subnet
|
|
print(s)
|
|
return s
|
|
|
|
def addRouteTableCommand(self, fromIP, id):
|
|
s = "ip rule add from " + fromIP + " table " + str(id + 1)
|
|
print(s)
|
|
return s
|
|
|
|
def addRouteScopeLinkCommand(self, network, interfaceName, id):
|
|
s = "ip route add " + network + " dev " + interfaceName + \
|
|
" scope link table " + str(id + 1)
|
|
print(s)
|
|
return s
|
|
|
|
def addRouteDefaultCommand(self, via, id):
|
|
s = "ip route add default via " + via + " table " + str(id + 1)
|
|
print(s)
|
|
return s
|
|
|
|
def addRouteDefaultGlobalCommand(self, via, interfaceName):
|
|
s = "ip route add default scope global nexthop via " + via + \
|
|
" dev " + interfaceName
|
|
print(s)
|
|
return s
|
|
|
|
def arpCommand(self, ip, mac):
|
|
s = "arp -s " + ip + " " + mac
|
|
print(s)
|
|
return s
|
|
|
|
def addRouteDefaultSimple(self, via):
|
|
s = "ip route add default via " + via
|
|
print(s)
|
|
return s
|
|
|
|
def pingCommand(self, fromIP, toIP, n=5):
|
|
s = "ping -c " + str(n) + " -I " + fromIP + " " + toIP + \
|
|
" >> " + TopoConfig.PING_OUTPUT
|
|
print(s)
|
|
return s
|