feat(federation): shared libraries and the signed read API for friends
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.
This commit is contained in:
parent
346466c621
commit
89826fcd07
28 changed files with 3970 additions and 60 deletions
|
|
@ -109,6 +109,9 @@ func newTestEnvDB(t *testing.T, mutate func(*Deps, *bun.DB)) (http.Handler, *bun
|
|||
Streams: streaming.NewService(noFiles{}),
|
||||
Federation: federation.NewService(storage.NewFederationRepo(db), federation.NewClient()),
|
||||
}
|
||||
libRepo := storage.NewLibraryRepo(db)
|
||||
deps.PeerCatalog = catalog.NewService(storage.NewSharedCatalogRepo(db))
|
||||
deps.PeerStreams = streaming.NewService(libRepo.Shared())
|
||||
feedbackSvc := feedback.NewService(storage.NewFeedbackRepo(db))
|
||||
deps.Feedback = feedbackSvc
|
||||
deps.Playlists = playlists.NewService(storage.NewPlaylistRepo(db))
|
||||
|
|
@ -120,6 +123,7 @@ func newTestEnvDB(t *testing.T, mutate func(*Deps, *bun.DB)) (http.Handler, *bun
|
|||
imageRepo := storage.NewImageRepo(db)
|
||||
imageSvc := images.NewService(filepath.Join(t.TempDir(), "data"), imageRepo, imageRepo)
|
||||
deps.Images, deps.ArtistImages = imageSvc, imageSvc
|
||||
deps.PeerCovers = images.StoredOnly{Service: imageSvc}
|
||||
deps.CoversJob = jobs.Runner{Ctx: context.Background(), Job: images.NewCoversJob(imageSvc, imageRepo)}
|
||||
deps.ArtistImagesJob = jobs.Runner{Ctx: context.Background(), Job: images.NewArtistImagesJob(imageSvc, imageRepo)}
|
||||
mutate(&deps, db)
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@ package httpapi
|
|||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"image"
|
||||
|
|
@ -29,6 +31,7 @@ import (
|
|||
"codeberg.org/squidd/sonda/internal/catalog"
|
||||
"codeberg.org/squidd/sonda/internal/discovery"
|
||||
"codeberg.org/squidd/sonda/internal/duplicates"
|
||||
"codeberg.org/squidd/sonda/internal/federation"
|
||||
"codeberg.org/squidd/sonda/internal/images"
|
||||
"codeberg.org/squidd/sonda/internal/jobs"
|
||||
"codeberg.org/squidd/sonda/internal/library"
|
||||
|
|
@ -157,6 +160,7 @@ func newContract(t *testing.T) *contract {
|
|||
pictures.SetArtistSource(&fakeArtistPictures{found: images.Found{Data: testJPEG(t, 800, 600, color.White),
|
||||
Credit: images.Credit{Author: "Someone", License: "CC BY 4.0", LicenseURL: "https://creativecommons.org/licenses/by/4.0", PageURL: "https://commons.wikimedia.org/wiki/File:X.jpg"}}})
|
||||
d.Images, d.ArtistImages = pictures, pictures
|
||||
d.PeerCovers = images.StoredOnly{Service: pictures}
|
||||
d.LidarrArtists = lidarr.NewService(storage.NewDiscoveryRepo(db), prov, fakeLidarrRemote{})
|
||||
})
|
||||
|
||||
|
|
@ -241,8 +245,8 @@ func (c *contract) validate(req *http.Request, payload []byte, rec *httptest.Res
|
|||
// The library skips HEAD and redirects, and cannot read audio or YAML.
|
||||
// Those are checked by hand: the status above, and the content type here.
|
||||
skipBody := req.Method == http.MethodHead || route.Path == "/openapi.yaml" ||
|
||||
(rec.Code >= 300 && rec.Code < 400) || (route.Path == "/tracks/{id}/stream" && rec.Code/100 == 2)
|
||||
if skipBody && documented != nil && documented.Value != nil && rec.Code/100 == 2 && req.Method != http.MethodHead && route.Path == "/tracks/{id}/stream" {
|
||||
(rec.Code >= 300 && rec.Code < 400) || ((route.Path == "/tracks/{id}/stream" || route.Path == "/peer/tracks/{id}/stream") && rec.Code/100 == 2)
|
||||
if skipBody && documented != nil && documented.Value != nil && rec.Code/100 == 2 && req.Method != http.MethodHead && (route.Path == "/tracks/{id}/stream" || route.Path == "/peer/tracks/{id}/stream") {
|
||||
mediaType, _, err := mime.ParseMediaType(rec.Header().Get("Content-Type"))
|
||||
if err != nil || documented.Value.Content.Get(mediaType) == nil {
|
||||
c.t.Errorf("%s -> %d: Content-Type %q is not one the spec lists", where, rec.Code, rec.Header().Get("Content-Type"))
|
||||
|
|
@ -828,7 +832,7 @@ func TestResponsesMatchTheSpec(t *testing.T) {
|
|||
c.mixes(t, token, libID)
|
||||
c.smartPlaylists(t, token)
|
||||
c.names(t, token)
|
||||
c.federation(t, token)
|
||||
c.federation(t, token, libID, albumID)
|
||||
|
||||
// ---- every operation in the spec was exercised ----
|
||||
var missing []string
|
||||
|
|
@ -1126,7 +1130,7 @@ func (c *contract) names(t *testing.T, token string) {
|
|||
c.expect(c.call("POST", "/smart-playlists/999999/suggest-name", token, nil), 404, "a name for an unknown smart playlist", "smart_playlist_not_found")
|
||||
}
|
||||
|
||||
func (c *contract) federation(t *testing.T, token string) {
|
||||
func (c *contract) federation(t *testing.T, token, libID, albumID string) {
|
||||
t.Helper()
|
||||
for _, r := range []struct{ method, path string }{
|
||||
{"GET", "/federation"}, {"PUT", "/federation"}, {"POST", "/federation/invites"}, {"POST", "/federation/friends"},
|
||||
|
|
@ -1170,6 +1174,8 @@ func (c *contract) federation(t *testing.T, token string) {
|
|||
c.expect(c.call("DELETE", "/federation/friends/"+id, token, nil), 204, "end the friendship")
|
||||
c.expect(c.call("DELETE", "/federation/friends/"+id, token, nil), 404, "end it twice", "friend_not_found")
|
||||
|
||||
c.peer(t, token, libID, albumID)
|
||||
|
||||
// This server uses an invite of another one, which is a real server of its own.
|
||||
other := newFriendServer(t, true)
|
||||
other.setUp(t, "Anna", other.ts.URL)
|
||||
|
|
@ -1180,6 +1186,8 @@ func (c *contract) federation(t *testing.T, token string) {
|
|||
t.Fatalf("friend = %v", friend)
|
||||
}
|
||||
c.expect(c.call("POST", "/federation/friends", token, map[string]any{"invite": theirs.Body["invite"]}), 409, "use the invite of a friend", "already_friends")
|
||||
c.expect(c.call("POST", "/federation/friends/"+idOf(friend)+"/check", token, nil), 409, "ask a friend that has not approved", "not_approved")
|
||||
c.expect(c.call("POST", "/federation/friends/999999/check", token, nil), 404, "check a missing friend", "friend_not_found")
|
||||
c.expect(c.call("DELETE", "/federation/friends/"+idOf(friend), token, nil), 204, "withdraw the request")
|
||||
again := other.call(t, "POST", "/federation/invites", nil)
|
||||
other.ts.Close()
|
||||
|
|
@ -1201,3 +1209,77 @@ func inviteCode(t *testing.T, text string) string {
|
|||
}
|
||||
return p.C
|
||||
}
|
||||
|
||||
// peer plays the part of a friend: it holds a key of its own, is paired and approved, and reads what is shared.
|
||||
func (c *contract) peer(t *testing.T, token, libID, albumID string) {
|
||||
t.Helper()
|
||||
c.expect(c.call("PATCH", "/libraries/"+libID, token, map[string]any{"shared": true}), 200, "share the library")
|
||||
|
||||
inv := c.expect(c.call("POST", "/federation/invites", token, nil), 201, "an invite for the friend")
|
||||
pub, priv, _ := ed25519.GenerateKey(rand.Reader)
|
||||
c.expect(c.call("POST", "/peer/pair", "", map[string]any{
|
||||
"code": inviteCode(t, inv["invite"].(string)), "name": "Reader", "address": "https://reader.example.org",
|
||||
"public_key": base64.RawURLEncoding.EncodeToString(pub),
|
||||
}), 200, "the friend pairs")
|
||||
var friendID string
|
||||
for _, f := range c.expect(c.call("GET", "/federation", token, nil), 200, "federation")["friends"].([]any) {
|
||||
if f.(map[string]any)["name"] == "Reader" {
|
||||
friendID = idOf(f.(map[string]any))
|
||||
}
|
||||
}
|
||||
c.expect(c.call("POST", "/federation/friends/"+friendID+"/approve", token, nil), 200, "approve the friend")
|
||||
|
||||
var n int
|
||||
signed := func(path string, extra ...string) *httptest.ResponseRecorder {
|
||||
n++
|
||||
h := federation.Sign(priv, "GET", "/api/v1"+path, time.Now(), "contract-nonce-"+strconv.Itoa(n)+"-0123456789")
|
||||
headers := append([]string{
|
||||
federation.HeaderKeyID, federation.KeyID(pub), federation.HeaderDate, h.Date,
|
||||
federation.HeaderNonce, h.Nonce, federation.HeaderSignature, h.Signature,
|
||||
}, extra...)
|
||||
return c.call("GET", path, "", nil, headers...)
|
||||
}
|
||||
|
||||
c.expect(c.call("GET", "/peer/info", "", nil), 401, "a friend's route without a signature", "unauthorized")
|
||||
info := c.expect(signed("/peer/info"), 200, "who this server is")
|
||||
if info["shared_libraries"] != float64(1) {
|
||||
t.Fatalf("info = %v", info)
|
||||
}
|
||||
artists := c.expect(signed("/peer/artists?limit=5"), 200, "the artists of the shared libraries")
|
||||
if artists["total"].(float64) == 0 {
|
||||
t.Fatalf("artists = %v", artists)
|
||||
}
|
||||
c.expect(signed("/peer/artists/"+idOf(artists["items"].([]any)[0].(map[string]any))), 200, "one artist")
|
||||
c.expect(signed("/peer/artists/999999"), 404, "an artist that is not there", "artist_not_found")
|
||||
c.expect(signed("/peer/albums?q=a&limit=5"), 200, "the albums")
|
||||
c.expect(signed("/peer/albums/"+albumID), 200, "one album")
|
||||
c.expect(signed("/peer/albums/999999"), 404, "an album that is not there", "album_not_found")
|
||||
tracks := c.expect(signed("/peer/tracks?limit=5"), 200, "the tracks")
|
||||
trackID := idOf(tracks["items"].([]any)[0].(map[string]any))
|
||||
c.expect(signed("/peer/tracks/"+trackID), 200, "one track")
|
||||
c.expect(signed("/peer/tracks/999999"), 404, "a track that is not there", "track_not_found")
|
||||
|
||||
if rec := signed("/peer/tracks/" + trackID + "/stream"); rec.Code != 200 {
|
||||
t.Fatalf("stream: %d %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if rec := signed("/peer/tracks/"+trackID+"/stream", "Range", "bytes=0-9"); rec.Code != 206 {
|
||||
t.Fatalf("stream range: %d", rec.Code)
|
||||
}
|
||||
c.expect(signed("/peer/tracks/999999/stream"), 404, "the stream of a track that is not there", "track_not_found")
|
||||
// A friend gets a cover once a listener's request has built it, never before.
|
||||
c.expect(signed("/peer/albums/"+albumID+"/cover?size=small"), 404, "a cover that was not asked for yet", "cover_not_found")
|
||||
if rec := c.call("GET", "/albums/"+albumID+"/cover", token, nil); rec.Code != 200 {
|
||||
t.Fatalf("the listener's cover: %d %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if rec := signed("/peer/albums/" + albumID + "/cover"); rec.Code != 200 || rec.Header().Get("Content-Type") != "image/jpeg" {
|
||||
t.Fatalf("cover: %d %q", rec.Code, rec.Header().Get("Content-Type"))
|
||||
}
|
||||
c.expect(signed("/peer/albums/999999/cover"), 404, "the cover of an album that is not there", "album_not_found")
|
||||
|
||||
reqs := c.expect(c.call("GET", "/federation/requests", token, nil), 200, "what friends asked")["requests"].([]any)
|
||||
if len(reqs) == 0 {
|
||||
t.Fatal("no request was logged")
|
||||
}
|
||||
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")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ func TestFederationStartsOffAndSaysWhatItSends(t *testing.T) {
|
|||
if r.Code != http.StatusOK {
|
||||
t.Fatalf("get: %d %v", r.Code, r.Body)
|
||||
}
|
||||
sameKeys(t, "federation", r.Body, "enabled", "name", "address", "key_id", "sends", "friends")
|
||||
sameKeys(t, "federation", r.Body, "enabled", "name", "address", "key_id", "sends", "friends", "max_streams", "max_kib_per_sec")
|
||||
if r.Body["enabled"] != false || r.Body["key_id"] != "" || r.Body["address"] != "" {
|
||||
t.Errorf("federation must start off with no key and no address: %v", r.Body)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,6 +20,13 @@ type federationService interface {
|
|||
Pair(ctx context.Context, req federation.PairRequest) (federation.PairReply, error)
|
||||
Approve(ctx context.Context, id int64) (federation.Friend, error)
|
||||
Remove(ctx context.Context, id int64) error
|
||||
Check(ctx context.Context, id int64) (federation.Friend, error)
|
||||
Requests(ctx context.Context) ([]federation.FriendRequest, error)
|
||||
// What the routes friends use need.
|
||||
Authenticate(ctx context.Context, in federation.Signed) (federation.Friend, error)
|
||||
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)
|
||||
}
|
||||
|
||||
// federationHandlers are the admin routes that set up federation and its friends, and the one public route
|
||||
|
|
@ -48,18 +55,20 @@ func toFriendJSON(f federation.Friend) friendJSON {
|
|||
}
|
||||
|
||||
type federationJSON struct {
|
||||
Enabled bool `json:"enabled"`
|
||||
Name string `json:"name"`
|
||||
Address string `json:"address"`
|
||||
KeyID string `json:"key_id"`
|
||||
Sends string `json:"sends"`
|
||||
Friends []friendJSON `json:"friends"`
|
||||
Enabled bool `json:"enabled"`
|
||||
Name string `json:"name"`
|
||||
Address string `json:"address"`
|
||||
KeyID string `json:"key_id"`
|
||||
Sends string `json:"sends"`
|
||||
MaxStreams int `json:"max_streams"`
|
||||
MaxKiBPerSec int `json:"max_kib_per_sec"`
|
||||
Friends []friendJSON `json:"friends"`
|
||||
}
|
||||
|
||||
func toFederationJSON(st federation.Status) federationJSON {
|
||||
out := federationJSON{
|
||||
Enabled: st.Enabled, Name: st.Name, Address: st.Address, KeyID: st.KeyID, Sends: st.Sends,
|
||||
Friends: make([]friendJSON, len(st.Friends)),
|
||||
MaxStreams: st.MaxStreams, MaxKiBPerSec: st.MaxKiBPerSec, Friends: make([]friendJSON, len(st.Friends)),
|
||||
}
|
||||
for i, f := range st.Friends {
|
||||
out.Friends[i] = toFriendJSON(f)
|
||||
|
|
@ -92,6 +101,10 @@ func writeFederationError(c *gin.Context, err error) {
|
|||
writeError(c, http.StatusNotFound, "friend_not_found", "no such friend")
|
||||
case errors.Is(err, federation.ErrWrongState):
|
||||
writeError(c, http.StatusConflict, "not_waiting", err.Error())
|
||||
case errors.Is(err, federation.ErrNotApproved):
|
||||
writeError(c, http.StatusConflict, "not_approved", "the other admin has not approved yet")
|
||||
case errors.Is(err, federation.ErrNotFriend):
|
||||
writeError(c, http.StatusConflict, "friend_gone", err.Error())
|
||||
default:
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
|
|
@ -108,9 +121,11 @@ func (h *federationHandlers) get(c *gin.Context) {
|
|||
}
|
||||
|
||||
type updateFederationRequest struct {
|
||||
Enabled *bool `json:"enabled"` // pointers: an absent field is left alone
|
||||
Name *string `json:"name"`
|
||||
Address *string `json:"address"`
|
||||
Enabled *bool `json:"enabled"` // pointers: an absent field is left alone
|
||||
Name *string `json:"name"`
|
||||
Address *string `json:"address"`
|
||||
MaxStreams *int `json:"max_streams"`
|
||||
MaxKiBPerSec *int `json:"max_kib_per_sec"`
|
||||
}
|
||||
|
||||
func (h *federationHandlers) update(c *gin.Context) {
|
||||
|
|
@ -118,7 +133,9 @@ func (h *federationHandlers) update(c *gin.Context) {
|
|||
if !bindJSON(c, &req) {
|
||||
return
|
||||
}
|
||||
st, err := h.svc.Update(c.Request.Context(), federation.Patch{Enabled: req.Enabled, Name: req.Name, Address: req.Address})
|
||||
st, err := h.svc.Update(c.Request.Context(), federation.Patch{
|
||||
Enabled: req.Enabled, Name: req.Name, Address: req.Address, MaxStreams: req.MaxStreams, MaxKiBPerSec: req.MaxKiBPerSec,
|
||||
})
|
||||
if err != nil {
|
||||
writeFederationError(c, err)
|
||||
return
|
||||
|
|
@ -219,3 +236,38 @@ func (h *federationHandlers) pair(c *gin.Context) {
|
|||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
}
|
||||
}
|
||||
|
||||
func (h *federationHandlers) check(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
f, err := h.svc.Check(c.Request.Context(), id)
|
||||
if err != nil {
|
||||
writeFederationError(c, err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, toFriendJSON(f))
|
||||
}
|
||||
|
||||
type requestJSON struct {
|
||||
At *string `json:"at"`
|
||||
FriendID int64 `json:"friend_id"`
|
||||
Friend string `json:"friend"`
|
||||
Route string `json:"route"`
|
||||
Status int `json:"status"`
|
||||
Bytes int64 `json:"bytes"`
|
||||
}
|
||||
|
||||
func (h *federationHandlers) requests(c *gin.Context) {
|
||||
list, err := h.svc.Requests(c.Request.Context())
|
||||
if err != nil {
|
||||
writeFederationError(c, err)
|
||||
return
|
||||
}
|
||||
out := make([]requestJSON, len(list))
|
||||
for i, r := range list {
|
||||
out[i] = requestJSON{At: rfc3339(r.At), FriendID: r.FriendID, Friend: r.FriendName, Route: r.Route, Status: r.Status, Bytes: r.Bytes}
|
||||
}
|
||||
c.JSON(http.StatusOK, gin.H{"requests": out})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,11 +17,12 @@ type libraryJSON struct {
|
|||
ID int64 `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Path string `json:"path"`
|
||||
Shared bool `json:"shared"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
func toLibraryJSON(l library.Library) libraryJSON {
|
||||
return libraryJSON{ID: l.ID, Name: l.Name, Path: l.Path, CreatedAt: l.CreatedAt.UTC().Format(time.RFC3339)}
|
||||
return libraryJSON{ID: l.ID, Name: l.Name, Path: l.Path, Shared: l.Shared, CreatedAt: l.CreatedAt.UTC().Format(time.RFC3339)}
|
||||
}
|
||||
|
||||
func writeLibraryError(c *gin.Context, err error) {
|
||||
|
|
@ -74,6 +75,8 @@ func (h *librariesHandlers) create(c *gin.Context) {
|
|||
type updateLibraryRequest struct {
|
||||
Name *string `json:"name"` // pointers: an absent field keeps the current value
|
||||
Path *string `json:"path"`
|
||||
// Shared says whether friends (federation) may read the library.
|
||||
Shared *bool `json:"shared"`
|
||||
}
|
||||
|
||||
func (h *librariesHandlers) update(c *gin.Context) {
|
||||
|
|
@ -85,11 +88,18 @@ func (h *librariesHandlers) update(c *gin.Context) {
|
|||
if !bindJSON(c, &req) {
|
||||
return
|
||||
}
|
||||
if req.Name == nil && req.Path == nil {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "send name, path or both")
|
||||
if req.Name == nil && req.Path == nil && req.Shared == nil {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "send name, path, shared or any of them")
|
||||
return
|
||||
}
|
||||
lib, err := h.svc.Update(c.Request.Context(), id, req.Name, req.Path)
|
||||
var lib library.Library
|
||||
var err error
|
||||
if req.Name != nil || req.Path != nil {
|
||||
lib, err = h.svc.Update(c.Request.Context(), id, req.Name, req.Path)
|
||||
}
|
||||
if err == nil && req.Shared != nil {
|
||||
lib, err = h.svc.SetShared(c.Request.Context(), id, *req.Shared)
|
||||
}
|
||||
if err != nil {
|
||||
writeLibraryError(c, err)
|
||||
return
|
||||
|
|
|
|||
194
internal/api/http/handlers_peer.go
Normal file
194
internal/api/http/handlers_peer.go
Normal file
|
|
@ -0,0 +1,194 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/catalog"
|
||||
"codeberg.org/squidd/sonda/internal/federation"
|
||||
)
|
||||
|
||||
const (
|
||||
peerPrefix = "/api/v1/peer/"
|
||||
friendKey = "friend"
|
||||
peerChunkSize = 32 << 10
|
||||
)
|
||||
|
||||
// registerPeer adds the routes another Sonda server reads, to v1. A friend signs every request (see
|
||||
// federation.Sign); what it can read is the catalogue and the files of the libraries that are shared, and nothing
|
||||
// else: the services it is given are the ones that look only at those.
|
||||
func registerPeer(v1 *gin.RouterGroup, d Deps) {
|
||||
peer := v1.Group("/peer", requireFriend(d.Federation))
|
||||
peer.GET("/info", (&peerInfoHandlers{fed: d.Federation, libs: d.Libraries}).info)
|
||||
|
||||
cat := &catalogHandlers{svc: d.PeerCatalog}
|
||||
peer.GET("/artists", cat.listArtists)
|
||||
peer.GET("/artists/:id", cat.getArtist)
|
||||
peer.GET("/albums", cat.listAlbums)
|
||||
peer.GET("/albums/:id", cat.getAlbum)
|
||||
peer.GET("/tracks", cat.listTracks)
|
||||
peer.GET("/tracks/:id", cat.getTrack)
|
||||
|
||||
peer.GET("/albums/:id/cover", (&peerCoverHandlers{fed: d.Federation, catalog: d.PeerCatalog, covers: &coverHandlers{svc: d.PeerCovers}}).album)
|
||||
peer.GET("/tracks/:id/stream", (&peerStreamHandlers{fed: d.Federation, inner: &streamHandlers{svc: d.PeerStreams}}).stream)
|
||||
}
|
||||
|
||||
// requireFriend lets a request through only when a friend signed it. Everything that is not properly signed is
|
||||
// the same 401, and while federation is off the routes are missing. Each request of a friend is logged afterwards:
|
||||
// the route (never the query), the status and the bytes sent.
|
||||
func requireFriend(fed federationService) gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
uri := c.Request.URL.RequestURI()
|
||||
// A proxy may serve Sonda under a sub-path: what is signed starts at /api/v1/peer.
|
||||
if i := strings.Index(uri, peerPrefix); i > 0 {
|
||||
uri = uri[i:]
|
||||
}
|
||||
friend, err := fed.Authenticate(c.Request.Context(), federation.Signed{
|
||||
KeyID: c.GetHeader(federation.HeaderKeyID),
|
||||
Date: c.GetHeader(federation.HeaderDate),
|
||||
Nonce: c.GetHeader(federation.HeaderNonce),
|
||||
Signature: c.GetHeader(federation.HeaderSignature),
|
||||
Method: c.Request.Method,
|
||||
URI: uri,
|
||||
})
|
||||
switch {
|
||||
case err == nil:
|
||||
case errors.Is(err, federation.ErrOff):
|
||||
writeError(c, http.StatusNotFound, "not_found", "no such route")
|
||||
return
|
||||
case errors.Is(err, federation.ErrUnauthorized):
|
||||
writeError(c, http.StatusUnauthorized, "unauthorized", "the request is not signed by a friend")
|
||||
return
|
||||
case errors.Is(err, federation.ErrNotApproved):
|
||||
writeError(c, http.StatusForbidden, "not_approved", "the friendship is not approved yet")
|
||||
return
|
||||
default:
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
return
|
||||
}
|
||||
c.Set(friendKey, friend)
|
||||
c.Next()
|
||||
sent := int64(c.Writer.Size())
|
||||
if sent < 0 {
|
||||
sent = 0
|
||||
}
|
||||
fed.Record(c.Request.Context(), federation.FriendRequest{FriendID: friend.ID, Route: c.FullPath(), Status: c.Writer.Status(), Bytes: sent})
|
||||
}
|
||||
}
|
||||
|
||||
func friendOf(c *gin.Context) federation.Friend {
|
||||
f, _ := c.Get(friendKey)
|
||||
friend, _ := f.(federation.Friend)
|
||||
return friend
|
||||
}
|
||||
|
||||
type peerInfoHandlers struct {
|
||||
fed federationService
|
||||
libs libraryService
|
||||
}
|
||||
|
||||
// info says who this server is and how many libraries are shared; no more.
|
||||
func (h *peerInfoHandlers) info(c *gin.Context) {
|
||||
st, err := h.fed.Status(c.Request.Context())
|
||||
if err != nil {
|
||||
writeFederationError(c, err)
|
||||
return
|
||||
}
|
||||
libs, err := h.libs.List(c.Request.Context())
|
||||
if err != nil {
|
||||
writeLibraryError(c, err)
|
||||
return
|
||||
}
|
||||
shared := 0
|
||||
for _, l := range libs {
|
||||
if l.Shared {
|
||||
shared++
|
||||
}
|
||||
}
|
||||
c.JSON(http.StatusOK, gin.H{"name": st.Name, "shared_libraries": shared})
|
||||
}
|
||||
|
||||
// pacedWriter slows the body of an answer to what the friend's allowance says.
|
||||
type pacedWriter struct {
|
||||
gin.ResponseWriter
|
||||
st *federation.Stream
|
||||
ctx context.Context
|
||||
}
|
||||
|
||||
func (w *pacedWriter) Write(p []byte) (int, error) {
|
||||
written := 0
|
||||
for len(p) > 0 {
|
||||
n := min(len(p), peerChunkSize)
|
||||
if err := w.st.Wait(w.ctx, n); err != nil {
|
||||
return written, err
|
||||
}
|
||||
m, err := w.ResponseWriter.Write(p[:n])
|
||||
written += m
|
||||
if err != nil {
|
||||
return written, err
|
||||
}
|
||||
p = p[n:]
|
||||
}
|
||||
return written, nil
|
||||
}
|
||||
|
||||
type peerStreamHandlers struct {
|
||||
fed federationService
|
||||
inner *streamHandlers
|
||||
}
|
||||
|
||||
// stream serves a track of a shared library to a friend, as a listener would get it, within the friend's
|
||||
// allowance: a few streams at a time, and a number of bytes a second.
|
||||
func (h *peerStreamHandlers) stream(c *gin.Context) {
|
||||
st, err := h.fed.StartStream(c.Request.Context(), friendOf(c).ID)
|
||||
if errors.Is(err, federation.ErrTooManyStreams) {
|
||||
c.Header("Retry-After", "5")
|
||||
writeError(c, http.StatusTooManyRequests, "too_many_streams", "this server already streams as much to you as it allows")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
return
|
||||
}
|
||||
defer st.Close()
|
||||
c.Writer = &pacedWriter{ResponseWriter: c.Writer, st: st, ctx: c.Request.Context()}
|
||||
h.inner.stream(c)
|
||||
}
|
||||
|
||||
type peerCoverHandlers struct {
|
||||
fed federationService
|
||||
catalog catalogService
|
||||
covers *coverHandlers
|
||||
}
|
||||
|
||||
// album serves a cover that was already built, for an album that has a track in a shared library.
|
||||
func (h *peerCoverHandlers) album(c *gin.Context) {
|
||||
id, ok := pathID(c)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if _, err := h.catalog.Album(c.Request.Context(), id); err != nil {
|
||||
if errors.Is(err, catalog.ErrNotFound) {
|
||||
writeError(c, http.StatusNotFound, "album_not_found", "no such album")
|
||||
return
|
||||
}
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
return
|
||||
}
|
||||
st, err := h.fed.Pace(c.Request.Context(), friendOf(c).ID)
|
||||
if err != nil {
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
return
|
||||
}
|
||||
defer st.Close()
|
||||
c.Writer = &pacedWriter{ResponseWriter: c.Writer, st: st, ctx: c.Request.Context()}
|
||||
h.covers.album(c)
|
||||
}
|
||||
|
|
@ -190,6 +190,9 @@ func (busyLibraries) Create(context.Context, string, string) (library.Library, e
|
|||
func (busyLibraries) Update(context.Context, int64, *string, *string) (library.Library, error) {
|
||||
return library.Library{}, library.ErrScanRunning
|
||||
}
|
||||
func (busyLibraries) SetShared(context.Context, int64, bool) (library.Library, error) {
|
||||
return library.Library{}, nil
|
||||
}
|
||||
func (busyLibraries) Delete(context.Context, int64) error { return library.ErrScanRunning }
|
||||
|
||||
func TestLibraryChangesDuringAScanAreConflicts(t *testing.T) {
|
||||
|
|
|
|||
526
internal/api/http/peer_test.go
Normal file
526
internal/api/http/peer_test.go
Normal file
|
|
@ -0,0 +1,526 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/ed25519"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/uptrace/bun"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/federation"
|
||||
"codeberg.org/squidd/sonda/internal/library"
|
||||
"codeberg.org/squidd/sonda/internal/storage"
|
||||
)
|
||||
|
||||
// peerFixture is a server with two libraries, one that can be shared and one that cannot, and a friend that holds
|
||||
// a key of its own.
|
||||
type peerFixture struct {
|
||||
h http.Handler
|
||||
db *bun.DB
|
||||
admin string
|
||||
fed *federation.Service
|
||||
pub ed25519.PublicKey
|
||||
priv ed25519.PrivateKey
|
||||
shared int64 // library ids
|
||||
private int64
|
||||
track map[string]int64
|
||||
friendID string
|
||||
bytes map[string][]byte // what each file holds
|
||||
nonce atomic.Int64
|
||||
}
|
||||
|
||||
func peerParsed(rel, title, album, artist string) library.ParsedFile {
|
||||
return library.ParsedFile{
|
||||
FileInfo: library.FileInfo{RelPath: rel, Size: 400, MTimeUnix: 1_700_000_000},
|
||||
Metadata: library.Metadata{
|
||||
Tags: library.Tags{Title: title, Album: album, AlbumArtist: artist, Artists: []string{artist}, TrackNo: 1, DiscNo: 1},
|
||||
Properties: library.Properties{Format: "mpeg", DurationMs: 60000, SampleRate: 44100},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func newPeerFixture(t *testing.T) *peerFixture {
|
||||
t.Helper()
|
||||
f := &peerFixture{track: map[string]int64{}, bytes: map[string][]byte{}}
|
||||
h, db := newTestEnvDB(t, func(d *Deps, db *bun.DB) {
|
||||
f.fed = federation.NewService(storage.NewFederationRepo(db), federation.NewClient())
|
||||
d.Federation = f.fed
|
||||
})
|
||||
f.h, f.db = h, db
|
||||
f.admin = registerAndLogin(t, h)
|
||||
|
||||
root := t.TempDir()
|
||||
repo := storage.NewLibraryRepo(db)
|
||||
for _, l := range []struct {
|
||||
name, title, album, artist string
|
||||
fill byte
|
||||
id *int64
|
||||
}{
|
||||
{"shared", "Shared Song", "Shared Album", "Shared Band", 0xA1, &f.shared},
|
||||
{"private", "Private Song", "Private Album", "Private Band", 0xB2, &f.private},
|
||||
} {
|
||||
dir := filepath.Join(root, l.name)
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
data := bytes.Repeat([]byte{l.fill}, 400)
|
||||
for i := range data {
|
||||
data[i] ^= byte(i)
|
||||
}
|
||||
f.bytes[l.title] = data
|
||||
if err := os.WriteFile(filepath.Join(dir, "song.mp3"), data, 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
lib, err := repo.CreateLibrary(t.Context(), l.name, dir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
*l.id = lib.ID
|
||||
if _, err := repo.SaveFile(t.Context(), lib.ID, peerParsed("song.mp3", l.title, l.album, l.artist), 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
rows, err := db.Query("SELECT id, title FROM tracks WHERE title <> 'song'")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for rows.Next() {
|
||||
var id int64
|
||||
var title string
|
||||
_ = rows.Scan(&id, &title)
|
||||
f.track[title] = id
|
||||
}
|
||||
_ = rows.Close()
|
||||
return f
|
||||
}
|
||||
|
||||
func (f *peerFixture) admin1(t *testing.T, method, path string, body any) resp {
|
||||
t.Helper()
|
||||
return do(t, f.h, method, "/api/v1"+path, f.admin, body)
|
||||
}
|
||||
|
||||
// befriend turns federation on and makes the friend (its key is in f.priv) an active friend, the way a real one
|
||||
// would: with an invite, and then the admin's approval.
|
||||
func (f *peerFixture) befriend(t *testing.T) {
|
||||
t.Helper()
|
||||
if r := f.admin1(t, "PUT", "/federation", map[string]any{"enabled": true, "name": "Anna", "address": "https://anna.example.org"}); r.Code != 200 {
|
||||
t.Fatalf("turn on: %d %v", r.Code, r.Body)
|
||||
}
|
||||
inv := f.admin1(t, "POST", "/federation/invites", nil)
|
||||
f.pub, f.priv, _ = ed25519.GenerateKey(rand.Reader)
|
||||
body := map[string]any{
|
||||
"code": inviteCode(t, str(inv.Body, "invite")), "name": "Bruno", "address": "https://bruno.example.org",
|
||||
"public_key": base64.RawURLEncoding.EncodeToString(f.pub),
|
||||
}
|
||||
if r := do(t, f.h, "POST", "/api/v1/peer/pair", "", body); r.Code != 200 {
|
||||
t.Fatalf("pair: %d %v", r.Code, r.Body)
|
||||
}
|
||||
list := f.admin1(t, "GET", "/federation", nil).Body["friends"].([]any)
|
||||
f.friendID = strconv.Itoa(int(list[0].(map[string]any)["id"].(float64)))
|
||||
if r := f.admin1(t, "POST", "/federation/friends/"+f.friendID+"/approve", nil); r.Code != 200 {
|
||||
t.Fatalf("approve: %d %v", r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *peerFixture) share(t *testing.T, id int64, on bool) {
|
||||
t.Helper()
|
||||
r := f.admin1(t, "PATCH", "/libraries/"+strconv.FormatInt(id, 10), map[string]any{"shared": on})
|
||||
if r.Code != 200 || r.Body["shared"] != on {
|
||||
t.Fatalf("share %d: %d %v", id, r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
// signed makes a request a friend would make, signed with its key.
|
||||
func (f *peerFixture) signed(method, path string, mutate ...func(*http.Request)) *http.Request {
|
||||
uri := "/api/v1/peer" + path
|
||||
n := f.nonce.Add(1)
|
||||
h := federation.Sign(f.priv, method, uri, time.Now(), "nonce-"+strconv.FormatInt(n, 10)+"-0123456789abcdef")
|
||||
req := httptest.NewRequest(method, uri, nil)
|
||||
req.Header.Set(federation.HeaderKeyID, federation.KeyID(f.pub))
|
||||
req.Header.Set(federation.HeaderDate, h.Date)
|
||||
req.Header.Set(federation.HeaderNonce, h.Nonce)
|
||||
req.Header.Set(federation.HeaderSignature, h.Signature)
|
||||
for _, m := range mutate {
|
||||
m(req)
|
||||
}
|
||||
return req
|
||||
}
|
||||
|
||||
func (f *peerFixture) serve(req *http.Request) *httptest.ResponseRecorder {
|
||||
rec := httptest.NewRecorder()
|
||||
f.h.ServeHTTP(rec, req)
|
||||
return rec
|
||||
}
|
||||
|
||||
func (f *peerFixture) get(t *testing.T, path string) resp {
|
||||
t.Helper()
|
||||
rec := f.serve(f.signed("GET", path))
|
||||
out := resp{Code: rec.Code, Body: map[string]any{}}
|
||||
_ = json.Unmarshal(rec.Body.Bytes(), &out.Body)
|
||||
return out
|
||||
}
|
||||
|
||||
func titlesIn(r resp) []string {
|
||||
var out []string
|
||||
for _, it := range r.Body["items"].([]any) {
|
||||
m := it.(map[string]any)
|
||||
if v, ok := m["title"].(string); ok {
|
||||
out = append(out, v)
|
||||
} else {
|
||||
out = append(out, m["name"].(string))
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func TestAFriendMustSignItsRequests(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.share(t, f.shared, true)
|
||||
|
||||
// Federation is off: the routes are as good as missing, whoever asks.
|
||||
if rec := f.serve(httptest.NewRequest("GET", "/api/v1/peer/info", nil)); rec.Code != 404 {
|
||||
t.Errorf("while off: %d", rec.Code)
|
||||
}
|
||||
f.befriend(t)
|
||||
|
||||
for name, req := range map[string]*http.Request{
|
||||
"no signature": httptest.NewRequest("GET", "/api/v1/peer/info", nil),
|
||||
"another path": f.signed("GET", "/info", func(r *http.Request) { r.URL.Path = "/api/v1/peer/artists" }),
|
||||
"a bad signature": f.signed("GET", "/info", func(r *http.Request) { r.Header.Set(federation.HeaderSignature, "AAAA") }),
|
||||
"an old date": f.signed("GET", "/info", func(r *http.Request) {
|
||||
r.Header.Set(federation.HeaderDate, strconv.FormatInt(time.Now().Add(-time.Hour).Unix(), 10))
|
||||
}),
|
||||
"another key": f.signed("GET", "/info", func(r *http.Request) { r.Header.Set(federation.HeaderKeyID, "0123456789abcdef") }),
|
||||
} {
|
||||
rec := f.serve(req)
|
||||
var body struct{ Error struct{ Code string } }
|
||||
_ = json.Unmarshal(rec.Body.Bytes(), &body)
|
||||
if rec.Code != 401 || body.Error.Code != "unauthorized" {
|
||||
t.Errorf("%s: %d %s", name, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
// A request is good once.
|
||||
req := f.signed("GET", "/info")
|
||||
if rec := f.serve(req); rec.Code != 200 {
|
||||
t.Fatalf("the good request: %d %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if rec := f.serve(req.Clone(req.Context())); rec.Code != 401 {
|
||||
t.Errorf("the same request again: %d, want 401", rec.Code)
|
||||
}
|
||||
|
||||
// Removing the friend ends it at once.
|
||||
f.admin1(t, "DELETE", "/federation/friends/"+f.friendID, nil)
|
||||
if rec := f.serve(f.signed("GET", "/info")); rec.Code != 401 {
|
||||
t.Errorf("after removal: %d, want 401", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAFriendWaitingForApprovalIsToldSo(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.admin1(t, "PUT", "/federation", map[string]any{"enabled": true, "address": "https://anna.example.org"})
|
||||
inv := f.admin1(t, "POST", "/federation/invites", nil)
|
||||
f.pub, f.priv, _ = ed25519.GenerateKey(rand.Reader)
|
||||
do(t, f.h, "POST", "/api/v1/peer/pair", "", map[string]any{
|
||||
"code": inviteCode(t, str(inv.Body, "invite")), "name": "Bruno", "address": "https://bruno.example.org",
|
||||
"public_key": base64.RawURLEncoding.EncodeToString(f.pub),
|
||||
})
|
||||
rec := f.serve(f.signed("GET", "/info"))
|
||||
if rec.Code != 403 || !strings.Contains(rec.Body.String(), `"not_approved"`) {
|
||||
t.Errorf("unapproved friend: %d %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAFriendSeesWhoWeAreAndHowManyLibrariesAreShared(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.befriend(t)
|
||||
r := f.get(t, "/info")
|
||||
sameKeys(t, "info", r.Body, "name", "shared_libraries")
|
||||
if r.Code != 200 || r.Body["name"] != "Anna" || r.Body["shared_libraries"] != float64(0) {
|
||||
t.Errorf("info = %d %v", r.Code, r.Body)
|
||||
}
|
||||
f.share(t, f.shared, true)
|
||||
if r := f.get(t, "/info"); r.Body["shared_libraries"] != float64(1) {
|
||||
t.Errorf("info = %v", r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAFriendReadsOnlyTheSharedLibraries(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.befriend(t)
|
||||
|
||||
// Nothing is shared: nothing is there, by list, by id or by search.
|
||||
for _, p := range []string{"/artists", "/albums", "/tracks"} {
|
||||
if r := f.get(t, p); r.Code != 200 || r.Body["total"] != float64(0) {
|
||||
t.Errorf("%s with nothing shared = %d %v", p, r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
for _, p := range []string{"/tracks/" + strconv.FormatInt(f.track["Shared Song"], 10), "/tracks/" + strconv.FormatInt(f.track["Private Song"], 10)} {
|
||||
if r := f.get(t, p); r.Code != 404 {
|
||||
t.Errorf("%s with nothing shared = %d", p, r.Code)
|
||||
}
|
||||
}
|
||||
|
||||
f.share(t, f.shared, true)
|
||||
if got := titlesIn(f.get(t, "/tracks")); len(got) != 1 || got[0] != "Shared Song" {
|
||||
t.Errorf("tracks = %v", got)
|
||||
}
|
||||
if got := titlesIn(f.get(t, "/albums")); len(got) != 1 || got[0] != "Shared Album" {
|
||||
t.Errorf("albums = %v", got)
|
||||
}
|
||||
if got := titlesIn(f.get(t, "/artists")); len(got) != 1 || got[0] != "Shared Band" {
|
||||
t.Errorf("artists = %v", got)
|
||||
}
|
||||
if got := titlesIn(f.get(t, "/tracks?q=private")); len(got) != 0 {
|
||||
t.Errorf("a search found %v in the library that is not shared", got)
|
||||
}
|
||||
if got := titlesIn(f.get(t, "/tracks?library_id="+strconv.FormatInt(f.private, 10))); len(got) != 0 {
|
||||
t.Errorf("asking for the other library found %v", got)
|
||||
}
|
||||
one := f.get(t, "/tracks/"+strconv.FormatInt(f.track["Shared Song"], 10))
|
||||
sameKeys(t, "track", one.Body, "id", "title", "duration_ms", "track_no", "disc_no", "album", "artists", "format")
|
||||
if one.Code != 200 || one.Body["title"] != "Shared Song" {
|
||||
t.Errorf("track = %d %v", one.Code, one.Body)
|
||||
}
|
||||
if r := f.get(t, "/tracks/"+strconv.FormatInt(f.track["Private Song"], 10)); r.Code != 404 || errCode(r) != "track_not_found" {
|
||||
t.Errorf("the track of the other library: %d %v", r.Code, r.Body)
|
||||
}
|
||||
for _, p := range []string{"/artists/", "/albums/"} {
|
||||
if r := f.get(t, p+"999999"); r.Code != 404 {
|
||||
t.Errorf("%s999999 = %d", p, r.Code)
|
||||
}
|
||||
}
|
||||
// Whatever the answer says, it is never a path.
|
||||
rec := f.serve(f.signed("GET", "/tracks"))
|
||||
if strings.Contains(rec.Body.String(), "song.mp3") || strings.Contains(rec.Body.String(), "/shared") {
|
||||
t.Errorf("the answer names a path: %s", rec.Body.String())
|
||||
}
|
||||
|
||||
// Unsharing takes it away at once.
|
||||
f.share(t, f.shared, false)
|
||||
if r := f.get(t, "/tracks"); r.Body["total"] != float64(0) {
|
||||
t.Errorf("after unsharing: %v", r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAFriendStreamsSharedMusicWithRanges(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.befriend(t)
|
||||
f.share(t, f.shared, true)
|
||||
want := f.bytes["Shared Song"]
|
||||
id := strconv.FormatInt(f.track["Shared Song"], 10)
|
||||
|
||||
rec := f.serve(f.signed("GET", "/tracks/"+id+"/stream"))
|
||||
if rec.Code != 200 || !bytes.Equal(rec.Body.Bytes(), want) {
|
||||
t.Fatalf("stream: %d, %d bytes", rec.Code, rec.Body.Len())
|
||||
}
|
||||
if ct := rec.Header().Get("Content-Type"); !strings.HasPrefix(ct, "audio/") {
|
||||
t.Errorf("Content-Type = %q", ct)
|
||||
}
|
||||
rec = f.serve(f.signed("GET", "/tracks/"+id+"/stream", func(r *http.Request) { r.Header.Set("Range", "bytes=100-199") }))
|
||||
if rec.Code != 206 || !bytes.Equal(rec.Body.Bytes(), want[100:200]) || rec.Header().Get("Content-Range") != "bytes 100-199/400" {
|
||||
t.Errorf("range: %d %q %d bytes", rec.Code, rec.Header().Get("Content-Range"), rec.Body.Len())
|
||||
}
|
||||
|
||||
// The other library is out of reach, by its id too.
|
||||
other := strconv.FormatInt(f.track["Private Song"], 10)
|
||||
if rec := f.serve(f.signed("GET", "/tracks/"+other+"/stream")); rec.Code != 404 {
|
||||
t.Errorf("stream of a track that is not shared: %d", rec.Code)
|
||||
}
|
||||
if rec := f.serve(f.signed("GET", "/tracks/999999/stream")); rec.Code != 404 {
|
||||
t.Errorf("stream of no track: %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAFriendCannotHaveMoreStreamsThanAllowed(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.befriend(t)
|
||||
f.share(t, f.shared, true)
|
||||
one := 1
|
||||
if _, err := f.fed.Update(t.Context(), federation.Patch{MaxStreams: &one}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
fid, _ := strconv.ParseInt(f.friendID, 10, 64)
|
||||
open, err := f.fed.StartStream(t.Context(), fid)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
id := strconv.FormatInt(f.track["Shared Song"], 10)
|
||||
rec := f.serve(f.signed("GET", "/tracks/"+id+"/stream"))
|
||||
if rec.Code != 429 || !strings.Contains(rec.Body.String(), `"too_many_streams"`) || rec.Header().Get("Retry-After") == "" {
|
||||
t.Errorf("one stream too many: %d %s (Retry-After %q)", rec.Code, rec.Body.String(), rec.Header().Get("Retry-After"))
|
||||
}
|
||||
open.Close()
|
||||
if rec := f.serve(f.signed("GET", "/tracks/"+id+"/stream")); rec.Code != 200 {
|
||||
t.Errorf("after the first ended: %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestACoverIsOnlyServedOnceBuiltAndOnlyForSharedAlbums(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.befriend(t)
|
||||
f.share(t, f.shared, true)
|
||||
var shared, private int64
|
||||
_ = f.db.QueryRow("SELECT id FROM albums WHERE title = 'Shared Album'").Scan(&shared)
|
||||
_ = f.db.QueryRow("SELECT id FROM albums WHERE title = 'Private Album'").Scan(&private)
|
||||
sid, pid := strconv.FormatInt(shared, 10), strconv.FormatInt(private, 10)
|
||||
|
||||
r := f.get(t, "/albums/"+sid+"/cover")
|
||||
if r.Code != 404 || errCode(r) != "cover_not_found" {
|
||||
t.Errorf("a cover that was not built: %d %v: a friend must not make this server build one", r.Code, r.Body)
|
||||
}
|
||||
if r := f.get(t, "/albums/"+pid+"/cover"); r.Code != 404 || errCode(r) != "album_not_found" {
|
||||
t.Errorf("the cover of an album that is not shared: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := f.get(t, "/albums/"+sid+"/cover?size=huge"); r.Code != 400 {
|
||||
t.Errorf("a bad size: %d", r.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSharingALibraryIsAnAdminsChoice(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
id := strconv.FormatInt(f.shared, 10)
|
||||
list := f.admin1(t, "GET", "/libraries", nil).Body["libraries"].([]any)
|
||||
for _, l := range list {
|
||||
if l.(map[string]any)["shared"] != false {
|
||||
t.Errorf("library %v starts shared", l)
|
||||
}
|
||||
}
|
||||
_, bob := addUser(t, f.h, f.admin, "bob", false)
|
||||
if r := do(t, f.h, "PATCH", "/api/v1/libraries/"+id, bob, map[string]any{"shared": true}); r.Code != 403 {
|
||||
t.Errorf("a user who is not an admin shares a library: %d", r.Code)
|
||||
}
|
||||
r := f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{"shared": true})
|
||||
if r.Code != 200 || r.Body["shared"] != true {
|
||||
t.Fatalf("share: %d %v", r.Code, r.Body)
|
||||
}
|
||||
// Name and sharing can be changed together or apart.
|
||||
r = f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{"name": "renamed"})
|
||||
if r.Code != 200 || r.Body["shared"] != true || r.Body["name"] != "renamed" {
|
||||
t.Errorf("rename keeps sharing: %d %v", r.Code, r.Body)
|
||||
}
|
||||
r = f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{"name": "again", "shared": false})
|
||||
if r.Code != 200 || r.Body["shared"] != false || r.Body["name"] != "again" {
|
||||
t.Errorf("both at once: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{}); r.Code != 400 {
|
||||
t.Errorf("nothing to change: %d", r.Code)
|
||||
}
|
||||
if r := f.admin1(t, "PATCH", "/libraries/99999", map[string]any{"shared": true}); r.Code != 404 {
|
||||
t.Errorf("unknown library: %d", r.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTheAdminSeesWhatFriendsAsked(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
f.befriend(t)
|
||||
f.share(t, f.shared, true)
|
||||
f.get(t, "/info")
|
||||
f.get(t, "/tracks?q=secret+words&limit=5")
|
||||
f.serve(f.signed("GET", "/tracks/"+strconv.FormatInt(f.track["Shared Song"], 10)+"/stream"))
|
||||
|
||||
r := f.admin1(t, "GET", "/federation/requests", nil)
|
||||
if r.Code != 200 {
|
||||
t.Fatalf("requests: %d %v", r.Code, r.Body)
|
||||
}
|
||||
list := r.Body["requests"].([]any)
|
||||
if len(list) != 3 {
|
||||
t.Fatalf("requests = %v", list)
|
||||
}
|
||||
newest := list[0].(map[string]any)
|
||||
sameKeys(t, "request", newest, "at", "friend_id", "friend", "route", "status", "bytes")
|
||||
if newest["route"] != "/api/v1/peer/tracks/:id/stream" || newest["status"] != float64(200) || newest["bytes"] != float64(400) || newest["friend"] != "Bruno" {
|
||||
t.Errorf("newest = %v", newest)
|
||||
}
|
||||
if body := strings.ToLower(jsonOf(t, r.Body)); strings.Contains(body, "secret") {
|
||||
t.Errorf("the log keeps what was searched for: %s", body)
|
||||
}
|
||||
_, bob := addUser(t, f.h, f.admin, "bob", false)
|
||||
if r := do(t, f.h, "GET", "/api/v1/federation/requests", bob, nil); r.Code != 403 {
|
||||
t.Errorf("a user who is not an admin reads the log: %d", r.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func jsonOf(t *testing.T, v any) string {
|
||||
t.Helper()
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return string(b)
|
||||
}
|
||||
|
||||
func TestTheLimitsAreSetWithTheOtherSettings(t *testing.T) {
|
||||
f := newPeerFixture(t)
|
||||
r := f.admin1(t, "GET", "/federation", nil)
|
||||
if r.Body["max_streams"] != float64(3) || r.Body["max_kib_per_sec"] != float64(4096) {
|
||||
t.Errorf("defaults = %v %v", r.Body["max_streams"], r.Body["max_kib_per_sec"])
|
||||
}
|
||||
r = f.admin1(t, "PUT", "/federation", map[string]any{"max_streams": 2, "max_kib_per_sec": 0})
|
||||
if r.Code != 200 || r.Body["max_streams"] != float64(2) || r.Body["max_kib_per_sec"] != float64(0) {
|
||||
t.Errorf("update = %d %v", r.Code, r.Body)
|
||||
}
|
||||
for _, body := range []map[string]any{{"max_streams": 0}, {"max_streams": 99}, {"max_kib_per_sec": 5}} {
|
||||
if r := f.admin1(t, "PUT", "/federation", body); r.Code != 400 || errCode(r) != "invalid_input" {
|
||||
t.Errorf("%v: %d %v", body, r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAServerChecksWhetherTheOtherApproved(t *testing.T) {
|
||||
a := newFriendServer(t, true)
|
||||
b := newFriendServer(t, false)
|
||||
a.setUp(t, "Anna", a.ts.URL)
|
||||
b.setUp(t, "Bruno", "https://bruno.example.org")
|
||||
inv := a.call(t, "POST", "/federation/invites", nil)
|
||||
mine := b.call(t, "POST", "/federation/friends", map[string]any{"invite": inv.Body["invite"]})
|
||||
bID := strconv.Itoa(int(mine.Body["id"].(float64)))
|
||||
|
||||
// Anna has not approved yet.
|
||||
r := b.call(t, "POST", "/federation/friends/"+bID+"/check", nil)
|
||||
if r.Code != http.StatusConflict || errCode(r) != "not_approved" {
|
||||
t.Fatalf("before approval: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if got := b.call(t, "GET", "/federation", nil).Body["friends"].([]any)[0].(map[string]any)["state"]; got != "outgoing" {
|
||||
t.Errorf("state = %v", got)
|
||||
}
|
||||
|
||||
list := a.call(t, "GET", "/federation", nil).Body["friends"].([]any)
|
||||
aID := strconv.Itoa(int(list[0].(map[string]any)["id"].(float64)))
|
||||
a.call(t, "POST", "/federation/friends/"+aID+"/approve", nil)
|
||||
|
||||
r = b.call(t, "POST", "/federation/friends/"+bID+"/check", nil)
|
||||
if r.Code != 200 || r.Body["state"] != "active" || r.Body["approved_at"] == nil {
|
||||
t.Fatalf("after approval: %d %v", r.Code, r.Body)
|
||||
}
|
||||
// Anna logged that call.
|
||||
if reqs := a.call(t, "GET", "/federation/requests", nil).Body["requests"].([]any); len(reqs) != 1 || reqs[0].(map[string]any)["route"] != "/api/v1/peer/info" {
|
||||
t.Errorf("Anna's log = %v", reqs)
|
||||
}
|
||||
|
||||
// Anna removes Bruno: Bruno is told it is no friend any more, and stays as it was.
|
||||
a.call(t, "DELETE", "/federation/friends/"+aID, nil)
|
||||
r = b.call(t, "POST", "/federation/friends/"+bID+"/check", nil)
|
||||
if r.Code != http.StatusConflict || errCode(r) != "friend_gone" {
|
||||
t.Errorf("after removal: %d %v", r.Code, r.Body)
|
||||
}
|
||||
// And a server that is gone is "unreachable", not a verdict.
|
||||
a.ts.Close()
|
||||
if r := b.call(t, "POST", "/federation/friends/"+bID+"/check", nil); r.Code != http.StatusBadGateway || errCode(r) != "friend_unreachable" {
|
||||
t.Errorf("server gone: %d %v", r.Code, r.Body)
|
||||
}
|
||||
if r := b.call(t, "POST", "/federation/friends/99999/check", nil); r.Code != 404 {
|
||||
t.Errorf("unknown friend: %d", r.Code)
|
||||
}
|
||||
}
|
||||
|
|
@ -183,6 +183,7 @@ type libraryService interface {
|
|||
List(ctx context.Context) ([]library.Library, error)
|
||||
Create(ctx context.Context, name, path string) (library.Library, error)
|
||||
Update(ctx context.Context, id int64, name, path *string) (library.Library, error)
|
||||
SetShared(ctx context.Context, id int64, shared bool) (library.Library, error)
|
||||
Delete(ctx context.Context, id int64) error
|
||||
}
|
||||
|
||||
|
|
@ -218,6 +219,11 @@ type Deps struct {
|
|||
Settings userSettingsService
|
||||
Streams streamService
|
||||
Federation federationService
|
||||
// What a friend's server reads: the catalogue and the files of the libraries that are shared, and only covers
|
||||
// that were already built.
|
||||
PeerCatalog catalogService
|
||||
PeerStreams streamService
|
||||
PeerCovers coverService
|
||||
// Web is the built web app, served on / and for its own links. It is optional: with none (a build
|
||||
// without the app) / shows a page that says how to build it, and the API works the same.
|
||||
Web fs.FS
|
||||
|
|
@ -262,6 +268,7 @@ func NewRouter(d Deps) *gin.Engine {
|
|||
v1.POST("/auth/logout", a.logout)
|
||||
// Another Sonda server pairs here, with the code of an invite instead of a login.
|
||||
v1.POST("/peer/pair", (&federationHandlers{svc: d.Federation}).pair)
|
||||
registerPeer(v1, d)
|
||||
|
||||
// Any signed-in user.
|
||||
protected := v1.Group("", requireAuth(d.Tokens, d.Auth, false))
|
||||
|
|
@ -397,6 +404,8 @@ func NewRouter(d Deps) *gin.Engine {
|
|||
admin.POST("/federation/invites", fed.invite)
|
||||
admin.POST("/federation/friends", fed.redeem)
|
||||
admin.POST("/federation/friends/:id/approve", fed.approve)
|
||||
admin.POST("/federation/friends/:id/check", fed.check)
|
||||
admin.GET("/federation/requests", fed.requests)
|
||||
admin.DELETE("/federation/friends/:id", fed.remove)
|
||||
u := &usersHandlers{svc: d.Auth}
|
||||
admin.GET("/users", u.list)
|
||||
|
|
|
|||
|
|
@ -3162,6 +3162,346 @@ paths:
|
|||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/federation/friends/{id}/check:
|
||||
parameters:
|
||||
- {name: id, in: path, required: true, schema: {type: integer}}
|
||||
post:
|
||||
tags: [Federation]
|
||||
operationId: checkFederationFriend
|
||||
summary: Ask a friend whether it approved
|
||||
description: |
|
||||
Admin only. Sends the friend one signed request (`GET /peer/info`). An answer means it approved, and a friend that
|
||||
was `outgoing` becomes `active`. The friend is returned. A friend in state `incoming` is a `409` (`not_waiting`):
|
||||
it waits for this server's admin, not the other way round.
|
||||
security: [{bearerAuth: []}]
|
||||
responses:
|
||||
'200':
|
||||
description: The friend, active when it answered.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/FederationFriend'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'403': {$ref: '#/components/responses/AdminRequired'}
|
||||
'404':
|
||||
description: No such friend (`friend_not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
'409':
|
||||
description: |
|
||||
Federation is off (`federation_off`), the friend is not waiting for the other admin (`not_waiting`), the other
|
||||
admin has not approved yet (`not_approved`), or the other server does not take this one for a friend any more
|
||||
(`friend_gone`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
'502':
|
||||
description: The other server could not be reached or did not answer as a Sonda server (`friend_unreachable`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/federation/requests:
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: listFederationRequests
|
||||
summary: The last requests friends made
|
||||
description: |
|
||||
Admin only. The last 50 requests that friends made to this server, newest first, kept for 7 days: when, which
|
||||
friend, which route (the pattern, never the query, so what was searched for is not kept), the status and how many
|
||||
bytes were sent.
|
||||
security: [{bearerAuth: []}]
|
||||
responses:
|
||||
'200':
|
||||
description: The requests.
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [requests]
|
||||
properties:
|
||||
requests:
|
||||
type: array
|
||||
items: {$ref: '#/components/schemas/FederationRequest'}
|
||||
'401': {$ref: '#/components/responses/Unauthorized'}
|
||||
'403': {$ref: '#/components/responses/AdminRequired'}
|
||||
|
||||
/peer/info:
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerInfo
|
||||
summary: Who this server is (called by a friend)
|
||||
description: |
|
||||
Not for people: a friend's server calls this, signed (see the `friendSignature` scheme), and also to find out whether
|
||||
this server's admin approved it. Says the name of this server and how many libraries are shared.
|
||||
security: [{friendSignature: []}]
|
||||
responses:
|
||||
'200':
|
||||
description: The name and the number of shared libraries.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/PeerInfo'}
|
||||
'401': {$ref: '#/components/responses/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404': {$ref: '#/components/responses/FederationOff'}
|
||||
|
||||
/peer/artists:
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerListArtists
|
||||
summary: The artists of the shared libraries (called by a friend)
|
||||
description: |
|
||||
Like `GET /artists`, over the libraries that are shared and nothing else: an artist is listed only when it has a
|
||||
playable track in one of them, and the counts are of those tracks. Paths, library ids and everything that providers
|
||||
said are never part of it. Signed like every `/peer` route.
|
||||
security: [{friendSignature: []}]
|
||||
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/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404': {$ref: '#/components/responses/FederationOff'}
|
||||
|
||||
/peer/artists/{id}:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerGetArtist
|
||||
summary: One artist of the shared libraries (called by a friend)
|
||||
security: [{friendSignature: []}]
|
||||
responses:
|
||||
'200':
|
||||
description: The artist.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Artist'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404':
|
||||
description: No such artist among the shared libraries (`artist_not_found`), or federation is off (`not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/peer/albums:
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerListAlbums
|
||||
summary: The albums of the shared libraries (called by a friend)
|
||||
description: Like `GET /albums`, over the libraries that are shared. Signed like every `/peer` route.
|
||||
security: [{friendSignature: []}]
|
||||
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/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404': {$ref: '#/components/responses/FederationOff'}
|
||||
|
||||
/peer/albums/{id}:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerGetAlbum
|
||||
summary: One album of the shared libraries (called by a friend)
|
||||
security: [{friendSignature: []}]
|
||||
responses:
|
||||
'200':
|
||||
description: The album.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Album'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404':
|
||||
description: No such album among the shared libraries (`album_not_found`), or federation is off (`not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/peer/albums/{id}/cover:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerGetAlbumCover
|
||||
summary: The cover of an album of the shared libraries (called by a friend)
|
||||
description: |
|
||||
Only a cover that this server already built from the audio files of the album: a friend never makes this server
|
||||
build one, read an audio file or ask a provider. A cover that came from the Cover Art Archive is not given. Any other
|
||||
album answers `cover_not_found`. The bytes go out within the friend's allowance.
|
||||
security: [{friendSignature: []}]
|
||||
parameters:
|
||||
- name: size
|
||||
in: query
|
||||
description: "`small` or `large`. Large when absent."
|
||||
schema: {type: string, enum: [small, large], default: large}
|
||||
- name: If-None-Match
|
||||
in: header
|
||||
required: false
|
||||
schema: {type: string}
|
||||
responses:
|
||||
'200':
|
||||
description: The cover.
|
||||
headers:
|
||||
ETag: {$ref: '#/components/headers/ETag'}
|
||||
Cache-Control: {$ref: '#/components/headers/CacheControl'}
|
||||
Content-Length: {$ref: '#/components/headers/ContentLength'}
|
||||
content:
|
||||
image/jpeg:
|
||||
schema: {type: string, format: binary}
|
||||
'304': {description: Not modified since `If-None-Match`.}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404':
|
||||
description: No such album among the shared libraries (`album_not_found`), no cover built (`cover_not_found`), or federation is off (`not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/peer/tracks:
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerListTracks
|
||||
summary: The tracks of the shared libraries (called by a friend)
|
||||
description: Like `GET /tracks`, over the libraries that are shared. Signed like every `/peer` route.
|
||||
security: [{friendSignature: []}]
|
||||
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/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404': {$ref: '#/components/responses/FederationOff'}
|
||||
|
||||
/peer/tracks/{id}:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerGetTrack
|
||||
summary: One track of the shared libraries (called by a friend)
|
||||
security: [{friendSignature: []}]
|
||||
responses:
|
||||
'200':
|
||||
description: The track.
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Track'}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404':
|
||||
description: No such track among the shared libraries (`track_not_found`), or federation is off (`not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
/peer/tracks/{id}/stream:
|
||||
parameters:
|
||||
- {$ref: '#/components/parameters/Id'}
|
||||
get:
|
||||
tags: [Federation]
|
||||
operationId: peerStreamTrack
|
||||
summary: Stream a track of the shared libraries (called by a friend)
|
||||
description: |
|
||||
The file of the track that lives in a shared library, with `Range` support, as a listener would get it. A track that is
|
||||
only in libraries that are not shared is `track_not_found`. A friend has a few streams open at a time and a number
|
||||
of bytes a second to share among them, both set by the admin (`max_streams`, `max_kib_per_sec`): one stream too many
|
||||
is a `429` (`too_many_streams`) with `Retry-After`.
|
||||
security: [{friendSignature: []}]
|
||||
parameters:
|
||||
- name: Range
|
||||
in: header
|
||||
required: false
|
||||
description: A byte range, for example `bytes=0-99`.
|
||||
schema: {type: string}
|
||||
- name: If-Modified-Since
|
||||
in: header
|
||||
required: false
|
||||
schema: {type: string}
|
||||
responses:
|
||||
'200':
|
||||
description: The whole file.
|
||||
headers:
|
||||
Accept-Ranges: {$ref: '#/components/headers/AcceptRanges'}
|
||||
Content-Length: {$ref: '#/components/headers/ContentLength'}
|
||||
Last-Modified: {$ref: '#/components/headers/LastModified'}
|
||||
content:
|
||||
audio/mpeg:
|
||||
schema: {type: string, format: binary}
|
||||
audio/flac:
|
||||
schema: {type: string, format: binary}
|
||||
'206':
|
||||
description: The requested byte range.
|
||||
headers:
|
||||
Content-Range:
|
||||
description: The range sent and the size of the file, for example `bytes 0-99/40635`.
|
||||
schema: {type: string}
|
||||
content:
|
||||
audio/mpeg:
|
||||
schema: {type: string, format: binary}
|
||||
audio/flac:
|
||||
schema: {type: string, format: binary}
|
||||
multipart/byteranges:
|
||||
schema: {type: string, format: binary}
|
||||
'304': {description: Not modified since `If-Modified-Since`.}
|
||||
'400': {$ref: '#/components/responses/InvalidInput'}
|
||||
'401': {$ref: '#/components/responses/FriendUnauthorized'}
|
||||
'403': {$ref: '#/components/responses/FriendNotApproved'}
|
||||
'404':
|
||||
description: No such track among the shared libraries (`track_not_found`), its file is not available (`file_missing`), or federation is off (`not_found`).
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
'416':
|
||||
description: The range cannot be satisfied.
|
||||
headers:
|
||||
Content-Range:
|
||||
description: '`bytes */<size of the file>`.'
|
||||
schema: {type: string}
|
||||
'429':
|
||||
description: The friend already has as many streams open as allowed (`too_many_streams`).
|
||||
headers:
|
||||
Retry-After:
|
||||
description: Seconds to wait.
|
||||
schema: {type: integer}
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
|
||||
components:
|
||||
securitySchemes:
|
||||
bearerAuth:
|
||||
|
|
@ -3175,6 +3515,18 @@ components:
|
|||
name: access_token
|
||||
description: The same access token, for stream URLs used by an `<audio>` element. Accepted only on `/tracks/{id}/stream`, `/albums/{id}/cover` and `/artists/{id}/image`.
|
||||
|
||||
friendSignature:
|
||||
type: apiKey
|
||||
in: header
|
||||
name: Sonda-Signature
|
||||
description: |
|
||||
For the routes under `/peer`, which only another Sonda server calls. Each request carries four headers:
|
||||
`Sonda-Key-Id` (the first 16 hex characters of the SHA-256 of the sender's public key), `Sonda-Date` (unix
|
||||
seconds, at most two minutes from the receiver's clock), `Sonda-Nonce` (16 to 64 characters of `A-Za-z0-9_-`, never
|
||||
used twice) and `Sonda-Signature` (the Ed25519 signature, base64url without padding, of these five lines:
|
||||
the method, the path from `/api/v1/peer` on with the query as sent, the date, the nonce and the SHA-256 in hex of
|
||||
the body, which is empty). Anything that is not properly signed gets the same `401`.
|
||||
|
||||
parameters:
|
||||
Id:
|
||||
name: id
|
||||
|
|
@ -3244,6 +3596,21 @@ components:
|
|||
schema: {type: string}
|
||||
|
||||
responses:
|
||||
FriendUnauthorized:
|
||||
description: "The request is not signed by a friend: no signature, a bad one, an old date, a nonce used before or an unknown key, all the same answer (`unauthorized`)."
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
FriendNotApproved:
|
||||
description: The signature is good but the admin of this server has not approved the friend yet (`not_approved`).
|
||||
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:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/Error'}
|
||||
InvalidInput:
|
||||
description: The request is malformed or a value is out of range (`invalid_input`).
|
||||
content:
|
||||
|
|
@ -3390,11 +3757,12 @@ components:
|
|||
Library:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [id, name, path, created_at]
|
||||
required: [id, name, path, shared, created_at]
|
||||
properties:
|
||||
id: {type: integer, format: int64}
|
||||
name: {type: string}
|
||||
path: {type: string, description: Absolute directory on the server.}
|
||||
shared: {type: boolean, description: Whether friends (federation) may read this library. Off until an admin turns it on.}
|
||||
created_at: {type: string, format: date-time}
|
||||
|
||||
NewLibrary:
|
||||
|
|
@ -3409,9 +3777,11 @@ components:
|
|||
anyOf:
|
||||
- required: [name]
|
||||
- required: [path]
|
||||
- required: [shared]
|
||||
properties:
|
||||
name: {type: string, minLength: 1, maxLength: 100}
|
||||
path: {type: string}
|
||||
shared: {type: boolean, description: "Whether friends may read this library. Changing it never needs a scan and never waits for one."}
|
||||
|
||||
ScanSummary:
|
||||
type: object
|
||||
|
|
@ -4505,13 +4875,15 @@ components:
|
|||
Federation:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [enabled, name, address, key_id, sends, friends]
|
||||
required: [enabled, name, address, key_id, sends, max_streams, max_kib_per_sec, friends]
|
||||
properties:
|
||||
enabled: {type: boolean, description: Whether this server may pair with others. Off by default.}
|
||||
name: {type: string, description: How friends see this server.}
|
||||
address: {type: string, description: Where friends reach this server; empty until set.}
|
||||
key_id: {type: string, description: "Names this server's key; empty until federation was first turned on. Compare it with the one the other admin sees."}
|
||||
sends: {type: string, description: "What a friend's server is sent, and what it never learns."}
|
||||
max_streams: {type: integer, minimum: 1, maximum: 20, description: Streams one friend may have open at a time.}
|
||||
max_kib_per_sec: {type: integer, minimum: 0, maximum: 102400, description: "KiB a second one friend may take over all its streams; 0 means no limit. Otherwise at least 64."}
|
||||
friends:
|
||||
type: array
|
||||
items: {$ref: '#/components/schemas/FederationFriend'}
|
||||
|
|
@ -4522,10 +4894,32 @@ components:
|
|||
- required: [enabled]
|
||||
- required: [name]
|
||||
- required: [address]
|
||||
- required: [max_streams]
|
||||
- required: [max_kib_per_sec]
|
||||
properties:
|
||||
enabled: {type: boolean}
|
||||
max_streams: {type: integer}
|
||||
max_kib_per_sec: {type: integer}
|
||||
name: {type: string, maxLength: 240, description: "At most 60 characters, no control characters. Empty goes back to the host name."}
|
||||
address: {type: string, maxLength: 300}
|
||||
FederationRequest:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [at, friend_id, friend, route, status, bytes]
|
||||
properties:
|
||||
at: {type: string, format: date-time}
|
||||
friend_id: {type: integer}
|
||||
friend: {type: string, description: The name of the friend.}
|
||||
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.}
|
||||
PeerInfo:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [name, shared_libraries]
|
||||
properties:
|
||||
name: {type: string}
|
||||
shared_libraries: {type: integer, description: How many libraries are shared with friends.}
|
||||
FederationInvite:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ import (
|
|||
"bytes"
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
|
|
@ -16,6 +17,7 @@ import (
|
|||
|
||||
const (
|
||||
pairPath = "/api/v1/peer/pair"
|
||||
infoPath = "/api/v1/peer/info"
|
||||
maxReplyBytes = 16 << 10
|
||||
)
|
||||
|
||||
|
|
@ -97,3 +99,51 @@ func (c *Client) Pair(ctx context.Context, address string, req PairRequest) (Pai
|
|||
return PairReply{}, fmt.Errorf("%w: it answered %d", ErrUnreachable, resp.StatusCode)
|
||||
}
|
||||
}
|
||||
|
||||
type infoBody struct {
|
||||
Name string `json:"name"`
|
||||
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) {
|
||||
raw := make([]byte, 18)
|
||||
if _, err := rand.Read(raw); err != nil {
|
||||
return Info{}, 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)
|
||||
if err != nil {
|
||||
return Info{}, fmt.Errorf("%w: %v", ErrUnreachable, err)
|
||||
}
|
||||
req.Header.Set("User-Agent", "Sonda (federation)")
|
||||
req.Header.Set(HeaderKeyID, auth.KeyID)
|
||||
req.Header.Set(HeaderDate, h.Date)
|
||||
req.Header.Set(HeaderNonce, h.Nonce)
|
||||
req.Header.Set(HeaderSignature, h.Signature)
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return Info{}, 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)
|
||||
}
|
||||
switch resp.StatusCode {
|
||||
case http.StatusOK:
|
||||
var in infoBody
|
||||
if json.Unmarshal(body, &in) != nil || in.Name == "" {
|
||||
return Info{}, fmt.Errorf("%w: the answer is not that of a Sonda server", ErrUnreachable)
|
||||
}
|
||||
return Info{Name: in.Name, SharedLibraries: in.SharedLibraries}, nil
|
||||
case http.StatusForbidden:
|
||||
return Info{}, ErrNotApproved
|
||||
case http.StatusUnauthorized, http.StatusNotFound:
|
||||
return Info{}, ErrNotFriend
|
||||
default:
|
||||
return Info{}, fmt.Errorf("%w: it answered %d", ErrUnreachable, resp.StatusCode)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import (
|
|||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
|
@ -139,3 +140,82 @@ func TestClientDoesNotUseTheProxyOfTheEnvironment(t *testing.T) {
|
|||
t.Errorf("err = %v, want ErrRefused: the request must go straight to the server", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientAsksWhoAFriendIsWithASignedRequest(t *testing.T) {
|
||||
pub, priv, _ := ed25519.GenerateKey(nil)
|
||||
var got Signed
|
||||
var path, agent string
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
path, agent = r.URL.Path, r.Header.Get("User-Agent")
|
||||
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/info",
|
||||
}
|
||||
_, _ = io.WriteString(w, `{"name":"Anna","shared_libraries":2}`)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
info, err := NewClient().Info(context.Background(), srv.URL+"/sonda/", Auth{KeyID: KeyID(pub), Key: priv})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if info.Name != "Anna" || info.SharedLibraries != 2 {
|
||||
t.Errorf("info = %+v", info)
|
||||
}
|
||||
// The sub-path of the address is the proxy's: what is signed starts at /api/v1/peer.
|
||||
if path != "/sonda/api/v1/peer/info" || !strings.HasPrefix(agent, "Sonda") {
|
||||
t.Errorf("path = %q, agent = %q", path, agent)
|
||||
}
|
||||
if got.KeyID != KeyID(pub) || !validNonce(got.Nonce) || !verify(pub, got.Method, got.URI, got.Date, got.Nonce, got.Signature) {
|
||||
t.Errorf("the request is not properly signed: %+v", got)
|
||||
}
|
||||
date, _ := strconv.ParseInt(got.Date, 10, 64)
|
||||
if d := time.Since(time.Unix(date, 0)); d < -5*time.Second || d > 5*time.Second {
|
||||
t.Errorf("date is %v from now", d)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEveryAskIsSignedWithADifferentNonce(t *testing.T) {
|
||||
_, priv, _ := ed25519.GenerateKey(nil)
|
||||
seen := map[string]bool{}
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
seen[r.Header.Get(HeaderNonce)] = true
|
||||
_, _ = io.WriteString(w, `{"name":"A","shared_libraries":0}`)
|
||||
}))
|
||||
defer srv.Close()
|
||||
c := NewClient()
|
||||
for i := 0; i < 5; i++ {
|
||||
if _, err := c.Info(context.Background(), srv.URL, Auth{KeyID: "0123456789abcdef", Key: priv}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if len(seen) != 5 {
|
||||
t.Errorf("%d different nonces in 5 asks", len(seen))
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientMapsWhatAFriendAnswersToAsk(t *testing.T) {
|
||||
_, priv, _ := ed25519.GenerateKey(nil)
|
||||
for _, tc := range []struct {
|
||||
status int
|
||||
body string
|
||||
want error
|
||||
}{
|
||||
{http.StatusForbidden, `{"error":{"code":"not_approved"}}`, ErrNotApproved},
|
||||
{http.StatusUnauthorized, `{"error":{"code":"unauthorized"}}`, ErrNotFriend},
|
||||
{http.StatusNotFound, `{"error":{"code":"not_found"}}`, ErrNotFriend},
|
||||
{http.StatusInternalServerError, `oops`, ErrUnreachable},
|
||||
{http.StatusOK, `not json`, ErrUnreachable},
|
||||
{http.StatusOK, `{"shared_libraries":1}`, ErrUnreachable},
|
||||
} {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
||||
w.WriteHeader(tc.status)
|
||||
_, _ = io.WriteString(w, tc.body)
|
||||
}))
|
||||
_, err := NewClient().Info(context.Background(), srv.URL, Auth{KeyID: "0123456789abcdef", Key: priv})
|
||||
srv.Close()
|
||||
if !errors.Is(err, tc.want) {
|
||||
t.Errorf("%d %q: err = %v, want %v", tc.status, tc.body, err, tc.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,6 +28,21 @@ var (
|
|||
ErrUnreachable = errors.New("the other server could not be reached")
|
||||
ErrRefused = errors.New("the other server refused the invite: it may be used, expired or federation off there")
|
||||
ErrKeyMismatch = errors.New("the other server's key is not the one in the invite")
|
||||
|
||||
// ErrUnauthorized is every way a request from a friend can fail to be signed properly: no signature, a bad one,
|
||||
// an old date, a nonce seen before, an unknown key. It says no more, so a stranger learns nothing.
|
||||
ErrUnauthorized = errors.New("the request is not signed by a friend")
|
||||
// ErrNotApproved: the signature is good but the friendship is waiting for an admin's approval.
|
||||
ErrNotApproved = errors.New("the friendship is not approved yet")
|
||||
// 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")
|
||||
)
|
||||
|
||||
// Defaults of the limits a friend is held to, and what they may be set to.
|
||||
const (
|
||||
DefaultMaxStreams = 3
|
||||
DefaultMaxKiBPerSec = 4096
|
||||
)
|
||||
|
||||
// State of a friend.
|
||||
|
|
@ -51,6 +66,19 @@ type Settings struct {
|
|||
PublicKey ed25519.PublicKey
|
||||
PrivateKey ed25519.PrivateKey
|
||||
UpdatedAt time.Time
|
||||
|
||||
MaxStreams int // parallel streams one friend may have
|
||||
MaxKiBPerSec int // bytes a friend may take, in KiB a second, over all its streams; 0 means no limit
|
||||
}
|
||||
|
||||
// FriendRequest is one request a friend made to this server, as it is logged.
|
||||
type FriendRequest struct {
|
||||
At time.Time
|
||||
FriendID int64
|
||||
FriendName string // filled in when listed
|
||||
Route string // the route pattern, never the query
|
||||
Status int
|
||||
Bytes int64
|
||||
}
|
||||
|
||||
// Friend is another Sonda server.
|
||||
|
|
@ -83,7 +111,12 @@ type Store interface {
|
|||
Friends(ctx context.Context) ([]Friend, error)
|
||||
Friend(ctx context.Context, id int64) (Friend, error) // ErrFriendMissing
|
||||
FriendByKey(ctx context.Context, key ed25519.PublicKey) (Friend, bool, error)
|
||||
AddFriend(ctx context.Context, f Friend) (Friend, error) // ErrAlreadyFriend when the key is known
|
||||
Approve(ctx context.Context, id int64, now time.Time) error // incoming to active; ErrFriendMissing, ErrWrongState
|
||||
DeleteFriend(ctx context.Context, id int64) error // ErrFriendMissing
|
||||
AddFriend(ctx context.Context, f Friend) (Friend, error) // ErrAlreadyFriend when the key is known
|
||||
Approve(ctx context.Context, id int64, now time.Time) error // incoming to active; ErrFriendMissing, ErrWrongState
|
||||
Activate(ctx context.Context, id int64, now time.Time) error // outgoing to active; ErrFriendMissing, ErrWrongState
|
||||
DeleteFriend(ctx context.Context, id int64) error // ErrFriendMissing
|
||||
|
||||
LogRequest(ctx context.Context, r FriendRequest) error
|
||||
Requests(ctx context.Context, limit int) ([]FriendRequest, error) // newest first, with the friend's name
|
||||
PruneRequests(ctx context.Context, before time.Time) error
|
||||
}
|
||||
|
|
|
|||
123
internal/federation/limits.go
Normal file
123
internal/federation/limits.go
Normal file
|
|
@ -0,0 +1,123 @@
|
|||
package federation
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// What a friend is held to while it reads: a few streams at a time, and a number of bytes a second shared by all
|
||||
// of them. The numbers are the admin's (see Settings).
|
||||
const (
|
||||
minKiBPerSec = 64
|
||||
maxKiBPerSec = 100 << 10
|
||||
maxStreamsCap = 20
|
||||
// A burst of this much time at the full rate is let through at once, so a small file is not slowed down.
|
||||
pacerBurst = 250 * time.Millisecond
|
||||
)
|
||||
|
||||
// pacer spaces out bytes: each Wait says when the allowance for those bytes is used up and sleeps until then.
|
||||
type pacer struct {
|
||||
mu sync.Mutex
|
||||
kib int
|
||||
next time.Time
|
||||
perByte time.Duration
|
||||
}
|
||||
|
||||
func newPacer(kib int) *pacer {
|
||||
return &pacer{kib: kib, perByte: time.Second / time.Duration(kib*1024)}
|
||||
}
|
||||
|
||||
func (p *pacer) wait(ctx context.Context, n int, now func() time.Time, sleep func(context.Context, time.Duration) error) error {
|
||||
p.mu.Lock()
|
||||
t := now()
|
||||
if p.next.Before(t) {
|
||||
p.next = t
|
||||
}
|
||||
p.next = p.next.Add(time.Duration(n) * p.perByte)
|
||||
delay := p.next.Sub(t) - pacerBurst
|
||||
p.mu.Unlock()
|
||||
if delay <= 0 {
|
||||
return nil
|
||||
}
|
||||
return sleep(ctx, delay)
|
||||
}
|
||||
|
||||
// Stream is a place among the streams a friend may have open. Close it when the stream ends.
|
||||
type Stream struct {
|
||||
s *Service
|
||||
friend int64
|
||||
slot bool // a place is taken, to give back on Close
|
||||
pace *pacer // nil: no limit
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
// Wait is called before sending n bytes: it sleeps as long as the friend's allowance asks.
|
||||
func (st *Stream) Wait(ctx context.Context, n int) error {
|
||||
if st.pace == nil {
|
||||
return nil
|
||||
}
|
||||
return st.pace.wait(ctx, n, st.s.now, st.s.sleep)
|
||||
}
|
||||
|
||||
// Close gives the place back. It may be called more than once.
|
||||
func (st *Stream) Close() {
|
||||
st.once.Do(func() {
|
||||
if !st.slot {
|
||||
return
|
||||
}
|
||||
st.s.mu.Lock()
|
||||
defer st.s.mu.Unlock()
|
||||
if st.s.streams[st.friend] > 0 {
|
||||
st.s.streams[st.friend]--
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// StartStream takes a place for a friend, or says ErrTooManyStreams. The limits are read every time, so a change
|
||||
// of the admin applies to the next stream.
|
||||
func (s *Service) StartStream(ctx context.Context, friendID int64) (*Stream, error) {
|
||||
return s.start(ctx, friendID, true)
|
||||
}
|
||||
|
||||
// Pace is a Stream that takes no place among the streams, only a share of the bytes: for what is small and comes
|
||||
// many at a time, like covers.
|
||||
func (s *Service) Pace(ctx context.Context, friendID int64) (*Stream, error) {
|
||||
return s.start(ctx, friendID, false)
|
||||
}
|
||||
|
||||
func (s *Service) start(ctx context.Context, friendID int64, slot bool) (*Stream, error) {
|
||||
set, err := s.load(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if slot {
|
||||
if s.streams[friendID] >= set.MaxStreams {
|
||||
return nil, ErrTooManyStreams
|
||||
}
|
||||
s.streams[friendID]++
|
||||
}
|
||||
st := &Stream{s: s, friend: friendID, slot: slot}
|
||||
if set.MaxKiBPerSec > 0 {
|
||||
p := s.pacers[friendID]
|
||||
if p == nil || p.kib != set.MaxKiBPerSec {
|
||||
p = newPacer(set.MaxKiBPerSec)
|
||||
s.pacers[friendID] = p
|
||||
}
|
||||
st.pace = p
|
||||
}
|
||||
return st, nil
|
||||
}
|
||||
|
||||
func sleepFor(ctx context.Context, d time.Duration) error {
|
||||
t := time.NewTimer(d)
|
||||
defer t.Stop()
|
||||
select {
|
||||
case <-t.C:
|
||||
return nil
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
}
|
||||
}
|
||||
400
internal/federation/peer_test.go
Normal file
400
internal/federation/peer_test.go
Normal file
|
|
@ -0,0 +1,400 @@
|
|||
package federation
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"errors"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// pairedServers makes two servers that are friends: b used an invite of a, and a approved. It returns a, its store,
|
||||
// b's key pair and the id of b among a's friends.
|
||||
func pairedServers(t *testing.T) (a *Service, aStore *memStore, ck *clock, bPub ed25519.PublicKey, bPriv ed25519.PrivateKey, bID int64) {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
a, aStore, ck = newServer(t, "Anna", "https://anna.example.org", nil)
|
||||
b, bStore, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
|
||||
inv, _ := a.CreateInvite(ctx)
|
||||
if _, err := b.Redeem(ctx, inv.Text); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
list, _ := aStore.Friends(ctx)
|
||||
if _, err := a.Approve(ctx, list[0].ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return a, aStore, ck, bStore.settings.PublicKey, bStore.settings.PrivateKey, list[0].ID
|
||||
}
|
||||
|
||||
func signedBy(priv ed25519.PrivateKey, pub ed25519.PublicKey, now time.Time, uri, nonce string) Signed {
|
||||
h := Sign(priv, "GET", uri, now, nonce)
|
||||
return Signed{KeyID: KeyID(pub), Date: h.Date, Nonce: nonce, Signature: h.Signature, Method: "GET", URI: uri}
|
||||
}
|
||||
|
||||
func TestAFriendThatSignsProperlyIsAuthenticated(t *testing.T) {
|
||||
a, _, ck, pub, priv, id := pairedServers(t)
|
||||
got, err := a.Authenticate(context.Background(), signedBy(priv, pub, ck.t, "/api/v1/peer/artists?limit=5", "nonce-0123456789ab"))
|
||||
if err != nil || got.ID != id || got.Name != "Bruno" || got.State != Active {
|
||||
t.Fatalf("Authenticate = %+v, %v", got, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthenticationRefusesWhatIsNotProperlySigned(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, _, ck, pub, priv, _ := pairedServers(t)
|
||||
good := signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "nonce-0123456789ab")
|
||||
|
||||
stranger, strangerPriv, _ := ed25519.GenerateKey(nil)
|
||||
tamper := func(f func(*Signed)) Signed { s := good; f(&s); return s }
|
||||
for name, in := range map[string]Signed{
|
||||
"nothing": {},
|
||||
"another path": tamper(func(s *Signed) { s.URI = "/api/v1/peer/albums" }),
|
||||
"another query": tamper(func(s *Signed) { s.URI = "/api/v1/peer/artists?limit=1" }),
|
||||
"another method": tamper(func(s *Signed) { s.Method = "POST" }),
|
||||
"another nonce": tamper(func(s *Signed) { s.Nonce = "nonce-ffffffffffff" }),
|
||||
"a short nonce": signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "short"),
|
||||
"a nonce with spaces": signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "nonce with spaces!!"),
|
||||
"a damaged signature": tamper(func(s *Signed) { s.Signature = "AAAA" }),
|
||||
"no signature": tamper(func(s *Signed) { s.Signature = "" }),
|
||||
"a key that is no friend": signedBy(strangerPriv, stranger, ck.t, "/api/v1/peer/artists", "nonce-0123456789ab"),
|
||||
"a bad key id": tamper(func(s *Signed) { s.KeyID = "xyz" }),
|
||||
"a date that is no date": tamper(func(s *Signed) { s.Date = "yesterday" }),
|
||||
"too old": signedBy(priv, pub, ck.t.Add(-3*time.Minute), "/api/v1/peer/artists", "nonce-0123456789ab"),
|
||||
"from the future": signedBy(priv, pub, ck.t.Add(3*time.Minute), "/api/v1/peer/artists", "nonce-0123456789ab"),
|
||||
} {
|
||||
if _, err := a.Authenticate(ctx, in); !errors.Is(err, ErrUnauthorized) {
|
||||
t.Errorf("%s: err = %v, want ErrUnauthorized", name, err)
|
||||
}
|
||||
}
|
||||
// None of those used the nonce up: the good request still works.
|
||||
if _, err := a.Authenticate(ctx, good); err != nil {
|
||||
t.Errorf("the good request after the bad ones: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnAnswerToTheSameRequestIsNotGivenTwice(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, _, ck, pub, priv, _ := pairedServers(t)
|
||||
req := signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "nonce-0123456789ab")
|
||||
if _, err := a.Authenticate(ctx, req); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := a.Authenticate(ctx, req); !errors.Is(err, ErrUnauthorized) {
|
||||
t.Errorf("replay = %v, want ErrUnauthorized", err)
|
||||
}
|
||||
// Once the window has passed the request is too old anyway, and the nonce is forgotten.
|
||||
ck.t = ck.t.Add(10 * time.Minute)
|
||||
if _, err := a.Authenticate(ctx, req); !errors.Is(err, ErrUnauthorized) {
|
||||
t.Errorf("replay after the window = %v, want ErrUnauthorized", err)
|
||||
}
|
||||
if n := len(a.seen); n != 0 {
|
||||
// Cleaned the next time one is added.
|
||||
a.remember("k", "n", ck.t)
|
||||
if len(a.seen) != 1 {
|
||||
t.Errorf("seen nonces = %d, want the old ones forgotten", len(a.seen))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestOnlyApprovedFriendsAreAnswered(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, aStore, ck, pub, priv, id := pairedServers(t)
|
||||
|
||||
// Not on, nothing is answered.
|
||||
off := false
|
||||
if _, err := a.Update(ctx, Patch{Enabled: &off}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := a.Authenticate(ctx, signedBy(priv, pub, ck.t, "/x", "nonce-0123456789ab")); !errors.Is(err, ErrOff) {
|
||||
t.Errorf("while off: %v, want ErrOff", err)
|
||||
}
|
||||
on := true
|
||||
_, _ = a.Update(ctx, Patch{Enabled: &on})
|
||||
|
||||
// A request that is waiting for approval is told so, once its signature is known to be good.
|
||||
aStore.friends[0].State = Incoming
|
||||
if _, err := a.Authenticate(ctx, signedBy(priv, pub, ck.t, "/x", "nonce-aaaaaaaaaaaa")); !errors.Is(err, ErrNotApproved) {
|
||||
t.Errorf("incoming: %v, want ErrNotApproved", err)
|
||||
}
|
||||
// A friend that was removed is a stranger.
|
||||
if err := a.Remove(ctx, id); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := a.Authenticate(ctx, signedBy(priv, pub, ck.t, "/x", "nonce-bbbbbbbbbbbb")); !errors.Is(err, ErrUnauthorized) {
|
||||
t.Errorf("removed: %v, want ErrUnauthorized", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAServerThatApprovedUsMayCallBeforeWeHeardIt(t *testing.T) {
|
||||
// b pasted an invite: for b, a is outgoing. When a calls b it has approved (it would not call otherwise),
|
||||
// so b answers and the friendship is active from then on.
|
||||
ctx := context.Background()
|
||||
a, aStore, ck, _, _, _ := pairedServers(t)
|
||||
b, bStore, _ := newServer(t, "Carla", "https://carla.example.org", &direct{to: a})
|
||||
inv, _ := a.CreateInvite(ctx)
|
||||
if _, err := b.Redeem(ctx, inv.Text); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
b.now = ck.now
|
||||
list, _ := aStore.Friends(ctx)
|
||||
_, _ = a.Approve(ctx, list[len(list)-1].ID)
|
||||
aPub, aPriv := aStore.settings.PublicKey, aStore.settings.PrivateKey
|
||||
if st, _ := bStore.Friends(ctx); st[0].State != Outgoing {
|
||||
t.Fatalf("b's friend = %+v", st)
|
||||
}
|
||||
got, err := b.Authenticate(ctx, signedBy(aPriv, aPub, ck.t, "/x", "nonce-0123456789ab"))
|
||||
if err != nil || got.State != Active {
|
||||
t.Fatalf("Authenticate = %+v, %v", got, err)
|
||||
}
|
||||
if st, _ := bStore.Friends(ctx); st[0].State != Active || st[0].ApprovedAt.IsZero() {
|
||||
t.Errorf("b's friend after the call = %+v", st)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStreamsAreLimitedForEachFriend(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, _, _, _, _, id := pairedServers(t)
|
||||
|
||||
var open []*Stream
|
||||
for i := 0; i < DefaultMaxStreams; i++ {
|
||||
s, err := a.StartStream(ctx, id)
|
||||
if err != nil {
|
||||
t.Fatalf("stream %d: %v", i, err)
|
||||
}
|
||||
open = append(open, s)
|
||||
}
|
||||
if _, err := a.StartStream(ctx, id); !errors.Is(err, ErrTooManyStreams) {
|
||||
t.Fatalf("one too many = %v, want ErrTooManyStreams", err)
|
||||
}
|
||||
// Another friend has its own allowance.
|
||||
if s, err := a.StartStream(ctx, id+1); err != nil {
|
||||
t.Errorf("another friend: %v", err)
|
||||
} else {
|
||||
s.Close()
|
||||
}
|
||||
open[0].Close()
|
||||
open[0].Close() // closing twice frees only one place
|
||||
s, err := a.StartStream(ctx, id)
|
||||
if err != nil {
|
||||
t.Fatalf("after one ended: %v", err)
|
||||
}
|
||||
if _, err := a.StartStream(ctx, id); !errors.Is(err, ErrTooManyStreams) {
|
||||
t.Errorf("a double Close freed two places: %v", err)
|
||||
}
|
||||
s.Close()
|
||||
|
||||
// The limit is the admin's to set.
|
||||
two := 2
|
||||
if _, err := a.Update(ctx, Patch{MaxStreams: &two}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, o := range open[1:] {
|
||||
o.Close()
|
||||
}
|
||||
x, _ := a.StartStream(ctx, id)
|
||||
y, _ := a.StartStream(ctx, id)
|
||||
if _, err := a.StartStream(ctx, id); !errors.Is(err, ErrTooManyStreams) {
|
||||
t.Errorf("limit 2: %v, want ErrTooManyStreams", err)
|
||||
}
|
||||
x.Close()
|
||||
y.Close()
|
||||
}
|
||||
|
||||
func TestTheBytesOfAFriendAreSpacedOutOverTime(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, _, ck, _, _, id := pairedServers(t)
|
||||
var slept time.Duration
|
||||
a.sleep = func(_ context.Context, d time.Duration) error { slept += d; ck.t = ck.t.Add(d); return nil }
|
||||
|
||||
kib := 1024 // one MiB a second
|
||||
if _, err := a.Update(ctx, Patch{MaxKiBPerSec: &kib}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s, err := a.StartStream(ctx, id)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer s.Close()
|
||||
for i := 0; i < 64; i++ { // 4 MiB in chunks of 64 KiB
|
||||
if err := s.Wait(ctx, 64<<10); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
// 4 MiB at 1 MiB/s is 4 s, less the short burst that is let through at once.
|
||||
if slept < 3500*time.Millisecond || slept > 4*time.Second {
|
||||
t.Errorf("slept %v for 4 MiB at 1 MiB/s", slept)
|
||||
}
|
||||
|
||||
// Two streams of one friend share the allowance.
|
||||
slept = 0
|
||||
s2, _ := a.StartStream(ctx, id)
|
||||
defer s2.Close()
|
||||
for i := 0; i < 16; i++ {
|
||||
_ = s.Wait(ctx, 64<<10)
|
||||
_ = s2.Wait(ctx, 64<<10)
|
||||
}
|
||||
if slept < 1500*time.Millisecond {
|
||||
t.Errorf("two streams slept %v for 2 MiB: they must share one allowance", slept)
|
||||
}
|
||||
|
||||
// 0 means no limit.
|
||||
zero := 0
|
||||
_, _ = a.Update(ctx, Patch{MaxKiBPerSec: &zero})
|
||||
s3, _ := a.StartStream(ctx, id)
|
||||
defer s3.Close()
|
||||
slept = 0
|
||||
for i := 0; i < 64; i++ {
|
||||
_ = s3.Wait(ctx, 64<<10)
|
||||
}
|
||||
if slept != 0 {
|
||||
t.Errorf("no limit slept %v", slept)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTheLimitsAreChecked(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
s := NewService(newMemStore(), nil)
|
||||
for name, p := range map[string]Patch{
|
||||
"no streams": {MaxStreams: ptr(0)},
|
||||
"too many": {MaxStreams: ptr(21)},
|
||||
"a trickle": {MaxKiBPerSec: ptr(10)},
|
||||
"negative": {MaxKiBPerSec: ptr(-1)},
|
||||
"a flood": {MaxKiBPerSec: ptr(200000)},
|
||||
} {
|
||||
if _, err := s.Update(ctx, p); !errors.Is(err, ErrInvalidInput) {
|
||||
t.Errorf("%s: err = %v, want ErrInvalidInput", name, err)
|
||||
}
|
||||
}
|
||||
st, err := s.Update(ctx, Patch{MaxStreams: ptr(5), MaxKiBPerSec: ptr(512)})
|
||||
if err != nil || st.MaxStreams != 5 || st.MaxKiBPerSec != 512 {
|
||||
t.Errorf("Update = %+v, %v", st, err)
|
||||
}
|
||||
if def, _ := NewService(newMemStore(), nil).Status(ctx); def.MaxStreams != DefaultMaxStreams || def.MaxKiBPerSec != DefaultMaxKiBPerSec {
|
||||
t.Errorf("defaults = %d and %d", def.MaxStreams, def.MaxKiBPerSec)
|
||||
}
|
||||
}
|
||||
|
||||
func ptr(n int) *int { return &n }
|
||||
|
||||
func TestTheRequestsOfFriendsAreKeptAndOldOnesDropped(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, aStore, ck, _, _, id := pairedServers(t)
|
||||
|
||||
for i := 0; i < 3; i++ {
|
||||
a.Record(ctx, FriendRequest{FriendID: id, Route: "/api/v1/peer/tracks/:id/stream", Status: 200, Bytes: int64(100 * (i + 1))})
|
||||
ck.t = ck.t.Add(time.Minute)
|
||||
}
|
||||
got, err := a.Requests(ctx)
|
||||
if err != nil || len(got) != 3 {
|
||||
t.Fatalf("Requests = %+v, %v", got, err)
|
||||
}
|
||||
if got[0].Bytes != 300 || got[0].FriendName != "Bruno" || got[0].Route == "" || got[2].Bytes != 100 {
|
||||
t.Errorf("newest first, with the friend's name: %+v", got)
|
||||
}
|
||||
|
||||
// Rows older than a week go, on a later write (every 100th).
|
||||
ck.t = ck.t.Add(8 * 24 * time.Hour)
|
||||
for i := 0; i < requestPruneEvery; i++ {
|
||||
a.Record(ctx, FriendRequest{FriendID: id, Route: "/api/v1/peer/info", Status: 200})
|
||||
}
|
||||
for _, r := range aStore.requests {
|
||||
if ck.t.Sub(r.At) > requestKeep {
|
||||
t.Errorf("a request from %v is still kept", r.At)
|
||||
}
|
||||
}
|
||||
got, _ = a.Requests(ctx)
|
||||
if len(got) == 0 || len(got) > requestsShown {
|
||||
t.Errorf("Requests shows %d rows, want 1 to %d", len(got), requestsShown)
|
||||
}
|
||||
}
|
||||
|
||||
// fakeRemote answers a signed call as a script says.
|
||||
type fakeRemote struct {
|
||||
info Info
|
||||
err error
|
||||
got Auth
|
||||
addr string
|
||||
}
|
||||
|
||||
func (f *fakeRemote) Pair(context.Context, string, PairRequest) (PairReply, error) {
|
||||
return PairReply{}, 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
|
||||
}
|
||||
|
||||
func TestAServerThatPastedAnInviteLearnsWhenTheOtherApproved(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, _, _ := newServer(t, "Anna", "https://anna.example.org", nil)
|
||||
remote := &fakeRemote{}
|
||||
b, bStore, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
|
||||
inv, _ := a.CreateInvite(ctx)
|
||||
mine, err := b.Redeem(ctx, inv.Text)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
b.remote = remote
|
||||
|
||||
// Anna has not approved yet: the answer is "not yet", and the friend stays as it is.
|
||||
remote.err = ErrNotApproved
|
||||
got, err := b.Check(ctx, mine.ID)
|
||||
if !errors.Is(err, ErrNotApproved) || got.State != Outgoing {
|
||||
t.Fatalf("before approval: %+v, %v", got, err)
|
||||
}
|
||||
if remote.addr != "https://anna.example.org" || remote.got.KeyID != KeyID(bStore.settings.PublicKey) || len(remote.got.Key) != ed25519.PrivateKeySize {
|
||||
t.Errorf("the call was made to %q with %+v: it must be signed by this server's key", remote.addr, remote.got.KeyID)
|
||||
}
|
||||
|
||||
// Anna approved: the first answer makes it active.
|
||||
remote.err, remote.info = nil, Info{Name: "Anna", SharedLibraries: 2}
|
||||
got, err = b.Check(ctx, mine.ID)
|
||||
if err != nil || got.State != Active || got.ApprovedAt.IsZero() {
|
||||
t.Fatalf("after approval: %+v, %v", got, err)
|
||||
}
|
||||
// And again once it is active: nothing changes, nothing breaks.
|
||||
if again, err := b.Check(ctx, mine.ID); err != nil || again.State != Active {
|
||||
t.Errorf("second check: %+v, %v", again, err)
|
||||
}
|
||||
|
||||
// A server that cannot be asked is not a verdict.
|
||||
remote.err = ErrUnreachable
|
||||
if _, err := b.Check(ctx, mine.ID); !errors.Is(err, ErrUnreachable) {
|
||||
t.Errorf("unreachable: %v", err)
|
||||
}
|
||||
if st, _ := bStore.Friends(ctx); st[0].State != Active {
|
||||
t.Errorf("an unreachable server changed the state to %v", st[0].State)
|
||||
}
|
||||
if _, err := b.Check(ctx, 999); !errors.Is(err, ErrFriendMissing) {
|
||||
t.Errorf("unknown friend: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnIncomingRequestIsNotSomethingToCheck(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
a, aStore, _ := newServer(t, "Anna", "https://anna.example.org", nil)
|
||||
a.remote = &fakeRemote{}
|
||||
pub, _, _ := ed25519.GenerateKey(nil)
|
||||
f, _ := aStore.AddFriend(ctx, Friend{Name: "B", Address: "https://b.example.org", PublicKey: pub, State: Incoming})
|
||||
if _, err := a.Check(ctx, f.ID); !errors.Is(err, ErrWrongState) {
|
||||
t.Errorf("Check of an incoming friend = %v, want ErrWrongState", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignAndVerifyAgree(t *testing.T) {
|
||||
pub, priv, _ := ed25519.GenerateKey(nil)
|
||||
now := time.Unix(1_700_000_000, 0)
|
||||
h := Sign(priv, "GET", "/api/v1/peer/info", now, "n-0123456789abcdef")
|
||||
if h.Date != strconv.FormatInt(now.Unix(), 10) || !strings.HasPrefix(h.Nonce, "n-") && h.Nonce == "" {
|
||||
t.Errorf("headers = %+v", h)
|
||||
}
|
||||
if !verify(pub, "GET", "/api/v1/peer/info", h.Date, "n-0123456789abcdef", h.Signature) {
|
||||
t.Error("a signature does not verify")
|
||||
}
|
||||
if verify(pub, "GET", "/api/v1/peer/other", h.Date, "n-0123456789abcdef", h.Signature) {
|
||||
t.Error("a signature verifies for another path")
|
||||
}
|
||||
}
|
||||
|
|
@ -8,11 +8,13 @@ import (
|
|||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/netip"
|
||||
"net/url"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
|
@ -29,6 +31,13 @@ const (
|
|||
pairAttempts = 10 // pairing requests allowed in one window, from anyone
|
||||
pairWindow = time.Minute
|
||||
keyIDHexLength = 16
|
||||
|
||||
clockSkew = 2 * time.Minute // how far a friend's clock may be from this one
|
||||
minNonceLen = 16
|
||||
maxNonceLen = 64
|
||||
requestPruneEvery = 100 // the log is tidied every this many requests
|
||||
requestKeep = 7 * 24 * time.Hour
|
||||
requestsShown = 50
|
||||
)
|
||||
|
||||
// Sends is what an admin is told before turning federation on.
|
||||
|
|
@ -56,6 +65,22 @@ type Remote interface {
|
|||
// Pair sends the request to the server at address. It returns ErrRefused when that server turned the invite down,
|
||||
// and ErrUnreachable when it did not answer as a Sonda server with federation on.
|
||||
Pair(ctx context.Context, address string, req PairRequest) (PairReply, error)
|
||||
// Info asks the server at address who it is, with a request signed by this server. It returns ErrNotApproved
|
||||
// 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)
|
||||
}
|
||||
|
||||
// Auth is what signs a request to a friend: this server's key.
|
||||
type Auth struct {
|
||||
KeyID string
|
||||
Key ed25519.PrivateKey
|
||||
}
|
||||
|
||||
// Info is what a server says of itself to a friend.
|
||||
type Info struct {
|
||||
Name string
|
||||
SharedLibraries int
|
||||
}
|
||||
|
||||
// Status is what an admin sees: the settings without the private key, and the friends.
|
||||
|
|
@ -66,6 +91,9 @@ type Status struct {
|
|||
KeyID string // empty until federation was first turned on
|
||||
Friends []Friend
|
||||
Sends string
|
||||
|
||||
MaxStreams int // parallel streams one friend may have
|
||||
MaxKiBPerSec int // KiB a second one friend may take; 0 means no limit
|
||||
}
|
||||
|
||||
// Patch changes some settings. A nil field is left alone; an empty Address clears it and an empty Name goes back to the host name.
|
||||
|
|
@ -73,6 +101,9 @@ type Patch struct {
|
|||
Enabled *bool
|
||||
Name *string
|
||||
Address *string
|
||||
|
||||
MaxStreams *int
|
||||
MaxKiBPerSec *int
|
||||
}
|
||||
|
||||
// Invite is what an admin gives to the other one, once.
|
||||
|
|
@ -88,13 +119,22 @@ type Service struct {
|
|||
now func() time.Time
|
||||
host func() string
|
||||
|
||||
mu sync.Mutex // an update reads then writes; the attempts list is shared
|
||||
sleep func(context.Context, time.Duration) error
|
||||
|
||||
mu sync.Mutex // an update reads then writes; the lists below are shared
|
||||
attempts []time.Time
|
||||
seen map[string]time.Time // nonces of signed requests, until they could not be replayed any more
|
||||
streams map[int64]int // streams open for each friend
|
||||
pacers map[int64]*pacer
|
||||
logged int
|
||||
}
|
||||
|
||||
// NewService builds a Service. remote may be nil in a server that never pastes an invite (tests).
|
||||
func NewService(store Store, remote Remote) *Service {
|
||||
return &Service{store: store, remote: remote, now: time.Now, host: hostName}
|
||||
return &Service{
|
||||
store: store, remote: remote, now: time.Now, host: hostName, sleep: sleepFor,
|
||||
seen: map[string]time.Time{}, streams: map[int64]int{}, pacers: map[int64]*pacer{},
|
||||
}
|
||||
}
|
||||
|
||||
func hostName() string {
|
||||
|
|
@ -105,10 +145,13 @@ func hostName() string {
|
|||
}
|
||||
|
||||
func (s *Service) load(ctx context.Context) (Settings, error) {
|
||||
set, _, err := s.store.Settings(ctx)
|
||||
set, found, err := s.store.Settings(ctx)
|
||||
if err != nil {
|
||||
return Settings{}, fmt.Errorf("read federation settings: %w", err)
|
||||
}
|
||||
if !found {
|
||||
set.MaxStreams, set.MaxKiBPerSec = DefaultMaxStreams, DefaultMaxKiBPerSec
|
||||
}
|
||||
return set, nil
|
||||
}
|
||||
|
||||
|
|
@ -129,7 +172,10 @@ func (s *Service) Status(ctx context.Context) (Status, error) {
|
|||
if err != nil {
|
||||
return Status{}, fmt.Errorf("list friends: %w", err)
|
||||
}
|
||||
st := Status{Enabled: set.Enabled, Name: s.name(set), Address: set.Address, Friends: friends, Sends: Sends}
|
||||
st := Status{
|
||||
Enabled: set.Enabled, Name: s.name(set), Address: set.Address, Friends: friends, Sends: Sends,
|
||||
MaxStreams: set.MaxStreams, MaxKiBPerSec: set.MaxKiBPerSec,
|
||||
}
|
||||
if set.PublicKey != nil {
|
||||
st.KeyID = KeyID(set.PublicKey)
|
||||
}
|
||||
|
|
@ -162,6 +208,20 @@ func (s *Service) Update(ctx context.Context, p Patch) (Status, error) {
|
|||
}
|
||||
set.Address = addr
|
||||
}
|
||||
if p.MaxStreams != nil {
|
||||
if *p.MaxStreams < 1 || *p.MaxStreams > maxStreamsCap {
|
||||
s.mu.Unlock()
|
||||
return Status{}, fmt.Errorf("%w: streams are 1 to %d", ErrInvalidInput, maxStreamsCap)
|
||||
}
|
||||
set.MaxStreams = *p.MaxStreams
|
||||
}
|
||||
if p.MaxKiBPerSec != nil {
|
||||
if k := *p.MaxKiBPerSec; k != 0 && (k < minKiBPerSec || k > maxKiBPerSec) {
|
||||
s.mu.Unlock()
|
||||
return Status{}, fmt.Errorf("%w: the rate is 0 (no limit) or %d to %d KiB a second", ErrInvalidInput, minKiBPerSec, maxKiBPerSec)
|
||||
}
|
||||
set.MaxKiBPerSec = *p.MaxKiBPerSec
|
||||
}
|
||||
if p.Enabled != nil {
|
||||
set.Enabled = *p.Enabled
|
||||
if set.Enabled && set.PublicKey == nil {
|
||||
|
|
@ -431,3 +491,132 @@ func onOwnNetwork(host string) bool {
|
|||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func validNonce(n string) bool {
|
||||
if len(n) < minNonceLen || len(n) > maxNonceLen {
|
||||
return false
|
||||
}
|
||||
for _, r := range n {
|
||||
if !(r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_') {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// remember says whether a nonce is new, and keeps it for as long as a request made with it would still be accepted.
|
||||
func (s *Service) remember(keyID, nonce string, now time.Time) bool {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
for k, until := range s.seen {
|
||||
if !now.Before(until) {
|
||||
delete(s.seen, k)
|
||||
}
|
||||
}
|
||||
key := keyID + ":" + nonce
|
||||
if _, again := s.seen[key]; again {
|
||||
return false
|
||||
}
|
||||
s.seen[key] = now.Add(2*clockSkew + time.Second)
|
||||
return true
|
||||
}
|
||||
|
||||
// Authenticate tells which friend made a request, or why none did. It answers ErrOff while federation is off,
|
||||
// ErrUnauthorized for every kind of request that is not properly signed (the same answer, so that a stranger learns
|
||||
// nothing), and ErrNotApproved when the signature is good but this server's admin has not approved the friend yet.
|
||||
// A friend this server is waiting for (outgoing) that calls has approved, so it becomes active.
|
||||
func (s *Service) Authenticate(ctx context.Context, in Signed) (Friend, error) {
|
||||
set, err := s.load(ctx)
|
||||
if err != nil {
|
||||
return Friend{}, err
|
||||
}
|
||||
if !set.Enabled || set.PublicKey == nil {
|
||||
return Friend{}, ErrOff
|
||||
}
|
||||
date, err := strconv.ParseInt(in.Date, 10, 64)
|
||||
if err != nil || len(in.KeyID) != keyIDHexLength || !validNonce(in.Nonce) || in.Signature == "" {
|
||||
return Friend{}, ErrUnauthorized
|
||||
}
|
||||
now := s.now()
|
||||
if skew := now.Sub(time.Unix(date, 0)); skew > clockSkew || skew < -clockSkew {
|
||||
return Friend{}, ErrUnauthorized
|
||||
}
|
||||
friends, err := s.store.Friends(ctx)
|
||||
if err != nil {
|
||||
return Friend{}, fmt.Errorf("list friends: %w", err)
|
||||
}
|
||||
var friend Friend
|
||||
found := false
|
||||
for _, f := range friends {
|
||||
if KeyID(f.PublicKey) == in.KeyID {
|
||||
friend, found = f, true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found || !verify(friend.PublicKey, in.Method, in.URI, in.Date, in.Nonce, in.Signature) {
|
||||
return Friend{}, ErrUnauthorized
|
||||
}
|
||||
if friend.State == Incoming {
|
||||
return Friend{}, ErrNotApproved
|
||||
}
|
||||
if !s.remember(in.KeyID, in.Nonce, now) {
|
||||
return Friend{}, ErrUnauthorized
|
||||
}
|
||||
if friend.State == Outgoing {
|
||||
if err := s.store.Activate(ctx, friend.ID, now); err == nil {
|
||||
friend.State, friend.ApprovedAt = Active, now
|
||||
}
|
||||
}
|
||||
return friend, nil
|
||||
}
|
||||
|
||||
// Check asks a friend that this server is waiting for, or already has, who it is, signed. An answer means it
|
||||
// approved, so a friend that was outgoing becomes active. ErrNotApproved means it has not approved yet.
|
||||
func (s *Service) Check(ctx context.Context, id int64) (Friend, error) {
|
||||
f, err := s.store.Friend(ctx, id)
|
||||
if err != nil {
|
||||
return Friend{}, err
|
||||
}
|
||||
if f.State == Incoming {
|
||||
return f, ErrWrongState
|
||||
}
|
||||
set, err := s.load(ctx)
|
||||
if err != nil {
|
||||
return f, err
|
||||
}
|
||||
if !set.Enabled || set.PublicKey == nil {
|
||||
return f, ErrOff
|
||||
}
|
||||
if _, err := s.remote.Info(ctx, f.Address, Auth{KeyID: KeyID(set.PublicKey), Key: set.PrivateKey}); err != nil {
|
||||
return f, err
|
||||
}
|
||||
if f.State == Outgoing {
|
||||
now := s.now()
|
||||
if err := s.store.Activate(ctx, f.ID, now); err != nil && !errors.Is(err, ErrWrongState) {
|
||||
return f, err
|
||||
}
|
||||
f.State, f.ApprovedAt = Active, now
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
|
||||
// Record logs a request a friend made. A failure to log is not a reason to fail the request, so it is not returned.
|
||||
func (s *Service) Record(ctx context.Context, r FriendRequest) {
|
||||
now := s.now()
|
||||
if r.At.IsZero() {
|
||||
r.At = now
|
||||
}
|
||||
_ = s.store.LogRequest(ctx, r)
|
||||
s.mu.Lock()
|
||||
s.logged++
|
||||
tidy := s.logged%requestPruneEvery == 0
|
||||
s.mu.Unlock()
|
||||
if tidy {
|
||||
_ = s.store.PruneRequests(ctx, now.Add(-requestKeep))
|
||||
}
|
||||
}
|
||||
|
||||
// Requests lists the last requests friends made, newest first.
|
||||
func (s *Service) Requests(ctx context.Context) ([]FriendRequest, error) {
|
||||
return s.store.Requests(ctx, requestsShown)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ type memStore struct {
|
|||
settings *Settings
|
||||
invites map[string]memInvite
|
||||
friends []Friend
|
||||
requests []FriendRequest
|
||||
nextID int64
|
||||
}
|
||||
|
||||
|
|
@ -94,6 +95,50 @@ func (m *memStore) Approve(_ context.Context, id int64, now time.Time) error {
|
|||
return ErrFriendMissing
|
||||
}
|
||||
|
||||
func (m *memStore) Activate(_ context.Context, id int64, now time.Time) error {
|
||||
for i, f := range m.friends {
|
||||
if f.ID != id {
|
||||
continue
|
||||
}
|
||||
if f.State != Outgoing {
|
||||
return ErrWrongState
|
||||
}
|
||||
m.friends[i].State, m.friends[i].ApprovedAt = Active, now
|
||||
return nil
|
||||
}
|
||||
return ErrFriendMissing
|
||||
}
|
||||
|
||||
func (m *memStore) LogRequest(_ context.Context, r FriendRequest) error {
|
||||
m.requests = append(m.requests, r)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *memStore) Requests(_ context.Context, limit int) ([]FriendRequest, error) {
|
||||
var out []FriendRequest
|
||||
for i := len(m.requests) - 1; i >= 0 && len(out) < limit; i-- {
|
||||
r := m.requests[i]
|
||||
for _, f := range m.friends {
|
||||
if f.ID == r.FriendID {
|
||||
r.FriendName = f.Name
|
||||
}
|
||||
}
|
||||
out = append(out, r)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (m *memStore) PruneRequests(_ context.Context, before time.Time) error {
|
||||
kept := m.requests[:0]
|
||||
for _, r := range m.requests {
|
||||
if !r.At.Before(before) {
|
||||
kept = append(kept, r)
|
||||
}
|
||||
}
|
||||
m.requests = kept
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *memStore) DeleteFriend(_ context.Context, id int64) error {
|
||||
for i, f := range m.friends {
|
||||
if f.ID == id {
|
||||
|
|
@ -122,6 +167,10 @@ func (d *direct) Pair(ctx context.Context, _ string, req PairRequest) (PairReply
|
|||
return reply, nil
|
||||
}
|
||||
|
||||
func (d *direct) Info(context.Context, string, Auth) (Info, error) {
|
||||
return Info{}, errors.New("not used")
|
||||
}
|
||||
|
||||
type clock struct{ t time.Time }
|
||||
|
||||
func (c *clock) now() time.Time { return c.t }
|
||||
|
|
@ -342,6 +391,10 @@ func TestAnExpiredInviteIsRefused(t *testing.T) {
|
|||
// A server that answers with another key than the one in the invite is not the one the invite came from.
|
||||
type swapKey struct{ real Remote }
|
||||
|
||||
func (s swapKey) Info(ctx context.Context, addr string, a Auth) (Info, error) {
|
||||
return s.real.Info(ctx, addr, 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 {
|
||||
|
|
|
|||
50
internal/federation/sign.go
Normal file
50
internal/federation/sign.go
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
package federation
|
||||
|
||||
import (
|
||||
"crypto/ed25519"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
// The headers of a request from a friend.
|
||||
const (
|
||||
HeaderKeyID = "Sonda-Key-Id"
|
||||
HeaderDate = "Sonda-Date"
|
||||
HeaderNonce = "Sonda-Nonce"
|
||||
HeaderSignature = "Sonda-Signature"
|
||||
)
|
||||
|
||||
// Headers are what a signed request adds, besides the key id.
|
||||
type Headers struct{ Date, Nonce, Signature string }
|
||||
|
||||
// Signed is what a server read of a request, to find out whether a friend made it.
|
||||
type Signed struct {
|
||||
KeyID, Date, Nonce, Signature string
|
||||
Method string
|
||||
URI string // the path from /api/v1/peer on, and the query, as sent
|
||||
}
|
||||
|
||||
// The body of a request from a friend is always empty (they only read), and its hash is part of what is signed.
|
||||
var emptyBodyHash = func() string { sum := sha256.Sum256(nil); return hex.EncodeToString(sum[:]) }()
|
||||
|
||||
func signingString(method, uri, date, nonce string) []byte {
|
||||
return []byte(method + "\n" + uri + "\n" + date + "\n" + nonce + "\n" + emptyBodyHash)
|
||||
}
|
||||
|
||||
// Sign signs a request: method, path and query, date, nonce and the hash of the (empty) body.
|
||||
func Sign(priv ed25519.PrivateKey, method, uri string, now time.Time, nonce string) Headers {
|
||||
date := strconv.FormatInt(now.Unix(), 10)
|
||||
sig := ed25519.Sign(priv, signingString(method, uri, date, nonce))
|
||||
return Headers{Date: date, Nonce: nonce, Signature: base64.RawURLEncoding.EncodeToString(sig)}
|
||||
}
|
||||
|
||||
func verify(pub ed25519.PublicKey, method, uri, date, nonce, signature string) bool {
|
||||
sig, err := base64.RawURLEncoding.DecodeString(signature)
|
||||
if err != nil || len(sig) != ed25519.SignatureSize || len(pub) != ed25519.PublicKeySize {
|
||||
return false
|
||||
}
|
||||
return ed25519.Verify(pub, signingString(method, uri, date, nonce), sig)
|
||||
}
|
||||
|
|
@ -255,6 +255,39 @@ func (s *Service) AlbumCover(ctx context.Context, albumID int64, size Size) (*Co
|
|||
return s.open(kindAlbum, albumID, size, built)
|
||||
}
|
||||
|
||||
// StoredAlbumCover is AlbumCover for a friend: it returns a cover that was already built from the audio files, and
|
||||
// nothing else. It builds nothing, reads no audio file and asks nobody, so a friend cannot make this server do
|
||||
// work or contact a provider. A cover that came from the Cover Art Archive is not given either: it has no licence
|
||||
// to share. Anything else is ErrNoCover.
|
||||
func (s *Service) StoredAlbumCover(ctx context.Context, albumID int64, size Size) (*Cover, error) {
|
||||
if size != Small && size != Large {
|
||||
return nil, fmt.Errorf("%w: %q", ErrInvalidSize, string(size))
|
||||
}
|
||||
if albumID <= 0 {
|
||||
return nil, ErrAlbumNotFound
|
||||
}
|
||||
rec, ok, err := s.store.Get(ctx, kindAlbum, albumID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read picture record: %w", err)
|
||||
}
|
||||
if !ok || rec.Status != StatusOK || rec.Source == SourceCoverArt {
|
||||
return nil, ErrNoCover
|
||||
}
|
||||
c, err := s.open(kindAlbum, albumID, size, rec)
|
||||
if err != nil {
|
||||
return nil, ErrNoCover
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// StoredOnly is a Service that answers AlbumCover as StoredAlbumCover does, for the routes friends use.
|
||||
type StoredOnly struct{ *Service }
|
||||
|
||||
// AlbumCover returns a cover that was already built, or ErrNoCover.
|
||||
func (s StoredOnly) AlbumCover(ctx context.Context, albumID int64, size Size) (*Cover, error) {
|
||||
return s.StoredAlbumCover(ctx, albumID, size)
|
||||
}
|
||||
|
||||
// buildShared builds the cover of an album, one build per album however many ask at once. It
|
||||
// runs on its own context, so the first one to leave does not fail the others; each caller
|
||||
// waits only as long as its own context allows.
|
||||
|
|
|
|||
|
|
@ -596,3 +596,52 @@ func TestTheETagChangesWithThePictureNotTheSize(t *testing.T) {
|
|||
t.Error("the picture changed but the etag did not")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAFriendGetsOnlyACoverThatIsAlreadyBuiltFromTheFiles(t *testing.T) {
|
||||
r := newRig(t)
|
||||
ctx := context.Background()
|
||||
stored := StoredOnly{r.svc}
|
||||
|
||||
// Nothing was built: nothing is built for a friend, and no file is read.
|
||||
if _, err := stored.AlbumCover(ctx, 1, Large); !errors.Is(err, ErrNoCover) {
|
||||
t.Fatalf("before anyone asked: %v, want ErrNoCover", err)
|
||||
}
|
||||
if n := atomic.LoadInt32(&r.src.calls) + atomic.LoadInt32(&r.reads); n != 0 {
|
||||
t.Errorf("a friend's ask looked at the files %d times", n)
|
||||
}
|
||||
|
||||
// A listener opens it: it is built from the files.
|
||||
r.embedded[filepath.Join(r.root, "Album One/01.mp3")] = jpegBytes(t, 600, 600, color.White)
|
||||
want := r.read(t, 1, Large)
|
||||
c, err := stored.AlbumCover(ctx, 1, Large)
|
||||
if err != nil {
|
||||
t.Fatalf("after a listener built it: %v", err)
|
||||
}
|
||||
got, _ := io.ReadAll(c.File)
|
||||
_ = c.File.Close()
|
||||
if !bytes.Equal(got, want) {
|
||||
t.Error("a friend gets another picture than a listener")
|
||||
}
|
||||
if s, err := stored.AlbumCover(ctx, 1, Small); err != nil {
|
||||
t.Errorf("small: %v", err)
|
||||
} else {
|
||||
_ = s.File.Close()
|
||||
}
|
||||
if _, err := stored.AlbumCover(ctx, 1, Size("huge")); !errors.Is(err, ErrInvalidSize) {
|
||||
t.Errorf("a bad size: %v", err)
|
||||
}
|
||||
if _, err := stored.AlbumCover(ctx, 0, Large); !errors.Is(err, ErrAlbumNotFound) {
|
||||
t.Errorf("no album: %v", err)
|
||||
}
|
||||
|
||||
// A cover that came from the Cover Art Archive has no licence to share: friends do not get it.
|
||||
r.store.recs[key(kindAlbum, 1)] = Record{Status: StatusOK, Source: SourceCoverArt, CheckedAt: r.now, ETag: "x"}
|
||||
if _, err := stored.AlbumCover(ctx, 1, Large); !errors.Is(err, ErrNoCover) {
|
||||
t.Errorf("a cover from the archive: %v, want ErrNoCover", err)
|
||||
}
|
||||
// A cover whose file is gone is not an error for a friend, just no cover.
|
||||
r.store.recs[key(kindAlbum, 2)] = Record{Status: StatusOK, Source: SourceEmbedded, CheckedAt: r.now, ETag: "y"}
|
||||
if _, err := stored.AlbumCover(ctx, 2, Large); !errors.Is(err, ErrNoCover) {
|
||||
t.Errorf("a file that is gone: %v, want ErrNoCover", err)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue