diff --git a/.dockerignore b/.dockerignore index fd7aa8c..1ebd59e 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,6 +1,7 @@ **/node_modules web/dist data +postgres .devdata bin *.md diff --git a/.env.example b/.env.example index e74d662..09f0471 100644 --- a/.env.example +++ b/.env.example @@ -23,3 +23,8 @@ USER_QUOTA_MB=0 COMMON_READONLY=false TRASH_DAYS=0 HISTORY_KEEP=10 +SHARE_SECRET= +# Catalogue PostgreSQL (service postgres du compose). Mot de passe sans caractère +# spécial d'URL (@ : / ? #), sinon fournir DATABASE_URL complète et encodée. +POSTGRES_PASSWORD= +DATABASE_URL= diff --git a/.gitignore b/.gitignore index 7694161..07a9820 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ /data/ +/postgres/ /.devdata/ /bin/ web/dist/* diff --git a/Dockerfile b/Dockerfile index cf2d026..a25727a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -12,12 +12,13 @@ RUN npm run build FROM golang:1.24-alpine AS backend ARG VERSION=dev WORKDIR /src -COPY go.mod ./ +COPY go.mod go.sum ./ +RUN --mount=type=cache,target=/go/pkg/mod go mod download COPY cmd ./cmd COPY internal ./internal COPY web/embed.go ./web/ COPY --from=frontend /src/web/dist ./web/dist -RUN --mount=type=cache,target=/root/.cache/go-build \ +RUN --mount=type=cache,target=/root/.cache/go-build --mount=type=cache,target=/go/pkg/mod \ CGO_ENABLED=0 go test ./... && \ CGO_ENABLED=0 go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" -o /out/server ./cmd/server && \ mkdir -p /out/data diff --git a/cmd/server/main.go b/cmd/server/main.go index 3292129..0b93656 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -20,6 +20,7 @@ import ( "github.com/vblogio/upandown/internal/api" "github.com/vblogio/upandown/internal/auth" + "github.com/vblogio/upandown/internal/catalog" "github.com/vblogio/upandown/internal/storage" "github.com/vblogio/upandown/internal/tokens" "github.com/vblogio/upandown/web" @@ -65,6 +66,19 @@ func fatal(msg string, args ...any) { os.Exit(1) } +// envDuration lit une durée (« 30s », « 2m »). +func envDuration(key string, def time.Duration) time.Duration { + v := os.Getenv(key) + if v == "" { + return def + } + d, err := time.ParseDuration(v) + if err != nil || d < 0 { + fatal(key + " invalide (durée attendue, ex. 60s)") + } + return d +} + // secretEnv lit un secret dans NAME, ou dans le fichier NAME_FILE (secrets Docker). func secretEnv(name string) string { if v := os.Getenv(name); v != "" { @@ -118,6 +132,20 @@ func main() { defer stop() spaces := storage.NewSpaces(store) + // Catalogue PostgreSQL partagé (mode cluster) : DATABASE_URL ou DATABASE_URL_FILE. + // Sans lui, les métadonnées restent dans les fichiers JSON de DATA_DIR. + if dsn := secretEnv("DATABASE_URL"); dsn != "" { + db, err := catalog.Open(ctx, dsn, envDuration("DATABASE_WAIT", 60*time.Second)) + if err != nil { + fatal("catalogue PostgreSQL", "err", err) + } + defer db.Close() + if err := store.UseCatalog(db, "main"); err != nil { + fatal("catalogue PostgreSQL", "err", err) + } + spaces.Catalog = db + slog.Info("catalogue PostgreSQL branché") + } spaces.MaxUpload = envInt("MAX_UPLOAD_MB", 0) << 20 // 0 : illimité mode := strings.ToLower(env("AUTH_MODE", "local")) diff --git a/docker-compose.yml b/docker-compose.yml index 72413d8..90ef871 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -41,6 +41,13 @@ services: HISTORY_INTERVAL: ${HISTORY_INTERVAL:-0} HISTORY_MAX_AGE: ${HISTORY_MAX_AGE:-0} SHARE_SECRET: ${SHARE_SECRET:-} + # Catalogue PostgreSQL partagé (indispensable pour plusieurs instances). + # Plusieurs hôtes possibles pour une base répliquée : + # postgres://upandown:@pg1,pg2/upandown?target_session_attrs=read-write + DATABASE_URL: ${DATABASE_URL:-postgres://upandown:${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis}@postgres:5432/upandown?sslmode=disable} + depends_on: + postgres: + condition: service_healthy volumes: # Bind mount : chown -R 65532:65532 ./data - ./data:/data @@ -50,6 +57,25 @@ services: - no-new-privileges:true networks: - traefik-net + - upandown-db + postgres: + image: postgres:16-alpine + restart: unless-stopped + environment: + POSTGRES_DB: upandown + POSTGRES_USER: upandown + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis} + volumes: + - ./postgres:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U upandown -d upandown"] + interval: 10s + timeout: 5s + retries: 5 + networks: + - upandown-db networks: + upandown-db: + internal: true traefik-net: external: true diff --git a/go.mod b/go.mod index d5a368c..b727cc3 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,14 @@ module github.com/vblogio/upandown go 1.24.7 + +require github.com/jackc/pgx/v5 v5.7.2 + +require ( + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + golang.org/x/crypto v0.31.0 // indirect + golang.org/x/sync v0.10.0 // indirect + golang.org/x/text v0.21.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..731b5df --- /dev/null +++ b/go.sum @@ -0,0 +1,28 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI= +github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= +golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= +golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ= +golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= +golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/catalog/catalog_test.go b/internal/catalog/catalog_test.go new file mode 100644 index 0000000..4b85430 --- /dev/null +++ b/internal/catalog/catalog_test.go @@ -0,0 +1,31 @@ +package catalog + +import ( + "context" + "errors" + "io" + "testing" + + "github.com/jackc/pgx/v5/pgconn" +) + +func TestRetryable(t *testing.T) { + cases := []struct { + err error + want bool + }{ + {&pgconn.PgError{Code: "40001"}, true}, // sérialisation + {&pgconn.PgError{Code: "40P01"}, true}, // interblocage + {&pgconn.PgError{Code: "25006"}, true}, // secondaire après bascule + {&pgconn.PgError{Code: "57P01"}, true}, // arrêt du serveur + {&pgconn.PgError{Code: "23505"}, false}, // doublon : erreur métier + {io.ErrUnexpectedEOF, true}, + {context.Canceled, false}, + {errors.New("autre"), false}, + } + for _, c := range cases { + if got := Retryable(c.err); got != c.want { + t.Errorf("Retryable(%v) = %v, veut %v", c.err, got, c.want) + } + } +} diff --git a/internal/catalog/migrations/001_init.sql b/internal/catalog/migrations/001_init.sql new file mode 100644 index 0000000..fab27df --- /dev/null +++ b/internal/catalog/migrations/001_init.sql @@ -0,0 +1,29 @@ +-- Métadonnées des fichiers et dossiers (tags, icône, auteurs), par racine : +-- "main" (arborescence commune), "home/" (espace personnel), "s3". +CREATE TABLE item_meta ( + root text NOT NULL, + path text NOT NULL, + tags text[] NOT NULL DEFAULT '{}', + favorite boolean NOT NULL DEFAULT false, + icon text NOT NULL DEFAULT '', + created timestamptz, + created_by text NOT NULL DEFAULT '', + edited_by text NOT NULL DEFAULT '', + PRIMARY KEY (root, path) +); + +-- Liens de partage ; data reprend le format de .shares.json. +CREATE TABLE shares ( + id text PRIMARY KEY, + root text NOT NULL, + data jsonb NOT NULL +); +CREATE INDEX shares_root ON shares (root); + +-- Reprises uniques des anciens fichiers JSON (une ligne par racine et par type). +CREATE TABLE imports ( + root text NOT NULL, + kind text NOT NULL, + done timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (root, kind) +); diff --git a/internal/storage/details.go b/internal/storage/details.go index 4d520b7..ba64183 100644 --- a/internal/storage/details.go +++ b/internal/storage/details.go @@ -152,24 +152,21 @@ func (s *Store) noteEdit(c, by string, created bool) { if c == "" { return } - s.metaMu.Lock() - defer s.metaMu.Unlock() - if s.loadMeta() != nil { - return - } - m := s.meta[c] - changed := false - if by != "" && m.EditedBy != by { - m.EditedBy, changed = by, true - } - if created && m.Created == nil { - now := time.Now().UTC().Truncate(time.Second) - m.Created, m.CreatedBy, changed = &now, by, true - } - if changed { - s.meta[c] = m - _ = s.saveMeta() - } + _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { + m := meta[c] + changed := false + if by != "" && m.EditedBy != by { + m.EditedBy, changed = by, true + } + if created && m.Created == nil { + now := time.Now().UTC().Truncate(time.Second) + m.Created, m.CreatedBy, changed = &now, by, true + } + if changed { + meta[c] = m + } + return changed, nil + }) } // AddDetails complète des entrées (chemins virtuels) de leurs détails. Les diff --git a/internal/storage/meta.go b/internal/storage/meta.go index d9f03e0..399ecb3 100644 --- a/internal/storage/meta.go +++ b/internal/storage/meta.go @@ -94,18 +94,62 @@ func (s *Store) saveMeta() error { return atomicWrite(filepath.Join(s.root, metaFile), b) } -// metaSnapshot renvoie une copie des métadonnées (pour List et Search). +// metaSnapshot renvoie une copie des métadonnées (pour List et Search) ; +// vide en cas d'erreur de lecture. func (s *Store) metaSnapshot() map[string]itemMeta { + m, err := s.readMeta() + if err != nil { + return map[string]itemMeta{} + } + return m +} + +// readMeta renvoie une copie des métadonnées de la racine (fichier .meta.json +// ou catalogue PostgreSQL). +func (s *Store) readMeta() (map[string]itemMeta, error) { + if s.cat != nil { + return s.cat.readMeta() + } s.metaMu.Lock() defer s.metaMu.Unlock() - if s.loadMeta() != nil { - return map[string]itemMeta{} + if err := s.loadMeta(); err != nil { + return nil, err } out := make(map[string]itemMeta, len(s.meta)) for k, v := range s.meta { out[k] = v } - return out + return out, nil +} + +// updateMeta applique fn aux métadonnées de la racine sous verrou (verrou du +// processus, ou verrou consultatif PostgreSQL partagé par les instances) et +// enregistre le résultat si fn renvoie true. fn reçoit une copie : rien n'est +// enregistré en cas d'erreur. +func (s *Store) updateMeta(fn func(map[string]itemMeta) (bool, error)) error { + if s.cat != nil { + return s.cat.updateMeta(fn) + } + s.metaMu.Lock() + defer s.metaMu.Unlock() + if err := s.loadMeta(); err != nil { + return err + } + m := make(map[string]itemMeta, len(s.meta)) + for k, v := range s.meta { + m[k] = v + } + changed, err := fn(m) + if err != nil || !changed { + return err + } + old := s.meta + s.meta = m + if err := s.saveMeta(); err != nil { + s.meta = old + return err + } + return nil } func decorate(e *Entry, meta map[string]itemMeta) { @@ -147,20 +191,17 @@ func (s *Store) editMeta(paths []string, edit func(*itemMeta) error) error { } cs = append(cs, c) } - s.metaMu.Lock() - defer s.metaMu.Unlock() - if err := s.loadMeta(); err != nil { - return err - } - for _, c := range cs { - m := s.meta[c] - m.Tags = append([]string(nil), m.Tags...) - if err := edit(&m); err != nil { - return err + return s.updateMeta(func(meta map[string]itemMeta) (bool, error) { + for _, c := range cs { + m := meta[c] + m.Tags = append([]string(nil), m.Tags...) + if err := edit(&m); err != nil { + return false, err + } + meta[c] = m } - s.meta[c] = m - } - return s.saveMeta() + return true, nil + }) } // SetFavorite ajoute ou retire des éléments des favoris. @@ -209,19 +250,17 @@ func (s *Store) EditTags(paths, add, remove []string) error { drop[fold(strings.TrimSpace(t))] = true } canon := map[string]string{} // écriture existante de chaque tag - s.metaMu.Lock() - err := s.loadMeta() - for _, m := range s.meta { + all, err := s.readMeta() + if err != nil { + return err + } + for _, m := range all { for _, t := range m.Tags { if _, ok := canon[fold(t)]; !ok { canon[fold(t)] = t } } } - s.metaMu.Unlock() - if err != nil { - return err - } return s.editMeta(paths, func(m *itemMeta) error { kept := m.Tags[:0] has := map[string]bool{} @@ -252,14 +291,13 @@ func (s *Store) EditTags(paths, add, remove []string) error { // Tags liste les tags utilisés, triés par nom, avec leur nombre d'éléments. func (s *Store) Tags() ([]TagCount, error) { - s.metaMu.Lock() - defer s.metaMu.Unlock() - if err := s.loadMeta(); err != nil { + all, err := s.readMeta() + if err != nil { return nil, err } idx := map[string]int{} out := []TagCount{} - for _, m := range s.meta { + for _, m := range all { for _, t := range m.Tags { k := fold(t) if i, ok := idx[k]; ok { @@ -279,52 +317,40 @@ func (s *Store) Tags() ([]TagCount, error) { func under(k, c string) bool { return k == c || strings.HasPrefix(k, c+"/") } func (s *Store) moveMeta(from, to string) { - s.metaMu.Lock() - defer s.metaMu.Unlock() - if s.loadMeta() != nil { - return - } - moved := map[string]itemMeta{} - for k, m := range s.meta { - if under(k, from) { - delete(s.meta, k) - moved[to+k[len(from):]] = m + _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { + moved := map[string]itemMeta{} + for k, m := range meta { + if under(k, from) { + delete(meta, k) + moved[to+k[len(from):]] = m + } } - } - for k, m := range moved { - s.meta[k] = m - } - if len(moved) > 0 { - _ = s.saveMeta() - } + for k, m := range moved { + meta[k] = m + } + return len(moved) > 0, nil + }) } func (s *Store) copyMeta(from, to string) { - s.metaMu.Lock() - defer s.metaMu.Unlock() - if s.loadMeta() != nil { - return - } - if m, ok := s.meta[from]; ok && len(m.Tags) > 0 { - s.meta[to] = itemMeta{Tags: append([]string(nil), m.Tags...)} // pas le favori - _ = s.saveMeta() - } + _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { + if m, ok := meta[from]; ok && len(m.Tags) > 0 { + meta[to] = itemMeta{Tags: append([]string(nil), m.Tags...)} // pas le favori + return true, nil + } + return false, nil + }) } func (s *Store) removeMeta(c string) { - s.metaMu.Lock() - defer s.metaMu.Unlock() - if s.loadMeta() != nil { - return - } - changed := false - for k := range s.meta { - if under(k, c) { - delete(s.meta, k) - changed = true + _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { + changed := false + for k := range meta { + if under(k, c) { + delete(meta, k) + changed = true + } } - } - if changed { - _ = s.saveMeta() - } + return changed, nil + }) } diff --git a/internal/storage/share.go b/internal/storage/share.go index 17aa150..ed3b587 100644 --- a/internal/storage/share.go +++ b/internal/storage/share.go @@ -127,6 +127,9 @@ func sign(key []byte, id string) string { } func (s *Store) readShares() (map[string]shareDisk, error) { + if s.cat != nil { + return s.cat.readShares() + } out := map[string]shareDisk{} b, err := os.ReadFile(filepath.Join(s.root, sharesFile)) switch { @@ -164,6 +167,9 @@ func (s *Store) writeShares(m map[string]shareDisk) error { func (s *Store) editShares(edit func(map[string]shareDisk) (bool, error)) error { s.sharesMu.Lock() defer s.sharesMu.Unlock() + if s.cat != nil { + return s.cat.editShares(edit) + } m, err := s.readShares() if err != nil { return err diff --git a/internal/storage/spaces.go b/internal/storage/spaces.go index 6552cbd..24d25bc 100644 --- a/internal/storage/spaces.go +++ b/internal/storage/spaces.go @@ -14,6 +14,8 @@ import ( "strings" "sync" "time" + + "github.com/vblogio/upandown/internal/catalog" ) // Espaces personnels et favoris par utilisateur : @@ -79,6 +81,10 @@ type Spaces struct { // MaxUpload borne la taille d'un fichier déposé (octets ; 0 : illimité). MaxUpload int64 + // Catalog : catalogue PostgreSQL partagé (nil : métadonnées en fichiers + // JSON). Les espaces personnels y sont rangés sous « home/ ». + Catalog *catalog.DB + mu sync.Mutex homes map[string]*Store @@ -116,6 +122,11 @@ func (sp *Spaces) home(id string) (*Store, error) { } st.History = sp.Main.History st.keyFrom = sp.Main + if sp.Catalog != nil { + if err := st.UseCatalog(sp.Catalog, "home/"+id); err != nil { + return nil, err + } + } sp.homes[id] = st return st, nil } @@ -1044,21 +1055,17 @@ func (u *Space) RevokeAllShares() error { // takeMeta retire et renvoie les métadonnées de c et de son contenu (clés // relatives à c). func (s *Store) takeMeta(c string) map[string]itemMeta { - s.metaMu.Lock() - defer s.metaMu.Unlock() - if s.loadMeta() != nil { - return nil - } out := map[string]itemMeta{} - for k, m := range s.meta { - if under(k, c) { - out[k[len(c):]] = m - delete(s.meta, k) + _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { + clear(out) + for k, m := range meta { + if under(k, c) { + out[k[len(c):]] = m + delete(meta, k) + } } - } - if len(out) > 0 { - _ = s.saveMeta() - } + return len(out) > 0, nil + }) return out } @@ -1066,15 +1073,12 @@ func (s *Store) putMeta(c string, m map[string]itemMeta) { if len(m) == 0 { return } - s.metaMu.Lock() - defer s.metaMu.Unlock() - if s.loadMeta() != nil { - return - } - for suffix, v := range m { - s.meta[c+suffix] = v - } - _ = s.saveMeta() + _ = s.updateMeta(func(meta map[string]itemMeta) (bool, error) { + for suffix, v := range m { + meta[c+suffix] = v + } + return true, nil + }) } func (s *Store) takeShares(c string) map[string]shareDisk { diff --git a/internal/storage/storage.go b/internal/storage/storage.go index eb19672..c7ba42a 100644 --- a/internal/storage/storage.go +++ b/internal/storage/storage.go @@ -86,6 +86,7 @@ type Store struct { thumbSem chan struct{} metaMu sync.Mutex // tags, favoris, auteurs (meta.go) + cat *catalogRef // catalogue PostgreSQL (catalog.go) ; nil : fichiers JSON meta map[string]itemMeta // nil : pas encore chargé sharesMu sync.Mutex // liens de partage (share.go) diff --git a/internal/storage/storage_test.go b/internal/storage/storage_test.go index beee280..a2925ba 100644 --- a/internal/storage/storage_test.go +++ b/internal/storage/storage_test.go @@ -21,6 +21,7 @@ func newStore(t *testing.T) *Store { if err != nil { t.Fatal(err) } + attachTestCatalog(t, s) return s }