oc-monitord/models/template.go

package models

import (
	"encoding/json"
	"fmt"
	"os/exec"
	"strings"

	"cloud.o-forge.io/core/oc-lib/config"
	"cloud.o-forge.io/core/oc-lib/models/common/models"
	"cloud.o-forge.io/core/oc-lib/models/resources"
	"cloud.o-forge.io/core/oc-lib/models/resources/native_tools"
	"cloud.o-forge.io/core/oc-lib/models/workflow_execution"
	"cloud.o-forge.io/core/oc-lib/tools"
)

type Parameter struct {
	Name  string `yaml:"name,omitempty"`
	Value string `yaml:"value,omitempty"`
}

type Container struct {
	Image           string        `yaml:"image"`
	ImagePullPolicy string        `yaml:"imagePullPolicy,omitempty"`
	Command         []string      `yaml:"command,omitempty,flow"`
	Args            []string      `yaml:"args,omitempty,flow"`
	VolumeMounts    []VolumeMount `yaml:"volumeMounts,omitempty"`
}

func (c *Container) AddVolumeMount(volumeMount VolumeMount, volumes []VolumeMount) []VolumeMount {
	for _, vm := range c.VolumeMounts {
		if vm.Name == volumeMount.Name {
			return volumes
		}
	}
	c.VolumeMounts = append(c.VolumeMounts, volumeMount)
	for _, vm := range c.VolumeMounts {
		for _, v := range volumes {
			if vm.Name == v.Name {
				return volumes
			}
		}
	}
	volumes = append(volumes, volumeMount)
	return volumes
}

type VolumeMount struct {
	Name       string                     `yaml:"name"`
	MountPath  string                     `yaml:"mountPath"`
	Storage    *resources.StorageResource `yaml:"-"`
	IsReparted bool                       `yaml:"-"`
}

type Task struct {
	Name         string   `yaml:"name"`
	Template     string   `yaml:"template"`
	Dependencies []string `yaml:"dependencies,omitempty"`
	Arguments    struct {
		Parameters []Parameter `yaml:"parameters,omitempty"`
	} `yaml:"arguments,omitempty"`
}

type Dag struct {
	Tasks []Task `yaml:"tasks,omitempty"`
}

type TemplateMetadata struct {
	Labels      map[string]string `yaml:"labels,omitempty"`
	Annotations map[string]string `yaml:"annotations,omitempty"`
}

type Secret struct {
	Name string `yaml:"name"`
	Key  string `yaml:"key"`
}

type Key struct {
	Key             string  `yaml:"key"`
	Bucket          string  `yaml:"bucket"`
	EndPoint        string  `yaml:"endpoint"`
	Insecure        bool    `yaml:"insecure"`
	AccessKeySecret *Secret `yaml:"accessKeySecret"`
	SecretKeySecret *Secret `yaml:"secretKeySecret"`
}

type Artifact struct {
	Name string `yaml:"name"`
	Path string `yaml:"path"`
}

type ArtifactRepositoryRef struct {
	ConfigMap string `yaml:"configMap"`
	Key       string `yaml:"key"`
}

type InOut struct {
	Parameters []Parameter `yaml:"parameters"`
	Artifacts  []Artifact  `yaml:"artifacts,omitempty"`
}

type Template struct {
	Name         string            `yaml:"name"`
	Inputs       InOut             `yaml:"inputs,omitempty"`
	Outputs      InOut             `yaml:"outputs,omitempty"`
	Container    Container         `yaml:"container,omitempty"`
	Dag          *Dag              `yaml:"dag,omitempty"`
	Metadata     TemplateMetadata  `yaml:"metadata,omitempty"`
	Resource     ServiceResource   `yaml:"resource,omitempty"`
	NodeSelector map[string]string `yaml:"nodeSelector,omitempty"`
}

func (template *Template) CreateEventContainer(execution *workflow_execution.WorkflowExecution, nt *resources.NativeTool, dag *Dag) {
	container := Container{Image: "natsio/nats-box", ImagePullPolicy: "IfNotPresent"}
	container.Command = []string{"sh", "-c"} // all is bash

	var event native_tools.WorkflowEventParams
	b, err := json.Marshal(nt.Params)
	if err != nil {
		fmt.Println(err)
		return
	}
	err = json.Unmarshal(b, &event)
	if err != nil {
		fmt.Println(err)
		return
	}
	if event.WorkflowResourceID != "" {
		event.Payload = event.Input
		event.Input = ""
		if b, err := json.Marshal(event); err == nil {
			payload, err := json.Marshal(&tools.NATSResponse{
				FromApp:  "oc-monitord",
				Datatype: tools.NATIVE_TOOL,
				Method:   int(tools.WORKFLOW_EVENT),
				Payload:  b,
			})
			if err == nil {
				cmd := exec.Command(
					"nats",
					"pub",
					"--server", config.GetConfig().NATSUrl+":4222",
					tools.WORKFLOW_EVENT.GenerateKey(),
					string(payload),
				)
				for _, args := range cmd.Args {
					container.Args = append(container.Args, args)
				}
				template.Container = container
			}
		}
	}
}

func (template *Template) CreateContainer(exec *workflow_execution.WorkflowExecution, processing *resources.ProcessingResource, dag *Dag) {
	index := 0
	if d, ok := exec.SelectedInstances[processing.GetID()]; ok {
		index = d
	}
	instance := processing.GetSelectedInstance(&index)
	if instance == nil {
		return
	}
	inst := instance.(*resources.ProcessingInstance)
	container := Container{Image: inst.Access.Container.Image, ImagePullPolicy: "IfNotPresent"}
	if container.Image == "" {
		return
	}
	container.Command = []string{"sh", "-c"} // all is bash
	for _, v := range inst.Env {
		template.Inputs.Parameters = append(template.Inputs.Parameters, Parameter{Name: v.Name})
	}
	for _, v := range inst.Inputs {
		template.Inputs.Parameters = append(template.Inputs.Parameters, Parameter{Name: v.Name})
	}
	for _, v := range inst.Inputs {
		template.Outputs.Parameters = append(template.Inputs.Parameters, Parameter{Name: v.Name})
	}
	cmd := strings.ReplaceAll(inst.Access.Container.Command, container.Image, "")

	for _, a := range strings.Split(cmd, " ") {
		container.Args = append(container.Args, template.ReplacePerEnv(a, inst.Env))
	}
	for _, a := range strings.Split(inst.Access.Container.Args, " ") {
		container.Args = append(container.Args, template.ReplacePerEnv(a, inst.Env))
	}
	container.Args = []string{strings.Join(container.Args, " ")}

	template.Container = container
}

func (template *Template) ReplacePerEnv(arg string, envs []models.Param) string {
	for _, v := range envs {
		if v.Name != "" && strings.Contains(arg, v.Name) {
			value := "{{ inputs.parameters." + v.Name + " }}"
			arg = strings.ReplaceAll(arg, v.Name, value)
			arg = strings.ReplaceAll(arg, "$"+v.Name, value)
			arg = strings.ReplaceAll(arg, "$", "")
		}
	}
	return arg
}

// AddAdmiraltyAnnotations marque le template pour qu'Admiralty route le pod
// vers le cluster virtuel correspondant au peerId.
//
// - elect: ""          déclenche le webhook Admiralty sur le pod créé par Argo.
// - nodeSelector       cible le virtual node Admiralty dont le label
//                      multicluster.admiralty.io/cluster-name vaut peerId,
//                      ce qui contraint le scheduling au cluster distant.
func (t *Template) AddAdmiraltyAnnotations(peerId string) {
	if t.Metadata.Annotations == nil {
		t.Metadata.Annotations = make(map[string]string)
	}
	t.Metadata.Annotations["multicluster.admiralty.io/elect"] = ""
	if t.NodeSelector == nil {
		t.NodeSelector = make(map[string]string)
	}
	t.NodeSelector["multicluster.admiralty.io/cluster-name"] = peerId
}