Initial commit: watch-together phases 0-4 + presence hardening, internet-tested
This commit is contained in:
foxyz committed
commit
427d851a5b
101 files changed
+11326
No files matched your search
@@ -0,0 +1,47 @@
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:args/args.dart';
|
||||
import 'package:logging/logging.dart' as pkg_logging;
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
import 'package:sync_relay_server/server.dart';
|
||||
|
||||
Future<void> main(List<String> args) async {
|
||||
final parser = ArgParser()
|
||||
..addOption('port', abbr: 'p', defaultsTo: '8080')
|
||||
..addOption('secret', defaultsTo: 'change-me')
|
||||
..addOption('name', defaultsTo: 'room')
|
||||
..addOption('media', defaultsTo: '')
|
||||
..addOption('advertise-host', defaultsTo: '127.0.0.1')
|
||||
..addOption('config')
|
||||
..addFlag('help', abbr: 'h', negatable: false);
|
||||
final parsed = parser.parse(args);
|
||||
if (parsed['help'] as bool) {
|
||||
// ignore: avoid_print
|
||||
print(parser.usage);
|
||||
return;
|
||||
}
|
||||
|
||||
initLogging(level: pkg_logging.Level.INFO);
|
||||
AppConfig config;
|
||||
final configPath = parsed['config'] as String?;
|
||||
if (configPath != null) {
|
||||
config = await AppConfig.loadFile(configPath);
|
||||
} else {
|
||||
config = AppConfig(
|
||||
port: int.tryParse('${parsed['port']}') ?? 8080,
|
||||
secret: '${parsed['secret']}',
|
||||
name: '${parsed['name']}',
|
||||
mediaPath: '${parsed['media']}',
|
||||
advertiseHost: '${parsed['advertise-host']}',
|
||||
);
|
||||
}
|
||||
|
||||
final server = RoomServer(config);
|
||||
await server.start();
|
||||
|
||||
// ignore: avoid_print
|
||||
print('READY port=${server.boundPort} room=${config.name}');
|
||||
|
||||
await ProcessSignal.sigint.watch().first;
|
||||
await server.stop();
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
export 'src/media_endpoint.dart';
|
||||
export 'src/room_hub.dart';
|
||||
export 'src/room_server.dart';
|
||||
export 'src/session.dart';
|
||||
@@ -0,0 +1,213 @@
|
||||
import 'dart:io';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:relic/relic.dart';
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
|
||||
import 'session.dart';
|
||||
|
||||
class MediaLog {
|
||||
final String method;
|
||||
final String path;
|
||||
final String? rangeHeader;
|
||||
final int status;
|
||||
final int bytesWritten;
|
||||
final int durationMs;
|
||||
const MediaLog({
|
||||
required this.method,
|
||||
required this.path,
|
||||
required this.rangeHeader,
|
||||
required this.status,
|
||||
required this.bytesWritten,
|
||||
required this.durationMs,
|
||||
});
|
||||
|
||||
@override
|
||||
String toString() =>
|
||||
'$method $path range=${rangeHeader ?? '-'} -> $status bytes=$bytesWritten ${durationMs}ms';
|
||||
}
|
||||
|
||||
class MediaResolution {
|
||||
final int status;
|
||||
final Map<String, String> headers;
|
||||
final int start;
|
||||
final int? end;
|
||||
const MediaResolution({
|
||||
required this.status,
|
||||
required this.headers,
|
||||
required this.start,
|
||||
required this.end,
|
||||
});
|
||||
|
||||
int contentLength(int size) => (end ?? (size - 1)) - start + 1;
|
||||
}
|
||||
|
||||
MediaResolution resolveMediaRequest({
|
||||
required String? rangeHeader,
|
||||
required int size,
|
||||
required String filename,
|
||||
MediaGate gate = MediaGate.ok,
|
||||
}) {
|
||||
Map<String, String> base(String contentType) => {
|
||||
'accept-ranges': 'bytes',
|
||||
'content-type': contentType,
|
||||
};
|
||||
final contentType = contentTypeForFile(filename);
|
||||
switch (gate) {
|
||||
case MediaGate.gone:
|
||||
return MediaResolution(status: 410, headers: base(contentType), start: 0, end: 0);
|
||||
case MediaGate.unauthorized:
|
||||
return MediaResolution(status: 401, headers: base(contentType), start: 0, end: 0);
|
||||
case MediaGate.forbidden:
|
||||
return MediaResolution(status: 403, headers: base(contentType), start: 0, end: 0);
|
||||
case MediaGate.offline:
|
||||
return MediaResolution(
|
||||
status: 503,
|
||||
headers: {...base(contentType), 'retry-after': '2'},
|
||||
start: 0,
|
||||
end: 0);
|
||||
case MediaGate.ok:
|
||||
break;
|
||||
}
|
||||
if (rangeHeader == null || rangeHeader.trim().isEmpty) {
|
||||
return MediaResolution(
|
||||
status: 200,
|
||||
headers: {...base(contentType), 'content-length': '$size'},
|
||||
start: 0,
|
||||
end: null,
|
||||
);
|
||||
}
|
||||
final parsed = RangeRequest.parse(rangeHeader, size);
|
||||
if (parsed == null) {
|
||||
return MediaResolution(
|
||||
status: 416,
|
||||
headers: {...base(contentType), 'content-range': 'bytes */$size'},
|
||||
start: 0,
|
||||
end: 0,
|
||||
);
|
||||
}
|
||||
final end = parsed.end ?? size - 1;
|
||||
return MediaResolution(
|
||||
status: 206,
|
||||
headers: {
|
||||
...base(contentType),
|
||||
'content-range': 'bytes ${parsed.start}-$end/$size',
|
||||
'content-length': '${end - parsed.start + 1}',
|
||||
},
|
||||
start: parsed.start,
|
||||
end: parsed.end,
|
||||
);
|
||||
}
|
||||
|
||||
void mountMediaRoute(RelicApp app, File file,
|
||||
{String route = '/m/file', void Function(MediaLog log)? onLog}) {
|
||||
app.get(route, (final req) async {
|
||||
final stopwatch = Stopwatch()..start();
|
||||
final size = await file.length();
|
||||
final name = file.path.split(Platform.pathSeparator).last;
|
||||
final typed = req.headers.range;
|
||||
String? rangeHeader;
|
||||
if (typed != null && typed.ranges.isNotEmpty) {
|
||||
final r = typed.ranges.first;
|
||||
rangeHeader = '${typed.unit}=${r.start?.toString() ?? ''}-${r.end?.toString() ?? ''}';
|
||||
}
|
||||
final res = resolveMediaRequest(rangeHeader: rangeHeader, size: size, filename: name);
|
||||
void log(int bytes) => onLog?.call(MediaLog(
|
||||
method: req.method.name,
|
||||
path: route,
|
||||
rangeHeader: rangeHeader,
|
||||
status: res.status,
|
||||
bytesWritten: bytes,
|
||||
durationMs: stopwatch.elapsedMilliseconds,
|
||||
));
|
||||
if (res.status != 200 && res.status != 206) {
|
||||
log(0);
|
||||
return Response(
|
||||
res.status,
|
||||
body: Body.fromString('status ${res.status}'),
|
||||
headers: Headers.build((h) {
|
||||
res.headers.forEach((k, v) => h[k] = [v]);
|
||||
}),
|
||||
);
|
||||
}
|
||||
final end = res.end ?? size - 1;
|
||||
final byteCount = end - res.start + 1;
|
||||
final stream = file.openRead(res.start, end + 1).map((c) => Uint8List.fromList(c));
|
||||
log(byteCount);
|
||||
return Response(
|
||||
res.status,
|
||||
body: Body.fromDataStream(stream, contentLength: byteCount),
|
||||
headers: Headers.build((h) {
|
||||
res.headers.forEach((k, v) => h[k] = [v]);
|
||||
}),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
Response _gatedResponse(MediaResolution res) => Response(
|
||||
res.status,
|
||||
body: Body.fromString('status ${res.status}'),
|
||||
headers: Headers.build((h) {
|
||||
res.headers.forEach((k, v) => h[k] = [v]);
|
||||
}),
|
||||
);
|
||||
|
||||
void mountSessionMediaRoute(
|
||||
RelicApp app,
|
||||
SessionMap sessions, {
|
||||
String pattern = '/m/:sid/:token/:name',
|
||||
void Function(String token, MediaLog log)? onLog,
|
||||
}) {
|
||||
app.get(pattern, (final req) async {
|
||||
final stopwatch = Stopwatch()..start();
|
||||
final sid = req.pathParameters.raw[#sid] ?? '';
|
||||
final token = req.pathParameters.raw[#token] ?? '';
|
||||
final session = sessions.get(sid);
|
||||
if (session == null) {
|
||||
return _gatedResponse(resolveMediaRequest(
|
||||
rangeHeader: null, size: 1, filename: 'x', gate: MediaGate.gone));
|
||||
}
|
||||
final gate = session.gate(token);
|
||||
if (gate != MediaGate.ok) {
|
||||
return _gatedResponse(
|
||||
resolveMediaRequest(rangeHeader: null, size: 1, filename: 'x', gate: gate));
|
||||
}
|
||||
final media = session.media;
|
||||
final file = media?.file;
|
||||
if (media == null || file == null) {
|
||||
return _gatedResponse(resolveMediaRequest(
|
||||
rangeHeader: null, size: 1, filename: 'x', gate: MediaGate.offline));
|
||||
}
|
||||
final size = media.size;
|
||||
final typed = req.headers.range;
|
||||
String? rangeHeader;
|
||||
if (typed != null && typed.ranges.isNotEmpty) {
|
||||
final r = typed.ranges.first;
|
||||
rangeHeader = '${typed.unit}=${r.start?.toString() ?? ''}-${r.end?.toString() ?? ''}';
|
||||
}
|
||||
final res = resolveMediaRequest(rangeHeader: rangeHeader, size: size, filename: media.name);
|
||||
if (res.status != 200 && res.status != 206) {
|
||||
return _gatedResponse(res);
|
||||
}
|
||||
final end = res.end ?? size - 1;
|
||||
final byteCount = end - res.start + 1;
|
||||
session.addBytes(token, byteCount);
|
||||
final shortToken = token.length > 4 ? '…${token.substring(token.length - 4)}' : token;
|
||||
onLog?.call(token, MediaLog(
|
||||
method: req.method.name,
|
||||
path: '/m/$sid/$shortToken/${media.name}',
|
||||
rangeHeader: rangeHeader,
|
||||
status: res.status,
|
||||
bytesWritten: byteCount,
|
||||
durationMs: stopwatch.elapsedMilliseconds,
|
||||
));
|
||||
final stream = file.openRead(res.start, end + 1).map((c) => Uint8List.fromList(c));
|
||||
return Response(
|
||||
res.status,
|
||||
body: Body.fromDataStream(stream, contentLength: byteCount),
|
||||
headers: Headers.build((h) {
|
||||
res.headers.forEach((k, v) => h[k] = [v]);
|
||||
}),
|
||||
);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,297 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:relic/relic.dart';
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
import 'package:web_socket/web_socket.dart';
|
||||
|
||||
import 'session.dart';
|
||||
|
||||
final _hubLog = createLogger('room_hub');
|
||||
|
||||
class RoomHub {
|
||||
final SessionMap sessions;
|
||||
final String expectedSecret;
|
||||
final RoomEngine engine;
|
||||
final Map<String, RelicWebSocket> sockets = {};
|
||||
|
||||
RoomHub(this.sessions, this.expectedSecret, {RoomEngine? engine})
|
||||
: engine = engine ?? RoomEngine();
|
||||
|
||||
Session get session => sessions.getOrCreate('default', expectedSecret);
|
||||
|
||||
void broadcastRoom() {
|
||||
final raw = jsonEncode(engine.broadcast().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();
|
||||
}
|
||||
|
||||
void changed() {
|
||||
broadcastRoom();
|
||||
broadcastFeed();
|
||||
}
|
||||
|
||||
void forgetSocket(String token) {
|
||||
engine.applyLeave(token);
|
||||
final viewer = session.tokens[token];
|
||||
if (viewer != null && !viewer.kicked) session.tokens.remove(token);
|
||||
sockets.remove(token);
|
||||
changed();
|
||||
}
|
||||
|
||||
Future<void> kickById(String targetId, String reason) async {
|
||||
final member = engine.byId(targetId);
|
||||
if (member == null) throw const AuthException('unknown kick target');
|
||||
await session.kick(member.token, reason: reason);
|
||||
}
|
||||
}
|
||||
|
||||
void wsErr(RelicWebSocket ws, String message) {
|
||||
ws.trySendText(jsonEncode({'t': 'err', 'message': message}));
|
||||
}
|
||||
|
||||
void mountSyncRoute(
|
||||
RelicApp app,
|
||||
RoomHub hub,
|
||||
String Function(String sid, String token, SessionMedia? media) urlBuilder,
|
||||
) {
|
||||
app.get('/sync', (final req) {
|
||||
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);
|
||||
hub.changed();
|
||||
case 'swap':
|
||||
if (token == null) return;
|
||||
final intent = SwapIntent.fromJson(decoded);
|
||||
hub.engine.applySwap(token, intent.media);
|
||||
final current = session.media;
|
||||
if (current?.file != null &&
|
||||
current!.name == intent.media.name &&
|
||||
current.size == intent.media.size) {
|
||||
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 'report':
|
||||
if (token == null) return;
|
||||
final report = ReportMessage.fromJson(decoded);
|
||||
hub.engine.applyReport(
|
||||
token, report.position, report.buffered, report.eventId);
|
||||
hub.broadcastRoom();
|
||||
case 'chat':
|
||||
final chat = ChatMessage.fromJson(decoded);
|
||||
hub.broadcastChat(viewer?.name ?? '?', chat.text);
|
||||
case 'kick':
|
||||
final kickReq = KickRequest.fromJson(decoded);
|
||||
final member = hub.engine.byId(kickReq.target);
|
||||
if (member == null) {
|
||||
wsErr(ws, 'unknown kick target');
|
||||
return;
|
||||
}
|
||||
final by = viewer?.name ?? '?';
|
||||
unawaited(hub.session.kick(member.token,
|
||||
reason: kickReq.reason.isEmpty
|
||||
? 'kicked by $by'
|
||||
: kickReq.reason));
|
||||
}
|
||||
} catch (_) {
|
||||
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.forgetSocket(token);
|
||||
},
|
||||
onDone: () {
|
||||
if (!firstText.isCompleted) {
|
||||
firstText.completeError(StateError('closed before hello'));
|
||||
} else if (token != null) {
|
||||
hub.forgetSocket(token);
|
||||
}
|
||||
},
|
||||
);
|
||||
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 (hello.secret != session.secret) {
|
||||
_hubLog.warning('reject ${hello.user.name}: wrong secret');
|
||||
wsErr(ws, 'wrong secret');
|
||||
await close();
|
||||
return;
|
||||
}
|
||||
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;
|
||||
}
|
||||
final memberId = hub.engine.applyJoin(token, hello.user.name, hello.user.avatar);
|
||||
final activeToken = token;
|
||||
hub.sockets[activeToken] = ws;
|
||||
session.tokens[activeToken]!.onKick = (reason) async {
|
||||
ws.trySendText(jsonEncode(KickedMessage(reason: reason).toJson()));
|
||||
await Future.delayed(const Duration(milliseconds: 200));
|
||||
await ws.tryClose();
|
||||
hub.forgetSocket(activeToken);
|
||||
};
|
||||
final media = session.media;
|
||||
final welcome = WelcomeMessage(
|
||||
token: activeToken,
|
||||
memberId: memberId,
|
||||
mediaUrl: media?.file != null ? urlBuilder('default', activeToken, media) : media?.url,
|
||||
state: hub.engine.broadcast().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 (_) {}
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:logging/logging.dart' as pkg_logging;
|
||||
import 'package:relic/relic.dart';
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
|
||||
import 'media_endpoint.dart';
|
||||
import 'room_hub.dart';
|
||||
import 'session.dart';
|
||||
|
||||
class RoomServer {
|
||||
final AppConfig config;
|
||||
final pkg_logging.Logger _log = createLogger('room_server');
|
||||
final RelicApp _app = RelicApp();
|
||||
final SessionMap sessions = SessionMap();
|
||||
late final RoomHub hub;
|
||||
RelicServer? _server;
|
||||
DateTime? _startedAt;
|
||||
Timer? _heartbeat;
|
||||
bool _routesMounted = false;
|
||||
|
||||
RoomServer(this.config) {
|
||||
hub = RoomHub(sessions, config.secret);
|
||||
}
|
||||
|
||||
bool get isRunning => _server != null;
|
||||
int get boundPort => _server?.port ?? config.port;
|
||||
Session get session => sessions.getOrCreate('default', config.secret);
|
||||
|
||||
Future<bool> setLocalFile(String path) async {
|
||||
final file = File(path);
|
||||
if (!await file.exists()) return false;
|
||||
final name = file.path.split(Platform.pathSeparator).last;
|
||||
final size = await file.length();
|
||||
session.media = SessionMedia(name: name, size: size, duration: 0, file: file);
|
||||
hub.engine.media = HelloMedia(name: name, size: size, duration: 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
void _mountRoutes() {
|
||||
if (_routesMounted) return;
|
||||
_routesMounted = true;
|
||||
_app.get('/health', (final req) {
|
||||
final s = sessions.get('default');
|
||||
final viewers = s?.tokens.length ?? 0;
|
||||
final bytes = s?.totalBytesServed ?? 0;
|
||||
final uptime = _startedAt == null ? 0 : DateTime.now().difference(_startedAt!).inSeconds;
|
||||
return Response.ok(
|
||||
body: Body.fromString(jsonEncode({
|
||||
'ok': true,
|
||||
'room': config.name,
|
||||
'proto': RelayConstants.protoVersion,
|
||||
'viewers': viewers,
|
||||
'bytesServed': bytes,
|
||||
'uptimeSecs': uptime,
|
||||
'media': s?.media?.name,
|
||||
'transport': hub.engine.transport.name,
|
||||
'eventId': hub.engine.eventId,
|
||||
})),
|
||||
);
|
||||
});
|
||||
mountSessionMediaRoute(_app, sessions);
|
||||
mountSyncRoute(_app, hub, (sid, token, media) {
|
||||
final name = Uri.encodeComponent(media?.name ?? 'file');
|
||||
return 'http://${config.advertiseHost}:$boundPort/m/$sid/$token/$name';
|
||||
});
|
||||
_app.fallback = (final req) => Response.notFound(
|
||||
body: Body.fromString('not found'),
|
||||
);
|
||||
}
|
||||
|
||||
Future<void> start() async {
|
||||
if (_server != null) return;
|
||||
final s = session;
|
||||
if (config.mediaPath.isNotEmpty) {
|
||||
final file = File(config.mediaPath);
|
||||
if (await file.exists()) {
|
||||
final name = file.path.split(Platform.pathSeparator).last;
|
||||
final size = await file.length();
|
||||
s.media = SessionMedia(name: name, size: size, duration: 0, file: file);
|
||||
hub.engine.media = HelloMedia(name: name, size: size, duration: 0);
|
||||
} else {
|
||||
_log.warning('media file not found: ${config.mediaPath}');
|
||||
}
|
||||
}
|
||||
_mountRoutes();
|
||||
_server = await _app.serve(
|
||||
address: InternetAddress.anyIPv4,
|
||||
port: config.port,
|
||||
);
|
||||
_startedAt = DateTime.now();
|
||||
_heartbeat = Timer.periodic(const Duration(seconds: 1), (_) {
|
||||
hub.engine.sweepStale();
|
||||
hub.sweepClosedSockets();
|
||||
hub.dropSilentSockets();
|
||||
hub.broadcastRoom();
|
||||
hub.broadcastFeed();
|
||||
});
|
||||
_log.info('room "${config.name}" listening on $boundPort');
|
||||
}
|
||||
|
||||
Future<void> stop() async {
|
||||
if (_server == null) return;
|
||||
_heartbeat?.cancel();
|
||||
_heartbeat = null;
|
||||
await hub.closeAllSockets();
|
||||
await _app.close();
|
||||
_server = null;
|
||||
_log.info('room "${config.name}" stopped');
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
import 'dart:io';
|
||||
import 'dart:math';
|
||||
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
|
||||
enum MediaGate { ok, gone, unauthorized, forbidden, offline }
|
||||
|
||||
class ViewerToken {
|
||||
final String token;
|
||||
final String name;
|
||||
final String avatar;
|
||||
bool kicked = false;
|
||||
int bytesServed = 0;
|
||||
DateTime lastSeen;
|
||||
Future<void> Function(String reason)? onKick;
|
||||
ViewerToken({required this.token, required this.name, this.avatar = ''})
|
||||
: lastSeen = DateTime.now().toUtc();
|
||||
|
||||
bool isStale(Duration timeout, [DateTime? now]) =>
|
||||
(now ?? DateTime.now().toUtc()).difference(lastSeen) > timeout;
|
||||
|
||||
void touch([DateTime? now]) => lastSeen = now ?? DateTime.now().toUtc();
|
||||
}
|
||||
|
||||
class SessionMedia {
|
||||
final String name;
|
||||
final int size;
|
||||
final double duration;
|
||||
final String? url;
|
||||
final File? file;
|
||||
final int mediaId;
|
||||
const SessionMedia({
|
||||
required this.name,
|
||||
required this.size,
|
||||
required this.duration,
|
||||
this.url,
|
||||
this.file,
|
||||
this.mediaId = 1,
|
||||
});
|
||||
}
|
||||
|
||||
class Session {
|
||||
final String id;
|
||||
final String secret;
|
||||
final Map<String, ViewerToken> tokens = {};
|
||||
SessionMedia? media;
|
||||
final _random = Random.secure();
|
||||
|
||||
Session({required this.id, required this.secret});
|
||||
|
||||
String issueToken(String name, String avatar) {
|
||||
if (avatar.length > RelayConstants.maxAvatarBytes) {
|
||||
throw const AuthException('avatar too large');
|
||||
}
|
||||
final trimmed = name.trim();
|
||||
final cleanName = trimmed.isEmpty
|
||||
? '?'
|
||||
: trimmed.substring(
|
||||
0, trimmed.length.clamp(0, RelayConstants.maxNameLength));
|
||||
final bytes = List<int>.generate(16, (_) => _random.nextInt(256));
|
||||
final token = bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join();
|
||||
tokens[token] = ViewerToken(token: token, name: cleanName, avatar: avatar);
|
||||
return token;
|
||||
}
|
||||
|
||||
MediaGate gate(String? token) {
|
||||
if (token == null || !tokens.containsKey(token)) return MediaGate.unauthorized;
|
||||
if (tokens[token]!.kicked) return MediaGate.forbidden;
|
||||
return MediaGate.ok;
|
||||
}
|
||||
|
||||
Future<void> kick(String token, {String reason = ''}) async {
|
||||
final viewer = tokens[token];
|
||||
if (viewer == null) throw const AuthException('unknown token');
|
||||
viewer.kicked = true;
|
||||
await viewer.onKick?.call(reason);
|
||||
}
|
||||
|
||||
void addBytes(String? token, int n) {
|
||||
if (token != null) tokens[token]?.bytesServed += n;
|
||||
}
|
||||
|
||||
int get totalBytesServed => tokens.values.fold(0, (a, v) => a + v.bytesServed);
|
||||
}
|
||||
|
||||
class SessionMap {
|
||||
final Map<String, Session> _sessions = {};
|
||||
|
||||
Session getOrCreate(String id, String secret) =>
|
||||
_sessions.putIfAbsent(id, () => Session(id: id, secret: secret));
|
||||
|
||||
Session? get(String id) => _sessions[id];
|
||||
|
||||
void drop(String id) => _sessions.remove(id);
|
||||
}
|
||||
@@ -0,0 +1,420 @@
|
||||
# Generated by pub
|
||||
# See https://dart.dev/tools/pub/glossary#lockfile
|
||||
packages:
|
||||
_fe_analyzer_shared:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: _fe_analyzer_shared
|
||||
sha256: fe18c7e37d5acb3b43224fa255281dec007970d6fd01f6d76fcd88ed3777a117
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "107.0.0"
|
||||
analyzer:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: analyzer
|
||||
sha256: f2dde9e50c23fc95b846b4ef334e98c3ae8c0effd5d2453b02fc9fb3f8939791
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "14.3.0"
|
||||
args:
|
||||
dependency: "direct main"
|
||||
description:
|
||||
name: args
|
||||
sha256: d0481093c50b1da8910eb0bb301626d4d8eb7284aa739614d2b394ee09e3ea04
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.7.0"
|
||||
async:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: async
|
||||
sha256: e2eb0491ba5ddb6177742d2da23904574082139b07c1e33b8503b9f46f3e1a37
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.13.1"
|
||||
boolean_selector:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: boolean_selector
|
||||
sha256: "8aab1771e1243a5063b8b0ff68042d67334e3feab9e95b9490f9a6ebf73b42ea"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.1.2"
|
||||
cli_config:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: cli_config
|
||||
sha256: ac20a183a07002b700f0c25e61b7ee46b23c309d76ab7b7640a028f18e4d99ec
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "0.2.0"
|
||||
collection:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: collection
|
||||
sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.19.1"
|
||||
convert:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: convert
|
||||
sha256: b30acd5944035672bc15c6b7a8b47d773e41e2f17de064350988c5d02adb1c68
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.1.2"
|
||||
coverage:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: coverage
|
||||
sha256: "956a3de0725ca232ad353565a8290d3357592bf4250f6f298a185e2d949c5d3d"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.15.1"
|
||||
crypto:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: crypto
|
||||
sha256: c8ea0233063ba03258fbcf2ca4d6dadfefe14f02fab57702265467a19f27fadf
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.0.7"
|
||||
file:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: file
|
||||
sha256: a3b4f84adafef897088c160faf7dfffb7696046cb13ae90b508c2cbc95d3b8d4
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "7.0.1"
|
||||
frontend_server_client:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: frontend_server_client
|
||||
sha256: f64a0333a82f30b0cca061bc3d143813a486dc086b574bfb233b7c1372427694
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "4.0.0"
|
||||
glob:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: glob
|
||||
sha256: "218aeb56050c714f62a3182775320dfa04602b55074873e24e31bbd39bda96fb"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.2.0"
|
||||
http_multi_server:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: http_multi_server
|
||||
sha256: aa6199f908078bb1c5efb8d8638d4ae191aac11b311132c3ef48ce352fb52ef8
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.2.2"
|
||||
http_parser:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: http_parser
|
||||
sha256: "178d74305e7866013777bab2c3d8726205dc5a4dd935297175b19a23a2e66571"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "4.1.2"
|
||||
io:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: io
|
||||
sha256: "2635216ca6a737e60de577ffa1a48a0bec76ca8a62917cfc1bb88c14c570646f"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.1.0"
|
||||
lints:
|
||||
dependency: "direct dev"
|
||||
description:
|
||||
name: lints
|
||||
sha256: c35bb79562d980e9a453fc715854e1ed39e24e7d0297a880ef54e17f9874a9d7
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "5.1.1"
|
||||
logging:
|
||||
dependency: "direct main"
|
||||
description:
|
||||
name: logging
|
||||
sha256: c8245ada5f1717ed44271ed1c26b8ce85ca3228fd2ffdb75468ab01979309d61
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.3.0"
|
||||
matcher:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: matcher
|
||||
sha256: "31bd099b47c10cd1aeb55146a2d46ce0277630ecef3f7dae54ad7873f36696cd"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "0.12.20"
|
||||
meta:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: meta
|
||||
sha256: "307249ce4ff29d58a18e97f6345f539382eb9c9c29ecda628900f31de0443dd9"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.19.0"
|
||||
mime:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: mime
|
||||
sha256: bd47de35f07e27267e69c8c8b22edf9473bfee170a60d60fcc93730c5144b7f6
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.1.0"
|
||||
node_preamble:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: node_preamble
|
||||
sha256: "6e7eac89047ab8a8d26cf16127b5ed26de65209847630400f9aefd7cd5c730db"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.0.2"
|
||||
package_config:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: package_config
|
||||
sha256: ffcf4cf3d6c0b74ac43708d9f56625506e8a68aa935abe9d267a7330f320eb5d
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.0.0"
|
||||
path:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: path
|
||||
sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.9.1"
|
||||
pool:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: pool
|
||||
sha256: "4177f68c237ea2128d1bee66ac17b2ce05ba3dbaafcbdd54c5d40a39d0b6b11c"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.5.3"
|
||||
pub_semver:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: pub_semver
|
||||
sha256: "261236774e8b1d69cfc6b9eabbc96c40f25e7a2d6b171f3385d4f65d5734fb24"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.2.1"
|
||||
relic:
|
||||
dependency: "direct main"
|
||||
description:
|
||||
name: relic
|
||||
sha256: d917b188dd1b6838c630d1904a1e26b040e6647406f2aab01b10fdf0ca051c12
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.2.0"
|
||||
relic_core:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: relic_core
|
||||
sha256: c2f7638d56fdf144a035d17eb8e93fb30fe53bd105fd81c31393f8be4f43ecdc
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.2.0"
|
||||
relic_io:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: relic_io
|
||||
sha256: d64a9f309943200ec7a45b2a127cbc5abf4dd6603159a179396d66b932a15f1f
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.2.0"
|
||||
shelf:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: shelf
|
||||
sha256: e7dd780a7ffb623c57850b33f43309312fc863fb6aa3d276a754bb299839ef12
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.4.2"
|
||||
shelf_packages_handler:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: shelf_packages_handler
|
||||
sha256: "89f967eca29607c933ba9571d838be31d67f53f6e4ee15147d5dc2934fee1b1e"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.0.2"
|
||||
shelf_static:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: shelf_static
|
||||
sha256: c87c3875f91262785dade62d135760c2c69cb217ac759485334c5857ad89f6e3
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.1.3"
|
||||
shelf_web_socket:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: shelf_web_socket
|
||||
sha256: "3632775c8e90d6c9712f883e633716432a27758216dfb61bd86a8321c0580925"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.0.0"
|
||||
source_map_stack_trace:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: source_map_stack_trace
|
||||
sha256: c0713a43e323c3302c2abe2a1cc89aa057a387101ebd280371d6a6c9fa68516b
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.1.2"
|
||||
source_maps:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: source_maps
|
||||
sha256: "14c2945847669b44089bb1222f66873d7ff7103c58911917f2a63c5a62327898"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "0.10.14"
|
||||
source_span:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: source_span
|
||||
sha256: "56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.10.2"
|
||||
stack_trace:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: stack_trace
|
||||
sha256: "277654b3034d17ac6f9f1cb5595db011b1d5d41e8806866db28e0abaa101c490"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.12.2"
|
||||
stream_channel:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: stream_channel
|
||||
sha256: "969e04c80b8bcdf826f8f16579c7b14d780458bd97f56d107d3950fdbeef059d"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "2.1.4"
|
||||
string_scanner:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: string_scanner
|
||||
sha256: "921cd31725b72fe181906c6a94d987c78e3b98c2e205b397ea399d4054872b43"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.4.1"
|
||||
sync_relay_core:
|
||||
dependency: "direct main"
|
||||
description:
|
||||
path: "../core"
|
||||
relative: true
|
||||
source: path
|
||||
version: "0.1.0"
|
||||
term_glyph:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: term_glyph
|
||||
sha256: "7f554798625ea768a7518313e58f83891c7f5024f88e46e7182a4558850a4b8e"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.2.2"
|
||||
test:
|
||||
dependency: "direct dev"
|
||||
description:
|
||||
name: test
|
||||
sha256: de5d145b0afff7921e5e788a880f52d7e5f3ae24068a202f6fd3b58e4ba26323
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.32.0"
|
||||
test_api:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: test_api
|
||||
sha256: "0a10344e901e5b2e63819567951cb6a06673ed6b84f40462188ff5a0c41f371f"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "0.7.14"
|
||||
test_core:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: test_core
|
||||
sha256: "80f3fb49087454e07e7e07c67578cfdd156c8c3a5227d8b3f47c7b2d019c2e93"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "0.6.20"
|
||||
typed_data:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: typed_data
|
||||
sha256: f9049c039ebfeb4cf7a7104a675823cd72dba8297f264b6637062516699fa006
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.4.0"
|
||||
vm_service:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: vm_service
|
||||
sha256: "5f37239c4851efcef929cea7824e76df7f2f0970aef85d66bbc430afa40e72f0"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "15.3.0"
|
||||
watcher:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: watcher
|
||||
sha256: "1398c9f081a753f9226febe8900fce8f7d0a67163334e1c94a2438339d79d635"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.2.1"
|
||||
web:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: web
|
||||
sha256: "868d88a33d8a87b18ffc05f9f030ba328ffefba92d6c127917a2ba740f9cfe4a"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.1.1"
|
||||
web_socket:
|
||||
dependency: "direct main"
|
||||
description:
|
||||
name: web_socket
|
||||
sha256: "34d64019aa8e36bf9842ac014bb5d2f5586ca73df5e4d9bf5c936975cae6982c"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.0.1"
|
||||
web_socket_channel:
|
||||
dependency: "direct dev"
|
||||
description:
|
||||
name: web_socket_channel
|
||||
sha256: d645757fb0f4773d602444000a8131ff5d48c9e47adfe9772652dd1a4f2d45c8
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.0.3"
|
||||
webkit_inspection_protocol:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: webkit_inspection_protocol
|
||||
sha256: "87d3f2333bb240704cd3f1c6b5b7acd8a10e7f0bc28c28dcf14e782014f4a572"
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "1.2.1"
|
||||
yaml:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: yaml
|
||||
sha256: f67cdd8e07d3c6329146aaef1ba043542b3134c12489f553ca9a7435d1068aea
|
||||
url: "https://pub.dev"
|
||||
source: hosted
|
||||
version: "3.1.4"
|
||||
sdks:
|
||||
dart: ">=3.11.0 <4.0.0"
|
||||
@@ -0,0 +1,17 @@
|
||||
name: sync_relay_server
|
||||
description: Pure-Dart room + media server. Embeddable, no Flutter.
|
||||
publish_to: none
|
||||
version: 0.1.0
|
||||
environment:
|
||||
sdk: ^3.0.0
|
||||
dependencies:
|
||||
sync_relay_core:
|
||||
path: ../core
|
||||
logging: ^1.2.0
|
||||
args: ^2.4.0
|
||||
relic: ^1.2.0
|
||||
web_socket: ^1.0.0
|
||||
dev_dependencies:
|
||||
lints: ^5.0.0
|
||||
test: ^1.25.0
|
||||
web_socket_channel: ^3.0.0
|
||||
@@ -0,0 +1,97 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
import 'package:sync_relay_server/server.dart';
|
||||
import 'package:test/test.dart';
|
||||
|
||||
class _ProbeClient {
|
||||
final WebSocket ws;
|
||||
final Completer<void> welcomed = Completer<void>();
|
||||
final Completer<String> closed = Completer<String>();
|
||||
_ProbeClient(this.ws) {
|
||||
ws.listen(
|
||||
(m) {
|
||||
if (!welcomed.isCompleted) {
|
||||
final decoded = jsonDecode('$m') as Map;
|
||||
expect(decoded['t'], 'welcome');
|
||||
welcomed.complete();
|
||||
}
|
||||
},
|
||||
onDone: () {
|
||||
if (!closed.isCompleted) {
|
||||
closed.complete('done code=${ws.closeCode} reason=${ws.closeReason}');
|
||||
}
|
||||
},
|
||||
onError: (Object e) {
|
||||
if (!closed.isCompleted) closed.complete('error $e');
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
static Future<_ProbeClient> hello(int port, String name) async {
|
||||
final ws = await WebSocket.connect('ws://127.0.0.1:$port/sync');
|
||||
final c = _ProbeClient(ws);
|
||||
ws.add(jsonEncode({
|
||||
't': 'hello',
|
||||
'proto': RelayConstants.protoVersion,
|
||||
'secret': 'cycle',
|
||||
'user': {'name': name},
|
||||
'media': {'name': '', 'size': 0, 'duration': 0.0},
|
||||
}));
|
||||
await c.welcomed.future.timeout(const Duration(seconds: 5));
|
||||
return c;
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _pollBool(
|
||||
FutureOr<bool> Function() cond,
|
||||
String what, {
|
||||
Duration timeout = const Duration(seconds: 8),
|
||||
}) async {
|
||||
final deadline = DateTime.now().add(timeout);
|
||||
while (DateTime.now().isBefore(deadline)) {
|
||||
if (await cond()) return;
|
||||
await Future.delayed(const Duration(milliseconds: 100));
|
||||
}
|
||||
fail('timed out: $what');
|
||||
}
|
||||
|
||||
void main() {
|
||||
group('presence lifecycle live', () {
|
||||
late RoomServer server;
|
||||
|
||||
setUp(() async {
|
||||
server = RoomServer(
|
||||
const AppConfig(port: 0, secret: 'cycle', name: 'cycle'));
|
||||
await server.start();
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
await server.stop();
|
||||
});
|
||||
|
||||
test('clean client close removes member within seconds, not timeout',
|
||||
() async {
|
||||
final client = await _ProbeClient.hello(server.boundPort, 'alice');
|
||||
await _pollBool(
|
||||
() => server.hub.engine.members.length == 1, 'join visible');
|
||||
await client.ws.close();
|
||||
await _pollBool(
|
||||
() => server.hub.engine.members.isEmpty, 'member removed');
|
||||
expect(server.session.tokens, isEmpty);
|
||||
expect(server.hub.sockets, isEmpty);
|
||||
});
|
||||
|
||||
test('server stop closes client sockets', () async {
|
||||
final client = await _ProbeClient.hello(server.boundPort, 'bob');
|
||||
await _pollBool(
|
||||
() => server.hub.engine.members.length == 1, 'join visible');
|
||||
await server.stop();
|
||||
final outcome = await client.closed.future
|
||||
.timeout(const Duration(seconds: 5), onTimeout: () => 'TIMEOUT');
|
||||
expect(outcome, isNot('TIMEOUT'), reason: 'client never saw close');
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,172 @@
|
||||
import 'dart:io';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:relic/relic.dart';
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
import 'package:sync_relay_server/server.dart';
|
||||
import 'package:test/test.dart';
|
||||
|
||||
void main() {
|
||||
group('resolveMediaRequest pure table', () {
|
||||
test('no Range -> 200 full with exact length', () {
|
||||
final r = resolveMediaRequest(rangeHeader: null, size: 1000, filename: 'a.mkv');
|
||||
expect(r.status, 200);
|
||||
expect(r.headers['accept-ranges'], 'bytes');
|
||||
expect(r.headers['content-type'], 'video/x-matroska');
|
||||
expect(r.headers['content-length'], '1000');
|
||||
expect(r.start, 0);
|
||||
expect(r.end, isNull);
|
||||
});
|
||||
|
||||
test('closed range -> 206 exact bytes + content-range', () {
|
||||
final r = resolveMediaRequest(rangeHeader: 'bytes=0-99', size: 1000, filename: 'a.mkv');
|
||||
expect(r.status, 206);
|
||||
expect(r.headers['content-range'], 'bytes 0-99/1000');
|
||||
expect(r.headers['content-length'], '100');
|
||||
});
|
||||
|
||||
test('open-ended range -> 206 to EOF', () {
|
||||
final r = resolveMediaRequest(rangeHeader: 'bytes=900-', size: 1000, filename: 'b.mp4');
|
||||
expect(r.status, 206);
|
||||
expect(r.headers['content-range'], 'bytes 900-999/1000');
|
||||
expect(r.headers['content-length'], '100');
|
||||
expect(r.headers['content-type'], 'video/mp4');
|
||||
});
|
||||
|
||||
test('suffix range -> tail (mkv cues probe)', () {
|
||||
final r = resolveMediaRequest(rangeHeader: 'bytes=-500', size: 1000, filename: 'c.mkv');
|
||||
expect(r.status, 206);
|
||||
expect(r.start, 500);
|
||||
expect(r.headers['content-length'], '500');
|
||||
});
|
||||
|
||||
test('out-of-range start -> 416 with bytes */size', () {
|
||||
final r = resolveMediaRequest(rangeHeader: 'bytes=5000-6000', size: 1000, filename: 'a.mkv');
|
||||
expect(r.status, 416);
|
||||
expect(r.headers['content-range'], 'bytes */1000');
|
||||
});
|
||||
|
||||
test('gates: gone/auth/forbidden/offline', () {
|
||||
expect(
|
||||
resolveMediaRequest(rangeHeader: null, size: 10, filename: 'a.mkv', gate: MediaGate.gone).status,
|
||||
410);
|
||||
expect(
|
||||
resolveMediaRequest(rangeHeader: null, size: 10, filename: 'a.mkv', gate: MediaGate.unauthorized)
|
||||
.status,
|
||||
401);
|
||||
expect(
|
||||
resolveMediaRequest(rangeHeader: null, size: 10, filename: 'a.mkv', gate: MediaGate.forbidden).status,
|
||||
403);
|
||||
final off =
|
||||
resolveMediaRequest(rangeHeader: null, size: 10, filename: 'a.mkv', gate: MediaGate.offline);
|
||||
expect(off.status, 503);
|
||||
expect(off.headers['retry-after'], isNotEmpty);
|
||||
});
|
||||
|
||||
test('content types by extension', () {
|
||||
expect(contentTypeForFile('x.MKV'), 'video/x-matroska');
|
||||
expect(contentTypeForFile('x.mp4'), 'video/mp4');
|
||||
expect(contentTypeForFile('x.webm'), 'video/webm');
|
||||
expect(contentTypeForFile('x.avi'), 'video/x-msvideo');
|
||||
expect(contentTypeForFile('x.unknown'), 'application/octet-stream');
|
||||
});
|
||||
});
|
||||
|
||||
group('live Relic media route (byte-exact)', () {
|
||||
late File file;
|
||||
late Uint8List bytes;
|
||||
late RelicApp app;
|
||||
late RelicServer server;
|
||||
late HttpClient client;
|
||||
|
||||
setUp(() async {
|
||||
bytes = Uint8List.fromList(List<int>.generate(65536, (i) => i % 251));
|
||||
file = File('${Directory.systemTemp.path}/media_test_${DateTime.now().microsecondsSinceEpoch}.bin');
|
||||
await file.writeAsBytes(bytes);
|
||||
app = RelicApp();
|
||||
mountMediaRoute(app, file);
|
||||
server = await app.serve(address: InternetAddress.loopbackIPv4, port: 0);
|
||||
client = HttpClient();
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
client.close();
|
||||
await app.close();
|
||||
await file.delete();
|
||||
});
|
||||
|
||||
Future<HttpClientResponse> get(String path, {String? range}) async {
|
||||
final req = await client.get('127.0.0.1', server.port, path);
|
||||
if (range != null) req.headers.set('range', range);
|
||||
return req.close();
|
||||
}
|
||||
|
||||
Future<List<int>> readAll(HttpClientResponse resp) async {
|
||||
final out = <int>[];
|
||||
await for (final chunk in resp) {
|
||||
out.addAll(chunk);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
test('200 full body matches file bytes', () async {
|
||||
final resp = await get('/m/file');
|
||||
expect(resp.statusCode, 200);
|
||||
expect(resp.headers.value('accept-ranges'), 'bytes');
|
||||
expect(resp.headers.value('content-length'), '${bytes.length}');
|
||||
expect(await readAll(resp), bytes);
|
||||
});
|
||||
|
||||
test('206 closed range byte-exact', () async {
|
||||
final resp = await get('/m/file', range: 'bytes=100-199');
|
||||
expect(resp.statusCode, 206);
|
||||
expect(resp.headers.value('content-range'), 'bytes 100-199/${bytes.length}');
|
||||
expect(resp.headers.value('content-length'), '100');
|
||||
expect(await readAll(resp), bytes.sublist(100, 200));
|
||||
});
|
||||
|
||||
test('206 open-ended streams to EOF', () async {
|
||||
final resp = await get('/m/file', range: 'bytes=${bytes.length - 1000}-');
|
||||
expect(resp.statusCode, 206);
|
||||
expect(resp.headers.value('content-length'), '1000');
|
||||
expect(await readAll(resp), bytes.sublist(bytes.length - 1000));
|
||||
});
|
||||
|
||||
test('206 suffix tail byte-exact', () async {
|
||||
final resp = await get('/m/file', range: 'bytes=-256');
|
||||
expect(resp.statusCode, 206);
|
||||
expect(await readAll(resp), bytes.sublist(bytes.length - 256));
|
||||
});
|
||||
|
||||
test('seek storm: 20 rapid seeks all byte-exact', () async {
|
||||
for (var i = 0; i < 20; i++) {
|
||||
final start = (i * 997) % (bytes.length - 512);
|
||||
final resp = await get('/m/file', range: 'bytes=$start-${start + 511}');
|
||||
expect(resp.statusCode, 206);
|
||||
expect(await readAll(resp), bytes.sublist(start, start + 512));
|
||||
}
|
||||
});
|
||||
|
||||
test('onLog hook records method/range/status/bytes', () async {
|
||||
final seen = <MediaLog>[];
|
||||
final logApp = RelicApp();
|
||||
mountMediaRoute(logApp, file, route: '/m/logged', onLog: seen.add);
|
||||
final logServer =
|
||||
await logApp.serve(address: InternetAddress.loopbackIPv4, port: 0);
|
||||
try {
|
||||
final req = await client.get('127.0.0.1', logServer.port, '/m/logged');
|
||||
req.headers.set('range', 'bytes=0-9');
|
||||
final resp = await req.close();
|
||||
await resp.drain();
|
||||
expect(resp.statusCode, 206);
|
||||
} finally {
|
||||
await logApp.close();
|
||||
}
|
||||
expect(seen, hasLength(1));
|
||||
expect(seen.single.status, 206);
|
||||
expect(seen.single.bytesWritten, 10);
|
||||
expect(seen.single.rangeHeader, 'bytes=0-9');
|
||||
expect(seen.single.toString(), contains('206'));
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,391 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
import 'package:sync_relay_server/server.dart';
|
||||
import 'package:test/test.dart';
|
||||
import 'package:web_socket_channel/web_socket_channel.dart';
|
||||
|
||||
void main() {
|
||||
group('room auth live', () {
|
||||
late File file;
|
||||
late Uint8List bytes;
|
||||
late RoomServer server;
|
||||
late HttpClient http;
|
||||
|
||||
setUp(() async {
|
||||
bytes = Uint8List.fromList(List<int>.generate(8192, (i) => i % 251));
|
||||
file = File(
|
||||
'${Directory.systemTemp.path}/room_test_${DateTime.now().microsecondsSinceEpoch}.bin');
|
||||
await file.writeAsBytes(bytes);
|
||||
server = RoomServer(AppConfig(
|
||||
port: 0, secret: 'shh', name: 'test', mediaPath: file.path));
|
||||
await server.start();
|
||||
http = HttpClient();
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
http.close();
|
||||
await server.stop();
|
||||
await file.delete();
|
||||
});
|
||||
|
||||
Future<HttpClientResponse> mediaGet(String path, {String? range}) async {
|
||||
final req = await http.get('127.0.0.1', server.boundPort, path);
|
||||
if (range != null) req.headers.set('range', range);
|
||||
return req.close();
|
||||
}
|
||||
|
||||
Future<String> hello(String secret,
|
||||
{int proto = RelayConstants.protoVersion,
|
||||
Duration timeout = const Duration(seconds: 5)}) async {
|
||||
final ch = WebSocketChannel.connect(
|
||||
Uri.parse('ws://127.0.0.1:${server.boundPort}/sync'));
|
||||
final msg = HelloMessage(
|
||||
proto: proto,
|
||||
secret: secret,
|
||||
user: const HelloUser(name: 'alice'),
|
||||
media:
|
||||
const HelloMedia(name: 'f.bin', size: 8192, duration: 10.0)).toJson();
|
||||
ch.sink.add(jsonEncode(msg));
|
||||
try {
|
||||
final first = await ch.stream.first.timeout(timeout);
|
||||
await ch.sink.close();
|
||||
return '$first';
|
||||
} catch (_) {
|
||||
try {
|
||||
await ch.sink.close();
|
||||
} catch (_) {}
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
test('health reports room, proto, viewers, bytes', () async {
|
||||
final req = await http.get('127.0.0.1', server.boundPort, '/health');
|
||||
final resp = await req.close();
|
||||
expect(resp.statusCode, 200);
|
||||
final body = await resp.transform(utf8.decoder).join();
|
||||
final decoded = jsonDecode(body) as Map;
|
||||
expect(decoded['ok'], isTrue);
|
||||
expect(decoded['room'], 'test');
|
||||
expect(decoded['proto'], RelayConstants.protoVersion);
|
||||
expect(decoded['viewers'], 0);
|
||||
expect(decoded['bytesServed'], 0);
|
||||
expect(decoded['media'], isNotNull);
|
||||
});
|
||||
|
||||
test('wrong secret gets err, right secret gets welcome+token', () async {
|
||||
final bad = await hello('wrong');
|
||||
expect(jsonDecode(bad)['t'], 'err');
|
||||
|
||||
final good = await hello('shh');
|
||||
final decoded = jsonDecode(good) as Map;
|
||||
expect(decoded['t'], 'welcome');
|
||||
final token = decoded['token'] as String;
|
||||
expect(token, hasLength(32));
|
||||
expect(decoded['mediaUrl'], contains(token));
|
||||
|
||||
final req = await http.get('127.0.0.1', server.boundPort, '/health');
|
||||
final resp = await req.close();
|
||||
await resp.drain();
|
||||
expect(server.session.tokens.length, 1);
|
||||
});
|
||||
|
||||
test('proto mismatch rejected', () async {
|
||||
final reply =
|
||||
await hello('shh', proto: RelayConstants.protoVersion + 99);
|
||||
expect(jsonDecode(reply)['t'], 'err');
|
||||
expect(server.session.tokens, isEmpty);
|
||||
});
|
||||
|
||||
test('media: no token 401, bad token 401, good token 200 byte-exact',
|
||||
() async {
|
||||
final good = await hello('shh');
|
||||
final token = (jsonDecode(good) as Map)['token'] as String;
|
||||
final name = file.path.split(Platform.pathSeparator).last;
|
||||
|
||||
var resp = await mediaGet('/m/default/notoken/$name');
|
||||
expect(resp.statusCode, 401);
|
||||
await resp.drain();
|
||||
|
||||
resp = await mediaGet('/m/default/deadbeefdeadbeefdeadbeefdeadbeef/$name');
|
||||
expect(resp.statusCode, 401);
|
||||
await resp.drain();
|
||||
|
||||
resp = await mediaGet('/m/default/$token/$name', range: 'bytes=0-99');
|
||||
expect(resp.statusCode, 206);
|
||||
expect(resp.headers.value('content-range'), 'bytes 0-99/8192');
|
||||
final body = <int>[];
|
||||
await for (final c in resp) {
|
||||
body.addAll(c);
|
||||
}
|
||||
expect(body, bytes.sublist(0, 100));
|
||||
expect(server.session.tokens[token]!.bytesServed, 100);
|
||||
});
|
||||
|
||||
test('unknown session -> 410', () async {
|
||||
final resp = await mediaGet('/m/nosuch/abc/file');
|
||||
expect(resp.statusCode, 410);
|
||||
await resp.drain();
|
||||
});
|
||||
|
||||
test('kick: WS drops and media goes 403', () async {
|
||||
final ch = WebSocketChannel.connect(
|
||||
Uri.parse('ws://127.0.0.1:${server.boundPort}/sync'));
|
||||
final firstCompleter = Completer<String>();
|
||||
var wsClosed = false;
|
||||
final sub = ch.stream.listen(
|
||||
(m) {
|
||||
if (!firstCompleter.isCompleted) firstCompleter.complete('$m');
|
||||
},
|
||||
onDone: () => wsClosed = true,
|
||||
);
|
||||
final msg = HelloMessage(
|
||||
proto: RelayConstants.protoVersion,
|
||||
secret: 'shh',
|
||||
user: const HelloUser(name: 'mallory'),
|
||||
media:
|
||||
const HelloMedia(name: 'f.bin', size: 8192, duration: 10.0)).toJson();
|
||||
ch.sink.add(jsonEncode(msg));
|
||||
final first =
|
||||
await firstCompleter.future.timeout(const Duration(seconds: 5));
|
||||
final token = (jsonDecode(first) as Map)['token'] as String;
|
||||
|
||||
await server.session.kick(token);
|
||||
final deadline = DateTime.now().add(const Duration(seconds: 5));
|
||||
while (!wsClosed && DateTime.now().isBefore(deadline)) {
|
||||
await Future.delayed(const Duration(milliseconds: 50));
|
||||
}
|
||||
expect(wsClosed, isTrue);
|
||||
try {
|
||||
await sub.cancel();
|
||||
} catch (_) {}
|
||||
try {
|
||||
await ch.sink.close();
|
||||
} catch (_) {}
|
||||
|
||||
final name = file.path.split(Platform.pathSeparator).last;
|
||||
final resp = await mediaGet('/m/default/$token/$name');
|
||||
expect(resp.statusCode, 403);
|
||||
await resp.drain();
|
||||
});
|
||||
|
||||
test('kick delivers reason then drops; instant rejoin works', () async {
|
||||
final ch = WebSocketChannel.connect(
|
||||
Uri.parse('ws://127.0.0.1:${server.boundPort}/sync'));
|
||||
final messages = <String>[];
|
||||
var wsClosed = false;
|
||||
final sub = ch.stream.listen(
|
||||
(m) => messages.add('$m'),
|
||||
onDone: () => wsClosed = true,
|
||||
);
|
||||
HelloMessage helloFor(String who) => HelloMessage(
|
||||
proto: RelayConstants.protoVersion,
|
||||
secret: 'shh',
|
||||
user: HelloUser(name: who),
|
||||
media: const HelloMedia(
|
||||
name: 'f.bin', size: 8192, duration: 10.0));
|
||||
ch.sink.add(jsonEncode(helloFor(' sleepy').toJson()));
|
||||
Map<String, Object?>? welcome;
|
||||
final welcomeDeadline = DateTime.now().add(const Duration(seconds: 5));
|
||||
while (DateTime.now().isBefore(welcomeDeadline)) {
|
||||
for (final m in messages) {
|
||||
final decoded = jsonDecode(m) as Map;
|
||||
if (decoded['t'] == 'welcome') {
|
||||
welcome = Map<String, Object?>.from(decoded);
|
||||
}
|
||||
}
|
||||
if (welcome != null) break;
|
||||
await Future.delayed(const Duration(milliseconds: 50));
|
||||
}
|
||||
expect(welcome, isNotNull);
|
||||
final token = welcome!['token'] as String;
|
||||
|
||||
await server.session.kick(token, reason: 'idle too long');
|
||||
final deadline = DateTime.now().add(const Duration(seconds: 5));
|
||||
Map<String, Object?>? kicked;
|
||||
while (DateTime.now().isBefore(deadline)) {
|
||||
for (final m in messages.skip(1)) {
|
||||
final decoded = jsonDecode(m) as Map;
|
||||
if (decoded['t'] == 'kicked') {
|
||||
kicked = Map<String, Object?>.from(decoded);
|
||||
}
|
||||
}
|
||||
if (wsClosed && kicked != null) break;
|
||||
await Future.delayed(const Duration(milliseconds: 50));
|
||||
}
|
||||
expect(wsClosed, isTrue);
|
||||
expect(kicked, isNotNull);
|
||||
expect(kicked!['reason'], 'idle too long');
|
||||
try {
|
||||
await sub.cancel();
|
||||
} catch (_) {}
|
||||
try {
|
||||
await ch.sink.close();
|
||||
} catch (_) {}
|
||||
|
||||
final rejoin = await hello('shh');
|
||||
final decoded = jsonDecode(rejoin) as Map;
|
||||
expect(decoded['t'], 'welcome');
|
||||
final token2 = decoded['token'] as String;
|
||||
expect(token2, isNot(token));
|
||||
final name = file.path.split(Platform.pathSeparator).last;
|
||||
final resp = await mediaGet('/m/default/$token2/$name');
|
||||
expect(resp.statusCode, 200);
|
||||
await resp.drain();
|
||||
});
|
||||
|
||||
test('kick via socket: peer kicked, unknown target errors', () async {
|
||||
WebSocketChannel open() => WebSocketChannel.connect(
|
||||
Uri.parse('ws://127.0.0.1:${server.boundPort}/sync'));
|
||||
Future<(WebSocketChannel, String, String, List<String>)> join(String who) async {
|
||||
final ch = open();
|
||||
final messages = <String>[];
|
||||
ch.stream.listen((m) => messages.add('$m'));
|
||||
final msg = HelloMessage(
|
||||
proto: RelayConstants.protoVersion,
|
||||
secret: 'shh',
|
||||
user: HelloUser(name: who),
|
||||
media: const HelloMedia(
|
||||
name: 'f.bin', size: 8192, duration: 10.0)).toJson();
|
||||
ch.sink.add(jsonEncode(msg));
|
||||
Map<String, Object?>? welcome;
|
||||
final deadline = DateTime.now().add(const Duration(seconds: 5));
|
||||
while (DateTime.now().isBefore(deadline)) {
|
||||
for (final m in messages) {
|
||||
final decoded = jsonDecode(m) as Map;
|
||||
if (decoded['t'] == 'welcome') {
|
||||
welcome = Map<String, Object?>.from(decoded);
|
||||
}
|
||||
}
|
||||
if (welcome != null) break;
|
||||
await Future.delayed(const Duration(milliseconds: 50));
|
||||
}
|
||||
expect(welcome, isNotNull,
|
||||
reason: 'no welcome for $who: $messages');
|
||||
final w = welcome!;
|
||||
return (ch, w['token'] as String, w['memberId'] as String, messages);
|
||||
}
|
||||
|
||||
Map<String, Object?>? findType(List<String> messages, String type) {
|
||||
for (final m in messages) {
|
||||
final decoded = jsonDecode(m) as Map;
|
||||
if (decoded['t'] == type) return Map<String, Object?>.from(decoded);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
Future<Map<String, Object?>?> waitType(
|
||||
List<String> messages, String type, Duration timeout) async {
|
||||
final deadline = DateTime.now().add(timeout);
|
||||
while (DateTime.now().isBefore(deadline)) {
|
||||
final found = findType(messages, type);
|
||||
if (found != null) return found;
|
||||
await Future.delayed(const Duration(milliseconds: 50));
|
||||
}
|
||||
return findType(messages, type);
|
||||
}
|
||||
|
||||
final (a, _, _, messagesA) = await join('alice');
|
||||
final (b, tokenB, idB, messagesB) = await join('bob');
|
||||
try {
|
||||
a.sink.add(jsonEncode(
|
||||
KickRequest(target: idB, reason: 'afk?').toJson()));
|
||||
final kicked = await waitType(
|
||||
messagesB, 'kicked', const Duration(seconds: 5));
|
||||
expect(kicked, isNotNull);
|
||||
expect(kicked!['reason'], 'afk?');
|
||||
expect(server.session.gate(tokenB), MediaGate.forbidden);
|
||||
|
||||
a.sink.add(
|
||||
jsonEncode(const KickRequest(target: 'm99').toJson()));
|
||||
final err = await waitType(
|
||||
messagesA, 'err', const Duration(seconds: 5));
|
||||
expect(err, isNotNull);
|
||||
} finally {
|
||||
try {
|
||||
await a.sink.close();
|
||||
} catch (_) {}
|
||||
try {
|
||||
await b.sink.close();
|
||||
} catch (_) {}
|
||||
}
|
||||
});
|
||||
|
||||
test('silent socket dropped and member removed', () async {
|
||||
final ch = WebSocketChannel.connect(
|
||||
Uri.parse('ws://127.0.0.1:${server.boundPort}/sync'));
|
||||
final messages = <String>[];
|
||||
var wsClosed = false;
|
||||
final sub = ch.stream.listen(
|
||||
(m) => messages.add('$m'),
|
||||
onDone: () => wsClosed = true,
|
||||
);
|
||||
final msg = HelloMessage(
|
||||
proto: RelayConstants.protoVersion,
|
||||
secret: 'shh',
|
||||
user: const HelloUser(name: 'ghost'),
|
||||
media: const HelloMedia(
|
||||
name: 'f.bin', size: 8192, duration: 10.0)).toJson();
|
||||
ch.sink.add(jsonEncode(msg));
|
||||
final deadline = DateTime.now().add(const Duration(seconds: 5));
|
||||
while (messages.isEmpty && DateTime.now().isBefore(deadline)) {
|
||||
await Future.delayed(const Duration(milliseconds: 50));
|
||||
}
|
||||
final token =
|
||||
(jsonDecode(messages.firstWhere((m) => (jsonDecode(m) as Map)['t'] == 'welcome')) as Map)['token']
|
||||
as String;
|
||||
server.hub.engine.members[token]!.lastSeen =
|
||||
DateTime.now().toUtc().subtract(const Duration(seconds: 61));
|
||||
server.hub.dropSilentSockets();
|
||||
final closeDeadline = DateTime.now().add(const Duration(seconds: 5));
|
||||
while ((!wsClosed ||
|
||||
server.hub.engine.members.containsKey(token) ||
|
||||
server.session.tokens.containsKey(token)) &&
|
||||
DateTime.now().isBefore(closeDeadline)) {
|
||||
await Future.delayed(const Duration(milliseconds: 50));
|
||||
}
|
||||
expect(wsClosed, isTrue);
|
||||
expect(server.hub.engine.members.containsKey(token), isFalse);
|
||||
expect(server.session.tokens.containsKey(token), isFalse);
|
||||
try {
|
||||
await sub.cancel();
|
||||
} catch (_) {}
|
||||
try {
|
||||
await ch.sink.close();
|
||||
} catch (_) {}
|
||||
});
|
||||
|
||||
test('any frame touches lastSeen (heartbeat baseline)', () async {
|
||||
final good = await hello('shh');
|
||||
final token = (jsonDecode(good) as Map)['token'] as String;
|
||||
final viewer = server.session.tokens[token]!;
|
||||
viewer.touch(DateTime.utc(2020, 1, 1));
|
||||
expect(viewer.isStale(const Duration(seconds: 30)), isTrue);
|
||||
|
||||
final ch = WebSocketChannel.connect(
|
||||
Uri.parse('ws://127.0.0.1:${server.boundPort}/sync'));
|
||||
final sub = ch.stream.listen((_) {});
|
||||
ch.sink.add(jsonEncode(HelloMessage(
|
||||
proto: RelayConstants.protoVersion,
|
||||
secret: 'shh',
|
||||
user: const HelloUser(name: 'hb'),
|
||||
media: const HelloMedia(
|
||||
name: 'f.bin', size: 8192, duration: 10.0))
|
||||
.toJson()));
|
||||
await Future.delayed(const Duration(seconds: 1));
|
||||
final hbToken = server.session.tokens.keys
|
||||
.firstWhere((k) => server.session.tokens[k]!.name == 'hb');
|
||||
expect(server.session.tokens[hbToken]!.isStale(const Duration(seconds: 30)), isFalse);
|
||||
expect(viewer.isStale(const Duration(seconds: 30)), isTrue);
|
||||
try {
|
||||
await sub.cancel();
|
||||
} catch (_) {}
|
||||
try {
|
||||
await ch.sink.close();
|
||||
} catch (_) {}
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
import 'package:sync_relay_server/server.dart';
|
||||
import 'package:test/test.dart';
|
||||
|
||||
void main() {
|
||||
test('server has zero flutter imports', () async {
|
||||
final libDir = Directory('lib');
|
||||
final binDir = Directory('bin');
|
||||
final offenders = <String>[];
|
||||
for (final dir in [libDir, binDir]) {
|
||||
if (!await dir.exists()) continue;
|
||||
await for (final entity in dir.list(recursive: true)) {
|
||||
if (entity is! File || !entity.path.endsWith('.dart')) continue;
|
||||
final content = await entity.readAsString();
|
||||
if (content.contains('package:flutter/') || content.contains('dart:ui')) {
|
||||
offenders.add(entity.path);
|
||||
}
|
||||
}
|
||||
}
|
||||
expect(offenders, isEmpty, reason: 'Flutter imports in server: $offenders');
|
||||
});
|
||||
|
||||
test('server starts, answers /health, stops cleanly', () async {
|
||||
final server = RoomServer(const AppConfig(port: 0, secret: 't', name: 'test'));
|
||||
await server.start();
|
||||
expect(server.isRunning, isTrue);
|
||||
final port = server.boundPort;
|
||||
expect(port, greaterThan(0));
|
||||
|
||||
final client = HttpClient();
|
||||
try {
|
||||
final req = await client.get('127.0.0.1', port, '/health');
|
||||
final resp = await req.close();
|
||||
expect(resp.statusCode, 200);
|
||||
final body = await resp.transform(const SystemEncoding().decoder).join();
|
||||
expect(body, contains('test'));
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
|
||||
await server.stop();
|
||||
expect(server.isRunning, isFalse);
|
||||
});
|
||||
|
||||
test('unknown path returns 404', () async {
|
||||
final server = RoomServer(const AppConfig(port: 0, secret: 't', name: 'test'));
|
||||
await server.start();
|
||||
final client = HttpClient();
|
||||
try {
|
||||
final req = await client.get('127.0.0.1', server.boundPort, '/nope');
|
||||
final resp = await req.close();
|
||||
expect(resp.statusCode, 404);
|
||||
await resp.drain();
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
await server.stop();
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
import 'package:sync_relay_core/core.dart';
|
||||
import 'package:sync_relay_server/server.dart';
|
||||
import 'package:test/test.dart';
|
||||
|
||||
void main() {
|
||||
group('Session model', () {
|
||||
test('tokens are unique 128-bit hex', () {
|
||||
final s = Session(id: 'default', secret: 'shh');
|
||||
final a = s.issueToken('alice', '');
|
||||
final b = s.issueToken('bob', '');
|
||||
expect(a, hasLength(32));
|
||||
expect(a, isNot(b));
|
||||
expect(RegExp(r'^[0-9a-f]{32}$').hasMatch(a), isTrue);
|
||||
});
|
||||
|
||||
test('gate: unknown -> unauthorized, known -> ok', () {
|
||||
final s = Session(id: 'default', secret: 'shh');
|
||||
expect(s.gate(null), MediaGate.unauthorized);
|
||||
expect(s.gate('nope'), MediaGate.unauthorized);
|
||||
final t = s.issueToken('alice', '');
|
||||
expect(s.gate(t), MediaGate.ok);
|
||||
});
|
||||
|
||||
test('kick unknown throws, kick known forbids + drops', () async {
|
||||
final s = Session(id: 'default', secret: 'shh');
|
||||
expect(() => s.kick('nope'), throwsA(isA<AuthException>()));
|
||||
final t = s.issueToken('mallory', '');
|
||||
var dropped = false;
|
||||
String? gotReason;
|
||||
s.tokens[t]!.onKick = (reason) async {
|
||||
dropped = true;
|
||||
gotReason = reason;
|
||||
};
|
||||
await s.kick(t, reason: 'idle');
|
||||
expect(s.gate(t), MediaGate.forbidden);
|
||||
expect(dropped, isTrue);
|
||||
expect(gotReason, 'idle');
|
||||
});
|
||||
|
||||
test('oversize avatar rejected', () {
|
||||
final s = Session(id: 'default', secret: 'shh');
|
||||
final big = 'x' * (RelayConstants.maxAvatarBytes + 1);
|
||||
expect(() => s.issueToken('alice', big), throwsA(isA<AuthException>()));
|
||||
});
|
||||
|
||||
test('names truncated to cap, blank becomes ?', () {
|
||||
final s = Session(id: 'default', secret: 'shh');
|
||||
final long = s.issueToken('a' * 100, '');
|
||||
expect(s.tokens[long]!.name, hasLength(RelayConstants.maxNameLength));
|
||||
final blank = s.issueToken(' ', '');
|
||||
expect(s.tokens[blank]!.name, '?');
|
||||
});
|
||||
|
||||
test('byte counters accumulate', () { final s = Session(id: 'default', secret: 'shh');
|
||||
final a = s.issueToken('alice', '');
|
||||
final b = s.issueToken('bob', '');
|
||||
s.addBytes(a, 100);
|
||||
s.addBytes(b, 50);
|
||||
s.addBytes('ghost', 999);
|
||||
expect(s.tokens[a]!.bytesServed, 100);
|
||||
expect(s.totalBytesServed, 150);
|
||||
});
|
||||
|
||||
test('SessionMap create/get/drop', () {
|
||||
final m = SessionMap();
|
||||
expect(m.get('default'), isNull);
|
||||
final s = m.getOrCreate('default', 'shh');
|
||||
expect(m.get('default'), same(s));
|
||||
expect(m.getOrCreate('default', 'other'), same(s));
|
||||
m.drop('default');
|
||||
expect(m.get('default'), isNull);
|
||||
});
|
||||
});
|
||||
|
||||
group('core welcome + proto', () {
|
||||
test('proto bumped to 4 for readiness + room fan-out', () {
|
||||
expect(RelayConstants.protoVersion, 4);
|
||||
});
|
||||
|
||||
test('welcome round-trips with token + member id', () {
|
||||
const w = WelcomeMessage(token: 'abc', memberId: 'm1', mediaUrl: 'http://h/m');
|
||||
final back = WelcomeMessage.fromJson(Map<String, Object?>.from(w.toJson()));
|
||||
expect(back.token, 'abc');
|
||||
expect(back.memberId, 'm1');
|
||||
expect(back.mediaUrl, 'http://h/m');
|
||||
expect(back.state, isNull);
|
||||
});
|
||||
|
||||
test('welcome rejects wrong type', () {
|
||||
expect(() => WelcomeMessage.fromJson({'t': 'hello'}), throwsA(isA<ProtocolException>()));
|
||||
});
|
||||
|
||||
test('kicked + kick request round-trip', () {
|
||||
const k = KickedMessage(reason: 'idle');
|
||||
final back = KickedMessage.fromJson(Map<String, Object?>.from(k.toJson()));
|
||||
expect(back.reason, 'idle');
|
||||
const r = KickRequest(target: 'abc', reason: 'afk?');
|
||||
final backR = KickRequest.fromJson(Map<String, Object?>.from(r.toJson()));
|
||||
expect(backR.target, 'abc');
|
||||
expect(backR.reason, 'afk?');
|
||||
expect(() => KickedMessage.fromJson({'t': 'err'}), throwsA(isA<ProtocolException>()));
|
||||
expect(() => KickRequest.fromJson({'t': 'err'}), throwsA(isA<ProtocolException>()));
|
||||
});
|
||||
|
||||
test('lastSeen touch + stale helper', () {
|
||||
final s = Session(id: 'default', secret: 'shh');
|
||||
final t = s.issueToken('alice', '');
|
||||
final viewer = s.tokens[t]!;
|
||||
expect(viewer.isStale(const Duration(seconds: 30)), isFalse);
|
||||
viewer.touch(DateTime.utc(2020, 1, 1));
|
||||
expect(viewer.isStale(const Duration(seconds: 30)), isTrue);
|
||||
expect(viewer.isStale(const Duration(seconds: 30), DateTime.utc(2020, 1, 1, 0, 0, 10)), isFalse);
|
||||
});
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user