def test_activate_desactivate_route(self):
"""
Test the activation/desactivation of temporary route
"""
# add test route
self.add_default_route()
# get the test route
route_list = self.get_route_list()
route = self.get_test_route(route_list)
route_id = route['id']
# check if the test route is active
route_activation = route['is_activated']
self.assertTrue(
route_activation, "\n\n>>> Route should be activated\
when created")
# desactivate test route
request_json.enable_disable_route(route_id, False)
# get the route
test = request_json.get_one_route(route_id)
route = test.json()
# check if the test route is not active
route_activation = route['is_activated']
self.assertFalse(
route_activation, "\n\n>>> Route should be \
desactivated when desactivated")
# delete test route
request_json.delete_route(route_id)
def delete_default_route(self):
"""
Intermediate testing function
Clarify the process of deleting the test route
"""
# get the list of routes
json_data = self.get_route_list()
# find the route to delete
route = self.get_test_route(json_data)
route_id = str(route['id'])
request_json.delete_route(route_id)
def delete_random(self):
"""
Route deletion ( almost all )
Efficient in parrallel, unreliable alone
May ask to delete routes that have already been deleted
"""
response = requests_get(settings.API_URL)
json_data = response.json()
json_size = len(json_data)
print(json_size, "routes to destroy\n")
# find the routes to delete
for _ in range(int(json_size)):
route = random_choice(json_data)
if self.is_deletable_route(route):
route_id = str(route['id'])
print(">> ", route_id)
request_json.delete_route(route_id)
def perf_route_deletion(self):
"""
Performance test
Route deletion ( 'amount' )
Fast but no feedback
"""
print("\n")
json_data = self.get_route_list()
amount_deleted = 0
for route in json_data:
if self.is_deletable_route(route):
route_id = str(route['id'])
request_json.delete_route(route_id)
amount_deleted += 1
if amount_deleted == self.amount:
break
def test_modify_route(self):
"""
Test to modify a temporaty route
"""
# add test route
self.add_default_route()
# get the test route
route_list = self.get_route_list()
route = self.get_test_route(route_list)
route_id = route['id']
#old_route_modified_at = route['modified_at']
old_route_ip = route['ip']
old_route_next_hop = route['next_hop']
old_route_community = route['communities']
# update route
request_json.put_route(route_id, self.modif_ip, self.modif_next_hop,
self.modif_community)
# get the modified test route
test = request_json.get_one_route(route_id)
route = test.json()
# TODO : 'modified_at' can't be tested unless we wait at least a minute
# (would slow down the testing process)
# check the differences
self.assertEqual(route['ip'], self.modif_ip)
self.assertEqual(route['next_hop'], self.modif_next_hop)
self.assertEqual(route['communities'], [self.modif_community])
self.assertNotEqual(route['ip'], old_route_ip)
self.assertNotEqual(route['next_hop'], old_route_next_hop)
self.assertNotEqual(route['communities'], old_route_community)
# delete test route
request_json.delete_route(route_id)
def perf_route_destruction(self):
"""
Performance test
Route deletion ( all )
"""
json_data = self.get_route_list()
json_size = len(json_data)
limit_percent = int(json_size/100)
deletions = 0
advancement = 0
# print("json_size",json_size)
# print("limit_percent",limit_percent)
print(" ")
print(json_size, "routes to destroy\n")
self.show_advancement(advancement)
# find the routes to delete
for route in json_data:
if self.is_deletable_route(route):
route_id = str(route['id'])
request_json.delete_route(route_id)
deletions += 1
advancement += 1
if advancement > limit_percent:
advancement = 0
progress = int((deletions-1)/json_size*100)
self.show_advancement(progress)
self.show_advancement(100)
def index(request):
"""
Activated when trying to access the dashboard
The entire dashboard will update for each modification.
It would have been preferable to update only the concerned elements,
but that would require javascript and more development time.
:param request: the request page
:return: dashboard for authenticated, login page for anonymous
"""
global requestlist
log_length = 500
# AUTHENTIFICATION
if not_auth(request):
return redirect(settings.AUTH_URL)
# AUTHENTIFICATION
try:
response = requests.get(settings.API_URL)
except ConnectionError as exception:
return render(request, 'error/Error503.html', {'exception': exception})
if len(requestlist) > log_length:
requestlist = ''
try:
json_data = response.json()
except ValueError as exception:
return render(request, 'error/Error409.html', {'exception': exception})
if request.method == 'POST':
form = PostForm(request.POST)
json_data = sort_switcher(request.POST, json_data)
if 'id_delete' in request.POST:
response_actual = rq_json.delete_route(
str(request.POST['id_delete']))
requestlist = requestlist[:] + '| Delete ' + str(
request.POST['id_delete']) + ': ' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'id_modify' in request.POST:
response_actual = rq_json.put_route(
str(request.POST['id_modify']), str(request.POST['ip']),
str(request.POST['next_hop']),
check_community(str(request.POST['communities'])))
requestlist = requestlist[:] + '| Modify ' + str(
request.POST['id_modify']) + ': ' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'id1' in request.POST:
response_actual = rq_json.enable_disable_route(
str(request.POST['id1']), False)
requestlist = requestlist[:] + '| Disable ' + \
str(request.POST['id1']) + ': ' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'id2' in request.POST:
response_actual = rq_json.enable_disable_route(
str(request.POST['id2']), True)
requestlist = requestlist[:] + '| Enable ' + \
str(request.POST['id2']) + ': ' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'id_to_delete' in request.POST:
for key, values in request.POST.lists():
if key == 'listed_id':
for value in values:
response_actual = rq_json.delete_route(str(value))
requestlist = requestlist[:] + '| Delete ' + \
str(value) + ': ' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'id_to_disable' in request.POST:
for key, values in request.POST.lists():
if key == 'listed_id':
for value in values:
response_actual = rq_json.enable_disable_route(
str(value), False)
requestlist = requestlist[:] + '| Disable ' + \
str(value) + ': ' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'id_to_enable' in request.POST:
for key, values in request.POST.lists():
if key == 'listed_id':
for value in values:
response_actual = rq_json.enable_disable_route(
str(value), True)
requestlist = requestlist[:] + '| Enable ' + \
str(value) + ': ' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'export' in request.POST:
exportfile = open(str(request.POST['export']), 'w')
json.dump(json_data, exportfile)
exportfile.close()
return redirect(settings.DASHBOARD_URL)
if 'import' in request.POST:
try:
importfile = open(str(request.POST['import']), 'r')
except FileNotFoundError as exception:
return render(request, 'error/Error404.html',
{'exception': exception})
json_file = json.load(importfile)
for to_import in json_file:
response_actual = rq_json.post_new_route(
to_import['ip'], to_import['next_hop'],
check_community(to_import['communities']))
requestlist = requestlist[:] + \
'| Post:' + str(response_actual) + ' '
return redirect(settings.DASHBOARD_URL)
if 'command_bgp' in request.POST:
response_actual = rq_json.post_command_bgp(
str(request.POST['command_bgp']))
requestlist = requestlist[:] + \
'| ExaBGP:' + str(response_actual.text) + ' '
if form.is_valid():
route = form.save(commit=False)
response_actual = rq_json.post_new_route(
str(route.ip), str(route.next_hop),
check_community(str(route.community)))
requestlist = requestlist[:] + '| Post:' + str(response_actual)
return redirect(settings.DASHBOARD_URL)
else:
form = PostForm()
return render(
request, settings.TEMPLATE_DASHBOARD, {
'data': json_data,
'form': form,
'sort': request.POST,
'response': requestlist,
})