nginx-proxy-manager/backend/internal/redirection-host.js
Tom Winnerl b60586aefc fix(review): merge a proxy or redirection host update with the row read under the lock
The update patch was merged (cleanSslHstsData) with the row read before the certificate request and the nginx lock, so it carried a stale enabled value and every other column: a disable that committed in between was undone and the host served again. updateAndConfigure() now takes a patch function that is built from the row as it is under the lock.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 19:30:23 +01:00

476 lines
14 KiB
JavaScript

import _ from "lodash";
import errs from "../lib/error.js";
import { castJsonIfNeed } from "../lib/helpers.js";
import utils from "../lib/utils.js";
import redirectionHostModel from "../models/redirection_host.js";
import internalAuditLog from "./audit-log.js";
import internalCertificate from "./certificate.js";
import internalHost from "./host.js";
import internalNginx from "./nginx.js";
const omissions = () => {
return ["is_deleted"];
};
const internalRedirectionHost = {
/**
* @param {Access} access
* @param {Object} data
* @returns {Promise}
*/
create: (access, data) => {
let thisData = internalHost.sanitiseInput(data || {});
const createCertificate = thisData.certificate_id === "new";
let createdId = null;
let issuedCertificateId = null;
if (createCertificate) {
delete thisData.certificate_id;
}
return access
.can("redirection_hosts:create", thisData)
.then((/*access_data*/) => {
// Get a list of the domain names and check each of them against existing records
const domain_name_check_promises = [];
thisData.domain_names.map((domain_name) => {
domain_name_check_promises.push(internalHost.isHostnameTaken(domain_name));
return true;
});
return Promise.all(domain_name_check_promises).then((check_results) => {
check_results.map((result) => {
if (result.is_taken) {
throw new errs.ValidationError(`${result.hostname} is already in use`);
}
return true;
});
});
})
.then(() => {
// At this point the domains should have been checked
thisData.owner_user_id = access.token.getUserId(1);
thisData = internalHost.cleanSslHstsData(thisData);
// Fix for db field not having a default value
// for this optional field.
if (typeof thisData.advanced_config === "undefined") {
thisData.advanced_config = "";
}
internalHost.assertAdvancedConfigAllowed(access, thisData);
return redirectionHostModel.query().insertAndFetch(thisData).then(utils.omitRow(omissions()));
})
.then((row) => {
createdId = row.id;
if (createCertificate) {
// Check that nginx accepts the host before a certificate is requested: when the host is
// rejected the create is rolled back, and a certificate issued for it would be left behind
// (and renewed forever). The SSL part is checked again when the certificate is added.
return internalNginx
.configure(redirectionHostModel, "redirection_host", row, { dryRun: true })
.then(() => internalCertificate.createQuickCertificate(access, thisData))
.then((cert) => {
issuedCertificateId = cert.id;
// update host with cert id
return internalRedirectionHost.update(access, {
id: row.id,
certificate_id: cert.id,
});
})
.then(() => {
return row;
});
}
return row;
})
.then((row) => {
// re-fetch with cert
return internalRedirectionHost.get(access, {
id: row.id,
expand: ["certificate", "owner"],
});
})
.then((row) => {
// Configure nginx
return internalNginx.configure(redirectionHostModel, "redirection_host", row).then((newMeta) => {
row.meta = newMeta;
return row;
});
})
.then((row) => {
thisData.meta = _.assign({}, thisData.meta || {}, row.meta);
// Add to audit log
return internalAuditLog
.add(access, {
action: "created",
object_type: "redirection-host",
object_id: row.id,
meta: thisData,
})
.then(() => {
return row;
});
})
.catch(async (err) => {
// nginx rejected the new host: don't keep a host that was never active
if (createdId && internalNginx.isHostLevelError(err)) {
await internalHost.discardRejectedCreate(redirectionHostModel, "redirection_host", createdId);
}
// the certificate requested for it is left unused when the host is gone or was rejected with it
if (issuedCertificateId) {
await internalHost.discardUnusedCertificate(issuedCertificateId, () =>
internalCertificate.delete(access, { id: issuedCertificateId }),
);
}
throw err;
});
},
/**
* @param {Access} access
* @param {Object} data
* @param {Number} data.id
* @return {Promise}
*/
update: (access, data) => {
let thisData = internalHost.sanitiseInput(data || {});
const createCertificate = thisData.certificate_id === "new";
let newCertificateId = null;
if (createCertificate) {
delete thisData.certificate_id;
}
return access
.can("redirection_hosts:update", thisData.id)
.then((/*access_data*/) => {
// Get a list of the domain names and check each of them against existing records
const domain_name_check_promises = [];
if (typeof thisData.domain_names !== "undefined") {
thisData.domain_names.map((domain_name) => {
domain_name_check_promises.push(
internalHost.isHostnameTaken(domain_name, "redirection", thisData.id),
);
return true;
});
return Promise.all(domain_name_check_promises).then((check_results) => {
check_results.map((result) => {
if (result.is_taken) {
throw new errs.ValidationError(`${result.hostname} is already in use`);
}
return true;
});
});
}
})
.then(() => {
return internalRedirectionHost.get(access, { id: thisData.id });
})
.then((row) => {
if (row.id !== thisData.id) {
// Sanity check that something crazy hasn't happened
throw new errs.InternalValidationError(
`Redirection Host could not be updated, IDs do not match: ${row.id} !== ${thisData.id}`,
);
}
// Before anything is configured or a certificate is requested
internalHost.assertAdvancedConfigAllowed(access, thisData, row);
if (createCertificate) {
// Check that nginx accepts the rest of the update before the certificate is requested
return internalRedirectionHost
.get(access, { id: row.id, expand: ["owner", "certificate"] })
.then((fullRow) =>
internalHost.checkProposedHost({
model: redirectionHostModel,
hostType: "redirection_host",
row: fullRow,
patch: internalHost.cleanSslHstsData(
_.assign({}, { domain_names: row.domain_names }, thisData),
row,
),
}),
)
.then(() =>
internalCertificate.createQuickCertificate(access, {
domain_names: thisData.domain_names || row.domain_names,
meta: _.assign({}, row.meta, thisData.meta),
}),
)
.then((cert) => {
// update host with cert id
thisData.certificate_id = cert.id;
newCertificateId = cert.id;
})
.then(() => {
return row;
});
}
return row;
})
.then((row) => {
const requested = thisData;
// Add domain_names to the data in case it isn't there, so that the audit log renders correctly. The order is important here.
thisData = internalHost.cleanSslHstsData(_.assign({}, { domain_names: row.domain_names }, requested), row);
return internalHost.updateAndConfigure({
model: redirectionHostModel,
hostType: "redirection_host",
id: thisData.id,
// merged with the row as it is under the lock, not the one read above (before the certificate
// request): a disable or another change in between must not be undone
patch: (current) => {
thisData = internalHost.cleanSslHstsData(
_.assign({}, { domain_names: current.domain_names }, requested),
current,
);
return thisData;
},
fetch: () =>
internalRedirectionHost.get(access, {
id: thisData.id,
expand: ["owner", "certificate"],
}),
audit: () =>
internalAuditLog.add(access, {
action: "updated",
object_type: "redirection-host",
object_id: thisData.id,
meta: thisData,
}),
});
})
.catch(async (err) => {
if (newCertificateId) {
await internalHost.discardUnusedCertificate(newCertificateId, () =>
internalCertificate.delete(access, { id: newCertificateId }),
);
}
throw err;
})
.then((row) => {
return _.omit(internalHost.cleanRowCertificateMeta(row), omissions());
});
},
/**
* @param {Access} access
* @param {Object} data
* @param {Number} data.id
* @param {Array} [data.expand]
* @param {Array} [data.omit]
* @return {Promise}
*/
get: (access, data) => {
const thisData = data || {};
return access
.can("redirection_hosts:get", thisData.id)
.then((access_data) => {
const query = redirectionHostModel
.query()
.where("is_deleted", 0)
.andWhere("id", thisData.id)
.allowGraph(redirectionHostModel.defaultAllowGraph)
.first();
if (access_data.permission_visibility !== "all") {
query.andWhere("owner_user_id", access.token.getUserId(1));
}
if (typeof thisData.expand !== "undefined" && thisData.expand !== null) {
query.withGraphFetched(`[${thisData.expand.join(", ")}]`);
}
return query.then(utils.omitRow(omissions()));
})
.then((row) => {
let thisRow = row;
if (!thisRow?.id) {
throw new errs.ItemNotFoundError(thisData.id);
}
thisRow = internalHost.cleanRowCertificateMeta(thisRow);
// Custom omissions
if (typeof thisData.omit !== "undefined" && thisData.omit !== null) {
return _.omit(thisRow, thisData.omit);
}
return thisRow;
});
},
/**
* @param {Access} access
* @param {Object} data
* @param {Number} data.id
* @param {String} [data.reason]
* @returns {Promise}
*/
delete: (access, data) => {
return access
.can("redirection_hosts:delete", data.id)
.then(() => {
return internalRedirectionHost.get(access, { id: data.id });
})
.then((row) => {
if (!row?.id) {
throw new errs.ItemNotFoundError(data.id);
}
return redirectionHostModel
.query()
.where("id", row.id)
.patch({
is_deleted: 1,
})
.then(() =>
// Delete Nginx Config. When nginx can't apply the removal it still serves the host
// (removeConfigAndReload() put its config back): the delete is undone
internalNginx.removeConfigAndReload("redirection_host", row).catch(async (err) => {
await redirectionHostModel.query().where("id", row.id).patch({ is_deleted: 0 });
throw err;
}),
)
.then(() => {
// Add to audit log
return internalAuditLog.add(access, {
action: "deleted",
object_type: "redirection-host",
object_id: row.id,
meta: _.omit(row, omissions()),
});
});
})
.then(() => {
return true;
});
},
/**
* @param {Access} access
* @param {Object} data
* @param {Number} data.id
* @param {String} [data.reason]
* @returns {Promise}
*/
enable: async (access, data) => {
await access.can("redirection_hosts:update", data.id);
// 404 and permission check before the lock is taken
await internalRedirectionHost.get(access, { id: data.id });
const row = await internalHost.setEnabledAndConfigure({
model: redirectionHostModel,
hostType: "redirection_host",
enable: true,
fetch: () => internalRedirectionHost.get(access, { id: data.id, expand: ["certificate", "owner"] }),
alreadyMessage: "Host is already enabled",
});
// Add to audit log
await internalAuditLog.add(access, {
action: "enabled",
object_type: "redirection-host",
object_id: row.id,
meta: _.omit(row, omissions()),
});
return true;
},
/**
* @param {Access} access
* @param {Object} data
* @param {Number} data.id
* @param {String} [data.reason]
* @returns {Promise}
*/
disable: async (access, data) => {
await access.can("redirection_hosts:update", data.id);
await internalRedirectionHost.get(access, { id: data.id });
const row = await internalHost.setEnabledAndConfigure({
model: redirectionHostModel,
hostType: "redirection_host",
enable: false,
fetch: () => internalRedirectionHost.get(access, { id: data.id }),
alreadyMessage: "Host is already disabled",
});
// Add to audit log
await internalAuditLog.add(access, {
action: "disabled",
object_type: "redirection-host",
object_id: row.id,
meta: _.omit(row, omissions()),
});
return true;
},
/**
* All Hosts
*
* @param {Access} access
* @param {Array} [expand]
* @param {String} [search_query]
* @returns {Promise}
*/
getAll: (access, expand, search_query) => {
return access
.can("redirection_hosts:list")
.then((access_data) => {
const query = redirectionHostModel
.query()
.where("is_deleted", 0)
.groupBy("id")
.allowGraph(redirectionHostModel.defaultAllowGraph)
.orderBy(castJsonIfNeed("domain_names"), "ASC");
if (access_data.permission_visibility !== "all") {
query.andWhere("owner_user_id", access.token.getUserId(1));
}
// Query is used for searching
if (typeof search_query === "string" && search_query.length > 0) {
query.where(function () {
this.where(castJsonIfNeed("domain_names"), "like", `%${search_query}%`);
});
}
if (typeof expand !== "undefined" && expand !== null) {
query.withGraphFetched(`[${expand.join(", ")}]`);
}
return query.then(utils.omitRows(omissions()));
})
.then((rows) => {
if (typeof expand !== "undefined" && expand !== null && expand.indexOf("certificate") !== -1) {
return internalHost.cleanAllRowsCertificateMeta(rows);
}
return rows;
});
},
/**
* Report use
*
* @param {Number} user_id
* @param {String} visibility
* @returns {Promise}
*/
getCount: (user_id, visibility) => {
const query = redirectionHostModel.query().count("id as count").where("is_deleted", 0);
if (visibility !== "all") {
query.andWhere("owner_user_id", user_id);
}
return query.first().then((row) => {
return Number.parseInt(row.count, 10);
});
},
};
export default internalRedirectionHost;