def clear(self, request, pk=None):
router = self.get_object().internet_exchange.router
if not router:
raise ServiceUnavailable("No router available to clear session")
result = router.clear_bgp_session(self.get_object())
return Response({"result": result})
def configure(self, request):
# Check user permission first
if not request.user.has_perm("peering.deploy_router_configuration"):
return Response(None, status=status.HTTP_403_FORBIDDEN)
router_ids = (request.data.get("routers[]", [])
if request.method != "GET" else
request.query_params.getlist("routers[]"))
# No router IDs, nothing to configure
if len(router_ids) < 1:
raise ServiceUnavailable("No routers to configure.")
routers = Router.objects.filter(pk__in=router_ids)
commit = request.method not in SAFE_METHODS
job_results = []
for router in routers:
job_result = JobResult.enqueue_job(
set_napalm_configuration,
"peering.router.set_napalm_configuration",
Router,
request.user,
router,
commit,
)
job_results.append(job_result)
serializer = get_serializer_for_model(JobResult)
return Response(
serializer(job_results, many=True, context={
"request": request
}).data,
status=status.HTTP_202_ACCEPTED,
)
def available_peers(self, request, pk=None):
available_peers = self.get_object().get_available_peers()
if not available_peers:
raise ServiceUnavailable("No peers found.")
return Response(
{"available-peers": PeerRecordSerializer(available_peers, many=True).data}
)
def import_peering_sessions(self, request, pk=None):
result = self.get_object().import_peering_sessions_from_router()
if not result:
raise ServiceUnavailable(
"Cannot import peering sessions from router.")
return Response({
"autonomous-system-count": result[0],
"peering-session-count": result[1],
"ignored-autonomous-systems": result[2],
})
def configure_router(self, request, pk=None):
internet_exchange = self.get_object()
if not internet_exchange.router:
raise ServiceUnavailable("No router available.")
# Check user permission first
if not request.user.has_perm("peering.deploy_configuration_internetexchange"):
return HttpResponseForbidden()
# Commit changes only if not using a GET request
error, changes = internet_exchange.router.set_napalm_configuration(
internet_exchange.generate_configuration(),
commit=(request.method not in SAFE_METHODS),
)
return Response({"changed": not error, "changes": changes, "error": error})
def configure(self, request, pk=None):
router = self.get_object()
# Check if the router runs on a supported platform
if not router.platform:
raise ServiceUnavailable("Unsupported router platform.")
# Check user permission first
if not request.user.has_perm("peering.deploy_configuration_router"):
return HttpResponseForbidden()
# Commit changes only if not using a GET request
error, changes = router.set_napalm_configuration(
router.generate_configuration(), commit=(request.method not in SAFE_METHODS)
)
return Response({"changed": not error, "changes": changes, "error": error})
def shared_internet_exchanges(self, request, pk=None):
try:
affiliated = AutonomousSystem.objects.get(
pk=request.user.preferences.get("context.as"))
except AutonomousSystem.DoesNotExist:
affiliated = None
if affiliated:
return Response({
"shared-internet-exchanges":
InternetExchangeNestedSerializer(
self.get_object().get_shared_internet_exchanges(
affiliated),
many=True,
context={
"request": request
},
).data
})
raise ServiceUnavailable("User did not choose an affiliated AS.")
def configure_task(self, request, pk=None):
router = self.get_object()
# Check if the router runs on a supported platform
if not router.platform:
raise ServiceUnavailable("Unsupported router platform.")
# Check user permission first
if not request.user.has_perm("peering.deploy_configuration_router"):
return HttpResponseForbidden()
# Enqueue a task and record the job ID in the router instance
job = enqueue_background_task(
"set_napalm_configuration",
router,
config=router.generate_configuration(),
commit=True,
)
if job:
router.last_deployment_id = job.id
router.save()
return Response({"status": "success"})
def test_napalm_connection(self, request, pk=None):
success = self.get_object().test_napalm_connection()
if not success:
raise ServiceUnavailable("Cannot connect to router using NAPALM.")
return Response({"status": "success"})
def poll_peering_sessions(self, request, pk=None):
success = self.get_object().poll_peering_sessions()
if not success:
raise ServiceUnavailable("Cannot update peering session states.")
return Response({"status": "success"})
def link_to_peeringdb(self, request, pk=None):
netixlan, ix = self.get_object().link_to_peeringdb()
if not netixlan and not ix:
raise ServiceUnavailable("Unable to link to PeeringDB.")
return Response({"sucess": True})