foxyzandClaude Opus 5.5
4ab37c55cf
Logs: one redaction pass (query strings to names, member tokens,
passwords, cookies, auth headers) for every line; daily files with size
and age caps in the app (hosted server included) and the dedicated
server (--log-dir); swaps, relay channels, per-member /r /m /j outcomes,
server fetches, mpv load errors, yt-dlp runs. Settings > About: Copy
diagnostics, Open logs folder.
Bilibili through someone else: the viewer opened /r/ before the source
dialled in; the server holds that request and mpv gives up after 5 s
("could not be opened"). Viewers now open a member relay once it is
live, the putter starts its source before its own player, and track
sizes are read in parallel.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
903 lines
37 KiB
Dart
903 lines
37 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:typed_data';
|
|
|
|
import 'package:relic/relic.dart';
|
|
import 'package:sync_relay_core/core.dart';
|
|
import 'package:web_socket/web_socket.dart';
|
|
|
|
import 'queue_ops.dart';
|
|
import 'relay_routes.dart';
|
|
import 'relay_stats.dart';
|
|
import 'session.dart';
|
|
|
|
final _hubLog = createLogger('server_hub');
|
|
|
|
class ServerHub {
|
|
final SessionMap sessions;
|
|
final String expectedSecret;
|
|
/// See [AppConfig.hostKey]; empty means nobody is the host.
|
|
final String hostKey;
|
|
final SyncEngine engine;
|
|
final Map<String, RelicWebSocket> sockets = {};
|
|
/// The server's Jellyfin login for the `/j/...` relay; null = no relay.
|
|
JellyfinCredential? jellyfin;
|
|
/// Reads web pages for "the server fetches it"; null = files only.
|
|
final YtDlp? ytDlp;
|
|
|
|
ServerHub(this.sessions, this.expectedSecret,
|
|
{SyncEngine? engine, this.hostKey = '', this.jellyfin, this.ytDlp})
|
|
: engine = engine ?? SyncEngine();
|
|
|
|
/// The current media is a Jellyfin ref on the server [jellyfin] logs in to.
|
|
bool get relayAvailable => _onLogin(session.media?.jellyfin);
|
|
|
|
/// Up next's first item is a Jellyfin ref on that server: `/j` serves it
|
|
/// too, so viewers without access get it ready.
|
|
bool get relayNextAvailable => _onLogin(nextJellyfinRef);
|
|
|
|
/// Up next's first item's Jellyfin ref (null: none, or not a ref).
|
|
JellyfinRef? get nextJellyfinRef => engine.queue.items.firstOrNull?.media.jellyfin;
|
|
|
|
bool _onLogin(JellyfinRef? ref) {
|
|
final cred = jellyfin;
|
|
return ref != null && cred != null && cred.serverId.isNotEmpty && cred.serverId == ref.serverId;
|
|
}
|
|
|
|
/// What the swapper reads when the server cannot fetch a link ([why]
|
|
/// from the relay). A yt-dlp failure on a server without cookies says
|
|
/// so, unless cookies would not help (unknown site, gone, unreachable).
|
|
String fetchFailText(String why) {
|
|
const head = "The server can't fetch this link";
|
|
final y = ytDlp;
|
|
final plain = playErrorText(why);
|
|
final cookiesMightHelp = y != null &&
|
|
y.enabled &&
|
|
why.contains('yt-dlp') &&
|
|
!const {unsupportedUrlText, notFoundText, unreachableText}.contains(plain) &&
|
|
y.cookies.read(count: false) == null;
|
|
return cookiesMightHelp
|
|
? '$head: it has no cookies (set them in Settings → Player → yt-dlp on the hosting app, or --yt-dlp-cookies)'
|
|
: '$head: $why';
|
|
}
|
|
|
|
StateBroadcast stateBroadcast() =>
|
|
engine.broadcast(relay: relayAvailable, relayNext: relayNextAvailable, warm: _warmView());
|
|
|
|
/// The relay of the current media (`/r/...`), if it is relayed.
|
|
ActiveRelay? relay;
|
|
|
|
/// Replaces the relay (null: the new media is not relayed). The old
|
|
/// buffer is dropped with it.
|
|
void setRelay(ActiveRelay? next) {
|
|
if (!identical(relay, next)) {
|
|
final old = relay;
|
|
if (old != null) _hubLog.info('relay of "${old.name}" dropped (sent ${_sent(old)})');
|
|
old?.dispose();
|
|
}
|
|
relay = next;
|
|
}
|
|
|
|
static String _sent(ActiveRelay r) =>
|
|
'${(r.buffers.fold<int>(0, (a, b) => a + b.bytesFromFeed) / 1048576).toStringAsFixed(1)} MiB in';
|
|
|
|
/// The warm relay: Up next's first item relayed before it goes up, so
|
|
/// every viewer preloads it (see ARCHITECTURE "Getting ready"); null
|
|
/// when that item is not relayed (or nobody would read it).
|
|
ActiveRelay? warm;
|
|
|
|
void _setWarm(ActiveRelay? next) {
|
|
if (!identical(warm, next)) {
|
|
final old = warm;
|
|
if (old != null) _hubLog.info('warm relay of Up next ${old.queueId} ("${old.name}") dropped (${_sent(old)})');
|
|
old?.dispose();
|
|
if (next != null) {
|
|
_hubLog.info('warm relay of Up next ${next.queueId} ("${next.name}"): '
|
|
'${next.fetch ? 'the server fetches it' : next.sourceId.isEmpty ? 'from the first member with an account' : 'from ${next.sourceId}'}');
|
|
}
|
|
}
|
|
warm = next;
|
|
}
|
|
|
|
/// Drops both relays (server stop).
|
|
void dropRelays() {
|
|
setRelay(null);
|
|
_setWarm(null);
|
|
}
|
|
|
|
/// `queue[0].media.relay` while the warm relay exists.
|
|
({String id, MediaRelay relay})? _warmView() {
|
|
final w = warm, id = w?.queueId;
|
|
if (w == null || id == null) return null;
|
|
return (
|
|
id: id,
|
|
relay: MediaRelay(
|
|
source: w.fetch ? '' : w.sourceId, fetch: w.fetch, live: w.live, tracks: w.live ? w.tracks : const []),
|
|
);
|
|
}
|
|
|
|
/// Keeps [warm] on Up next's first item when it is relayed: a link the
|
|
/// server fetches (its fetch starts now), a link passed on or a file
|
|
/// (its adder's app feeds it, while someone else is here to read it;
|
|
/// not the host's own file), a
|
|
/// Jellyfin item that someone here cannot play and the server's login
|
|
/// does not cover (the first member with an account feeds it). Called
|
|
/// on every change; anything else drops it.
|
|
void syncWarm() {
|
|
final first = engine.queue.items.firstOrNull;
|
|
final w = warm;
|
|
if (w != null && (first == null || w.queueId != first.id || !_keepWarm(w, first))) _setWarm(null);
|
|
if (warm == null && first != null) _setWarm(_newWarm(first));
|
|
}
|
|
|
|
bool _othersHere(String? memberId) => engine.members.values.any((m) => m.id != memberId);
|
|
|
|
/// A Jellyfin [ref] someone here cannot play while someone can, outside
|
|
/// the server's login.
|
|
bool _jellyfinNeedsWarm(JellyfinRef ref) =>
|
|
!_onLogin(ref) &&
|
|
engine.members.values.any((m) => !m.out && m.jf[ref.serverId] != true) &&
|
|
engine.members.values.any((m) => m.jf[ref.serverId] == true);
|
|
|
|
bool _keepWarm(ActiveRelay w, QueueItem first) {
|
|
switch (first.how) {
|
|
case QueueHow.server:
|
|
return w.fetch;
|
|
case QueueHow.through:
|
|
case QueueHow.file:
|
|
final adder = engine.byId(first.by);
|
|
return adder != null && adder.token == w.sourceToken && _othersHere(adder.id);
|
|
case QueueHow.jellyfin:
|
|
final ref = first.media.jellyfin;
|
|
final src = w.sourceToken;
|
|
return ref != null && _jellyfinNeedsWarm(ref) && (src == null || engine.members.containsKey(src));
|
|
case QueueHow.direct:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
ActiveRelay? _newWarm(QueueItem first) {
|
|
final id = first.id;
|
|
final name = sanitizeMediaName(first.media.name.isEmpty ? first.title : first.media.name);
|
|
late final ActiveRelay r;
|
|
switch (first.how) {
|
|
case QueueHow.server:
|
|
final url = Uri.tryParse(engine.queue.privateUrlOf(id) ?? '');
|
|
if (url == null || session.secret.isEmpty) return null;
|
|
r = ActiveRelay.fetchLink(-1, name, url, ytDlp: ytDlp, queueId: id, onLiveChanged: () => relayLiveChanged(r));
|
|
case QueueHow.through:
|
|
case QueueHow.file:
|
|
final adder = engine.byId(first.by);
|
|
// The host's own file plays from its `/m` URL, never relayed.
|
|
if (adder == null || !_othersHere(adder.id) || (adder.host && first.how == QueueHow.file)) return null;
|
|
r = ActiveRelay.warmFromMember(id, name, adder.token,
|
|
sourceId: adder.id, onLiveChanged: () => relayLiveChanged(r));
|
|
case QueueHow.jellyfin:
|
|
final ref = first.media.jellyfin;
|
|
if (ref == null || !_jellyfinNeedsWarm(ref)) return null;
|
|
r = ActiveRelay.warmFromMember(id, name, null, onLiveChanged: () => relayLiveChanged(r));
|
|
case QueueHow.direct:
|
|
return null;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/// The relay `/r/.../<key>/...` reads: the current one by its media id,
|
|
/// or by the queue id it was started for, or the warm one.
|
|
ActiveRelay? relayAt(String key) {
|
|
final r = relay, w = warm;
|
|
final mediaId = int.tryParse(key);
|
|
if (mediaId != null) return r != null && r.mediaId == mediaId ? r : null;
|
|
if (key.isEmpty) return null;
|
|
if (w != null && w.queueId == key) return w;
|
|
if (r != null && r.queueId == key) return r;
|
|
return null;
|
|
}
|
|
|
|
/// The relay member [token] may feed on its channel: the current one
|
|
/// ([queueId] null), or the one of Up next item [queueId] (warm or
|
|
/// already promoted). A warm Jellyfin item takes the first member with
|
|
/// an account on that server that dials in.
|
|
ActiveRelay? sourceOf(String token, String? queueId) {
|
|
if (queueId == null || queueId.isEmpty) {
|
|
final r = relay;
|
|
return r != null && r.sourceToken == token ? r : null;
|
|
}
|
|
final r = relayAt(queueId);
|
|
if (r == null || r.fetch) return null;
|
|
if (r.sourceToken == null && identical(r, warm)) {
|
|
final ref = engine.queue.item(queueId)?.media.jellyfin;
|
|
final m = engine.members[token];
|
|
if (ref == null || m == null || m.jf[ref.serverId] != true) return null;
|
|
r
|
|
..sourceToken = token
|
|
..sourceId = m.id;
|
|
broadcastState();
|
|
}
|
|
return r.sourceToken == token ? r : null;
|
|
}
|
|
|
|
/// A swap of Up next item [queueId] by [token]: its warm relay, when it
|
|
/// can become the media's (the same kind of relay; a member's from its
|
|
/// own source with the same tracks), else null. Taken either way: the
|
|
/// item goes up now.
|
|
ActiveRelay? takeWarm(String? queueId, String token, {required bool fetch, List<RelayTrackSpec> tracks = const []}) {
|
|
final w = warm;
|
|
if (queueId == null || w == null || w.queueId != queueId) return null;
|
|
warm = null;
|
|
final ok = fetch
|
|
? w.fetch && !w.failed
|
|
: !w.fetch && w.sourceToken == token && (!w.known || _sameTracks(w.tracks, tracks));
|
|
if (ok) {
|
|
_hubLog.info('warm relay of Up next $queueId promoted (${_sent(w)}, live ${w.live})');
|
|
w.ensureTracks(tracks);
|
|
return w;
|
|
}
|
|
_hubLog.info('warm relay of Up next $queueId not promoted (${w.failed ? 'its fetch failed' : 'another kind or source'})');
|
|
w.dispose();
|
|
return null;
|
|
}
|
|
|
|
static bool _sameTracks(List<RelayTrackSpec> a, List<RelayTrackSpec> b) =>
|
|
a.length == b.length && [for (var i = 0; i < a.length; i++) a[i] == b[i]].every((x) => x);
|
|
|
|
/// `media.relay` for a relayed swap by [token]: who serves the bytes
|
|
/// and, from a member, its tracks (the server finds a fetched link's).
|
|
MediaRelay relayFor(String token, MediaRelay requested) => requested.fetch
|
|
? const MediaRelay(fetch: true)
|
|
: MediaRelay(source: engine.members[token]?.id ?? '', tracks: requested.tracks);
|
|
|
|
/// `media.relay` of a promoted warm relay [w] (Up next item [queueId]).
|
|
MediaRelay promotedRelay(ActiveRelay w, String queueId) => w.fetch
|
|
? MediaRelay(fetch: true, live: w.live, tracks: w.live ? w.tracks : const [], queueId: queueId)
|
|
: MediaRelay(source: w.sourceId, live: w.live, tracks: w.tracks, queueId: queueId);
|
|
|
|
/// The relay's channel came up or went down, or a fetched link was read:
|
|
/// `media.relay.live` and `tracks` follow (the warm one's in `queue`).
|
|
void relayLiveChanged(ActiveRelay r) {
|
|
if (identical(warm, r)) {
|
|
broadcastState();
|
|
return;
|
|
}
|
|
final m = engine.media;
|
|
if (!identical(relay, r) || m?.relay == null) return;
|
|
final was = m!.relay!;
|
|
if (was.live == r.live && was.tracks.join(',') == r.tracks.join(',')) return;
|
|
if (was.live != r.live) _hubLog.info('relay of "${r.name}" ${r.live ? 'live' : 'not live (source away)'}');
|
|
engine.media = m.copyWith(relay: was.copyWith(live: r.live, tracks: r.tracks));
|
|
changed();
|
|
}
|
|
|
|
final _readRates = ReadRates();
|
|
var _statTicks = 0;
|
|
|
|
static String _kbs(int bytesPerSec) => '${(bytesPerSec / 1024).round()} KiB/s';
|
|
|
|
/// Once a second: each member's read rate (`members[].rate`) and the
|
|
/// relay's source rate and bitrate (`media.relay.rate` / `need`). Goes
|
|
/// out with the next state.
|
|
void sampleRates() {
|
|
final tokens = session.tokens;
|
|
final rates = _readRates.sample(engine.now, {
|
|
for (final t in engine.members.keys) t: tokens[t]?.bytesServed ?? 0,
|
|
});
|
|
for (final m in engine.members.values) {
|
|
m.rate = rates[m.token] ?? 0;
|
|
}
|
|
final r = relay, m = engine.media;
|
|
final was = m?.relay;
|
|
if (r == null || m == null || was == null || r.mediaId != engine.mediaId) return;
|
|
r.sampleRate();
|
|
final rate = r.rate, need = r.need(m.duration);
|
|
if (++_statTicks % 30 == 0 && r.live) {
|
|
final readers = engine.members.values.where((x) => x.rate > 0).map((x) => '${x.name} ${_kbs(x.rate)}');
|
|
_hubLog.info('relay stats "${r.name}": source ${_kbs(rate)}, needs ${_kbs(need)}, '
|
|
'buffered ${(r.cachedBytes / 1048576).toStringAsFixed(1)} MiB, ${_sent(r)}'
|
|
'${readers.isEmpty ? '' : '; reading: ${readers.join(', ')}'}');
|
|
}
|
|
if (rate != was.rate || need != was.need) {
|
|
engine.media = m.copyWith(relay: was.copyWith(rate: rate, need: need));
|
|
}
|
|
}
|
|
|
|
bool isHostKey(String key) => hostKey.isNotEmpty && key == hostKey;
|
|
|
|
/// A member for the log: `name (id)`, never its token.
|
|
String who(String token) {
|
|
final m = engine.members[token];
|
|
if (m != null) return '${m.name} (${m.id})';
|
|
final v = session.tokens[token];
|
|
return v != null ? '${v.name} (no member)' : 'unknown member';
|
|
}
|
|
|
|
/// The member a reconnecting client may take over with its old token:
|
|
/// still known.
|
|
EngineMember? resumable(String token) {
|
|
if (token.isEmpty || !session.tokens.containsKey(token)) return null;
|
|
return engine.members[token];
|
|
}
|
|
|
|
Session get session => sessions.getOrCreate('default', expectedSecret);
|
|
|
|
void broadcastState() {
|
|
final raw = jsonEncode(stateBroadcast().toJson());
|
|
for (final ws in sockets.values.toList()) {
|
|
ws.trySendText(raw);
|
|
}
|
|
}
|
|
|
|
void broadcastFeed() {
|
|
for (final feed in engine.feed.drain()) {
|
|
final raw = jsonEncode(feed.toJson());
|
|
for (final ws in sockets.values.toList()) {
|
|
ws.trySendText(raw);
|
|
}
|
|
}
|
|
}
|
|
|
|
void dropSilentSockets() {
|
|
for (final token in engine.sweepDropped()) {
|
|
final ws = sockets[token];
|
|
if (ws != null) unawaited(ws.tryClose());
|
|
forgetSocket(token);
|
|
}
|
|
}
|
|
|
|
void sweepClosedSockets() {
|
|
for (final entry in sockets.entries.toList()) {
|
|
var closed = false;
|
|
try {
|
|
closed = entry.value.isClosed;
|
|
} catch (_) {
|
|
closed = true;
|
|
}
|
|
if (closed) forgetSocket(entry.key);
|
|
}
|
|
}
|
|
|
|
Future<void> closeAllSockets() async {
|
|
final all = sockets.values.toList();
|
|
sockets.clear();
|
|
for (final ws in all) {
|
|
try {
|
|
await ws.tryClose();
|
|
} catch (_) {}
|
|
}
|
|
}
|
|
|
|
void broadcastChat(String from, String text) {
|
|
final clean = text.length > RelayConstants.maxChatLength
|
|
? text.substring(0, RelayConstants.maxChatLength)
|
|
: text;
|
|
final raw = jsonEncode(
|
|
ChatMessage(text: clean).toJson()..addAll({'from': from}));
|
|
for (final ws in sockets.values.toList()) {
|
|
ws.trySendText(raw);
|
|
}
|
|
engine.feed.add(
|
|
FeedMessage(actor: from, action: 'chat', at: engine.now));
|
|
broadcastFeed();
|
|
}
|
|
|
|
/// The server's own fetch of [name] failed: everyone hears it (the
|
|
/// swapper also gets the reason as an error), not just "getting it…".
|
|
void fetchFailed(String name) {
|
|
engine.feed.add(FeedMessage(actor: 'server', action: 'fetch-fail', target: name, at: engine.now));
|
|
broadcastFeed();
|
|
}
|
|
|
|
void changed() {
|
|
syncWarm();
|
|
broadcastState();
|
|
broadcastFeed();
|
|
}
|
|
|
|
/// Like [forgetSocket], but only while [ws] is still the member's socket:
|
|
/// after a resume the old socket's close must not remove the member.
|
|
void forgetSocketOf(String token, RelicWebSocket ws) {
|
|
if (!identical(sockets[token], ws)) return;
|
|
forgetSocket(token);
|
|
}
|
|
|
|
void forgetSocket(String token) {
|
|
if (engine.members.containsKey(token)) _hubLog.info('leave ${who(token)}');
|
|
engine.applyLeave(token);
|
|
session.tokens.remove(token);
|
|
sockets.remove(token);
|
|
changed();
|
|
}
|
|
|
|
/// Passes a nudge from [fromToken] to the member [targetId] only;
|
|
/// over the sender's rate cap, to itself or to nobody it is dropped.
|
|
void nudge(String fromToken, String targetId) {
|
|
final from = engine.members[fromToken];
|
|
final target = engine.byId(targetId);
|
|
final viewer = session.tokens[fromToken];
|
|
if (from == null || target == null || viewer == null || identical(from, target)) return;
|
|
if (!viewer.takeNudge(engine.now)) return;
|
|
sockets[target.token]?.trySendText(jsonEncode(NudgeNotice(from: from.id, name: from.name).toJson()));
|
|
}
|
|
}
|
|
|
|
/// How a swap's media plays, for the log (a link's query cut to names).
|
|
String _swapKind(HelloMedia m) {
|
|
final relay = m.relay;
|
|
final url = (m.url ?? '').isEmpty ? '' : ' ${logUrl(m.url)}';
|
|
if (m.jellyfin != null) return 'Jellyfin item ${m.jellyfin!.itemId}${relay == null ? '' : ', relayed from the swapper'}';
|
|
if (relay == null) return url.isEmpty ? 'hosted file' : 'link, everyone fetches it:$url';
|
|
if (relay.fetch) return 'link, the server fetches it:$url';
|
|
final tracks = relay.tracks.isEmpty ? 'one file' : relay.tracks.map((t) => t.toJson().values.join('/')).join(' + ');
|
|
return 'through the swapper ($tracks, ${m.size} bytes)';
|
|
}
|
|
|
|
/// `GET /a/<sid>/<token>/<hash>`: a current member's picture by its
|
|
/// content hash, for members (valid token) only. The bytes for a
|
|
/// hash never change, so clients may cache them for good.
|
|
void mountAvatarRoute(RelicApp app, ServerHub hub) =>
|
|
_mountPictureRoute(app, hub, 'a', hub.engine.avatarFor);
|
|
|
|
/// `GET /i/<sid>/<token>/<hash>`: the current media's art (`art`) by hash,
|
|
/// same rules as [mountAvatarRoute].
|
|
void mountArtRoute(RelicApp app, ServerHub hub) =>
|
|
_mountPictureRoute(app, hub, 'i', hub.engine.artFor);
|
|
|
|
void _mountPictureRoute(RelicApp app, ServerHub hub, String prefix, Uint8List? Function(String hash) lookup) {
|
|
Response status(int code) => Response(code, body: Body.fromString('status $code'));
|
|
app.get('/$prefix/:sid/:token/:hash', (final req) {
|
|
final sid = req.pathParameters.raw[#sid] ?? '';
|
|
final token = req.pathParameters.raw[#token] ?? '';
|
|
final hash = req.pathParameters.raw[#hash] ?? '';
|
|
final session = hub.sessions.get(sid);
|
|
if (session == null) return status(410);
|
|
switch (session.gate(token)) {
|
|
case MediaGate.unauthorized:
|
|
return status(401);
|
|
default:
|
|
break;
|
|
}
|
|
final bytes = lookup(hash);
|
|
final type = bytes == null ? null : avatarImageType(bytes);
|
|
if (bytes == null || type == null) return status(404);
|
|
return Response.ok(
|
|
body: Body.fromData(bytes, mimeType: MimeType(type.$1, type.$2)),
|
|
headers: Headers.build((h) {
|
|
h['cache-control'] = ['private, max-age=31536000, immutable'];
|
|
}),
|
|
);
|
|
});
|
|
}
|
|
|
|
/// Media names are shown to everyone and must never carry a URL (api_key etc.).
|
|
/// A URL-looking name is reduced to its last path segment, no query/fragment.
|
|
String sanitizeMediaName(String name) {
|
|
final trimmed = name.trim();
|
|
if (!RegExp(r'^[a-zA-Z][a-zA-Z0-9+.-]*://').hasMatch(trimmed)) return name;
|
|
final uri = Uri.tryParse(trimmed);
|
|
final segments = uri?.pathSegments.where((s) => s.isNotEmpty).toList() ?? const [];
|
|
if (segments.isNotEmpty) return segments.last;
|
|
return 'media';
|
|
}
|
|
|
|
void wsErr(RelicWebSocket ws, String message) {
|
|
ws.trySendText(jsonEncode({'t': 'err', 'message': message}));
|
|
}
|
|
|
|
/// Jellyfin ids are path segments of upstream requests: keep them plain.
|
|
final _jellyfinId = RegExp(r'^[A-Za-z0-9-]{1,64}$');
|
|
|
|
/// The swap's Jellyfin ref cleaned for broadcast (names like
|
|
/// [sanitizeMediaName]), or null when its ids are unusable.
|
|
JellyfinRef? sanitizeJellyfinRef(JellyfinRef ref) {
|
|
if (!_jellyfinId.hasMatch(ref.serverId) || !_jellyfinId.hasMatch(ref.itemId)) return null;
|
|
final source = ref.mediaSourceId;
|
|
if (source != null && !_jellyfinId.hasMatch(source)) return null;
|
|
final runtime = ref.runtimeSecs;
|
|
return JellyfinRef(
|
|
serverId: ref.serverId,
|
|
itemId: ref.itemId,
|
|
mediaSourceId: source,
|
|
title: sanitizeMediaName(ref.title),
|
|
subtitle: ref.subtitle == null ? null : sanitizeMediaName(ref.subtitle!),
|
|
runtimeSecs: runtime == null || runtime < 0 ? null : runtime,
|
|
);
|
|
}
|
|
|
|
/// [relayUrlBuilder] builds a member's `/j/...` URL for `welcome.relayUrl`.
|
|
void mountSyncRoute(
|
|
RelicApp app,
|
|
ServerHub hub,
|
|
String Function(String sid, String token, SessionMedia? media, String host)
|
|
urlBuilder, {
|
|
String Function(String sid, String token, String itemId, String host)? relayUrlBuilder,
|
|
/// `key`: the media id, or the queue id of a relay started in Up next.
|
|
String Function(String sid, String token, String key, String name, List<RelayTrackSpec> tracks, String host)?
|
|
relayMediaUrlBuilder,
|
|
}) {
|
|
app.get('/sync', (final req) {
|
|
// Host the client dialled (Host header), so file URLs work for remote joiners.
|
|
final dialledHost = req.url.hasPort
|
|
? '${req.url.host.contains(':') ? '[${req.url.host}]' : req.url.host}:${req.url.port}'
|
|
: (req.url.host.contains(':') ? '[${req.url.host}]' : req.url.host);
|
|
return WebSocketUpgrade((final ws) async {
|
|
ws.pingInterval = Duration(seconds: RelayConstants.pingIntervalSecs);
|
|
final firstText = Completer<String>();
|
|
String? token;
|
|
var welcomed = false;
|
|
late StreamSubscription<WebSocketEvent> sub;
|
|
Future<void> close() async {
|
|
try {
|
|
await sub.cancel();
|
|
} catch (_) {}
|
|
await ws.tryClose();
|
|
}
|
|
|
|
void handleIntent(String text) {
|
|
final session = hub.session;
|
|
final viewer = token == null ? null : session.tokens[token];
|
|
viewer?.touch();
|
|
Map<String, Object?> decoded;
|
|
try {
|
|
final parsed = jsonDecode(text);
|
|
if (parsed is! Map) return;
|
|
decoded = Map<String, Object?>.from(parsed);
|
|
} catch (_) {
|
|
return;
|
|
}
|
|
final type = decoded['t'];
|
|
try {
|
|
switch (type) {
|
|
case 'ready':
|
|
if (token == null) return;
|
|
final intent = ReadyIntent.fromJson(decoded);
|
|
hub.engine.applyReady(token, intent.ready, source: intent.source);
|
|
hub.changed();
|
|
case 'force':
|
|
if (token == null) return;
|
|
final intent = ForceIntent.fromJson(decoded);
|
|
hub.engine.applyForce(token, intent.target, intent.ready);
|
|
hub.changed();
|
|
case 'seek':
|
|
if (token == null) return;
|
|
final intent = SeekIntent.fromJson(decoded);
|
|
hub.engine.applySeek(token, intent.position, seq: intent.seq);
|
|
hub.changed();
|
|
case 'swap':
|
|
if (token == null) return;
|
|
final swap = SwapIntent.fromJson(decoded);
|
|
var parsed = swap.media;
|
|
final queueId = swap.queueId;
|
|
_hubLog.info('swap by ${hub.who(token)}: "${parsed.name}" ${_swapKind(parsed)}'
|
|
'${queueId == null ? '' : ' (Up next $queueId)'}');
|
|
if (queueId != null) {
|
|
// Already put up by someone else: nothing to do.
|
|
if (!hub.engine.queue.has(queueId)) return;
|
|
// A server-fetched item's link never left the server.
|
|
final hidden = hub.engine.queue.privateUrlOf(queueId);
|
|
if (hidden != null && (parsed.url ?? '').isEmpty) {
|
|
parsed = HelloMedia(
|
|
name: parsed.name, size: parsed.size, duration: parsed.duration, url: hidden, relay: parsed.relay);
|
|
}
|
|
}
|
|
if (parsed.jellyfin != null) {
|
|
// By reference only: no URL (it could carry a token) is
|
|
// stored or broadcast for Jellyfin media.
|
|
final ref = sanitizeJellyfinRef(parsed.jellyfin!);
|
|
// Relayed for viewers without access: from the swapper's
|
|
// machine (its own sign-in never leaves it).
|
|
final relayReq = parsed.relay == null || parsed.relay!.fetch ? null : parsed.relay;
|
|
// Up next's warm relay of this item carries on as its relay.
|
|
final promoted = relayReq == null || ref == null ? null : hub.takeWarm(queueId, token, fetch: false);
|
|
final media = ref == null
|
|
? null
|
|
: HelloMedia(
|
|
name: promoted?.name ?? sanitizeMediaName(parsed.name.isEmpty ? ref.title : parsed.name),
|
|
size: parsed.size,
|
|
duration: parsed.duration,
|
|
jellyfin: ref,
|
|
relay: relayReq == null
|
|
? null
|
|
: promoted != null
|
|
? hub.promotedRelay(promoted, queueId!)
|
|
: hub.relayFor(token, const MediaRelay()));
|
|
if (media == null || !hub.engine.applySwap(token, media, queueId: queueId)) {
|
|
promoted?.dispose();
|
|
wsErr(ws, 'bad swap media');
|
|
return;
|
|
}
|
|
session.media = SessionMedia(
|
|
name: media.name,
|
|
size: media.size,
|
|
duration: media.duration,
|
|
jellyfin: ref,
|
|
mediaId: hub.engine.mediaId);
|
|
hub.setRelay(relayReq == null
|
|
? null
|
|
: promoted != null
|
|
? (promoted..promote(hub.engine.mediaId))
|
|
: _memberRelay(hub, token, media.name, const []));
|
|
hub.changed();
|
|
return;
|
|
}
|
|
final relayReq = parsed.relay;
|
|
if (relayReq != null) {
|
|
// Relayed file or link: no URL is stored or broadcast (a
|
|
// link may be private to the swapper; the server keeps a
|
|
// fetched one to itself).
|
|
final name = sanitizeMediaName(parsed.name.isEmpty ? 'media' : parsed.name);
|
|
final link = Uri.tryParse(parsed.url ?? '');
|
|
if (relayReq.fetch &&
|
|
(link == null || !(link.isScheme('http') || link.isScheme('https')) || link.host.isEmpty)) {
|
|
wsErr(ws, 'relay fetch needs an http(s) url');
|
|
return;
|
|
}
|
|
// The server would fetch any address it can reach (its own
|
|
// network, a VPN) for whoever asks: only for members who
|
|
// know the password.
|
|
if (relayReq.fetch && session.secret.isEmpty) {
|
|
wsErr(ws, 'server fetch needs a server password');
|
|
return;
|
|
}
|
|
// Up next's warm relay of this item carries on as its relay
|
|
// (its buffer, its feed, its `/r/.../<queueId>/` URLs).
|
|
final promoted = hub.takeWarm(queueId, token, fetch: relayReq.fetch, tracks: relayReq.tracks);
|
|
final shown = promoted?.name ?? name;
|
|
final media = HelloMedia(
|
|
name: shown,
|
|
size: parsed.size,
|
|
duration: parsed.duration,
|
|
relay: promoted != null ? hub.promotedRelay(promoted, queueId!) : hub.relayFor(token, relayReq));
|
|
if (!hub.engine.applySwap(token, media, queueId: queueId)) {
|
|
promoted?.dispose();
|
|
wsErr(ws, 'bad swap media');
|
|
return;
|
|
}
|
|
session.media = SessionMedia(
|
|
name: shown, size: parsed.size, duration: parsed.duration, mediaId: hub.engine.mediaId);
|
|
void failed(String why) {
|
|
wsErr(ws, hub.fetchFailText(why));
|
|
hub.fetchFailed(shown);
|
|
}
|
|
late final ActiveRelay active;
|
|
if (promoted != null) {
|
|
active = promoted..promote(hub.engine.mediaId);
|
|
if (active.fetch) {
|
|
active.onFail = failed;
|
|
}
|
|
} else {
|
|
active = relayReq.fetch
|
|
? ActiveRelay.fetchLink(hub.engine.mediaId, name, link!,
|
|
ytDlp: hub.ytDlp, onLiveChanged: () => hub.relayLiveChanged(active), onFail: failed)
|
|
: _memberRelay(hub, token, name, media.relay!.tracks);
|
|
}
|
|
hub.setRelay(active);
|
|
hub.changed();
|
|
return;
|
|
}
|
|
final intent = SwapIntent(
|
|
media: HelloMedia(
|
|
name: sanitizeMediaName(parsed.name),
|
|
size: parsed.size,
|
|
duration: parsed.duration,
|
|
url: parsed.url));
|
|
final current = session.media;
|
|
final matchesFile = current?.file != null &&
|
|
current!.name == intent.media.name &&
|
|
current.size == intent.media.size;
|
|
if (!matchesFile && (intent.media.url ?? '').isEmpty) {
|
|
wsErr(ws, 'swap needs a url or the hosted file');
|
|
return;
|
|
}
|
|
if (!hub.engine.applySwap(token, intent.media, queueId: queueId)) {
|
|
wsErr(ws, 'bad swap media');
|
|
return;
|
|
}
|
|
hub.setRelay(null);
|
|
if (matchesFile) {
|
|
session.media = SessionMedia(
|
|
name: current.name,
|
|
size: current.size,
|
|
duration: intent.media.duration,
|
|
url: intent.media.url,
|
|
file: current.file,
|
|
mediaId: hub.engine.mediaId);
|
|
} else {
|
|
session.media = SessionMedia(
|
|
name: intent.media.name,
|
|
size: intent.media.size,
|
|
duration: intent.media.duration,
|
|
url: intent.media.url,
|
|
mediaId: hub.engine.mediaId);
|
|
}
|
|
hub.changed();
|
|
case 'profile':
|
|
if (token == null || viewer == null) return;
|
|
final intent = ProfileIntent.fromJson(decoded);
|
|
final avatar = intent.avatar;
|
|
if (avatar != null && avatar.length > RelayConstants.maxAvatarBytes) {
|
|
wsErr(ws, 'rejected: avatar too large');
|
|
return;
|
|
}
|
|
final name = intent.name == null ? null : cleanMemberName(intent.name!);
|
|
// Chat names the sender by its token's name.
|
|
if (name != null) viewer.name = name;
|
|
hub.engine.applyProfile(token, name: name, avatar: avatar);
|
|
hub.changed();
|
|
case 'art':
|
|
if (token == null) return;
|
|
final art = ArtMessage.fromJson(decoded);
|
|
if (hub.engine.applyArt(token, art.mediaId, poster: art.poster, banner: art.banner)) {
|
|
hub.broadcastState();
|
|
}
|
|
case 'report':
|
|
if (token == null) return;
|
|
final report = ReportMessage.fromJson(decoded);
|
|
final before = hub.engine.members[token]?.error ?? '';
|
|
if (report.error != before && report.mediaId == hub.engine.mediaId) {
|
|
_hubLog.warning(report.error.isEmpty
|
|
? '${hub.who(token)}: player error cleared'
|
|
: '${hub.who(token)}: cannot play media ${report.mediaId}: ${report.error}');
|
|
}
|
|
hub.engine.applyReport(
|
|
token, report.position, report.buffered, report.eventId,
|
|
duration: report.duration, mediaId: report.mediaId, jf: report.jf, error: report.error);
|
|
hub.changed();
|
|
case 'ping':
|
|
final ping = PingMessage.fromJson(decoded);
|
|
ws.trySendText(jsonEncode(PongMessage(
|
|
clientMs: ping.clientMs,
|
|
serverMs: hub.engine.now.millisecondsSinceEpoch)
|
|
.toJson()));
|
|
case 'chat':
|
|
final chat = ChatMessage.fromJson(decoded);
|
|
hub.broadcastChat(viewer?.name ?? '?', chat.text);
|
|
case 'out':
|
|
if (token == null) return;
|
|
final intent = OutIntent.fromJson(decoded);
|
|
hub.engine.applyOut(token, intent.target, intent.out);
|
|
hub.changed();
|
|
case 'nudge':
|
|
if (token == null) return;
|
|
hub.nudge(token, NudgeIntent.fromJson(decoded).target);
|
|
case 'queue':
|
|
if (token == null) return;
|
|
handleQueueIntent(hub, token, ws, decoded);
|
|
}
|
|
} on ProtocolException catch (e) {
|
|
_hubLog.info('${token == null ? 'a socket' : hub.who(token)}: bad $type message: ${e.message}');
|
|
wsErr(ws, 'bad message: ${e.message}');
|
|
} catch (e, st) {
|
|
_hubLog.warning('${token == null ? 'a socket' : hub.who(token)}: $type message failed: $e', e, st);
|
|
return;
|
|
}
|
|
}
|
|
|
|
sub = ws.events.listen(
|
|
(event) {
|
|
if (event is! TextDataReceived) return;
|
|
if (!firstText.isCompleted) {
|
|
firstText.complete(event.text);
|
|
} else if (welcomed) {
|
|
handleIntent(event.text);
|
|
}
|
|
},
|
|
onError: (_) {
|
|
if (token != null) hub.forgetSocketOf(token, ws);
|
|
},
|
|
onDone: () {
|
|
if (!firstText.isCompleted) {
|
|
firstText.completeError(StateError('closed before hello'));
|
|
} else if (token != null) {
|
|
hub.forgetSocketOf(token, ws);
|
|
}
|
|
},
|
|
);
|
|
String raw;
|
|
try {
|
|
raw = await firstText.future.timeout(const Duration(seconds: 10));
|
|
} catch (_) {
|
|
await close();
|
|
return;
|
|
}
|
|
HelloMessage hello;
|
|
try {
|
|
final decoded = jsonDecode(raw);
|
|
if (decoded is! Map) throw const ProtocolException('hello must be an object');
|
|
hello = HelloMessage.fromJson(Map<String, Object?>.from(decoded));
|
|
} catch (e) {
|
|
_hubLog.warning('reject: bad hello: $e');
|
|
wsErr(ws, 'bad hello: $e');
|
|
await close();
|
|
return;
|
|
}
|
|
if (hello.proto != RelayConstants.protoVersion) {
|
|
_hubLog.warning(
|
|
'reject ${hello.user.name}: proto mismatch: got ${hello.proto}, want ${RelayConstants.protoVersion}');
|
|
wsErr(ws, 'proto mismatch: got ${hello.proto}, want ${RelayConstants.protoVersion}');
|
|
await close();
|
|
return;
|
|
}
|
|
final session = hub.session;
|
|
if (session.secret.isNotEmpty && hello.secret != session.secret) {
|
|
_hubLog.warning('reject ${hello.user.name}: wrong secret');
|
|
wsErr(ws, 'wrong secret');
|
|
await close();
|
|
return;
|
|
}
|
|
final resumed = hub.resumable(hello.resume);
|
|
String memberId;
|
|
if (resumed != null) {
|
|
// Unclean drop the server has not noticed yet: take the member over
|
|
// (same token, id, ready flag) and drop the dead socket quietly.
|
|
token = hello.resume;
|
|
memberId = resumed.id;
|
|
final old = hub.sockets.remove(token);
|
|
if (old != null) unawaited(old.tryClose());
|
|
hub.engine.applyResume(token);
|
|
_hubLog.info('resume ${hello.user.name} ($memberId)');
|
|
} else {
|
|
try {
|
|
token = session.issueToken(hello.user.name, hello.user.avatar);
|
|
} catch (e) {
|
|
_hubLog.warning('reject ${hello.user.name}: $e');
|
|
wsErr(ws, 'rejected: $e');
|
|
await close();
|
|
return;
|
|
}
|
|
memberId = hub.engine.applyJoin(token, session.tokens[token]!.name, hello.user.avatar);
|
|
}
|
|
final isHost = hub.isHostKey(hello.hostKey);
|
|
session.tokens[token]!.isHost = isHost;
|
|
hub.engine.members[token]?.host = isHost;
|
|
final activeToken = token;
|
|
hub.sockets[activeToken] = ws;
|
|
final media = session.media;
|
|
final relay = hub.relayAvailable;
|
|
final relayed = hub.relay;
|
|
final welcome = WelcomeMessage(
|
|
token: activeToken,
|
|
memberId: memberId,
|
|
// Jellyfin media resolves per member (own account first); only
|
|
// relayed files and links start from the /r/ URL, and never for
|
|
// the source itself (it plays its own copy).
|
|
// A fetched link not read yet has no URL: the state's `live` opens it.
|
|
mediaUrl: relayed != null &&
|
|
media != null &&
|
|
media.jellyfin == null &&
|
|
relayed.sourceToken != activeToken &&
|
|
relayed.mediaId == media.mediaId &&
|
|
relayMediaUrlBuilder != null
|
|
? (relayed.known
|
|
? relayMediaUrlBuilder('default', activeToken, relayed.queueId ?? '${relayed.mediaId}', media.name,
|
|
relayed.tracks, dialledHost)
|
|
: null)
|
|
: media?.file != null
|
|
? urlBuilder('default', activeToken, media, dialledHost)
|
|
: media?.url,
|
|
relayUrl: relay && relayUrlBuilder != null
|
|
? relayUrlBuilder('default', activeToken, media!.jellyfin!.itemId, dialledHost)
|
|
: null,
|
|
state: hub.stateBroadcast().toJson(),
|
|
);
|
|
try {
|
|
ws.sendText(jsonEncode(welcome.toJson()));
|
|
} catch (_) {
|
|
await close();
|
|
return;
|
|
}
|
|
welcomed = true;
|
|
_hubLog.info('join ${hello.user.name} ($memberId)');
|
|
hub.changed();
|
|
try {
|
|
await sub.asFuture();
|
|
} catch (_) {}
|
|
});
|
|
});
|
|
}
|
|
|
|
ActiveRelay _memberRelay(ServerHub hub, String token, String name, List<RelayTrackSpec> tracks) {
|
|
late final ActiveRelay r;
|
|
r = ActiveRelay.fromMember(hub.engine.mediaId, name, token,
|
|
tracks: tracks, sourceId: hub.engine.members[token]?.id ?? '', onLiveChanged: () => hub.relayLiveChanged(r));
|
|
return r;
|
|
}
|