Usenet streaming with a WebDAV server and a SABnzbd-compatible API
C#
import WebSocket, { WebSocketServer } from 'ws';
import { isAuthenticated } from "../app/auth/authentication.server";
import type { IncomingMessage } from 'http';
function initializeWebsocketServer(wss: WebSocketServer) {
// keep track of socket subscriptions
const websockets = new Map<WebSocket, any>();
const subscriptions = new Map<string, Set<WebSocket>>();
const lastMessage = new Map<string, string>();
initializeWebsocketClient(subscriptions, lastMessage);
// authenticate new websocket sessions
wss.on("connection", async (ws: WebSocket, request: IncomingMessage) => {
try {
// ensure user is logged in
if (!await isAuthenticated(request)) {
ws.close(1008, "Unauthorized");
return;
}
// handle topic subscription
ws.onmessage = (event: WebSocket.MessageEvent) => {
try {
var topics = JSON.parse(event.data.toString());
websockets.set(ws, topics);
for (const topic in topics) {
var topicSubscriptions = subscriptions.get(topic);
if (topicSubscriptions) topicSubscriptions.add(ws);
else subscriptions.set(topic, new Set<WebSocket>([ws]));
if (topics[topic] === 'state') {
var messageToSend = lastMessage.get(topic);
if (messageToSend) ws.send(messageToSend);
}
}
} catch {
ws.close(1003, "Could not process topic subscription. If recently updated, try refreshing the page.");
}
};
// unsubscribe from topics
ws.onclose = () => {
var topics = websockets.get(ws);
if (topics) {
websockets.delete(ws);
for (const topic in topics) {
var topicSubscriptions = subscriptions.get(topic);
if (topicSubscriptions) topicSubscriptions.delete(ws);
}
}
};
} catch (error) {
console.error("Error authenticating websocket session:", error);
ws.close(1011, "Internal server error");
return;
}
});
}
export function initializeWebsocketClient(subscriptions: Map<string, Set<WebSocket>>, lastMessage: Map<string, string>) {
let reconnectRetryDelay = 1000;
let reconnectTimeout: NodeJS.Timeout | null = null;
const url = getBackendWebsocketUrl();
function connect() {
const socket = new WebSocket(url);
socket.on('error', (error: Error) => {
console.error('WebSocket error:', error.message);
});
socket.onopen = () => {
console.info("WebSocket connected");
if (reconnectTimeout) {
clearTimeout(reconnectTimeout);
reconnectTimeout = null;
}
socket.send(Buffer.from(process.env.FRONTEND_BACKEND_API_KEY!, "utf-8"), { binary: false });
};
socket.onmessage = (event: WebSocket.MessageEvent) => {
var rawMessage = event.data.toString();
var topicMessage = JSON.parse(rawMessage);
var [topic, message] = [topicMessage.Topic, topicMessage.Message];
if (!topic || !message) return;
lastMessage.set(topic, rawMessage);
var subscribed = subscriptions.get(topic) || [];
subscribed.forEach(client => {
if (client.readyState === client.OPEN) {
client.send(rawMessage);
}
});
};
socket.onclose = (event: WebSocket.CloseEvent) => {
console.info(`WebSocket closed (code: ${event.code}, reason: ${event.reason})`);
scheduleReconnect();
};
}
function scheduleReconnect() {
if (reconnectTimeout) clearTimeout(reconnectTimeout);
reconnectTimeout = setTimeout(() => {
console.info(`WebSocket reconnecting...`);
connect();
}, reconnectRetryDelay);
}
connect();
}
function getBackendWebsocketUrl() {
const host = process.env.BACKEND_URL!;
return `${host.replace(/\/$/, '')}/ws`.replace(/^http/, 'ws');
}
export const websocketServer = {
initialize: initializeWebsocketServer
}