mirror of
https://github.com/R0m1k3/Loki.git
synced 2026-10-15 19:29:16 +02:00
MichaelandClaude Opus 5.5
c3005f5b56
StartTurn persistait AVANT de lancer la génération : un marshal, puis deux commits bbolt (contenu, puis index), soit deux fsync et plusieurs ouvertures de base — 26-30 ms mesurés sur un NVMe Windows, bien plus sur un /mnt/user d'Unraid ou un disque de parité, payés à chaque message avant que la requête ne parte vers llama-server. Même facture au milieu d'un tour (vérification du mode Code) et pour chaque résultat d'outil coupé (« voir plus »). - chat_persist.go : un écrivain unique et ordonné. L'instantané reste pris sous c.mu (images → références, marshal, identifiant de la discussion) ; seule l'E/S part en différé. Le dernier instantané de chaque discussion l'emporte (numéro pris sous c.mu), les lots sont fusionnés en UNE transaction : contenu + index ensemble, résultats d'outils compris. - Seuls StartTurn, la persistance en cours de tour et les résultats d'outils sont asynchrones. Fin de tour, reset, bascules, compactage manuel restent synchrones et attendent tout ce qui précède ; la suppression écarte puis attend les écritures qui la visent (plus de discussion ressuscitée). - Discussion active gardée en RAM, créée sous verrou (plus de double identifiant sur base neuve) et changée sous c.mu avec le contenu : un instantané ne peut plus écrire l'ancien fil sous le nouvel identifiant. - « Voir plus » servi depuis la mémoire tant que le résultat n'est pas écrit ; verrouillage vérifié avant de rendre un id. - En plein tour, la base reçoit le journal sous sa forme de fin de tour (compactLog, version pure de compactLogLocked) ; la mémoire n'est pas touchée. - Vidage de l'écrivain avant redémarrage, « Quitter », exec et (dé)chiffrement. Le contexte vu par le modèle ne change pas : il lit c.Messages en mémoire, les résultats complets d'outils et la compaction du journal ne servent qu'à l'UI. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
88 lines
3.1 KiB
Go
88 lines
3.1 KiB
Go
//go:build windows
|
|
|
|
package loki
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
// Redémarrage propre de l'application après une mise à jour, sous Windows.
|
|
//
|
|
// Un process ne peut pas se relancer lui-même : tant qu'il tourne, le nouveau
|
|
// binaire ne peut pas prendre sa place sur le port, et le dossier de données
|
|
// reste tenu. On délègue donc à un ACCOMPAGNATEUR détaché — une copie de nous
|
|
// lancée avec une sous-commande interne — qui attend notre disparition, profite
|
|
// de cette fenêtre pour terminer la migration, puis relance l'application.
|
|
//
|
|
// C'est cette fenêtre qui manquait. Une mise à jour en place laisse Loki
|
|
// tourner, et donc le dossier tenu : le renommage échouait avec « Accès refusé »,
|
|
// qui sous Windows ne distingue pas un verrou d'un manque de droits. D'où des
|
|
// postes qui restaient indéfiniment sur l'ancien nom.
|
|
|
|
const restartArg = "restart-after-update"
|
|
|
|
// scheduleAppRestart lance l'accompagnateur et annonce que le redémarrage est
|
|
// pris en charge. L'appelant doit ensuite rendre la main puis quitter, pour que
|
|
// la réponse HTTP parte AVANT que le process ne disparaisse.
|
|
func scheduleAppRestart() (bool, string) {
|
|
exe, err := os.Executable()
|
|
if err != nil {
|
|
return false, ""
|
|
}
|
|
cmd := spawnDetached(exe, restartArg, strconv.Itoa(os.Getpid()))
|
|
if err := cmd.Start(); err != nil {
|
|
return false, ""
|
|
}
|
|
// L'accompagnateur ne doit pas mourir avec nous : spawnDetached l'a déjà
|
|
// sorti de notre groupe de processus, on se contente de l'oublier.
|
|
_ = cmd.Process.Release()
|
|
|
|
go func() {
|
|
time.Sleep(1500 * time.Millisecond) // laisser la réponse atteindre le navigateur
|
|
flushPersister(persistExitWait) // écritures différées de la discussion
|
|
os.Exit(0)
|
|
}()
|
|
return true, "Loki redémarre — la page se reconnectera toute seule dans quelques secondes."
|
|
}
|
|
|
|
// cmdRestartAfterUpdate est exécuté par l'accompagnateur détaché.
|
|
//
|
|
// Il n'écrit rien à l'écran : personne ne le regarde, il n'a pas de console, et
|
|
// son seul travail visible est de faire réapparaître l'application.
|
|
func cmdRestartAfterUpdate(args []string) error {
|
|
if len(args) > 0 {
|
|
if pid, err := strconv.Atoi(args[0]); err == nil {
|
|
waitForExit(pid, 30*time.Second)
|
|
}
|
|
}
|
|
target := installedExePath()
|
|
if _, err := os.Stat(target); err != nil {
|
|
// La cible a disparu : mieux vaut relancer ce qu'on a que rien du tout.
|
|
if self, e := os.Executable(); e == nil {
|
|
target = self
|
|
}
|
|
}
|
|
if !launch(target) {
|
|
return fmt.Errorf("relance de %s impossible", target)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// waitForExit attend la fin du process pid, sans dépasser le délai imparti.
|
|
// Un dépassement n'est pas bloquant : on poursuit quand même, quitte à ce que
|
|
// la migration échoue et soit retentée plus tard. Rester coincé ici serait pire
|
|
// — l'utilisateur se retrouverait sans application du tout.
|
|
func waitForExit(pid int, timeout time.Duration) {
|
|
deadline := time.Now().Add(timeout)
|
|
for time.Now().Before(deadline) {
|
|
if !pidAlive(pid) {
|
|
time.Sleep(500 * time.Millisecond) // laisser les handles se fermer
|
|
return
|
|
}
|
|
time.Sleep(200 * time.Millisecond)
|
|
}
|
|
}
|