feat(GitLab): Receive webhooks for automatic state sync (#7301)

Author: khvn26

api/api/urls/v1.py

@@ -11,6 +11,7 @@
 from features.feature_health.views import feature_health_webhook
 from features.views import SDKFeatureStates, get_multivariate_options
 from integrations.github.views import github_webhook
+from integrations.gitlab.views import gitlab_webhook
 from organisations.views import chargebee_webhook
 
 schema_view_permission_class = (  # pragma: no cover
@@ -42,6 +43,12 @@
     re_path(r"cb-webhook/", chargebee_webhook, name="chargebee-webhook"),
     # GitHub integration webhook
     re_path(r"github-webhook/", github_webhook, name="github-webhook"),
+    # GitLab integration webhook
+    path(
+        "gitlab-webhook/<uuid:webhook_uuid>/",
+        gitlab_webhook,
+        name="gitlab-webhook",
+    ),
     re_path(r"cb-webhook/", chargebee_webhook, name="chargebee-webhook"),
     # Feature health webhook
     re_path(

api/features/feature_external_resources/models.py

@@ -5,6 +5,7 @@
 from django.db import models
 from django.db.models import Q
 from django_lifecycle import (  # type: ignore[import-untyped]
+    AFTER_DELETE,
     AFTER_SAVE,
     BEFORE_DELETE,
     LifecycleModelMixin,
@@ -32,6 +33,12 @@ class ResourceType(models.TextChoices):
     GITLAB_MR = "GITLAB_MR", "GitLab MR"
 
 
+GITLAB_RESOURCE_TYPES: tuple[ResourceType, ...] = (
+    ResourceType.GITLAB_ISSUE,
+    ResourceType.GITLAB_MR,
+)
+
+
 tag_by_type_and_state = {
     ResourceType.GITHUB_ISSUE.value: {
         "open": GitHubTag.ISSUE_OPEN.value,
@@ -135,6 +142,32 @@ def notify_github_on_link(self):  # type: ignore[no-untyped-def]
                 feature_states=feature_states,
             )
 
+    @hook(AFTER_SAVE, when="type", is_now="GITLAB_ISSUE")  # type: ignore[misc]
+    @hook(AFTER_SAVE, when="type", is_now="GITLAB_MR")  # type: ignore[misc]
+    def apply_gitlab_tag(self) -> None:
+        from integrations.gitlab.services import apply_initial_tag
+
+        apply_initial_tag(self)
+
+    @hook(AFTER_DELETE, when="type", is_now="GITLAB_ISSUE")  # type: ignore[misc]
+    @hook(AFTER_DELETE, when="type", is_now="GITLAB_MR")  # type: ignore[misc]
+    def deregister_gitlab_webhook(self) -> None:
+        from integrations.gitlab.models import GitLabConfiguration
+        from integrations.gitlab.services import parse_project_path
+        from integrations.gitlab.tasks import (
+            deregister_gitlab_webhook as deregister_task,
+        )
+
+        project_path = parse_project_path(self.url)
+        if project_path is None:
+            return
+        config = GitLabConfiguration.objects.filter(
+            project=self.feature.project,
+        ).first()
+        if config is None:
+            return
+        deregister_task.delay(args=(config.id, project_path))
+
     @hook(BEFORE_DELETE, when="type", is_now="GITHUB_ISSUE")  # type: ignore[misc]
     @hook(BEFORE_DELETE, when="type", is_now="GITHUB_PR")  # type: ignore[misc]
     def notify_github_on_unlink(self) -> None:

api/features/feature_external_resources/views.py

@@ -14,9 +14,12 @@
     label_github_issue_pr,
 )
 from integrations.github.models import GitHubRepository
+from integrations.gitlab.models import GitLabConfiguration
+from integrations.gitlab.services import parse_project_path
+from integrations.gitlab.tasks import register_gitlab_webhook
 from organisations.models import Organisation
 
-from .models import FeatureExternalResource, ResourceType
+from .models import GITLAB_RESOURCE_TYPES, FeatureExternalResource, ResourceType
 from .serializers import FeatureExternalResourceSerializer
 
 
@@ -72,10 +75,16 @@ def list(self, request, *args, **kwargs) -> Response:  # type: ignore[no-untyped
         return Response(data={"results": data})
 
     def create(self, request, *args, **kwargs):  # type: ignore[no-untyped-def]
-        if request.data.get("type") not in [
+        resource_type = request.data.get("type")
+
+        # GitLab side effects run in ``perform_create`` below.
+        if resource_type in GITLAB_RESOURCE_TYPES:
+            return super().create(request, *args, **kwargs)
+
+        if resource_type not in (
             ResourceType.GITHUB_ISSUE,
             ResourceType.GITHUB_PR,
-        ]:
+        ):
             return super().create(request, *args, **kwargs)
 
         feature = get_object_or_404(
@@ -137,12 +146,21 @@ def create(self, request, *args, **kwargs):  # type: ignore[no-untyped-def]
 
     def perform_create(self, serializer: FeatureExternalResourceSerializer) -> None:  # type: ignore[override]
         resource = serializer.save()
+        resource_type = ResourceType(resource.type)
+
+        if resource_type in GITLAB_RESOURCE_TYPES:
+            project_path = parse_project_path(resource.url)
+            config = GitLabConfiguration.objects.filter(
+                project=resource.feature.project,
+            ).first()
+            if config is not None and project_path is not None:
+                register_gitlab_webhook.delay(args=(config.id, project_path))
 
         log_event_names: dict[ResourceType, tuple[str, str]] = {
             ResourceType.GITLAB_ISSUE: ("gitlab", "issue.linked"),
             ResourceType.GITLAB_MR: ("gitlab", "merge_request.linked"),
         }
-        if (resource_type := ResourceType(resource.type)) in log_event_names:
+        if resource_type in log_event_names:
             logger_name, event_name = log_event_names[resource_type]
             structlog.get_logger(logger_name).info(
                 event_name,

api/integrations/gitlab/client/__init__.py

@@ -1,4 +1,6 @@
 from integrations.gitlab.client.api import (
+    create_project_hook,
+    delete_project_hook,
     fetch_gitlab_projects,
     search_gitlab_issues,
     search_gitlab_merge_requests,
@@ -8,13 +10,17 @@
     GitLabMergeRequest,
     GitLabPage,
     GitLabProject,
+    GitLabProjectHook,
 )
 
 __all__ = [
     "GitLabIssue",
     "GitLabMergeRequest",
     "GitLabPage",
     "GitLabProject",
+    "GitLabProjectHook",
+    "create_project_hook",
+    "delete_project_hook",
     "fetch_gitlab_projects",
     "search_gitlab_issues",
     "search_gitlab_merge_requests",

api/integrations/gitlab/client/api.py

@@ -1,5 +1,6 @@
 from collections.abc import Mapping
 from typing import Any
+from urllib.parse import quote
 
 import requests
 
@@ -8,6 +9,7 @@
     GitLabMergeRequest,
     GitLabPage,
     GitLabProject,
+    GitLabProjectHook,
     T,
 )
 
@@ -147,3 +149,44 @@ def search_gitlab_merge_requests(
         for item in response.json()
     ]
     return _gitlab_page(results, response.headers)
+
+
+def create_project_hook(
+    instance_url: str,
+    access_token: str,
+    *,
+    project_path: str,
+    hook_url: str,
+    secret: str,
+) -> GitLabProjectHook:
+    encoded_path = quote(project_path, safe="")
+    response = requests.post(
+        f"{instance_url}/api/v4/projects/{encoded_path}/hooks",
+        headers={"PRIVATE-TOKEN": access_token},
+        json={
+            "url": hook_url,
+            "token": secret,
+            "issues_events": True,
+            "merge_requests_events": True,
+            "enable_ssl_verification": True,
+        },
+    )
+    response.raise_for_status()
+    payload = response.json()
+    return {"id": payload["id"], "project_id": payload["project_id"]}
+
+
+def delete_project_hook(
+    instance_url: str,
+    access_token: str,
+    *,
+    project_id: int,
+    hook_id: int,
+) -> None:
+    response = requests.delete(
+        f"{instance_url}/api/v4/projects/{project_id}/hooks/{hook_id}",
+        headers={"PRIVATE-TOKEN": access_token},
+    )
+    if response.status_code == 404:
+        return
+    response.raise_for_status()

api/integrations/gitlab/client/types.py

@@ -27,6 +27,11 @@ class GitLabMergeRequest(TypedDict):
     draft: bool
 
 
+class GitLabProjectHook(TypedDict):
+    id: int
+    project_id: int
+
+
 class GitLabPage(TypedDict, Generic[T]):
     results: list[T]
     current_page: int

api/integrations/gitlab/constants.py

@@ -0,0 +1,33 @@
+from enum import Enum
+
+GITLAB_TAG_COLOR = "#FC6D26"
+GITLAB_WEBHOOK_TIMEOUT = 10
+
+
+class GitLabTagLabel(Enum):
+    ISSUE_OPEN = "Issue Open"
+    ISSUE_CLOSED = "Issue Closed"
+    MR_OPEN = "MR Open"
+    MR_CLOSED = "MR Closed"
+    MR_MERGED = "MR Merged"
+    MR_DRAFT = "MR Draft"
+
+
+GITLAB_TAG_KIND_BY_LABEL: dict[GitLabTagLabel, str] = {
+    GitLabTagLabel.ISSUE_OPEN: "Issue",
+    GitLabTagLabel.ISSUE_CLOSED: "Issue",
+    GitLabTagLabel.MR_OPEN: "MR",
+    GitLabTagLabel.MR_CLOSED: "MR",
+    GitLabTagLabel.MR_MERGED: "MR",
+    GitLabTagLabel.MR_DRAFT: "MR",
+}
+
+
+GITLAB_TAG_DESCRIPTION_BY_LABEL: dict[GitLabTagLabel, str] = {
+    GitLabTagLabel.ISSUE_OPEN: "Has a linked GitLab issue open",
+    GitLabTagLabel.ISSUE_CLOSED: "Has a linked GitLab issue closed",
+    GitLabTagLabel.MR_OPEN: "Has a linked GitLab merge request open",
+    GitLabTagLabel.MR_CLOSED: "Has a linked GitLab merge request closed",
+    GitLabTagLabel.MR_MERGED: "Has a linked GitLab merge request merged",
+    GitLabTagLabel.MR_DRAFT: "Has a linked GitLab merge request draft",
+}

api/integrations/gitlab/mappers.py

@@ -0,0 +1,75 @@
+from pydantic import TypeAdapter, ValidationError
+
+from features.feature_external_resources.models import (
+    FeatureExternalResource,
+    ResourceType,
+)
+from integrations.gitlab.constants import GitLabTagLabel
+from integrations.gitlab.types import GitLabResourceMetadata, GitLabWebhookPayload
+
+_resource_metadata_adapter: TypeAdapter[GitLabResourceMetadata] = TypeAdapter(
+    GitLabResourceMetadata,
+)
+
+
+def map_issue_state_to_tag_label(state: str | None) -> GitLabTagLabel | None:
+    if state in {"opened", "reopened", "open"}:
+        return GitLabTagLabel.ISSUE_OPEN
+    if state == "closed":
+        return GitLabTagLabel.ISSUE_CLOSED
+    return None
+
+
+def map_merge_request_state_to_tag_label(
+    state: str | None,
+    action: str | None,
+    is_draft: bool,
+) -> GitLabTagLabel | None:
+    if action == "merge" or state == "merged":
+        return GitLabTagLabel.MR_MERGED
+    if state == "closed":
+        return GitLabTagLabel.MR_CLOSED
+    if state in {"opened", "reopened", "open"}:
+        return GitLabTagLabel.MR_DRAFT if is_draft else GitLabTagLabel.MR_OPEN
+    return None
+
+
+def map_gitlab_resource_to_tag_label(
+    resource: FeatureExternalResource,
+) -> GitLabTagLabel | None:
+    """Derive the GitLab tag label for ``resource.feature`` from the JSON
+    metadata snapshot the client supplied at link time.
+    """
+    try:
+        metadata = _resource_metadata_adapter.validate_json(resource.metadata or "")
+    except ValidationError:
+        return None
+    state = metadata.get("state")
+    if resource.type == ResourceType.GITLAB_ISSUE.value:
+        return map_issue_state_to_tag_label(state)
+    if resource.type == ResourceType.GITLAB_MR.value:
+        return map_merge_request_state_to_tag_label(
+            state,
+            action=None,
+            is_draft=bool(metadata.get("draft")),
+        )
+    return None
+
+
+def map_gitlab_webhook_payload_to_tag_label(
+    payload: GitLabWebhookPayload,
+) -> GitLabTagLabel | None:
+    attrs = payload.get("object_attributes")
+    if not attrs:
+        return None
+    state = attrs.get("state")
+    object_kind = payload.get("object_kind")
+    if object_kind == "issue":
+        return map_issue_state_to_tag_label(state)
+    if object_kind == "merge_request":
+        return map_merge_request_state_to_tag_label(
+            state,
+            action=attrs.get("action"),
+            is_draft=bool(attrs.get("draft") or attrs.get("work_in_progress")),
+        )
+    return None