258 lines
9.1 KiB
JavaScript
258 lines
9.1 KiB
JavaScript
/**
|
|
* GET/POST для справочников из EvoBGP (ранее textDataRoutes + S3).
|
|
*/
|
|
|
|
const crypto = require('crypto');
|
|
const evobgpClient = require('../services/evobgpClient');
|
|
const { sendError, sendOk, checkIfNoneMatch } = require('../middleware/errorHandler');
|
|
|
|
const countOnlyCache = { map: new Map(), ttlMs: 10_000 };
|
|
|
|
function getCountOnlyCache(cacheKey) {
|
|
const v = countOnlyCache.map.get(cacheKey);
|
|
if (!v) return null;
|
|
if (Date.now() > v.at + countOnlyCache.ttlMs) {
|
|
countOnlyCache.map.delete(cacheKey);
|
|
return null;
|
|
}
|
|
return v.value;
|
|
}
|
|
|
|
function setCountOnlyCache(cacheKey, value) {
|
|
countOnlyCache.map.set(cacheKey, { value, at: Date.now() });
|
|
}
|
|
|
|
function etagForJson(obj) {
|
|
const s = JSON.stringify(obj);
|
|
const h = crypto.createHash('sha256').update(Buffer.from(s, 'utf8')).digest('hex');
|
|
return `"${h}"`;
|
|
}
|
|
|
|
function filterPage(items, q, offset, limit) {
|
|
const qstr = q ? String(q).toLowerCase() : '';
|
|
const filtered = !qstr
|
|
? items
|
|
: items.filter((it) => JSON.stringify(it).toLowerCase().includes(qstr));
|
|
const total = filtered.length;
|
|
if (limit > 0) {
|
|
return { items: filtered.slice(offset, offset + limit), total };
|
|
}
|
|
return { items: filtered, total };
|
|
}
|
|
|
|
function createEvobgpListGET({ fetchItems, cachePrefix, validate }) {
|
|
return async (req, res) => {
|
|
const { q = '', offset, limit, countOnly, format } = req.query || {};
|
|
if (!evobgpClient.isConfigured()) {
|
|
return sendError(res, 503, 'EvoBGP не настроен', 'E_EVOBGP_NOT_CONFIGURED');
|
|
}
|
|
try {
|
|
if (countOnly === 'true') {
|
|
const cacheKey = `${cachePrefix}:count:${q}`;
|
|
const cached = getCountOnlyCache(cacheKey);
|
|
if (cached != null) {
|
|
return res.json(format === 'std' ? { items: [], total: cached, meta: {} } : { total: cached });
|
|
}
|
|
const all = await fetchItems();
|
|
const { total } = filterPage(all, q, 0, 0);
|
|
setCountOnlyCache(cacheKey, total);
|
|
return res.json(format === 'std' ? { items: [], total, meta: {} } : { total });
|
|
}
|
|
|
|
if (Number(limit) > 0) {
|
|
const all = await fetchItems();
|
|
if (!validate(all)) {
|
|
return sendError(res, 500, 'Invalid data format', 'E_SCHEMA');
|
|
}
|
|
const { items, total } = filterPage(all, q, Number(offset) || 0, Number(limit) || 0);
|
|
return res.json(format === 'std' ? { items, total, meta: {} } : { items, total });
|
|
}
|
|
|
|
const all = await fetchItems();
|
|
if (!validate(all)) {
|
|
return sendError(res, 500, 'Invalid data format', 'E_SCHEMA');
|
|
}
|
|
const etag = etagForJson(all);
|
|
res.set('ETag', etag);
|
|
res.set('Last-Modified', new Date().toUTCString());
|
|
res.set('Content-Length-Source', String(Buffer.byteLength(JSON.stringify(all), 'utf8')));
|
|
if (checkIfNoneMatch(req, res, etag)) return;
|
|
if (format === 'std') {
|
|
return res.json({ items: all, total: all.length, meta: {} });
|
|
}
|
|
return res.json(all);
|
|
} catch (e) {
|
|
console.error(cachePrefix, e);
|
|
return sendError(res, 500, e.message || 'EvoBGP error', 'E_EVOBGP');
|
|
}
|
|
};
|
|
}
|
|
|
|
function readIfMatch(req) {
|
|
const raw = req.headers['if-match'] || req.headers['If-Match'];
|
|
if (!raw) return null;
|
|
return String(raw).trim();
|
|
}
|
|
|
|
function createEvobgpDomainsNewPOST({ validate, validateItem }) {
|
|
return async (req, res) => {
|
|
const { domains: items, etag: bodyEtag } = req.body || {};
|
|
if (!Array.isArray(items)) {
|
|
return sendError(res, 400, 'Data must be an array', 'E_BAD_REQUEST');
|
|
}
|
|
if (!validate(items)) {
|
|
return sendError(res, 400, 'Invalid payload format', 'E_SCHEMA');
|
|
}
|
|
if (validateItem) {
|
|
const validationErrors = [];
|
|
for (let i = 0; i < items.length; i++) {
|
|
const errors = validateItem(items[i], i);
|
|
if (errors.length > 0) validationErrors.push(...errors);
|
|
}
|
|
if (validationErrors.length > 0) {
|
|
return sendError(res, 400, 'Validation errors', 'E_VALIDATION', {
|
|
errors: validationErrors.slice(0, 10),
|
|
});
|
|
}
|
|
}
|
|
if (!evobgpClient.isConfigured()) {
|
|
return sendError(res, 503, 'EvoBGP не настроен', 'E_EVOBGP_NOT_CONFIGURED');
|
|
}
|
|
try {
|
|
const current = await evobgpClient.fetchDomainsData();
|
|
const currentEtag = etagForJson(current);
|
|
const ifMatch = readIfMatch(req);
|
|
const expected = ifMatch || bodyEtag;
|
|
if (expected && String(expected).trim() !== currentEtag) {
|
|
return sendError(res, 412, 'ETag mismatch', 'E_ETAG_MISMATCH');
|
|
}
|
|
const normalized = items.map((d) => ({
|
|
domain: String(d.domain || '').trim().toLowerCase(),
|
|
community: String(d.community || '').trim(),
|
|
}));
|
|
await evobgpClient.saveDomainsData(normalized, current);
|
|
return sendOk(res, { etag: null, lastModified: new Date().toISOString(), contentLength: null });
|
|
} catch (e) {
|
|
console.error(e);
|
|
return sendError(res, 500, e.message || 'EvoBGP write failed', 'E_EVOBGP');
|
|
}
|
|
};
|
|
}
|
|
|
|
function createEvobgpAsnsPOST({ validate, validateItem }) {
|
|
return async (req, res) => {
|
|
const { domains: items, etag: bodyEtag } = req.body || {};
|
|
if (!Array.isArray(items)) {
|
|
return sendError(res, 400, 'Data must be an array', 'E_BAD_REQUEST');
|
|
}
|
|
if (!validate(items)) {
|
|
return sendError(res, 400, 'Invalid payload format', 'E_SCHEMA');
|
|
}
|
|
if (validateItem) {
|
|
const validationErrors = [];
|
|
for (let i = 0; i < items.length; i++) {
|
|
const errors = validateItem(items[i], i);
|
|
if (errors.length > 0) validationErrors.push(...errors);
|
|
}
|
|
if (validationErrors.length > 0) {
|
|
return sendError(res, 400, 'Validation errors', 'E_VALIDATION', {
|
|
errors: validationErrors.slice(0, 10),
|
|
});
|
|
}
|
|
}
|
|
if (!evobgpClient.isConfigured()) {
|
|
return sendError(res, 503, 'EvoBGP не настроен', 'E_EVOBGP_NOT_CONFIGURED');
|
|
}
|
|
try {
|
|
const current = await evobgpClient.fetchAsnsData();
|
|
const currentEtag = etagForJson(
|
|
current.map((a) => ({ domain: a.asn, type: a.community })),
|
|
);
|
|
const ifMatch = readIfMatch(req);
|
|
const expected = ifMatch || bodyEtag;
|
|
if (expected && String(expected).trim() !== currentEtag) {
|
|
return sendError(res, 412, 'ETag mismatch', 'E_ETAG_MISMATCH');
|
|
}
|
|
const normalized = items.map((a) => ({
|
|
asn: String(a.domain || a.asn || '').trim(),
|
|
community: String(a.type || a.community || '').trim(),
|
|
}));
|
|
await evobgpClient.saveAsnsData(normalized, current);
|
|
return sendOk(res, { etag: null, lastModified: new Date().toISOString(), contentLength: null });
|
|
} catch (e) {
|
|
console.error(e);
|
|
return sendError(res, 500, e.message || 'EvoBGP write failed', 'E_EVOBGP');
|
|
}
|
|
};
|
|
}
|
|
|
|
function createEvobgpIpRangesPOST({ validate, validateItem }) {
|
|
return async (req, res) => {
|
|
const payload = Array.isArray(req.body?.domains)
|
|
? req.body.domains
|
|
: Array.isArray(req.body?.ipRanges)
|
|
? req.body.ipRanges
|
|
: null;
|
|
const { etag: bodyEtag } = req.body || {};
|
|
if (!Array.isArray(payload)) {
|
|
return sendError(res, 400, 'Data must be an array', 'E_BAD_REQUEST');
|
|
}
|
|
if (!validate(payload)) {
|
|
return sendError(res, 400, 'Invalid payload format', 'E_SCHEMA');
|
|
}
|
|
if (validateItem) {
|
|
const validationErrors = [];
|
|
for (let i = 0; i < payload.length; i++) {
|
|
const errors = validateItem(payload[i], i);
|
|
if (errors.length > 0) validationErrors.push(...errors);
|
|
}
|
|
if (validationErrors.length > 0) {
|
|
return sendError(res, 400, 'Validation errors', 'E_VALIDATION', {
|
|
errors: validationErrors.slice(0, 10),
|
|
});
|
|
}
|
|
}
|
|
if (!evobgpClient.isConfigured()) {
|
|
return sendError(res, 503, 'EvoBGP не настроен', 'E_EVOBGP_NOT_CONFIGURED');
|
|
}
|
|
try {
|
|
const current = await evobgpClient.fetchIpRangesData();
|
|
const currentEtag = etagForJson(current);
|
|
const ifMatch = readIfMatch(req);
|
|
const expected = ifMatch || bodyEtag;
|
|
if (expected && String(expected).trim() !== currentEtag) {
|
|
return sendError(res, 412, 'ETag mismatch', 'E_ETAG_MISMATCH');
|
|
}
|
|
const normalized = payload.map((ip) => ({
|
|
ipRange: String(ip.ipRange || '').trim(),
|
|
community: String(ip.community || '').trim(),
|
|
}));
|
|
await evobgpClient.saveIpRangesData(normalized, current);
|
|
return sendOk(res, { etag: null, lastModified: new Date().toISOString(), contentLength: null });
|
|
} catch (e) {
|
|
console.error(e);
|
|
return sendError(res, 500, e.message || 'EvoBGP write failed', 'E_EVOBGP');
|
|
}
|
|
};
|
|
}
|
|
|
|
/** Legacy /api/domains: тот же модуль ASN, ответ в полях domain + type. */
|
|
function createEvobgpLegacyDomainsGET({ validate }) {
|
|
return createEvobgpListGET({
|
|
cachePrefix: 'domains',
|
|
validate,
|
|
fetchItems: async () => {
|
|
const rows = await evobgpClient.fetchAsnsData();
|
|
return rows.map((r) => ({ domain: r.asn, type: r.community }));
|
|
},
|
|
});
|
|
}
|
|
|
|
module.exports = {
|
|
createEvobgpListGET,
|
|
createEvobgpDomainsNewPOST,
|
|
createEvobgpAsnsPOST,
|
|
createEvobgpIpRangesPOST,
|
|
createEvobgpLegacyDomainsGET,
|
|
};
|