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.
251 lines
9.5 KiB
Go
251 lines
9.5 KiB
Go
package storage
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/ed25519"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/uptrace/bun"
|
|
|
|
"codeberg.org/squidd/sonda/internal/federation"
|
|
)
|
|
|
|
func testKey(t *testing.T, seed byte) ed25519.PublicKey {
|
|
t.Helper()
|
|
pub, _, err := ed25519.GenerateKey(bytes.NewReader(bytes.Repeat([]byte{seed}, 64)))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return pub
|
|
}
|
|
|
|
func TestFederationSettings(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
repo := NewFederationRepo(db)
|
|
|
|
if _, found, err := repo.Settings(ctx); err != nil || found {
|
|
t.Fatalf("Settings before any save = found %v, %v", found, err)
|
|
}
|
|
|
|
pub, priv, err := ed25519.GenerateKey(bytes.NewReader(bytes.Repeat([]byte{7}, 64)))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := federation.Settings{
|
|
Enabled: true, Name: "Home", Address: "https://music.example.org",
|
|
PublicKey: pub, PrivateKey: priv, UpdatedAt: time.Unix(1_700_000_000, 0),
|
|
}
|
|
if err := repo.SaveSettings(ctx, want); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// A second save replaces the row, it does not add one.
|
|
want.Name = "Away"
|
|
want.Enabled = false
|
|
if err := repo.SaveSettings(ctx, want); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, found, err := repo.Settings(ctx)
|
|
if err != nil || !found {
|
|
t.Fatalf("Settings = found %v, %v", found, err)
|
|
}
|
|
if got.Enabled || got.Name != "Away" || got.Address != want.Address ||
|
|
!bytes.Equal(got.PublicKey, pub) || !bytes.Equal(got.PrivateKey, priv) || !got.UpdatedAt.Equal(want.UpdatedAt) {
|
|
t.Errorf("Settings = %+v, want %+v", got, want)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestFederationSettingsWithoutKeys(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
repo := NewFederationRepo(db)
|
|
if err := repo.SaveSettings(ctx, federation.Settings{Name: "x", UpdatedAt: time.Unix(5, 0)}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, found, err := repo.Settings(ctx)
|
|
if err != nil || !found || got.PublicKey != nil || got.PrivateKey != nil {
|
|
t.Fatalf("Settings = %+v, found %v, %v: a server with no keys yet must read back with none", got, found, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestFederationInvitesAreSingleUseAndExpire(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
repo := NewFederationRepo(db)
|
|
now := time.Unix(1_700_000_000, 0)
|
|
|
|
if err := repo.AddInvite(ctx, "hash-a", now, now.Add(time.Hour)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ok, err := repo.UseInvite(ctx, "no-such", now); err != nil || ok {
|
|
t.Errorf("unknown invite: ok = %v, %v", ok, err)
|
|
}
|
|
if ok, err := repo.UseInvite(ctx, "hash-a", now.Add(2*time.Hour)); err != nil || ok {
|
|
t.Errorf("expired invite: ok = %v, %v", ok, err)
|
|
}
|
|
if ok, err := repo.UseInvite(ctx, "hash-a", now.Add(time.Minute)); err != nil || !ok {
|
|
t.Errorf("first use: ok = %v, %v", ok, err)
|
|
}
|
|
if ok, err := repo.UseInvite(ctx, "hash-a", now.Add(time.Minute)); err != nil || ok {
|
|
t.Errorf("second use: ok = %v, %v, an invite is good once", ok, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestFederationFriends(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
repo := NewFederationRepo(db)
|
|
now := time.Unix(1_700_000_000, 0)
|
|
|
|
if list, err := repo.Friends(ctx); err != nil || len(list) != 0 {
|
|
t.Fatalf("Friends = %v, %v", list, err)
|
|
}
|
|
a, err := repo.AddFriend(ctx, federation.Friend{
|
|
Name: "Anna", Address: "https://anna.example.org", PublicKey: testKey(t, 1), State: federation.Incoming, CreatedAt: now,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if a.ID <= 0 {
|
|
t.Fatalf("AddFriend returned %+v", a)
|
|
}
|
|
if _, err := repo.AddFriend(ctx, federation.Friend{
|
|
Name: "Again", Address: "https://x.example.org", PublicKey: testKey(t, 1), State: federation.Outgoing, CreatedAt: now,
|
|
}); !errors.Is(err, federation.ErrAlreadyFriend) {
|
|
t.Errorf("same key twice: err = %v, want ErrAlreadyFriend", err)
|
|
}
|
|
b, err := repo.AddFriend(ctx, federation.Friend{
|
|
Name: "Bruno", Address: "https://bruno.example.org", PublicKey: testKey(t, 2), State: federation.Outgoing, CreatedAt: now.Add(time.Second),
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
list, err := repo.Friends(ctx)
|
|
if err != nil || len(list) != 2 || list[0].ID != a.ID || list[1].ID != b.ID {
|
|
t.Fatalf("Friends = %+v, %v, want Anna then Bruno", list, err)
|
|
}
|
|
got, err := repo.Friend(ctx, a.ID)
|
|
if err != nil || got.Name != "Anna" || got.State != federation.Incoming || !got.ApprovedAt.IsZero() ||
|
|
!bytes.Equal(got.PublicKey, testKey(t, 1)) || !got.CreatedAt.Equal(now) {
|
|
t.Errorf("Friend = %+v, %v", got, err)
|
|
}
|
|
byKey, found, err := repo.FriendByKey(ctx, testKey(t, 2))
|
|
if err != nil || !found || byKey.ID != b.ID {
|
|
t.Errorf("FriendByKey = %+v, %v, %v", byKey, found, err)
|
|
}
|
|
if _, found, err := repo.FriendByKey(ctx, testKey(t, 9)); err != nil || found {
|
|
t.Errorf("FriendByKey unknown = %v, %v", found, err)
|
|
}
|
|
|
|
// Approving moves an incoming friend to active; the other one is not waiting for me.
|
|
if err := repo.Approve(ctx, a.ID, now.Add(time.Hour)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := repo.Friend(ctx, a.ID); got.State != federation.Active || !got.ApprovedAt.Equal(now.Add(time.Hour)) {
|
|
t.Errorf("after Approve: %+v", got)
|
|
}
|
|
if err := repo.Approve(ctx, a.ID, now); !errors.Is(err, federation.ErrWrongState) {
|
|
t.Errorf("approve an active friend: %v, want ErrWrongState", err)
|
|
}
|
|
if err := repo.Approve(ctx, b.ID, now); !errors.Is(err, federation.ErrWrongState) {
|
|
t.Errorf("approve an outgoing friend: %v, want ErrWrongState", err)
|
|
}
|
|
if err := repo.Approve(ctx, 999, now); !errors.Is(err, federation.ErrFriendMissing) {
|
|
t.Errorf("approve missing: %v, want ErrFriendMissing", err)
|
|
}
|
|
|
|
if err := repo.DeleteFriend(ctx, a.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := repo.Friend(ctx, a.ID); !errors.Is(err, federation.ErrFriendMissing) {
|
|
t.Errorf("Friend after delete: %v", err)
|
|
}
|
|
if err := repo.DeleteFriend(ctx, a.ID); !errors.Is(err, federation.ErrFriendMissing) {
|
|
t.Errorf("delete twice: %v, want ErrFriendMissing", err)
|
|
}
|
|
// The key is free again: the same server can be invited anew.
|
|
if _, err := repo.AddFriend(ctx, federation.Friend{
|
|
Name: "Anna", Address: "https://anna.example.org", PublicKey: testKey(t, 1), State: federation.Incoming, CreatedAt: now,
|
|
}); err != nil {
|
|
t.Errorf("add after delete: %v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestFederationLimitsAreStored(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
repo := NewFederationRepo(db)
|
|
if err := repo.SaveSettings(ctx, federation.Settings{Enabled: true, MaxStreams: 5, MaxKiBPerSec: 0, UpdatedAt: time.Unix(5, 0)}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, _, err := repo.Settings(ctx)
|
|
if err != nil || got.MaxStreams != 5 || got.MaxKiBPerSec != 0 {
|
|
t.Fatalf("Settings = %+v, %v: 0 KiB a second means no limit and must stay 0", got, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestAnOutgoingFriendBecomesActive(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
repo := NewFederationRepo(db)
|
|
now := time.Unix(1_700_000_000, 0)
|
|
out, _ := repo.AddFriend(ctx, federation.Friend{Name: "A", Address: "https://a.example.org", PublicKey: testKey(t, 1), State: federation.Outgoing, CreatedAt: now})
|
|
in, _ := repo.AddFriend(ctx, federation.Friend{Name: "B", Address: "https://b.example.org", PublicKey: testKey(t, 2), State: federation.Incoming, CreatedAt: now})
|
|
|
|
if err := repo.Activate(ctx, in.ID, now); !errors.Is(err, federation.ErrWrongState) {
|
|
t.Errorf("activate an incoming friend: %v, want ErrWrongState", err)
|
|
}
|
|
if err := repo.Activate(ctx, 999, now); !errors.Is(err, federation.ErrFriendMissing) {
|
|
t.Errorf("activate a missing friend: %v, want ErrFriendMissing", err)
|
|
}
|
|
if err := repo.Activate(ctx, out.ID, now.Add(time.Hour)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := repo.Friend(ctx, out.ID); got.State != federation.Active || !got.ApprovedAt.Equal(now.Add(time.Hour)) {
|
|
t.Errorf("after Activate: %+v", got)
|
|
}
|
|
if err := repo.Activate(ctx, out.ID, now); !errors.Is(err, federation.ErrWrongState) {
|
|
t.Errorf("activate twice: %v, want ErrWrongState", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestTheRequestsOfFriendsAreLoggedListedAndPruned(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
repo := NewFederationRepo(db)
|
|
now := time.Unix(1_700_000_000, 0)
|
|
f, _ := repo.AddFriend(ctx, federation.Friend{Name: "Anna", Address: "https://a.example.org", PublicKey: testKey(t, 1), State: federation.Active, CreatedAt: now})
|
|
for i, at := range []time.Time{now, now.Add(time.Hour), now.Add(2 * time.Hour)} {
|
|
if err := repo.LogRequest(ctx, federation.FriendRequest{At: at, FriendID: f.ID, Route: "/api/v1/peer/tracks/:id/stream", Status: 200 + i, Bytes: int64(i)}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
got, err := repo.Requests(ctx, 2)
|
|
if err != nil || len(got) != 2 || got[0].Status != 202 || got[1].Status != 201 || got[0].FriendName != "Anna" || got[0].Route == "" {
|
|
t.Fatalf("Requests(2) = %+v, %v: want the newest two, with the name", got, err)
|
|
}
|
|
if err := repo.PruneRequests(ctx, now.Add(30*time.Minute)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := repo.Requests(ctx, 10); len(got) != 2 {
|
|
t.Errorf("after pruning: %d requests, want 2", len(got))
|
|
}
|
|
// A friend that goes takes its log with it.
|
|
if err := repo.DeleteFriend(ctx, f.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := repo.Requests(ctx, 10); len(got) != 0 {
|
|
t.Errorf("after the friend was removed: %d requests, want 0", len(got))
|
|
}
|
|
})
|
|
}
|