Historique des versions : snapshots horodatés, différences, restauration
- Avant d'écraser un schéma, le contenu précédent est copié dans DATA_DIR/.history/<chemin>/<date>.excalidraw, au plus une version par HISTORY_INTERVAL (10 min) ; rétention HISTORY_KEEP (50) et HISTORY_MAX_AGE. Pas de git : l'image reste distroless. - API : GET /api/history, GET /api/history/version, POST /api/history/snapshot, POST /api/history/restore (le contenu remplacé devient une version). - L'historique suit renommages et déplacements, part à la corbeille avec le schéma supprimé. - Dialogue Historique (barre du haut, menu de l'explorateur) : aperçu, différences colorées avec l'état actuel, restaurer, restaurer en copie, créer une version. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01H6J7vKwXx7uopxKhWfFJpm
This commit is contained in:
claude BotandClaude Opus 5.5 committed
1 parent
88f7750577
commit
9f9ec3b3a4
14 files changed
+1005
-7
No files matched your search
@@ -10,6 +10,10 @@
|
||||
// POST /api/copy {"from":"x","to":"y"} duplication d'un schéma
|
||||
// DELETE /api/entry?path=x[&recursive=true] mise à la corbeille
|
||||
// GET /api/thumb?path=x / PUT (image/png) miniature d'un schéma
|
||||
// GET /api/history?path=x versions d'un schéma
|
||||
// GET /api/history/version?path=x&id=v contenu d'une version
|
||||
// POST /api/history/snapshot {"path"} version du contenu courant
|
||||
// POST /api/history/restore {"path","id"} restauration (ETag en en-tête)
|
||||
// GET /api/library / PUT /api/library bibliothèque Excalidraw
|
||||
// GET /api/settings / PUT {"title","channel"} paramètres (titre, logo, canal)
|
||||
// GET /api/logo / PUT (image/png) / DELETE logo 64x64
|
||||
@@ -47,6 +51,10 @@ func (h *Handler) Register(mux *http.ServeMux) {
|
||||
mux.HandleFunc("DELETE /api/entry", h.delete)
|
||||
mux.HandleFunc("GET /api/thumb", h.readThumb)
|
||||
mux.HandleFunc("PUT /api/thumb", h.writeThumb)
|
||||
mux.HandleFunc("GET /api/history", h.history)
|
||||
mux.HandleFunc("GET /api/history/version", h.readVersion)
|
||||
mux.HandleFunc("POST /api/history/snapshot", h.snapshot)
|
||||
mux.HandleFunc("POST /api/history/restore", h.restore)
|
||||
mux.HandleFunc("GET /api/library", h.readLibrary)
|
||||
mux.HandleFunc("PUT /api/library", h.writeLibrary)
|
||||
mux.HandleFunc("GET /api/settings", h.readSettings)
|
||||
@@ -267,6 +275,61 @@ func (h *Handler) delete(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (h *Handler) history(w http.ResponseWriter, r *http.Request) {
|
||||
vs, err := h.Store.Versions(r.URL.Query().Get("path"))
|
||||
if err != nil {
|
||||
fail(w, err)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Cache-Control", "no-cache")
|
||||
writeJSON(w, http.StatusOK, vs)
|
||||
}
|
||||
|
||||
func (h *Handler) readVersion(w http.ResponseWriter, r *http.Request) {
|
||||
q := r.URL.Query()
|
||||
data, err := h.Store.ReadVersion(q.Get("path"), q.Get("id"))
|
||||
if err != nil {
|
||||
fail(w, err)
|
||||
return
|
||||
}
|
||||
// Une version ne change jamais.
|
||||
w.Header().Set("Cache-Control", "private, max-age=86400, immutable")
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_, _ = w.Write(data)
|
||||
}
|
||||
|
||||
func (h *Handler) snapshot(w http.ResponseWriter, r *http.Request) {
|
||||
var req pathReq
|
||||
if !h.decode(w, r, &req) {
|
||||
return
|
||||
}
|
||||
v, err := h.Store.Snapshot(req.Path)
|
||||
if err != nil {
|
||||
fail(w, err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, v)
|
||||
}
|
||||
|
||||
type restoreReq struct {
|
||||
Path string `json:"path"`
|
||||
ID string `json:"id"`
|
||||
}
|
||||
|
||||
func (h *Handler) restore(w http.ResponseWriter, r *http.Request) {
|
||||
var req restoreReq
|
||||
if !h.decode(w, r, &req) {
|
||||
return
|
||||
}
|
||||
entry, etag, err := h.Store.Restore(req.Path, req.ID)
|
||||
if err != nil {
|
||||
fail(w, err)
|
||||
return
|
||||
}
|
||||
w.Header().Set("ETag", etag)
|
||||
writeJSON(w, http.StatusOK, entry)
|
||||
}
|
||||
|
||||
func (h *Handler) readLibrary(w http.ResponseWriter, r *http.Request) {
|
||||
data, err := h.Store.ReadLibrary()
|
||||
if err != nil {
|
||||
|
||||
@@ -0,0 +1,253 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Historique des versions : avant qu'un schéma soit écrasé, son contenu
|
||||
// précédent est copié dans .history/ en miroir de l'arborescence
|
||||
// (a/b.excalidraw -> .history/a/b.excalidraw/<date>.excalidraw).
|
||||
//
|
||||
// Avec l'enregistrement automatique (toutes les 1,5 s pendant l'édition), une
|
||||
// copie par écriture serait inutilisable : une version n'est prise que si la
|
||||
// précédente date d'au moins HistoryPolicy.Interval. Restaurer une version ou
|
||||
// créer une version à la demande copie toujours le contenu courant.
|
||||
|
||||
const historyDir = ".history"
|
||||
|
||||
// HistoryPolicy règle la prise et la rétention des versions.
|
||||
type HistoryPolicy struct {
|
||||
Keep int // versions conservées par schéma (0 : historique désactivé)
|
||||
Interval time.Duration // écart minimal entre deux versions automatiques
|
||||
MaxAge time.Duration // âge maximal d'une version (0 : illimité)
|
||||
}
|
||||
|
||||
// DefaultHistory : 50 versions par schéma, au plus une toutes les 10 minutes.
|
||||
var DefaultHistory = HistoryPolicy{Keep: 50, Interval: 10 * time.Minute}
|
||||
|
||||
// Version décrit une version enregistrée d'un schéma. Time est la date à
|
||||
// laquelle ce contenu avait été enregistré.
|
||||
type Version struct {
|
||||
ID string `json:"id"`
|
||||
Time time.Time `json:"time"`
|
||||
Size int64 `json:"size"`
|
||||
}
|
||||
|
||||
const versionLayout = "20060102T150405.000000000Z"
|
||||
|
||||
var versionID = regexp.MustCompile(`^\d{8}T\d{6}\.\d{9}Z$`)
|
||||
|
||||
func (s *Store) historyAbs(c string) string {
|
||||
return filepath.Join(s.root, historyDir, filepath.FromSlash(c))
|
||||
}
|
||||
|
||||
// versions liste les versions d'un schéma, la plus récente en premier.
|
||||
// taken renvoie en plus la date de prise de la plus récente (date du fichier).
|
||||
func (s *Store) versions(c string) ([]Version, time.Time, error) {
|
||||
des, err := os.ReadDir(s.historyAbs(c))
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return []Version{}, time.Time{}, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, time.Time{}, err
|
||||
}
|
||||
out := []Version{}
|
||||
var taken time.Time
|
||||
for _, de := range des {
|
||||
id, ok := strings.CutSuffix(de.Name(), Ext)
|
||||
if !ok || de.IsDir() || !versionID.MatchString(id) {
|
||||
continue
|
||||
}
|
||||
t, err := time.Parse(versionLayout, id)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
fi, err := de.Info()
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
out = append(out, Version{ID: id, Time: t, Size: fi.Size()})
|
||||
if fi.ModTime().After(taken) {
|
||||
taken = fi.ModTime()
|
||||
}
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool { return out[i].ID > out[j].ID })
|
||||
return out, taken, nil
|
||||
}
|
||||
|
||||
// snapshot enregistre data (contenu d'un schéma daté de mod) comme version.
|
||||
// Sans force, rien n'est pris si la dernière version a moins de Interval.
|
||||
// Une version identique à la plus récente n'est jamais dupliquée.
|
||||
func (s *Store) snapshot(c string, data []byte, mod time.Time, force bool) (Version, error) {
|
||||
p := s.History
|
||||
if p.Keep <= 0 {
|
||||
return Version{}, nil
|
||||
}
|
||||
vs, taken, err := s.versions(c)
|
||||
if err != nil {
|
||||
return Version{}, err
|
||||
}
|
||||
if !force && len(vs) > 0 && time.Since(taken) < p.Interval {
|
||||
return Version{}, nil
|
||||
}
|
||||
if len(vs) > 0 && vs[0].Size == int64(len(data)) {
|
||||
if last, err := os.ReadFile(s.versionAbs(c, vs[0].ID)); err == nil && bytes.Equal(last, data) {
|
||||
return vs[0], nil
|
||||
}
|
||||
}
|
||||
v := Version{ID: mod.UTC().Format(versionLayout), Time: mod.UTC(), Size: int64(len(data))}
|
||||
dir := s.historyAbs(c)
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
return Version{}, err
|
||||
}
|
||||
if err := atomicWrite(s.versionAbs(c, v.ID), data); err != nil {
|
||||
return Version{}, err
|
||||
}
|
||||
s.pruneHistory(c)
|
||||
return v, nil
|
||||
}
|
||||
|
||||
func (s *Store) versionAbs(c, id string) string {
|
||||
return filepath.Join(s.historyAbs(c), id+Ext)
|
||||
}
|
||||
|
||||
// pruneHistory applique la rétention (nombre et âge) aux versions d'un schéma.
|
||||
func (s *Store) pruneHistory(c string) {
|
||||
vs, _, err := s.versions(c)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
for i, v := range vs {
|
||||
if i >= s.History.Keep || (s.History.MaxAge > 0 && time.Since(v.Time) > s.History.MaxAge) {
|
||||
_ = os.Remove(s.versionAbs(c, v.ID))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// autoSnapshot est appelé par Write avant d'écraser un schéma ; un échec est
|
||||
// journalisé mais n'empêche pas l'enregistrement.
|
||||
func (s *Store) autoSnapshot(c string, cur []byte, mod time.Time) {
|
||||
if _, err := s.snapshot(c, cur, mod, false); err != nil {
|
||||
slog.Warn("historique : version non enregistrée", "path", c, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Store) schema(rel string) (string, string, error) {
|
||||
c, abs, err := s.resolve(rel)
|
||||
if err == nil {
|
||||
err = requireSchemaPath(c)
|
||||
}
|
||||
return c, abs, err
|
||||
}
|
||||
|
||||
// Versions liste les versions d'un schéma existant, la plus récente en premier.
|
||||
func (s *Store) Versions(rel string) ([]Version, error) {
|
||||
c, abs, err := s.schema(rel)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := os.Stat(abs); err != nil {
|
||||
return nil, mapErr(err)
|
||||
}
|
||||
vs, _, err := s.versions(c)
|
||||
return vs, err
|
||||
}
|
||||
|
||||
// ReadVersion renvoie le contenu d'une version.
|
||||
func (s *Store) ReadVersion(rel, id string) ([]byte, error) {
|
||||
c, _, err := s.schema(rel)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !versionID.MatchString(id) {
|
||||
return nil, fmt.Errorf("%w : version %q", ErrInvalidPath, id)
|
||||
}
|
||||
b, err := os.ReadFile(s.versionAbs(c, id))
|
||||
return b, mapErr(err)
|
||||
}
|
||||
|
||||
// Snapshot crée une version du contenu courant, quel que soit l'intervalle.
|
||||
func (s *Store) Snapshot(rel string) (Version, error) {
|
||||
c, abs, err := s.schema(rel)
|
||||
if err != nil {
|
||||
return Version{}, err
|
||||
}
|
||||
if s.History.Keep <= 0 {
|
||||
return Version{}, fmt.Errorf("%w : historique désactivé (HISTORY_KEEP=0)", ErrInvalidPath)
|
||||
}
|
||||
fi, err := os.Stat(abs)
|
||||
if err != nil {
|
||||
return Version{}, mapErr(err)
|
||||
}
|
||||
b, err := os.ReadFile(abs)
|
||||
if err != nil {
|
||||
return Version{}, mapErr(err)
|
||||
}
|
||||
return s.snapshot(c, b, fi.ModTime(), true)
|
||||
}
|
||||
|
||||
// Restore remplace le contenu d'un schéma par une de ses versions. Le contenu
|
||||
// courant est d'abord enregistré comme version : une restauration s'annule.
|
||||
func (s *Store) Restore(rel, id string) (Entry, string, error) {
|
||||
data, err := s.ReadVersion(rel, id)
|
||||
if err != nil {
|
||||
return Entry{}, "", err
|
||||
}
|
||||
c, abs, _ := s.schema(rel)
|
||||
fi, err := os.Stat(abs)
|
||||
if err != nil {
|
||||
return Entry{}, "", mapErr(err)
|
||||
}
|
||||
cur, err := os.ReadFile(abs)
|
||||
if err != nil {
|
||||
return Entry{}, "", mapErr(err)
|
||||
}
|
||||
if !bytes.Equal(cur, data) {
|
||||
if _, err := s.snapshot(c, cur, fi.ModTime(), true); err != nil {
|
||||
return Entry{}, "", err
|
||||
}
|
||||
if err := atomicWrite(abs, data); err != nil {
|
||||
return Entry{}, "", err
|
||||
}
|
||||
}
|
||||
if fi, err = os.Stat(abs); err != nil {
|
||||
return Entry{}, "", err
|
||||
}
|
||||
return toEntry(c, fi), ETag(data), nil
|
||||
}
|
||||
|
||||
// Les opérations suivantes accompagnent Move/Delete.
|
||||
|
||||
func (s *Store) moveHistory(from, to string) {
|
||||
src, dst := s.historyAbs(from), s.historyAbs(to)
|
||||
if _, err := os.Stat(src); err != nil {
|
||||
return
|
||||
}
|
||||
_ = os.RemoveAll(dst)
|
||||
if err := os.MkdirAll(filepath.Dir(dst), 0o755); err == nil {
|
||||
_ = os.Rename(src, dst)
|
||||
}
|
||||
}
|
||||
|
||||
// trashHistory range l'historique d'un élément supprimé avec lui dans la
|
||||
// corbeille (trash/.history/<nom>), pour pouvoir le récupérer à la main.
|
||||
func (s *Store) trashHistory(c, trash string) {
|
||||
src := s.historyAbs(c)
|
||||
if _, err := os.Stat(src); err != nil {
|
||||
return
|
||||
}
|
||||
dst := filepath.Join(trash, historyDir, filepath.Base(src))
|
||||
if err := os.MkdirAll(filepath.Dir(dst), 0o755); err == nil {
|
||||
_ = os.Rename(src, dst)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestHistoryInterval(t *testing.T) {
|
||||
s := newStore(t)
|
||||
s.History = HistoryPolicy{Keep: 3, Interval: time.Hour}
|
||||
p := "a/b.excalidraw"
|
||||
if _, _, err := s.Write(p, []byte(`{"v":1}`), "", true); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if vs, _ := s.Versions(p); len(vs) != 0 {
|
||||
t.Fatalf("création : aucune version attendue, %+v", vs)
|
||||
}
|
||||
s.Write(p, []byte(`{"v":2}`), "", false) // v1 conservée
|
||||
s.Write(p, []byte(`{"v":3}`), "", false) // < Interval : rien
|
||||
vs, err := s.Versions(p)
|
||||
if err != nil || len(vs) != 1 {
|
||||
t.Fatalf("Versions = %+v, %v", vs, err)
|
||||
}
|
||||
if b, _ := s.ReadVersion(p, vs[0].ID); string(b) != `{"v":1}` {
|
||||
t.Fatalf("version = %s", b)
|
||||
}
|
||||
|
||||
// Intervalle nul : une version par écriture, rétention à 3.
|
||||
s.History.Interval = 0
|
||||
for i := 4; i <= 8; i++ {
|
||||
time.Sleep(2 * time.Millisecond) // dates de fichier distinctes
|
||||
s.Write(p, []byte(`{"v":`+string(rune('0'+i))+`}`), "", false)
|
||||
}
|
||||
vs, _ = s.Versions(p)
|
||||
if len(vs) != 3 {
|
||||
t.Fatalf("rétention : %d versions", len(vs))
|
||||
}
|
||||
if b, _ := s.ReadVersion(p, vs[0].ID); string(b) != `{"v":7}` {
|
||||
t.Fatalf("plus récente = %s", b)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHistoryRestoreMoveDelete(t *testing.T) {
|
||||
s := newStore(t)
|
||||
s.History = HistoryPolicy{Keep: 10, Interval: time.Hour}
|
||||
p := "b.excalidraw"
|
||||
s.Write(p, []byte(`{"v":1}`), "", true)
|
||||
v1, err := s.Snapshot(p)
|
||||
if err != nil || v1.ID == "" {
|
||||
t.Fatalf("Snapshot = %+v, %v", v1, err)
|
||||
}
|
||||
if again, _ := s.Snapshot(p); again.ID != v1.ID {
|
||||
t.Fatalf("version identique dupliquée : %+v", again)
|
||||
}
|
||||
time.Sleep(2 * time.Millisecond)
|
||||
s.Write(p, []byte(`{"v":2}`), "", false) // < Interval : pas de version
|
||||
|
||||
_, etag, err := s.Restore(p, v1.ID)
|
||||
if err != nil || etag != ETag([]byte(`{"v":1}`)) {
|
||||
t.Fatalf("Restore : %s, %v", etag, err)
|
||||
}
|
||||
vs, _ := s.Versions(p)
|
||||
if len(vs) != 2 {
|
||||
t.Fatalf("la restauration doit conserver le contenu remplacé : %+v", vs)
|
||||
}
|
||||
if b, _ := s.ReadVersion(p, vs[0].ID); string(b) != `{"v":2}` {
|
||||
t.Fatalf("contenu remplacé = %s", b)
|
||||
}
|
||||
|
||||
for _, bad := range []string{"../x", "2026", ""} {
|
||||
if _, err := s.ReadVersion(p, bad); !errors.Is(err, ErrInvalidPath) {
|
||||
t.Errorf("ReadVersion(%q) : %v", bad, err)
|
||||
}
|
||||
}
|
||||
|
||||
// L'historique suit les déplacements (fichier puis dossier parent).
|
||||
s.Mkdir("d")
|
||||
if _, err := s.Move(p, "d/c.excalidraw"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s.Move("d", "e")
|
||||
if vs, _ := s.Versions("e/c.excalidraw"); len(vs) != 2 {
|
||||
t.Fatalf("après déplacement : %+v", vs)
|
||||
}
|
||||
// Supprimé : l'historique part dans la corbeille avec le schéma.
|
||||
if err := s.Delete("e/c.excalidraw", false); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := os.Stat(s.historyAbs("e/c.excalidraw")); !errors.Is(err, os.ErrNotExist) {
|
||||
t.Fatalf("historique resté en place : %v", err)
|
||||
}
|
||||
m, _ := filepath.Glob(filepath.Join(s.root, trashDir, "*", historyDir, "c.excalidraw"))
|
||||
if len(m) != 1 {
|
||||
t.Fatalf("historique absent de la corbeille : %v", m)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHistoryDisabled(t *testing.T) {
|
||||
s := newStore(t)
|
||||
s.History = HistoryPolicy{}
|
||||
s.Write("x.excalidraw", []byte(`{"v":1}`), "", true)
|
||||
s.Write("x.excalidraw", []byte(`{"v":2}`), "", false)
|
||||
if vs, _ := s.Versions("x.excalidraw"); len(vs) != 0 {
|
||||
t.Fatalf("historique désactivé : %+v", vs)
|
||||
}
|
||||
if _, err := s.Snapshot("x.excalidraw"); !errors.Is(err, ErrInvalidPath) {
|
||||
t.Fatalf("Snapshot désactivé : %v", err)
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
@@ -52,6 +53,9 @@ type Entry struct {
|
||||
type Store struct {
|
||||
root string
|
||||
|
||||
// History règle l'historique des versions (DefaultHistory par défaut).
|
||||
History HistoryPolicy
|
||||
|
||||
settingsMu sync.Mutex // sérialise les lectures-modifications de .settings.json
|
||||
}
|
||||
|
||||
@@ -69,7 +73,7 @@ func New(root string) (*Store, error) {
|
||||
if abs, err = filepath.EvalSymlinks(abs); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &Store{root: abs}, nil
|
||||
return &Store{root: abs, History: DefaultHistory}, nil
|
||||
}
|
||||
|
||||
// Clean normalise un chemin relatif : "/a/../b/" -> "b", "" -> "".
|
||||
@@ -269,6 +273,10 @@ func (s *Store) Write(rel string, data []byte, ifMatch string, create bool) (Ent
|
||||
return Entry{}, "", ErrConflict
|
||||
case err != nil && !errors.Is(err, fs.ErrNotExist):
|
||||
return Entry{}, "", err
|
||||
case err == nil && !bytes.Equal(cur, data):
|
||||
if fi, err := os.Stat(abs); err == nil {
|
||||
s.autoSnapshot(c, cur, fi.ModTime())
|
||||
}
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
|
||||
return Entry{}, "", err
|
||||
@@ -363,6 +371,7 @@ func (s *Store) Move(from, to string) (Entry, error) {
|
||||
return Entry{}, mapErr(err)
|
||||
}
|
||||
s.moveThumb(cf, ct, fi.IsDir())
|
||||
s.moveHistory(cf, ct)
|
||||
fi, err = os.Stat(at)
|
||||
if err != nil {
|
||||
return Entry{}, err
|
||||
@@ -463,6 +472,7 @@ func (s *Store) Delete(rel string, recursive bool) error {
|
||||
return err
|
||||
}
|
||||
s.removeThumb(c, fi.IsDir())
|
||||
s.trashHistory(c, trash)
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user