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})