Gronod
268238215e
Fast poll (every cycle): SABnzbd, Sonarr/Radarr queue + history, qBittorrent — all lightweight with no include* params. Slow cache (5 min TTL): Sonarr series, Radarr movies, tags — fetched only when cache expires. These rarely change. This eliminates the 2s+ includeSeries/includeMovie joins from every poll cycle. First poll is still slow (cold cache), but subsequent polls should complete in <500ms.
259 lines
10 KiB
JavaScript
259 lines
10 KiB
JavaScript
const axios = require('axios');
|
|
const cache = require('./cache');
|
|
const { getTorrents } = require('./qbittorrent');
|
|
const {
|
|
getSABnzbdInstances,
|
|
getSonarrInstances,
|
|
getRadarrInstances
|
|
} = require('./config');
|
|
|
|
const rawPollInterval = (process.env.POLL_INTERVAL || '').toLowerCase();
|
|
const POLL_INTERVAL = (rawPollInterval === 'off' || rawPollInterval === 'false' || rawPollInterval === 'disabled')
|
|
? 0
|
|
: (parseInt(process.env.POLL_INTERVAL, 10) || 5000);
|
|
const POLLING_ENABLED = POLL_INTERVAL > 0;
|
|
|
|
let polling = false;
|
|
let lastPollTimings = null;
|
|
const SLOW_CACHE_TTL = 5 * 60 * 1000; // 5 minutes for series/movie library
|
|
|
|
// Timed fetch helper: runs a fetch and records how long it took
|
|
async function timed(label, fn) {
|
|
const t0 = Date.now();
|
|
const result = await fn();
|
|
return { label, result, ms: Date.now() - t0 };
|
|
}
|
|
|
|
async function pollAllServices() {
|
|
if (polling) {
|
|
console.log('[Poller] Previous poll still running, skipping');
|
|
return;
|
|
}
|
|
polling = true;
|
|
const start = Date.now();
|
|
|
|
try {
|
|
const sabInstances = getSABnzbdInstances();
|
|
const sonarrInstances = getSonarrInstances();
|
|
const radarrInstances = getRadarrInstances();
|
|
|
|
// Slow-changing data: series/movie libraries + tags (only fetch when cache expired)
|
|
const slowTasks = [];
|
|
if (!cache.get('poll:sonarr-series')) {
|
|
slowTasks.push(
|
|
timed('Sonarr Series', () => Promise.all(sonarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/series`, {
|
|
headers: { 'X-Api-Key': inst.apiKey }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Sonarr ${inst.id} series error:`, err.message);
|
|
return { instance: inst.id, data: [] };
|
|
})
|
|
)))
|
|
);
|
|
}
|
|
if (!cache.get('poll:radarr-movies')) {
|
|
slowTasks.push(
|
|
timed('Radarr Movies', () => Promise.all(radarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/movie`, {
|
|
headers: { 'X-Api-Key': inst.apiKey }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Radarr ${inst.id} movies error:`, err.message);
|
|
return { instance: inst.id, data: [] };
|
|
})
|
|
)))
|
|
);
|
|
}
|
|
if (!cache.get('poll:sonarr-tags')) {
|
|
slowTasks.push(
|
|
timed('Sonarr Tags', () => Promise.all(sonarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/tag`, {
|
|
headers: { 'X-Api-Key': inst.apiKey }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Sonarr ${inst.id} tags error:`, err.message);
|
|
return { instance: inst.id, data: [] };
|
|
})
|
|
)))
|
|
);
|
|
}
|
|
if (!cache.get('poll:radarr-tags')) {
|
|
slowTasks.push(
|
|
timed('Radarr Tags', () => Promise.all(radarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/tag`, {
|
|
headers: { 'X-Api-Key': inst.apiKey }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Radarr ${inst.id} tags error:`, err.message);
|
|
return { instance: inst.id, data: [] };
|
|
})
|
|
)))
|
|
);
|
|
}
|
|
|
|
// Fast-changing data: queues, history, torrents (every poll)
|
|
const fastTasks = [
|
|
timed('SABnzbd Queue', () => Promise.all(sabInstances.map(inst =>
|
|
axios.get(`${inst.url}/api`, {
|
|
params: { mode: 'queue', apikey: inst.apiKey, output: 'json' }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] SABnzbd ${inst.id} queue error:`, err.message);
|
|
return { instance: inst.id, data: { queue: { slots: [] } } };
|
|
})
|
|
))),
|
|
timed('SABnzbd History', () => Promise.all(sabInstances.map(inst =>
|
|
axios.get(`${inst.url}/api`, {
|
|
params: { mode: 'history', apikey: inst.apiKey, output: 'json', limit: 10 }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] SABnzbd ${inst.id} history error:`, err.message);
|
|
return { instance: inst.id, data: { history: { slots: [] } } };
|
|
})
|
|
))),
|
|
timed('Sonarr Queue', () => Promise.all(sonarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/queue`, {
|
|
headers: { 'X-Api-Key': inst.apiKey }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Sonarr ${inst.id} queue error:`, err.message);
|
|
return { instance: inst.id, data: { records: [] } };
|
|
})
|
|
))),
|
|
timed('Sonarr History', () => Promise.all(sonarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/history`, {
|
|
headers: { 'X-Api-Key': inst.apiKey },
|
|
params: { pageSize: 10 }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Sonarr ${inst.id} history error:`, err.message);
|
|
return { instance: inst.id, data: { records: [] } };
|
|
})
|
|
))),
|
|
timed('Radarr Queue', () => Promise.all(radarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/queue`, {
|
|
headers: { 'X-Api-Key': inst.apiKey }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Radarr ${inst.id} queue error:`, err.message);
|
|
return { instance: inst.id, data: { records: [] } };
|
|
})
|
|
))),
|
|
timed('Radarr History', () => Promise.all(radarrInstances.map(inst =>
|
|
axios.get(`${inst.url}/api/v3/history`, {
|
|
headers: { 'X-Api-Key': inst.apiKey },
|
|
params: { pageSize: 10 }
|
|
}).then(res => ({ instance: inst.id, data: res.data })).catch(err => {
|
|
console.error(`[Poller] Radarr ${inst.id} history error:`, err.message);
|
|
return { instance: inst.id, data: { records: [] } };
|
|
})
|
|
))),
|
|
timed('qBittorrent', () => getTorrents().catch(err => {
|
|
console.error(`[Poller] qBittorrent error:`, err.message);
|
|
return [];
|
|
}))
|
|
];
|
|
|
|
// Run slow + fast in parallel
|
|
const allResults = await Promise.all([...slowTasks, ...fastTasks]);
|
|
const slowResults = allResults.slice(0, slowTasks.length);
|
|
const fastResults = allResults.slice(slowTasks.length);
|
|
|
|
const [
|
|
{ result: sabQueues }, { result: sabHistories },
|
|
{ result: sonarrQueues }, { result: sonarrHistories },
|
|
{ result: radarrQueues }, { result: radarrHistories },
|
|
{ result: qbittorrentTorrents }
|
|
] = fastResults;
|
|
|
|
// Store per-task timings
|
|
const totalMs = Date.now() - start;
|
|
lastPollTimings = {
|
|
totalMs,
|
|
timestamp: new Date().toISOString(),
|
|
tasks: allResults.map(r => ({ label: r.label, ms: r.ms }))
|
|
};
|
|
|
|
// When polling is active, TTL is 3x interval to avoid gaps between polls
|
|
// When polling is disabled (on-demand), use 30s so data refreshes on next request after expiry
|
|
const cacheTTL = POLLING_ENABLED ? POLL_INTERVAL * 3 : 30000;
|
|
|
|
// Store slow-changing data (only if fetched this cycle)
|
|
for (const sr of slowResults) {
|
|
if (sr.label === 'Sonarr Series') {
|
|
cache.set('poll:sonarr-series', sr.result.flatMap(s => {
|
|
const inst = sonarrInstances.find(i => i.id === s.instance);
|
|
return (s.data || []).map(item => ({ ...item, _instanceUrl: inst ? inst.url : null }));
|
|
}), SLOW_CACHE_TTL);
|
|
} else if (sr.label === 'Radarr Movies') {
|
|
cache.set('poll:radarr-movies', sr.result.flatMap(m => {
|
|
const inst = radarrInstances.find(i => i.id === m.instance);
|
|
return (m.data || []).map(item => ({ ...item, _instanceUrl: inst ? inst.url : null }));
|
|
}), SLOW_CACHE_TTL);
|
|
} else if (sr.label === 'Sonarr Tags') {
|
|
cache.set('poll:sonarr-tags', sr.result, SLOW_CACHE_TTL);
|
|
} else if (sr.label === 'Radarr Tags') {
|
|
cache.set('poll:radarr-tags', sr.result.flatMap(t => t.data || []), SLOW_CACHE_TTL);
|
|
}
|
|
}
|
|
|
|
// SABnzbd
|
|
const firstSabQueue = sabQueues[0] && sabQueues[0].data && sabQueues[0].data.queue;
|
|
cache.set('poll:sab-queue', {
|
|
slots: sabQueues.flatMap(q => (q.data.queue && q.data.queue.slots) || []),
|
|
status: firstSabQueue && firstSabQueue.status,
|
|
speed: firstSabQueue && firstSabQueue.speed,
|
|
kbpersec: firstSabQueue && firstSabQueue.kbpersec
|
|
}, cacheTTL);
|
|
|
|
cache.set('poll:sab-history', {
|
|
slots: sabHistories.flatMap(h => (h.data.history && h.data.history.slots) || [])
|
|
}, cacheTTL);
|
|
|
|
// Sonarr (lightweight — no embedded series/movie objects)
|
|
cache.set('poll:sonarr-queue', {
|
|
records: sonarrQueues.flatMap(q => q.data.records || [])
|
|
}, cacheTTL);
|
|
cache.set('poll:sonarr-history', {
|
|
records: sonarrHistories.flatMap(h => h.data.records || [])
|
|
}, cacheTTL);
|
|
|
|
// Radarr (lightweight — no embedded series/movie objects)
|
|
cache.set('poll:radarr-queue', {
|
|
records: radarrQueues.flatMap(q => q.data.records || [])
|
|
}, cacheTTL);
|
|
cache.set('poll:radarr-history', {
|
|
records: radarrHistories.flatMap(h => h.data.records || [])
|
|
}, cacheTTL);
|
|
|
|
// qBittorrent
|
|
cache.set('poll:qbittorrent', qbittorrentTorrents, cacheTTL);
|
|
|
|
const elapsed = Date.now() - start;
|
|
console.log(`[Poller] Poll complete in ${elapsed}ms`);
|
|
} catch (err) {
|
|
console.error(`[Poller] Poll error:`, err.message);
|
|
} finally {
|
|
polling = false;
|
|
}
|
|
}
|
|
|
|
let intervalHandle = null;
|
|
|
|
function startPoller() {
|
|
if (!POLLING_ENABLED) {
|
|
console.log(`[Poller] Background polling disabled (POLL_INTERVAL=${process.env.POLL_INTERVAL || 'not set'}). Data will be fetched on-demand.`);
|
|
return;
|
|
}
|
|
console.log(`[Poller] Starting background poller (interval: ${POLL_INTERVAL}ms)`);
|
|
// Run immediately, then on interval
|
|
pollAllServices();
|
|
intervalHandle = setInterval(pollAllServices, POLL_INTERVAL);
|
|
}
|
|
|
|
function stopPoller() {
|
|
if (intervalHandle) {
|
|
clearInterval(intervalHandle);
|
|
intervalHandle = null;
|
|
console.log('[Poller] Stopped');
|
|
}
|
|
}
|
|
|
|
function getLastPollTimings() {
|
|
return lastPollTimings;
|
|
}
|
|
|
|
module.exports = { startPoller, stopPoller, pollAllServices, getLastPollTimings, POLL_INTERVAL, POLLING_ENABLED };
|