Monitord Acces Change

2026-05-27 16:09:45 +02:00
parent a9284314ef
commit 7c91a8b032
19 changed files with 2496 additions and 332 deletions
@@ -0,0 +1,459 @@
+package workflow_builder
+
+// source_private.go — Phase 4 : sources privées (isReachable = false)
+//
+// Pour les ressources (Processing ou Data) dont la source n'est pas
+// directement accessible (access.IsReachable == false), le protocole est :
+//
+//  1. oc-monitord publie un ARGO_KUBE_EVENT(PROCESSING_RESOURCE) sur NATS
+//     avec les informations de couplage (vérification AE côté peer distant).
+//
+//  2. Le peer propriétaire valide l'AE, génère une URL pré-signée Minio
+//     éphémère et répond via CONSIDERS_EVENT avec presigned_url + resource_id.
+//
+//  3. oc-monitord crée un Secret Kubernetes éphémère contenant l'URL,
+//     labelisé oc-execution-id pour nettoyage post-exécution.
+//
+//  4. La step Argo injecte un wrapper sh qui :
+//     • Processing binary : lit l'URL → /dev/shm/.exec → chmod+x → fork → rm → wait
+//     • Data              : lit l'URL → destPath/filename  (pas de chmod/rm/exec)
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"oc-monitord/conf"
+	. "oc-monitord/models"
+	"oc-monitord/tools"
+
+	oclib "cloud.o-forge.io/core/oc-lib"
+	"cloud.o-forge.io/core/oc-lib/models/resources"
+	"cloud.o-forge.io/core/oc-lib/models/workflow_execution"
+	octools "cloud.o-forge.io/core/oc-lib/tools"
+)
+
+// ── Demande NATS d'URL pré-signée ────────────────────────────────────────────
+
+// waitForPresignedURL publie un ARGO_KUBE_EVENT(PROCESSING_RESOURCE) sur NATS
+// pour demander une URL pré-signée au peer propriétaire de la source privée,
+// puis attend la réponse via globalSourceCache.
+//
+// Résultats envoyés dans urlCh / errCh ; wg.Done() est toujours appelé.
+func waitForPresignedURL(
+	executionsID string,
+	event ArgoKubeEvent,
+	wg *sync.WaitGroup,
+	urlCh chan<- string,
+	errCh chan<- error,
+) {
+	defer wg.Done()
+
+	b, err := json.Marshal(event)
+	if err != nil {
+		logger.Error().Msg("[source-private] cannot marshal ArgoKubeEvent: " + err.Error())
+		urlCh <- ""
+		errCh <- err
+		return
+	}
+	octools.NewNATSCaller().SetNATSPub(octools.ARGO_KUBE_EVENT, octools.NATSResponse{
+		FromApp:  "oc-monitord",
+		Datatype: octools.PROCESSING_RESOURCE,
+		User:     "root",
+		Method:   int(octools.ARGO_KUBE_EVENT),
+		Payload:  b,
+	})
+
+	key := sourceConsidersKey(executionsID, event.SourcePeerID, event.SourceResourceID)
+	ch, unregister := globalSourceCache.register(key)
+	defer unregister()
+
+	select {
+	case url := <-ch:
+		logger.Info().Msg(fmt.Sprintf(
+			"[source-private] presigned URL received resource=%s exec=%s",
+			event.SourceResourceID, executionsID,
+		))
+		urlCh <- url
+		errCh <- nil
+	case <-time.After(5 * time.Minute):
+		ferr := fmt.Errorf(
+			"timeout waiting for presigned URL resource=%s exec=%s",
+			event.SourceResourceID, executionsID,
+		)
+		logger.Error().Msg(ferr.Error())
+		urlCh <- ""
+		errCh <- ferr
+	}
+}
+
+// ── Nommage du Secret ─────────────────────────────────────────────────────────
+
+// secretNameFor génère un nom de Secret K8s valide (63 chars max, alphanum+-)
+// à partir d'un nom de step et d'un execution ID.
+func secretNameFor(stepBaseName, executionID string) string {
+	base := strings.ToLower(strings.ReplaceAll(stepBaseName, "_", "-"))
+	if len(base) > 30 {
+		base = base[:30]
+	}
+	suffix := executionID
+	if len(suffix) > 8 {
+		suffix = suffix[:8]
+	}
+	name := "oc-src-" + base + "-" + suffix
+
+	// Éliminer les caractères non autorisés par K8s (alphanum + '-').
+	var clean strings.Builder
+	for _, c := range name {
+		if (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' {
+			clean.WriteRune(c)
+		}
+	}
+	s := strings.Trim(clean.String(), "-")
+	if len(s) > 63 {
+		s = s[:63]
+	}
+	return s
+}
+
+// ── Injection step Processing (source privée) ─────────────────────────────────
+
+// injectPrivateProcessingStep ajoute dans le DAG et dans les templates Argo une
+// step wrapper pour un Processing à source privée.
+//
+// Le script sh :
+//  1. Lit l'URL pré-signée depuis le Secret monté à /var/oc-secrets/presigned-url
+//  2. Télécharge le binaire dans /dev/shm/.exec (RAM — jamais sur disque)
+//  3. Le rend exécutable, le lance en background, supprime le fichier, attend la fin
+//
+// Le Secret est déclaré dans spec.volumes (ExistingVolume) et monté en lecture
+// seule dans le container.
+//
+// Retourne le nom Argo de la step créée.
+func (b *ArgoBuilder) injectPrivateProcessingStep(
+	stepBaseName string,
+	secretName string,
+	dependsOn []string,
+) string {
+	stepName := stepBaseName + "-prv-fetch"
+	volName := strings.ReplaceAll(secretName, ".", "-")
+
+	script := `PRESIGNED=$(cat /var/oc-secrets/presigned-url)
+curl -fsSL "$PRESIGNED" -o /dev/shm/.exec
+chmod +x /dev/shm/.exec
+/dev/shm/.exec &
+PID=$!
+rm -f /dev/shm/.exec
+wait $PID`
+
+	// Volume Secret dans le spec du workflow (partagé entre toutes les steps).
+	b.addSecretVolumeIfAbsent(volName, secretName)
+
+	fetchTask := Task{
+		Name:         stepName,
+		Template:     stepName,
+		Dependencies: dependsOn,
+	}
+	b.Workflow.getDag().Tasks = append(b.Workflow.getDag().Tasks, fetchTask)
+
+	fetchTemplate := Template{
+		Name: stepName,
+		Container: Container{
+			Image:           curlImage,
+			ImagePullPolicy: "IfNotPresent",
+			Command:         []string{"sh", "-c"},
+			Args:            []string{script},
+			VolumeMounts: []VolumeMount{
+				{Name: volName, MountPath: "/var/oc-secrets", ReadOnly: true},
+			},
+		},
+	}
+	b.Workflow.Spec.Templates = append(b.Workflow.Spec.Templates, fetchTemplate)
+
+	logger.Info().Msg(fmt.Sprintf(
+		"[source-private] injected private processing step '%s' (secret=%s)",
+		stepName, secretName,
+	))
+	return stepName
+}
+
+// ── Injection step Data (source privée) ──────────────────────────────────────
+
+// injectPrivateDataStep ajoute dans le DAG une step de téléchargement sécurisé
+// pour une Data à source privée vers le storage lié (pas de /dev/shm, pas de rm).
+func (b *ArgoBuilder) injectPrivateDataStep(
+	stepBaseName string,
+	secretName string,
+	destPath string,
+	filename string,
+	dependsOn []string,
+) string {
+	stepName := stepBaseName + "-prv-fetch"
+	volName := strings.ReplaceAll(secretName, ".", "-")
+	fullDest := destPath + "/" + filename
+
+	script := fmt.Sprintf(
+		"PRESIGNED=$(cat /var/oc-secrets/presigned-url)\ncurl -fsSL \"$PRESIGNED\" -o '%s'",
+		fullDest,
+	)
+
+	b.addSecretVolumeIfAbsent(volName, secretName)
+
+	fetchTask := Task{
+		Name:         stepName,
+		Template:     stepName,
+		Dependencies: dependsOn,
+	}
+	b.Workflow.getDag().Tasks = append(b.Workflow.getDag().Tasks, fetchTask)
+
+	fetchTemplate := Template{
+		Name: stepName,
+		Container: Container{
+			Image:           curlImage,
+			ImagePullPolicy: "IfNotPresent",
+			Command:         []string{"sh", "-c"},
+			Args:            []string{script},
+			VolumeMounts: []VolumeMount{
+				{Name: volName, MountPath: "/var/oc-secrets", ReadOnly: true},
+			},
+		},
+	}
+	b.Workflow.Spec.Templates = append(b.Workflow.Spec.Templates, fetchTemplate)
+
+	logger.Info().Msg(fmt.Sprintf(
+		"[source-private] injected private data step '%s' → %s (secret=%s)",
+		stepName, fullDest, secretName,
+	))
+	return stepName
+}
+
+// addSecretVolumeIfAbsent déclare un volume de type Secret dans spec.volumes
+// uniquement s'il n'est pas déjà présent (déduplication par nom).
+func (b *ArgoBuilder) addSecretVolumeIfAbsent(volName, secretName string) {
+	for _, v := range b.Workflow.Spec.ExistingVolumes {
+		if v.Name == volName {
+			return
+		}
+	}
+	b.Workflow.Spec.ExistingVolumes = append(b.Workflow.Spec.ExistingVolumes, ExistingVolume{
+		Name:   volName,
+		Secret: &SecretRef{SecretName: secretName},
+	})
+}
+
+// ── handlePrivateProcessingSource ────────────────────────────────────────────
+
+// handlePrivateProcessingSource gère le cas où un ProcessingInstance a une source
+// privée (access.HasSource() && !access.IsReachable).
+//
+// Orchestration :
+//  1. Demande de l'URL pré-signée via NATS (waitForPresignedURL)
+//  2. Création du Secret K8s éphémère
+//  3. Injection de la step wrapper dans le DAG
+//  4. Recâblage des dépendances (processing dépend du step wrapper)
+func (b *ArgoBuilder) handlePrivateProcessingSource(
+	exec *workflow_execution.WorkflowExecution,
+	graphID string,
+	procResource *resources.ProcessingResource,
+	procInst *resources.ProcessingInstance,
+	argoStepName string,
+	namespace string,
+) error {
+	access := procInst.Access
+	if !access.HasSource() || access.Source.IsReachable {
+		return nil
+	}
+
+	self, err := oclib.GetMySelf()
+	if err != nil {
+		return fmt.Errorf("[source-private] cannot get local peer ID: %w", err)
+	}
+
+	// Demande de l'URL pré-signée au peer propriétaire.
+	var wg sync.WaitGroup
+	urlCh := make(chan string, 1)
+	errCh := make(chan error, 1)
+	wg.Add(1)
+	go waitForPresignedURL(exec.ExecutionsID, ArgoKubeEvent{
+		ExecutionsID:     exec.ExecutionsID,
+		Type:             octools.PROCESSING_RESOURCE,
+		SourcePeerID:     procResource.GetCreatorID(),
+		DestPeerID:       self.GetID(),
+		OriginID:         conf.GetConfig().PeerID,
+		SourceResourceID: procResource.GetID(),
+	}, &wg, urlCh, errCh)
+	wg.Wait()
+	close(urlCh)
+	close(errCh)
+
+	presignedURL := <-urlCh
+	if ferr := <-errCh; ferr != nil || presignedURL == "" {
+		if ferr == nil {
+			ferr = fmt.Errorf("empty presigned URL for processing '%s'", procResource.GetName())
+		}
+		return ferr
+	}
+
+	// Création du Secret K8s contenant l'URL.
+	secretName := secretNameFor(argoStepName, exec.ExecutionsID)
+	kube, kerr := tools.NewKubernetesTool()
+	if kerr != nil {
+		return fmt.Errorf("[source-private] cannot create K8s client: %w", kerr)
+	}
+	if kerr = kube.CreateSourceSecret(secretName, presignedURL, exec.ExecutionsID, namespace); kerr != nil {
+		return fmt.Errorf("[source-private] CreateSourceSecret: %w", kerr)
+	}
+
+	// Dépendances actuelles de la step processing (seront portées par le step wrapper).
+	existingDeps := b.getArgoDependencies(exec, graphID)
+
+	// Injection de la step wrapper.
+	fetchStepName := b.injectPrivateProcessingStep(argoStepName, secretName, existingDeps)
+
+	// Recâblage : la step processing ne dépend plus que du step wrapper.
+	dag := b.Workflow.getDag()
+	for i, task := range dag.Tasks {
+		if task.Name == argoStepName {
+			dag.Tasks[i].Dependencies = []string{fetchStepName}
+			break
+		}
+	}
+
+	logger.Info().Msg(fmt.Sprintf(
+		"[source-private] processing '%s' wired: %v → %s → %s",
+		procResource.GetName(), existingDeps, fetchStepName, argoStepName,
+	))
+	return nil
+}
+
+// ── HandlePrivateDataSources ─────────────────────────────────────────────────
+
+// HandlePrivateDataSources parcourt tous les items Data dont une instance a
+// une source privée (access.HasSource() && !access.IsReachable) et injecte
+// pour chacun une step de téléchargement sécurisé dans le storage lié.
+//
+// Appelé depuis HandleDataSources() en fin de createTemplates().
+func (b *ArgoBuilder) HandlePrivateDataSources(
+	exec *workflow_execution.WorkflowExecution,
+	namespace string,
+) {
+	self, err := oclib.GetMySelf()
+	if err != nil {
+		logger.Error().Msg("[source-private] cannot get local peer ID: " + err.Error())
+		return
+	}
+
+	for itemID, item := range b.OriginWorkflow.Graph.Items {
+		if !b.OriginWorkflow.Graph.IsData(item) || item.ItemResource.Data == nil {
+			continue
+		}
+
+		var sourceURL string
+		var resourceID string
+		var creatorID string
+
+		for _, inst := range item.ItemResource.Data.Instances {
+			if inst == nil || !inst.Access.HasSource() || inst.Access.Source.IsReachable {
+				continue
+			}
+			sourceURL = inst.Access.Source.Source
+			resourceID = item.ItemResource.Data.GetID()
+			creatorID = item.ItemResource.Data.GetCreatorID()
+			break
+		}
+		if sourceURL == "" {
+			continue
+		}
+
+		// Storage lié à cette Data.
+		linkedStorageIDs := b.OriginWorkflow.Graph.GetLinkedStorageForData(itemID)
+		if len(linkedStorageIDs) == 0 {
+			logger.Error().Msg(fmt.Sprintf(
+				"[source-private] data '%s' has private source but no storage linked — skipping",
+				item.ItemResource.Data.GetName(),
+			))
+			continue
+		}
+		storageItem, ok := b.OriginWorkflow.Graph.Items[linkedStorageIDs[0]]
+		if !ok || storageItem.ItemResource.Storage == nil || len(storageItem.ItemResource.Storage.Instances) == 0 {
+			continue
+		}
+		mountPath := storageItem.ItemResource.Storage.Instances[0].Source
+		if mountPath == "" {
+			logger.Error().Msg(fmt.Sprintf(
+				"[source-private] storage linked to data '%s' has no mount path — skipping",
+				item.ItemResource.Data.GetName(),
+			))
+			continue
+		}
+
+		// Demande de l'URL pré-signée.
+		var wg sync.WaitGroup
+		urlCh := make(chan string, 1)
+		errCh := make(chan error, 1)
+		wg.Add(1)
+		go waitForPresignedURL(exec.ExecutionsID, ArgoKubeEvent{
+			ExecutionsID:     exec.ExecutionsID,
+			Type:             octools.PROCESSING_RESOURCE,
+			SourcePeerID:     creatorID,
+			DestPeerID:       self.GetID(),
+			OriginID:         conf.GetConfig().PeerID,
+			SourceResourceID: resourceID,
+		}, &wg, urlCh, errCh)
+		wg.Wait()
+		close(urlCh)
+		close(errCh)
+
+		presignedURL := <-urlCh
+		if ferr := <-errCh; ferr != nil || presignedURL == "" {
+			logger.Error().Msg(fmt.Sprintf(
+				"[source-private] data '%s': failed to get presigned URL: %v",
+				item.ItemResource.Data.GetName(), ferr,
+			))
+			continue
+		}
+
+		// Création du Secret K8s.
+		fetchBaseName := strings.ToLower(strings.ReplaceAll(item.ItemResource.Data.GetName(), " ", "-"))
+		secretName := secretNameFor(fetchBaseName, exec.ExecutionsID)
+		kube, kerr := tools.NewKubernetesTool()
+		if kerr != nil {
+			logger.Error().Msg("[source-private] cannot create K8s client: " + kerr.Error())
+			continue
+		}
+		if kerr = kube.CreateSourceSecret(secretName, presignedURL, exec.ExecutionsID, namespace); kerr != nil {
+			logger.Error().Msg("[source-private] cannot create source secret: " + kerr.Error())
+			continue
+		}
+
+		// Injection pour chaque processing aval lisant ce storage.
+		downstreamProcIDs := b.processingsThatReadStorage(linkedStorageIDs[0])
+		filename := sourceFilename(sourceURL)
+
+		for _, procItemID := range downstreamProcIDs {
+			procItem := b.OriginWorkflow.Graph.Items[procItemID]
+			if procItem.ItemResource.Processing == nil {
+				continue
+			}
+
+			existingDeps := b.getArgoDependencies(exec, procItemID)
+			fetchStepName := b.injectPrivateDataStep(
+				fetchBaseName, secretName, mountPath, filename, existingDeps,
+			)
+
+			// Recâblage des steps processing aval.
+			dag := b.Workflow.getDag()
+			for _, pb := range getAllPeersForItem(exec, procItemID) {
+				procArgoName := getArgoName(procItem.ItemResource.Processing.GetName(), pb.BookingID)
+				for i, task := range dag.Tasks {
+					if task.Name == procArgoName {
+						dag.Tasks[i].Dependencies = []string{fetchStepName}
+						break
+					}
+				}
+			}
+		}
+	}
+}