Lot 2 (fin) : jetons, réglages et secrets communs en mode cluster
- tokens.Store : UseCatalog, reprise unique de .tokens.json, recherche par empreinte indexée, date d'utilisation mise à jour sans verrou global. - Réglages d'administration et logo en base (app_settings, app_blobs), reprise unique de .settings.json et .logo.png. - Avec DATABASE_URL, SHARE_SECRET et SESSION_SECRET sont obligatoires (SESSION_SECRET non exigé avec AUTH_MODE=none) ; la forme hex:<clé> reprend un ancien .share-secret / .session-secret sans casser les liens ni les sessions. Variables *_FILE acceptées. - docker-compose : les deux secrets sont exigés au lancement. - Tests : comptes, jetons et réglages partagés entre deux instances. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
This commit is contained in:
1 parent
3bbbac5998
commit
479aa2477c
10 files changed
+438
-69
No files matched your search
+170
-49
@@ -4,8 +4,9 @@
|
||||
// sans session de navigateur.
|
||||
//
|
||||
// Les jetons ne sont conservés que hachés (SHA-256) dans DATA_DIR/.tokens.json
|
||||
// (0600), rattachés à l'utilisateur qui les a créés : ils donnent accès à ses
|
||||
// fichiers comme sa session, mais ne peuvent pas gérer les jetons ni les comptes.
|
||||
// (0600) ou dans le catalogue PostgreSQL, rattachés à l'utilisateur qui les a
|
||||
// créés : ils donnent accès à ses fichiers comme sa session, mais ne peuvent
|
||||
// pas gérer les jetons ni les comptes.
|
||||
package tokens
|
||||
|
||||
import (
|
||||
@@ -16,6 +17,8 @@ import (
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
@@ -25,7 +28,9 @@ import (
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/vblogio/upandown/internal/auth"
|
||||
"github.com/vblogio/upandown/internal/catalog"
|
||||
)
|
||||
|
||||
const (
|
||||
@@ -64,35 +69,129 @@ func (t *Token) info() Info {
|
||||
return Info{ID: t.ID, Name: t.Name, Created: t.Created, LastUsed: t.LastUsed}
|
||||
}
|
||||
|
||||
// Store conserve les jetons dans dir/.tokens.json.
|
||||
// Store conserve les jetons dans dir/.tokens.json, ou dans la table tokens du
|
||||
// catalogue PostgreSQL (UseCatalog), partagée par toutes les instances.
|
||||
type Store struct {
|
||||
mu sync.Mutex
|
||||
file string
|
||||
tokens []*Token
|
||||
tokens map[string]*Token // mode fichier, par ID
|
||||
db *catalog.DB // mode catalogue
|
||||
}
|
||||
|
||||
const (
|
||||
table = "tokens"
|
||||
dbTimeout = 30 * time.Second
|
||||
)
|
||||
|
||||
// Open charge (ou crée) le fichier des jetons de dir.
|
||||
func Open(dir string) (*Store, error) {
|
||||
s := &Store{file: filepath.Join(dir, fileName)}
|
||||
s := &Store{file: filepath.Join(dir, fileName), tokens: map[string]*Token{}}
|
||||
b, err := os.ReadFile(s.file)
|
||||
switch {
|
||||
case errors.Is(err, os.ErrNotExist):
|
||||
case err != nil:
|
||||
return nil, err
|
||||
default:
|
||||
var d struct {
|
||||
Tokens []*Token `json:"tokens"`
|
||||
}
|
||||
if err := json.Unmarshal(b, &d); err != nil {
|
||||
list, err := decode(b)
|
||||
if err != nil {
|
||||
return nil, errors.New(s.file + " invalide : " + err.Error())
|
||||
}
|
||||
s.tokens = d.Tokens
|
||||
s.tokens = list
|
||||
}
|
||||
return s, nil
|
||||
}
|
||||
|
||||
func (s *Store) save() error {
|
||||
b, err := json.Marshal(map[string]any{"tokens": s.tokens})
|
||||
func decode(b []byte) (map[string]*Token, error) {
|
||||
var d struct {
|
||||
Tokens []*Token `json:"tokens"`
|
||||
}
|
||||
if err := json.Unmarshal(b, &d); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
m := make(map[string]*Token, len(d.Tokens))
|
||||
for _, t := range d.Tokens {
|
||||
m[t.ID] = t
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// UseCatalog range désormais les jetons dans le catalogue ; .tokens.json est
|
||||
// repris une seule fois puis renommé en .tokens.json.imported. À appeler au
|
||||
// démarrage, avant de servir des requêtes.
|
||||
func (s *Store) UseCatalog(db *catalog.DB) error {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
|
||||
defer cancel()
|
||||
err := db.ImportFileOnce(ctx, "global", "tokens", s.file, func(ctx context.Context, tx pgx.Tx, b []byte) error {
|
||||
m, err := decode(b)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return catalog.InsertDocs(ctx, tx, table, m)
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("reprise des jetons : %w", err)
|
||||
}
|
||||
s.mu.Lock()
|
||||
s.db, s.tokens = db, nil
|
||||
s.mu.Unlock()
|
||||
return nil
|
||||
}
|
||||
|
||||
// snapshot renvoie une copie de tous les jetons.
|
||||
func (s *Store) snapshot() (map[string]*Token, error) {
|
||||
if s.db != nil {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), dbTimeout)
|
||||
defer cancel()
|
||||
return catalog.AllDocs[Token](ctx, s.db, table)
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
return clone(s.tokens), nil
|
||||
}
|
||||
|
||||
// update applique fn à tous les jetons, de façon atomique (rien n'est
|
||||
// enregistré si fn échoue).
|
||||
func (s *Store) update(fn func(map[string]*Token) error) error {
|
||||
if s.db != nil {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), dbTimeout)
|
||||
defer cancel()
|
||||
return catalog.UpdateDocs(ctx, s.db, table, fn)
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
next := clone(s.tokens)
|
||||
if err := fn(next); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.save(next); err != nil {
|
||||
return err
|
||||
}
|
||||
s.tokens = next
|
||||
return nil
|
||||
}
|
||||
|
||||
func clone(m map[string]*Token) map[string]*Token {
|
||||
out := make(map[string]*Token, len(m))
|
||||
for id, t := range m {
|
||||
c := *t
|
||||
out[id] = &c
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// save écrit le fichier ; appelé sous mu.
|
||||
func (s *Store) save(m map[string]*Token) error {
|
||||
list := make([]*Token, 0, len(m))
|
||||
for _, t := range m {
|
||||
list = append(list, t)
|
||||
}
|
||||
sort.Slice(list, func(i, j int) bool {
|
||||
if !list[i].Created.Equal(list[j].Created) {
|
||||
return list[i].Created.Before(list[j].Created)
|
||||
}
|
||||
return list[i].ID < list[j].ID
|
||||
})
|
||||
b, err := json.Marshal(map[string]any{"tokens": list})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -132,22 +231,23 @@ func (s *Store) Create(userID, name string) (string, Info, error) {
|
||||
if name == "" || !utf8.ValidString(name) || utf8.RuneCountInString(name) > MaxNameLen {
|
||||
return "", Info{}, ErrInvalid
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
n := 0
|
||||
for _, t := range s.tokens {
|
||||
if t.UserID == userID {
|
||||
n++
|
||||
}
|
||||
}
|
||||
if n >= maxPerUser {
|
||||
return "", Info{}, ErrTooMany
|
||||
}
|
||||
secret := prefix + randomString(32)
|
||||
t := &Token{ID: randomString(9), Name: name, UserID: userID, Hash: hashOf(secret), Created: time.Now().UTC().Truncate(time.Second)}
|
||||
s.tokens = append(s.tokens, t)
|
||||
if err := s.save(); err != nil {
|
||||
s.tokens = s.tokens[:len(s.tokens)-1]
|
||||
err := s.update(func(m map[string]*Token) error {
|
||||
n := 0
|
||||
for _, o := range m {
|
||||
if o.UserID == userID {
|
||||
n++
|
||||
}
|
||||
}
|
||||
if n >= maxPerUser {
|
||||
return ErrTooMany
|
||||
}
|
||||
c := *t
|
||||
m[t.ID] = &c
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return "", Info{}, err
|
||||
}
|
||||
return secret, t.info(), nil
|
||||
@@ -155,10 +255,12 @@ func (s *Store) Create(userID, name string) (string, Info, error) {
|
||||
|
||||
// List renvoie les jetons de userID, les plus récents en premier.
|
||||
func (s *Store) List(userID string) []Info {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
m, err := s.snapshot()
|
||||
if err != nil {
|
||||
slog.Error("jetons : lecture", "err", err)
|
||||
}
|
||||
out := []Info{}
|
||||
for _, t := range s.tokens {
|
||||
for _, t := range m {
|
||||
if t.UserID == userID {
|
||||
out = append(out, t.info())
|
||||
}
|
||||
@@ -169,30 +271,27 @@ func (s *Store) List(userID string) []Info {
|
||||
|
||||
// Revoke supprime un jeton de userID.
|
||||
func (s *Store) Revoke(userID, id string) error {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
for i, t := range s.tokens {
|
||||
if t.ID == id && t.UserID == userID {
|
||||
s.tokens = append(s.tokens[:i:i], s.tokens[i+1:]...)
|
||||
return s.save()
|
||||
return s.update(func(m map[string]*Token) error {
|
||||
if t, ok := m[id]; !ok || t.UserID != userID {
|
||||
return ErrNotFound
|
||||
}
|
||||
}
|
||||
return ErrNotFound
|
||||
delete(m, id)
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// RevokeUser supprime tous les jetons d'un utilisateur (compte supprimé ou désactivé).
|
||||
func (s *Store) RevokeUser(userID string) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
kept := s.tokens[:0:0]
|
||||
for _, t := range s.tokens {
|
||||
if t.UserID != userID {
|
||||
kept = append(kept, t)
|
||||
err := s.update(func(m map[string]*Token) error {
|
||||
for id, t := range m {
|
||||
if t.UserID == userID {
|
||||
delete(m, id)
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(kept) != len(s.tokens) {
|
||||
s.tokens = kept
|
||||
_ = s.save()
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
slog.Error("jetons : révocation", "user", userID, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -202,13 +301,35 @@ func (s *Store) Lookup(secret string) (Token, bool) {
|
||||
return Token{}, false
|
||||
}
|
||||
h := hashOf(secret)
|
||||
if s.db != nil {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), dbTimeout)
|
||||
defer cancel()
|
||||
t, err := catalog.FindDoc[Token](ctx, s.db, table, "hash", h)
|
||||
if err != nil {
|
||||
slog.Error("jetons : lecture", "err", err)
|
||||
}
|
||||
if t == nil {
|
||||
return Token{}, false
|
||||
}
|
||||
if time.Since(t.LastUsed) > touchEvery {
|
||||
t.LastUsed = time.Now().UTC().Truncate(time.Second)
|
||||
if err := catalog.ReplaceDoc(ctx, s.db, table, t.ID, t); err != nil {
|
||||
slog.Warn("jetons : date d'utilisation non enregistrée", "err", err)
|
||||
}
|
||||
}
|
||||
return *t, true
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
for _, t := range s.tokens {
|
||||
if t.Hash == h {
|
||||
if time.Since(t.LastUsed) > touchEvery {
|
||||
t.LastUsed = time.Now().UTC().Truncate(time.Second)
|
||||
_ = s.save()
|
||||
next := clone(s.tokens)
|
||||
next[t.ID].LastUsed = time.Now().UTC().Truncate(time.Second)
|
||||
if s.save(next) == nil {
|
||||
s.tokens = next
|
||||
t = next[t.ID]
|
||||
}
|
||||
}
|
||||
return *t, true
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user