monitor/views.py aktualisiert

monitor/views.py

@@ -1,84 +1,98 @@
-import requests
+import json
 from django.http import JsonResponse
 from django.views.generic import TemplateView, View
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+
+# Globaler In-Memory Speicher für die gepushten Cluster-States (simuliert eine DB)
+# Struktur: { "repo_name": { ... d3_tree_data ... } }
+CLUSTER_STATES = {}
 
 class DashboardView(TemplateView):
     template_name = "monitor/dashboard.html"
 
-class ClusterGraphDataView(View):
+@method_decorator(csrf_exempt, name='dispatch')
-    def get(self, request, *args, **kwargs):
+class StatePushReceiverView(View):
-        # Holt den State direkt aus deinem Forgejo-HTTP-Backend
+    """
-        forgejo_url = "http://forgejo:3000/api/v1/repos/bast/boday_tf/terraform/state/sandbox"
+    Der offizielle Enterprise-Endpunkt: Nimmt das anonymisierte 'terraform show -json'
-        headers = {"Authorization": "token z6xlwg3dSRYZ59zUxfrztDJasG6VkvulFyTwtJQS"}
+    aus JEDER Pipeline der Welt per POST entgegen.
+    """
+    def post(self, request, *args, **kwargs):
+        # Einfacher API-Token Check (Best Practice für dein Produkt)
+        token = request.headers.get("Authorization")
+        if token != "Bearer boday-cloudmon-super-token-2026":
+            return JsonResponse({"error": "Unauthorized"}, status=401)
 
         try:
-            response = requests.get(forgejo_url, headers=headers, timeout=5)
+            # Das rohe Terraform-JSON einlesen
-            if response.status_code != 200:
+            tf_data = json.loads(request.body.decode('utf-8'))
-                return JsonResponse({"error": "Terraform State konnte nicht geladen werden"}, status=response.status_code)
             
-            state_json = response.json()
+            # Wir holen uns den Repo-Namen aus den Query-Parametern (?repo=boday_tf)
-            resources = state_json.get("resources", [])
+            repo_name = request.GET.get("repo", "default_cluster")
+
+            # Parser für das standardisierte Terraform-JSON (Format von: terraform show -json)
+            # In der JSON-Ausgabe liegen alle angelegten Ressourcen flach im 'values' Block
+            values = tf_data.get("values", {}).get("root_module", {}).get("resources", [])
             
             ingresses = []
             services = {}
             deployments = {}
 
-            # Flache Terraform-Struktur filtern
+            for res in values:
-            for res in resources:
                 res_type = res.get("type")
                 res_name = res.get("name")
-                instances = res.get("instances", [])
+                values_inner = res.get("values", {})
-                if not instances: continue
-                # act/gitea liefert instanzen als Liste
-                if isinstance(instances, list) and len(instances) > 0:
-                    attributes = instances[0].get("attributes", {})
-                else:
-                    attributes = instances.get("attributes", {})
 
                 if res_type == "kubernetes_ingress_v1":
                     ingresses.append({
-                        "name": attributes.get("metadata", [{}])[0].get("name", res_name) if isinstance(attributes.get("metadata"), list) else attributes.get("metadata", {}).get("name", res_name),
+                        "name": values_inner.get("metadata", [{}])[0].get("name", res_name) if isinstance(values_inner.get("metadata"), list) else values_inner.get("metadata", {}).get("name", res_name),
-                        "rules": attributes.get("spec", [{}])[0].get("rule", []) if isinstance(attributes.get("spec"), list) else attributes.get("spec", {}).get("rule", [])
+                        "rules": values_inner.get("spec", [{}])[0].get("rule", []) if isinstance(values_inner.get("spec"), list) else values_inner.get("spec", {}).get("rule", [])
                     })
-                elif res_type == "kubernetes_service" or res_type == "kubernetes_service_v1":
+                elif res_type in ["kubernetes_service", "kubernetes_service_v1"]:
-                    svc_actual_name = attributes.get("metadata", [{}])[0].get("name", res_name) if isinstance(attributes.get("metadata"), list) else attributes.get("metadata", {}).get("name", res_name)
+                    svc_name = values_inner.get("metadata", [{}])[0].get("name", res_name) if isinstance(values_inner.get("metadata"), list) else values_inner.get("metadata", {}).get("name", res_name)
-                    services[svc_actual_name] = {"name": svc_actual_name, "type": "Service"}
+                    services[svc_name] = {"name": svc_name, "type": "Service"}
-                elif res_type == "kubernetes_deployment" or res_type == "kubernetes_deployment_v1":
+                elif res_type in ["kubernetes_deployment", "kubernetes_deployment_v1"]:
-                    dep_actual_name = attributes.get("metadata", [{}])[0].get("name", res_name) if isinstance(attributes.get("metadata"), list) else attributes.get("metadata", {}).get("name", res_name)
+                    dep_name = values_inner.get("metadata", [{}])[0].get("name", res_name) if isinstance(values_inner.get("metadata"), list) else values_inner.get("metadata", {}).get("name", res_name)
-                    deployments[dep_actual_name] = {"name": dep_actual_name, "type": "Deployment"}
+                    deployments[dep_name] = {"name": dep_name, "type": "Deployment"}
 
-            # D3.js Baumhierarchie aufbauen
+            # D3.js Baumstruktur aufbauen
             root_node = {
-                "name": "Forgejo Control Plane",
+                "name": f"Cluster: {repo_name}",
                 "type": "Root",
                 "children": []
             }
 
             for ing in ingresses:
                 ing_node = {"name": ing["name"], "type": "Ingress", "children": []}
-                
                 for rule in ing["rules"]:
-                    http_paths = rule.get("http", [{}])[0].get("path", []) if isinstance(rule.get("http"), list) else rule.get("http", {}).get("path", [])
+                    paths = rule.get("http", [{}])[0].get("path", []) if isinstance(rule.get("http"), list) else rule.get("http", {}).get("path", [])
-                    for path in http_paths:
+                    for path in paths:
                         backend_svc = path.get("backend", [{}])[0].get("service", [{}])[0].get("name") if isinstance(path.get("backend"), list) else path.get("backend", {}).get("service", {}).get("name")
                         
                         if backend_svc in services:
                             svc_node = {"name": backend_svc, "type": "Service", "children": []}
-                            
                             for dep_name in deployments.keys():
                                 if dep_name in backend_svc or backend_svc in dep_name:
-                                    svc_node["children"].append({
+                                    svc_node["children"].append({"name": dep_name, "type": "Deployment", "children": []})
-                                        "name": dep_name,
-                                        "type": "Deployment",
-                                        "children": []
-                                    })
-                            
                             ing_node["children"].append(svc_node)
-                
                 root_node["children"].append(ing_node)
 
-            return JsonResponse(root_node)
+            # Im globalen RAM-Speicher sichern
+            CLUSTER_STATES[repo_name] = root_node
+            return JsonResponse({"status": "success", "message": f"State für {repo_name} aktualisiert!"})
 
         except Exception as e:
-            return JsonResponse({"error": str(e)}, status=500)
+            return JsonResponse({"error": str(e)}, status=400)
 
+
+class ClusterGraphDataView(View):
+    """ Liefert die Daten an das D3.js Frontend aus """
+    def get(self, request, *args, **kwargs):
+        repo_name = request.GET.get("repo", "boday_tf")
+        # Holt die Daten aus dem Speicher, Fallback auf leeren Root-Knoten
+        data = CLUSTER_STATES.get(repo_name, {
+            "name": f"Warte auf ersten Push für '{repo_name}'...",
+            "type": "Root",
+            "children": []
+        })
+        return JsonResponse(data)