mirror of
https://github.com/R0m1k3/Loki.git
synced 2026-10-16 19:59:56 +02:00
Claude
9a0455be8f
Avec LOKI_TASKS=rust (expérimental), la façade sert les routes /api/tasks* et fait tourner le planificateur, que le Go ne démarre plus. Elle exécute elle-même les tâches « script seul » (shell de l'agent, limite de 10 min, arrêt à la main). Une tâche IA passe par le verrou de génération et les outils de l'agent, restés au Go : la façade la lui fait exécuter (/internal/v1/tasks/run), comme son propre planificateur l'aurait fait. Les notifications partent par la façade si elle les tient, sinon par le Go (/internal/v1/push/send). - src/tz.rs : les fuseaux IANA comme le Go (TZif v1/v2 et règle POSIX, time.Local, time.Date et ses heures qui sautent ou se répètent) ; - tasks/cron.rs : les quatre formes de fréquence, avec ParseDuration du Go et ses messages d'erreur ; instants sur 128 bits (dates au-delà de 2262) ; - tasks/mod.rs : la base, l'exécution, le planificateur (un tic par minute, une tâche due par tic) et les sept routes. Le Go reçoit un crochet de test pour l'heure des tâches (tasksNow). Correction de la façade : les appels à l'API interne du Go étaient tous bornés à 10 s. Un outil exécuté par le Go qui dure plus longtemps (page lente, navigateur, MCP tenu par le Go) était coupé, alors qu'il continuait. Ces appels sont désormais bornés à 30 min ; une tâche IA est attendue jusqu'à 24 h. Parité : parity_tasks_test.go tire du Go un journal rejoué par tests/tasks.rs, l'heure des tâches fixée pas à pas. Il couvre l'enregistrement (chaque forme et chaque erreur de fréquence, plusieurs fuseaux), la bascule, l'interrupteur maître, la suppression, les lancements et les tics du planificateur. Les mutations (79, dont 77 tuées et 2 équivalentes) ont fait trouver et corriger cinq écarts du port : dates lointaines, intervalle en jours démesuré, heure qui saute au printemps, compte-rendu coupé au milieu d'un caractère, noms de fuseau contenant « .. ». Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016tcGfJWefW5kUGoC2wL8cv
74 lines
2.4 KiB
Go
74 lines
2.4 KiB
Go
package loki
|
|
|
|
// tasks_sched.go — la boucle de planification. Une seule goroutine, un tick par
|
|
// minute, dans le process qui possède la conversation et l'UI (ajean-ui /
|
|
// `ajean link`). Voir StartTaskScheduler, câblée dans newWebMux (web_server.go).
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var taskSchedOnce sync.Once
|
|
|
|
// StartTaskScheduler démarre la boucle de planification (idempotent : sûr à
|
|
// appeler à chaque construction du mux, ne lance qu'une goroutine).
|
|
func StartTaskScheduler() {
|
|
taskSchedOnce.Do(func() { go taskSchedLoop() })
|
|
}
|
|
|
|
// taskSchedLoop réveille les tâches dues, une par tick (elles sont de toute façon
|
|
// sérialisées par le gate de génération). Le tick d'une minute suffit : c'est la
|
|
// résolution de la planification (voir tasks_cron.go).
|
|
func taskSchedLoop() {
|
|
// Premier passage immédiat pour amorcer les NextRun manquants (après un
|
|
// redémarrage du process, ou pour une tâche fraîchement créée sans NextRun).
|
|
primeNextRuns()
|
|
t := time.NewTicker(time.Minute)
|
|
defer t.Stop()
|
|
for range t.C {
|
|
tickTasks(tasksNow())
|
|
}
|
|
}
|
|
|
|
// primeNextRuns renseigne NextRun de toute tâche activée qui n'en a pas (0),
|
|
// relativement à maintenant — sinon une tâche à NextRun=0 serait considérée « due »
|
|
// en permanence, ou jamais planifiée selon le sens de la comparaison.
|
|
func primeNextRuns() {
|
|
now := tasksNow()
|
|
for _, t := range listTasks() {
|
|
if t.Enabled && t.NextRun == 0 {
|
|
t.NextRun = computeNextRun(t.Schedule, t.TZ, now)
|
|
_ = saveTask(t)
|
|
}
|
|
}
|
|
}
|
|
|
|
// tickTasks lance la première tâche due (si l'interrupteur maître n'est pas en
|
|
// pause). Une seule par tick : lancer plusieurs inférences en parallèle est de
|
|
// toute façon impossible (gate de génération), et étaler leur départ évite qu'une
|
|
// rafale de tâches monopolise le modèle d'un coup.
|
|
func tickTasks(now time.Time) {
|
|
if tasksPaused() || tuneGuard() != nil {
|
|
// Optimisation en cours : la tâche due attend sa fin, elle n'échoue pas.
|
|
return
|
|
}
|
|
nowMs := now.UnixMilli()
|
|
for _, t := range listTasks() {
|
|
if !t.Enabled {
|
|
continue
|
|
}
|
|
if t.NextRun == 0 {
|
|
// Priming raté (schedule invalide) ou tâche neuve : on tente de le poser,
|
|
// sans la déclencher ce tour-ci.
|
|
t.NextRun = computeNextRun(t.Schedule, t.TZ, now)
|
|
_ = saveTask(t)
|
|
continue
|
|
}
|
|
if t.NextRun <= nowMs {
|
|
runTask(t) // met à jour LastRun/NextRun/… et persiste
|
|
return
|
|
}
|
|
}
|
|
}
|