Prepull for pod & Asym Jobs

workflow_builder/considers_cache.go

@@ -0,0 +1,100 @@
+package workflow_builder
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"sync"
+
+	"cloud.o-forge.io/core/oc-lib/logs"
+	"cloud.o-forge.io/core/oc-lib/tools"
+)
+
+// considersCache stocke les canaux en attente d'un PB_CONSIDERS,
+// indexés par "executionsId:dataType". Un même message NATS réveille
+// tous les waiters enregistrés sous la même clé (broadcast).
+type considersCache struct {
+	mu      sync.Mutex
+	pending map[string][]chan struct{}
+}
+
+var globalConsidersCache = &considersCache{
+	pending: make(map[string][]chan struct{}),
+}
+
+// considersKey construit la clé du cache à partir de l'ID d'exécution,
+// du type de données et du peer compute (SourcePeerID).
+// peerID permet de différencier plusieurs waiters COMPUTE_RESOURCE du même
+// executionsId (1 local + N distants en parallèle).
+func considersKey(executionsId string, dataType tools.DataType, peerID string) string {
+	key := executionsId + ":" + strconv.Itoa(dataType.EnumIndex())
+	if peerID != "" {
+		key += ":" + peerID
+	}
+	return key
+}
+
+// register inscrit un nouveau canal d'attente pour la clé donnée.
+// Retourne le canal à lire et une fonction de désinscription à appeler en defer.
+func (c *considersCache) register(key string) (<-chan struct{}, func()) {
+	ch := make(chan struct{}, 1)
+	c.mu.Lock()
+	c.pending[key] = append(c.pending[key], ch)
+	c.mu.Unlock()
+
+	unregister := func() {
+		c.mu.Lock()
+		defer c.mu.Unlock()
+		list := c.pending[key]
+		for i, existing := range list {
+			if existing == ch {
+				c.pending[key] = append(list[:i], list[i+1:]...)
+				break
+			}
+		}
+		if len(c.pending[key]) == 0 {
+			delete(c.pending, key)
+		}
+	}
+	return ch, unregister
+}
+
+// confirm réveille tous les waiters enregistrés sous la clé donnée
+// et les supprime du cache.
+func (c *considersCache) confirm(key string) {
+	c.mu.Lock()
+	list := c.pending[key]
+	delete(c.pending, key)
+	c.mu.Unlock()
+
+	for _, ch := range list {
+		select {
+		case ch <- struct{}{}:
+		default:
+		}
+	}
+}
+
+// StartConsidersListener démarre un abonné NATS global via ListenNats (oclib)
+// qui reçoit les messages CONSIDERS_EVENT et réveille les goroutines en attente
+// via globalConsidersCache.  Doit être appelé une seule fois au démarrage.
+func StartConsidersListener() {
+	log := logs.GetLogger()
+	log.Info().Msg("Considers NATS listener starting on " + tools.CONSIDERS_EVENT.GenerateKey())
+	go tools.NewNATSCaller().ListenNats(map[tools.NATSMethod]func(tools.NATSResponse){
+		tools.CONSIDERS_EVENT: func(resp tools.NATSResponse) {
+			fmt.Println("CONSIDERS")
+			var body struct {
+				ExecutionsID string `json:"executions_id"`
+				PeerID       string `json:"peer_id,omitempty"`
+			}
+			if err := json.Unmarshal(resp.Payload, &body); err != nil {
+				log.Error().Msg("CONSIDERS_EVENT: cannot unmarshal payload: " + err.Error())
+				return
+			}
+			key := considersKey(body.ExecutionsID, resp.Datatype, body.PeerID)
+			log.Info().Msg(fmt.Sprintf("CONSIDERS_EVENT dispatched for key=%s", key))
+			globalConsidersCache.confirm(key)
+		},
+	})
+}