def addFileHandlerToMininetLogger(level):
filename = 'mfwdTest_' + time.strftime("%Y%m%d-%H%S") + ".log"
fh = logging.FileHandler('./logs/%s' % filename, mode='w')
fh.setLevel(LEVELS['%s' % level])
fileFormatter = logging.Formatter(LOGMSGFORMAT)
fh.setFormatter(fileFormatter)
# Add this handler to Mininet Logger
lg.addHandler(fh)
info('\nLogging to file %s with level %s\n' % (filename, level))
def set_mininet_log_file(log_level='info',
console=True,
log_file=DEFAULT_MN_LOG_FILE):
fh = FileHandlerNoNewLine(log_file)
fh.setFormatter(Formatter('%(message)s'))
lg.addHandler(fh)
setLogLevel('info')
if not console:
lg.handlers = [
h for h in lg.handlers if not isinstance(h, StreamHandlerNoNewline)
]
def get_logger(log_level='info',
logname='athos',
log_file=DEFAULT_LOG_FILE,
console=True):
log_lvl = LEVELS.get(log_level) if log_level in LEVELS else logging.INFO
# Needed to be able to use more than 1 log with mininet
logging.basicConfig(level=log_lvl, force=True)
logger = logging.getLogger(logname)
logger_fhandler = logging.FileHandler(log_file)
logger_fhandler.setFormatter(
logging.Formatter(LOGMSGFORMAT, '%b %d %H:%M:%S'))
logger_fhandler.setLevel(log_lvl)
lg.addHandler(logger_fhandler)
lg.propagate = False
return logger
def do(datadir, jsondir, tmpdir, runs):
"""
:param datadir: directory where to save pcaps
:param jsondir: directory where to save jsons
:param tmpdir: directory where to save pcaps temporarily
:param runs: list of topology information
"""
runtime_params = []
# it is possible to have multiple topologies in parallel (untested, we only used one)
for run in runs:
runtime_params.append({})
runtime_params[-1]['time'] = run['time']
runtime_params[-1]['opts'] = run
ok = False
while True:
# find unused filenames
uniqueid = uuid.uuid4().hex
runtime_params[-1]['uniquename'] = run['pcapName'] + '+' + uniqueid
logfilename = jsondir + runtime_params[-1]['uniquename'] + ".log"
templogfilename = tmpdir + '/' + runtime_params[-1][
'uniquename'] + ".log"
runtime_params[-1]['templogfilename'] = templogfilename
runtime_params[-1]['logfilename'] = logfilename
runtime_params[-1]['jsonfilename'] = jsondir + runtime_params[-1][
'uniquename'] + ".json"
if not os._exists(logfilename):
break
# log into file
runtime_params[-1]['filehandler'] = logging.FileHandler(
templogfilename)
runtime_params[-1]['filehandler'].setLevel(logging.INFO)
lg.addHandler(runtime_params[-1]['filehandler'])
retry = 0
while True:
retry += 1
# setup topology from params
topo = DynamicTopo(runs)
net = MininetCong(
topo=topo,
link=TCLinkTBF,
controller=None, # OVSController,
switch=OVSBridge)
# setup and build network
net.start()
net.waitConnected()
for runtime in runtime_params:
lg.output("%s\n" % runtime['opts'])
run_senders = topo.getSenders()
run_recordsenders = topo.getRecordsenders()
run_receivers = topo.getReceivers()
run_recorddevcons = topo.getRecordDevCons()
# print(run_recorddevcons)
run_recordlinks = topo.getRecordingLinks()
switch_by_name = {s.name: s for s in net.switches}
hosts_by_name = {h.name: h for h in net.hosts}
run_senders = [[hosts_by_name[sender] for sender in senders]
for senders in run_senders]
run_receivers = [[hosts_by_name[receiver] for receiver in receivers]
for receivers in run_receivers]
run_recordsenders = [[
hosts_by_name[recordsender] for recordsender in recordsenders
] for recordsenders in run_recordsenders]
run_recorddevcons = [[(hosts_by_name[a], hosts_by_name[b], c, p)
for a, b, c, p in devcons]
for devcons in run_recorddevcons]
recs = []
# set up recordings
for senders, recordlinks, runtime, recordsenders in zip(
run_senders, run_recordlinks, runtime_params,
run_recordsenders):
last_sender = recordsenders[0]
assert len(recordsenders) == 1
# switches = [(s0, "s0"), (s1, "s1"), (s4, "s4"), (s5, "s5")]
# edgeswitches = [(switch_by_name[first_switch], "s0"), (switch_by_name[last_switch], "s5")]
runtime['opts']['ip'] = last_sender.IP()
for link, switchname, name in recordlinks:
print(link())
switch = switch_by_name[switchname]
filename = runtime['uniquename'] + "+" + name + ".pcap"
recs.append(
PcapRecorder(switch, tmpdir + '/' + filename,
link().name, last_sender.IP(),
datadir + filename))
# try up to 40 times to ping the connected hots
for i in range(40):
l = 0
for senders, receivers, recordsenders in zip(
run_senders, run_receivers, run_recordsenders):
all_hosts = senders + recordsenders + receivers
l += net.ping(all_hosts)
if l == 0:
break
sleep(2)
# start trafficgen server
for receiver, runtime in zip(run_receivers, runtime_params):
for h2 in receiver:
lg.output("start own server %s\n" % h2.name)
# h1 is client sender, h2 is server receiver
# data is sent from h1 to h2
net.ownStartServer(h2, seconds=runtime['time'] + 10)
# h2.cmd("timeout 20 nc -l -p 5001 > /dev/null &")
sleep(2)
# start test is server is listening
con = True
for recorddevcon, runtime in zip(run_recorddevcons, runtime_params):
for (h1, h2, c, p) in recorddevcon:
lg.output("test connection between server %s and client %s\n" %
(h2.name, h1.name))
con = net.ownTestConnection(h2, h1)
if not con:
break
if not con:
lg.output("connection failed\n")
with open("errors.txt", "a+") as f:
f.write("connection failed\n")
for receiver in run_receivers:
for h2 in receiver:
lg.output("stop own server %s\n" % h2.name)
# h1 is client, h2 is server
# data is sent from h1 to h2
net.ownStopServer(h2)
try:
net.stop()
except:
pass
cleanup()
if retry <= 3:
continue
else:
lg.output("3 retries failed\n")
with open("errors.txt", "a+") as f:
f.write("3 retries failed\n")
break
lg.output("run generation\n")
# start client (sender) of background connections
i = 0
for recordsenders, devcon, runtime in zip(run_recordsenders,
run_recorddevcons,
runtime_params):
# for (h1, h2) in zip(sender, receiver):
for (h1, h2, cong, pacing) in devcon:
if h1 in recordsenders:
continue
net.ownStartClient(h2,
h1,
seconds=runtime['time'] + 2 + 2,
cong=cong,
pacing=pacing)
# h1.cmd("timeout 15 nc 10.0.0.1 5001 & ")
i += 1
# start tcpdump recording
for rec in recs:
rec.start()
sleep(2)
# start client (sender) which should be recorded
for recordsenders, devcon, runtime in zip(run_recordsenders,
run_recorddevcons,
runtime_params):
# for (h1, h2) in zip(sender, receiver):
for (h1, h2, cong, pacing) in devcon:
if not h1 in recordsenders:
continue
net.ownStartClient(h2,
h1,
seconds=runtime['time'],
cong=cong,
pacing=pacing)
# h1.cmd("timeout 10 dd if=/dev/zero | nc 10.0.0.2 5001")
# net.iperf((h1, h2), seconds=5, cong=cong[-1])
sleep(max([runtime['time'] for runtime in runtime_params]) + 2)
# stop recording
for rec in recs:
rec.stop()
# stop client and server and check whether succesful
try:
for sender, receiver, recordsender, runtime in zip(
run_senders, run_receivers, run_recordsenders,
runtime_params):
for h1 in sender + recordsender:
# h1 is client, h2 is server
lg.output("stop %s\n" % h1.name)
net._parseOwn(net.ownStopClient(h1))
for h2 in receiver:
lg.output("stop %s\n" % h2.name)
net._parseOwn(net.ownStopServer(h2))
except Exception as e:
lg.output("stopping hosts failed\n")
with open("errors.txt", "a+") as f:
f.write("stopping hosts failed " + str(e) + "\n")
for sender, receiver, recordsender, runtime in zip(
run_senders, run_receivers, run_recordsenders,
runtime_params):
for h1 in sender + recordsender:
# h1 is client, h2 is server
lg.output("stop %s\n" % h1.name)
net.ownStopClient(h1)
for h2 in receiver:
lg.output("stop %s\n" % h2.name)
net.ownStopServer(h2)
cleanup()
if retry <= 3:
continue
else:
lg.output("3 retries failed\n")
with open("errors.txt", "a+") as f:
f.write("3 retries failed\n")
break
net.stop()
ok = True
break
print("remove handler\n")
for runtime in runtime_params:
with open(runtime['jsonfilename'], 'w') as f:
f.write(json.dumps(runtime['opts']))
f.flush()
lg.removeHandler(runtime['filehandler'])
shutil.move(runtime['templogfilename'], runtime['logfilename'])
cleanup()
print("done\n")
return ok
def createTopology(self, topoOptions):
self.options = topoOptions
networks = []
mininet_logger = MyMininetLogger()
lg.handlers.pop(
) # remove default <StreamHandlerNoNewline <stderr> (Level 25)>
lg.addHandler(mininet_logger)
lg.setLevel(logging.INFO)
if self.options["controllerType"] == "local" or self.options["controllerType"] == "remote" \
or self.options["controllerType"] == "none":
pass
elif self.options["controllerType"] == "floodlight":
os.system('sudo docker run -d -p ' +
str(self.options["controllerPort"]) + ':6653 -p ' +
str(self.options["controllerWebGui"]) + ':8080 --name=' +
self.options["controllerName"] +
' glefevre/floodlight >/dev/null')
else:
raise ValueError("Unknown controller option",
self.options["controllerType"])
if self.options["method"] == "load":
networks.extend(self.__createTopologyFromFile())
elif self.options["method"] == "predefined":
predefinedTopo = predefinedTopos.topos[self.options["path"]]
if not issubclass(predefinedTopo,
predefinedTopos.IPredefinedTopology):
raise ValueError(
"Predefined topology \"" + self.options["path"] +
"\" does NOT inherit a proper interface (\"IPredefinedTopology\"."
)
else:
net = predefinedTopo.getNetwork()
if type(net) is list:
networks.extend(net)
else:
networks.append(net)
elif self.options["method"] == "custom":
net = Containernet(controller=Controller,
ipBase=self.options["ipBase"])
delay = str(self.options["linkDelay"]) + "ms"
volumePath = self.options["volumeMachine"] + ":" + self.options[
"volumeHost"]
gatewayIp = self.options["ipBase"].split('/')[0]
gatewayIp = gatewayIp.split('.')
gatewayIp = '.'.join(
[gatewayIp[0], gatewayIp[1], gatewayIp[2], '1'])
gateway = net.addNAT('gw0',
ip=gatewayIp,
connect=False,
inNamespace=(not self.options["NAT"]))
general_parameters = (net, gateway, gatewayIp, delay, volumePath)
if self.options["topoStyle"] == "linear":
self.__createCustomLinear(*general_parameters,
*self.options["topoSpecific"])
elif self.options["topoStyle"] == "tree":
self.__createCustomTree(*general_parameters,
*self.options["topoSpecific"])
elif self.options["topoStyle"] == "torus":
self.__createCustomTorus(*general_parameters,
*self.options["topoSpecific"])
else:
raise ValueError("Unknown custom topology style (\"" +
self.options["topoStyle"] + "\").")
networks.append(net)
else:
raise ValueError("Unknown creation method \"" +
self.options["method"] + "\".")
local_controller = None
for net in networks:
if not net.controllers:
if self.options["controllerType"] == "none":
pass
elif self.options["controllerType"] == "local":
if local_controller is None:
local_controller = net.addController(name='con0')
else:
net.addController(local_controller)
else:
net.addController(name='con0',
controller=RemoteController,
ip=self.options["controllerIp"],
port=self.options["controllerPort"])
net.start()
return networks, mininet_logger
def connection_addr(addr_client = 'localhost'):
socket_handler = SocketHandlerMininet(addr_client, handlers.DEFAULT_TCP_LOGGING_PORT)
socket_handler.setLevel(logging.INFO)
lg.addHandler(socket_handler)