Add v2 APIs for Project

We have added several APIs to help users easily manage Projects
and objects related to each project, such as notifiers, rules, exporters, and URLs.

Author: hoangpn

promgen/filters.py

@@ -192,3 +192,26 @@ class URLFilter(django_filters.rest_framework.FilterSet):
         choices=models.Probe.objects.values_list("module", "description").distinct(),
         help_text="Filter by exact probe scheme. Example: probe=http_2xx",
     )
+
+
+class ProjectFilterV2(django_filters.rest_framework.FilterSet):
+    name = django_filters.CharFilter(
+        field_name="name",
+        lookup_expr="contains",
+        help_text="Filter by project name containing a specific substring. Example: name=Example Project",
+    )
+    service = django_filters.CharFilter(
+        field_name="service__name",
+        lookup_expr="exact",
+        help_text="Filter by exact service name. Example: service=Example Service",
+    )
+    shard = django_filters.CharFilter(
+        field_name="shard__name",
+        lookup_expr="exact",
+        help_text="Filter by exact shard name. Example: shard=Example Shard",
+    )
+    owner = django_filters.CharFilter(
+        field_name="owner__username",
+        lookup_expr="exact",
+        help_text="Filter by exact owner username. Example: owner=Example Owner",
+    )

promgen/fixtures/testcases.yaml

@@ -70,8 +70,8 @@
   pk: 2
   fields:
     name: another-project
-    owner: 1
-    service: 1
+    owner: 2
+    service: 2
     shard: 1
     farm: 1
 - model: promgen.host

promgen/rest_v2.py

@@ -14,7 +14,7 @@
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 
-from promgen import filters, models, serializers
+from promgen import filters, models, serializers, signals
 
 class RuleMixin:
     @extend_schema(
@@ -340,3 +340,194 @@ class URLViewSet(mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.Gene
     lookup_value_regex = "[^/]+"
     lookup_field = "id"
     pagination_class = PromgenPagination
+
+
+@extend_schema_view(
+    list=extend_schema(summary="List Projects", description="Retrieve a list of all projects."),
+    retrieve=extend_schema(
+        summary="Retrieve Project",
+        description="Retrieve detailed information about a specific project.",
+    ),
+    create=extend_schema(summary="Create Project", description="Create a new project."),
+    update=extend_schema(summary="Update Project", description="Update an existing project."),
+    partial_update=extend_schema(
+        summary="Partially Update Project", description="Partially update an existing project."
+    ),
+    destroy=extend_schema(summary="Delete Project", description="Delete an existing project."),
+)
+@extend_schema(tags=["Project"])
+class ProjectViewSet(NotifierMixin, RuleMixin, viewsets.ModelViewSet):
+    queryset = models.Project.objects.prefetch_related("service", "shard", "farm")
+    filterset_class = filters.ProjectFilterV2
+    lookup_value_regex = "[^/]+"
+    lookup_field = "id"
+    pagination_class = PromgenPagination
+
+    def get_serializer_class(self):
+        if self.action == "list":
+            return serializers.ProjectRetrieveSerializer
+        if self.action == "retrieve":
+            return serializers.ProjectRetrieveSerializer
+        if self.action == "create":
+            return serializers.ProjectCreateSerializer
+        if self.action == "update":
+            return serializers.ProjectUpdateSerializer
+        if self.action == "partial_update":
+            return serializers.ProjectUpdateSerializer
+        return serializers.ProjectRetrieveSerializer
+
+    @extend_schema(
+        summary="List Exporters",
+        description="Retrieve all exporters associated with the specified project.",
+        responses=serializers.ExporterSerializer(many=True),
+    )
+    @action(detail=True, methods=["get"], pagination_class=None, filterset_class=None)
+    def exporters(self, request, id):
+        project = self.get_object()
+        return Response(serializers.ExporterSerializer(project.exporter_set.all(), many=True).data)
+
+    @extend_schema(
+        summary="List URLs",
+        description="Retrieve all URLs associated with the specified project.",
+        responses=serializers.URLSerializer(many=True),
+    )
+    @action(detail=True, methods=["get"], pagination_class=None, filterset_class=None)
+    def urls(self, request, id):
+        project = self.get_object()
+        return Response(serializers.URLSerializer(project.url_set.all(), many=True).data)
+
+    @extend_schema(
+        summary="Link Farm",
+        description="Link a farm to the specified project.",
+        request=serializers.LinkFarmSerializer,
+        responses=serializers.ProjectRetrieveSerializer,
+    )
+    @action(detail=True, methods=["patch"], url_path="farm-link")
+    def link_farm(self, request, id):
+        serializer = serializers.LinkFarmSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        project = self.get_object()
+        farm, created = models.Farm.objects.get_or_create(
+            name=serializer.validated_data["farm"],
+            source=serializer.validated_data["source"],
+        )
+        if created:
+            farm.refresh()
+        project.farm = farm
+        project.save()
+        return Response(serializers.ProjectRetrieveSerializer(project).data)
+
+    @extend_schema(
+        summary="Unlink Farm",
+        description="Unlink the farm from the specified project.",
+        responses=serializers.ProjectRetrieveSerializer,
+    )
+    @action(detail=True, methods=["patch"], url_path="farm-unlink")
+    def unlink_farm(self, request, id):
+        project = self.get_object()
+        if project.farm is None:
+            return Response(serializers.ProjectRetrieveSerializer(project).data)
+
+        old_farm, project.farm = project.farm, None
+        project.save()
+        signals.trigger_write_config.send(request)
+
+        if old_farm.project_set.count() == 0 and old_farm.editable is False:
+            old_farm.delete()
+        return Response(serializers.ProjectRetrieveSerializer(project).data)
+
+    @extend_schema(
+        summary="Register URL",
+        description="Register a new URL for the specified project.",
+        request=serializers.RegisterURLProjectSerializer,
+        responses={201: serializers.URLSerializer(many=True)},
+    )
+    @urls.mapping.post
+    def register_url(self, request, id):
+        serializer = serializers.RegisterURLProjectSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        project = self.get_object()
+
+        models.URL.objects.get_or_create(
+            project=project,
+            url=serializer.validated_data["url"],
+            probe=serializer.validated_data["probe"],
+        )
+        return Response(
+            serializers.URLSerializer(project.url_set, many=True).data, status=HTTPStatus.CREATED
+        )
+
+    @extend_schema(
+        summary="Delete URL",
+        description="Delete a URL from the specified project.",
+    )
+    @action(
+        detail=True,
+        methods=["delete"],
+        url_path="urls/(?P<url_id>\d+)",
+        pagination_class=None,
+        filterset_class=None,
+    )
+    def delete_url(self, request, id, url_id):
+        project = self.get_object()
+        models.URL.objects.filter(project=project, pk=url_id).delete()
+        return Response(status=HTTPStatus.NO_CONTENT)
+
+    @extend_schema(
+        summary="Register Exporter",
+        description="Register a new exporter for the specified project.",
+        request=serializers.RegisterExporterProjectSerializer,
+        responses={201: serializers.ExporterSerializer(many=True)},
+    )
+    @exporters.mapping.post
+    def register_exporter(self, request, id):
+        serializer = serializers.RegisterExporterProjectSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        project = self.get_object()
+
+        attributes = {
+            "project_id": project.id,
+        }
+
+        for field in serializer.fields:
+            value = serializer.validated_data.get(field)
+            if value is not None:
+                attributes[field] = value
+
+        models.Exporter.objects.get_or_create(**attributes)
+        return Response(
+            serializers.ExporterSerializer(project.exporter_set, many=True).data,
+            status=HTTPStatus.CREATED,
+        )
+
+    @extend_schema(
+        summary="Update Exporter",
+        description="Update an existing exporter for the specified project.",
+        request=serializers.UpdateExporterProjectSerializer,
+        responses=serializers.ExporterSerializer(many=True),
+    )
+    @action(
+        detail=True,
+        methods=["patch"],
+        url_path="exporters/(?P<exporter_id>\d+)",
+        pagination_class=None,
+        filterset_class=None,
+    )
+    def update_exporter(self, request, id, exporter_id):
+        serializer = serializers.UpdateExporterProjectSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        project = self.get_object()
+        exporter = models.Exporter.objects.filter(project=project, pk=exporter_id).first()
+        exporter.enabled = serializer.validated_data.get("enabled")
+        exporter.save()
+        return Response(serializers.ExporterSerializer(project.exporter_set, many=True).data)
+
+    @extend_schema(
+        summary="Delete Exporter",
+        description="Delete an exporter from the specified project.",
+    )
+    @update_exporter.mapping.delete
+    def delete_exporter(self, request, id, exporter_id):
+        project = self.get_object()
+        models.Exporter.objects.filter(project=project, pk=exporter_id).delete()
+        return Response(status=HTTPStatus.NO_CONTENT)

promgen/serializers.py

@@ -53,7 +53,7 @@ class Meta:
 
 class SenderSerializer(serializers.ModelSerializer):
     owner = serializers.ReadOnlyField(source="owner.username")
-    label = serializers.ReadOnlyField(source="show_value")
+    label = serializers.CharField(source="show_value", read_only=True)
 
     class Meta:
         model = models.Sender
@@ -251,3 +251,141 @@ class URLSerializer(serializers.ModelSerializer):
     class Meta:
         model = models.URL
         fields = "__all__"
+
+
+@extend_schema_field(OpenApiTypes.STR)
+class OwnerField(serializers.Field):
+    def to_internal_value(self, data):
+        if not data:
+            return serializers.CurrentUserDefault()
+        try:
+            owner = User.objects.get(username=data)
+        except User.DoesNotExist:
+            raise serializers.ValidationError("Owner does not exist.")
+        return owner
+
+    def to_representation(self, value):
+        return value.username
+
+
+@extend_schema_field(OpenApiTypes.STR)
+class ServiceField(serializers.Field):
+    def to_internal_value(self, data):
+        try:
+            service = models.Service.objects.get(name=data)
+        except models.Service.DoesNotExist:
+            raise serializers.ValidationError("Service does not exist.")
+        return service
+
+    def to_representation(self, value):
+        return value.name
+
+
+@extend_schema_field(OpenApiTypes.STR)
+class ShardField(serializers.Field):
+    def to_internal_value(self, data):
+        try:
+            shard = models.Shard.objects.get(name=data)
+        except models.Shard.DoesNotExist:
+            raise serializers.ValidationError("Shard does not exist.")
+        return shard
+
+    def to_representation(self, value):
+        return value.name
+
+
+@extend_schema_field(OpenApiTypes.STR)
+class FarmField(serializers.Field):
+    def to_internal_value(self, data):
+        try:
+            farm = models.Farm.objects.get(name=data)
+        except models.Farm.DoesNotExist:
+            raise serializers.ValidationError("Farm does not exist.")
+        return farm
+
+    def to_representation(self, value):
+        return value.name
+
+
+class ProjectRetrieveSerializer(serializers.ModelSerializer):
+    owner = serializers.ReadOnlyField(source="owner.username")
+    service = serializers.ReadOnlyField(source="service.name")
+    shard = serializers.ReadOnlyField(source="shard.name")
+    farm = serializers.ReadOnlyField(source="farm.name")
+
+    class Meta:
+        model = models.Project
+        fields = "__all__"
+
+
+class ProjectCreateSerializer(serializers.ModelSerializer):
+    owner = OwnerField(required=False, default=serializers.CurrentUserDefault())
+    service = ServiceField()
+    shard = ShardField()
+    farm = FarmField(required=False)
+
+    class Meta:
+        model = models.Project
+        fields = "__all__"
+
+
+class ProjectUpdateSerializer(serializers.ModelSerializer):
+    owner = OwnerField(required=False)
+    service = ServiceField(required=False, read_only=True)
+    shard = ShardField(required=False)
+    farm = serializers.ReadOnlyField(source="farm.name")
+    name = serializers.CharField(required=False)
+
+    class Meta:
+        model = models.Project
+        fields = "__all__"
+
+
+class LinkFarmSerializer(serializers.Serializer):
+    farm = serializers.CharField()
+    source = serializers.ChoiceField(choices=[name for name, _ in models.Farm.driver_set()])
+
+
+@extend_schema_field(OpenApiTypes.STR)
+class ProbeField(serializers.Field):
+    def to_internal_value(self, data):
+        try:
+            probe = models.Probe.objects.get(module=data)
+        except models.Probe.DoesNotExist:
+            raise serializers.ValidationError("Probe does not exist.")
+        return probe
+
+    def to_representation(self, value):
+        return value.module
+
+
+class RegisterURLProjectSerializer(serializers.Serializer):
+    url = serializers.CharField()
+    probe = ProbeField()
+
+
+class RegisterExporterProjectSerializer(serializers.Serializer):
+    job = serializers.CharField()
+    port = serializers.IntegerField()
+    path = serializers.CharField()
+    scheme = serializers.ChoiceField(choices=["http", "https"])
+    enabled = serializers.BooleanField(required=False)
+
+
+class UpdateExporterProjectSerializer(serializers.Serializer):
+    enabled = serializers.BooleanField()
+
+
+class DeleteExporterProjectSerializer(serializers.Serializer):
+    job = serializers.CharField()
+    port = serializers.IntegerField()
+    path = serializers.CharField()
+    scheme = serializers.CharField()
+
+
+class RegisterNotifierSerializer(serializers.Serializer):
+    sender = serializers.ChoiceField(choices=[name for name, _ in models.Sender.driver_set()])
+    value = serializers.CharField()
+    alias = serializers.CharField(required=False)
+    enabled = serializers.BooleanField(required=False, default=True)
+    filters = FilterSerializer(many=True, required=False)