def conflict_resolver(pyt_src,
pyt_dst,
mydict,
gamma,
conflict_type,
rap,
src_intersection_part=None,
dst_intersection_part=None,
src_port_intersection_part=None,
dst_port_intersection_part=None):
if (conflict_type == "shadowing"):
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
print("Hold R")
elif (conflict_type == "redundancy_gamma_removing"):
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
add_rule_to_patricia(pyt_src, pyt_dst, mydict)
add_rule_to_newft(mydict)
print("REDUNDANCY GAMMA REMOVED AND R ADDED")
elif (conflict_type == "redundancy"):
print("No adding of R")
elif (conflict_type == "generalization"):
'''a=input('generalization conflict. Choose one flow rule : ')
if(a=="gamma"):
print("No need to add rule")
else :
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
add_rule_to_patricia(pyt_src, pyt_dst, mydict)
add_rule_to_newft(mydict)
print("Resolved Generalization:")'''
# delete_rule_from_pt_ft(pyt_src, pyt_dst, mydict)
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]), int(gamma["src_end"]))),
src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]), int(gamma["dst_end"]))),
dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
add_rule_to_newft(x)
elif (conflict_type == "overlap"):
''''a=input('Overlap conflict. Choose one flow rule : ')
if(a=="gamma"):
print("No need to add rule")
else :
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
add_rule_to_patricia(pyt_src, pyt_dst, mydict)
add_rule_to_newft(mydict)
print("Resolved Overlap:")
# print "Do union here" #union operation'''
# delete_rule_from_pt_ft(pyt_src, pyt_dst, mydict)
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]), int(gamma["src_end"]))),
src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]), int(gamma["dst_end"]))),
dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
add_rule_to_newft(x)
elif (conflict_type == "correlation_prompt"):
'''a=input('Correlation conflict. Choose one flow rule : ')
if(a=="gamma"):
print("No need to add rule")
else :
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
add_rule_to_patricia(pyt_src, pyt_dst, mydict)
add_rule_to_newft(mydict) '''
# delete_rule_from_pt_ft(pyt_src, pyt_dst, mydict)
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]), int(gamma["src_end"]))),
src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]), int(gamma["dst_end"]))),
dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
add_rule_to_newft(x)
print("Resolved correlation:")
elif (conflict_type == "correlation"):
# delete_rule_from_pt_ft(pyt_src, pyt_dst, mydict)
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]), int(gamma["src_end"]))),
src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]), int(gamma["dst_end"]))),
dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
add_rule_to_newft(x)
'''elif(conflict_type=="imbrication"):
a=input('Cross layer conflict. Choose one flow rule : ')
if(a=="gamma"):
print("No need to add rule")
else :
add_rule_to_patricia(pyt_src, pyt_dst, mydict)
add_rule_to_newft(mydict)
print("Resolved Imbrication:")'''
return rap
def conflict_resolver(pyt_src,
pyt_dst,
mydict,
gamma,
conflict_type,
rap,
src_intersection_part=None,
dst_intersection_part=None,
src_port_intersection_part=None,
dst_port_intersection_part=None):
if (conflict_type == "shadowing"):
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
rap = 200
print("Removed gamma R Holded")
elif (conflict_type == "redundancy_gamma_removing"):
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
add_rule_to_patricia(pyt_src, pyt_dst, mydict)
# add_rule_to_newft(mydict)
print("Gamma Removed R adds")
elif (conflict_type == "redundancy"):
print("No adding of R")
pass
elif (conflict_type == "generalization"):
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]),
int(gamma["src_end"]) + 1)), src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]),
int(gamma["dst_end"]) + 1)), dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
# add_rule_to_newft(x)
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
print("gamma Splitted")
elif (conflict_type == "overlap"):
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]),
int(gamma["src_end"]) + 1)), src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]),
int(gamma["dst_end"]) + 1)), dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
# add_rule_to_newft(x)
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
print("gamma Splitted")
elif (conflict_type == "correlation_prompt"):
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]),
int(gamma["src_end"]) + 1)), src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]),
int(gamma["dst_end"]) + 1)), dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
# add_rule_to_newft(x)
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
print("gamma Splitted:")
elif (conflict_type == "correlation"):
rap = 200
src_ip_list = excluding_ip.func_exclude_ip(gamma["src_ip"],
src_intersection_part)
dst_ip_list = excluding_ip.func_exclude_ip(gamma["dst_ip"],
dst_intersection_part)
src_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["src_start"]),
int(gamma["src_end"]) + 1)), src_port_intersection_part)
dst_port_list = excluding_port.func_exclude_port(
list(range(int(gamma["dst_start"]),
int(gamma["dst_end"]) + 1)), dst_port_intersection_part)
f_list = add_all_rules_after_excluding.add_all_rules(
src_ip_list, dst_ip_list, src_port_list, dst_port_list, mydict,
gamma, pyt_src, pyt_dst)
for x in f_list:
add_rule_to_patricia(pyt_src, pyt_dst, x)
# add_rule_to_newft(x)
delete_rule_from_pt_ft(pyt_src, pyt_dst, gamma)
print("gamma Splitted")
return rap