866 lines
34 KiB
Go
866 lines
34 KiB
Go
// Package workflow_builder traduit les informations du graphe d'un Workflow
|
|
// (ses composants, ses liens) en un fichier YAML Argo Workflow prêt à être
|
|
// soumis à un cluster Kubernetes. Le point d'entrée principal est ArgoBuilder.
|
|
package workflow_builder
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"oc-monitord/conf"
|
|
. "oc-monitord/models"
|
|
"sync"
|
|
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
oclib "cloud.o-forge.io/core/oc-lib"
|
|
"cloud.o-forge.io/core/oc-lib/logs"
|
|
"cloud.o-forge.io/core/oc-lib/models/common/enum"
|
|
"cloud.o-forge.io/core/oc-lib/models/peer"
|
|
"cloud.o-forge.io/core/oc-lib/models/resources"
|
|
"cloud.o-forge.io/core/oc-lib/models/resources/native_tools"
|
|
w "cloud.o-forge.io/core/oc-lib/models/workflow"
|
|
"cloud.o-forge.io/core/oc-lib/models/workflow/graph"
|
|
"cloud.o-forge.io/core/oc-lib/models/workflow_execution"
|
|
"cloud.o-forge.io/core/oc-lib/tools"
|
|
"github.com/nwtgck/go-fakelish"
|
|
"github.com/rs/zerolog"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// logger est le logger zerolog partagé au sein du package, initialisé à
|
|
// chaque appel de CreateDAG pour récupérer la configuration courante.
|
|
var logger zerolog.Logger
|
|
|
|
// ArgoBuilder est le constructeur principal du fichier Argo Workflow.
|
|
// Il porte l'état de la construction (workflow source, templates générés,
|
|
// services k8s à créer, timeout global, liste des peers distants impliqués).
|
|
type ArgoBuilder struct {
|
|
// OriginWorkflow est le workflow métier Open Cloud dont on construit la représentation Argo.
|
|
OriginWorkflow *w.Workflow
|
|
// Workflow est la structure YAML Argo en cours de construction.
|
|
Workflow Workflow
|
|
// Services liste les services Kubernetes à exposer pour les processings "IsService".
|
|
Services []*Service
|
|
// Timeout est la durée maximale d'exécution en secondes (activeDeadlineSeconds).
|
|
Timeout int
|
|
// RemotePeers contient les IDs des peers distants détectés via Admiralty.
|
|
RemotePeers []string
|
|
// HasLocalCompute indique qu'au moins un processing s'exécute sur le kube local.
|
|
// Le kube local doit recevoir son propre ArgoKubeEvent COMPUTE_RESOURCE.
|
|
HasLocalCompute bool
|
|
// PeerImages associe chaque peer aux images de conteneurs qu'il doit exécuter.
|
|
// Clé "" désigne le peer local. Utilisé pour le pre-pull et le release post-exec.
|
|
PeerImages map[string][]string
|
|
}
|
|
|
|
// Workflow est la structure racine du fichier YAML Argo Workflow.
|
|
// Elle correspond exactement au format attendu par le contrôleur Argo.
|
|
type Workflow struct {
|
|
ApiVersion string `yaml:"apiVersion"`
|
|
Kind string `yaml:"kind"`
|
|
Metadata struct {
|
|
Name string `yaml:"name"`
|
|
} `yaml:"metadata"`
|
|
Spec Spec `yaml:"spec,omitempty"`
|
|
}
|
|
|
|
// getDag retourne le pointeur sur le template "dag" du workflow.
|
|
// S'il n'existe pas encore, il est créé et ajouté à la liste des templates.
|
|
func (b *Workflow) getDag() *Dag {
|
|
for _, t := range b.Spec.Templates {
|
|
if t.Name == "dag" {
|
|
return t.Dag
|
|
}
|
|
}
|
|
b.Spec.Templates = append(b.Spec.Templates, Template{Name: "dag", Dag: &Dag{}})
|
|
return b.Spec.Templates[len(b.Spec.Templates)-1].Dag
|
|
}
|
|
|
|
// PodSecurityContext mirrors the subset of k8s PodSecurityContext used by Argo.
|
|
type PodSecurityContext struct {
|
|
RunAsUser *int64 `yaml:"runAsUser,omitempty"`
|
|
RunAsGroup *int64 `yaml:"runAsGroup,omitempty"`
|
|
FSGroup *int64 `yaml:"fsGroup,omitempty"`
|
|
}
|
|
|
|
// Spec contient la spécification complète du workflow Argo :
|
|
// compte de service, point d'entrée, volumes, templates et timeout.
|
|
type Spec struct {
|
|
ArtifactRepositoryRef
|
|
ServiceAccountName string `yaml:"serviceAccountName,omitempty"`
|
|
Entrypoint string `yaml:"entrypoint"`
|
|
Arguments []Parameter `yaml:"arguments,omitempty"`
|
|
Volumes []VolumeClaimTemplate `yaml:"volumeClaimTemplates,omitempty"`
|
|
ExistingVolumes []ExistingVolume `yaml:"volumes,omitempty"`
|
|
Templates []Template `yaml:"templates"`
|
|
Timeout int `yaml:"activeDeadlineSeconds,omitempty"`
|
|
SecurityContext *PodSecurityContext `yaml:"securityContext,omitempty"`
|
|
}
|
|
|
|
// CreateDAG est le point d'entrée de la construction du DAG Argo.
|
|
// Il crée tous les templates (un par processing / native tool / sous-workflow),
|
|
// configure les volumes persistants, positionne les métadonnées globales du
|
|
// workflow et retourne :
|
|
// - le nombre de tâches dans le DAG,
|
|
// - les noms des premières tâches (sans dépendances),
|
|
// - les noms des dernières tâches (dont personne ne dépend),
|
|
// - une éventuelle erreur.
|
|
//
|
|
// Le paramètre write est conservé pour usage futur (écriture effective du YAML).
|
|
// TODO: gérer S3, GCS, Azure selon le type de stockage lié au processing.
|
|
func (b *ArgoBuilder) CreateDAG(exec *workflow_execution.WorkflowExecution, namespace string, write bool) (int, []string, []string, error) {
|
|
logger = logs.GetLogger()
|
|
logger.Info().Msg(fmt.Sprint("Creating DAG ", b.OriginWorkflow.Graph.Items))
|
|
// Crée un template Argo pour chaque nœud du graphe et collecte les volumes.
|
|
firstItems, lastItems, volumes, err := b.createTemplates(exec, namespace)
|
|
if err != nil {
|
|
return 0, firstItems, lastItems, err
|
|
}
|
|
b.createVolumes(exec, volumes)
|
|
|
|
if b.Timeout > 0 {
|
|
b.Workflow.Spec.Timeout = b.Timeout
|
|
}
|
|
b.Workflow.Spec.ServiceAccountName = "sa-" + namespace
|
|
b.Workflow.Spec.Entrypoint = "dag"
|
|
b.Workflow.ApiVersion = "argoproj.io/v1alpha1"
|
|
b.Workflow.Kind = "Workflow"
|
|
if !write {
|
|
return len(b.Workflow.getDag().Tasks), firstItems, lastItems, nil
|
|
}
|
|
|
|
return len(b.Workflow.getDag().Tasks), firstItems, lastItems, nil
|
|
}
|
|
|
|
// createTemplates parcourt tous les nœuds du graphe (processings, native tools,
|
|
// sous-workflows) et génère les templates Argo correspondants.
|
|
// Elle gère également le recâblage des dépendances DAG entre sous-workflows
|
|
// imbriqués, et l'ajout du pod de service si nécessaire.
|
|
// Retourne les premières tâches, les dernières tâches et les volumes à créer.
|
|
func (b *ArgoBuilder) createTemplates(exec *workflow_execution.WorkflowExecution, namespace string) ([]string, []string, []VolumeMount, error) {
|
|
volumes := []VolumeMount{}
|
|
firstItems := []string{}
|
|
lastItems := []string{}
|
|
|
|
// --- Processings ---
|
|
for _, item := range b.OriginWorkflow.GetGraphItems(b.OriginWorkflow.Graph.IsProcessing) {
|
|
index := 0
|
|
_, res := item.GetResource()
|
|
if d, ok := exec.SelectedInstances[res.GetID()]; ok {
|
|
index = d
|
|
}
|
|
instance := item.Processing.GetSelectedInstance(&index)
|
|
logger.Info().Msg(fmt.Sprint("Creating template for", item.Processing.GetName(), instance))
|
|
if instance == nil || instance.(*resources.ProcessingInstance).Access == nil && instance.(*resources.ProcessingInstance).Access.Container != nil {
|
|
logger.Error().Msg("Not enough configuration setup, template can't be created : " + item.Processing.GetName())
|
|
return firstItems, lastItems, volumes, nil
|
|
}
|
|
// Un même processing peut être bookié sur plusieurs peers : on crée
|
|
// un template Argo distinct par peer, déployés en parallèle.
|
|
for _, pb := range getAllPeersForItem(exec, item.ID) {
|
|
var err error
|
|
volumes, firstItems, lastItems, err = b.createArgoTemplates(exec,
|
|
namespace, item.ID, pb.PeerID, pb.BookingID, item.Processing, volumes, firstItems, lastItems)
|
|
if err != nil {
|
|
return firstItems, lastItems, volumes, err
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Native Tools de type WORKFLOW_EVENT uniquement ---
|
|
for _, item := range b.OriginWorkflow.GetGraphItems(b.OriginWorkflow.Graph.IsNativeTool) {
|
|
if item.NativeTool.Kind != int(native_tools.WORKFLOW_EVENT) {
|
|
continue
|
|
}
|
|
index := 0
|
|
_, res := item.GetResource()
|
|
if d, ok := exec.SelectedInstances[res.GetID()]; ok {
|
|
index = d
|
|
}
|
|
instance := item.NativeTool.GetSelectedInstance(&index)
|
|
logger.Info().Msg(fmt.Sprint("Creating template for", item.NativeTool.GetName(), instance))
|
|
var err error
|
|
volumes, firstItems, lastItems, err = b.createArgoTemplates(exec,
|
|
namespace, item.ID, "", item.ID, item.NativeTool, volumes, firstItems, lastItems)
|
|
if err != nil {
|
|
return firstItems, lastItems, volumes, err
|
|
}
|
|
}
|
|
|
|
// --- Sous-workflows : chargement, construction récursive et fusion du DAG ---
|
|
firstWfTasks := map[string][]string{}
|
|
latestWfTasks := map[string][]string{}
|
|
relatedWfTasks := map[string][]string{}
|
|
for _, wf := range b.OriginWorkflow.Workflows {
|
|
realWorkflow, code, err := w.NewAccessor(nil).LoadOne(wf)
|
|
if code != 200 {
|
|
logger.Error().Msg("Error loading the workflow : " + err.Error())
|
|
continue
|
|
}
|
|
subBuilder := ArgoBuilder{OriginWorkflow: realWorkflow.(*w.Workflow), Timeout: b.Timeout}
|
|
_, fi, li, err := subBuilder.CreateDAG(exec, namespace, false)
|
|
if err != nil {
|
|
logger.Error().Msg("Error creating the subworkflow : " + err.Error())
|
|
continue
|
|
}
|
|
firstWfTasks[wf] = fi
|
|
if ok, depsOfIds := subBuilder.isArgoDependancy(exec, wf); ok { // le sous-workflow est une dépendance d'autre chose
|
|
latestWfTasks[wf] = li
|
|
relatedWfTasks[wf] = depsOfIds
|
|
}
|
|
// Fusion des tâches, templates, volumes et arguments du sous-workflow dans le DAG principal.
|
|
subDag := subBuilder.Workflow.getDag()
|
|
d := b.Workflow.getDag()
|
|
d.Tasks = append(d.Tasks, subDag.Tasks...)
|
|
b.Workflow.Spec.Templates = append(b.Workflow.Spec.Templates, subBuilder.Workflow.Spec.Templates...)
|
|
b.Workflow.Spec.Volumes = append(b.Workflow.Spec.Volumes, subBuilder.Workflow.Spec.Volumes...)
|
|
b.Workflow.Spec.Arguments = append(b.Workflow.Spec.Arguments, subBuilder.Workflow.Spec.Arguments...)
|
|
b.Services = append(b.Services, subBuilder.Services...)
|
|
}
|
|
|
|
// Recâblage : les tâches qui dépendaient du sous-workflow dépendent désormais
|
|
// de sa dernière tâche réelle (latestWfTasks).
|
|
for wfID, depsOfIds := range relatedWfTasks {
|
|
for _, dep := range depsOfIds {
|
|
for _, task := range b.Workflow.getDag().Tasks {
|
|
if strings.Contains(task.Name, dep) {
|
|
index := -1
|
|
for i, depp := range task.Dependencies {
|
|
if strings.Contains(depp, wfID) {
|
|
index = i
|
|
break
|
|
}
|
|
}
|
|
if index != -1 {
|
|
task.Dependencies = append(task.Dependencies[:index], task.Dependencies[index+1:]...)
|
|
}
|
|
task.Dependencies = append(task.Dependencies, latestWfTasks[wfID]...)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Les premières tâches du sous-workflow héritent des dépendances
|
|
// que le sous-workflow avait vis-à-vis du DAG principal.
|
|
for wfID, fi := range firstWfTasks {
|
|
deps := b.getArgoDependencies(exec, wfID)
|
|
if len(deps) > 0 {
|
|
for _, dep := range fi {
|
|
for _, task := range b.Workflow.getDag().Tasks {
|
|
if strings.Contains(task.Name, dep) {
|
|
task.Dependencies = append(task.Dependencies, deps...)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Si des services Kubernetes sont nécessaires, on ajoute le pod dédié.
|
|
if b.Services != nil {
|
|
dag := b.Workflow.getDag()
|
|
dag.Tasks = append(dag.Tasks, Task{Name: "workflow-service-pod", Template: "workflow-service-pod"})
|
|
b.addServiceToArgo()
|
|
}
|
|
return firstItems, lastItems, volumes, nil
|
|
}
|
|
|
|
// createArgoTemplates crée le template Argo pour un nœud du graphe (processing
|
|
// ou native tool) sur un peer donné. Il :
|
|
// 1. Ajoute la tâche au DAG avec ses dépendances.
|
|
// 2. Crée le template de container (ou d'événement pour les native tools).
|
|
// 3. Ajoute les annotations Admiralty si peerID désigne un peer distant.
|
|
// 4. Crée un service Kubernetes si le processing est déclaré IsService.
|
|
// 5. Configure les annotations de stockage (S3, volumes locaux).
|
|
func (b *ArgoBuilder) createArgoTemplates(
|
|
exec *workflow_execution.WorkflowExecution,
|
|
namespace string,
|
|
graphID string,
|
|
peerID string,
|
|
bookingID string,
|
|
obj resources.ResourceInterface,
|
|
volumes []VolumeMount,
|
|
firstItems []string,
|
|
lastItems []string,
|
|
) ([]VolumeMount, []string, []string, error) {
|
|
|
|
_, firstItems, lastItems = b.addTaskToArgo(exec, b.Workflow.getDag(), graphID, bookingID, obj, firstItems, lastItems)
|
|
template := &Template{Name: getArgoName(obj.GetName(), bookingID)}
|
|
logger.Info().Msg(fmt.Sprint("Creating template for", template.Name))
|
|
|
|
if obj.GetType() == tools.PROCESSING_RESOURCE.String() {
|
|
template.CreateContainer(exec, obj.(*resources.ProcessingResource), b.Workflow.getDag())
|
|
} else if obj.GetType() == tools.NATIVE_TOOL.String() {
|
|
template.CreateEventContainer(exec, obj.(*resources.NativeTool), b.Workflow.getDag())
|
|
}
|
|
// Enregistre l'image pour le pre-pull sur le peer cible.
|
|
// peerID == "" désigne le peer local (clé "" dans PeerImages).
|
|
b.addPeerImage(peerID, template.Container.Image)
|
|
|
|
// Vérifie si le peer est distant (Admiralty).
|
|
isReparted, remotePeer := b.isPeerReparted(peerID)
|
|
if isReparted {
|
|
logger.Debug().Msg("Reparted processing, on " + remotePeer.GetID())
|
|
b.RemotePeers = append(b.RemotePeers, remotePeer.GetID())
|
|
template.AddAdmiraltyAnnotations(remotePeer.GetID())
|
|
} else {
|
|
// Processing local : le kube local doit aussi être configuré.
|
|
b.HasLocalCompute = true
|
|
}
|
|
|
|
// Si le processing expose un service Kubernetes, on l'enregistre et on
|
|
// applique le label "app" pour que le Service puisse le sélectionner.
|
|
if obj.GetType() == tools.PROCESSING_RESOURCE.String() && obj.(*resources.ProcessingResource).IsService {
|
|
b.CreateService(exec, graphID, obj)
|
|
template.Metadata.Labels = make(map[string]string)
|
|
template.Metadata.Labels["app"] = "oc-service-" + obj.GetName()
|
|
}
|
|
|
|
var err error
|
|
volumes, err = b.addStorageAnnotations(exec, graphID, template, namespace, volumes, isReparted)
|
|
if err != nil {
|
|
return volumes, firstItems, lastItems, err
|
|
}
|
|
b.Workflow.Spec.Templates = append(b.Workflow.Spec.Templates, *template)
|
|
return volumes, firstItems, lastItems, nil
|
|
}
|
|
|
|
// addStorageAnnotations parcourt tous les nœuds de stockage liés au processing
|
|
// identifié par id. Pour chaque lien de stockage :
|
|
// - Construit le nom de l'artefact Argo (lecture ou écriture).
|
|
// - Pour les stockages S3 : appelle waitForConsiders (STORAGE_RESOURCE) pour
|
|
// attendre la validation PB_CONSIDERS avant de configurer les annotations S3.
|
|
// - Pour les volumes locaux : ajoute un VolumeMount dans le container.
|
|
// Si isReparted est true (step Admiralty), le volume local est marqué comme
|
|
// réparti afin que createVolumes ne génère pas de PVC local-path incompatible
|
|
// avec les virtual kubelets.
|
|
func (b *ArgoBuilder) addStorageAnnotations(exec *workflow_execution.WorkflowExecution, id string, template *Template, namespace string, volumes []VolumeMount, isReparted bool) ([]VolumeMount, error) {
|
|
// Récupère tous les nœuds de stockage connectés au processing courant.
|
|
related := b.OriginWorkflow.GetByRelatedProcessing(id, b.OriginWorkflow.Graph.IsStorage)
|
|
|
|
for _, r := range related {
|
|
storage := r.Node.(*resources.StorageResource)
|
|
for _, linkToStorage := range r.Links {
|
|
for _, rw := range linkToStorage.StorageLinkInfos {
|
|
var art Artifact
|
|
// Le nom de l'artefact doit être alphanumérique + '-' ou '_'.
|
|
artifactBaseName := strings.Join(strings.Split(storage.GetName(), " "), "-") + "-" + strings.Replace(rw.FileName, ".", "-", -1)
|
|
if rw.Write {
|
|
// Écriture vers S3 : Path = chemin du fichier dans le pod.
|
|
art = Artifact{Path: template.ReplacePerEnv(rw.Source, linkToStorage.Env)}
|
|
art.Name = artifactBaseName + "-input-write"
|
|
} else {
|
|
// Lecture depuis S3 : Path = destination dans le pod.
|
|
art = Artifact{Path: template.ReplacePerEnv(rw.Destination+"/"+rw.FileName, linkToStorage.Env)}
|
|
art.Name = artifactBaseName + "-input-read"
|
|
}
|
|
|
|
if storage.StorageType == enum.S3 {
|
|
// Pour chaque ressource de compute liée à ce stockage S3,
|
|
// on notifie via NATS et on attend la validation PB_CONSIDERS
|
|
// avec DataType = STORAGE_RESOURCE avant de continuer.
|
|
// Les goroutines tournent en parallèle ; un timeout sur l'une
|
|
// d'elles est une erreur fatale qui stoppe la suite du build.
|
|
relatedProcessing := b.getStorageRelatedProcessing(storage.GetID())
|
|
var wg sync.WaitGroup
|
|
errCh := make(chan error, len(relatedProcessing))
|
|
for _, r := range relatedProcessing {
|
|
wg.Add(1)
|
|
go waitForConsiders(exec.ExecutionsID, tools.STORAGE_RESOURCE, ArgoKubeEvent{
|
|
ExecutionsID: exec.ExecutionsID,
|
|
DestPeerID: r.GetID(),
|
|
Type: tools.STORAGE_RESOURCE,
|
|
SourcePeerID: storage.GetCreatorID(),
|
|
OriginID: conf.GetConfig().PeerID,
|
|
}, &wg, errCh)
|
|
}
|
|
wg.Wait()
|
|
close(errCh)
|
|
for err := range errCh {
|
|
if err != nil {
|
|
return volumes, err
|
|
}
|
|
}
|
|
// Configure la référence au dépôt d'artefacts S3 dans le Spec.
|
|
b.addS3annotations(storage, namespace)
|
|
}
|
|
|
|
if rw.Write {
|
|
template.Outputs.Artifacts = append(template.Outputs.Artifacts, art)
|
|
} else {
|
|
template.Inputs.Artifacts = append(template.Inputs.Artifacts, art)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Si l'instance de stockage est locale, on pré-provisionne le PVC via
|
|
// oc-datacenter (même pattern que MinIO) puis on monte un volume existant.
|
|
index := 0
|
|
if s, ok := exec.SelectedInstances[storage.GetID()]; ok {
|
|
index = s
|
|
}
|
|
s := storage.Instances[index]
|
|
if s.Local {
|
|
var pvcWg sync.WaitGroup
|
|
pvcErrCh := make(chan error, 1)
|
|
pvcWg.Add(1)
|
|
go waitForConsiders(exec.ExecutionsID, tools.STORAGE_RESOURCE, ArgoKubeEvent{
|
|
ExecutionsID: exec.ExecutionsID,
|
|
Type: tools.STORAGE_RESOURCE,
|
|
SourcePeerID: conf.GetConfig().PeerID,
|
|
DestPeerID: conf.GetConfig().PeerID,
|
|
OriginID: conf.GetConfig().PeerID,
|
|
MinioID: storage.GetID(),
|
|
Local: true,
|
|
StorageName: storage.GetName(),
|
|
}, &pvcWg, pvcErrCh)
|
|
pvcWg.Wait()
|
|
close(pvcErrCh)
|
|
for err := range pvcErrCh {
|
|
if err != nil {
|
|
return volumes, err
|
|
}
|
|
}
|
|
volumes = template.Container.AddVolumeMount(VolumeMount{
|
|
Name: strings.ReplaceAll(strings.ToLower(storage.GetName()), " ", "-"),
|
|
MountPath: s.Source,
|
|
Storage: storage,
|
|
IsReparted: isReparted,
|
|
}, volumes)
|
|
}
|
|
}
|
|
return volumes, nil
|
|
}
|
|
|
|
// getStorageRelatedProcessing retourne la liste des ressources de compute
|
|
// connectées (via un processing intermédiaire) au stockage identifié par storageId.
|
|
// Ces ressources sont utilisées pour construire les ArgoKubeEvent destinés
|
|
// à la validation NATS.
|
|
func (b *ArgoBuilder) getStorageRelatedProcessing(storageId string) (res []resources.ResourceInterface) {
|
|
var storageLinks []graph.GraphLink
|
|
// On ne conserve que les liens impliquant ce stockage.
|
|
for _, link := range b.OriginWorkflow.Graph.Links {
|
|
if link.Destination.ID == storageId || link.Source.ID == storageId {
|
|
storageLinks = append(storageLinks, link)
|
|
}
|
|
}
|
|
|
|
for _, link := range storageLinks {
|
|
var resourceId string
|
|
// L'opposé du lien est soit la source soit la destination selon la direction.
|
|
if link.Source.ID != storageId {
|
|
resourceId = link.Source.ID
|
|
} else {
|
|
resourceId = link.Destination.ID
|
|
}
|
|
// Si l'opposé est un processing, on récupère ses ressources de compute.
|
|
if b.OriginWorkflow.Graph.IsProcessing(b.OriginWorkflow.Graph.Items[resourceId]) {
|
|
res = append(res, b.getComputeProcessing(resourceId)...)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// getComputeProcessing retourne toutes les ressources de compute attachées
|
|
// au processing identifié par processingId dans le graphe du workflow.
|
|
func (b *ArgoBuilder) getComputeProcessing(processingId string) (res []resources.ResourceInterface) {
|
|
arr := []resources.ResourceInterface{}
|
|
computeRel := b.OriginWorkflow.GetByRelatedProcessing(processingId, b.OriginWorkflow.Graph.IsCompute)
|
|
for _, rel := range computeRel {
|
|
arr = append(arr, rel.Node)
|
|
}
|
|
return arr
|
|
}
|
|
|
|
// addS3annotations configure la référence au dépôt d'artefacts S3 dans le Spec
|
|
// du workflow Argo. La ConfigMap et la clé sont dérivées de l'ID du stockage.
|
|
// Le namespace est conservé en signature pour une évolution future.
|
|
func (b *ArgoBuilder) addS3annotations(storage *resources.StorageResource, namespace string) {
|
|
b.Workflow.Spec.ArtifactRepositoryRef = ArtifactRepositoryRef{
|
|
ConfigMap: storage.GetID() + "-artifact-repository",
|
|
Key: storage.GetID() + "-s3-local",
|
|
}
|
|
}
|
|
|
|
// addTaskToArgo ajoute une tâche au DAG Argo pour le nœud graphItemID.
|
|
// Elle résout les dépendances DAG, propage les paramètres d'environnement,
|
|
// d'entrée et de sortie de l'instance sélectionnée, et met à jour les listes
|
|
// firstItems / lastItems utilisées pour le recâblage des sous-workflows.
|
|
// bookingID est le nom unique de cette instance (peut varier par peer).
|
|
func (b *ArgoBuilder) addTaskToArgo(exec *workflow_execution.WorkflowExecution, dag *Dag, graphItemID string, bookingID string, processing resources.ResourceInterface,
|
|
firstItems []string, lastItems []string) (*Dag, []string, []string) {
|
|
|
|
unique_name := getArgoName(processing.GetName(), bookingID)
|
|
step := Task{Name: unique_name, Template: unique_name}
|
|
|
|
index := 0
|
|
if d, ok := exec.SelectedInstances[processing.GetID()]; ok {
|
|
index = d
|
|
}
|
|
instance := processing.GetSelectedInstance(&index)
|
|
if instance != nil {
|
|
// Propagation des variables d'environnement, entrées et sorties
|
|
// de l'instance vers les paramètres de la tâche Argo.
|
|
for _, value := range instance.(*resources.ProcessingInstance).Env {
|
|
step.Arguments.Parameters = append(step.Arguments.Parameters, Parameter{
|
|
Name: value.Name,
|
|
Value: value.Value,
|
|
})
|
|
}
|
|
for _, value := range instance.(*resources.ProcessingInstance).Inputs {
|
|
step.Arguments.Parameters = append(step.Arguments.Parameters, Parameter{
|
|
Name: value.Name,
|
|
Value: value.Value,
|
|
})
|
|
}
|
|
for _, value := range instance.(*resources.ProcessingInstance).Outputs {
|
|
step.Arguments.Parameters = append(step.Arguments.Parameters, Parameter{
|
|
Name: value.Name,
|
|
Value: value.Value,
|
|
})
|
|
}
|
|
}
|
|
|
|
step.Dependencies = b.getArgoDependencies(exec, graphItemID)
|
|
|
|
// Détermine si ce nœud est une première ou une dernière tâche du DAG.
|
|
name := ""
|
|
if b.OriginWorkflow.Graph.Items[graphItemID].Processing != nil {
|
|
name = b.OriginWorkflow.Graph.Items[graphItemID].Processing.GetName()
|
|
}
|
|
if b.OriginWorkflow.Graph.Items[graphItemID].Workflow != nil {
|
|
name = b.OriginWorkflow.Graph.Items[graphItemID].Workflow.GetName()
|
|
}
|
|
if len(step.Dependencies) == 0 && name != "" {
|
|
firstItems = append(firstItems, getArgoName(name, bookingID))
|
|
}
|
|
if ok, _ := b.isArgoDependancy(exec, graphItemID); !ok && name != "" {
|
|
lastItems = append(lastItems, getArgoName(name, bookingID))
|
|
}
|
|
|
|
dag.Tasks = append(dag.Tasks, step)
|
|
return dag, firstItems, lastItems
|
|
}
|
|
|
|
// createVolumes référence les PVCs pré-provisionnés par oc-datacenter comme
|
|
// volumes existants (ExistingVolumes) dans le Spec Argo.
|
|
// Le nom du PVC est calculé de manière déterministe : <storageName>-<executionsID>,
|
|
// identique à ClaimName() dans oc-datacenter/infrastructure/storage/pvc_setter.go.
|
|
func (b *ArgoBuilder) createVolumes(exec *workflow_execution.WorkflowExecution, volumes []VolumeMount) {
|
|
seen := make(map[string]struct{})
|
|
for _, volume := range volumes {
|
|
name := strings.ReplaceAll(strings.ToLower(volume.Name), " ", "-")
|
|
if _, ok := seen[name]; ok {
|
|
continue
|
|
}
|
|
seen[name] = struct{}{}
|
|
claimName := name + "-" + exec.ExecutionsID
|
|
ev := ExistingVolume{}
|
|
ev.Name = name
|
|
ev.PersistentVolumeClaim.ClaimName = claimName
|
|
b.Workflow.Spec.ExistingVolumes = append(b.Workflow.Spec.ExistingVolumes, ev)
|
|
}
|
|
// hostPath PVs are created as root:root 0755. Ensure pods can read/write
|
|
// by running as root when local volumes are present.
|
|
if len(b.Workflow.Spec.ExistingVolumes) > 0 && b.Workflow.Spec.SecurityContext == nil {
|
|
zero := int64(0)
|
|
b.Workflow.Spec.SecurityContext = &PodSecurityContext{
|
|
RunAsUser: &zero,
|
|
RunAsGroup: &zero,
|
|
FSGroup: &zero,
|
|
}
|
|
}
|
|
}
|
|
|
|
// isArgoDependancy vérifie si le nœud identifié par id est une dépendance
|
|
// d'au moins un autre nœud du DAG (i.e. s'il existe un lien sortant vers
|
|
// un processing ou un workflow).
|
|
// Retourne true + la liste des noms Argo des nœuds qui en dépendent.
|
|
func (b *ArgoBuilder) isArgoDependancy(exec *workflow_execution.WorkflowExecution, id string) (bool, []string) {
|
|
dependancyOfIDs := []string{}
|
|
isDeps := false
|
|
for _, link := range b.OriginWorkflow.Graph.Links {
|
|
if _, ok := b.OriginWorkflow.Graph.Items[link.Destination.ID]; !ok {
|
|
logger.Info().Msg(fmt.Sprint("Could not find the source of the link", link.Destination.ID))
|
|
continue
|
|
}
|
|
source := b.OriginWorkflow.Graph.Items[link.Destination.ID].Processing
|
|
if id == link.Source.ID && source != nil {
|
|
isDeps = true
|
|
for _, pb := range getAllPeersForItem(exec, link.Destination.ID) {
|
|
dependancyOfIDs = append(dependancyOfIDs, getArgoName(source.GetName(), pb.BookingID))
|
|
}
|
|
}
|
|
wourceWF := b.OriginWorkflow.Graph.Items[link.Destination.ID].Workflow
|
|
if id == link.Source.ID && wourceWF != nil {
|
|
isDeps = true
|
|
for _, pb := range getAllPeersForItem(exec, link.Destination.ID) {
|
|
dependancyOfIDs = append(dependancyOfIDs, getArgoName(wourceWF.GetName(), pb.BookingID))
|
|
}
|
|
}
|
|
}
|
|
return isDeps, dependancyOfIDs
|
|
}
|
|
|
|
// getArgoDependencies retourne la liste des noms de tâches Argo dont dépend
|
|
// le nœud identifié par id (liens entrants depuis des processings).
|
|
// Si le processing source est bookié sur N peers, toutes ses instances sont
|
|
// retournées comme dépendances (la tâche courante attend toutes les instances).
|
|
func (b *ArgoBuilder) getArgoDependencies(exec *workflow_execution.WorkflowExecution, id string) (dependencies []string) {
|
|
for _, link := range b.OriginWorkflow.Graph.Links {
|
|
if _, ok := b.OriginWorkflow.Graph.Items[link.Source.ID]; !ok {
|
|
logger.Info().Msg(fmt.Sprint("Could not find the source of the link", link.Source.ID))
|
|
continue
|
|
}
|
|
source := b.OriginWorkflow.Graph.Items[link.Source.ID].Processing
|
|
if id == link.Destination.ID && source != nil {
|
|
for _, pb := range getAllPeersForItem(exec, link.Source.ID) {
|
|
dependencies = append(dependencies, getArgoName(source.GetName(), pb.BookingID))
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// getArgoName construit le nom unique d'une tâche / template Argo à partir
|
|
// du nom humain de la ressource et de son ID dans le graphe.
|
|
// Les espaces sont remplacés par des tirets et tout est mis en minuscules.
|
|
func getArgoName(raw_name string, component_id string) (formatedName string) {
|
|
formatedName = strings.ReplaceAll(raw_name, " ", "-")
|
|
formatedName += "-" + component_id
|
|
formatedName = strings.ToLower(formatedName)
|
|
return
|
|
}
|
|
|
|
// peerBooking associe un peerID à son bookingID pour un item du graphe.
|
|
type peerBooking struct {
|
|
PeerID string
|
|
BookingID string
|
|
}
|
|
|
|
// getAllPeersForItem retourne tous les (peerID, bookingID) enregistrés dans
|
|
// PeerBookByGraph pour un item donné. Si aucun booking n'est trouvé (item
|
|
// non encore planifié ou sous-workflow), retourne une entrée locale de
|
|
// fallback avec BookingID = graphItemID.
|
|
func getAllPeersForItem(exec *workflow_execution.WorkflowExecution, graphItemID string) []peerBooking {
|
|
var result []peerBooking
|
|
for peerID, byGraph := range exec.PeerBookByGraph {
|
|
if bookings, ok := byGraph[graphItemID]; ok && len(bookings) > 0 {
|
|
result = append(result, peerBooking{PeerID: peerID, BookingID: bookings[0]})
|
|
}
|
|
}
|
|
if len(result) == 0 {
|
|
result = []peerBooking{{PeerID: "", BookingID: graphItemID}}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// isPeerReparted vérifie si le peerID désigne un peer distant (Relation != 1).
|
|
// Un peerID vide signifie exécution locale : retourne false sans appel réseau.
|
|
func (b *ArgoBuilder) isPeerReparted(peerID string) (bool, *peer.Peer) {
|
|
if peerID == "" {
|
|
return false, nil
|
|
}
|
|
|
|
req := oclib.NewRequest(oclib.LibDataEnum(oclib.PEER), "", "", nil, nil)
|
|
if req == nil {
|
|
fmt.Println("TODO : handle error when trying to create a request on the Peer Collection")
|
|
return false, nil
|
|
}
|
|
|
|
res := req.LoadOne(peerID)
|
|
if res.Err != "" {
|
|
fmt.Print("TODO : handle error when requesting PeerID: " + res.Err)
|
|
return false, nil
|
|
}
|
|
|
|
p := res.ToPeer()
|
|
// Relation == 1 signifie "moi-même" : le processing est local.
|
|
isNotReparted := p.Relation == 1
|
|
logger.Info().Msg(fmt.Sprint("Result IsMySelf for ", p.UUID, " : ", isNotReparted))
|
|
return !isNotReparted, p
|
|
}
|
|
|
|
// waitForConsiders publie un ArgoKubeEvent sur NATS puis attend la confirmation
|
|
// PB_CONSIDERS via le cache global (globalConsidersCache), sans ouvrir de
|
|
// connexion NATS supplémentaire. Le listener centralisé (StartConsidersListener)
|
|
// dispatche le message vers le bon canal.
|
|
// Un timeout de 5 minutes est appliqué pour éviter un blocage indéfini.
|
|
func waitForConsiders(executionsId string, dataType tools.DataType, event ArgoKubeEvent, wg *sync.WaitGroup, errCh chan<- error) {
|
|
defer wg.Done()
|
|
|
|
// Sérialise l'événement et le publie sur ARGO_KUBE_EVENT.
|
|
b, err := json.Marshal(event)
|
|
if err != nil {
|
|
logger.Error().Msg("Cannot marshal ArgoKubeEvent: " + err.Error())
|
|
errCh <- err
|
|
return
|
|
}
|
|
tools.NewNATSCaller().SetNATSPub(tools.ARGO_KUBE_EVENT, tools.NATSResponse{
|
|
FromApp: "oc-monitord",
|
|
Datatype: dataType,
|
|
User: "root",
|
|
Method: int(tools.ARGO_KUBE_EVENT),
|
|
Payload: b,
|
|
})
|
|
|
|
// Enregistrement dans le cache et attente de la confirmation.
|
|
// Pour COMPUTE_RESOURCE, SourcePeerID différencie le peer compute (local ou distant).
|
|
// Pour STORAGE_RESOURCE, SourcePeerID est le peer hébergeant le stockage.
|
|
key := considersKey(executionsId, dataType, event.SourcePeerID)
|
|
ch, unregister := globalConsidersCache.register(key)
|
|
defer unregister()
|
|
|
|
select {
|
|
case <-ch:
|
|
logger.Info().Msg(fmt.Sprintf("PB_CONSIDERS received for executions_id=%s datatype=%s source_peer=%s dest_peer=%s", executionsId, dataType.String(), event.SourcePeerID, event.DestPeerID))
|
|
errCh <- nil
|
|
case <-time.After(5 * time.Minute):
|
|
err := fmt.Errorf("timeout waiting for PB_CONSIDERS executions_id=%s datatype=%s", executionsId, dataType.String())
|
|
logger.Error().Msg(err.Error())
|
|
errCh <- err
|
|
}
|
|
}
|
|
|
|
// ArgoKubeEvent est la structure publiée sur NATS lors de la demande de
|
|
// provisionnement d'une ressource distante (Admiralty ou stockage S3).
|
|
// Le champ OriginID identifie le peer initiateur : c'est vers lui que la
|
|
// réponse PB_CONSIDERS sera routée par le système de propagation.
|
|
type ArgoKubeEvent struct {
|
|
// ExecutionsID est l'identifiant de l'exécution de workflow en cours.
|
|
ExecutionsID string `json:"executions_id"`
|
|
// DestPeerID est le peer de destination (compute ou peer S3 cible).
|
|
DestPeerID string `json:"dest_peer_id"`
|
|
// Type indique la nature de la ressource : COMPUTE_RESOURCE ou STORAGE_RESOURCE.
|
|
Type tools.DataType `json:"data_type"`
|
|
// SourcePeerID est le peer source de la ressource demandée.
|
|
SourcePeerID string `json:"source_peer_id"`
|
|
// OriginID est le peer qui a initié la demande de provisionnement ;
|
|
// la réponse PB_CONSIDERS lui sera renvoyée.
|
|
OriginID string `json:"origin_id"`
|
|
// MinioID est l'ID de la ressource storage (Minio ou local PVC).
|
|
MinioID string `json:"minio_id,omitempty"`
|
|
// Local signale un storage Local=true (PVC pré-provisionné par oc-datacenter).
|
|
Local bool `json:"local,omitempty"`
|
|
// StorageName est le nom normalisé du storage, utilisé pour calculer le claimName.
|
|
StorageName string `json:"storage_name,omitempty"`
|
|
// Images est la liste des images de conteneurs à pre-pull sur le peer cible
|
|
// avant le démarrage du workflow. Vide pour les events STORAGE_RESOURCE.
|
|
Images []string `json:"images,omitempty"`
|
|
}
|
|
|
|
// addPeerImage enregistre une image à pre-pull pour un peer donné.
|
|
// Clé "" désigne le peer local. Les doublons sont ignorés.
|
|
func (b *ArgoBuilder) addPeerImage(peerID, image string) {
|
|
if image == "" {
|
|
return
|
|
}
|
|
if b.PeerImages == nil {
|
|
b.PeerImages = make(map[string][]string)
|
|
}
|
|
for _, existing := range b.PeerImages[peerID] {
|
|
if existing == image {
|
|
return
|
|
}
|
|
}
|
|
b.PeerImages[peerID] = append(b.PeerImages[peerID], image)
|
|
}
|
|
|
|
|
|
// CompleteBuild finalise la construction du workflow Argo après la génération
|
|
// du DAG. Elle effectue dans l'ordre :
|
|
// 1. Pour chaque peer distant (Admiralty) : publie un ArgoKubeEvent de type
|
|
// COMPUTE_RESOURCE et attend la validation PB_CONSIDERS via waitForConsiders.
|
|
// 2. Met à jour les annotations Admiralty des templates avec le nom de cluster
|
|
// construit à partir du peerId et de l'executionsId.
|
|
// 3. Sérialise le workflow en YAML et l'écrit dans ./argo_workflows/.
|
|
//
|
|
// Retourne le chemin du fichier YAML généré.
|
|
func (b *ArgoBuilder) CompleteBuild(executionsId string) (string, error) {
|
|
logger.Info().Msg("DEV :: Completing build")
|
|
|
|
// --- Étape 1 : validation kube pour tous les peers (local + distants) ---
|
|
// Les goroutines tournent en parallèle ; un timeout est une erreur fatale.
|
|
// Déduplique RemotePeers : plusieurs processings peuvent pointer vers le même
|
|
// peer distant, on ne doit envoyer qu'un seul ArgoKubeEvent par peer.
|
|
seen := make(map[string]struct{})
|
|
uniqueRemotePeers := b.RemotePeers[:0]
|
|
for _, p := range b.RemotePeers {
|
|
if _, ok := seen[p]; !ok {
|
|
seen[p] = struct{}{}
|
|
uniqueRemotePeers = append(uniqueRemotePeers, p)
|
|
}
|
|
}
|
|
b.RemotePeers = uniqueRemotePeers
|
|
|
|
total := len(b.RemotePeers)
|
|
if b.HasLocalCompute {
|
|
total++
|
|
}
|
|
var wg sync.WaitGroup
|
|
errCh := make(chan error, total)
|
|
|
|
// Le kube local doit aussi être configuré s'il porte au moins un processing.
|
|
if b.HasLocalCompute {
|
|
if localPeer, err := oclib.GetMySelf(); err == nil {
|
|
logger.Info().Msg("DEV :: Launching local kube setup for " + localPeer.GetID())
|
|
wg.Add(1)
|
|
go waitForConsiders(executionsId, tools.COMPUTE_RESOURCE, ArgoKubeEvent{
|
|
ExecutionsID: executionsId,
|
|
Type: tools.COMPUTE_RESOURCE,
|
|
DestPeerID: localPeer.GetID(),
|
|
SourcePeerID: localPeer.GetID(),
|
|
OriginID: localPeer.GetID(),
|
|
Images: b.PeerImages[""], // images à pre-pull sur le cluster local
|
|
}, &wg, errCh)
|
|
}
|
|
}
|
|
|
|
// Peers distants via Admiralty.
|
|
for _, peer := range b.RemotePeers {
|
|
logger.Info().Msg(fmt.Sprint("DEV :: Launching Admiralty Setup for ", peer))
|
|
if self, err := oclib.GetMySelf(); err == nil {
|
|
wg.Add(1)
|
|
go waitForConsiders(executionsId, tools.COMPUTE_RESOURCE, ArgoKubeEvent{
|
|
ExecutionsID: executionsId,
|
|
Type: tools.COMPUTE_RESOURCE,
|
|
DestPeerID: self.GetID(),
|
|
SourcePeerID: peer,
|
|
OriginID: self.GetID(),
|
|
Images: b.PeerImages[peer], // images à pre-pull sur le cluster distant (via kubeconfig Admiralty)
|
|
}, &wg, errCh)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
close(errCh)
|
|
for err := range errCh {
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
}
|
|
|
|
// --- Étape 2 : génération et écriture du fichier YAML ---
|
|
random_name := fakelish.GenerateFakeWord(5, 8) + "-" + fakelish.GenerateFakeWord(5, 8)
|
|
b.Workflow.Metadata.Name = "oc-monitor-" + random_name
|
|
logger = oclib.GetLogger()
|
|
yamlified, err := yaml.Marshal(b.Workflow)
|
|
if err != nil {
|
|
logger.Error().Msg("Could not transform object to yaml file")
|
|
return "", err
|
|
}
|
|
// Nom de fichier horodaté au format DD_MM_YYYY_hhmmss.
|
|
current_timestamp := time.Now().UTC().Format("02_01_2006_150405")
|
|
file_name := random_name + "_" + current_timestamp + ".yml"
|
|
workflows_dir := "./argo_workflows/"
|
|
err = os.WriteFile(workflows_dir+file_name, []byte(yamlified), 0660)
|
|
if err != nil {
|
|
logger.Error().Msg("Could not write the yaml file")
|
|
return "", err
|
|
}
|
|
|
|
return workflows_dir + file_name, nil
|
|
}
|