A friend's server can now read what an admin chose to share.
- A library has a shared flag, off by default (migration 0024), set with
PATCH /libraries/{id}. Changing it never waits for a scan.
- Requests between friends are signed with each server's Ed25519 key: the
method, the path and query from /api/v1/peer on, a date, a nonce and the
hash of the empty body. A date more than two minutes off, a nonce used
before, an unknown or removed key and a bad signature all get the same
401. A friend still waiting for approval gets 403, and while federation is
off the routes are missing.
- Routes under /api/v1/peer: info, artists, albums, tracks, covers and
streaming with Range. The catalogue, the counts and the format come from
the shared libraries only, and the file served is the one in a shared
library. No path, library id, listen, taste, user or provider data is part
of an answer.
- A friend never makes this server build a cover, read an audio file or ask
a provider: only covers already built from the audio files are served.
- Per-friend limits, set by the admin: parallel streams (default 3) and KiB
a second (default 4096, 0 for none), shared by all the streams of a friend.
- A log of the last requests friends made (route, status, bytes; never the
query), kept for 7 days, in GET /federation/requests.
- POST /federation/friends/{id}/check lets the side that pasted an invite
find out that the other admin approved; a signed call from a friend this
server is waiting for makes it active too.
- Admin: a Shared with friends switch on each library, which asks first, and
limits, recent requests and a Check button in the Federation section, in
English and Italian.
- OpenAPI paths and schemas, contract test, two real servers checked end to
end with tagged audio files.
247 lines
8.2 KiB
Go
247 lines
8.2 KiB
Go
package library
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// Errors returned by the Libraries service.
|
|
var (
|
|
ErrLibraryNotFound = errors.New("library not found")
|
|
ErrLibraryExists = errors.New("a library with this name or path already exists")
|
|
ErrInvalidLibrary = errors.New("invalid library")
|
|
)
|
|
|
|
const maxLibraryNameLen = 100
|
|
|
|
// Library is a named directory of music.
|
|
type Library struct {
|
|
ID int64
|
|
Name string
|
|
Path string // absolute directory
|
|
Shared bool // friends (federation) may read it; off until an admin says so
|
|
CreatedAt time.Time
|
|
}
|
|
|
|
// LibraryStore persists libraries.
|
|
type LibraryStore interface {
|
|
ListLibraries(ctx context.Context) ([]Library, error)
|
|
// GetLibrary returns ErrLibraryNotFound for an unknown id.
|
|
GetLibrary(ctx context.Context, id int64) (Library, error)
|
|
// CreateLibrary and UpdateLibrary return ErrLibraryExists when the name
|
|
// (case-insensitive) or the path is already used by another library.
|
|
CreateLibrary(ctx context.Context, name, path string) (Library, error)
|
|
UpdateLibrary(ctx context.Context, id int64, name, path string) (Library, error)
|
|
// SetLibraryShared says whether friends may read the library. It returns ErrLibraryNotFound for an unknown id.
|
|
SetLibraryShared(ctx context.Context, id int64, shared bool) (Library, error)
|
|
// DeleteLibrary removes the library and its indexed files, never the music
|
|
// on disk. It returns ErrLibraryNotFound for an unknown id.
|
|
DeleteLibrary(ctx context.Context, id int64) error
|
|
}
|
|
|
|
// Libraries manages the list of libraries and keeps it sane: every path is an
|
|
// absolute, existing directory, and no library sits inside or around another
|
|
// (that would index the same files twice).
|
|
type Libraries struct {
|
|
store LibraryStore
|
|
|
|
// mu makes validate-then-write atomic, so two admins creating libraries at
|
|
// the same moment cannot both pass the overlap check. Sonda is a
|
|
// single-instance server, so an in-process lock is enough.
|
|
mu sync.Mutex
|
|
busy func() bool
|
|
}
|
|
|
|
// NewLibraries builds the service.
|
|
func NewLibraries(store LibraryStore) *Libraries { return &Libraries{store: store} }
|
|
|
|
// SetBusy registers a function that tells whether a scan is running. While it
|
|
// is, a library's directory cannot change and a library cannot be deleted: the
|
|
// scan works from the list it started with and would write under a stale path.
|
|
func (s *Libraries) SetBusy(fn func() bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.busy = fn
|
|
}
|
|
|
|
func (s *Libraries) scanning() bool { return s.busy != nil && s.busy() }
|
|
|
|
// List returns every library.
|
|
func (s *Libraries) List(ctx context.Context) ([]Library, error) {
|
|
return s.store.ListLibraries(ctx)
|
|
}
|
|
|
|
// Create adds a library.
|
|
func (s *Libraries) Create(ctx context.Context, name, path string) (Library, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
name, path, err := s.validate(ctx, name, path, 0, true)
|
|
if err != nil {
|
|
return Library{}, err
|
|
}
|
|
return s.store.CreateLibrary(ctx, name, path)
|
|
}
|
|
|
|
// Update changes the name and/or the path of a library. A nil argument keeps
|
|
// the current value. Files keep their identity when the path changes.
|
|
func (s *Libraries) Update(ctx context.Context, id int64, name, path *string) (Library, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
cur, err := s.store.GetLibrary(ctx, id)
|
|
if err != nil {
|
|
return Library{}, err
|
|
}
|
|
newName, newPath := cur.Name, cur.Path
|
|
if name != nil {
|
|
newName = *name
|
|
}
|
|
if path != nil {
|
|
newPath = *path
|
|
}
|
|
// An untouched name is not validated again: a migrated library is named
|
|
// after its path, which can be longer than the limit for new names.
|
|
newName, newPath, err = s.validate(ctx, newName, newPath, id, name != nil)
|
|
if err != nil {
|
|
return Library{}, err
|
|
}
|
|
if newPath != cur.Path && s.scanning() {
|
|
return Library{}, ErrScanRunning
|
|
}
|
|
return s.store.UpdateLibrary(ctx, id, newName, newPath)
|
|
}
|
|
|
|
// SetShared says whether friends (federation) may read a library. Nothing is shared until an admin turns it on.
|
|
func (s *Libraries) SetShared(ctx context.Context, id int64, shared bool) (Library, error) {
|
|
return s.store.SetLibraryShared(ctx, id, shared)
|
|
}
|
|
|
|
// Delete removes a library from the index. The music on disk is untouched.
|
|
func (s *Libraries) Delete(ctx context.Context, id int64) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
if s.scanning() {
|
|
return ErrScanRunning
|
|
}
|
|
return s.store.DeleteLibrary(ctx, id)
|
|
}
|
|
|
|
// validate checks a name and a path, ignoring the library skipID when it
|
|
// looks for overlaps. It returns the trimmed name and the cleaned path. The
|
|
// name is only checked when checkName is true.
|
|
func (s *Libraries) validate(ctx context.Context, name, path string, skipID int64, checkName bool) (string, string, error) {
|
|
name = strings.TrimSpace(name)
|
|
if checkName {
|
|
if name == "" || utf8.RuneCountInString(name) > maxLibraryNameLen {
|
|
return "", "", fmt.Errorf("%w: name must be 1-%d characters", ErrInvalidLibrary, maxLibraryNameLen)
|
|
}
|
|
for _, r := range name {
|
|
if unicode.IsControl(r) {
|
|
return "", "", fmt.Errorf("%w: name has control characters", ErrInvalidLibrary)
|
|
}
|
|
}
|
|
}
|
|
|
|
if path == "" || !filepath.IsAbs(path) {
|
|
return "", "", fmt.Errorf("%w: path must be absolute", ErrInvalidLibrary)
|
|
}
|
|
path = filepath.Clean(path)
|
|
if filepath.Dir(path) == path {
|
|
return "", "", fmt.Errorf("%w: the filesystem root cannot be a library", ErrInvalidLibrary)
|
|
}
|
|
real, err := filepath.EvalSymlinks(path)
|
|
if errors.Is(err, fs.ErrNotExist) {
|
|
return "", "", fmt.Errorf("%w: directory does not exist", ErrInvalidLibrary)
|
|
}
|
|
if err != nil {
|
|
return "", "", fmt.Errorf("%w: cannot read the directory: %v", ErrInvalidLibrary, err)
|
|
}
|
|
info, err := os.Stat(real)
|
|
if err != nil || !info.IsDir() {
|
|
return "", "", fmt.Errorf("%w: path is not a directory", ErrInvalidLibrary)
|
|
}
|
|
|
|
others, err := s.store.ListLibraries(ctx)
|
|
if err != nil {
|
|
return "", "", fmt.Errorf("list libraries: %w", err)
|
|
}
|
|
for _, o := range others {
|
|
if o.ID == skipID {
|
|
continue
|
|
}
|
|
if o.Path == path {
|
|
return "", "", ErrLibraryExists
|
|
}
|
|
// Done here, not only by the database: SQLite's NOCASE folds ASCII
|
|
// letters only, PostgreSQL's lower() folds accents too.
|
|
if checkName && strings.ToLower(o.Name) == strings.ToLower(name) {
|
|
return "", "", ErrLibraryExists
|
|
}
|
|
// Compare real paths so a symlink cannot hide an overlap. A library
|
|
// whose directory has vanished is compared by its stored path.
|
|
otherReal, err := filepath.EvalSymlinks(o.Path)
|
|
if err != nil {
|
|
otherReal = o.Path
|
|
}
|
|
if real == otherReal {
|
|
return "", "", ErrLibraryExists
|
|
}
|
|
if within(real, otherReal) || within(otherReal, real) {
|
|
return "", "", fmt.Errorf("%w: overlaps the library %q", ErrInvalidLibrary, o.Name)
|
|
}
|
|
}
|
|
return name, path, nil
|
|
}
|
|
|
|
// within reports whether child is strictly inside parent.
|
|
func within(child, parent string) bool {
|
|
return strings.HasPrefix(child, parent+string(filepath.Separator))
|
|
}
|
|
|
|
// Problems lists libraries that look wrong: a directory that cannot be read, or
|
|
// libraries that overlap and would index the same files twice. Migrated data
|
|
// skips validation, so this is meant to run at startup and be logged.
|
|
func (s *Libraries) Problems(ctx context.Context) ([]string, error) {
|
|
libs, err := s.store.ListLibraries(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list libraries: %w", err)
|
|
}
|
|
|
|
var problems []string
|
|
reals := make([]string, len(libs))
|
|
for i, l := range libs {
|
|
real, err := filepath.EvalSymlinks(l.Path)
|
|
if err != nil {
|
|
problems = append(problems, fmt.Sprintf("library %q: directory %s cannot be read: %v", l.Name, l.Path, err))
|
|
continue
|
|
}
|
|
reals[i] = real
|
|
}
|
|
for i := range libs {
|
|
for j := i + 1; j < len(libs); j++ {
|
|
a, b := reals[i], reals[j]
|
|
switch {
|
|
case a == "" || b == "":
|
|
// already reported as unreadable
|
|
case a == b:
|
|
problems = append(problems, fmt.Sprintf("libraries %q and %q point at the same directory: files are indexed twice", libs[i].Name, libs[j].Name))
|
|
case within(a, b):
|
|
problems = append(problems, fmt.Sprintf("library %q is inside library %q: files are indexed twice", libs[i].Name, libs[j].Name))
|
|
case within(b, a):
|
|
problems = append(problems, fmt.Sprintf("library %q is inside library %q: files are indexed twice", libs[j].Name, libs[i].Name))
|
|
}
|
|
}
|
|
}
|
|
return problems, nil
|
|
}
|