chore: update

control-plane/api/internal/demos/project_provisioner.go

@@ -0,0 +1,282 @@
+package demos
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// Projets vitrine (voir internal/projects) : même infrastructure que les
+// démos (namespace isolé, NetworkPolicy, ResourceQuota, Traefik + WAF
+// partagés, sauvegardes Velero par namespace) mais avec les charts du
+// produit vitrine (h.vitrineChartsDir) et une durée d'abonnement en mois.
+// Le cycle de vie (durée, suspension, suppression) vit dans internal/projects ;
+// ce fichier ne contient que ce qui touche au cluster.
+
+// Noms de release/chart utilisés par les charts vitrine (dossier
+// deploy/chart-vitrine). Le nom de Service produit par le chart est
+// "<release>-<nom du chart>" avec release = "<namespace>-<chart>" (voir
+// installChartFrom) : ces deux fonctions doivent rester synchronisées avec les
+// defaults de deploy/chart-vitrine/ingressroute/templates/_helpers.tpl.
+func vitrineBackendService(namespace string) string {
+	return namespace + "-backend-vitrine-backend"
+}
+
+func vitrineFrontendService(namespace string) string {
+	return namespace + "-frontend-vitrine-frontend"
+}
+
+// replicasBeforeSuspendAnnotation : nombre de réplicas d'une charge de travail
+// avant sa suspension, pour la relancer à l'identique (voir SuspendProject).
+const replicasBeforeSuspendAnnotation = "omnex.app/replicas-before-suspend"
+
+// ProjectSpec : ce dont le provisioner a besoin pour déployer un projet
+// vitrine. AdminPassword ne doit jamais être persisté : il ne transite que
+// par le fichier de valeurs Helm temporaire puis le Secret k8s du chart.
+type ProjectSpec struct {
+	Namespace     string
+	Host          string // nom d'hôte public, sans protocole (ex. vitrine-ab12cd34.vitrine-omnex.club)
+	URL           string // URL publique complète (https://<Host>)
+	AdminUsername string
+	AdminPassword string
+	// AdminNumber : nombre maximum de comptes admin du backend (ADMIN_NUMBER),
+	// choisi par l'admin Omnex au déploiement.
+	AdminNumber int
+}
+
+// ProvisionProject déploie un projet vitrine :
+//  1. namespace + Schedule Velero (identique aux démos : voir
+//     ensureDemoBackupSchedule),
+//  2. isolation réseau, quota, identifiants du registry (charts des démos),
+//  3. postgresql, redis, backend (migrations + compte admin via hooks Helm),
+//     frontend puis ingressroute (charts vitrine).
+//
+// En cas d'échec, le namespace et le Schedule sont supprimés.
+func (h *HelmProvisioner) ProvisionProject(p ProjectSpec) error {
+	ns := p.Namespace
+	// Sans image, les valeurs Helm écraseraient les défauts des charts par
+	// une chaîne vide : échec explicite avant de créer quoi que ce soit.
+	if h.cfg.VitrineBackendImage == "" || h.cfg.VitrineFrontendImage == "" {
+		return fmt.Errorf("VITRINE_BACKEND_IMAGE et VITRINE_FRONTEND_IMAGE doivent être définies")
+	}
+	if err := h.createNamespace(ns); err != nil {
+		return fmt.Errorf("création namespace %s: %w", ns, err)
+	}
+
+	// Non-fatal : un projet doit pouvoir démarrer même si Velero est
+	// momentanément indisponible (même règle que pour les démos).
+	if err := h.ensureDemoBackupSchedule(ns); err != nil {
+		log.Printf("Warning: planning de sauvegarde échoué pour %s: %v", ns, err)
+	}
+
+	fail := func(step string, err error) error {
+		if derr := h.deleteDemoBackups(ns); derr != nil {
+			log.Printf("Warning: nettoyage des sauvegardes de %s après échec: %v", ns, derr)
+		}
+		_ = h.deleteNamespace(ns)
+		return fmt.Errorf("déploiement %s: %w", step, err)
+	}
+
+	// Isolation réseau AVANT tout workload, plafond de ressources, puis
+	// identifiants du registry avant tout pull d'image : mêmes charts que les
+	// démos (h.chartsDir).
+	if err := h.installChart(ns, "network-policy", h.buildNetworkPolicyValues()); err != nil {
+		return fail("network-policy", err)
+	}
+	if err := h.installChart(ns, "resource-quota", nil); err != nil {
+		return fail("resource-quota", err)
+	}
+	if err := h.installChart(ns, "registry-credentials", h.buildRegistryCredentialsValues()); err != nil {
+		return fail("registry-credentials", err)
+	}
+
+	// Secrets générés par projet, jamais partagés ni codés en dur.
+	pgPassword := randomSecret()
+	redisPassword := randomSecret()
+	jwtSecret := randomSecret()
+
+	steps := []struct {
+		chart  string
+		values map[string]interface{}
+	}{
+		{"postgresql", h.buildVitrinePostgresValues(pgPassword)},
+		{"redis", h.buildVitrineRedisValues(redisPassword)},
+		{"backend", h.buildVitrineBackendValues(p, pgPassword, redisPassword, jwtSecret)},
+		{"frontend", h.buildVitrineFrontendValues()},
+		{"ingressroute", h.buildVitrineIngressRouteValues(p)},
+	}
+	for _, s := range steps {
+		if err := h.installChartFrom(h.vitrineChartsDir, ns, s.chart, s.values); err != nil {
+			return fail(s.chart, err)
+		}
+	}
+
+	if err := h.waitForRollout(ns); err != nil {
+		// Le déploiement Helm a réussi (--wait --atomic) : on ne détruit pas
+		// pour un simple dépassement de délai de cette vérification.
+		log.Printf("Warning: rollout check échoué pour %s: %v", ns, err)
+	}
+	return nil
+}
+
+// TeardownProject supprime le namespace du projet (PVC compris) et ses
+// sauvegardes Velero — même chemin que Teardown pour une démo.
+func (h *HelmProvisioner) TeardownProject(namespace string) error {
+	return h.Teardown(Demo{Namespace: namespace})
+}
+
+// SuspendProject met à 0 les Deployment et StatefulSet du namespace : le
+// projet n'est plus servi (Traefik répond 503) mais ses PVC, ses Secrets et
+// son IngressRoute restent en place. Le nombre de réplicas d'origine est
+// noté en annotation pour ResumeProject. Idempotent.
+func (h *HelmProvisioner) SuspendProject(namespace string) error {
+	return h.scaleProject(namespace, false)
+}
+
+// ResumeProject relance ce que SuspendProject a arrêté, au nombre de
+// réplicas d'origine (1 à défaut d'annotation). Idempotent.
+func (h *HelmProvisioner) ResumeProject(namespace string) error {
+	return h.scaleProject(namespace, true)
+}
+
+func (h *HelmProvisioner) scaleProject(namespace string, up bool) error {
+	ctx := context.Background()
+
+	deploys, err := h.k8sClient.AppsV1().Deployments(namespace).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		return fmt.Errorf("liste des deployments de %s: %w", namespace, err)
+	}
+	for i := range deploys.Items {
+		d := &deploys.Items[i]
+		if d.Spec.Replicas == nil {
+			one := int32(1)
+			d.Spec.Replicas = &one
+		}
+		target, changed := nextReplicas(d.Spec.Replicas, &d.Annotations, up)
+		if !changed {
+			continue
+		}
+		d.Spec.Replicas = &target
+		if _, err := h.k8sClient.AppsV1().Deployments(namespace).Update(ctx, d, metav1.UpdateOptions{}); err != nil {
+			return fmt.Errorf("mise à l'échelle du deployment %s: %w", d.Name, err)
+		}
+	}
+
+	sets, err := h.k8sClient.AppsV1().StatefulSets(namespace).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		return fmt.Errorf("liste des statefulsets de %s: %w", namespace, err)
+	}
+	for i := range sets.Items {
+		s := &sets.Items[i]
+		if s.Spec.Replicas == nil {
+			one := int32(1)
+			s.Spec.Replicas = &one
+		}
+		target, changed := nextReplicas(s.Spec.Replicas, &s.Annotations, up)
+		if !changed {
+			continue
+		}
+		s.Spec.Replicas = &target
+		if _, err := h.k8sClient.AppsV1().StatefulSets(namespace).Update(ctx, s, metav1.UpdateOptions{}); err != nil {
+			return fmt.Errorf("mise à l'échelle du statefulset %s: %w", s.Name, err)
+		}
+	}
+	return nil
+}
+
+// nextReplicas calcule le nombre de réplicas cible d'une charge de travail et
+// met à jour ses annotations. changed=false : rien à faire (déjà dans l'état
+// demandé).
+func nextReplicas(current *int32, annotations *map[string]string, up bool) (target int32, changed bool) {
+	if !up {
+		if *current == 0 {
+			return 0, false
+		}
+		if *annotations == nil {
+			*annotations = map[string]string{}
+		}
+		(*annotations)[replicasBeforeSuspendAnnotation] = strconv.Itoa(int(*current))
+		return 0, true
+	}
+	if *current != 0 {
+		return *current, false
+	}
+	target = 1
+	if v, ok := (*annotations)[replicasBeforeSuspendAnnotation]; ok {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 {
+			target = int32(n)
+		}
+		delete(*annotations, replicasBeforeSuspendAnnotation)
+	}
+	return target, true
+}
+
+func (h *HelmProvisioner) buildVitrinePostgresValues(password string) map[string]interface{} {
+	// Nom de base et utilisateur : défauts du chart (vitrine_db / postgres),
+	// alignés sur database.name / database.user du chart backend.
+	return map[string]interface{}{
+		"imagePullSecrets": h.imagePullSecretsValue(),
+		"auth":             map[string]interface{}{"password": password},
+	}
+}
+
+func (h *HelmProvisioner) buildVitrineRedisValues(password string) map[string]interface{} {
+	return map[string]interface{}{
+		"imagePullSecrets": h.imagePullSecretsValue(),
+		"auth":             map[string]interface{}{"password": password},
+	}
+}
+
+func (h *HelmProvisioner) buildVitrineBackendValues(p ProjectSpec, pgPassword, redisPassword, jwtSecret string) map[string]interface{} {
+	repo, tag := parseImage(h.cfg.VitrineBackendImage)
+	return map[string]interface{}{
+		"replicaCount":     1, // volumes ReadWriteOnce : un seul replica (voir le chart)
+		"imagePullSecrets": h.imagePullSecretsValue(),
+		"image": map[string]interface{}{
+			"repository": repo,
+			"tag":        tag,
+			"pullPolicy": "Always",
+		},
+		"autoscaling": map[string]interface{}{"enabled": false},
+		"env": map[string]interface{}{
+			"ADMIN_NUMBER":         strconv.Itoa(p.AdminNumber),
+			"SEED_ADMIN_USERNAME":  p.AdminUsername,
+			"MEDIA_LOCAL_BASE_URL": p.URL + "/uploads",
+		},
+		"secrets": map[string]interface{}{
+			"JWT_SECRET":          jwtSecret,
+			"DB_PASSWORD":         pgPassword,
+			"REDIS_PASSWORD":      redisPassword,
+			"SEED_ADMIN_PASSWORD": p.AdminPassword,
+		},
+		// Compte admin créé par le hook post-install du chart (jamais rejoué
+		// à l'upgrade : cmd/seed n'est pas idempotent).
+		"seedJob": map[string]interface{}{"enabled": true},
+	}
+}
+
+func (h *HelmProvisioner) buildVitrineFrontendValues() map[string]interface{} {
+	repo, tag := parseImage(h.cfg.VitrineFrontendImage)
+	return map[string]interface{}{
+		"replicaCount":     1,
+		"imagePullSecrets": h.imagePullSecretsValue(),
+		"image": map[string]interface{}{
+			"repository": repo,
+			"tag":        tag,
+			"pullPolicy": "Always",
+		},
+		"autoscaling": map[string]interface{}{"enabled": false},
+	}
+}
+
+func (h *HelmProvisioner) buildVitrineIngressRouteValues(p ProjectSpec) map[string]interface{} {
+	return map[string]interface{}{
+		"host":             p.Host,
+		"traefikNamespace": sharedTraefikNamespace,
+		"backend":          map[string]interface{}{"serviceName": vitrineBackendService(p.Namespace)},
+		"frontend":         map[string]interface{}{"serviceName": vitrineFrontendService(p.Namespace)},
+	}
+}