# argo_builder.go — Résumé

## Rôle général

`argo_builder.go` traduit un **Workflow Open Cloud** (graphe de nœuds : processings,
stockages, computes, sous-workflows) en un **fichier YAML Argo Workflow** prêt à
être soumis à un cluster Kubernetes.

---

## Structures principales

| Struct | Rôle |
|---|---|
| `ArgoBuilder` | Constructeur principal. Porte le workflow source, la structure YAML en cours de build, les services k8s, le timeout et la liste des peers distants (Admiralty). |
| `Workflow` | Racine du YAML Argo (`apiVersion`, `kind`, `metadata`, `spec`). |
| `Spec` | Spécification du workflow : compte de service, entrypoint, templates, volumes, timeout, référence au dépôt d'artefacts S3. |
| `ArgoKubeEvent` | Événement publié sur NATS lors de la demande de provisionnement d'une ressource distante (compute ou stockage S3). Contient `executions_id`, `dest_peer_id`, `source_peer_id`, `data_type`, `origin_id`. |

---

## Flux d'exécution principal

```
CreateDAG()
  └─ createTemplates()
       ├─ [pour chaque processing]   createArgoTemplates()
       │     ├─ addTaskToArgo()           → ajoute la tâche au DAG + dépendances
       │     ├─ CreateContainer()         → template container Argo
       │     ├─ AddAdmiraltyAnnotations() → si peer distant détecté
       │     └─ addStorageAnnotations()   → S3 + volumes locaux
       ├─ [pour chaque native tool WORKFLOW_EVENT]  createArgoTemplates()
       └─ [pour chaque sous-workflow]
             ├─ CreateDAG() récursif
             └─ fusion DAG + recâblage des dépendances
  └─ createVolumes()   → PersistentVolumeClaims

CompleteBuild()
  ├─ waitForConsiders() × N peers   → validation Admiralty (COMPUTE_RESOURCE)
  ├─ mise à jour annotations Admiralty (clustername)
  └─ écriture du YAML dans ./argo_workflows/
```

---

## Fonctions clés

### `CreateDAG(exec, namespace, write) → (nbTâches, firstItems, lastItems, err)`
Point d'entrée. Initialise le logger, déclenche la création des templates et des
volumes, configure les métadonnées globales du workflow Argo.

### `createTemplates(exec, namespace) → (firstItems, lastItems, volumes)`
Itère sur tous les nœuds du graphe.
- Processings → template container.
- Native tools `WORKFLOW_EVENT` → template événement.
- Sous-workflows → build récursif + fusion DAG + recâblage des dépendances entrantes/sortantes.

### `createArgoTemplates(exec, namespace, id, obj, …)`
Crée le template Argo pour un nœud donné.
Détecte si le processing est **réparti** (peer distant via `isReparted`) → ajoute les
annotations Admiralty et enregistre le peer dans `RemotePeers`.
Délègue la configuration du stockage à `addStorageAnnotations`.

### `addStorageAnnotations(exec, id, template, namespace, volumes)`
Pour chaque stockage lié au processing :
- **S3** : appelle `waitForConsiders(STORAGE_RESOURCE)` pour chaque compute associé,
  puis configure la référence au dépôt d'artefacts via `addS3annotations`.
- **Local** : monte un `VolumeMount` dans le container.

### `waitForConsiders(executionsId, dataType, event)`
**Fonction bloquante.**
1. Publie l'`ArgoKubeEvent` sur le canal NATS `ARGO_KUBE_EVENT`.
2. S'abonne à `PROPALGATION_EVENT`.
3. Attend un `PropalgationMessage` vérifiant :
   - `Action == PB_CONSIDERS`
   - `DataType == dataType`
   - `Payload.executions_id == executionsId`
4. Timeout : **5 minutes**.

| Appelant | DataType attendu | Signification |
|---|---|---|
| `addStorageAnnotations` (S3) | `STORAGE_RESOURCE` | Le stockage S3 distant est prêt |
| `CompleteBuild` (Admiralty) | `COMPUTE_RESOURCE` | Le cluster cible Admiralty est configuré |

### `CompleteBuild(executionsId) → (cheminYAML, err)`
Finalise le build :
1. Pour chaque peer dans `RemotePeers` → `waitForConsiders(COMPUTE_RESOURCE)` (bloquant, séquentiel).
2. Met à jour les annotations `multicluster.admiralty.io/clustername` avec `target-<peerId>-<executionsId>`.
3. Sérialise le workflow en YAML et l'écrit dans `./argo_workflows/<nom>_<timestamp>.yml`.

### `isReparted(processing, graphID) → (bool, *peer.Peer)`
Retrouve le Compute attaché au processing, charge le Peer propriétaire via l'API
oc-lib, et vérifie si `Relation != 1` (pas le peer local).

### `addTaskToArgo(exec, dag, graphItemID, processing, …)`
Crée une `Task` Argo (nom unique, template, dépendances DAG, paramètres env/inputs/outputs)
et la rattache au DAG.  Met à jour `firstItems` / `lastItems`.

### `isArgoDependancy(id) → (bool, []string)`
Vérifie si un nœud est utilisé comme source d'un lien sortant vers un autre
processing ou workflow (il est donc une dépendance pour quelqu'un).

### `getArgoDependencies(id) → []string`
Retourne les noms des tâches Argo dont ce nœud dépend (liens entrants).

---

## Protocole NATS utilisé

```
Publication  →  canal : ARGO_KUBE_EVENT
               payload : NATSResponse{Method: PROPALGATION_EVENT, Payload: ArgoKubeEvent}

Attente      ←  canal : PROPALGATION_EVENT
               filtre : PropalgationMessage{
                   Action   = PB_CONSIDERS,
                   DataType = COMPUTE_RESOURCE | STORAGE_RESOURCE,
                   Payload  = {"executions_id": "<id en cours>"}
               }
```

---

## Fichier YAML produit

- Nom : `oc-monitor-<mot1>-<mot2>_<DD_MM_YYYY_hhmmss>.yml`
- Dossier : `./argo_workflows/`
- Permissions : `0660`