A friend's server works out the peaks of a track in a shared library and gives
them to a signed friend (GET /peer/tracks/{id}/peaks). This server asks for them
and passes them on to the listener after checking them: 1 to 1000 levels from 0
to 255, as many as the count says (GET /friends/{friend}/tracks/{id}/peaks). The
player uses it for a friend's track, so its bar is no longer flat.
195 lines
6 KiB
Go
195 lines
6 KiB
Go
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/peaks", (&waveformHandlers{svc: d.PeerWaveform}).peaks)
|
|
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)
|
|
}
|