Publish current app and server

server/internal/api/server_alerts.go

@@ -0,0 +1,135 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ponzischeme89/memby/server/internal/library"
+)
+
+// News about the service itself, as opposed to news about what is in it.
+//
+// Both producers here answer the same question a viewer would otherwise have to guess
+// at: why the library changed under them, and why playback stopped working. They are
+// the alerts most worth showing *during* a film, which is why they are worded to be read
+// in one glance and never ask for an action.
+const (
+	// A refresh is only interesting while it is recent — long enough that a set switched
+	// on shortly afterwards still learns why there is something new on the home screen,
+	// short enough that it is never yesterday's news.
+	librarySyncAlertWindow = 30 * time.Minute
+
+	// Reachability is a live fact, so its window is short: a TV waking up half an hour
+	// after Emby went down should find out by asking, not by being told about the past.
+	reachabilityAlertWindow = 10 * time.Minute
+
+	// embyFailureThreshold is how many probes in a row must fail before it is announced.
+	// One timeout is a hiccup — a restart, a slow scan — and telling a room full of
+	// people about it is worse than saying nothing.
+	embyFailureThreshold = 3
+)
+
+// AnnounceLibrarySync tells every TV that the catalogue moved.
+//
+// Only a run that actually changed something is announced: the import is scheduled, so
+// most passes find nothing, and an hourly "nothing happened" banner would train viewers
+// to ignore the one that matters. Removals alone are deliberately silent — a title
+// disappearing is not something to celebrate mid-film.
+func (s *Server) AnnounceLibrarySync(ctx context.Context, result library.Result) {
+	if result.Changed <= 0 {
+		return
+	}
+	now := time.Now().UTC()
+	s.publishAlert(ctx, clientAlert{
+		// Keyed on the minute the sync finished: two runs are two pieces of news, but a
+		// retried publish of the same run is not.
+		ID:      fmt.Sprintf("library:%d", now.Truncate(time.Minute).Unix()),
+		Kind:    alertKindLibrarySync,
+		Label:   "LIBRARY UPDATED",
+		Title:   librarySyncTitle(result.Changed),
+		Message: "Memby has finished refreshing — it is on the home screen now.",
+		AiredAt: now.Format(time.RFC3339),
+	}, librarySyncAlertWindow)
+}
+
+func librarySyncTitle(changed int) string {
+	if changed == 1 {
+		return "1 title added or updated"
+	}
+	return fmt.Sprintf("%d titles added or updated", changed)
+}
+
+// WatchEmbyReachability announces Emby going away and coming back.
+//
+// This is the one alert that matters more during playback than on the home screen: video
+// direct-plays from Emby, so when Emby stops answering a film stops with no explanation
+// the viewer can act on. The gateway keeps serving /v1/status either way, which is what
+// makes it able to say so.
+//
+// Only *transitions* are announced. A server that is down stays down, and repeating it
+// every minute would bury everything else.
+func (s *Server) WatchEmbyReachability(ctx context.Context, interval time.Duration) {
+	if interval <= 0 {
+		return
+	}
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	// Start out assuming reachable: a gateway booting while Emby is down should not
+	// open with a banner about a state nobody has seen change.
+	reachable := true
+	failures := 0
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			probeCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+			err := s.emby.Ping(probeCtx)
+			cancel()
+
+			if err != nil {
+				failures++
+				if reachable && failures >= embyFailureThreshold {
+					reachable = false
+					s.log.Warn("emby unreachable, announcing", "error", err)
+					s.publishAlert(ctx, s.reachabilityAlert(false), reachabilityAlertWindow)
+				}
+				continue
+			}
+			if !reachable {
+				s.log.Info("emby reachable again, announcing")
+				s.publishAlert(ctx, s.reachabilityAlert(true), reachabilityAlertWindow)
+			}
+			reachable = true
+			failures = 0
+		}
+	}
+}
+
+// reachabilityAlert is timestamped per transition, so the "back online" banner never
+// collides with the "not responding" one it replaces.
+func (s *Server) reachabilityAlert(up bool) clientAlert {
+	now := time.Now().UTC()
+	if up {
+		return clientAlert{
+			ID:      fmt.Sprintf("emby:up:%d", now.Unix()),
+			Kind:    alertKindServerUp,
+			Label:   "SERVER BACK ONLINE",
+			Title:   "Emby is responding again",
+			Message: "Playback and browsing are working normally.",
+			AiredAt: now.Format(time.RFC3339),
+		}
+	}
+	return clientAlert{
+		ID:    fmt.Sprintf("emby:down:%d", now.Unix()),
+		Kind:  alertKindServerDown,
+		Label: "SERVER NOT RESPONDING",
+		Title: "Emby has stopped communicating",
+		// Says what the viewer will see rather than what failed: a diagnosis they cannot
+		// act on from the sofa is worse than none.
+		Message: "Playback may stop until it is back. Memby will say when it returns.",
+		AiredAt: now.Format(time.RFC3339),
+	}
+}