def conduct_path_hopping_trial(results_repository, the_trial):
hosts = {}
flow_allocation_seed_number = the_trial.get_parameter("seed-number")
flows = the_trial.get_parameter("flow-set")
flow_tokens = set()
tag_values = defaultdict(int)
try:
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(TARGET_GRAPH)
hosts = create_virtual_hosts(id_to_dpid)
for host in hosts.values():
host.start_traffic_generation_server()
for flow in flows:
source_node, destination_node, flow_tx_rate = (
flow.source_node, flow.destination_node, flow.flow_tx_rate)
flow_json, tag_values_for_flow = simple_paths_to_flow_json(
flow.paths, tag_values, id_to_dpid)
flow_token = onos_route_adder.install_flow(flow_json)
flow_tokens.add(flow_token)
scaled_flow_tx_rate = scale_flow_tx_rate(flow_tx_rate)
hosts[source_node + 1].configure_flow(
scaled_flow_tx_rate, 0.0, "uniform",
hosts[destination_node + 1].virtual_host_ip, 50000,
flow.splitting_ratio, 10, tag_values_for_flow)
traffic_monitor = stat_monitor.OnMonitor(cfg.of_controller_ip,
cfg.of_controller_port)
traffic_monitor.start_monitor()
for host in hosts.values():
host.start_traffic_generation_client()
# input("Hosts have been created and flows have been added. Press enter to continue...")
time.sleep(the_trial.get_parameter("duration"))
traffic_monitor.stop_monitor()
utilization_results = traffic_monitor.get_monitor_statistics()
the_trial.add_parameter("byte-counts-over-time", utilization_results)
the_trial.add_parameter(
"link-utilization-over-time",
compute_link_utilization_over_time(utilization_results))
the_trial.add_parameter(
"measured-link-utilization",
compute_mean_link_utilization(utilization_results))
except Exception as ex:
traceback.print_exc()
print(ex)
input(
"Failed to carry out path hopping test. Press enter to continue..."
)
finally:
destroy_all_hosts(hosts)
remove_all_flows(flow_tokens)
def build_tuiti_trial_provider():
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(EXPECTED_TOPO)
source_node, destination_node = (0, 1)
disjoint_paths = list(node_disjoint_paths(EXPECTED_TOPO, source_node, destination_node))
the_trial_provider = trial_provider.TrialProvider("tuiti-trial-provider")
trial_file_directory = path.Path("/home/alexj/repos/inter-dc/trial-parameters/")
trials = TuitiTrial.batch_from_directory(trial_file_directory, id_to_dpid, EXPECTED_TOPO)
for the_trial in [t for t in trials
# if t.get_parameter("maximum-bandwidth-variation") == 50
# and t.name == "eb-99"
]:
the_trial_provider.add_trial(the_trial)
return the_trial_provider
def serialization_testing():
dir_path = path.Path("/home/alexj/repos/inter-dc/trial-parameters")
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(EXPECTED_TOPO)
trials = TuitiTrial.batch_from_directory(dir_path, id_to_dpid, EXPECTED_TOPO)
for trial in trials:
# if trial.name == "eb":
# confidence_interval = trial.get_parameter("confidence-interval")
# print(f"confidence interval is {confidence_interval}")
print("Mean demand: %s" % trial.get_parameter("mean-flow-demand"))
if trial.name == "ts":
sample_flow = next(iter(trial.get_parameter("flow-set")))
print(sample_flow.flow_tx_rate)
pp.pprint([trial.name for trial in trials])
def test_virtual_host_installation():
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(SUBSTRATE_TOPOLOGY)
sender, receiver = None, None
# add_path_hopping_delays("ens192", 9, lambda: int(np.random.uniform(0, 1000)))
while True:
try:
sender, receiver = create_sender_receiver_pair(id_to_dpid)
except Exception as ex:
print(ex)
print("Failed to create sender or receiver")
input("Okay do stuff now...")
try:
destroy_sender_receiver_pair(sender, receiver)
# remove_path_hopping_delays("ens192")
except Exception:
pass
break
def build_mininet_test_trial_provider():
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(EXPECTED_TOPO)
source_node, destination_node = (0, 1)
print(source_node, destination_node)
disjoint_paths = list(node_disjoint_paths(EXPECTED_TOPO, source_node, destination_node))
the_trial_provider = trial_provider.TrialProvider("mininet-trial")
flow_set = trial_provider.FlowSet()
the_trial = trial_provider.Trial("mininet-test")
the_trial.add_parameter("duration", 120)
flow_tx_rate = 131072 * 100
the_flow = trial_provider.Flow( source_node = source_node
, destination_node = destination_node
, flow_tx_rate = flow_tx_rate
, paths = disjoint_paths
, splitting_ratio = [1.0] + [0]*(len(disjoint_paths)-1)
)
flow_set.add_flows([the_flow])
the_trial.add_parameter("seed-number", 0)
the_trial.add_parameter("flow-set", flow_set)
the_trial.add_parameter("traffic-sampling-distribution", "uniform")
the_trial_provider.add_trial(the_trial)
return the_trial_provider
def conduct_path_hopping_trial(results_repository, the_trial):
def stringify(value):
return value if type(value) == str else str(value)
def get_sender_kwargs(the_trial):
sender_kwargs = { "port" : the_trial.get_parameter("port")
, "K" : the_trial.get_parameter("K")
, "N" : the_trial.get_parameter("N")
, "data_file" : the_trial.get_parameter("input-file")
, "message_size" : the_trial.get_parameter("message-size")
, "timestep" : the_trial.get_parameter("timestep")
, "hop_probability" : the_trial.get_parameter("lambda")
, "reliable" : the_trial.get_parameter("reliable")
, "hop_method" : the_trial.get_parameter("hop")
}
sender_kwargs = {kw: stringify(arg) for kw, arg in sender_kwargs.items()}
return sender_kwargs
def get_receiver_kwargs(the_trial, sender_ip):
receiver_kwargs = { "sender_ip" : sender_ip
, "port" : the_trial.get_parameter("port")
, "data_file" : the_trial.get_parameter("output-file")
, "timestep" : the_trial.get_parameter("timestep")
, "hopping_probability" : the_trial.get_parameter("lambda")
}
receiver_kwargs = {kw: stringify(arg) for kw, arg in receiver_kwargs.items()}
return receiver_kwargs
def collect_mpc_sender_hopping_times():
hopping_times_record_path = path.Path("./hopping-time-record.txt")
hopping_times_text = hopping_times_record_path.read_text()
hopping_times = [int(s_i) for s_i in hopping_times_text.splitlines()]
hopping_times_record_path.unlink()
return hopping_times
sender, receiver, packet_capture = None, None, None
try:
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(SUBSTRATE_TOPOLOGY)
sender, receiver = create_sender_receiver_pair(id_to_dpid)
time.sleep(10)
packet_capture = pcap.InterfaceCapture("ens192")
traffic_monitor = stat_monitor.OnMonitor(cfg.of_controller_ip, cfg.of_controller_port)
packet_capture.start_capture()
traffic_monitor.start_monitor()
sender.start_path_hopping_sender(**get_sender_kwargs(the_trial))
start_time = time.time()
receiver.start_path_hopping_receiver(
**get_receiver_kwargs(the_trial, sender.virtual_host_ip))
print("Waiting on the receiver to terminate...")
receiver.wait_until_done()
end_time = time.time()
print("Receiver has terminated.")
elapsed_tx_time = end_time - start_time
traffic_monitor.stop_monitor()
utilization_results = traffic_monitor.get_monitor_statistics()
packet_capture.stop_capture()
packets = packet_capture.process_capture_data()
hopping_times = collect_mpc_sender_hopping_times()
print("Captured %d packets" % len(packets))
the_trial.add_parameter("packet-dump", packets)
the_trial.add_parameter("measured-link-utilization", utilization_results)
the_trial.add_parameter("link-utilization-over-time",
compute_link_utilization_over_time(utilization_results))
the_trial.add_parameter("elapsed-tx-time", elapsed_tx_time)
the_trial.add_parameter("hopping-times", hopping_times)
except Exception as ex:
traceback.print_exc()
print(ex)
input("Failed to carry out path hopping attacker test. Press enter to continue...")
finally:
destroy_sender_receiver_pair(sender, receiver)
if packet_capture != None and packet_capture.is_capture_running():
packet_capture.stop_capture()
def conduct_test_mininet_trial(results_reposity, the_trial):
hosts = {}
flow_allocation_seed_number = the_trial.get_parameter("seed-number")
flows = the_trial.get_parameter("flow-set")
flow_tokens = set()
tag_values = defaultdict(int)
try:
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(EXPECTED_TOPO)
pp.pprint(id_to_dpid)
hosts = create_mininet_hosts(id_to_dpid, [0, 1])
for host in hosts.values():
host.start_traffic_generation_server()
# print(f"PID of server on host with IP {host.host_ip} is {host.server_proc.pid}")
source_node, destination_node = (0, 1)
flow_rate_list = [1310720]*300
hosts[source_node].configure_flow_with_precomputed_transmit_rates(flow_rate_list,
hosts[destination_node].host_ip, 50000, [1.0, 0.0, 0.0, 0.0, 0.0], hosts[source_node].host_id,
10, [0, 0, 0, 0, 0])
# for flow_id, flow in enumerate(flows):
# source_node, destination_node, flow_tx_rate = (flow.source_node, flow.destination_node,
# flow.flow_tx_rate)
# flow_json, tag_values_for_flow = simple_paths_to_flow_json(flow.paths, tag_values, id_to_dpid)
# flow_token = onos_route_adder.install_flow(flow_json)
# flow_tokens.add(flow_token)
# # ======================================= For Testing =======================================
# hosts[flow.source_node].configure_flow(flow.flow_tx_rate, 0.0,
# the_trial.get_parameter("traffic-sampling-distribution"), hosts[flow.destination_node].host_ip,
# 50000, [1.0] + [0.0]*(len(flow.paths)-1), 100, [0]*len(flow.paths))
# # ======================================= End Testing =======================================
# print(f"Tag values:\n{tag_values_for_flow}")
time.sleep(10)
traffic_monitor = stat_monitor.OnMonitor(cfg.of_controller_ip, cfg.of_controller_port)
traffic_monitor.start_monitor()
for host in hosts.values():
host.start_traffic_generation_client()
traffic_generation_client_pid = hosts[0].client_proc.pid
print(f"PID of traffic generation client: {traffic_generation_client_pid}")
# print(f"Trial duration is {the_trial.get_parameter('duration')}")
# time.sleep(the_trial.get_parameter("duration"))
# time.sleep(300)
input("Press enter to continue...")
for host in hosts.values():
host.stop_traffic_generation_client()
for host in hosts.values():
host.stop_traffic_generation_server()
traffic_monitor.stop_monitor()
utilization_results = traffic_monitor.get_monitor_statistics()
link_utilization_over_time = stat_monitor.compute_link_utilization_over_time(utilization_results)
mean_link_utilization = stat_monitor.compute_mean_link_utilization(utilization_results)
end_host_results = collect_end_host_results(hosts)
path.Path("./mean-link-utilization.txt").write_text(pp.pformat(mean_link_utilization))
path.Path("./raw-utilization-results.txt").write_text(pp.pformat(utilization_results))
path.Path("./host-utilization-results.txt").write_text(pp.pformat(end_host_results))
pp.pprint(end_host_results)
the_trial.add_parameter("byte-counts-over-time", utilization_results)
# pp.pprint(utilization_results)
except Exception as ex:
print(ex)
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_tb(exc_traceback, limit=10, file=sys.stdout)
finally:
destroy_all_mininet_hosts(hosts)
remove_all_flows(flow_tokens)
def conduct_mininet_trial(results_repository, schema_vars, the_trial_provider, the_trial):
hosts = {}
flow_allocation_seed_number = the_trial.get_parameter("seed-number")
flows = the_trial.get_parameter("flow-set")
flow_tokens = set()
tag_values = defaultdict(int)
try:
id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(EXPECTED_TOPO)
# pp.pprint(id_to_dpid)
hosts = create_mininet_hosts(id_to_dpid, [0, 1])
for host in hosts.values():
host.start_traffic_generation_server()
# print(f"PID of server on host with IP {host.host_ip} is {host.server_proc.pid}")
k_matrix = [0.0]*len(flows)
for flow_id, flow in enumerate(flows):
source, destination_node, flow_tx_rate_list = (flow.source_node, flow.destination_node,
flow.flow_tx_rate)
flow_json, tag_values_for_flow = simple_paths_to_flow_json(flow.paths, tag_values, id_to_dpid)
flow_token = onos_route_adder.install_flow(flow_json)
flow_tokens.add(flow_token)
# k_matrix is the splitting ratio
# tag_values indicate which DSCP tag to use for the path. I think we want a K-matrix that looks
# kind of like this:
#
# 1 0 0 0 0
# 0 1 0 0 0
# 0 0 1 0 0
# 0 0 0 1 0
# 0 0 0 0 1
k_matrix[flow_id] = 1.0
hosts[flow.source_node].configure_flow_with_precomputed_transmit_rates(
flow_tx_rate_list, hosts[flow.destination_node].host_ip, 50000,
pycopy.copy(k_matrix), hosts[flow.source_node].host_id,
1, tag_values_for_flow, flow_id)
k_matrix[flow_id] = 0.0
# print(f"Flow source node: {flow.source_node}. Flow destination node: {flow.destination_node}")
# print(f"Flow source IP: {hosts[flow.source_node].host_ip}, Flow destination IP: {hosts[flow.destination_node].host_ip}")
for flow_id, background_flow in enumerate(the_trial.get_parameter("background-traffic-flow-set")):
source, destination, flow_tx_rate_list = (background_flow.source_node,
background_flow.destination_node, background_flow.flow_tx_rate)
# @TODO: Another thing I need to think about is whether I should have separate flow rules
# (i.e. separate DSCP values) for the foreground and background traffic. I don't think
# that it would be necessary to have them but it might be useful as it would allow me
# to use ONOS to monitor transmission rates of background and foreground traffic separately.
# Might be able to do that with port numbers too but that would probably be more difficult/
# annoying. As an alternative the traffic generation clients will record the number of packtes
# for foreground and background traffic but you can only calculate average transmit rate
# over the course of the entire flow, not on a per timeslot basis.
# flow_json, tag_values_for_flow = simple_paths_to_flow_json(flow.paths, tag_values, id_to_dpid)
# flow_token = onos_route_adder.install_flow(flow_json)
# flow_tokens.add(flow_token)
# @TODO: I think the values that I'm getting from the solver are actually link capacity,
# not the volume of background traffic. So rather than using those values directly
# to compute a transmit rate, I need to compute (link_capacity - value_from_solver)
# and then use that to derive a transmission rate.
k_matrix[flow_id] = 1.0
hosts[background_flow.source_node].configure_flow_with_precomputed_transmit_rates(
flow_tx_rate_list, hosts[background_flow.destination_node].host_ip, 50000,
pycopy.copy(k_matrix), hosts[background_flow.source_node].host_id,
1, tag_values_for_flow, flow_id)
k_matrix[flow_id] = 0.0
# print(f"Tag values:\n{tag_values_for_flow}")
time.sleep(10)
traffic_monitor = stat_monitor.OnMonitor(cfg.of_controller_ip, cfg.of_controller_port)
traffic_monitor.start_monitor()
for host in hosts.values():
host.start_traffic_generation_client()
traffic_generation_pids = [proc.pid for proc in hosts[0].client_procs]
print(f"PIDs of traffic generation process': {traffic_generation_pids}")
trial_duration = the_trial.get_parameter("duration")
# trial_duration = 10
for idx in progressbar.progressbar(range(int(trial_duration))):
time.sleep(1.0)
# input("Press enter to continue...")
for host in hosts.values():
host.stop_traffic_generation_client()
for host in hosts.values():
host.stop_traffic_generation_server()
traffic_monitor.stop_monitor()
utilization_results = traffic_monitor.get_monitor_statistics()
link_utilization_over_time = stat_monitor.compute_link_utilization_over_time(utilization_results)
mean_link_utilization = stat_monitor.compute_mean_link_utilization(utilization_results)
end_host_results = collect_end_host_results(hosts)
path.Path("./mean-link-utilization.txt").write_text(pp.pformat(mean_link_utilization))
path.Path("./raw-utilization-results.txt").write_text(pp.pformat(utilization_results))
path.Path("./host-utilization-results.txt").write_text(pp.pformat(end_host_results))
the_trial.add_parameter("byte-counts-over-time", utilization_results)
the_trial.add_parameter("link-utilization-over-time", link_utilization_over_time)
the_trial.add_parameter("measured-link-utilization", mean_link_utilization)
the_trial.add_parameter("end-host-results", end_host_results)
except Exception as ex:
print(ex)
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_tb(exc_traceback, limit=10, file=sys.stdout)
finally:
destroy_all_mininet_hosts(hosts)
remove_all_flows(flow_tokens)