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 enqueue_webhooks(instance, user, request_id, action):
"""
Enqueues webhooks so they can be processed.
"""
# Ignore object changes as a webhook is about informing of a change
if isinstance(instance, ObjectChange):
return
# Finds usable webhooks
action_flag = {
ObjectChangeAction.CREATE: "type_create",
ObjectChangeAction.UPDATE: "type_update",
ObjectChangeAction.DELETE: "type_delete",
}[action]
webhooks = Webhook.objects.filter(enabled=True, **{action_flag: True})
if webhooks.exists():
# Get the Model's API serializer class and serialize the object
serializer_class = get_serializer_for_model(instance.__class__)
serializer_context = {"request": None}
serializer = serializer_class(instance, context=serializer_context)
# Enqueue the webhooks
webhook_queue = get_queue("default")
for webhook in webhooks:
webhook_queue.enqueue(
"webhooks.workers.process_webhook",
webhook,
serializer.data,
instance._meta.model_name,
action,
str(timezone.now()),
user.username,
request_id,
)
def get_serializer_class(self):
request = self.get_serializer_context()["request"]
if request.query_params.get("brief"):
try:
return get_serializer_for_model(self.queryset.model,
suffix="Nested")
except Exception:
pass
# Fall back to the hard-coded serializer class
return self.serializer_class
def update_local(self, request):
job_result = JobResult.enqueue_job(synchronize,
"peeringdb.synchronize",
Synchronization, request.user)
serializer = get_serializer_for_model(JobResult)
return Response(
serializer(instance=job_result, context={
"request": request
}).data,
status=status.HTTP_202_ACCEPTED,
)
def test_napalm_connection(self, request, pk=None):
job_result = JobResult.enqueue_job(
test_napalm_connection,
"peering.router.test_napalm_connection",
Router,
request.user,
self.get_object(),
)
serializer = get_serializer_for_model(JobResult)
return Response(
serializer(instance=job_result, context={
"request": request
}).data,
status=status.HTTP_202_ACCEPTED,
)
def get_changed_object(self, o):
"""
Serialize a nested representation of the changed object.
"""
if o.changed_object is None:
return None
try:
serializer = get_serializer_for_model(o.changed_object,
prefix="Nested")
except Exception:
return o.object_repr
context = {"request": self.context["request"]}
data = serializer(o.changed_object, context=context).data
return data
def configuration(self, request, pk=None):
# Check user permission first
if not request.user.has_perm("peering.view_router_configuration"):
return Response(None, status=status.HTTP_403_FORBIDDEN)
job_result = JobResult.enqueue_job(
generate_configuration,
"peering.router.generate_configuration",
Router,
request.user,
self.get_object(),
)
serializer = get_serializer_for_model(JobResult)
return Response(
serializer(instance=job_result, context={
"request": request
}).data,
status=status.HTTP_202_ACCEPTED,
)
def poll_peering_sessions(self, request, pk=None):
# Check user permission first
if not request.user.has_perm("peering.change_directpeeringsession"):
return Response(None, status=status.HTTP_403_FORBIDDEN)
job_result = JobResult.enqueue_job(
poll_peering_sessions,
"peering.bgpgroup.poll_peering_sessions",
BGPGroup,
request.user,
self.get_object(),
)
serializer = get_serializer_for_model(JobResult)
return Response(
serializer(instance=job_result, context={
"request": request
}).data,
status=status.HTTP_202_ACCEPTED,
)
def import_peering_sessions(self, request, pk=None):
if not request.user.has_perm(
"peering.add_internetexchangepeeringsession"):
return Response(None, status=status.HTTP_403_FORBIDDEN)
job_result = JobResult.enqueue_job(
import_peering_sessions_from_router,
"peering.internet_exchange.import_peering_sessions_from_router",
InternetExchange,
request.user,
self.get_object(),
)
serializer = get_serializer_for_model(JobResult)
return Response(
serializer(instance=job_result, context={
"request": request
}).data,
status=status.HTTP_202_ACCEPTED,
)
