ThatGuyJack/nginx-proxy-manager
1
0
Fork 0
mirror of https://github.com/NginxProxyManager/nginx-proxy-manager.git synced 2025-04-30 02:52:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix linter warnings

Browse Source
This commit is contained in:
Varun Gupta 2023-12-02 20:09:10 -05:00 committed by Varun Gupta
parent ec9eb0dd60
commit 972d158161
2 changed files with 204 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
backend/internal/nginx.js
View File

@ -1,9 +1,9 @@
const _ = require('lodash'); const _ = require('lodash');
const fs = require('fs'); const fs = require('fs');
const logger = require('../logger').nginx; const logger = require('../logger').nginx;
const config = require('../lib/config'); const config = require('../lib/config');
const utils = require('../lib/utils'); const utils = require('../lib/utils');
const error = require('../lib/error'); const error = require('../lib/error');
const ddnsResolver = require('../lib/ddns_resolver'); const ddnsResolver = require('../lib/ddns_resolver');
const internalNginx = { const internalNginx = {
@ -151,7 +151,7 @@ const internalNginx = {
} }
} }
} }
if (promises.length) { if (promises.length) {
return Promise.all(promises); return Promise.all(promises);
} }
return Promise.resolve(); return Promise.resolve();

394
backend/lib/ddns_resolver.js
View File

@ -1,239 +1,239 @@
const error = require('./error') const error = require('./error');
const logger = require('../logger').ddns; const logger = require('../logger').ddns;
const internalAccessList = require('../internal/access-list'); const internalAccessList = require('../internal/access-list');
const utils = require('./utils'); const utils = require('./utils');
const ddnsResolver = { const ddnsResolver = {
/** /**
* Starts a timer to periodically check for ddns updates * Starts a timer to periodically check for ddns updates
*/ */
initTimer: () => { initTimer: () => {
ddnsResolver._initialize(); ddnsResolver._initialize();
ddnsResolver._interval = setInterval(ddnsResolver._checkForDDNSUpdates, ddnsResolver._updateIntervalMs); ddnsResolver._interval = setInterval(ddnsResolver._checkForDDNSUpdates, ddnsResolver._updateIntervalMs);
logger.info(`DDNS Update Timer initialized (interval: ${Math.floor(ddnsResolver._updateIntervalMs / 1000)}s)`); logger.info(`DDNS Update Timer initialized (interval: ${Math.floor(ddnsResolver._updateIntervalMs / 1000)}s)`);
// Trigger a run so that initial cache is populated and hosts can be updated - delay by 10s to give server time to boot up // Trigger a run so that initial cache is populated and hosts can be updated - delay by 10s to give server time to boot up
setTimeout(ddnsResolver._checkForDDNSUpdates, 10 * 1000); setTimeout(ddnsResolver._checkForDDNSUpdates, 10 * 1000);
}, },
/** /**
* Checks whether the address requires resolution (i.e. starts with ddns:) * Checks whether the address requires resolution (i.e. starts with ddns:)
* @param {String} address * @param {String} address
* @returns {boolean} * @returns {boolean}
*/ */
requiresResolution: (address) => { requiresResolution: (address) => {
if (typeof address !== 'undefined' && address && address.toLowerCase().startsWith('ddns:')) { if (typeof address !== 'undefined' && address && address.toLowerCase().startsWith('ddns:')) {
return true; return true;
} }
return false; return false;
}, },
/** /**
* Resolves the given address to its IP * Resolves the given address to its IP
* @param {String} address * @param {String} address
* @param {boolean} forceUpdate: whether to force resolution instead of using the cached value * @param {boolean} forceUpdate: whether to force resolution instead of using the cached value
*/ */
resolveAddress: (address, forceUpdate=false) => { resolveAddress: (address, forceUpdate=false) => {
if (!forceUpdate && ddnsResolver._cache.has(address)) { if (!forceUpdate && ddnsResolver._cache.has(address)) {
// Check if it is still valid // Check if it is still valid
const value = ddnsResolver._cache.get(address); const value = ddnsResolver._cache.get(address);
const ip = value[0]; const ip = value[0];
const lastUpdated = value[1]; const lastUpdated = value[1];
const nowSeconds = Date.now(); const nowSeconds = Date.now();
const delta = nowSeconds - lastUpdated; const delta = nowSeconds - lastUpdated;
if (delta < ddnsResolver._updateIntervalMs) { if (delta < ddnsResolver._updateIntervalMs) {
return Promise.resolve(ip); return Promise.resolve(ip);
} }
} }
ddnsResolver._cache.delete(address); ddnsResolver._cache.delete(address);
// Reach here only if cache value doesn't exist or needs to be updated // Reach here only if cache value doesn't exist or needs to be updated
let host = address.toLowerCase(); let host = address.toLowerCase();
if (host.startsWith('ddns:')) { if (host.startsWith('ddns:')) {
host = host.substring(5); host = host.substring(5);
} }
return ddnsResolver._queryHost(host) return ddnsResolver._queryHost(host)
.then((resolvedIP) => { .then((resolvedIP) => {
ddnsResolver._cache.set(address, [resolvedIP, Date.now()]); ddnsResolver._cache.set(address, [resolvedIP, Date.now()]);
return resolvedIP; return resolvedIP;
}) })
.catch((_error) => { .catch((/*error*/) => {
// return input address in case of failure // return input address in case of failure
return address; return address;
}); });
}, },
/** Private **/ /** Private **/
// Properties // Properties
_initialized: false, _initialized: false,
_updateIntervalMs: 60 * 60 * 1000, // 1 hr default (overriden with $DDNS_UPDATE_INTERVAL env var) _updateIntervalMs: 60 * 60 * 1000, // 1 hr default (overriden with $DDNS_UPDATE_INTERVAL env var)
/** /**
* cache mapping host to (ip address, last updated time) * cache mapping host to (ip address, last updated time)
*/ */
_cache: new Map(), _cache: new Map(),
_interval: null, // reference to created interval id _interval: null, // reference to created interval id
_processingDDNSUpdate: false, _processingDDNSUpdate: false,
// Methods // Methods
_initialize: () => { _initialize: () => {
if (ddnsResolver._initialized) { if (ddnsResolver._initialized) {
return; return;
} }
// Init the resolver // Init the resolver
// Read and set custom update interval from env if needed // Read and set custom update interval from env if needed
if (typeof process.env.DDNS_UPDATE_INTERVAL !== 'undefined') { if (typeof process.env.DDNS_UPDATE_INTERVAL !== 'undefined') {
const interval = Number(process.env.DDNS_UPDATE_INTERVAL.toLowerCase()); const interval = Number(process.env.DDNS_UPDATE_INTERVAL.toLowerCase());
if (!isNaN(interval)) { if (!isNaN(interval)) {
// Interval value from env is in seconds. Set min to 60s. // Interval value from env is in seconds. Set min to 60s.
ddnsResolver._updateIntervalMs = Math.max(interval * 1000, 60 * 1000); ddnsResolver._updateIntervalMs = Math.max(interval * 1000, 60 * 1000);
} else { } else {
logger.warn(`[DDNS] invalid value for update interval: '${process.env.DDNS_UPDATE_INTERVAL}'`); logger.warn(`[DDNS] invalid value for update interval: '${process.env.DDNS_UPDATE_INTERVAL}'`);
} }
} }
ddnsResolver._initialized = true; ddnsResolver._initialized = true;
}, },
/** /**
* *
* @param {String} host * @param {String} host
* @returns {Promise} * @returns {Promise}
*/ */
_queryHost: (host) => { _queryHost: (host) => {
logger.info('Looking up IP for ', host); logger.info('Looking up IP for ', host);
return utils.execSafe('getent', ['hosts', host]) return utils.execSafe('getent', ['hosts', host])
.then((result) => { .then((result) => {
if (result.length < 8) { if (result.length < 8) {
logger.error('IP lookup returned invalid output: ', result); logger.error('IP lookup returned invalid output: ', result);
throw error.ValidationError('Invalid output from getent hosts'); throw error.ValidationError('Invalid output from getent hosts');
} }
const out = result.split(/\s+/); const out = result.split(/\s+/);
logger.info(`Resolved ${host} to ${out[0]}`); logger.info(`Resolved ${host} to ${out[0]}`);
return out[0]; return out[0];
}, },
(error) => { (error) => {
logger.error('Error looking up IP for ' + host + ': ', error); logger.error('Error looking up IP for ' + host + ': ', error);
throw error; throw error;
}); });
}, },
/** /**
* Triggered by a timer, will check for and update ddns hosts in access list clients * Triggered by a timer, will check for and update ddns hosts in access list clients
*/ */
_checkForDDNSUpdates: () => { _checkForDDNSUpdates: () => {
const internalNginx = require('../internal/nginx'); // Prevent circular import const internalNginx = require('../internal/nginx'); // Prevent circular import
logger.info('Checking for DDNS updates...'); logger.info('Checking for DDNS updates...');
if (!ddnsResolver._processingDDNSUpdate) { if (!ddnsResolver._processingDDNSUpdate) {
ddnsResolver._processingDDNSUpdate = true; ddnsResolver._processingDDNSUpdate = true;
const updatedAddresses = new Map(); const updatedAddresses = new Map();
// Get all ddns hostnames in use // Get all ddns hostnames in use
return ddnsResolver._getAccessLists() return ddnsResolver._getAccessLists()
.then((rows) => { .then((rows) => {
// Build map of used addresses that require resolution // Build map of used addresses that require resolution
const usedAddresses = new Map(); const usedAddresses = new Map();
for (const row of rows) { for (const row of rows) {
if (!row.proxy_host_count) { if (!row.proxy_host_count) {
// Ignore rows (access lists) that are not associated to any hosts // Ignore rows (access lists) that are not associated to any hosts
continue; continue;
} }
for (const client of row.clients) { for (const client of row.clients) {
if (!ddnsResolver.requiresResolution(client.address)) { if (!ddnsResolver.requiresResolution(client.address)) {
continue; continue;
} }
if (!usedAddresses.has(client.address)) { if (!usedAddresses.has(client.address)) {
usedAddresses.set(client.address, [row]); usedAddresses.set(client.address, [row]);
} else { } else {
usedAddresses.get(client.address).push(row); usedAddresses.get(client.address).push(row);
} }
} }
} }
logger.info(`Found ${usedAddresses.size} address(es) in use.`); logger.info(`Found ${usedAddresses.size} address(es) in use.`);
// Remove unused addresses // Remove unused addresses
const addressesToRemove = []; const addressesToRemove = [];
for (const address of ddnsResolver._cache.keys()) { for (const address of ddnsResolver._cache.keys()) {
if (!usedAddresses.has(address)) { if (!usedAddresses.has(address)) {
addressesToRemove.push(address); addressesToRemove.push(address);
} }
} }
addressesToRemove.forEach((address) => { ddnsResolver._cache.delete(address); }); addressesToRemove.forEach((address) => { ddnsResolver._cache.delete(address); });
const promises = []; const promises = [];
for (const [address, rows] of usedAddresses) { for (const [address, rows] of usedAddresses) {
let oldIP = ''; let oldIP = '';
if (ddnsResolver._cache.has(address)) { if (ddnsResolver._cache.has(address)) {
oldIP = ddnsResolver._cache.get(address)[0]; oldIP = ddnsResolver._cache.get(address)[0];
} }
const p = ddnsResolver.resolveAddress(address, true) const p = ddnsResolver.resolveAddress(address, true)
.then((resolvedIP) => { .then((resolvedIP) => {
if (resolvedIP !== address && resolvedIP !== oldIP) { if (resolvedIP !== address && resolvedIP !== oldIP) {
// Mark this as an updated address // Mark this as an updated address
updatedAddresses.set(address, rows); updatedAddresses.set(address, rows);
} }
}); });
promises.push(p); promises.push(p);
} }
if (promises.length) { if (promises.length) {
return Promise.all(promises); return Promise.all(promises);
} }
return Promise.resolve(); return Promise.resolve();
}) })
.then(() => { .then(() => {
logger.info(`${updatedAddresses.size} DDNS IP(s) updated.`); logger.info(`${updatedAddresses.size} DDNS IP(s) updated.`);
const updatedRows = new Map(); const updatedRows = new Map();
const proxy_hosts = []; const proxy_hosts = [];
for (const rows of updatedAddresses.values()) { for (const rows of updatedAddresses.values()) {
for (const row of rows) { for (const row of rows) {
if (!updatedRows.has(row.id)) { if (!updatedRows.has(row.id)) {
updatedRows.set(row.id, 1); updatedRows.set(row.id, 1);
proxy_hosts.push(...row.proxy_hosts); proxy_hosts.push(...row.proxy_hosts);
} }
} }
} }
if (proxy_hosts.length) { if (proxy_hosts.length) {
logger.info(`Updating ${proxy_hosts.length} proxy host(s) affected by DDNS changes`); logger.info(`Updating ${proxy_hosts.length} proxy host(s) affected by DDNS changes`);
return internalNginx.bulkGenerateConfigs('proxy_host', proxy_hosts) return internalNginx.bulkGenerateConfigs('proxy_host', proxy_hosts)
.then(internalNginx.reload); .then(internalNginx.reload);
} }
return Promise.resolve(); return Promise.resolve();
}) })
.then(() => { .then(() => {
logger.info('Finished checking for DDNS updates'); logger.info('Finished checking for DDNS updates');
ddnsResolver._processingDDNSUpdate = false; ddnsResolver._processingDDNSUpdate = false;
}); });
} else { } else {
logger.info('Skipping since previous DDNS update check is in progress'); logger.info('Skipping since previous DDNS update check is in progress');
} }
}, },
_getAccessLists: () => { _getAccessLists: () => {
const fakeAccess = { const fakeAccess = {
can: (capabilityStr) => { can: (/*role*/) => {
return Promise.resolve({ return Promise.resolve({
permission_visibility: 'all' permission_visibility: 'all'
}) });
} }
}; };
return internalAccessList.getAll(fakeAccess) return internalAccessList.getAll(fakeAccess)
.then((rows) => { .then((rows) => {
const promises = []; const promises = [];
for (const row of rows) { for (const row of rows) {
const p = internalAccessList.get(fakeAccess, { const p = internalAccessList.get(fakeAccess, {
id: row.id, id: row.id,
expand: ['owner', 'items', 'clients', 'proxy_hosts.[certificate,access_list.[clients,items]]'] expand: ['owner', 'items', 'clients', 'proxy_hosts.[certificate,access_list.[clients,items]]']
}, true /* <- skip masking */); }, true /* <- skip masking */);
promises.push(p); promises.push(p);
} }
if (promises.length) { if (promises.length) {
return Promise.all(promises); return Promise.all(promises);
} }
return Promise.resolve([]); return Promise.resolve([]);
}); });
} }
}; };
module.exports = ddnsResolver; module.exports = ddnsResolver;