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