Files
MultiRoombaRover/server/src/services/roverManagementService/index.js
T
2026-11-16 23:08:30 -05:00

196 lines
8.3 KiB
JavaScript

const { randomUUID } = require('node:crypto');
const io = require('../../globals/io');
const { managementWSS } = require('../../globals/ws');
const { isAdmin } = require('../roleService');
const { sendAlert } = require('../alertService');
const logger = require('../../globals/logger').child('roverManagement');
// Management availability is independent of the control roster: a rover with
// failed hardware must still be configurable. All state here is memory-only.
const rovers = new Map();
const pending = new Map();
const MAX_MESSAGE_BYTES = 1024 * 1024;
function snapshot(record) {
return {
roverId: record.roverId,
config: record.config,
schema: record.schema,
profiles: record.profiles,
mediaStatus: record.mediaStatus,
updateStatus: record.updateStatus,
hostStats: record.hostStats || null,
notices: record.notices,
};
}
function notifyAdmins(event, value) {
for (const socket of io.sockets.sockets.values()) {
if (isAdmin(socket)) socket.emit(event, value);
}
}
function finish(id, error, ack) {
const item = pending.get(id);
if (!item) return;
clearTimeout(item.timer);
pending.delete(id);
if (error) item.reject(error); else item.resolve(ack);
}
function request(roverId, payload) {
const record = rovers.get(String(roverId));
if (!record || record.ws.readyState !== 1) throw new Error('Rover management offline');
const id = randomUUID();
const data = JSON.stringify({ ...payload, id });
if (Buffer.byteLength(data) > MAX_MESSAGE_BYTES) throw new Error('Management request too large');
const result = new Promise((resolve, reject) => {
const timer = setTimeout(() => finish(id, new Error('Rover management acknowledgement timed out')), 30000);
pending.set(id, { roverId: record.roverId, ws: record.ws, resolve, reject, timer });
try {
record.ws.send(data, (error) => { if (error) finish(id, error); });
} catch (error) { finish(id, error); }
});
return { id, result };
}
// Existing reboot/update callers retain their permission gates and commandAck
// UI, but transport and acknowledgement ownership now live on management.
function issueCommand(roverId, payload) {
const { id, result } = request(roverId, payload);
result.then(
() => io.emit('commandAck', { roverId, id, status: 'ok' }),
(error) => io.emit('commandAck', { roverId, id, status: 'error', error: error.message }),
);
return id;
}
managementWSS.on('connection', (ws) => {
let record;
let alive = true;
const helloTimeout = setTimeout(() => ws.terminate(), 10000);
const heartbeat = setInterval(() => {
if (!alive) return ws.terminate();
alive = false;
ws.ping();
}, 15000);
ws.on('pong', () => { alive = true; });
ws.on('error', (error) => logger.warn('Management socket error', error.message));
ws.on('message', (raw) => {
alive = true;
try {
const msg = JSON.parse(raw.toString());
if (msg.type === 'hello' && !record) {
if (typeof msg.name !== 'string' || !msg.name || !msg.config || !msg.schema) throw new Error('Invalid management hello');
clearTimeout(helloTimeout);
const previous = rovers.get(msg.name);
record = { roverId: msg.name, ws, config: msg.config, schema: msg.schema, profiles: msg.profiles, mediaStatus: msg.mediaStatus || {}, updateStatus: msg.updateStatus || null, notices: [] };
rovers.set(record.roverId, record);
previous?.ws.close(1000, 'Replaced by new connection');
notifyAdmins('roverManagement:changed', snapshot(record));
return;
}
if (!record || rovers.get(record.roverId) !== record) return;
if (msg.type === 'ack') {
if (pending.get(msg.id)?.ws !== ws) return;
finish(msg.id, msg.status === 'ok' ? null : new Error(msg.error || 'Management action failed'), msg);
} else if (msg.type === 'updateStatus') {
record.updateStatus = msg.status;
notifyAdmins('roverManagement:updateStatus', { roverId: record.roverId, status: msg.status });
} else if (msg.type === 'hostStats') {
record.hostStats = msg;
require('../roverManager').handleHostStats(record.roverId, msg);
notifyAdmins('roverManagement:hostStats', { roverId: record.roverId, ...msg });
} else if (msg.type === 'event') {
if (msg.event === 'media.status') record.mediaStatus[msg.data.category] = msg.data.message;
record.notices.push(msg);
if (record.notices.length > 100) record.notices.shift();
notifyAdmins('roverManagement:event', { roverId: record.roverId, ...msg });
if (!msg.event?.startsWith('media.')) sendAlert({ color: '#00bcd4', title: record.roverId, message: msg.data?.message || msg.event });
}
} catch (error) {
logger.warn('Invalid management message', error.message);
ws.close(1008, 'Invalid management message');
}
});
ws.on('close', () => {
clearTimeout(helloTimeout);
clearInterval(heartbeat);
for (const [id, item] of pending) {
if (item.ws === ws) finish(id, new Error('Rover management disconnected before acknowledgement'));
}
if (record && rovers.get(record.roverId) === record) {
rovers.delete(record.roverId);
notifyAdmins('roverManagement:offline', { roverId: record.roverId });
}
});
});
io.on('connection', (socket) => {
const bind = (event, handler) => socket.on(event, async (payload = {}, callback) => {
const reply = typeof callback === 'function' ? callback : () => {};
try {
if (!isAdmin(socket)) throw new Error('Not authorized');
reply({ success: true, ...await handler(payload) });
} catch (error) { reply({ error: error.message }); }
});
bind('roverManagement:list', () => ({ rovers: [...rovers.values()].map(snapshot) }));
bind('roverManagement:get', ({ roverId }) => {
const record = rovers.get(String(roverId));
if (!record) throw new Error('Rover management offline');
return snapshot(record);
});
bind('roverManagement:save', async ({ roverId, config }) => {
const { id, result } = request(roverId, { type: 'config.set', config });
await result;
// The next hello is authoritative; do not replace cached state optimistically.
return { id };
});
bind('roverManagement:applyField', async ({ path, value }) => {
if (!Array.isArray(path) || path.length === 0 || value === undefined
|| path.some((key) => typeof key !== 'string' || !key
|| ['__proto__', 'constructor', 'prototype'].includes(key))) {
throw new Error('A nonempty field path and value are required');
}
// Snapshot the connected fleet before any save restarts a rover. Each
// object is independent; never copy one rover's unrelated settings across.
const targets = [...rovers.values()];
const results = await Promise.all(targets.map(async (record) => {
try {
const config = structuredClone(record.config);
let parent = config;
for (const key of path.slice(0, -1)) {
if (!parent || typeof parent !== 'object' || Array.isArray(parent)
|| !Object.hasOwn(parent, key)) throw new Error('Field does not exist on this rover');
parent = parent[key];
}
const key = path.at(-1);
if (!parent || typeof parent !== 'object' || Array.isArray(parent)
|| !Object.hasOwn(parent, key)) throw new Error('Field does not exist on this rover');
parent[key] = structuredClone(value);
// Do not submit a stale snapshot to a replacement connection.
if (rovers.get(record.roverId) !== record) throw new Error('Rover connection changed');
const { id, result } = request(record.roverId, { type: 'config.set', config });
await result;
return { roverId: record.roverId, success: true, id };
} catch (error) {
return { roverId: record.roverId, success: false, error: error.message };
}
}));
return { results };
});
bind('roverManagement:saveProfile', async ({ roverId, category, profile }) => {
const { id, result } = request(roverId, { type: 'profile.set', category, profile });
await result;
return { id };
});
bind('roverManagement:command', async ({ roverId, type, reboot, media }) => {
if (!['reboot', 'update', 'media'].includes(type)) throw new Error('Unsupported management command');
const { id, result } = request(roverId, { type, reboot, media });
await result;
return { id };
});
});
module.exports = { rovers, request, issueCommand };