mirror of
https://github.com/NginxProxyManager/nginx-proxy-manager.git
synced 2026-11-19 14:40:27 +00:00
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>
476 lines
14 KiB
JavaScript
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;
|