lzstealth/pulse-signage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Activity

Release 2.6.7

Browse Source
This commit is contained in:
lzstealth
2026-08-08 13:02:31 +01:00
parent b20beb250b
commit 7e46fffc34
41 changed files with 2489 additions and 1290 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/web/lib/background-tasks/tasks-scheduled/font-sweep.js
+32 -39
View File
@@ -18,57 +18,50 @@ function registerFontSweepTask(options) {
const uploadSyncService = options && options.uploadSyncService;
const pushUploadFileToPlayer = uploadSyncService && uploadSyncService.pushUploadFileToPlayer;
const removeUploadFileFromPlayer = uploadSyncService && uploadSyncService.removeUploadFileFromPlayer;
const getPlayerTaskMetadata = uploadSyncService && uploadSyncService.getPlayerTaskMetadata;
const mediaDir = String(options && options.mediaDir || '').trim();
if (!backgroundTaskQueue || typeof pushUploadFileToPlayer !== 'function' || typeof removeUploadFileFromPlayer !== 'function' || !mediaDir) {
throw new Error('registerFontSweepTask requires the font sweep dependencies.');
}
const metadataPromise = typeof getPlayerTaskMetadata === 'function'
? Promise.resolve(getPlayerTaskMetadata())
: Promise.resolve({});
backgroundTaskQueue.registerRecurringTask({
key: TASK.key,
title: TASK.title,
category: TASK.category,
intervalMs: TASK.intervalMs,
metadata: {
mediaDir: mediaDir
},
run: async function () {
const desiredOperations = collectFontLibrarySyncOperations(mediaDir);
const desiredUploadPaths = new Set(desiredOperations.map(function (operation) {
return operation && operation.uploadPath ? operation.uploadPath : '';
}).filter(Boolean));
const currentUploadPaths = await collectFontLibraryDirectoryUploadPaths(mediaDir);
return metadataPromise.then(function (metadata) {
backgroundTaskQueue.registerRecurringTask({
key: TASK.key,
title: TASK.title,
category: TASK.category,
intervalMs: TASK.intervalMs,
metadata: Object.assign({
mediaDir: mediaDir
}, metadata || {}),
run: async function () {
const desiredOperations = collectFontLibrarySyncOperations(mediaDir);
const desiredUploadPaths = new Set(desiredOperations.map(function (operation) {
return operation && operation.uploadPath ? operation.uploadPath : '';
}).filter(Boolean));
const currentUploadPaths = await collectFontLibraryDirectoryUploadPaths(mediaDir);
for (let i = 0; i < desiredOperations.length; i += 1) {
const operation = desiredOperations[i] || {};
const uploadPath = String(operation.uploadPath || '').trim();
if (!uploadPath) {
continue;
}
if (String(operation.type || '').trim().toLowerCase() === 'delete') {
await removeUploadFileFromPlayer(uploadPath, mediaDir);
} else {
await pushUploadFileToPlayer(uploadPath, mediaDir);
}
for (let i = 0; i < desiredOperations.length; i += 1) {
const operation = desiredOperations[i] || {};
const uploadPath = String(operation.uploadPath || '').trim();
if (!uploadPath) {
continue;
}
for (let i = 0; i < currentUploadPaths.length; i += 1) {
const uploadPath = String(currentUploadPaths[i] || '').trim();
if (!uploadPath || desiredUploadPaths.has(uploadPath)) {
continue;
}
if (String(operation.type || '').trim().toLowerCase() === 'delete') {
await removeUploadFileFromPlayer(uploadPath, mediaDir);
} else {
await pushUploadFileToPlayer(uploadPath, mediaDir);
}
}
});
for (let i = 0; i < currentUploadPaths.length; i += 1) {
const uploadPath = String(currentUploadPaths[i] || '').trim();
if (!uploadPath || desiredUploadPaths.has(uploadPath)) {
continue;
}
await removeUploadFileFromPlayer(uploadPath, mediaDir);
}
}
});
}
src/web/lib/background-tasks/tasks-scheduled/onboarding-device-prune.js
+32
View File
@@ -0,0 +1,32 @@
const TASK = {
key: 'onboarding-device-prune',
title: 'Onboarding device prune',
category: 'cleanup',
trigger: 'scheduled recurring task, hourly',
purpose: 'remove stale onboarding device bindings that have been idle for more than one minute.',
taskType: 'recurring-run',
intervalMs: 60 * 60 * 1000
};
function registerOnboardingDevicePruneTask(options) {
const backgroundTaskQueue = options && options.backgroundTaskQueue;
const pool = options && options.pool;
const common = options && options.common;
if (!backgroundTaskQueue || !pool || !common || typeof common.pruneStaleOnboardingDevices !== 'function') {
throw new Error('registerOnboardingDevicePruneTask requires the onboarding prune dependencies.');
}
backgroundTaskQueue.registerRecurringTask({
key: TASK.key,
title: TASK.title,
category: TASK.category,
intervalMs: TASK.intervalMs,
metadata: {},
run: async function () {
await common.pruneStaleOnboardingDevices(pool);
}
});
}
module.exports = { registerOnboardingDevicePruneTask };
src/web/lib/config.js
+6 -6
View File
@@ -5,9 +5,9 @@ function createWebConfig() {
const uploadsDir = path.join(mediaDir, 'uploads');
const thumbnailsDir = path.join(mediaDir, 'thumbnails');
const assetDir = path.join(__dirname, '..', 'public');
const playerInternalBaseUrl = (process.env.PLAYER_INTERNAL_BASE_URL || process.env.PLAYER_BASE_URL || 'http://player:8081').replace(/\/$/, '');
const thinClientBaseUrl = (process.env.THIN_CLIENT_BASE_URL || 'http://player-bridge:8090').replace(/\/$/, '');
const webBaseUrl = (process.env.WEB_BASE_URL || `http://127.0.0.1:${Number(process.env.WEB_PORT || 8080)}`).replace(/\/$/, '');
const playerInternalUrl = (process.env.PLAYER_INTERNAL_URL || process.env.PLAYER_BASE_URL || 'http://player:8081').replace(/\/$/, '');
const bridgeInternalUrl = (process.env.BRIDGE_INTERNAL_URL || 'http://player-bridge:8090').replace(/\/$/, '');
const webInternalUrl = (process.env.WEB_INTERNAL_URL || `http://127.0.0.1:${Number(process.env.WEB_PORT || 8080)}`).replace(/\/$/, '');
const sessionCookieName = 'digital_signage_session';
const sessionMaxAgeDays = Number(process.env.SESSION_MAX_AGE_DAYS || 14);
const sessionMaxAgeMs = (Number.isFinite(sessionMaxAgeDays) && sessionMaxAgeDays > 0 ? sessionMaxAgeDays : 14) * 24 * 60 * 60 * 1000;
@@ -20,9 +20,9 @@ function createWebConfig() {
uploadsDir: uploadsDir,
thumbnailsDir: thumbnailsDir,
assetDir: assetDir,
playerInternalBaseUrl: playerInternalBaseUrl,
thinClientBaseUrl: thinClientBaseUrl,
webBaseUrl: webBaseUrl,
playerInternalUrl: playerInternalUrl,
bridgeInternalUrl: bridgeInternalUrl,
webInternalUrl: webInternalUrl,
sessionCookieName: sessionCookieName,
sessionMaxAgeMs: sessionMaxAgeMs,
dataSourceStartupRefreshStaggerMs: dataSourceStartupRefreshStaggerMs
src/web/lib/media/upload-sync.js
+13
View File
@@ -438,6 +438,9 @@ function createUploadSyncService(options) {
console.warn('Unable to flush pending upload syncs:', error);
});
}, 5000);
if (pendingPlayerUploadSyncFlushTimer && typeof pendingPlayerUploadSyncFlushTimer.unref === 'function') {
pendingPlayerUploadSyncFlushTimer.unref();
}
}
async function pushUploadFileToPlayer(uploadPath, localUploadDir, resolvedPlayerInternalBaseUrl) {
@@ -677,6 +680,11 @@ function createUploadSyncService(options) {
return pendingPlaylistUploadSyncFlushInFlight;
}
if (pendingPlaylistUploadSyncFlushTimer) {
clearTimeout(pendingPlaylistUploadSyncFlushTimer);
pendingPlaylistUploadSyncFlushTimer = null;
}
if (!pendingPlaylistUploadSyncs.size) {
return null;
}
@@ -715,6 +723,11 @@ function createUploadSyncService(options) {
return pendingPlayerUploadSyncFlushInFlight;
}
if (pendingPlayerUploadSyncFlushTimer) {
clearTimeout(pendingPlayerUploadSyncFlushTimer);
pendingPlayerUploadSyncFlushTimer = null;
}
if (!pendingPlayerUploadSyncs.size) {
return null;
}
src/web/lib/player-actions.js
+119 -66
View File
@@ -1,5 +1,5 @@
const { createRequestAuthHeaders } = require('#src/request-auth');
const { fetchPlayerRegistrations, getConfiguredPlayerIdentifier } = require('#src/data/player-registry');
const { getConfiguredPlayerIdentifier } = require('#src/data/player-registry');
function isLocalLikeBaseUrl(value) {
let host = '';
@@ -33,24 +33,10 @@ function isRecentPlayerRegistration(player, staleSeconds) {
return Number.isFinite(lastSeenAtValue) && lastSeenAtValue >= cutoffTime;
}
async function fetchRecentPlayerRegistrations(pool) {
if (!pool || typeof fetchPlayerRegistrations !== 'function') {
return [];
}
try {
const players = await fetchPlayerRegistrations(pool);
return (Array.isArray(players) ? players : []).filter(function (player) {
return isRecentPlayerRegistration(player, 60);
});
} catch (_error) {
return [];
}
}
function createPlayerActionService(options) {
const pool = options && options.pool;
const configuredPlayerInternalBaseUrl = String(options && options.playerInternalBaseUrl || '').replace(/\/$/, '');
const configuredBridgeInternalBaseUrl = String(options && options.bridgeInternalBaseUrl || '').trim().replace(/\/$/, '');
const common = options && options.common;
if (!common) {
@@ -151,6 +137,79 @@ function createPlayerActionService(options) {
});
}
async function fetchScreenConnectionsFromBaseUrl(baseUrl, slug) {
const targetBaseUrl = normalizeBaseUrl(baseUrl);
if (!targetBaseUrl) {
return null;
}
const authHeaders = createRequestAuthHeaders({
method: 'GET',
pathname: `/api/screens/${encodeURIComponent(slug)}/connections`
});
const response = await fetch(`${targetBaseUrl}/api/screens/${encodeURIComponent(slug)}/connections`, {
method: 'GET',
headers: {
Accept: 'application/json',
...authHeaders
}
});
if (!response.ok) {
const errorText = await response.text().catch(function () { return ''; });
const error = new Error(errorText || `Unable to fetch connections for player ${slug}.`);
error.statusCode = response.status;
throw error;
}
return response.json().catch(function () {
return null;
});
}
async function forwardPlayerCommandToDevice(deviceId, commandOrPayload) {
const targetDeviceId = String(deviceId || '').trim();
const targetBridgeBaseUrl = normalizeBaseUrl(configuredBridgeInternalBaseUrl);
if (!targetDeviceId) {
throw new Error('Device ID is required.');
}
if (!targetBridgeBaseUrl) {
throw new Error('Unable to resolve the player bridge base URL.');
}
const payload = typeof commandOrPayload === 'object' && commandOrPayload !== null
? Object.assign({}, commandOrPayload)
: { command: commandOrPayload };
const authHeaders = createRequestAuthHeaders({
method: 'POST',
pathname: `/api/players/${encodeURIComponent(targetDeviceId)}/commands`,
body: payload
});
const response = await fetch(`${targetBridgeBaseUrl}/api/players/${encodeURIComponent(targetDeviceId)}/commands`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Accept: 'application/json',
...authHeaders
},
body: JSON.stringify(payload)
});
if (!response.ok) {
const errorText = await response.text().catch(function () { return ''; });
const error = new Error(errorText || `Unable to send command to player ${targetDeviceId}.`);
error.statusCode = response.status;
throw error;
}
return response.json().catch(function () {
return { ok: true };
});
}
async function forwardPlayerCommand(slug, commandOrPayload, connectionId) {
const resolvedPlayerInternalBaseUrl = await getPlayerInternalBaseUrl();
return forwardPlayerCommandToBaseUrl(resolvedPlayerInternalBaseUrl, slug, commandOrPayload, connectionId);
@@ -190,69 +249,62 @@ function createPlayerActionService(options) {
}
async function getScreenConnections(slug) {
const authHeaders = createRequestAuthHeaders({
method: 'GET',
pathname: `/api/screens/${encodeURIComponent(slug)}/connections`
});
const recentPlayers = await fetchRecentPlayerRegistrations(pool);
const targetBaseUrls = Array.from(new Set((recentPlayers.length ? recentPlayers : []).map(function (player) {
return normalizeBaseUrl(player && player.public_base_url);
}).filter(Boolean)));
if (!targetBaseUrls.length) {
const resolvedPlayerInternalBaseUrl = await getPlayerInternalBaseUrl();
if (resolvedPlayerInternalBaseUrl) {
targetBaseUrls.push(resolvedPlayerInternalBaseUrl);
}
}
const bridgeBaseUrl = normalizeBaseUrl(configuredBridgeInternalBaseUrl);
const playerBaseUrl = await getPlayerInternalBaseUrl();
const targetBaseUrls = Array.from(new Set([bridgeBaseUrl, playerBaseUrl].map(normalizeBaseUrl).filter(Boolean)));
if (!targetBaseUrls.length) {
throw new Error('Unable to resolve the player internal base URL.');
}
const results = await Promise.all(targetBaseUrls.map(async function (baseUrl) {
const response = await fetch(`${baseUrl}/api/screens/${encodeURIComponent(slug)}/connections`, {
method: 'GET',
headers: {
Accept: 'application/json',
...authHeaders
}
});
if (!response.ok) {
return null;
}
return response.json().catch(function () {
return null;
});
const results = await Promise.allSettled(targetBaseUrls.map(function (baseUrl) {
return fetchScreenConnectionsFromBaseUrl(baseUrl, slug);
}));
const successfulResults = results.filter(function (result) {
return result.status === 'fulfilled' && result.value;
}).map(function (result) {
return result.value;
});
if (!successfulResults.length) {
const rejection = results.find(function (result) {
return result.status === 'rejected';
});
throw rejection ? rejection.reason : new Error(`Unable to fetch connections for player ${slug}.`);
}
const mergedConnections = [];
let screen = null;
let degraded = false;
results.forEach(function (result) {
if (!result) {
degraded = true;
return;
}
if (!screen && result.screen) {
screen = result.screen;
}
if (Array.isArray(result.connections)) {
mergedConnections.push.apply(mergedConnections, result.connections);
}
if (result.degraded) {
degraded = true;
}
const seenKeys = new Set();
successfulResults.forEach(function (result) {
const connections = Array.isArray(result && result.connections) ? result.connections : [];
connections.forEach(function (connection) {
const key = [
String(connection && connection.id || '').trim(),
String(connection && connection.clientId || '').trim(),
String(connection && connection.deviceId || '').trim(),
String(connection && connection.playerPublicBaseUrl || '').trim()
].join('|');
if (!key || seenKeys.has(key)) {
return;
}
seenKeys.add(key);
mergedConnections.push(connection);
});
});
return {
screen: screen,
screen: successfulResults.find(function (result) {
return Boolean(result && result.screen);
}) ? successfulResults.find(function (result) {
return Boolean(result && result.screen);
}).screen : null,
screenSlug: slug,
count: mergedConnections.length,
connections: mergedConnections,
degraded: degraded
degraded: results.some(function (result) {
return result.status === 'fulfilled' && Boolean(result.value && result.value.degraded);
})
};
}
@@ -302,6 +354,7 @@ function createPlayerActionService(options) {
forwardAnnouncementRefresh: forwardAnnouncementRefresh,
getScreenConnections: getScreenConnections,
forwardPlayerCommandToBaseUrl: forwardPlayerCommandToBaseUrl,
forwardPlayerCommandToDevice: forwardPlayerCommandToDevice,
getScreenDeleteBlockMessage: getScreenDeleteBlockMessage,
getSlideDeleteBlockMessage: getSlideDeleteBlockMessage,
getTemplateDeleteBlockMessage: getTemplateDeleteBlockMessage,