def run_net_model_1():
topo = NetModel_1_topo()
netopts = dict( topo = topo, controller = RemoteController, link = TCLink, autoSetMacs = True, autoStaticArp = True, cleanup = True)
print "***Starting NetModel_1 configuration..."
net = Mininet (**netopts)
net.start()
srv1 = net.getNodeByName("srv1")
srv2 = net.getNodeByName("srv2")
print "***Starting UDP Server..."
srv1.cmd('iperf --single_udp -s -u &')
srv2.cmd('iperf --single_udp -s -u &')
srv1_udp_pid = int( srv1.cmd('echo $!') )
srv2_udp_pid = int( srv2.cmd('echo $!') )
print "UDP Server started on srv1 with PID ", srv1_udp_pid
print "UDP Server started on srv2 with PID ", srv2_udp_pid
print "***Starting TCP Server..."
srv1.cmd('iperf -s &')
srv2.cmd('iperf -s &')
srv1_tcp_pid = int(srv1.cmd('echo $!'))
srv2_tcp_pid = int(srv2.cmd('echo $!'))
print "TCP Server started on srv1 with PID ", srv1_tcp_pid
print "TCP Server started on srv2 with PID ", srv2_tcp_pid
print "Running CLI..."
CLI(net)
print "Killing mininet..."
cleaner.cleanup()
def run_exercise():
#Create and start a new network with our custom topology
topo = TLSTopo()
net = Mininet(topo=topo)
net.start()
net.pingAll()
processes = []
#Start Nginx HTTP-server
processes.append(net["Server-1"].popen(
'nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_1.conf'))
processes.append(net["Server-2"].popen(
'nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_2.conf'))
processes.append(net["Server-3"].popen(
'nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_3.conf'))
processes.append(net["Server-4"].popen(
'nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_4.conf'))
processes.append(net["Server-5"].popen(
'nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_5.conf'))
#Open wireshark
processes.append(net["A"].popen('wireshark'))
#Open terminals
processes.append(makeTerms([net["A"]], title="Student terminal")[0])
raw_input("Press Enter to exit....")
for process in processes:
process.kill()
Cleanup.cleanup()
def test_main(module):
"""Test main."""
setLogLevel('error')
print('testing module %s' % module)
(requested_test_classes, clean, dumpfail, keep_logs, nocheck, serial,
repeat, excluded_test_classes, report_json_filename,
port_order) = parse_args()
if clean:
print('Cleaning up test interfaces, processes and openvswitch '
'configuration from previous test runs')
Cleanup.cleanup()
sys.exit(0)
if nocheck:
print('Skipping dependency checks')
else:
if not check_dependencies():
print('dependency check failed. check required library/binary '
'list in header of this script')
sys.exit(-1)
print("port order: -o", ','.join(str(i) for i in port_order))
hw_config = import_hw_config()
run_tests(module, hw_config, requested_test_classes, dumpfail, keep_logs,
serial, repeat, excluded_test_classes, report_json_filename,
port_order)
def test_main():
"""Test main."""
setLogLevel('error')
(requested_test_classes, clean, dumpfail, keep_logs, nocheck,
serial, excluded_test_classes) = parse_args()
if clean:
print('Cleaning up test interfaces, processes and openvswitch '
'configuration from previous test runs')
Cleanup.cleanup()
sys.exit(0)
if nocheck:
print('Skipping dependencies/lint checks')
else:
if not check_dependencies():
print('dependency check failed. check required library/binary '
'list in header of this script')
sys.exit(-1)
if not lint_check():
print('pylint must pass with no errors')
sys.exit(-1)
hw_config = None
run_tests(
hw_config, requested_test_classes, dumpfail,
keep_logs, serial, excluded_test_classes)
def run_exercise():
#Create and start a new network with our custom topology
topo = TLSTopo()
net = Mininet(topo=topo)
net.start()
net.pingAll()
processes = []
#Start Nginx HTTP-server
processes.append(net["Server-1"].popen('nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_1.conf'))
processes.append(net["Server-2"].popen('nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_2.conf'))
processes.append(net["Server-3"].popen('nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_3.conf'))
processes.append(net["Server-4"].popen('nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_4.conf'))
processes.append(net["Server-5"].popen('nginx -p /home/vagrant/assignments/ssl_tls/nginx -c nginx_5.conf'))
#Open wireshark
processes.append(net["A"].popen('wireshark'))
#Open terminals
processes.append(makeTerms([net["A"]], title="Student terminal")[0])
raw_input("Press Enter to exit....")
for process in processes:
process.kill()
Cleanup.cleanup()
def __init__(self):
setLogLevel('info')
Cleanup.cleanup() # clean up any running mininet network
self.enable_sflow_rt() # compile and run sflow-rt helper script
self.net = Mininet(
topo=TopoThree(),
controller=lambda name: RemoteController(
name, ip='127.0.0.1', port=6633, protocol='tcp'))
self.net.start()
def runMininet():
Cleanup.cleanup() #Cleaning up the Mininet before start
"You can change the bottleneck link property by modifing these parameter"
myTopo = Assignment3Topo(bw_v=10, delay_v="10ms",
loss_v=0) #make test network topology
net = Mininet(topo=myTopo, link=TCLink) #make Mininet instance
net.start() #start Mininet
"Get Host and host's ip address"
hosts = net.hosts
print("Starting test...")
receiver = hosts[0]
sender = hosts[1]
recvAddr = receiver.IP()
sendAddr = sender.IP()
"Get parameter to run the test"
windowSize = int(sys.argv[1])
srcFilename = sys.argv[2]
dstFilename = sys.argv[3]
"execute ping for establish switching table"
net.pingAll(timeout="30ms") #This code must not be removed
"If you want to test with ping and iperf, uncomment this"
"""
net.pingFull([receiver,sender])
net.iperf([receiver,sender],seconds=10)
"""
popens = {}
"If your code is python, uncomment this"
"""
popens[receiver] = receiver.popen('python3','receiver.py')
popens[sender] = sender.popen('python3','sender.py',recvAddr, str(windowSize), srcFilename, dstFilename)
"""
endTime = time() + 180 #after 3 minutes mininet test will be shut
"If sender or receiver print something, pmonitor will let you to see it"
for h, line in pmonitor(popens, timeoutms=500):
if h:
print('<%s>: %s' % (h.name, line)) #,
if time() >= endTime:
for p in popens.values():
p.send_signal(SIGINT)
net.stop() #stop Mininet
print("Testing fininshed")
def performance_test(spread, depth, bandwidth, delay, loss, ping_all, iperf, quick, log):
if quick:
spread = 3
depth = 3
bandwidth = 500
delay = '0ms'
loss = 0
ping_all = True
iperf = True
log = 'info'
Cleanup.cleanup()
setLogLevel(log)
logger = logging.getLogger(__name__)
if log == 'debug':
logger.setLevel(logging.DEBUG)
setup_logging(default_level=logging.DEBUG)
elif log == 'warning':
logger.setLevel(logging.WARNING)
setup_logging(default_level=logging.WARNING)
elif log == 'error':
logger.setLevel(logging.ERROR)
setup_logging(default_level=logging.ERROR)
elif log == 'critical':
logger.setLevel(logging.CRITICAL)
setup_logging(default_level=logging.CRITICAL)
else:
logger.setLevel(logging.INFO)
setup_logging(default_level=logging.INFO)
"Create network and run simple performance test"
topo = TreeTopoGeneric(spread, depth, bandwidth, delay, loss)
net = Mininet(topo=topo, host=CPULimitedHost, link=TCLink, autoStaticArp=True)
net.start()
logger.info("Dumping host connections")
dumpNodeConnections(net.hosts)
if ping_all:
logger.info("Running ping test between all hosts")
net.pingAll()
if iperf:
logger.info("Testing bandwidth between first and last hosts")
net.iperf()
net.stop()
def removeLost():
import os
cmd1 = "sudo docker rm -f $(sudo docker ps -a | grep mn | awk '{print $1}')"
cmd2 = "sudo mn --wifi"
cmd3 = "sudo docker stop -t 15 $(sudo docker ps -a | grep mn | awk '{print $1}')"
info("Using mininet cleanup\n")
Cleanup.cleanup()
info("Stopping containers\n")
os.system(cmd3)
info("Removing containers\n")
os.system(cmd1)
info("IF cleanup was not sucessful. Reboot Machine!\n")
def test_main(modules, serial_override=None):
"""Test main."""
print('testing module %s' % modules)
(requested_test_classes, regex_test_classes, clean, dumpfail, debug,
keep_logs, nocheck, serial, repeat, excluded_test_classes,
report_json_filename, port_order, start_port, loglevel,
profile) = parse_args()
if serial_override is not None:
print('overriding serial to ', serial_override)
serial = serial_override
setLogLevel(loglevel)
if clean:
print('Cleaning up test interfaces, processes and openvswitch '
'configuration from previous test runs')
Cleanup.cleanup()
sys.exit(0)
if nocheck:
print('Skipping dependency checks')
else:
if not check_dependencies():
print('dependency check failed. check required library/binary '
'list in header of this script')
sys.exit(-1)
print('port order: -o', ','.join(str(i) for i in port_order))
print('start port: --port %s' % start_port)
hw_config = import_hw_config()
if profile:
# use wall clock time
pr = cProfile.Profile(time.time) # pylint: disable=invalid-name
pr.enable()
run_tests(modules, hw_config, requested_test_classes, regex_test_classes,
dumpfail, debug, keep_logs, serial, repeat,
excluded_test_classes, report_json_filename, port_order,
start_port)
if profile:
pr.disable()
ps = pstats.Stats(pr).sort_stats('cumulative') # pylint: disable=invalid-name
ps.print_stats()
def run_all_tests_sequentially():
run_index = 0
for delay in DELAYS:
for bw in BANDWIDTHS:
for loss in LOSSES:
for pl in PAYLOADS:
if run_index < 10:
run_index += 1
continue
performance_test("./TcpMQ/mqsub/mqsub -h=192.168.0.3:1883",
"./TcpMQ/mqpub/mqpub -h=192.168.0.3:1883",
"./TcpMQ/surgemq/surgemq",
run_index,
RUN_TIME,
pl,
delay=str(delay) + "ms",
bw=bw,
loss=loss)
run_index += 1
Cleanup.cleanup()
def after_scenario(context, scenario):
######################################
#OpenStack Part
#IF OPENSTACK=True
######################################
if (context.openStackTest):
if (context.tf.readyToDestroy == True):
context.tf.destroy()
pass
else:
print("Please destroy infrastructure manually.")
else:
######################################
#Mininet & Controller Part
#IF OPENSTACK=False
######################################
if (context.onosFlag):
context.onosRest.removeOnosIntents()
context.onosFlag = False
Cleanup.cleanup()
def test_main(module):
"""Test main."""
setLogLevel('error')
print('testing module %s' % module)
(requested_test_classes, clean, dumpfail, keep_logs, nocheck,
serial, excluded_test_classes, report_json_filename) = parse_args()
if clean:
print('Cleaning up test interfaces, processes and openvswitch '
'configuration from previous test runs')
Cleanup.cleanup()
sys.exit(0)
if nocheck:
print('Skipping dependency checks')
else:
if not check_dependencies():
print('dependency check failed. check required library/binary '
'list in header of this script')
sys.exit(-1)
hw_config = import_hw_config()
run_tests(
module, hw_config, requested_test_classes, dumpfail,
keep_logs, serial, excluded_test_classes, report_json_filename)
def run_all_tests_sequentially():
for delay in DELAYS:
for bw in BANDWIDTHS:
for loss in LOSSES:
performance_test('quic',
delay=str(delay) + "ms",
bw=bw,
loss=loss)
Cleanup.cleanup()
for delay in DELAYS:
for bw in BANDWIDTHS:
for loss in LOSSES:
performance_test('tcp',
delay=str(delay) + "ms",
bw=bw,
loss=loss)
Cleanup.cleanup()
#h7.cmd('ethtool -s h7-eth0 speed 1 duplex full autoneg off');
#h8.cmd('ethtool -s h8-eth0 speed 1 duplex full autoneg off');
#h9.cmd('ethtool -s h9-eth0 speed 1 duplex full autoneg off');
#h10.cmd('ethtool -s h10-eth0 speed 1 duplex full autoneg off');
info('*** Configure switches (Open vSwitch w/ OpenFlow13)\n');
#s1.cmd('ifconfig s1 10.0.0.64');
#s2.cmd('ifconfig s2 10.0.0.65');
#s3.cmd('ifconfig s3 10.0.0.66');
#s4.cmd('ifconfig s4 10.0.0.67');
#s5.cmd('ifconfig s5 10.0.0.68');
#s1.cmd('ethtool -s s1 speed 1 duplex full autoneg off');
#s2.cmd('ethtool -s s2 speed 1 duplex full autoneg off');
#s3.cmd('ethtool -s s3 speed 1 duplex full autoneg off');
#s4.cmd('ethtool -s s4 speed 1 duplex full autoneg off');
#s5.cmd('ethtool -s s5 speed 1 duplex full autoneg off');
#s1.cmd('ovs-vsctl set bridge s1 stp-enable=true rstp-enable=true');
#s2.cmd('ovs-vsctl set bridge s2 stp-enable=true rstp-enable=true');
#s3.cmd('ovs-vsctl set bridge s3 stp-enable=true rstp-enable=true');
#s4.cmd('ovs-vsctl set bridge s4 stp-enable=true rstp-enable=true');
#s5.cmd('ovs-vsctl set bridge s5 stp-enable=true rstp-enable=true');
info('*** Switching to CLI\n');
#CLI(net);
info('*** Stopping Network\n');
net.stop();
info('*** Cleaning Up\n');
Cleanup.cleanup();
average = 0
for f in outfiles.values():
start_flag = False
bw = 0.0
with open(f, 'r') as o:
for line in o:
if start_flag == True:
a = line.rfind('/sec')
if a < 0:
continue
a = line[0:a].rfind(' ')
b = line[0:a].rfind(' ')
bw = float(line[b+1:a])
if 'Bandwidth' in line:
start_flag = True
print(f, bw)
average += bw
average = float(average) / len(outfiles.values())
print ('average bandwidth between all pairs = '+str(average))
# output
arq = open('average1flow-ECMP.dat','w')
arq.write('1 flow - ECMP - 20 servers average: ' + str(average) +'\n')
arq.close()
# CLI(net)
net.stop()
Cleanup.cleanup()
def mplexExperiment(
n = 5,
inc_function = None,
udp = False,
pdrop_min = 0.0,
pdrop_max = 1.0,
pdrop_stride = 0.1,
playback_file = "../../data/pcaps/bigFlows.pcap",
playback = False,
linkopts = {"delay": 20},
base_iperf_port = 5201,
csv_dir = None,
result_interval = 1.0,
max_pdrop = 0.4,
step_interval = 3.0,
n_steps = 10,
force_cmd_routes = False,
):
if inc_function is None:
inc_function = lambda last, i, n: float(i+1)
# helpers
initd_host_count = [0]
initd_switch_count = [0]
next_ip = [1]
def newNamedHost(**kw_args):
o = net.addHost("h{}".format(initd_host_count[0]), **kw_args)
initd_host_count[0] += 1
return o
def newNamedSwitch(**kw_args):
o = net.addSwitch("s{}".format(initd_switch_count[0]), listenPort=7000+initd_switch_count[0], **kw_args)
initd_switch_count[0] += 1
return o
def assignIP(node):
node.setIP("10.0.0.{}".format(next_ip[0]), 24)
next_ip[0] += 1
def trackedLink(src, target, extras=None):
if extras is None:
extras = linkopts
l = net.addLink(src, target, **extras)
return l
route_commands = [[]]
switch_sockets = [{}]
def openSwitchSocket(switch):
if switch.name in switch_sockets[0]:
killsock(switch_sockets[0][switch.name])
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("127.0.0.1", switch.listenPort))
s.sendall(ofpb.ofp_hello(None, None))
ofpp.parse(s.recv(8))
switch.control_socket = s
switch_sockets[0][switch.name] = s
return s
def killsock(s):
try:
s.shutdown(socket.SHUT_RDWR)
except:
pass
s.close()
def removeAllSockets():
for _, sock in switch_sockets[0].viewitems():
killsock(sock)
switch_sockets[0] = {}
def updateOneRoute(switch, cmd_list, msg):
if force_cmd_routes or not switch.listenPort:
switch.cmd(*cmd_list)
else:
s = (switch_sockets[0][switch.name]
if switch.name in switch_sockets[0]
else openSwitchSocket(switch)
)
# seems like pipes can randomly break. oops!
sent = False
while not sent:
try:
s.sendall(msg)
sent = True
except:
s = openSwitchSocket(switch)
def executeRouteQueue():
for el in route_commands[0]:
updateOneRoute(*el)
route_commands[0] = []
# Downstream should be computed similarly, but without the probdrops or anything like that.
flow_pdrop_msg = ofpb.ofp_flow_mod(
None, 0, 0, 0, ofp.OFPFC_ADD,
0, 0, 1, None, None, None, 0, 1,
ofpb.ofp_match(None, None, None),
ofpb.ofp_instruction_actions(ofp.OFPIT_WRITE_ACTIONS, None, [
# Looks like 29 is the number I picked for Pdrop.
ofpb._pack("HHI", 29, 8, 0xffffffff),
ofpb.ofp_action_output(None, 16, 1, 65535)
])
)
def updateUpstreamRoute(switch, out_port=1, ac_prob=0.0, ip="10.0.0.1"):
# Turn from prob_drop into prob_send!
prob = 1 - ac_prob
p_drop_num = pdrop(prob)
#p_drop = "" if ac_prob == 0.0 else "probdrop:{},".format(p_drop_num)
p_drop = "probdrop:{},".format(p_drop_num)
cmd_tail = [
"in_port=*,ip,nw_dst={},actions={}\"{}-eth{}\"".format(ip, p_drop, switch.name, out_port)
]
msg = ofpb.ofp_flow_mod(
None, 0, 0, 0, ofp.OFPFC_ADD,
0, 0, 1, None, None, None, 0, 1,
ofpb.ofp_match(ofp.OFPMT_OXM, None, [
# Need to match Dest IP against curr host's.
ofpm.build(None, ofp.OFPXMT_OFB_ETH_TYPE, False, 0, 0x0800, None),
ofpm.build(None, ofp.OFPXMT_OFB_IPV4_DST, False, 0, socket.inet_aton(ip), None)
]),
ofpb.ofp_instruction_actions(ofp.OFPIT_WRITE_ACTIONS, None, [
# Looks like 29 is the number I picked for Pdrop.
ofpb._pack("HHI", 29, 8, p_drop_num),
ofpb.ofp_action_output(None, 16, out_port, 65535)
])
)
switchRouteCommand(switch, cmd_tail, msg)
def updateDownstreamRoute(switch, host, out_port):
ip = host.IP()
cmd_tail = [
"in_port=*,ip,nw_dst={},actions=\"{}-eth{}\"".format(ip,switch.name, out_port)
]
msg = ofpb.ofp_flow_mod(
None, 0, 0, 0, ofp.OFPFC_ADD,
0, 0, 1, None, None, None, 0, 1,
ofpb.ofp_match(ofp.OFPMT_OXM, None, [
# Need to match Dest IP against curr host's.
ofpm.build(None, ofp.OFPXMT_OFB_ETH_TYPE, False, 0, 0x0800, None),
ofpm.build(None, ofp.OFPXMT_OFB_IPV4_DST, False, 0, socket.inet_aton(ip), None)
]),
ofpb.ofp_instruction_actions(ofp.OFPIT_WRITE_ACTIONS, None, [
ofpb.ofp_action_output(None, 16, out_port, 65535)
])
)
switchRouteCommand(switch, cmd_tail, msg)
def floodRoute(switch):
cmd_tail = [
"actions=flood"
]
msg = ofpb.ofp_flow_mod(
None, 0, 0, 0, ofp.OFPFC_ADD,
0, 0, 1, None, None, None, 0, 1,
ofpb.ofp_match(None, None, None),
ofpb.ofp_instruction_actions(ofp.OFPIT_WRITE_ACTIONS, None, [
# Looks like 29 is the number I picked for Pdrop.
ofpb.ofp_action_output(None, 16, ofp.OFPP_FLOOD, 65535)
])
)
switchRouteCommand(switch, cmd_tail, msg)
def switchRouteCommand(switch, cmd_tail, msg):
name = switch.name
if not switch.listenPort:
listenAddr = "unix:/tmp/{}.listen".format(switch.name)
else:
listenAddr = "tcp:127.0.0.1:{}".format(switch.listenPort)
cmd_list = [
"ovs-ofctl",
"add-flow",
listenAddr
] + cmd_tail
if alive:
updateOneRoute(switch, cmd_list, msg)
else:
route_commands[0].append((switch, cmd_list, msg))
def enactActions(learners, sarsas):
for (node, sarsa) in zip(learners, sarsas):
(_, action, _) = sarsa.last_act
updateUpstreamRoute(node, ac_prob=action)
def buildNet(n_hosts):
server = newNamedHost()
server_switch = newNamedSwitch()
core_link = trackedLink(server, server_switch)
assignIP(server)
hosts = []
last_bw = 0.0
for i in xrange(n_hosts):
h = newNamedHost()
bw = inc_function(last_bw, i, n_hosts)
last_bw = bw
opts = linkopts
opts["bw"] = bw
trackedLink(server_switch, h, extras=opts)
hosts.append((h, bw))
assignIP(h)
updateDownstreamRoute(server_switch, h, i+2)
updateUpstreamRoute(server_switch)
floodRoute(server_switch)
return (server, core_link, server_switch, hosts)
def pdrop(prob):
return int(prob * 0xffffffff)
def fxrange(start, stop, step):
curr = start
while curr <= stop:
yield curr
curr += step
### THE EXPERIMENT? ###
net = Mininet(link=TCLink)
alive = False
Cleanup.cleanup()
(server, core_link, server_switch, hosts) = buildNet(n)
net.start()
alive = True
executeRouteQueue()
print "starting procs"
server_procs = [server.popen(["iperf3", "-s", "-p", str(base_iperf_port+x)], stdin=PIPE, stderr=sys.stderr) for x in xrange(n)]
host_procs = [host.popen(
["iperf3",
"-c", server.IP(),
"-i", str(result_interval),
"-p", str(base_iperf_port+i),
"-b", "{}M".format(bw),
"-t", str(32),
"-J"] +
(["-u"] if udp else []),
stdin=PIPE, stdout=PIPE, stderr=sys.stderr) for i, (host, bw) in enumerate(hosts)
]
#net.interact()
time.sleep(0.5)
for step in xrange(n_steps):
updateUpstreamRoute(server_switch, ac_prob=max_pdrop * (step/float(n_steps)))
print "pushing drop rate", max_pdrop * (step/float(n_steps)), "at t =",0.5+step_interval*(step)
time.sleep(step_interval)
print "gathering stats..."
updateUpstreamRoute(server_switch, ac_prob=0.0)
datas_pre = [proc.communicate() for proc in host_procs]
datas = [json.loads(data[0]) for data in datas_pre]
print "gathered"
out_results = []
for (_, bw), data in zip(hosts, datas):
for inter in data["intervals"]:
inner = inter["sum"]
out_results.append([bw, inner["end"], float(inner["bits_per_second"])/1e6])
if udp: print "bw=", bw, "lost", data["end"]["sum"]["lost_percent"]
print "output written, cleaning up..."
removeAllSockets()
for proc in host_procs + server_procs:
try:
proc.terminate()
except:
pass
net.stop()
return out_results
def run_exercise():
#Create and start a new network with our custom topology
topo = DDoSTopo()
net = Mininet(topo=topo)
net.start()
#Configure switch so that packets reach the right port (to prevent l2 learning from affecting the exercise)
net["s1"].dpctl("del-flows")
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=1,nw_dst=10.0.0.1,actions=output:1,mod_vlan_vid:11,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=1,nw_dst=10.0.0.2,actions=output:2,mod_vlan_vid:11,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=1,nw_dst=10.0.0.3,actions=output:3,mod_vlan_vid:11,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=2,nw_dst=10.0.0.1,actions=output:1,mod_vlan_vid:12,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=2,nw_dst=10.0.0.2,actions=output:2,mod_vlan_vid:12,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=2,nw_dst=10.0.0.3,actions=output:3,mod_vlan_vid:12,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=3,nw_dst=10.0.0.1,actions=output:1,mod_vlan_vid:13,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=3,nw_dst=10.0.0.2,actions=output:2,mod_vlan_vid:13,output:4"
)
net["s1"].dpctl(
"add-flow",
"dl_type=0x0800,in_port=3,nw_dst=10.0.0.3,actions=output:3,mod_vlan_vid:13,output:4"
)
#Verify connectivity
net.pingAll()
processes = []
#Start BIND DNS-server
processes.append(net["B"].popen(
'named', '-g', '-c',
'/home/vagrant/assignments/DNS/config/named.conf'))
#Open terminals
processes.append(makeTerms([net["A"]], title="Attacker terminal")[0])
processes.append(makeTerms([net["D"]], title="Capture terminal")[0])
raw_input("Press Enter to exit....")
for process in processes:
process.kill()
Cleanup.cleanup()
def run(hosts,
host_config_path,
sensor_config_path,
grid_config_path,
output_dir,
resource_types,
type_map,
trecs_root_dir,
time_limit=None,
_loss=None):
"""Run the agents on a Mininet network.
Parameters
----------
hosts : iterable
Iterable containing information about each host.
host_config_path : path_like
Path to host config file
sensor_config_path : path_like
Path to sensor config file
grid_config_path : path_like
Path to grid config file
output_dir : path_like
Directory to which executables' output will be written.
resource_types : set
Set of resource types used in the current T-RECS run.abs
type_map : dictionary
A dictionary mapping resource names to types.
trecs_root_dir : path_like
Path of T-RECS root directory.
time_limit : float (optional, default None)
Maximum time to run the simulation for (in minutes).
loss : float (optional, default None)
Network loss (as a fraction of packets).
"""
relative_to_absolute_path_conversion(hosts, host_config_path)
check_execs_and_required_files(hosts)
prepare_run_directory(resource_types, trecs_root_dir)
# Add grid container so that we can run the grid model.
add_grid_host(hosts, grid_config_path, sensor_config_path, trecs_root_dir,
output_dir)
# Add resource models to their corresponding resource agent hosts
add_resource_models_to_ra_hosts(hosts, type_map, trecs_root_dir)
# Clean the Mininet remains from last run, if any
Cleanup.cleanup()
net = Mininet(link=TCLink,
xterms=True,
ipBase='{}/{}'.format(GLOBAL_IP, GLOBAL_PREFIX))
net.addController('c0')
router = None
switch = None
vhosts = []
linkopts = dict(bw=100, delay='0ms', loss=_loss,
use_htb=False) # bw in Mbps
LOGGER.info("Create the network")
mapping_host_ip = {}
for host, host_addr, router_addr, local_addr in zip(
hosts, HOST_ADDRS, ROUTER_ADDRS, LOCAL_ADDRS):
if router is None:
LOGGER.info("Add router to connect subnets and log traffic")
router = net.addHost('router', ip=router_addr)
LOGGER.info("Configure router")
router.cmd('sysctl net.ipv4.ip_forward=1')
if switch is None:
LOGGER.info("Add switch to connect grid and RAs")
switch = net.addSwitch('s0')
LOGGER.info("Add host {} at {}".format(host['host_name'], host_addr))
vhost = net.addHost(host['host_name'], ip=host_addr)
vhosts.append(vhost)
LOGGER.info("Add link router <-> {}".format(host['host_name']))
link = net.addLink(router, vhost, **linkopts)
router.setIP(router_addr, intf=link.intf1)
vhost.setIP(host_addr, intf=link.intf2)
# Add an entry to the router's routing table.
router_ip = router_addr.split('/')[0]
router.cmd('ip route add {} via {}'.format(network(host_addr),
router_ip))
# Set the router as the host's default gateway.
vhost.cmd('ip route add default via {}'.format(router_ip))
# If the host is the grid container or an RA, connect it to the LAN.
if host['host_type'] in ('RA', 'grid'):
LOGGER.info("Add link switch <-> {}".format(host['host_name']))
link = net.addLink(switch, vhost, **linkopts)
vhost.setIP(local_addr, intf=link.intf2)
mapping_host_ip[host['host_name']] = host_addr
with open(path.join(trecs_root_dir, 'run', 'mapping_host_ip.json'),
'w') as mapping_file:
mapping_file.write(dumps(mapping_host_ip))
LOGGER.info("Start the network")
net.start()
sleep(2) # sleep for 2 seconds
LOGGER.info("Run the executables")
# LOGGER.info("Run Scapy on router")
# exec_path = os.path.join(trecs_root_dir, 'run', 'router', 'sniff.py')
# router.cmd('{} > {} 2>&1 &'.format(
# quote(exec_path),
# quote(os.path.join(
# output_dir, 'router', 'sniff.py') + '.out')))
for host, vhost in zip(reversed(hosts), reversed(vhosts)):
for exec_ in host['executables']:
path_, exec_name = path.split(exec_['executable_path'])
LOGGER.info('Run {} on {}.'.format(exec_name, host['host_name']))
cmd = './{} {} > {} 2>&1 &'.format(
quote(exec_name), ' '.join(exec_['command_line_arguments']),
quote(
path.join(output_dir, host['host_name'], exec_name) +
'.out'))
vhost.cmd('cd {}'.format(path_))
vhost.cmd(cmd)
# Check if we should set a time limit.
if time_limit is not None:
alarm(int(60 * time_limit))
LOGGER.info("Run the CLI")
try:
CLI(net)
except RuntimeError as e:
LOGGER.warn(str(e))
finally:
LOGGER.info("Stop the network")
net.stop()
from multiprocessing import Process
import subprocess
import shutil
# test_duration = 6 * 60*60 # six hours
test_duration = 24 * 60 * 60 # 10 min
# if the script is run directly (sudo custom/optical.py):
if __name__ == '__main__':
start_logging()
write_time('starting', start_empty=True)
##Clean up
Cleanup.cleanup()
db = Database()
db.delete_content()
##Start
net = MyNetwork(get_config('configs.json'))
net.start()
net.enable_netflow(net.switches, net.config['controller']['ip'])
net.enable_sflow(net.switches, net.config['controller']['ip'], 256, 30)
net.pingAll() # this is for the discovery
net.pingAll() #just to make sure everythings working
int_table = net.print_interface_id(
) #This will print and log the interface name and corresponding ifaceindex in SFLOW
net.print_link_info() # This will print and log the connection information
h1, h2, h3 = net.get('h1', 'h2', 'h3')
def sigint_handler(signum, frame):
global net
net.stop()
Cleanup.cleanup()
sys.exit()
def clean_network(self):
c = Cleanup()
c.cleanup()
net = Mininet( controller=Controller , link=TCLink)
net.addController( 'c0' )
switches = []
count=1
ip1='10.0.1.'
ip2='10.0.2.'
for i in range(y):
s = net.addSwitch('s'+str(i+1))
for j in range(x):
ind=count
if ind % 2 !=0:
h = net.addHost( 'h'+str(count), ip=ip1+str(ind)+'/24')
net.addLink( h, s, bw=1 )
else:
h = net.addHost( 'h'+str(count), ip=ip2+str(ind)+'/24')
net.addLink( h, s , bw=2 )
count= count+1
switches.append(s)
for i in range(y):
if i < y-1:
net.addLink(switches[i], switches[i+1], bw=2)
net.start()
CLI( net )
net.stop()
Cleanup.cleanup()
