756 lines
28 KiB
JavaScript
756 lines
28 KiB
JavaScript
/**
|
|
* Разные утилитарные роуты (auto-urls, history, s3 meta, availability, etc.)
|
|
*/
|
|
|
|
const {
|
|
writeS3TextObject,
|
|
writeS3JsonObject,
|
|
readS3TextObject,
|
|
headMeta,
|
|
listBlobVersionsForKey,
|
|
rollbackBlobVersion,
|
|
} = require('../services/s3Service');
|
|
const evobgpClient = require('../services/evobgpClient');
|
|
const filterRulesStorage = require('../services/filterRulesStorage');
|
|
const { sendError, sendOk } = require('../middleware/errorHandler');
|
|
const { resourceToKey, toIso } = require('../utils/helpers');
|
|
const validators = require('../lib/validators');
|
|
const net = require('net');
|
|
const http = require('http');
|
|
const https = require('https');
|
|
const { URL } = require('url');
|
|
|
|
// GET /api/s3/last-modified
|
|
async function getS3LastModified(req, res) {
|
|
try {
|
|
const keys = [
|
|
{ name: 'domainsNew', key: 'bgp_data/domains_community.txt' },
|
|
{ name: 'asns', key: 'bgp_data/asns.txt' },
|
|
{ name: 'servers', key: 'servers.json' },
|
|
{ name: 'filters', key: null },
|
|
{ name: 'ipRanges', key: 'bgp_data/ips.txt' },
|
|
{ name: 'uiSettings', key: 'bgp_data/rt_ui_settings.json' }
|
|
];
|
|
|
|
const out = {};
|
|
for (const k of keys) {
|
|
if (k.name === 'filters') {
|
|
try {
|
|
const head = filterRulesStorage.headMetaForScope('global');
|
|
out.filters = {
|
|
etag: head.etag,
|
|
lastModified: head.lastModified,
|
|
contentLength: head.contentLength,
|
|
};
|
|
} catch {
|
|
out.filters = null;
|
|
}
|
|
continue;
|
|
}
|
|
if (['domainsNew', 'asns', 'ipRanges'].includes(k.name) && evobgpClient.isConfigured()) {
|
|
try {
|
|
await evobgpClient.fetchRouterListsCatalog();
|
|
out[k.name] = { etag: null, lastModified: new Date().toISOString(), contentLength: null };
|
|
} catch {
|
|
out[k.name] = null;
|
|
}
|
|
continue;
|
|
}
|
|
out[k.name] = await headMeta(k.key).catch(() => null);
|
|
}
|
|
|
|
res.json(out);
|
|
} catch (error) {
|
|
console.error('Error fetching last modified dates:', error);
|
|
return sendError(res, 500, 'Error fetching last modified dates', 'E_STORAGE');
|
|
}
|
|
}
|
|
|
|
const EVOBGP_ONLY_HISTORY_RESOURCES = new Set(['domains-new', 'asns', 'ip-ranges', 'filters']);
|
|
|
|
// GET /api/history/:resource
|
|
async function getHistory(req, res) {
|
|
const { resource } = req.params;
|
|
const { countOnly, format } = req.query || {};
|
|
if (EVOBGP_ONLY_HISTORY_RESOURCES.has(resource)) {
|
|
const note =
|
|
resource === 'filters'
|
|
? 'Фильтры в SQL-таблице app_filter_rules; локальной истории отката через этот API нет'
|
|
: 'Версии хранятся в EvoBGP, локальной истории нет';
|
|
if (countOnly === 'true') {
|
|
return res.json(format === 'std' ? { items: [], total: 0, meta: { noBlobHistory: true } } : { total: 0 });
|
|
}
|
|
return res.json(
|
|
format === 'std'
|
|
? { items: [], total: 0, meta: { noBlobHistory: true, note } }
|
|
: { items: [], total: 0 },
|
|
);
|
|
}
|
|
|
|
const key = resourceToKey(resource);
|
|
|
|
if (!key) return sendError(res, 400, 'Unknown resource', 'E_RESOURCE');
|
|
|
|
try {
|
|
const rows = listBlobVersionsForKey(key, 50);
|
|
const versionsAll = rows.map((r) => ({
|
|
id: r.id,
|
|
object_key: r.object_key,
|
|
byte_size: r.byte_size,
|
|
etag: r.etag,
|
|
created_at: r.created_at,
|
|
}));
|
|
|
|
if (countOnly === 'true') {
|
|
const total = versionsAll.length;
|
|
return res.json(format === 'std' ? { items: [], total, meta: {} } : { total });
|
|
}
|
|
|
|
const versions = versionsAll.slice(0, 10).map((v, idx) => ({
|
|
versionId: String(v.id),
|
|
isLatest: idx === 0,
|
|
lastModified: toIso(v.created_at),
|
|
size: v.byte_size,
|
|
etag: v.etag,
|
|
}));
|
|
|
|
return res.json(format === 'std' ? { items: versions, total: versionsAll.length, meta: {} } : { items: versions });
|
|
} catch (e) {
|
|
console.error('history error', e);
|
|
return sendError(res, 500, 'Error reading history', 'E_STORAGE', { error: String(e?.message || e) });
|
|
}
|
|
}
|
|
|
|
// POST /api/history/:resource/rollback
|
|
async function postRollback(req, res) {
|
|
const { resource } = req.params;
|
|
const { versionId } = req.body || {};
|
|
if (EVOBGP_ONLY_HISTORY_RESOURCES.has(resource)) {
|
|
const msg =
|
|
resource === 'filters'
|
|
? 'Откат версий для фильтров не поддерживается (данные в SQL, не в blob_versions)'
|
|
: 'Откат версий для этого справочника не поддерживается (данные в EvoBGP)';
|
|
return sendError(res, 400, msg, resource === 'filters' ? 'E_HISTORY_FILTERS_SQL' : 'E_HISTORY_EV');
|
|
}
|
|
|
|
const key = resourceToKey(resource);
|
|
|
|
if (!key || !versionId) {
|
|
return sendError(res, 400, 'Bad request', 'E_BAD_REQUEST');
|
|
}
|
|
|
|
try {
|
|
rollbackBlobVersion(key, versionId);
|
|
const meta = await headMeta(key);
|
|
return sendOk(res, meta);
|
|
} catch (e) {
|
|
console.error('rollback error', e);
|
|
return sendError(res, 500, 'Error rollback', 'E_STORAGE', { error: String(e?.message || e) });
|
|
}
|
|
}
|
|
|
|
// GET /api/auto-urls
|
|
async function getAutoUrls(req, res) {
|
|
try {
|
|
if (!evobgpClient.isConfigured()) {
|
|
return sendError(res, 503, 'EvoBGP не настроен', 'E_EVOBGP_NOT_CONFIGURED');
|
|
}
|
|
const rows = await evobgpClient.fetchAutoUrlsData();
|
|
res.json(rows);
|
|
} catch (error) {
|
|
console.error(error);
|
|
return sendError(res, 500, 'Error reading auto URLs', 'E_EVOBGP');
|
|
}
|
|
}
|
|
|
|
// POST /api/auto-urls
|
|
async function postAutoUrls(req, res) {
|
|
const { urls } = req.body;
|
|
if (!Array.isArray(urls)) {
|
|
return sendError(res, 400, 'urls must be an array', 'E_BAD_REQUEST');
|
|
}
|
|
try {
|
|
if (!evobgpClient.isConfigured()) {
|
|
return sendError(res, 503, 'EvoBGP не настроен', 'E_EVOBGP_NOT_CONFIGURED');
|
|
}
|
|
await evobgpClient.saveAutoUrlsData(urls);
|
|
return sendOk(res, { etag: null, lastModified: new Date().toISOString(), contentLength: null });
|
|
} catch (error) {
|
|
console.error(error);
|
|
return sendError(res, 500, 'Error writing auto URLs', 'E_EVOBGP');
|
|
}
|
|
}
|
|
|
|
// POST /api/auto-urls/process
|
|
async function processAutoUrls(req, res) {
|
|
try {
|
|
if (!evobgpClient.isConfigured()) {
|
|
return sendError(res, 503, 'EvoBGP не настроен', 'E_EVOBGP_NOT_CONFIGURED');
|
|
}
|
|
|
|
const urls = await evobgpClient.fetchAutoUrlsData();
|
|
if (urls.length === 0) {
|
|
return sendError(res, 400, 'No URLs to process', 'E_BAD_REQUEST');
|
|
}
|
|
|
|
const currentIps = await evobgpClient.fetchIpRangesData();
|
|
const currentDomains = await evobgpClient.fetchDomainsData();
|
|
|
|
// Обработка URL
|
|
const newIps = [];
|
|
const newDomains = [];
|
|
|
|
for (const urlData of urls) {
|
|
try {
|
|
const url = String(urlData.url || '').trim();
|
|
const community = String(urlData.community || '').trim();
|
|
if (!url || !community) continue;
|
|
|
|
const content = await new Promise((resolve, reject) => {
|
|
const protocol = url.startsWith('https:') ? https : http;
|
|
const req = protocol.get(url, (r) => {
|
|
let data = '';
|
|
r.on('data', (chunk) => { data += chunk; });
|
|
r.on('end', () => resolve(data));
|
|
});
|
|
req.on('error', reject);
|
|
req.setTimeout(15000, () => req.destroy());
|
|
});
|
|
|
|
const lines = content.split('\n');
|
|
for (const raw of lines) {
|
|
const line = String(raw || '').trim();
|
|
if (!line || line.startsWith('#') || line.startsWith('//')) continue;
|
|
const token = line.split(/\s+/)[0]?.trim();
|
|
if (!token) continue;
|
|
|
|
if (validators.isValidCIDRv4(token) || validators.isValidCIDRv6(token)) {
|
|
newIps.push({ ipRange: token, community });
|
|
} else if (validators.isValidIPv4(token)) {
|
|
newIps.push({ ipRange: `${token}/32`, community });
|
|
} else if (validators.isValidDomain(token)) {
|
|
newDomains.push({ domain: token.toLowerCase(), community });
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error processing URL ${urlData.url}:`, error);
|
|
}
|
|
}
|
|
|
|
// Объединение и дедупликация
|
|
const existingIpRanges = new Set(currentIps.map(i => i.ipRange));
|
|
const uniqueNewIps = newIps.filter(i => !existingIpRanges.has(i.ipRange));
|
|
const allIps = [...currentIps, ...uniqueNewIps];
|
|
|
|
const existingDomains = new Set(currentDomains.map(d => d.domain));
|
|
const uniqueNewDomains = newDomains.filter(d => !existingDomains.has(d.domain));
|
|
const allDomains = [...currentDomains, ...uniqueNewDomains];
|
|
|
|
await evobgpClient.saveIpRangesData(allIps, currentIps);
|
|
await evobgpClient.saveDomainsData(allDomains, currentDomains);
|
|
|
|
const msg = `Обработано ${urls.length} URL, добавлено ${uniqueNewIps.length} IP и ${uniqueNewDomains.length} доменов`;
|
|
return res.json({
|
|
success: true,
|
|
message: msg,
|
|
processedUrls: urls.length,
|
|
newIpsCount: uniqueNewIps.length,
|
|
newDomainsCount: uniqueNewDomains.length,
|
|
totalIpsCount: allIps.length,
|
|
totalDomainsCount: allDomains.length
|
|
});
|
|
} catch (error) {
|
|
console.error('Error processing auto URLs:', error);
|
|
return sendError(res, 500, 'Error processing auto URLs', 'E_EVOBGP');
|
|
}
|
|
}
|
|
|
|
// GET /api/servers/availability
|
|
const availabilityCache = { at: 0, data: null };
|
|
|
|
function tcpCheck(host, port, timeoutMs) {
|
|
return new Promise((resolve) => {
|
|
const socket = new net.Socket();
|
|
let settled = false;
|
|
const settle = (ok) => {
|
|
if (!settled) {
|
|
settled = true;
|
|
try { socket.destroy(); } catch {}
|
|
resolve(ok);
|
|
}
|
|
};
|
|
socket.setTimeout(timeoutMs, () => settle(false));
|
|
socket.once('error', () => settle(false));
|
|
socket.connect(port, host, () => settle(true));
|
|
});
|
|
}
|
|
|
|
/** Измерить RTT (мс) до host:port по TCP. Возвращает число мс или null при ошибке/таймауте. */
|
|
function measureTcpRtt(host, port = 443, timeoutMs = 6000) {
|
|
return new Promise((resolve) => {
|
|
const start = Date.now();
|
|
const socket = new net.Socket();
|
|
let settled = false;
|
|
const settle = (ms) => {
|
|
if (!settled) {
|
|
settled = true;
|
|
try { socket.destroy(); } catch (_) {}
|
|
resolve(ms);
|
|
}
|
|
};
|
|
socket.setTimeout(timeoutMs, () => settle(null));
|
|
socket.once('error', () => settle(null));
|
|
socket.connect(port, host, () => {
|
|
const ms = Math.round(Date.now() - start);
|
|
settle(ms);
|
|
});
|
|
});
|
|
}
|
|
|
|
/** Список целей для пинга по умолчанию (id, name, host, port, icon, color) */
|
|
const PING_SERVICES_DEFAULT = [
|
|
{ id: 'google', name: 'Google', host: '8.8.8.8', port: 443, icon: 'IconBrandGoogle', color: 'blue' },
|
|
{ id: 'cloudflare', name: 'Cloudflare', host: '1.1.1.1', port: 443, icon: 'IconBrandCloudflare', color: 'orange' },
|
|
{ id: 'yandex', name: 'Yandex', host: 'ya.ru', port: 443, icon: 'IconBrandYandex', color: 'red' },
|
|
{ id: 'instagram', name: 'Instagram', host: 'instagram.com', port: 443, icon: 'IconBrandInstagram', color: 'pink' },
|
|
];
|
|
|
|
function getPingServicesListFromSettings(uiSettings) {
|
|
const raw = uiSettings.pingServicesList;
|
|
if (Array.isArray(raw) && raw.length > 0) {
|
|
return raw.map((s) => ({
|
|
id: String(s?.id ?? '').trim() || `svc-${Math.random().toString(36).slice(2, 9)}`,
|
|
name: String(s?.name ?? '').trim() || 'Сервис',
|
|
host: String(s?.host ?? '').trim() || '0.0.0.0',
|
|
port: Math.max(1, parseInt(s?.port, 10) || 443),
|
|
icon: typeof s?.icon === 'string' ? s.icon : 'IconWorld',
|
|
color: typeof s?.color === 'string' ? s.color : 'primary',
|
|
})).filter((s) => s.host !== '0.0.0.0');
|
|
}
|
|
return PING_SERVICES_DEFAULT;
|
|
}
|
|
|
|
/** Загрузить UI-настройки из S3 (для pingServicesSource и др.) */
|
|
async function loadUiSettingsSync() {
|
|
try {
|
|
const data = await readS3TextObject('bgp_data/rt_ui_settings.json');
|
|
const parsed = JSON.parse(data.body || '{}');
|
|
return parsed && typeof parsed === 'object' ? parsed : {};
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
const PING_SERVICES_CACHE_KEY_PREFIX = 'ping-services/cache_';
|
|
const PING_SERVICES_HISTORY_KEY_PREFIX = 'ping-services/history_';
|
|
const PING_HISTORY_MAX = 30;
|
|
|
|
function pingServicesStorageSuffix(viaRouter, serverId, gatewayIp) {
|
|
return (viaRouter ? 'router' : 'web') + '_' + String(serverId || '').replace(/[^a-zA-Z0-9.-]/g, '_') + '_' + String(gatewayIp || '').replace(/[^a-zA-Z0-9.]/g, '_');
|
|
}
|
|
|
|
/**
|
|
* Прочитать историю замеров пингов из S3. Формат: { byId: { [serviceId]: number[] } }.
|
|
*/
|
|
async function readPingServicesHistory(suffix) {
|
|
const key = PING_SERVICES_HISTORY_KEY_PREFIX + suffix;
|
|
try {
|
|
const raw = await readS3TextObject(key).catch(() => null);
|
|
if (!raw?.body) return {};
|
|
const parsed = JSON.parse(raw.body);
|
|
return parsed?.byId && typeof parsed.byId === 'object' ? parsed.byId : {};
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Записать историю замеров пингов в S3.
|
|
*/
|
|
async function writePingServicesHistory(suffix, byId) {
|
|
const key = PING_SERVICES_HISTORY_KEY_PREFIX + suffix;
|
|
await writeS3JsonObject(key, { byId }).catch((err) => console.warn('[ping-services] history write failed:', err?.message));
|
|
}
|
|
|
|
/**
|
|
* Обновить кеш пинг-сервисов: выполнить пинги по списку из настроек и записать результат в S3.
|
|
* Используется планировщиком и при промахе кеша в getPingServices.
|
|
* @returns {Promise<Record<string, { id: string, name: string, host: string, ms: number|null }>>} byId
|
|
*/
|
|
async function refreshPingServicesCache() {
|
|
const uiSettings = await loadUiSettingsSync();
|
|
const servicesList = getPingServicesListFromSettings(uiSettings);
|
|
const fallbackPayload = {};
|
|
servicesList.forEach((s) => { fallbackPayload[s.id] = { id: s.id, name: s.name, host: s.host, ms: null }; });
|
|
|
|
const viaRouter = String(uiSettings.pingServicesSource || 'web').toLowerCase() === 'router';
|
|
const cacheSeconds = Math.max(0, parseInt(uiSettings.pingServicesCacheSeconds, 10) || 0);
|
|
|
|
let serverId = null;
|
|
let gatewayIp = null;
|
|
if (viaRouter) {
|
|
const { readServersFromS3 } = require('./serversRoutes');
|
|
const servers = await readServersFromS3();
|
|
const routerServers = servers.filter(
|
|
(s) => s && (String(s.type || '').toLowerCase() === 'jumphost' || String(s.type || '').toLowerCase() === 'home')
|
|
);
|
|
serverId = (uiSettings.pingServicesServerId && String(uiSettings.pingServicesServerId).trim()) || (routerServers[0] && (routerServers[0].id || routerServers[0].dns || routerServers[0].ip));
|
|
gatewayIp = (uiSettings.pingServicesGatewayIp && String(uiSettings.pingServicesGatewayIp).trim()) || null;
|
|
}
|
|
|
|
const suffix = pingServicesStorageSuffix(viaRouter, serverId, gatewayIp);
|
|
const cacheKey = cacheSeconds > 0 ? PING_SERVICES_CACHE_KEY_PREFIX + suffix : null;
|
|
|
|
if (viaRouter) {
|
|
const { runPingViaRouter } = require('./mikrotikConfigRoutes');
|
|
const { readServersFromS3 } = require('./serversRoutes');
|
|
const servers = await readServersFromS3();
|
|
const routerServers = servers.filter(
|
|
(s) => s && (String(s.type || '').toLowerCase() === 'jumphost' || String(s.type || '').toLowerCase() === 'home')
|
|
);
|
|
let gatewayIpResolved = gatewayIp;
|
|
if (!gatewayIpResolved && serverId && routerServers.length > 0) {
|
|
const server = routerServers.find((s) => (s.id || s.dns || s.ip) === serverId) || routerServers[0];
|
|
const gateways = Array.isArray(server.gateways) ? server.gateways : [];
|
|
const primary = gateways.find((g) => g && g.primary) || gateways[0];
|
|
gatewayIpResolved = primary && (primary.ip || primary.remoteIp) ? (primary.ip || primary.remoteIp) : null;
|
|
}
|
|
if (!serverId) {
|
|
console.warn('[ping-services] router mode: no serverId (no jumphost/home in settings or in servers list)');
|
|
return fallbackPayload;
|
|
}
|
|
const results = await Promise.all(
|
|
servicesList.map(async (svc) => {
|
|
try {
|
|
const result = await runPingViaRouter(serverId, gatewayIpResolved || null, svc.host, 3);
|
|
const ms = typeof result.avgMs === 'number' ? Math.round(result.avgMs) : null;
|
|
return { id: svc.id, name: svc.name, host: svc.host, ms };
|
|
} catch (err) {
|
|
console.warn('[ping-services] runPingViaRouter failed for', svc.host, err?.message || err);
|
|
return { id: svc.id, name: svc.name, host: svc.host, ms: null };
|
|
}
|
|
})
|
|
);
|
|
const byId = {};
|
|
results.forEach((r) => { byId[r.id] = r; });
|
|
if (cacheKey) {
|
|
writeS3JsonObject(cacheKey, { byId, cachedAt: Date.now() }).catch((err) => console.warn('[ping-services] cache write failed:', err?.message));
|
|
}
|
|
const history = await readPingServicesHistory(suffix);
|
|
Object.keys(byId).forEach((id) => {
|
|
const ms = byId[id]?.ms;
|
|
if (typeof ms !== 'number') return;
|
|
const list = Array.isArray(history[id]) ? history[id] : [];
|
|
history[id] = [...list, ms].slice(-PING_HISTORY_MAX);
|
|
});
|
|
await writePingServicesHistory(suffix, history);
|
|
return byId;
|
|
}
|
|
|
|
const results = await Promise.all(
|
|
servicesList.map(async (svc) => {
|
|
const ms = await measureTcpRtt(svc.host, svc.port, 6000);
|
|
return { id: svc.id, name: svc.name, host: svc.host, ms };
|
|
})
|
|
);
|
|
const byId = {};
|
|
results.forEach((r) => { byId[r.id] = r; });
|
|
if (cacheKey) {
|
|
writeS3JsonObject(cacheKey, { byId, cachedAt: Date.now() }).catch((err) => console.warn('[ping-services] cache write failed:', err?.message));
|
|
}
|
|
const history = await readPingServicesHistory(suffix);
|
|
Object.keys(byId).forEach((id) => {
|
|
const ms = byId[id]?.ms;
|
|
if (typeof ms !== 'number') return;
|
|
const list = Array.isArray(history[id]) ? history[id] : [];
|
|
history[id] = [...list, ms].slice(-PING_HISTORY_MAX);
|
|
});
|
|
await writePingServicesHistory(suffix, history);
|
|
return byId;
|
|
}
|
|
|
|
// GET /api/ping-services-list — список сервисов для пинга из настроек (для дашборда и редактора)
|
|
async function getPingServicesList(req, res) {
|
|
try {
|
|
const uiSettings = await loadUiSettingsSync();
|
|
const list = getPingServicesListFromSettings(uiSettings);
|
|
return res.json({ list });
|
|
} catch (e) {
|
|
console.error('ping-services-list error', e);
|
|
return res.json({ list: PING_SERVICES_DEFAULT });
|
|
}
|
|
}
|
|
|
|
// GET /api/ping-services — RTT до сервисов из списка (веб или через RouterOS по настройке)
|
|
async function getPingServices(req, res) {
|
|
try {
|
|
const uiSettings = await loadUiSettingsSync();
|
|
const servicesList = getPingServicesListFromSettings(uiSettings);
|
|
const fallbackPayload = {};
|
|
servicesList.forEach((s) => { fallbackPayload[s.id] = { id: s.id, name: s.name, host: s.host, ms: null }; });
|
|
|
|
const viaRouter = String(uiSettings.pingServicesSource || 'web').toLowerCase() === 'router';
|
|
const cacheSeconds = Math.max(0, parseInt(uiSettings.pingServicesCacheSeconds, 10) || 0);
|
|
|
|
let serverId = null;
|
|
let gatewayIp = null;
|
|
if (viaRouter) {
|
|
const { readServersFromS3 } = require('./serversRoutes');
|
|
const servers = await readServersFromS3();
|
|
const routerServers = servers.filter(
|
|
(s) => s && (String(s.type || '').toLowerCase() === 'jumphost' || String(s.type || '').toLowerCase() === 'home')
|
|
);
|
|
serverId = (uiSettings.pingServicesServerId && String(uiSettings.pingServicesServerId).trim()) || (routerServers[0] && (routerServers[0].id || routerServers[0].dns || routerServers[0].ip));
|
|
gatewayIp = (uiSettings.pingServicesGatewayIp && String(uiSettings.pingServicesGatewayIp).trim()) || null;
|
|
}
|
|
|
|
const suffix = pingServicesStorageSuffix(viaRouter, serverId, gatewayIp);
|
|
const cacheKey = cacheSeconds > 0 ? PING_SERVICES_CACHE_KEY_PREFIX + suffix : null;
|
|
const skipCache = ['1', 'true', 'yes'].includes(String(req.query?.refresh || req.query?.nocache || '').toLowerCase());
|
|
if (cacheKey && !skipCache) {
|
|
try {
|
|
const raw = await readS3TextObject(cacheKey).catch(() => null);
|
|
if (raw?.body) {
|
|
const cached = JSON.parse(raw.body);
|
|
const cachedAt = typeof cached.cachedAt === 'number' ? cached.cachedAt : 0;
|
|
const ttlMs = cacheSeconds * 1000;
|
|
if (cachedAt && Date.now() - cachedAt < ttlMs && cached.byId && typeof cached.byId === 'object') {
|
|
const history = await readPingServicesHistory(suffix);
|
|
return res.json({ byId: cached.byId, history });
|
|
}
|
|
}
|
|
} catch (_) {}
|
|
}
|
|
|
|
const byId = await refreshPingServicesCache();
|
|
const history = await readPingServicesHistory(suffix);
|
|
return res.json({ byId, history });
|
|
} catch (e) {
|
|
console.error('ping-services error', e);
|
|
const fallback = {};
|
|
PING_SERVICES_DEFAULT.forEach((s) => { fallback[s.id] = { id: s.id, name: s.name, host: s.host, ms: null }; });
|
|
res.status(500).json({ byId: fallback, history: {} });
|
|
}
|
|
}
|
|
|
|
function anyTrue(promises) {
|
|
return new Promise((resolve) => {
|
|
if (!Array.isArray(promises) || promises.length === 0) return resolve(false);
|
|
let remaining = promises.length;
|
|
let resolved = false;
|
|
for (const p of promises) {
|
|
Promise.resolve(p).then((v) => {
|
|
if (v && !resolved) { resolved = true; resolve(true); }
|
|
}).finally(() => {
|
|
remaining -= 1;
|
|
if (remaining === 0 && !resolved) resolve(false);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
async function checkOneServerFast(srv, perSocketTimeoutMs = 800, perServerBudgetMs = 1000) {
|
|
const hosts = [];
|
|
if (srv.ip) hosts.push(String(srv.ip));
|
|
if (srv.dns) hosts.push(String(srv.dns));
|
|
|
|
const tryOneHost = (host) => anyTrue([
|
|
tcpCheck(host, 443, perSocketTimeoutMs),
|
|
tcpCheck(host, 80, perSocketTimeoutMs),
|
|
]);
|
|
|
|
const run = anyTrue(hosts.map((h) => tryOneHost(h)));
|
|
const timeout = new Promise((resolve) => setTimeout(() => resolve(false), perServerBudgetMs));
|
|
return Promise.race([run, timeout]);
|
|
}
|
|
|
|
async function getServersAvailability(req, res) {
|
|
try {
|
|
const ttlSeconds = Math.max(0, Math.min(300, Number(req.query.ttlSeconds) || 30));
|
|
const now = Date.now();
|
|
|
|
if (availabilityCache.data && (now - availabilityCache.at) < ttlSeconds * 1000) {
|
|
return res.json({ ...availabilityCache.data, cached: true });
|
|
}
|
|
|
|
let servers = [];
|
|
try {
|
|
const data = await readS3TextObject('servers.json');
|
|
servers = JSON.parse(data.body);
|
|
if (!Array.isArray(servers)) servers = [];
|
|
} catch {
|
|
servers = [];
|
|
}
|
|
|
|
const checks = await Promise.allSettled(servers.map((s) => checkOneServerFast(s)));
|
|
const statuses = servers.map((s, i) => ({
|
|
ip: s.ip,
|
|
dns: s.dns,
|
|
online: checks[i].status === 'fulfilled' ? Boolean(checks[i].value) : false
|
|
}));
|
|
|
|
const online = statuses.filter((x) => x.online).length;
|
|
const payload = { online, total: servers.length, statuses };
|
|
availabilityCache.at = Date.now();
|
|
availabilityCache.data = payload;
|
|
res.json(payload);
|
|
} catch (e) {
|
|
console.error('availability error', e);
|
|
res.status(500).json({ online: 0, total: 0, statuses: [] });
|
|
}
|
|
}
|
|
|
|
// POST /api/update-bgp/background
|
|
async function updateBgpBackground(req, res) {
|
|
try {
|
|
const targetUrl = process.env.BGP_BACKGROUND_URL;
|
|
if (!targetUrl) {
|
|
return sendError(res, 500, 'BGP_BACKGROUND_URL is not configured', 'E_CONFIG');
|
|
}
|
|
|
|
const u = new URL(targetUrl);
|
|
const client = u.protocol === 'https:' ? https : http;
|
|
const options = {
|
|
method: 'POST',
|
|
hostname: u.hostname,
|
|
port: u.port || (u.protocol === 'https:' ? 443 : 80),
|
|
path: `${u.pathname}${u.search || ''}`,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Accept': 'application/json',
|
|
},
|
|
timeout: 15000,
|
|
};
|
|
|
|
const body = req.body && Object.keys(req.body).length ? JSON.stringify(req.body) : '';
|
|
|
|
const upstream = client.request(options, (r) => {
|
|
let data = '';
|
|
r.setEncoding('utf8');
|
|
r.on('data', (chunk) => { data += chunk; });
|
|
r.on('end', () => {
|
|
const status = r.statusCode || 502;
|
|
try {
|
|
const json = data ? JSON.parse(data) : {};
|
|
return res.status(status).json(json);
|
|
} catch (_) {
|
|
return res.status(status).json({ ok: status >= 200 && status < 300, data });
|
|
}
|
|
});
|
|
});
|
|
|
|
upstream.on('timeout', () => {
|
|
try { upstream.destroy(); } catch {}
|
|
return sendError(res, 504, 'Upstream timeout', 'E_UPSTREAM_TIMEOUT');
|
|
});
|
|
|
|
upstream.on('error', (e) => {
|
|
return sendError(res, 502, 'Upstream error', 'E_UPSTREAM', { error: String(e?.message || e) });
|
|
});
|
|
|
|
if (body) upstream.write(body);
|
|
upstream.end();
|
|
} catch (e) {
|
|
return sendError(res, 500, 'Proxy error', 'E_PROXY', { error: String(e?.message || e) });
|
|
}
|
|
}
|
|
|
|
// GET /api/ws/url
|
|
async function getWsUrl(req, res) {
|
|
try {
|
|
let settings = {};
|
|
try {
|
|
const d = await readS3TextObject('bgp_data/rt_ui_settings.json');
|
|
settings = JSON.parse(d.body || '{}');
|
|
} catch (_) {
|
|
settings = {};
|
|
}
|
|
|
|
const url = settings?.wsUpdateUrl || process.env.WS_UPDATE_URL || '';
|
|
return res.json({ url });
|
|
} catch (e) {
|
|
return res.json({ url: '' });
|
|
}
|
|
}
|
|
|
|
// GET/POST /api/ui-settings
|
|
async function getUiSettings(req, res) {
|
|
const { checkIfNoneMatch } = require('../middleware/errorHandler');
|
|
|
|
try {
|
|
const head = await headMeta('bgp_data/rt_ui_settings.json');
|
|
const etag = head?.etag || null;
|
|
if (etag) res.set('ETag', String(etag));
|
|
if (head?.lastModified) res.set('Last-Modified', new Date(head.lastModified).toUTCString());
|
|
if (typeof head?.contentLength === 'number') res.set('Content-Length-Source', String(head.contentLength));
|
|
if (checkIfNoneMatch(req, res, etag)) return;
|
|
|
|
let jsonText = '{}';
|
|
try {
|
|
const data = await readS3TextObject('bgp_data/rt_ui_settings.json');
|
|
jsonText = data.body;
|
|
} catch (e) {
|
|
if (e?.code !== 'NoSuchKey') throw e;
|
|
}
|
|
let settings = {};
|
|
try {
|
|
const parsed = JSON.parse(jsonText);
|
|
if (parsed && typeof parsed === 'object') settings = parsed;
|
|
} catch (parseError) {
|
|
settings = {};
|
|
}
|
|
return res.json(settings);
|
|
} catch (error) {
|
|
if (error?.code === 'NoSuchKey') {
|
|
return res.json({});
|
|
}
|
|
console.error('Error reading ui settings:', error);
|
|
return sendError(res, 500, 'Error reading UI settings', 'E_STORAGE');
|
|
}
|
|
}
|
|
|
|
async function postUiSettings(req, res) {
|
|
const { settings, etag } = req.body || {};
|
|
const payload = (settings && typeof settings === 'object') ? settings : {};
|
|
|
|
try {
|
|
const { headS3ObjectEtag } = require('../services/s3Service');
|
|
let current = null;
|
|
const ifMatch = req.headers['if-match'] ? String(req.headers['if-match']).replace(/\"/g,'"') : null;
|
|
try { current = await headS3ObjectEtag('bgp_data/rt_ui_settings.json'); } catch {}
|
|
if (current && (ifMatch || etag) && current !== String(ifMatch || etag)) {
|
|
const meta = await headMeta('bgp_data/rt_ui_settings.json');
|
|
return sendError(res, 412, 'Precondition Failed: ETag mismatch', 'E_ETAG_MISMATCH', { currentEtag: current, meta });
|
|
}
|
|
} catch {}
|
|
|
|
try {
|
|
const { writeS3JsonObject } = require('../services/s3Service');
|
|
const meta = await writeS3JsonObject('bgp_data/rt_ui_settings.json', payload);
|
|
return sendOk(res, meta);
|
|
} catch (error) {
|
|
console.error('Error writing UI settings:', error);
|
|
return sendError(res, 500, 'Error writing UI settings', 'E_STORAGE', { error: String(error?.message || error) });
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
getS3LastModified,
|
|
getHistory,
|
|
postRollback,
|
|
getAutoUrls,
|
|
postAutoUrls,
|
|
processAutoUrls,
|
|
getServersAvailability,
|
|
updateBgpBackground,
|
|
getWsUrl,
|
|
getUiSettings,
|
|
postUiSettings,
|
|
getPingServicesList,
|
|
getPingServices,
|
|
refreshPingServicesCache,
|
|
checkOneServerFast,
|
|
loadUiSettingsSync,
|
|
};
|
|
|