FahdShalhoub
249 lines
10 KiB
Go
249 lines
10 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"log"
|
|
"net/http"
|
|
"slices"
|
|
"strings"
|
|
"thamanyah/discovery/internal/api"
|
|
"thamanyah/discovery/internal/db/repositories"
|
|
"thamanyah/discovery/internal/services"
|
|
"time"
|
|
)
|
|
|
|
// GetVideo serves the catalogue's copy of one video.
|
|
//
|
|
// @Summary Get a catalogued video
|
|
// @Description Returns the catalogue's copy of a video: what a reader needs to show and play it. A video appears here only after the CMS has announced it as ready, so a video that is still transcoding — or one the CMS never made ready — is a 404.
|
|
// @Tags videos
|
|
// @Produce json
|
|
// @Param id path string true "Video id, as issued by the CMS"
|
|
// @Success 200 {object} api.Video
|
|
// @Failure 404 {object} api.ProblemDetails
|
|
// @Failure 500 {object} api.ProblemDetails
|
|
// @Router /api/videos/{id} [get]
|
|
func GetVideo(w http.ResponseWriter, r *http.Request) {
|
|
id := r.PathValue("id")
|
|
|
|
video, err := repositories.VideoRepo.GetVideoByID(r.Context(), id)
|
|
if errors.Is(err, repositories.ErrVideoNotFound) {
|
|
writeProblem(w, http.StatusNotFound, "Video Not In The Catalogue",
|
|
"No video with that id is in the catalogue. A video appears here once the CMS announces it as ready, so one that is still being transcoded is not here yet.")
|
|
return
|
|
}
|
|
if err != nil {
|
|
log.Printf("Something Went Wrong Loading A Catalogued Video: id=%q: %s", id, err)
|
|
writeProblem(w, http.StatusInternalServerError, "Something Went Wrong Loading The Catalogue",
|
|
"The video could not be read from the database. This is a server-side fault and the request was not processed; retrying in a few moments may succeed.")
|
|
return
|
|
}
|
|
|
|
// Translated field by field rather than returned as-is: models.Video is the
|
|
// row, api.Video is the published schema, and neither should drag the other
|
|
// along when it changes.
|
|
writeJSON(w, http.StatusOK, api.Video{
|
|
ID: video.ID,
|
|
Title: video.Title,
|
|
PlaybackURL: video.PlaybackURL,
|
|
// Never null on the wire: a video with no categories has an empty
|
|
// list, which is a different thing from "unknown".
|
|
Categories: append([]string{}, video.Categories...),
|
|
})
|
|
}
|
|
|
|
const (
|
|
// searchPageSize is how many videos a search returns when the caller does
|
|
// not say. Small enough to keep the common request cheap.
|
|
searchPageSize = 20
|
|
|
|
// maxSearchPageSize is the largest page the catalogue will build, however
|
|
// big a page the caller asks for. The endpoint is read constantly, and a
|
|
// page size is a request for work: without a ceiling, one client asking
|
|
// for the whole catalogue in a single response makes every other reader
|
|
// wait behind it.
|
|
//
|
|
// Asking for more is not an error — the page is simply capped, and the
|
|
// cursor still reaches the rest — because a client that wants everything
|
|
// is doing something legitimate, just not in one request.
|
|
maxSearchPageSize = 100
|
|
|
|
// searchCacheTTL is how long a page of results stays servable from the
|
|
// cache before it has to be built again.
|
|
//
|
|
// Nothing invalidates an entry when a video is announced: the consumer
|
|
// writes rows continuously and would have to know which of the cached
|
|
// pages a new title belongs on, which for a ranked search is every page it
|
|
// outranks. Expiry is the cheaper answer, and it bounds the staleness — a
|
|
// video is findable within a minute of being catalogued, which is the same
|
|
// order as the announcement's own delivery lag.
|
|
searchCacheTTL = time.Minute
|
|
)
|
|
|
|
// searchCacheKey is what one page of search results is stored under: the title
|
|
// searched for, the categories it was narrowed to, and the page within that
|
|
// result set.
|
|
//
|
|
// The page is named by the cursor, because with keyset paging that is what a
|
|
// page *is* — there is no page number to key on, and the cursor identifies the
|
|
// same rows whenever it is presented. The empty cursor is the first page.
|
|
//
|
|
// The limit is in the key too, even though a reader would not call it part of
|
|
// "which page". It has to be: the same title, categories and cursor with a
|
|
// different limit is a different set of rows, and sharing an entry between
|
|
// them would hand a client asking for 50 a page of 20.
|
|
//
|
|
// The parts are JSON-encoded rather than pasted together with separators so
|
|
// that no category name can be mistaken for the boundary between two of them —
|
|
// {"c":["a,b"]} and {"c":["a","b"]} stay distinguishable, which "a,b" and
|
|
// "a,b" would not. The key stays readable in redis-cli either way.
|
|
func searchCacheKey(title string, categories []string, limit int, cursor string) string {
|
|
// The title is lowercased because the search itself is: tsQueryFor folds
|
|
// case before it builds the tsquery, so two spellings that differ only in
|
|
// case are the same search and should be the same entry. The categories
|
|
// are not — they are compared to the stored array verbatim, so "News" and
|
|
// "news" really do ask different questions.
|
|
//
|
|
// Sorting the categories is safe for the same reason the SQL uses &&:
|
|
// they mean "any of these", so their order never changed the answer. Two
|
|
// readers naming the same categories in a different order now share one
|
|
// entry instead of building the same page twice.
|
|
//
|
|
// Never nil, so that a client sending "categories": [] and one omitting
|
|
// the member entirely — the same search, since both mean "every category"
|
|
// — land on one entry rather than on `null` and `[]`.
|
|
sorted := append([]string{}, categories...)
|
|
slices.Sort(sorted)
|
|
sorted = slices.Compact(sorted)
|
|
|
|
parts := struct {
|
|
Title string `json:"t"`
|
|
Categories []string `json:"c"`
|
|
Limit int `json:"l"`
|
|
Cursor string `json:"p"`
|
|
}{
|
|
Title: strings.ToLower(strings.TrimSpace(title)),
|
|
Categories: sorted,
|
|
Limit: limit,
|
|
Cursor: cursor,
|
|
}
|
|
|
|
// Cannot fail: every field is a string, a string slice or an int.
|
|
encoded, _ := json.Marshal(parts)
|
|
return "discovery:search:v1:" + string(encoded)
|
|
}
|
|
|
|
// cachedSearch returns the page held under key, or false when there is none to
|
|
// serve.
|
|
//
|
|
// Every failure reads as "no cached page": a cache that is unreachable, slow
|
|
// or holding something unreadable must cost a reader nothing more than the
|
|
// database query they would have paid for anyway. Only faults worth acting on
|
|
// are logged — a miss is not one.
|
|
func cachedSearch(ctx context.Context, key string) (api.SearchResults, bool) {
|
|
encoded, err := services.CacheClient.Get(ctx, key)
|
|
if errors.Is(err, services.ErrCacheMiss) {
|
|
return api.SearchResults{}, false
|
|
}
|
|
if err != nil {
|
|
log.Printf("Could Not Read The Search Cache, Falling Back To The Database: key=%q: %s", key, err)
|
|
return api.SearchResults{}, false
|
|
}
|
|
|
|
var results api.SearchResults
|
|
if err := json.Unmarshal(encoded, &results); err != nil {
|
|
// Only reachable if something else wrote this key, or the shape
|
|
// changed without the v1 in the prefix changing with it.
|
|
log.Printf("Could Not Read A Cached Search Page, Falling Back To The Database: key=%q: %s", key, err)
|
|
return api.SearchResults{}, false
|
|
}
|
|
|
|
return results, true
|
|
}
|
|
|
|
func cacheSearch(ctx context.Context, key string, results api.SearchResults) {
|
|
encoded, err := json.Marshal(results)
|
|
if err != nil {
|
|
log.Printf("Could Not Encode A Search Page For The Cache: key=%q: %s", key, err)
|
|
return
|
|
}
|
|
|
|
if err := services.CacheClient.Set(ctx, key, encoded, searchCacheTTL); err != nil {
|
|
log.Printf("Could Not Write The Search Cache: key=%q: %s", key, err)
|
|
}
|
|
}
|
|
|
|
// SearchVideos serves the catalogue's lexical search.
|
|
//
|
|
// It is served on QUERY rather than GET or POST: a search is safe and
|
|
// idempotent, which POST is not, but its parameters are a structured document
|
|
// that does not belong in a query string. QUERY says both. It is specified in
|
|
// draft-ietf-httpbis-safe-method-w-body, not in RFC 9110 — still a draft, so
|
|
// expect intermediaries that have never heard of it. Note it also cannot be
|
|
// expressed in the generated OpenAPI spec — Swagger 2.0 and OpenAPI 3.x define a fixed set of
|
|
// per-method fields with no slot for QUERY, and swag rejects the annotation
|
|
// outright — so this endpoint is deliberately absent from /swagger and
|
|
// documented here instead.
|
|
func SearchVideos(w http.ResponseWriter, r *http.Request) {
|
|
var request api.SearchRequest
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
|
|
writeProblem(w, http.StatusBadRequest, "Malformed Search",
|
|
"The request body could not be read as JSON. Send a JSON object describing what to search for; an empty object browses the whole catalogue.")
|
|
return
|
|
}
|
|
|
|
limit := request.Limit
|
|
if limit <= 0 {
|
|
limit = searchPageSize
|
|
}
|
|
if limit > maxSearchPageSize {
|
|
limit = maxSearchPageSize
|
|
}
|
|
|
|
// Read through the cache before touching Postgres. A ranked search is the
|
|
// expensive request this service serves — ts_rank is computed per matching
|
|
// row, so deep pages scan rather than seek — and readers ask for the same
|
|
// few things over and over, which is exactly the shape a cache pays for.
|
|
//
|
|
// Only successful pages are ever stored, so a malformed cursor still
|
|
// reaches the repository and is still rejected below.
|
|
cacheKey := searchCacheKey(request.Title, request.Categories, limit, request.Cursor)
|
|
if cached, hit := cachedSearch(r.Context(), cacheKey); hit {
|
|
writeJSON(w, http.StatusOK, cached)
|
|
return
|
|
}
|
|
|
|
found, next, err := repositories.VideoRepo.SearchVideos(r.Context(), request.Title, request.Categories, limit, request.Cursor)
|
|
if errors.Is(err, repositories.ErrInvalidCursor) {
|
|
writeProblem(w, http.StatusBadRequest, "Malformed Search Cursor",
|
|
"The cursor could not be read. Send back the nextCursor from a previous search unchanged, or omit it to start from the first page.")
|
|
return
|
|
}
|
|
if err != nil {
|
|
log.Printf("Something Went Wrong Searching The Catalogue: title=%q: %s", request.Title, err)
|
|
writeProblem(w, http.StatusInternalServerError, "Something Went Wrong Searching The Catalogue",
|
|
"The catalogue could not be searched. This is a server-side fault and the request was not processed; retrying in a few moments may succeed.")
|
|
return
|
|
}
|
|
|
|
// Translated field by field, for the same reason GetVideo does it: the row
|
|
// and the published schema are different things.
|
|
videos := make([]api.Video, 0, len(found))
|
|
for _, v := range found {
|
|
videos = append(videos, api.Video{
|
|
ID: v.ID,
|
|
Title: v.Title,
|
|
PlaybackURL: v.PlaybackURL,
|
|
Categories: append([]string{}, v.Categories...),
|
|
})
|
|
}
|
|
|
|
results := api.SearchResults{Videos: videos, NextCursor: next}
|
|
cacheSearch(r.Context(), cacheKey, results)
|
|
|
|
writeJSON(w, http.StatusOK, results)
|
|
}
|