feat(federation): browse and search a friend's catalogue

A listener can now browse the music that a friend's server shares.

- GET /friends lists the friends both admins agreed to, by id and name; an
  address or a key is for the admin only. It is empty while federation is off.
- GET /friends/{friend}/artists, albums and tracks (q, limit, offset,
  artist_id, album_id) and the one-item routes: this server asks the friend
  with a request signed by its own key and passes the page on. The answer is
  read into this API's own types first, so what a friend adds is dropped and
  the shape is the one in the spec. Nothing is kept, and the ids are the
  friend's own.
- Only the three kinds of thing can be asked, and only the parameters their
  routes take: a listener cannot make this server ask a friend for anything
  else. The friend's address and what the connection said never reach a
  listener.
- A friend that cannot be reached, no longer takes this server for a friend,
  is busy or is not there is told in words, never as an error page.
- The client of friends gets a generic signed GET with a size limit.
- The web app has a Friends entry in the menu, shown only when there is a
  friend to browse, a list of friends and a page for each with artists,
  albums and songs, a search and links from an artist to its albums and from
  an album to its songs, in English and Italian.
- OpenAPI paths and schemas, contract test with a friend that is a whole
  server, and two real servers checked end to end.
This commit is contained in:
tgiachi 2026-11-13 15:59:26 +01:00
commit 29bd46c3ba
26 changed files with 2090 additions and 25 deletions

View file

@ -28,11 +28,11 @@ It is a single executable, one database (SQLite by default, PostgreSQL if you pr
- **Your own settings.** `GET` and `PATCH /me/settings` hold choices that belong to you, not to the server. Everyone starts private: `discover_from_listening` is off, so this setting never sends your listening to a provider. When you turn it on, Discover may start from the artists you listen to most, and their names are sent to Last.fm (only if an admin switched it on). What Last.fm answers is kept in the shared database like any other lookup, so another local user can see, from `retrieved_at` of `GET /artists/{id}/similar`, that someone looked up an artist, but not who.
- **Tags.** `GET /artists/{id}/tags` shows what Last.fm and MusicBrainz say kind of music an artist plays, each with its own weights, and the genres of the artist's own files, read offline. See [External providers](#external-providers).
- **Similar artists.** With Last.fm switched on, `GET /artists/{id}/similar` lists artists similar to an artist, and says which of them you already have. See [External providers](#external-providers). Without it, Sonda makes no outbound network requests at all.
- **Friends (federation).** Two Sonda servers can become friends, and the listeners of one can read what the other chose to share. `PUT /federation` (admin) turns federation on, which is off by default, and gives this server a name and a public address (`https`; plain `http` only on a network of your own); the server then makes its own Ed25519 key, kept in the database and never returned. `POST /federation/invites` makes an invite that works once and expires in 24 hours (only a hash of its code is kept). The other admin uses it with `POST /federation/friends`: that server is asked to accept this one, the key it answers with must be the one named in the invite, and the friend waits as `outgoing` until the first admin approves it with `POST /federation/friends/{id}/approve` (`POST /federation/friends/{id}/check` lets the waiting side find out). Either side can remove a friend with `DELETE /federation/friends/{id}`. Nothing is shared until an admin turns on `shared` for a library (`PATCH /libraries/{id}`). A friend's server then reads, with requests signed by its key (the method, the path and query, a date, a nonce and the hash of the body), the routes under `/peer`: the artists, albums and tracks that have a file in a shared library, their covers once they are built, and the audio itself with `Range`. A friend never sees a path, a library id, a listen, a taste or a user, never makes this server build a cover or ask a provider, and has a few streams at a time and a number of KiB a second to share (`max_streams`, `max_kib_per_sec`); the admin sees the last requests it made (`GET /federation/requests`, the route and the size, never what was searched for). Sharing a library lets friends play it and, in practice, copy its files. Browsing a friend's music from the web app is not there yet. The admin area has a Federation section for all of it.
- **Friends (federation).** Two Sonda servers can become friends, and the listeners of one can read what the other chose to share. `PUT /federation` (admin) turns federation on, which is off by default, and gives this server a name and a public address (`https`; plain `http` only on a network of your own); the server then makes its own Ed25519 key, kept in the database and never returned. `POST /federation/invites` makes an invite that works once and expires in 24 hours (only a hash of its code is kept). The other admin uses it with `POST /federation/friends`: that server is asked to accept this one, the key it answers with must be the one named in the invite, and the friend waits as `outgoing` until the first admin approves it with `POST /federation/friends/{id}/approve` (`POST /federation/friends/{id}/check` lets the waiting side find out). Either side can remove a friend with `DELETE /federation/friends/{id}`. Nothing is shared until an admin turns on `shared` for a library (`PATCH /libraries/{id}`). A friend's server then reads, with requests signed by its key (the method, the path and query, a date, a nonce and the hash of the body), the routes under `/peer`: the artists, albums and tracks that have a file in a shared library, their covers once they are built, and the audio itself with `Range`. A friend never sees a path, a library id, a listen, a taste or a user, never makes this server build a cover or ask a provider, and has a few streams at a time and a number of KiB a second to share (`max_streams`, `max_kib_per_sec`); the admin sees the last requests it made (`GET /federation/requests`, the route and the size, never what was searched for). Sharing a library lets friends play it and, in practice, copy its files. A listener browses the music of a friend with `GET /friends` (the names of the friends whose friendship both admins agreed to, never an address or a key) and `GET /friends/{friend}/artists`, `albums` and `tracks` with `q`, `limit` and `offset`, and one item at a time: this server asks the friend with a signed request, checks the shape of the answer and passes it on, and nothing is kept; the ids are the friend's own. A friend that cannot be reached or no longer takes this server for a friend is told in words. The web app has a Friends section for it, shown only when there is a friend to browse. Playing a friend's music and showing its covers is not there yet. The admin area has a Federation section for all of it.
## What is not there yet
Browsing and playing a friend's libraries from the web app (federation), radio queues, OpenSubsonic compatibility, transcoding, and the ListenBrainz integration. The web client is built into the binary (see [Web app](#web-app)), and its admin area covers everything the API can do for an admin: libraries and scanning, users, the external providers and the bulk jobs.
Playing a friend's music and showing its covers (federation), radio queues, OpenSubsonic compatibility, transcoding, and the ListenBrainz integration. The web client is built into the binary (see [Web app](#web-app)), and its admin area covers everything the API can do for an admin: libraries and scanning, users, the external providers and the bulk jobs.
## Requirements

View file

@ -1175,6 +1175,7 @@ func (c *contract) federation(t *testing.T, token, libID, albumID string) {
c.expect(c.call("DELETE", "/federation/friends/"+id, token, nil), 404, "end it twice", "friend_not_found")
c.peer(t, token, libID, albumID)
c.friends(t, token)
// This server uses an invite of another one, which is a real server of its own.
other := newFriendServer(t, true)
@ -1283,3 +1284,52 @@ func (c *contract) peer(t *testing.T, token, libID, albumID string) {
c.expect(c.call("DELETE", "/federation/friends/"+friendID, token, nil), 204, "remove the reader")
c.expect(c.call("PATCH", "/libraries/"+libID, token, map[string]any{"shared": false}), 200, "stop sharing the library")
}
// friends plays a listener of this server who browses what a friend shares. The friend is a whole server of its own.
func (c *contract) friends(t *testing.T, token string) {
t.Helper()
p := newPeerFixture(t)
p.share(t, p.shared, true)
ts := httptest.NewServer(p.h)
defer ts.Close()
p.admin1(t, "PUT", "/federation", map[string]any{"enabled": true, "name": "Anna", "address": ts.URL})
inv := p.admin1(t, "POST", "/federation/invites", nil)
mine := c.expect(c.call("POST", "/federation/friends", token, map[string]any{"invite": inv.Body["invite"]}), 201, "use the invite of a friend to browse")
fid := idOf(mine)
theirs := p.admin1(t, "GET", "/federation", nil).Body["friends"].([]any)
p.admin1(t, "POST", "/federation/friends/"+idOf(theirs[0].(map[string]any))+"/approve", nil)
c.expect(c.call("GET", "/friends", "", nil), 401, "the friends without a login", "unauthorized")
if got := c.expect(c.call("GET", "/friends", token, nil), 200, "the friends before it is checked")["friends"].([]any); len(got) != 0 {
t.Fatalf("a friend that is waiting is listed: %v", got)
}
c.expect(c.call("POST", "/federation/friends/"+fid+"/check", token, nil), 200, "check the friend")
list := c.expect(c.call("GET", "/friends", token, nil), 200, "the friends")["friends"].([]any)
if len(list) != 1 || list[0].(map[string]any)["name"] != "Anna" {
t.Fatalf("friends = %v", list)
}
base := "/friends/" + fid
c.expect(c.call("GET", base+"/tracks", "", nil), 401, "a friend's tracks without a login", "unauthorized")
artists := c.expect(c.call("GET", base+"/artists?limit=5", token, nil), 200, "a friend's artists")
albums := c.expect(c.call("GET", base+"/albums?q=shared", token, nil), 200, "a friend's albums")
tracks := c.expect(c.call("GET", base+"/tracks?limit=5&offset=0", token, nil), 200, "a friend's tracks")
if artists["total"] != float64(1) || albums["total"] != float64(1) || tracks["total"] != float64(1) {
t.Fatalf("what the friend shares: %v %v %v", artists["total"], albums["total"], tracks["total"])
}
albumID, trackID := idOf(albums["items"].([]any)[0].(map[string]any)), idOf(tracks["items"].([]any)[0].(map[string]any))
c.expect(c.call("GET", base+"/artists/"+idOf(artists["items"].([]any)[0].(map[string]any)), token, nil), 200, "one artist of a friend")
c.expect(c.call("GET", base+"/albums/"+albumID, token, nil), 200, "one album of a friend")
c.expect(c.call("GET", base+"/tracks/"+trackID, token, nil), 200, "one track of a friend")
c.expect(c.call("GET", base+"/tracks?album_id="+albumID, token, nil), 200, "the tracks of an album of a friend")
c.expect(c.call("GET", base+"/artists/999999", token, nil), 404, "an artist the friend does not have", "artist_not_found")
c.expect(c.call("GET", base+"/albums/999999", token, nil), 404, "an album the friend does not have", "album_not_found")
c.expect(c.call("GET", base+"/tracks/999999", token, nil), 404, "a track the friend does not have", "track_not_found")
c.expect(c.call("GET", "/friends/999999/tracks", token, nil), 404, "a friend that is not there", "friend_not_found")
c.expect(c.call("GET", base+"/tracks?limit=abc", token, nil), 400, "a limit that is no number", "invalid_input")
// The friend removes this server: the listener is told, and nothing is kept.
p.admin1(t, "DELETE", "/federation/friends/"+idOf(theirs[0].(map[string]any)), nil)
c.expect(c.call("GET", base+"/tracks", token, nil), 409, "a friend that removed this server", "friend_gone")
c.expect(c.call("DELETE", "/federation/friends/"+fid, token, nil), 204, "forget the friend")
}

View file

@ -0,0 +1,267 @@
package httpapi
import (
"context"
"net/http"
"net/http/httptest"
"net/url"
"strconv"
"strings"
"testing"
"github.com/uptrace/bun"
"codeberg.org/squidd/sonda/internal/federation"
"codeberg.org/squidd/sonda/internal/storage"
)
// browseFixture is a server C whose listener browses the shared libraries of a friend P, a real server of its own.
type browseFixture struct {
p *peerFixture
ts *httptest.Server
c *friendServer
listener string
friendID string // the id of P among C's friends
pFriend string // the id of C among P's friends
}
func newBrowseFixture(t *testing.T) *browseFixture {
t.Helper()
p := newPeerFixture(t)
p.share(t, p.shared, true)
ts := httptest.NewServer(p.h)
t.Cleanup(ts.Close)
if r := p.admin1(t, "PUT", "/federation", map[string]any{"enabled": true, "name": "Anna", "address": ts.URL}); r.Code != 200 {
t.Fatalf("turn P on: %d %v", r.Code, r.Body)
}
c := newFriendServer(t, false)
c.setUp(t, "Bruno", "https://bruno.example.org")
inv := p.admin1(t, "POST", "/federation/invites", nil)
mine := c.call(t, "POST", "/federation/friends", map[string]any{"invite": inv.Body["invite"]})
if mine.Code != 201 {
t.Fatalf("C pastes the invite: %d %v", mine.Code, mine.Body)
}
f := &browseFixture{p: p, ts: ts, c: c, friendID: strconv.Itoa(int(mine.Body["id"].(float64)))}
list := p.admin1(t, "GET", "/federation", nil).Body["friends"].([]any)
f.pFriend = strconv.Itoa(int(list[0].(map[string]any)["id"].(float64)))
p.admin1(t, "POST", "/federation/friends/"+f.pFriend+"/approve", nil)
if r := c.call(t, "POST", "/federation/friends/"+f.friendID+"/check", nil); r.Code != 200 {
t.Fatalf("C checks: %d %v", r.Code, r.Body)
}
_, f.listener = addUser(t, c.h, c.admin, "lia", false)
return f
}
func (f *browseFixture) get(t *testing.T, path string) resp {
t.Helper()
return do(t, f.c.h, "GET", "/api/v1"+path, f.listener, nil)
}
func TestAListenerSeesTheNamesOfTheFriendsAndNothingMore(t *testing.T) {
f := newBrowseFixture(t)
if r := do(t, f.c.h, "GET", "/api/v1/friends", "", nil); r.Code != 401 {
t.Errorf("without a login: %d", r.Code)
}
r := f.get(t, "/friends")
list := r.Body["friends"].([]any)
if r.Code != 200 || len(list) != 1 {
t.Fatalf("friends = %d %v", r.Code, r.Body)
}
sameKeys(t, "friend", list[0].(map[string]any), "id", "name")
if list[0].(map[string]any)["name"] != "Anna" || list[0].(map[string]any)["id"] != mustFloat(t, f.friendID) {
t.Errorf("friend = %v", list[0])
}
// The address and the key are for the admin.
if body := jsonOf(t, r.Body); strings.Contains(body, "127.0.0.1") || strings.Contains(body, "key") {
t.Errorf("the list says more than a name: %s", body)
}
// Federation off: nobody to browse.
f.c.call(t, "PUT", "/federation", map[string]any{"enabled": false})
if r := f.get(t, "/friends"); r.Code != 200 || len(r.Body["friends"].([]any)) != 0 {
t.Errorf("while off: %d %v", r.Code, r.Body)
}
}
func mustFloat(t *testing.T, s string) float64 {
t.Helper()
n, err := strconv.ParseFloat(s, 64)
if err != nil {
t.Fatal(err)
}
return n
}
func TestAWaitingFriendIsNotInTheList(t *testing.T) {
f := newPeerFixture(t)
f.admin1(t, "PUT", "/federation", map[string]any{"enabled": true, "address": "https://anna.example.org"})
_, lia := addUser(t, f.h, f.admin, "lia", false)
inv := f.admin1(t, "POST", "/federation/invites", nil)
do(t, f.h, "POST", "/api/v1/peer/pair", "", pairBody(inviteCode(t, str(inv.Body, "invite")), "Bruno", "https://bruno.example.org"))
if r := do(t, f.h, "GET", "/api/v1/friends", lia, nil); r.Code != 200 || len(r.Body["friends"].([]any)) != 0 {
t.Errorf("a friend nobody approved: %d %v", r.Code, r.Body)
}
}
func TestAListenerBrowsesWhatAFriendSharesAndNothingElse(t *testing.T) {
f := newBrowseFixture(t)
base := "/friends/" + f.friendID
for path, want := range map[string]string{"/tracks": "Shared Song", "/albums": "Shared Album", "/artists": "Shared Band"} {
r := f.get(t, base+path)
if r.Code != 200 {
t.Fatalf("%s: %d %v", path, r.Code, r.Body)
}
sameKeys(t, "page", r.Body, "items", "total", "limit", "offset")
if got := titlesIn(r); len(got) != 1 || got[0] != want || r.Body["total"] != float64(1) {
t.Errorf("%s = %v (total %v)", path, got, r.Body["total"])
}
}
if got := titlesIn(f.get(t, base+"/tracks?q=private")); len(got) != 0 {
t.Errorf("a search found %v in a library that is not shared", got)
}
if got := titlesIn(f.get(t, base+"/tracks?q=shared&limit=1&offset=0")); len(got) != 1 {
t.Errorf("a search = %v", got)
}
// One item of each kind, found through the lists.
track := f.get(t, base+"/tracks").Body["items"].([]any)[0].(map[string]any)
album := f.get(t, base+"/albums").Body["items"].([]any)[0].(map[string]any)
artist := f.get(t, base+"/artists").Body["items"].([]any)[0].(map[string]any)
for path, title := range map[string]string{
"/tracks/" + idOf(track): "Shared Song", "/albums/" + idOf(album): "Shared Album", "/artists/" + idOf(artist): "Shared Band",
} {
r := f.get(t, base+path)
if r.Code != 200 || (r.Body["title"] != title && r.Body["name"] != title) {
t.Errorf("%s = %d %v", path, r.Code, r.Body)
}
}
sameKeys(t, "track", f.get(t, base+"/tracks/"+idOf(track)).Body, "id", "title", "duration_ms", "track_no", "disc_no", "album", "artists", "format")
if got := titlesIn(f.get(t, base+"/tracks?album_id="+idOf(album))); len(got) != 1 {
t.Errorf("the tracks of an album = %v", got)
}
// What the friend does not share is not there, by id either.
private := strconv.FormatInt(f.p.track["Private Song"], 10)
if r := f.get(t, base+"/tracks/"+private); r.Code != 404 || errCode(r) != "track_not_found" {
t.Errorf("a track that is not shared: %d %v", r.Code, r.Body)
}
for path, code := range map[string]string{"/artists/999999": "artist_not_found", "/albums/999999": "album_not_found"} {
if r := f.get(t, base+path); r.Code != 404 || errCode(r) != code {
t.Errorf("%s: %d %v", path, r.Code, r.Body)
}
}
}
func TestOnlyTheCatalogueOfAFriendCanBeAsked(t *testing.T) {
f := newBrowseFixture(t)
base := "/friends/" + f.friendID
// The friend's other routes are not reachable through this server.
for _, p := range []string{"/info", "/pair", "/tracks/1/stream", "/albums/1/cover", "/../federation"} {
if r := f.get(t, base+p); r.Code != 404 {
t.Errorf("%s: %d, want 404", p, r.Code)
}
}
// What the routes do not take is dropped, so a listener cannot steer the request.
if r := f.get(t, base+"/tracks?"+url.Values{"library_id": {strconv.FormatInt(f.p.private, 10)}, "evil": {"1"}}.Encode()); r.Code != 200 || r.Body["total"] != float64(1) {
t.Errorf("an unknown parameter: %d %v", r.Code, r.Body)
}
if r := f.get(t, base+"/tracks?q="+strings.Repeat("a", 201)); r.Code != 400 || errCode(r) != "invalid_input" {
t.Errorf("a search that is too long: %d %v", r.Code, r.Body)
}
if r := f.get(t, base+"/tracks?limit=abc"); r.Code != 400 {
t.Errorf("a limit that is no number: %d %v", r.Code, r.Body)
}
}
func TestAFriendThatIsNotThereIsNotFound(t *testing.T) {
f := newBrowseFixture(t)
for _, p := range []string{"/friends/99999/tracks", "/friends/99999/artists/1"} {
if r := f.get(t, p); r.Code != 404 || errCode(r) != "friend_not_found" {
t.Errorf("%s: %d %v", p, r.Code, r.Body)
}
}
if r := f.get(t, "/friends/abc/tracks"); r.Code != 400 {
t.Errorf("a friend that is no number: %d", r.Code)
}
if r := do(t, f.c.h, "GET", "/api/v1/friends/"+f.friendID+"/tracks", "", nil); r.Code != 401 {
t.Errorf("without a login: %d", r.Code)
}
// Federation off: the friend is not there for a listener.
f.c.call(t, "PUT", "/federation", map[string]any{"enabled": false})
if r := f.get(t, "/friends/"+f.friendID+"/tracks"); r.Code != 404 || errCode(r) != "friend_not_found" {
t.Errorf("while off: %d %v", r.Code, r.Body)
}
}
func TestWhenAFriendChangesItsMindTheListenerIsToldInWords(t *testing.T) {
f := newBrowseFixture(t)
base := "/friends/" + f.friendID
// P stops sharing: the friend has nothing, and that is no error.
f.p.share(t, f.p.shared, false)
if r := f.get(t, base+"/tracks"); r.Code != 200 || r.Body["total"] != float64(0) {
t.Errorf("after unsharing: %d %v", r.Code, r.Body)
}
// P removes this server from its friends.
f.p.admin1(t, "DELETE", "/federation/friends/"+f.pFriend, nil)
r := f.get(t, base+"/tracks")
if r.Code != 409 || errCode(r) != "friend_gone" {
t.Errorf("after being removed: %d %v", r.Code, r.Body)
}
// P goes away.
f.ts.Close()
r = f.get(t, base+"/tracks")
if r.Code != 502 || errCode(r) != "friend_unreachable" {
t.Errorf("a friend that is down: %d %v", r.Code, r.Body)
}
if body := jsonOf(t, r.Body); strings.Contains(body, "127.0.0.1") || strings.Contains(body, "dial") {
t.Errorf("the answer names the friend's address: %s", body)
}
}
// crafted is a Federation whose friend sends what it likes.
type crafted struct {
federationService
body string
}
func (c crafted) Browse(context.Context, int64, string, int64, url.Values) ([]byte, error) {
return []byte(c.body), nil
}
func TestWhatAFriendSendsIsCheckedBeforeItIsPassedOn(t *testing.T) {
h, _ := newTestEnvDB(t, func(d *Deps, db *bun.DB) {
d.Federation = crafted{
federationService: federation.NewService(storage.NewFederationRepo(db), federation.NewClient()),
body: `{"items":[{"id":1,"name":"<script>alert(1)</script>","album_count":2,"track_count":3,"path":"/srv/music/secret","token":"x"}],"total":1,"limit":50,"offset":0,"debug":"yes"}`,
}
})
tok := registerAndLogin(t, h)
r := do(t, h, "GET", "/api/v1/friends/1/artists", tok, nil)
if r.Code != 200 {
t.Fatalf("%d %v", r.Code, r.Body)
}
sameKeys(t, "page", r.Body, "items", "total", "limit", "offset")
item := r.Body["items"].([]any)[0].(map[string]any)
sameKeys(t, "artist", item, "id", "name", "album_count", "track_count")
if strings.Contains(jsonOf(t, r.Body), "secret") {
t.Errorf("a field the friend added was passed on: %v", r.Body)
}
}
func TestAnAnswerThatIsNotACataloguePageIsNotPassedOn(t *testing.T) {
for name, body := range map[string]string{"html": "<html>hello</html>", "a list": `[1,2]`, "empty": ``} {
h, _ := newTestEnvDB(t, func(d *Deps, db *bun.DB) {
d.Federation = crafted{federationService: federation.NewService(storage.NewFederationRepo(db), federation.NewClient()), body: body}
})
tok := registerAndLogin(t, h)
r := do(t, h, "GET", "/api/v1/friends/1/tracks", tok, nil)
if r.Code != http.StatusBadGateway || errCode(r) != "friend_unreachable" {
t.Errorf("%s: %d %v", name, r.Code, r.Body)
}
}
}

View file

@ -6,6 +6,7 @@ import (
"encoding/base64"
"errors"
"net/http"
"net/url"
"github.com/gin-gonic/gin"
@ -27,6 +28,9 @@ type federationService interface {
StartStream(ctx context.Context, friendID int64) (*federation.Stream, error)
Pace(ctx context.Context, friendID int64) (*federation.Stream, error)
Record(ctx context.Context, r federation.FriendRequest)
// What a listener may ask about friends.
ActiveFriends(ctx context.Context) ([]federation.Friend, error)
Browse(ctx context.Context, friendID int64, resource string, id int64, query url.Values) ([]byte, error)
}
// federationHandlers are the admin routes that set up federation and its friends, and the one public route

View file

@ -0,0 +1,127 @@
package httpapi
import (
"encoding/json"
"errors"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"codeberg.org/squidd/sonda/internal/federation"
)
// friendsHandlers let any signed-in listener browse the catalogue that a friend shares. This server asks the
// friend, with a request signed by its own key, and passes the answer on after checking its shape; nothing is
// kept. A listener learns a friend's name and nothing more: the address and the key are for the admin.
type friendsHandlers struct{ svc federationService }
// friendNotFound maps a kind of thing to the code of the answer when the friend does not have it.
var friendNotFound = map[string]string{"artists": "artist_not_found", "albums": "album_not_found", "tracks": "track_not_found"}
func (h *friendsHandlers) list(c *gin.Context) {
friends, err := h.svc.ActiveFriends(c.Request.Context())
if err != nil {
_ = c.Error(err)
writeError(c, http.StatusInternalServerError, "internal", "internal error")
return
}
out := make([]gin.H, len(friends))
for i, f := range friends {
out[i] = gin.H{"id": f.ID, "name": f.Name}
}
c.JSON(http.StatusOK, gin.H{"friends": out})
}
// writeFriendError tells a listener, in fixed words, what went wrong with a friend. The address of the friend and
// what the connection said never leave the server.
func writeFriendError(c *gin.Context, err error, resource string) {
switch {
case errors.Is(err, federation.ErrFriendMissing):
writeError(c, http.StatusNotFound, "friend_not_found", "no such friend")
case errors.Is(err, federation.ErrInvalidInput):
writeError(c, http.StatusBadRequest, "invalid_input", "the question was not valid")
case errors.Is(err, federation.ErrNotFoundThere):
writeError(c, http.StatusNotFound, friendNotFound[resource], "not found")
case errors.Is(err, federation.ErrNotFriend), errors.Is(err, federation.ErrNotApproved):
writeError(c, http.StatusConflict, "friend_gone", "this friend does not answer as a friend any more")
case errors.Is(err, federation.ErrTooMany):
c.Header("Retry-After", "5")
writeError(c, http.StatusTooManyRequests, "friend_busy", "this friend is busy: try again in a moment")
case errors.Is(err, federation.ErrUnreachable):
_ = c.Error(err) // the cause stays in the log
writeError(c, http.StatusBadGateway, "friend_unreachable", "this friend could not be reached")
default:
_ = c.Error(err)
writeError(c, http.StatusInternalServerError, "internal", "internal error")
}
}
// fetch asks the friend of the request for a list or an item, and returns what it said.
func (h *friendsHandlers) fetch(c *gin.Context, resource string, withID bool) ([]byte, bool) {
friend, err := strconv.ParseInt(c.Param("friend"), 10, 64)
if err != nil || friend <= 0 {
writeError(c, http.StatusBadRequest, "invalid_input", "friend must be a positive number")
return nil, false
}
var id int64
if withID {
v, ok := pathID(c)
if !ok {
return nil, false
}
id = v
}
body, err := h.svc.Browse(c.Request.Context(), friend, resource, id, c.Request.URL.Query())
if err != nil {
writeFriendError(c, err, resource)
return nil, false
}
return body, true
}
func badAnswer(c *gin.Context) {
_ = c.Error(errors.New("a friend sent an answer that is not a catalogue page"))
writeError(c, http.StatusBadGateway, "friend_unreachable", "this friend could not be reached")
}
// relayPage passes a page of the friend's catalogue on. It is read into the types of this server's own API first,
// so whatever else the friend added is dropped and the answer has the shape the spec promises.
func relayPage[T any](h *friendsHandlers, resource string) gin.HandlerFunc {
return func(c *gin.Context) {
body, ok := h.fetch(c, resource, false)
if !ok {
return
}
var page struct {
Items []T `json:"items"`
Total int `json:"total"`
Limit int `json:"limit"`
Offset int `json:"offset"`
}
if json.Unmarshal(body, &page) != nil || page.Total < 0 {
badAnswer(c)
return
}
if page.Items == nil {
page.Items = []T{}
}
c.JSON(http.StatusOK, page)
}
}
// relayOne passes one artist, album or track of the friend on, checked the same way.
func relayOne[T any](h *friendsHandlers, resource string) gin.HandlerFunc {
return func(c *gin.Context) {
body, ok := h.fetch(c, resource, true)
if !ok {
return
}
var item T
if json.Unmarshal(body, &item) != nil {
badAnswer(c)
return
}
c.JSON(http.StatusOK, item)
}
}

View file

@ -320,6 +320,14 @@ func NewRouter(d Deps) *gin.Engine {
protected.GET("/smart-playlists/:id/tracks", sm.tracks)
protected.GET("/smart-playlists/:id/covers", sm.covers)
protected.POST("/smart-playlists/:id/playlist", sm.save)
fr := &friendsHandlers{svc: d.Federation}
protected.GET("/friends", fr.list)
protected.GET("/friends/:friend/artists", relayPage[artistJSON](fr, "artists"))
protected.GET("/friends/:friend/artists/:id", relayOne[artistJSON](fr, "artists"))
protected.GET("/friends/:friend/albums", relayPage[albumJSON](fr, "albums"))
protected.GET("/friends/:friend/albums/:id", relayOne[albumJSON](fr, "albums"))
protected.GET("/friends/:friend/tracks", relayPage[trackJSON](fr, "tracks"))
protected.GET("/friends/:friend/tracks/:id", relayOne[trackJSON](fr, "tracks"))
protected.GET("/wishlist", fb.list(feedback.Wishlist))
protected.PUT("/wishlist/:id", fb.add(feedback.Wishlist))
protected.DELETE("/wishlist/:id", fb.remove(feedback.Wishlist))

View file

@ -47,6 +47,8 @@ tags:
description: External services Sonda can ask about artists, set up by an admin.
- name: Federation
description: Friend Sonda servers, whose listeners can play the libraries an admin shares (admin).
- name: Friends
description: Browsing the music that a friend's server shares, for any signed-in listener.
paths:
/health:
@ -3502,6 +3504,207 @@ paths:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/friends:
get:
tags: [Friends]
operationId: listFriends
summary: The friends whose music can be browsed
description: |
The friends that both admins agreed to, by name. A listener never sees an address or a key: those are for the
admin (`GET /federation`). Empty while federation is off.
security: [{bearerAuth: []}]
responses:
'200':
description: The friends, oldest first.
content:
application/json:
schema:
type: object
additionalProperties: false
required: [friends]
properties:
friends:
type: array
items: {$ref: '#/components/schemas/FriendRef'}
'401': {$ref: '#/components/responses/Unauthorized'}
/friends/{friend}/artists:
parameters:
- {name: friend, in: path, required: true, description: The id from `GET /friends`., schema: {type: integer, format: int64, minimum: 1}}
get:
tags: [Friends]
operationId: listFriendArtists
summary: The artists a friend shares
description: |
This server asks the friend, with a request signed by its own key, and passes the page on after checking its
shape; nothing is kept. Only what the friend shares is there. `q`, `limit` and `offset` are the same as in
`GET /artists`. A friend that cannot be reached is `502` (`friend_unreachable`); one that no longer takes this
server for a friend is `409` (`friend_gone`).
security: [{bearerAuth: []}]
parameters:
- {$ref: '#/components/parameters/Q'}
- {$ref: '#/components/parameters/Limit'}
- {$ref: '#/components/parameters/Offset'}
responses:
'200':
description: A page of artists.
content:
application/json:
schema: {$ref: '#/components/schemas/ArtistPage'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'409': {$ref: '#/components/responses/FriendGone'}
'429': {$ref: '#/components/responses/FriendBusy'}
'502': {$ref: '#/components/responses/FriendUnreachable'}
'404':
description: No such friend, or it is not active (`friend_not_found`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/friends/{friend}/artists/{id}:
parameters:
- {name: friend, in: path, required: true, description: The id from `GET /friends`., schema: {type: integer, format: int64, minimum: 1}}
- {$ref: '#/components/parameters/Id'}
get:
tags: [Friends]
operationId: getFriendArtist
summary: One artist of a friend
security: [{bearerAuth: []}]
responses:
'200':
description: The artist.
content:
application/json:
schema: {$ref: '#/components/schemas/Artist'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'409': {$ref: '#/components/responses/FriendGone'}
'429': {$ref: '#/components/responses/FriendBusy'}
'502': {$ref: '#/components/responses/FriendUnreachable'}
'404':
description: No such friend, or it is not active (`friend_not_found`) or the friend has no such artist (`artist_not_found`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/friends/{friend}/albums:
parameters:
- {name: friend, in: path, required: true, description: The id from `GET /friends`., schema: {type: integer, format: int64, minimum: 1}}
get:
tags: [Friends]
operationId: listFriendAlbums
summary: The albums a friend shares
description: Like `GET /friends/{friend}/artists`, for albums; `artist_id` is the friend's own id of an artist.
security: [{bearerAuth: []}]
parameters:
- {$ref: '#/components/parameters/Q'}
- {$ref: '#/components/parameters/Limit'}
- {$ref: '#/components/parameters/Offset'}
- {$ref: '#/components/parameters/ArtistId'}
responses:
'200':
description: A page of albums.
content:
application/json:
schema: {$ref: '#/components/schemas/AlbumPage'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'409': {$ref: '#/components/responses/FriendGone'}
'429': {$ref: '#/components/responses/FriendBusy'}
'502': {$ref: '#/components/responses/FriendUnreachable'}
'404':
description: No such friend, or it is not active (`friend_not_found`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/friends/{friend}/albums/{id}:
parameters:
- {name: friend, in: path, required: true, description: The id from `GET /friends`., schema: {type: integer, format: int64, minimum: 1}}
- {$ref: '#/components/parameters/Id'}
get:
tags: [Friends]
operationId: getFriendAlbum
summary: One album of a friend
security: [{bearerAuth: []}]
responses:
'200':
description: The album.
content:
application/json:
schema: {$ref: '#/components/schemas/Album'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'409': {$ref: '#/components/responses/FriendGone'}
'429': {$ref: '#/components/responses/FriendBusy'}
'502': {$ref: '#/components/responses/FriendUnreachable'}
'404':
description: No such friend, or it is not active (`friend_not_found`) or the friend has no such album (`album_not_found`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/friends/{friend}/tracks:
parameters:
- {name: friend, in: path, required: true, description: The id from `GET /friends`., schema: {type: integer, format: int64, minimum: 1}}
get:
tags: [Friends]
operationId: listFriendTracks
summary: The tracks a friend shares
description: |
Like `GET /friends/{friend}/artists`, for tracks; `artist_id` and `album_id` are the friend's own ids. The ids in
every answer are the friend's, never this server's: a listener keeps the friend and the id together.
security: [{bearerAuth: []}]
parameters:
- {$ref: '#/components/parameters/Q'}
- {$ref: '#/components/parameters/Limit'}
- {$ref: '#/components/parameters/Offset'}
- {$ref: '#/components/parameters/ArtistId'}
- {$ref: '#/components/parameters/AlbumId'}
responses:
'200':
description: A page of tracks.
content:
application/json:
schema: {$ref: '#/components/schemas/TrackPage'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'409': {$ref: '#/components/responses/FriendGone'}
'429': {$ref: '#/components/responses/FriendBusy'}
'502': {$ref: '#/components/responses/FriendUnreachable'}
'404':
description: No such friend, or it is not active (`friend_not_found`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
/friends/{friend}/tracks/{id}:
parameters:
- {name: friend, in: path, required: true, description: The id from `GET /friends`., schema: {type: integer, format: int64, minimum: 1}}
- {$ref: '#/components/parameters/Id'}
get:
tags: [Friends]
operationId: getFriendTrack
summary: One track of a friend
security: [{bearerAuth: []}]
responses:
'200':
description: The track.
content:
application/json:
schema: {$ref: '#/components/schemas/Track'}
'400': {$ref: '#/components/responses/InvalidInput'}
'401': {$ref: '#/components/responses/Unauthorized'}
'409': {$ref: '#/components/responses/FriendGone'}
'429': {$ref: '#/components/responses/FriendBusy'}
'502': {$ref: '#/components/responses/FriendUnreachable'}
'404':
description: No such friend, or it is not active (`friend_not_found`) or the friend has no such track (`track_not_found`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
components:
securitySchemes:
bearerAuth:
@ -3606,6 +3809,25 @@ components:
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
FriendGone:
description: The friend no longer takes this server for a friend (`friend_gone`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
FriendBusy:
description: The friend is busy (`friend_busy`). Try again after `Retry-After` seconds.
headers:
Retry-After:
description: Seconds to wait.
schema: {type: integer}
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
FriendUnreachable:
description: The friend could not be reached, or sent something that is not a catalogue page (`friend_unreachable`).
content:
application/json:
schema: {$ref: '#/components/schemas/Error'}
FederationOff:
description: Federation is off on this server, so the route is as good as missing (`not_found`).
content:
@ -4913,6 +5135,13 @@ components:
route: {type: string, description: "The route pattern, like `/api/v1/peer/tracks/:id/stream`. Never the query."}
status: {type: integer}
bytes: {type: integer, format: int64, description: Bytes of the answer.}
FriendRef:
type: object
additionalProperties: false
required: [id, name]
properties:
id: {type: integer, format: int64, description: Names the friend in the routes under `/friends`.}
name: {type: string}
PeerInfo:
type: object
additionalProperties: false

View file

@ -0,0 +1,157 @@
package federation
import (
"context"
"crypto/ed25519"
"errors"
"net/url"
"strings"
"testing"
)
// getRemote is a Remote whose signed GET answers as a script says.
type getRemote struct {
fakeRemote
status int
body string
err error
uri string
auth Auth
addr string
calls int
}
func (g *getRemote) Get(_ context.Context, addr, uri string, auth Auth) (int, []byte, error) {
g.calls++
g.addr, g.uri, g.auth = addr, uri, auth
return g.status, []byte(g.body), g.err
}
// browsing returns a server that has an active friend, and the remote it asks.
func browsing(t *testing.T) (*Service, *memStore, *getRemote, int64) {
t.Helper()
s, st, _, _, _, id := pairedServers(t)
remote := &getRemote{status: 200, body: `{"items":[],"total":0,"limit":50,"offset":0}`}
s.remote = remote
return s, st, remote, id
}
func TestAListenerSeesTheFriendsThatAreActiveAndNothingElse(t *testing.T) {
ctx := context.Background()
s, st, _, _ := browsing(t)
pub, _, _ := ed25519.GenerateKey(nil)
_, _ = st.AddFriend(ctx, Friend{Name: "Waiting", Address: "https://w.example.org", PublicKey: pub, State: Outgoing})
pub2, _, _ := ed25519.GenerateKey(nil)
_, _ = st.AddFriend(ctx, Friend{Name: "Asking", Address: "https://a.example.org", PublicKey: pub2, State: Incoming})
got, err := s.ActiveFriends(ctx)
if err != nil || len(got) != 1 || got[0].Name != "Bruno" {
t.Fatalf("ActiveFriends = %+v, %v", got, err)
}
off := false
if _, err := s.Update(ctx, Patch{Enabled: &off}); err != nil {
t.Fatal(err)
}
if got, err := s.ActiveFriends(ctx); err != nil || len(got) != 0 {
t.Errorf("while off: %+v, %v, want none", got, err)
}
}
func TestBrowsingAsksTheFriendWithASignedRequestForTheRightRoute(t *testing.T) {
ctx := context.Background()
s, st, remote, id := browsing(t)
q := url.Values{"q": {"blue train"}, "limit": {"5"}, "offset": {"10"}, "artist_id": {"3"}, "album_id": {"4"}}
body, err := s.Browse(ctx, id, "tracks", 0, q)
if err != nil || string(body) != remote.body {
t.Fatalf("Browse = %q, %v", body, err)
}
if remote.uri != "/api/v1/peer/tracks?album_id=4&artist_id=3&limit=5&offset=10&q=blue+train" {
t.Errorf("uri = %q", remote.uri)
}
if remote.addr != "https://bruno.example.org" || remote.auth.KeyID != KeyID(st.settings.PublicKey) || len(remote.auth.Key) != ed25519.PrivateKeySize {
t.Errorf("asked %q with %+v", remote.addr, remote.auth.KeyID)
}
if _, err := s.Browse(ctx, id, "albums", 7, nil); err != nil || remote.uri != "/api/v1/peer/albums/7" {
t.Errorf("one album: %v, uri %q", err, remote.uri)
}
// Only what the friend's routes take is passed on, however it is asked.
if _, err := s.Browse(ctx, id, "artists", 0, url.Values{"q": {"x"}, "evil": {"1"}, "library_id": {"1"}, "access_token": {"secret"}}); err != nil || remote.uri != "/api/v1/peer/artists?q=x" {
t.Errorf("filtered: %v, uri %q", err, remote.uri)
}
// An item has no list parameters at all.
if _, err := s.Browse(ctx, id, "artists", 9, url.Values{"q": {"x"}, "limit": {"3"}}); err != nil || remote.uri != "/api/v1/peer/artists/9" {
t.Errorf("an item with parameters: %v, uri %q", err, remote.uri)
}
}
func TestBrowsingOnlyAsksForTheThreeKindsOfThing(t *testing.T) {
ctx := context.Background()
s, _, remote, id := browsing(t)
for _, resource := range []string{"", "info", "tracks/1/stream", "../pair", "artists?x=1", "Tracks"} {
if _, err := s.Browse(ctx, id, resource, 0, nil); !errors.Is(err, ErrInvalidInput) {
t.Errorf("%q: err = %v, want ErrInvalidInput", resource, err)
}
}
if _, err := s.Browse(ctx, id, "tracks", -1, nil); !errors.Is(err, ErrInvalidInput) {
t.Errorf("a negative id: %v", err)
}
if remote.calls != 0 {
t.Errorf("the friend was asked %d times for things that cannot be asked", remote.calls)
}
}
func TestOnlyAnActiveFriendCanBeBrowsed(t *testing.T) {
ctx := context.Background()
s, st, remote, id := browsing(t)
pub, _, _ := ed25519.GenerateKey(nil)
waiting, _ := st.AddFriend(ctx, Friend{Name: "Waiting", Address: "https://w.example.org", PublicKey: pub, State: Outgoing})
pub2, _, _ := ed25519.GenerateKey(nil)
asking, _ := st.AddFriend(ctx, Friend{Name: "Asking", Address: "https://a.example.org", PublicKey: pub2, State: Incoming})
for name, fid := range map[string]int64{"waiting": waiting.ID, "asking": asking.ID, "unknown": 999} {
if _, err := s.Browse(ctx, fid, "tracks", 0, nil); !errors.Is(err, ErrFriendMissing) {
t.Errorf("%s: err = %v, want ErrFriendMissing", name, err)
}
}
off := false
_, _ = s.Update(ctx, Patch{Enabled: &off})
if _, err := s.Browse(ctx, id, "tracks", 0, nil); !errors.Is(err, ErrFriendMissing) {
t.Errorf("while off: %v, want ErrFriendMissing", err)
}
if remote.calls != 0 {
t.Errorf("the friend was asked %d times", remote.calls)
}
}
func TestWhatAFriendAnswersIsToldInOurOwnTerms(t *testing.T) {
ctx := context.Background()
s, _, remote, id := browsing(t)
for _, tc := range []struct {
status int
body string
err error
want error
}{
{400, `{"error":{"code":"invalid_input"}}`, nil, ErrInvalidInput},
{401, `{"error":{"code":"unauthorized"}}`, nil, ErrNotFriend},
{403, `{"error":{"code":"not_approved"}}`, nil, ErrNotApproved},
{404, `{"error":{"code":"not_found"}}`, nil, ErrNotFriend},
{404, `<html>nginx</html>`, nil, ErrNotFriend},
{404, `{"error":{"code":"track_not_found"}}`, nil, ErrNotFoundThere},
{404, `{"error":{"code":"album_not_found"}}`, nil, ErrNotFoundThere},
{429, `{"error":{"code":"too_many_requests"}}`, nil, ErrTooMany},
{500, `oops`, nil, ErrUnreachable},
{200, ``, ErrUnreachable, ErrUnreachable},
} {
remote.status, remote.body, remote.err = tc.status, tc.body, tc.err
_, err := s.Browse(ctx, id, "tracks", 1, nil)
if !errors.Is(err, tc.want) {
t.Errorf("%d %q: err = %v, want %v", tc.status, tc.body, err, tc.want)
}
if err != nil && strings.Contains(err.Error(), "bruno.example.org") && !errors.Is(err, ErrUnreachable) {
t.Errorf("the error names the friend's address: %v", err)
}
}
}

View file

@ -19,6 +19,8 @@ const (
pairPath = "/api/v1/peer/pair"
infoPath = "/api/v1/peer/info"
maxReplyBytes = 16 << 10
// A page of 200 tracks with their credits is far below this.
maxBrowseBytes = 2 << 20
)
// Client talks to other Sonda servers. It is not the outbound client of the providers, which by design never sends a
@ -105,17 +107,18 @@ type infoBody struct {
SharedLibraries int `json:"shared_libraries"`
}
// Info asks the server at address who it is, with a request signed by auth.Key. The path that is signed starts at
// /api/v1/peer, so a server that sits behind a proxy under a sub-path checks the same text.
func (c *Client) Info(ctx context.Context, address string, auth Auth) (Info, error) {
// get sends a signed GET of uri (the path from /api/v1/peer on, and the query) and returns the status and the body,
// whatever the status, up to limit bytes. The path that is signed starts at /api/v1/peer, so a server that sits
// behind a proxy under a sub-path checks the same text.
func (c *Client) get(ctx context.Context, address, uri string, auth Auth, limit int64) (int, []byte, error) {
raw := make([]byte, 18)
if _, err := rand.Read(raw); err != nil {
return Info{}, fmt.Errorf("make a nonce: %w", err)
return 0, nil, fmt.Errorf("make a nonce: %w", err)
}
h := Sign(auth.Key, http.MethodGet, infoPath, time.Now(), base64.RawURLEncoding.EncodeToString(raw))
req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(address, "/")+infoPath, nil)
h := Sign(auth.Key, http.MethodGet, uri, time.Now(), base64.RawURLEncoding.EncodeToString(raw))
req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(address, "/")+uri, nil)
if err != nil {
return Info{}, fmt.Errorf("%w: %v", ErrUnreachable, err)
return 0, nil, fmt.Errorf("%w: %v", ErrUnreachable, err)
}
req.Header.Set("User-Agent", "Sonda (federation)")
req.Header.Set(HeaderKeyID, auth.KeyID)
@ -125,14 +128,28 @@ func (c *Client) Info(ctx context.Context, address string, auth Auth) (Info, err
resp, err := c.http.Do(req)
if err != nil {
return Info{}, fmt.Errorf("%w: %v", ErrUnreachable, err)
return 0, nil, fmt.Errorf("%w: %v", ErrUnreachable, err)
}
defer resp.Body.Close()
body, err := io.ReadAll(io.LimitReader(resp.Body, maxReplyBytes+1))
if err != nil || len(body) > maxReplyBytes {
return Info{}, fmt.Errorf("%w: no usable answer", ErrUnreachable)
body, err := io.ReadAll(io.LimitReader(resp.Body, limit+1))
if err != nil || int64(len(body)) > limit {
return 0, nil, fmt.Errorf("%w: no usable answer", ErrUnreachable)
}
switch resp.StatusCode {
return resp.StatusCode, body, nil
}
// Get is a signed GET for the catalogue of a friend: lists are a few hundred kilobytes at most.
func (c *Client) Get(ctx context.Context, address, uri string, auth Auth) (int, []byte, error) {
return c.get(ctx, address, uri, auth, maxBrowseBytes)
}
// Info asks the server at address who it is, with a request signed by auth.Key.
func (c *Client) Info(ctx context.Context, address string, auth Auth) (Info, error) {
status, body, err := c.get(ctx, address, infoPath, auth, maxReplyBytes)
if err != nil {
return Info{}, err
}
switch status {
case http.StatusOK:
var in infoBody
if json.Unmarshal(body, &in) != nil || in.Name == "" {
@ -144,6 +161,6 @@ func (c *Client) Info(ctx context.Context, address string, auth Auth) (Info, err
case http.StatusUnauthorized, http.StatusNotFound:
return Info{}, ErrNotFriend
default:
return Info{}, fmt.Errorf("%w: it answered %d", ErrUnreachable, resp.StatusCode)
return Info{}, fmt.Errorf("%w: it answered %d", ErrUnreachable, status)
}
}

View file

@ -219,3 +219,38 @@ func TestClientMapsWhatAFriendAnswersToAsk(t *testing.T) {
}
}
}
func TestClientGetsAPageOfTheCatalogueSignedWithItsQuery(t *testing.T) {
pub, priv, _ := ed25519.GenerateKey(nil)
var got Signed
var rawQuery string
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rawQuery = r.URL.RawQuery
got = Signed{
KeyID: r.Header.Get(HeaderKeyID), Date: r.Header.Get(HeaderDate), Nonce: r.Header.Get(HeaderNonce),
Signature: r.Header.Get(HeaderSignature), Method: r.Method, URI: "/api/v1/peer/tracks?limit=5&q=blue+train",
}
w.WriteHeader(http.StatusNotFound)
_, _ = io.WriteString(w, `{"error":{"code":"track_not_found"}}`)
}))
defer srv.Close()
status, body, err := NewClient().Get(context.Background(), srv.URL, "/api/v1/peer/tracks?limit=5&q=blue+train", Auth{KeyID: KeyID(pub), Key: priv})
if err != nil || status != 404 || !strings.Contains(string(body), "track_not_found") {
t.Fatalf("Get = %d %q, %v: a status other than 200 is an answer, not an error", status, body, err)
}
if rawQuery != "limit=5&q=blue+train" || !verify(pub, got.Method, got.URI, got.Date, got.Nonce, got.Signature) {
t.Errorf("query %q, signed %+v", rawQuery, got)
}
}
func TestClientRefusesAnAnswerThatIsTooBigForACatalogue(t *testing.T) {
_, priv, _ := ed25519.GenerateKey(nil)
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
_, _ = w.Write(bytes.Repeat([]byte("x"), 3<<20))
}))
defer srv.Close()
if _, _, err := NewClient().Get(context.Background(), srv.URL, "/api/v1/peer/tracks", Auth{KeyID: "0123456789abcdef", Key: priv}); !errors.Is(err, ErrUnreachable) {
t.Errorf("a 3 MiB answer: err = %v, want ErrUnreachable", err)
}
}

View file

@ -37,6 +37,8 @@ var (
// ErrNotFriend: the other server does not take this server for a friend (it removed it, or federation is off there).
ErrNotFriend = errors.New("the other server does not take this server for a friend")
ErrTooManyStreams = errors.New("this friend already has as many streams open as allowed")
// ErrNotFoundThere: the friend has no such artist, album or track among what it shares.
ErrNotFoundThere = errors.New("the friend has no such item")
)
// Defaults of the limits a friend is held to, and what they may be set to.

View file

@ -322,6 +322,10 @@ func (f *fakeRemote) Pair(context.Context, string, PairRequest) (PairReply, erro
return PairReply{}, errors.New("not used")
}
func (f *fakeRemote) Get(context.Context, string, string, Auth) (int, []byte, error) {
return 0, nil, errors.New("not used")
}
func (f *fakeRemote) Info(_ context.Context, addr string, auth Auth) (Info, error) {
f.got, f.addr = auth, addr
return f.info, f.err

View file

@ -11,6 +11,7 @@ import (
"errors"
"fmt"
"net"
"net/http"
"net/netip"
"net/url"
"os"
@ -69,6 +70,9 @@ type Remote interface {
// when the other admin has not approved yet, ErrNotFriend when that server does not take this one for a friend,
// and ErrUnreachable when it did not answer as a Sonda server.
Info(ctx context.Context, address string, auth Auth) (Info, error)
// Get sends a signed GET of uri (the path from /api/v1/peer on, and the query) to the server at address and
// returns its status and body, whatever the status. An error means no answer was had.
Get(ctx context.Context, address, uri string, auth Auth) (status int, body []byte, err error)
}
// Auth is what signs a request to a friend: this server's key.
@ -620,3 +624,95 @@ func (s *Service) Record(ctx context.Context, r FriendRequest) {
func (s *Service) Requests(ctx context.Context) ([]FriendRequest, error) {
return s.store.Requests(ctx, requestsShown)
}
// ActiveFriends lists the friends a listener may browse. While federation is off there are none.
func (s *Service) ActiveFriends(ctx context.Context) ([]Friend, error) {
set, err := s.load(ctx)
if err != nil {
return nil, err
}
if !set.Enabled || set.PublicKey == nil {
return nil, nil
}
all, err := s.store.Friends(ctx)
if err != nil {
return nil, fmt.Errorf("list friends: %w", err)
}
var out []Friend
for _, f := range all {
if f.State == Active {
out = append(out, f)
}
}
return out, nil
}
// What a listener may ask a friend: the three lists and their items, with the few parameters those take.
var (
browseResources = map[string]bool{"artists": true, "albums": true, "tracks": true}
browseParams = []string{"q", "limit", "offset", "artist_id", "album_id"}
)
// Browse asks an active friend, with a signed request, for a list (id 0) or one item of what it shares, and
// returns the answer as the friend gave it, to be checked by whoever uses it. Nothing is kept. Anything else than
// the three kinds of thing, and any parameter a route does not take, is dropped before the friend is asked, so a
// listener cannot make this server ask for anything but the catalogue. A friend that is not active, does not
// exist or is not reachable while federation is off is ErrFriendMissing.
func (s *Service) Browse(ctx context.Context, friendID int64, resource string, id int64, query url.Values) ([]byte, error) {
if !browseResources[resource] || id < 0 {
return nil, fmt.Errorf("%w: there is no such thing to browse", ErrInvalidInput)
}
set, err := s.load(ctx)
if err != nil {
return nil, err
}
if !set.Enabled || set.PublicKey == nil {
return nil, ErrFriendMissing
}
f, err := s.store.Friend(ctx, friendID)
if err != nil || f.State != Active {
return nil, ErrFriendMissing
}
uri := "/api/v1/peer/" + resource
if id > 0 {
uri += "/" + strconv.FormatInt(id, 10)
} else {
keep := url.Values{}
for _, k := range browseParams {
if v := query.Get(k); v != "" {
keep.Set(k, v)
}
}
if len(keep) > 0 {
uri += "?" + keep.Encode()
}
}
status, body, err := s.remote.Get(ctx, f.Address, uri, Auth{KeyID: KeyID(set.PublicKey), Key: set.PrivateKey})
if err != nil {
return nil, err
}
switch status {
case http.StatusOK:
return body, nil
case http.StatusBadRequest:
return nil, fmt.Errorf("%w: the friend did not take the question", ErrInvalidInput)
case http.StatusForbidden:
return nil, ErrNotApproved
case http.StatusUnauthorized:
return nil, ErrNotFriend
case http.StatusNotFound:
var e struct {
Error struct {
Code string `json:"code"`
} `json:"error"`
}
if json.Unmarshal(body, &e) == nil && strings.HasSuffix(e.Error.Code, "_not_found") {
return nil, ErrNotFoundThere
}
return nil, ErrNotFriend // federation is off there, or it is not a Sonda server that knows us
case http.StatusTooManyRequests:
return nil, ErrTooMany
default:
return nil, fmt.Errorf("%w: it answered %d", ErrUnreachable, status)
}
}

View file

@ -171,6 +171,10 @@ func (d *direct) Info(context.Context, string, Auth) (Info, error) {
return Info{}, errors.New("not used")
}
func (d *direct) Get(context.Context, string, string, Auth) (int, []byte, error) {
return 0, nil, errors.New("not used")
}
type clock struct{ t time.Time }
func (c *clock) now() time.Time { return c.t }
@ -395,6 +399,10 @@ func (s swapKey) Info(ctx context.Context, addr string, a Auth) (Info, error) {
return s.real.Info(ctx, addr, a)
}
func (s swapKey) Get(ctx context.Context, addr, uri string, a Auth) (int, []byte, error) {
return s.real.Get(ctx, addr, uri, a)
}
func (s swapKey) Pair(ctx context.Context, addr string, req PairRequest) (PairReply, error) {
r, err := s.real.Pair(ctx, addr, req)
if err != nil {

38
web/src/api/friends.ts Normal file
View file

@ -0,0 +1,38 @@
import { useQuery } from '@tanstack/react-query'
import { api } from './client'
import { usePagedList, type Album, type Artist, type ListOptions, type Track } from './catalog'
import type { components } from './schema'
export type Friend = components['schemas']['FriendRef']
const FRIENDS = ['friends']
/** The friends whose music can be browsed: their names, never their addresses. Empty while federation is off. */
export function useFriends() {
return useQuery({
queryKey: FRIENDS,
queryFn: () => api.get<{ friends: Friend[] }>('/friends'),
select: (data) => data.friends,
staleTime: 60_000,
})
}
/**
* Lists of what a friend shares. The ids in them are the friend's own, so a list is always asked for together with
* the friend, and an artist or an album id only means something for that friend.
*/
export function useFriendArtists(friend: number, q: string, opts: ListOptions = {}) {
return usePagedList<Artist>(`/friends/${friend}/artists`, { q: q || undefined }, opts)
}
export function useFriendAlbums(friend: number, filter: { q?: string; artistId?: number }, opts: ListOptions = {}) {
return usePagedList<Album>(`/friends/${friend}/albums`, { q: filter.q || undefined, artist_id: filter.artistId }, opts)
}
export function useFriendTracks(friend: number, filter: { q?: string; artistId?: number; albumId?: number }, opts: ListOptions = {}) {
return usePagedList<Track>(
`/friends/${friend}/tracks`,
{ q: filter.q || undefined, artist_id: filter.artistId, album_id: filter.albumId },
opts,
)
}

View file

@ -2398,6 +2398,163 @@ export interface paths {
patch?: never;
trace?: never;
};
"/friends": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/**
* The friends whose music can be browsed
* @description The friends that both admins agreed to, by name. A listener never sees an address or a key: those are for the
* admin (`GET /federation`). Empty while federation is off.
*/
get: operations["listFriends"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/friends/{friend}/artists": {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
};
cookie?: never;
};
/**
* The artists a friend shares
* @description This server asks the friend, with a request signed by its own key, and passes the page on after checking its
* shape; nothing is kept. Only what the friend shares is there. `q`, `limit` and `offset` are the same as in
* `GET /artists`. A friend that cannot be reached is `502` (`friend_unreachable`); one that no longer takes this
* server for a friend is `409` (`friend_gone`).
*/
get: operations["listFriendArtists"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/friends/{friend}/artists/{id}": {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
id: components["parameters"]["Id"];
};
cookie?: never;
};
/** One artist of a friend */
get: operations["getFriendArtist"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/friends/{friend}/albums": {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
};
cookie?: never;
};
/**
* The albums a friend shares
* @description Like `GET /friends/{friend}/artists`, for albums; `artist_id` is the friend's own id of an artist.
*/
get: operations["listFriendAlbums"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/friends/{friend}/albums/{id}": {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
id: components["parameters"]["Id"];
};
cookie?: never;
};
/** One album of a friend */
get: operations["getFriendAlbum"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/friends/{friend}/tracks": {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
};
cookie?: never;
};
/**
* The tracks a friend shares
* @description Like `GET /friends/{friend}/artists`, for tracks; `artist_id` and `album_id` are the friend's own ids. The ids in
* every answer are the friend's, never this server's: a listener keeps the friend and the id together.
*/
get: operations["listFriendTracks"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/friends/{friend}/tracks/{id}": {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
id: components["parameters"]["Id"];
};
cookie?: never;
};
/** One track of a friend */
get: operations["getFriendTrack"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
}
export type webhooks = Record<string, never>;
export interface components {
@ -3475,6 +3632,14 @@ export interface components {
*/
bytes: number;
};
FriendRef: {
/**
* Format: int64
* @description Names the friend in the routes under `/friends`.
*/
id: number;
name: string;
};
PeerInfo: {
name: string;
/** @description How many libraries are shared with friends. */
@ -3539,6 +3704,35 @@ export interface components {
"application/json": components["schemas"]["Error"];
};
};
/** @description The friend no longer takes this server for a friend (`friend_gone`). */
FriendGone: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description The friend is busy (`friend_busy`). Try again after `Retry-After` seconds. */
FriendBusy: {
headers: {
/** @description Seconds to wait. */
"Retry-After"?: number;
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description The friend could not be reached, or sent something that is not a catalogue page (`friend_unreachable`). */
FriendUnreachable: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Federation is off on this server, so the route is as good as missing (`not_found`). */
FederationOff: {
headers: {
@ -7770,4 +7964,282 @@ export interface operations {
};
};
};
listFriends: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
/** @description The friends, oldest first. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
friends: components["schemas"]["FriendRef"][];
};
};
};
401: components["responses"]["Unauthorized"];
};
};
listFriendArtists: {
parameters: {
query?: {
/**
* @description Case- and accent-insensitive substring of the name or title: `bjork`, `BJORK` and `BJÖRK` all
* find `Björk`, and `strasse` finds `Straße`. At most 200 characters.
*/
q?: components["parameters"]["Q"];
/** @description Page size. 50 when absent or 0; values above 200 are lowered to 200. */
limit?: components["parameters"]["Limit"];
offset?: components["parameters"]["Offset"];
};
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description A page of artists. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ArtistPage"];
};
};
400: components["responses"]["InvalidInput"];
401: components["responses"]["Unauthorized"];
/** @description No such friend, or it is not active (`friend_not_found`). */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
409: components["responses"]["FriendGone"];
429: components["responses"]["FriendBusy"];
502: components["responses"]["FriendUnreachable"];
};
};
getFriendArtist: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
id: components["parameters"]["Id"];
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description The artist. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Artist"];
};
};
400: components["responses"]["InvalidInput"];
401: components["responses"]["Unauthorized"];
/** @description No such friend, or it is not active (`friend_not_found`) or the friend has no such artist (`artist_not_found`). */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
409: components["responses"]["FriendGone"];
429: components["responses"]["FriendBusy"];
502: components["responses"]["FriendUnreachable"];
};
};
listFriendAlbums: {
parameters: {
query?: {
/**
* @description Case- and accent-insensitive substring of the name or title: `bjork`, `BJORK` and `BJÖRK` all
* find `Björk`, and `strasse` finds `Straße`. At most 200 characters.
*/
q?: components["parameters"]["Q"];
/** @description Page size. 50 when absent or 0; values above 200 are lowered to 200. */
limit?: components["parameters"]["Limit"];
offset?: components["parameters"]["Offset"];
artist_id?: components["parameters"]["ArtistId"];
};
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description A page of albums. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["AlbumPage"];
};
};
400: components["responses"]["InvalidInput"];
401: components["responses"]["Unauthorized"];
/** @description No such friend, or it is not active (`friend_not_found`). */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
409: components["responses"]["FriendGone"];
429: components["responses"]["FriendBusy"];
502: components["responses"]["FriendUnreachable"];
};
};
getFriendAlbum: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
id: components["parameters"]["Id"];
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description The album. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Album"];
};
};
400: components["responses"]["InvalidInput"];
401: components["responses"]["Unauthorized"];
/** @description No such friend, or it is not active (`friend_not_found`) or the friend has no such album (`album_not_found`). */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
409: components["responses"]["FriendGone"];
429: components["responses"]["FriendBusy"];
502: components["responses"]["FriendUnreachable"];
};
};
listFriendTracks: {
parameters: {
query?: {
/**
* @description Case- and accent-insensitive substring of the name or title: `bjork`, `BJORK` and `BJÖRK` all
* find `Björk`, and `strasse` finds `Straße`. At most 200 characters.
*/
q?: components["parameters"]["Q"];
/** @description Page size. 50 when absent or 0; values above 200 are lowered to 200. */
limit?: components["parameters"]["Limit"];
offset?: components["parameters"]["Offset"];
artist_id?: components["parameters"]["ArtistId"];
album_id?: components["parameters"]["AlbumId"];
};
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description A page of tracks. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["TrackPage"];
};
};
400: components["responses"]["InvalidInput"];
401: components["responses"]["Unauthorized"];
/** @description No such friend, or it is not active (`friend_not_found`). */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
409: components["responses"]["FriendGone"];
429: components["responses"]["FriendBusy"];
502: components["responses"]["FriendUnreachable"];
};
};
getFriendTrack: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id from `GET /friends`. */
friend: number;
id: components["parameters"]["Id"];
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description The track. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Track"];
};
};
400: components["responses"]["InvalidInput"];
401: components["responses"]["Unauthorized"];
/** @description No such friend, or it is not active (`friend_not_found`) or the friend has no such track (`track_not_found`). */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
409: components["responses"]["FriendGone"];
429: components["responses"]["FriendBusy"];
502: components["responses"]["FriendUnreachable"];
};
};
}

View file

@ -25,6 +25,9 @@ async function renderAt(path: string) {
await screen.findByRole('main')
}
/** The menu asks which friends there are; the tests below are about what an admin page asks. */
const notFriends = (c: { url: URL }) => c.url.pathname !== '/api/v1/friends'
function mainNav() {
return screen.getByRole('navigation', { name: 'Main' })
}
@ -95,7 +98,7 @@ test('someone who is not an admin who opens the jobs address gets a notice and n
await renderAt('/admin/jobs')
expect(await screen.findByText('Only admins can see this page.')).toBeInTheDocument()
await new Promise((r) => setTimeout(r, 30))
expect(calls).toHaveLength(0)
expect(calls.filter(notFriends)).toHaveLength(0)
})
test('someone who is not an admin who opens the providers address gets a notice and no request', async () => {
@ -104,7 +107,7 @@ test('someone who is not an admin who opens the providers address gets a notice
await renderAt('/admin/providers')
expect(await screen.findByText('Only admins can see this page.')).toBeInTheDocument()
await new Promise((r) => setTimeout(r, 30))
expect(calls).toHaveLength(0)
expect(calls.filter(notFriends)).toHaveLength(0)
})
test('someone who is not an admin who opens the users address gets a notice and no request', async () => {
@ -113,7 +116,7 @@ test('someone who is not an admin who opens the users address gets a notice and
await renderAt('/admin/users')
expect(await screen.findByText('Only admins can see this page.')).toBeInTheDocument()
await new Promise((r) => setTimeout(r, 30))
expect(calls).toHaveLength(0)
expect(calls.filter(notFriends)).toHaveLength(0)
})
test('someone who is not an admin who opens the admin address gets a notice and no request', async () => {

View file

@ -1,9 +1,11 @@
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { render, screen, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { MemoryRouter } from 'react-router-dom'
import { beforeEach, expect, test, vi } from 'vitest'
import { sessionStore } from '@/auth/session'
import { initI18n } from '@/i18n'
import { mockFetch } from '@/test/mockFetch'
import Sidebar from './Sidebar'
const KEY = 'sonda.sidebar'
@ -15,11 +17,14 @@ beforeEach(async () => {
sessionStore.setState({ status: 'authenticated', user: { id: 1, email: 'tom@example.org', is_admin: true } })
})
function renderSidebar() {
function renderSidebar(friends: { id: number; name: string }[] = []) {
mockFetch({ 'GET /api/v1/friends': () => ({ friends }) })
render(
<MemoryRouter initialEntries={['/albums']}>
<Sidebar />
</MemoryRouter>,
<QueryClientProvider client={new QueryClient({ defaultOptions: { queries: { retry: false } } })}>
<MemoryRouter initialEntries={['/albums']}>
<Sidebar />
</MemoryRouter>
</QueryClientProvider>,
)
return screen.getByRole('navigation', { name: 'Main' })
}
@ -79,3 +84,14 @@ test('a browser that will not keep it still folds and opens the sidebar', async
await userEvent.click(within(nav).getByRole('button', { name: 'Collapse the sidebar' }))
expect(nav).toHaveAttribute('data-collapsed', 'true')
})
test('Friends is in the menu only when there is a friend to browse', async () => {
const none = renderSidebar()
await screen.findByRole('link', { name: 'Albums' })
expect(within(none).queryByRole('link', { name: 'Friends' })).not.toBeInTheDocument()
})
test('with a friend the menu has a Friends link', async () => {
const nav = renderSidebar([{ id: 3, name: 'Anna' }])
expect(await within(nav).findByRole('link', { name: 'Friends' })).toHaveAttribute('href', '/friends')
})

View file

@ -1,14 +1,15 @@
import {
Compass, Disc3, House, ListMusic, Mic2, Music, PanelLeftClose, PanelLeftOpen, Search, Settings, ShieldCheck, Sparkles, Wand2, type LucideIcon,
Compass, Disc3, House, ListMusic, Mic2, Music, PanelLeftClose, PanelLeftOpen, Search, Settings, ShieldCheck, Sparkles, Users, Wand2, type LucideIcon,
} from 'lucide-react'
import { useState } from 'react'
import { NavLink } from 'react-router-dom'
import { useTranslation } from 'react-i18next'
import { useFriends } from '@/api/friends'
import { useSession } from '@/auth/session'
import Logo from '@/components/Logo'
import { cn } from '@/lib/utils'
const LINKS: { to: string; key: string; icon: LucideIcon; end: boolean; adminOnly: boolean }[] = [
const LINKS: { to: string; key: string; icon: LucideIcon; end: boolean; adminOnly: boolean; friends?: boolean }[] = [
{ to: '/', key: 'nav.home', icon: House, end: true, adminOnly: false },
{ to: '/search', key: 'nav.search', icon: Search, end: false, adminOnly: false },
{ to: '/discover', key: 'nav.discover', icon: Compass, end: false, adminOnly: false },
@ -18,6 +19,7 @@ const LINKS: { to: string; key: string; icon: LucideIcon; end: boolean; adminOnl
{ to: '/mixes', key: 'nav.mixes', icon: Sparkles, end: false, adminOnly: false },
{ to: '/playlists', key: 'nav.playlists', icon: ListMusic, end: false, adminOnly: false },
{ to: '/smart-playlists', key: 'nav.smartPlaylists', icon: Wand2, end: false, adminOnly: false },
{ to: '/friends', key: 'nav.friends', icon: Users, end: false, adminOnly: false, friends: true },
{ to: '/admin', key: 'nav.admin', icon: ShieldCheck, end: false, adminOnly: true },
{ to: '/settings', key: 'nav.settings', icon: Settings, end: false, adminOnly: false },
]
@ -48,7 +50,9 @@ export default function Sidebar() {
const { t } = useTranslation()
const { user } = useSession()
const [collapsed, setCollapsed] = useState(readCollapsed)
const links = LINKS.filter((link) => !link.adminOnly || user?.is_admin)
// Friends is in the menu only when there is a friend to browse (federation on, and a friendship both admins agreed to).
const hasFriends = (useFriends().data?.length ?? 0) > 0
const links = LINKS.filter((link) => (!link.adminOnly || user?.is_admin) && (!link.friends || hasFriends))
function toggle() {
writeCollapsed(!collapsed)

View file

@ -17,6 +17,7 @@
"mixes": "Mixes",
"playlists": "Playlists",
"smartPlaylists": "Smart playlists",
"friends": "Friends",
"admin": "Admin",
"settings": "Settings"
},
@ -543,6 +544,36 @@
"cancel": "Cancel"
}
},
"friends": {
"title": "Friends",
"intro": "Music that the admin of another Sonda server shares with this one. It is asked for from their server when you open a page, and nothing is copied here.",
"noneYet": "You have no friends yet. An admin makes friends in Admin → Federation.",
"musicOf": "Music of {{name}}",
"whose": "{{name}}’s server shares this music. It is asked for when you open a page and is never copied here.",
"noPlayYet": "For now you can browse this music; playing it comes next.",
"searchLabel": "Search the music of {{name}}",
"searchPlaceholder": "Artists, albums and songs",
"tabsLabel": "Sections of {{name}}’s music",
"tabs": {
"artists": "Artists",
"albums": "Albums",
"songs": "Songs"
},
"albumCount_one": "{{count}} album",
"albumCount_other": "{{count}} albums",
"songCount_one": "{{count}} song",
"songCount_other": "{{count}} songs",
"albumsOf": "Albums of {{name}}",
"songsOf": "Songs of {{name}}",
"showAll": "Show all",
"nothing": "{{name}} has not shared anything yet.",
"errors": {
"friend_unreachable": "{{name}} could not be reached. Try again later.",
"friend_gone": "{{name}} no longer takes this server for a friend. An admin can tell you more.",
"friend_busy": "{{name}} is busy. Try again in a moment.",
"friend_not_found": "This friend is not there any more."
}
},
"home": {
"greeting_morning": "Good morning",
"greeting_afternoon": "Good afternoon",

Some files were not shown because too many files have changed in this diff Show more