gaschz/trilium
1
0
Fork 0
mirror of https://github.com/zadam/trilium.git synced 2025-06-06 18:08:33 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

run consistency checks on demand

Browse Source
This commit is contained in:
zadam 2019-12-10 22:03:00 +01:00
parent ee15db0ae1
commit dce54c7af3
4 changed files with 613 additions and 627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/public/javascripts/dialogs/options/advanced.js
View File

@ -13,6 +13,10 @@ const TPL = `
<br/>
<br/>
<h4>Consistency checks</h4>
<button id="find-and-fix-consistency-issues-button" class="btn">Find and fix consistency issues</button><br/><br/>
<h4>Debugging</h4>
<button id="anonymize-button" class="btn">Save anonymized database</button><br/><br/>
@ -33,9 +37,8 @@ export default class AdvancedOptions {
this.$forceFullSyncButton = $("#force-full-sync-button");
this.$fillSyncRowsButton = $("#fill-sync-rows-button");
this.$anonymizeButton = $("#anonymize-button");
this.$cleanupSoftDeletedButton = $("#cleanup-soft-deleted-items-button");
this.$cleanupUnusedImagesButton = $("#cleanup-unused-images-button");
this.$vacuumDatabaseButton = $("#vacuum-database-button");
this.$findAndFixConsistencyIssuesButton = $("#find-and-fix-consistency-issues-button");
this.$forceFullSyncButton.on('click', async () => {
await server.post('sync/force-full-sync');
@ -55,26 +58,16 @@ export default class AdvancedOptions {
toastService.showMessage("Created anonymized database");
});
this.$cleanupSoftDeletedButton.on('click', async () => {
if (confirm("Do you really want to clean up soft-deleted items?")) {
await server.post('cleanup/cleanup-soft-deleted-items');
toastService.showMessage("Soft deleted items have been cleaned up");
}
});
this.$cleanupUnusedImagesButton.on('click', async () => {
if (confirm("Do you really want to clean up unused images?")) {
await server.post('cleanup/cleanup-unused-images');
toastService.showMessage("Unused images have been cleaned up");
}
});
this.$vacuumDatabaseButton.on('click', async () => {
await server.post('cleanup/vacuum-database');
toastService.showMessage("Database has been vacuumed");
});
this.$findAndFixConsistencyIssuesButton.on('click', async () => {
await server.post('cleanup/find-and-fix-consistency-issues');
toastService.showMessage("Consistency issues should be fixed.");
});
}
}

8
src/routes/api/cleanup.js
View File

@ -2,6 +2,7 @@
const sql = require('../../services/sql');
const log = require('../../services/log');
const consistencyChecksService = require('../../services/consistency_checks');
async function vacuumDatabase() {
await sql.execute("VACUUM");
@ -9,6 +10,11 @@ async function vacuumDatabase() {
log.info("Database has been vacuumed.");
}
async function findAndFixConsistencyIssues() {
await consistencyChecksService.runOnDemandChecks(true);
}
module.exports = {
vacuumDatabase
vacuumDatabase,
findAndFixConsistencyIssues
};

3
src/routes/routes.js
View File

@ -215,10 +215,11 @@ function register(app) {
apiRoute(POST, '/api/sql/execute', sqlRoute.execute);
apiRoute(POST, '/api/anonymization/anonymize', anonymizationRoute.anonymize);
apiRoute(POST, '/api/cleanup/cleanup-unused-images', cleanupRoute.cleanupUnusedImages);
// VACUUM requires execution outside of transaction
route(POST, '/api/cleanup/vacuum-database', [auth.checkApiAuthOrElectron, csrfMiddleware], cleanupRoute.vacuumDatabase, apiResultHandler, false);
route(POST, '/api/cleanup/find-and-fix-consistency-issues', [auth.checkApiAuthOrElectron, csrfMiddleware], cleanupRoute.findAndFixConsistencyIssues, apiResultHandler, false);
apiRoute(POST, '/api/script/exec', scriptRoute.exec);
apiRoute(POST, '/api/script/run/:noteId', scriptRoute.run);
apiRoute(GET, '/api/script/startup', scriptRoute.getStartupBundles);

532
src/services/consistency_checks.js
View File

@ -11,46 +11,47 @@ const syncTableService = require('./sync_table');
const optionsService = require('./options');
const Branch = require('../entities/branch');
let unrecoveredConsistencyErrors = false;
let fixedIssues = false;
class ConsistencyChecks {
constructor(autoFix) {
this.autoFix = autoFix;
this.unrecoveredConsistencyErrors = false;
this.fixedIssues = false;
}
async function findIssues(query, errorCb) {
async findIssues(query, errorCb) {
const results = await sql.getRows(query);
for (const res of results) {
logError(errorCb(res));
unrecoveredConsistencyErrors = true;
this.unrecoveredConsistencyErrors = true;
}
return results;
}
}
async function findAndFixIssues(query, fixerCb) {
async findAndFixIssues(query, fixerCb) {
const results = await sql.getRows(query);
for (const res of results) {
const autoFix = await optionsService.getOptionBool('autoFixConsistencyIssues');
try {
await fixerCb(res, autoFix);
await fixerCb(res);
if (autoFix) {
fixedIssues = true;
if (this.autoFix) {
this.fixedIssues = true;
} else {
unrecoveredConsistencyErrors = true;
this.unrecoveredConsistencyErrors = true;
}
}
catch (e) {
} catch (e) {
logError(`Fixer failed with ${e.message} ${e.stack}`);
unrecoveredConsistencyErrors = true;
this.unrecoveredConsistencyErrors = true;
}
}
return results;
}
}
async function checkTreeCycles() {
async checkTreeCycles() {
const childToParents = {};
const rows = await sql.getRows("SELECT noteId, parentNoteId FROM branches WHERE isDeleted = 0");
@ -70,7 +71,7 @@ async function checkTreeCycles() {
if (!childToParents[noteId] || childToParents[noteId].length === 0) {
logError(`No parents found for note ${noteId}`);
unrecoveredConsistencyErrors = true;
this.unrecoveredConsistencyErrors = true;
return;
}
@ -78,9 +79,8 @@ async function checkTreeCycles() {
if (path.includes(parentNoteId)) {
logError(`Tree cycle detected at parent-child relationship: ${parentNoteId} - ${noteId}, whole path: ${path}`);
unrecoveredConsistencyErrors = true;
}
else {
this.unrecoveredConsistencyErrors = true;
} else {
const newPath = path.slice();
newPath.push(noteId);
@ -97,148 +97,145 @@ async function checkTreeCycles() {
if (childToParents['root'].length !== 1 || childToParents['root'][0] !== 'none') {
logError('Incorrect root parent: ' + JSON.stringify(childToParents['root']));
unrecoveredConsistencyErrors = true;
this.unrecoveredConsistencyErrors = true;
}
}
}
async function findBrokenReferenceIssues() {
await findAndFixIssues(`
async findBrokenReferenceIssues() {
await this.findAndFixIssues(`
SELECT branchId, branches.noteId
FROM branches LEFT JOIN notes USING(noteId)
WHERE branches.isDeleted = 0 AND notes.noteId IS NULL`,
async ({branchId, noteId}, autoFix) => {
if (autoFix) {
FROM branches
LEFT JOIN notes USING (noteId)
WHERE branches.isDeleted = 0
AND notes.noteId IS NULL`,
async ({branchId, noteId}) => {
if (this.autoFix) {
const branch = await repository.getBranch(branchId);
branch.isDeleted = true;
await branch.save();
logFix(`Branch ${branchId} has been deleted since it references missing note ${noteId}`);
}
else {
} else {
logError(`Branch ${branchId} references missing note ${noteId}`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT branchId, branches.noteId AS parentNoteId
FROM branches LEFT JOIN notes ON notes.noteId = branches.parentNoteId
WHERE branches.isDeleted = 0 AND branches.branchId != 'root' AND notes.noteId IS NULL`,
async ({branchId, parentNoteId}, autoFix) => {
if (autoFix) {
FROM branches
LEFT JOIN notes ON notes.noteId = branches.parentNoteId
WHERE branches.isDeleted = 0
AND branches.branchId != 'root'
AND notes.noteId IS NULL`,
async ({branchId, parentNoteId}) => {
if (this.autoFix) {
const branch = await repository.getBranch(branchId);
branch.parentNoteId = 'root';
await branch.save();
logFix(`Branch ${branchId} was set to root parent since it was referencing missing parent note ${parentNoteId}`);
}
else {
} else {
logError(`Branch ${branchId} references missing parent note ${parentNoteId}`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT attributeId, attributes.noteId
FROM attributes LEFT JOIN notes USING(noteId)
WHERE attributes.isDeleted = 0 AND notes.noteId IS NULL`,
async ({attributeId, noteId}, autoFix) => {
if (autoFix) {
FROM attributes
LEFT JOIN notes USING (noteId)
WHERE attributes.isDeleted = 0
AND notes.noteId IS NULL`,
async ({attributeId, noteId}) => {
if (this.autoFix) {
const attribute = await repository.getAttribute(attributeId);
attribute.isDeleted = true;
await attribute.save();
logFix(`Attribute ${attributeId} has been deleted since it references missing source note ${noteId}`);
}
else {
} else {
logError(`Attribute ${attributeId} references missing source note ${noteId}`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT attributeId, attributes.value AS noteId
FROM attributes LEFT JOIN notes ON notes.noteId = attributes.value
WHERE attributes.isDeleted = 0 AND attributes.type = 'relation'
FROM attributes
LEFT JOIN notes ON notes.noteId = attributes.value
WHERE attributes.isDeleted = 0
AND attributes.type = 'relation'
AND notes.noteId IS NULL`,
async ({attributeId, noteId}, autoFix) => {
if (autoFix) {
async ({attributeId, noteId}) => {
if (this.autoFix) {
const attribute = await repository.getAttribute(attributeId);
attribute.isDeleted = true;
await attribute.save();
logFix(`Relation ${attributeId} has been deleted since it references missing note ${noteId}`)
}
else {
} else {
logError(`Relation ${attributeId} references missing note ${noteId}`)
}
});
await findIssues(`
await this.findIssues(`
SELECT noteRevisionId, note_revisions.noteId
FROM note_revisions LEFT JOIN notes USING(noteId)
FROM note_revisions
LEFT JOIN notes USING (noteId)
WHERE notes.noteId IS NULL`,
({noteRevisionId, noteId}) => `Note revision ${noteRevisionId} references missing note ${noteId}`);
}
}
async function findExistencyIssues() {
async findExistencyIssues() {
// principle for fixing inconsistencies is that if the note itself is deleted (isDeleted=true) then all related entities should be also deleted (branches, attributes)
// but if note is not deleted, then at least one branch should exist.
// the order here is important - first we might need to delete inconsistent branches and after that
// another check might create missing branch
await findAndFixIssues(`
SELECT
branchId, noteId
FROM
branches
JOIN notes USING(noteId)
WHERE
notes.isDeleted = 1
await this.findAndFixIssues(`
SELECT branchId,
noteId
FROM branches
JOIN notes USING (noteId)
WHERE notes.isDeleted = 1
AND branches.isDeleted = 0`,
async ({branchId, noteId}, autoFix) => {
if (autoFix) {
async ({branchId, noteId}) => {
if (this.autoFix) {
const branch = await repository.getBranch(branchId);
branch.isDeleted = true;
await branch.save();
logFix(`Branch ${branchId} has been deleted since associated note ${noteId} is deleted.`);
}
else {
} else {
logError(`Branch ${branchId} is not deleted even though associated note ${noteId} is deleted.`)
}
});
await findAndFixIssues(`
SELECT
branchId, parentNoteId
FROM
branches
await this.findAndFixIssues(`
SELECT branchId,
parentNoteId
FROM branches
JOIN notes AS parentNote ON parentNote.noteId = branches.parentNoteId
WHERE
parentNote.isDeleted = 1
WHERE parentNote.isDeleted = 1
AND branches.isDeleted = 0
`, async ({branchId, parentNoteId}, autoFix) => {
if (autoFix) {
`, async ({branchId, parentNoteId}) => {
if (this.autoFix) {
const branch = await repository.getBranch(branchId);
branch.isDeleted = true;
await branch.save();
logFix(`Branch ${branchId} has been deleted since associated parent note ${parentNoteId} is deleted.`);
}
else {
} else {
logError(`Branch ${branchId} is not deleted even though associated parent note ${parentNoteId} is deleted.`)
}
});
await findAndFixIssues(`
SELECT
DISTINCT notes.noteId
FROM
notes
await this.findAndFixIssues(`
SELECT DISTINCT notes.noteId
FROM notes
LEFT JOIN branches ON notes.noteId = branches.noteId AND branches.isDeleted = 0
WHERE
notes.isDeleted = 0
WHERE notes.isDeleted = 0
AND branches.branchId IS NULL
`, async ({noteId}, autoFix) => {
if (autoFix) {
`, async ({noteId}) => {
if (this.autoFix) {
const branch = await new Branch({
parentNoteId: 'root',
noteId: noteId,
@ -246,27 +243,22 @@ async function findExistencyIssues() {
}).save();
logFix(`Created missing branch ${branch.branchId} for note ${noteId}`);
}
else {
} else {
logError(`No undeleted branch found for note ${noteId}`);
}
});
// there should be a unique relationship between note and its parent
await findAndFixIssues(`
SELECT
noteId, parentNoteId
FROM
branches
WHERE
branches.isDeleted = 0
GROUP BY
branches.parentNoteId,
await this.findAndFixIssues(`
SELECT noteId,
parentNoteId
FROM branches
WHERE branches.isDeleted = 0
GROUP BY branches.parentNoteId,
branches.noteId
HAVING
COUNT(1) > 1`,
async ({noteId, parentNoteId}, autoFix) => {
if (autoFix) {
HAVING COUNT(1) > 1`,
async ({noteId, parentNoteId}) => {
if (this.autoFix) {
const branches = await repository.getEntities(
`SELECT *
FROM branches
@ -284,170 +276,156 @@ async function findExistencyIssues() {
logFix(`Removing branch ${branch.branchId} since it's parent-child duplicate of branch ${origBranch.branchId}`);
}
}
else {
} else {
logError(`Duplicate branches for note ${noteId} and parent ${parentNoteId}`);
}
});
}
}
async function findLogicIssues() {
await findAndFixIssues( `
async findLogicIssues() {
await this.findAndFixIssues(`
SELECT noteId, type
FROM notes
WHERE
isDeleted = 0
WHERE isDeleted = 0
AND type NOT IN ('text', 'code', 'render', 'file', 'image', 'search', 'relation-map', 'book')`,
async ({noteId, type}, autoFix) => {
if (autoFix) {
async ({noteId, type}) => {
if (this.autoFix) {
const note = await repository.getNote(noteId);
note.type = 'file'; // file is a safe option to recover notes if type is not known
await note.save();
logFix(`Note ${noteId} type has been change to file since it had invalid type=${type}`)
}
else {
} else {
logError(`Note ${noteId} has invalid type=${type}`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT notes.noteId
FROM notes
LEFT JOIN note_contents USING(noteId)
WHERE
note_contents.noteId IS NULL`,
async ({noteId}, autoFix) => {
if (autoFix) {
LEFT JOIN note_contents USING (noteId)
WHERE note_contents.noteId IS NULL`,
async ({noteId}) => {
if (this.autoFix) {
const note = await repository.getNote(noteId);
// empty string might be wrong choice for some note types (and protected notes) but it's a best guess
await note.setContent(note.isErased ? null : '');
logFix(`Note ${noteId} content was set to empty string since there was no corresponding row`);
}
else {
} else {
logError(`Note ${noteId} content row does not exist`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT noteId
FROM notes
JOIN note_contents USING(noteId)
WHERE
isDeleted = 0
JOIN note_contents USING (noteId)
WHERE isDeleted = 0
AND content IS NULL`,
async ({noteId}, autoFix) => {
if (autoFix) {
async ({noteId}) => {
if (this.autoFix) {
const note = await repository.getNote(noteId);
// empty string might be wrong choice for some note types (and protected notes) but it's a best guess
await note.setContent('');
logFix(`Note ${noteId} content was set to empty string since it was null even though it is not deleted`);
}
else {
} else {
logError(`Note ${noteId} content is null even though it is not deleted`);
}
});
await findIssues(`
await this.findIssues(`
SELECT noteId
FROM notes
JOIN note_contents USING(noteId)
WHERE
isErased = 1
JOIN note_contents USING (noteId)
WHERE isErased = 1
AND content IS NOT NULL`,
({noteId}) => `Note ${noteId} content is not null even though the note is erased`);
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT noteId, noteRevisionId
FROM notes
JOIN note_revisions USING(noteId)
WHERE
notes.isErased = 1
JOIN note_revisions USING (noteId)
WHERE notes.isErased = 1
AND note_revisions.isErased = 0`,
async ({noteId, noteRevisionId}, autoFix) => {
if (autoFix) {
async ({noteId, noteRevisionId}) => {
if (this.autoFix) {
const noteRevision = await repository.getNoteRevision(noteRevisionId);
noteRevision.isErased = true;
await noteRevision.setContent(null);
await noteRevision.save();
logFix(`Note revision ${noteRevisionId} has been erased since its note ${noteId} is also erased.`);
}
else {
} else {
logError(`Note revision ${noteRevisionId} is not erased even though note ${noteId} is erased.`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT note_revisions.noteRevisionId
FROM note_revisions
LEFT JOIN note_revision_contents USING(noteRevisionId)
LEFT JOIN note_revision_contents USING (noteRevisionId)
WHERE note_revision_contents.noteRevisionId IS NULL`,
async ({noteRevisionId}, autoFix) => {
if (autoFix) {
async ({noteRevisionId}) => {
if (this.autoFix) {
const noteRevision = await repository.getNoteRevision(noteRevisionId);
await noteRevision.setContent(null);
noteRevision.isErased = true;
await noteRevision.save();
logFix(`Note revision content ${noteRevisionId} was created and set to erased since it did not exist.`);
}
else {
} else {
logError(`Note revision content ${noteRevisionId} does not exist`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT noteRevisionId
FROM note_revisions
JOIN note_revision_contents USING(noteRevisionId)
WHERE
isErased = 0
JOIN note_revision_contents USING (noteRevisionId)
WHERE isErased = 0
AND content IS NULL`,
async ({noteRevisionId}, autoFix) => {
if (autoFix) {
async ({noteRevisionId}) => {
if (this.autoFix) {
const noteRevision = await repository.getNoteRevision(noteRevisionId);
noteRevision.isErased = true;
await noteRevision.save();
logFix(`Note revision ${noteRevisionId} content was set to empty string since it was null even though it is not erased`);
}
else {
} else {
logError(`Note revision ${noteRevisionId} content is null even though it is not erased`);
}
});
await findIssues(`
await this.findIssues(`
SELECT noteRevisionId
FROM note_revisions
JOIN note_revision_contents USING(noteRevisionId)
WHERE
isErased = 1
JOIN note_revision_contents USING (noteRevisionId)
WHERE isErased = 1
AND content IS NOT NULL`,
({noteRevisionId}) => `Note revision ${noteRevisionId} content is not null even though the note revision is erased`);
await findIssues(`
await this.findIssues(`
SELECT noteId
FROM notes
WHERE
isErased = 1
WHERE isErased = 1
AND isDeleted = 0`,
({noteId}) => `Note ${noteId} is not deleted even though it is erased`);
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT parentNoteId
FROM
branches
FROM branches
JOIN notes ON notes.noteId = branches.parentNoteId
WHERE
notes.isDeleted = 0
WHERE notes.isDeleted = 0
AND notes.type == 'search'
AND branches.isDeleted = 0`,
async ({parentNoteId}, autoFix) => {
if (autoFix) {
const branches = await repository.getEntities(`SELECT * FROM branches WHERE isDeleted = 0 AND parentNoteId = ?`, [parentNoteId]);
async ({parentNoteId}) => {
if (this.autoFix) {
const branches = await repository.getEntities(`SELECT *
FROM branches
WHERE isDeleted = 0
AND parentNoteId = ?`, [parentNoteId]);
for (const branch of branches) {
branch.parentNoteId = 'root';
@ -455,106 +433,92 @@ async function findLogicIssues() {
logFix(`Child branch ${branch.branchId} has been moved to root since it was a child of a search note ${parentNoteId}`)
}
}
else {
} else {
logError(`Search note ${parentNoteId} has children`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT attributeId
FROM attributes
WHERE
isDeleted = 0
WHERE isDeleted = 0
AND type = 'relation'
AND value = ''`,
async ({attributeId}, autoFix) => {
if (autoFix) {
async ({attributeId}) => {
if (this.autoFix) {
const relation = await repository.getAttribute(attributeId);
relation.isDeleted = true;
await relation.save();
logFix(`Removed relation ${relation.attributeId} of name "${relation.name} with empty target.`);
}
else {
} else {
logError(`Relation ${attributeId} has empty target.`);
}
});
await findAndFixIssues(`
SELECT
attributeId,
await this.findAndFixIssues(`
SELECT attributeId,
type
FROM attributes
WHERE
isDeleted = 0
WHERE isDeleted = 0
AND type != 'label'
AND type != 'label-definition'
AND type != 'relation'
AND type != 'relation-definition'`,
async ({attributeId, type}, autoFix) => {
if (autoFix) {
async ({attributeId, type}) => {
if (this.autoFix) {
const attribute = await repository.getAttribute(attributeId);
attribute.type = 'label';
await attribute.save();
logFix(`Attribute ${attributeId} type was changed to label since it had invalid type '${type}'`);
}
else {
} else {
logError(`Attribute ${attributeId} has invalid type '${type}'`);
}
});
await findAndFixIssues(`
SELECT
attributeId,
await this.findAndFixIssues(`
SELECT attributeId,
attributes.noteId
FROM
attributes
FROM attributes
JOIN notes ON attributes.noteId = notes.noteId
WHERE
attributes.isDeleted = 0
WHERE attributes.isDeleted = 0
AND notes.isDeleted = 1`,
async ({attributeId, noteId}, autoFix) => {
if (autoFix) {
async ({attributeId, noteId}) => {
if (this.autoFix) {
const attribute = await repository.getAttribute(attributeId);
attribute.isDeleted = true;
await attribute.save();
logFix(`Removed attribute ${attributeId} because owning note ${noteId} is also deleted.`);
}
else {
} else {
logError(`Attribute ${attributeId} is not deleted even though owning note ${noteId} is deleted.`);
}
});
await findAndFixIssues(`
SELECT
attributeId,
await this.findAndFixIssues(`
SELECT attributeId,
attributes.value AS targetNoteId
FROM
attributes
FROM attributes
JOIN notes ON attributes.value = notes.noteId
WHERE
attributes.type = 'relation'
WHERE attributes.type = 'relation'
AND attributes.isDeleted = 0
AND notes.isDeleted = 1`,
async ({attributeId, targetNoteId}, autoFix) => {
if (autoFix) {
async ({attributeId, targetNoteId}) => {
if (this.autoFix) {
const attribute = await repository.getAttribute(attributeId);
attribute.isDeleted = true;
await attribute.save();
logFix(`Removed attribute ${attributeId} because target note ${targetNoteId} is also deleted.`);
}
else {
} else {
logError(`Attribute ${attributeId} is not deleted even though target note ${targetNoteId} is deleted.`);
}
});
}
}
async function runSyncRowChecks(entityName, key) {
await findAndFixIssues(`
async runSyncRowChecks(entityName, key) {
await this.findAndFixIssues(`
SELECT
${key} as entityId
FROM
@ -562,18 +526,17 @@ async function runSyncRowChecks(entityName, key) {
LEFT JOIN sync ON sync.entityName = '${entityName}' AND entityId = ${key}
WHERE
sync.id IS NULL AND ` + (entityName === 'options' ? 'isSynced = 1' : '1'),
async ({entityId}, autoFix) => {
if (autoFix) {
async ({entityId}) => {
if (this.autoFix) {
await syncTableService.addEntitySync(entityName, entityId);
logFix(`Created missing sync record for entityName=${entityName}, entityId=${entityId}`);
}
else {
} else {
logError(`Missing sync record for entityName=${entityName}, entityId=${entityId}`);
}
});
await findAndFixIssues(`
await this.findAndFixIssues(`
SELECT
id, entityId
FROM
@ -582,92 +545,101 @@ async function runSyncRowChecks(entityName, key) {
WHERE
sync.entityName = '${entityName}'
AND ${key} IS NULL`,
async ({id, entityId}, autoFix) => {
if (autoFix) {
async ({id, entityId}) => {
if (this.autoFix) {
await sql.execute("DELETE FROM sync WHERE entityName = ? AND entityId = ?", [entityName, entityId]);
logFix(`Deleted extra sync record id=${id}, entityName=${entityName}, entityId=${entityId}`);
}
else {
} else {
logError(`Unrecognized sync record id=${id}, entityName=${entityName}, entityId=${entityId}`);
}
});
}
async function findSyncRowsIssues() {
await runSyncRowChecks("notes", "noteId");
await runSyncRowChecks("note_contents", "noteId");
await runSyncRowChecks("note_revisions", "noteRevisionId");
await runSyncRowChecks("branches", "branchId");
await runSyncRowChecks("recent_notes", "noteId");
await runSyncRowChecks("attributes", "attributeId");
await runSyncRowChecks("api_tokens", "apiTokenId");
await runSyncRowChecks("options", "name");
}
async function runAllChecks() {
unrecoveredConsistencyErrors = false;
fixedIssues = false;
await findBrokenReferenceIssues();
await findExistencyIssues();
await findLogicIssues();
await findSyncRowsIssues();
if (unrecoveredConsistencyErrors) {
// we run this only if basic checks passed since this assumes basic data consistency
await checkTreeCycles();
}
return !unrecoveredConsistencyErrors;
}
async findSyncRowsIssues() {
await this.runSyncRowChecks("notes", "noteId");
await this.runSyncRowChecks("note_contents", "noteId");
await this.runSyncRowChecks("note_revisions", "noteRevisionId");
await this.runSyncRowChecks("branches", "branchId");
await this.runSyncRowChecks("recent_notes", "noteId");
await this.runSyncRowChecks("attributes", "attributeId");
await this.runSyncRowChecks("api_tokens", "apiTokenId");
await this.runSyncRowChecks("options", "name");
}
async function showEntityStat(name, query) {
async runAllChecks() {
this.unrecoveredConsistencyErrors = false;
this.fixedIssues = false;
await this.findBrokenReferenceIssues();
await this.findExistencyIssues();
await this.findLogicIssues();
await this.findSyncRowsIssues();
if (this.unrecoveredConsistencyErrors) {
// we run this only if basic checks passed since this assumes basic data consistency
await this.checkTreeCycles();
}
return !this.unrecoveredConsistencyErrors;
}
async showEntityStat(name, query) {
const map = await sql.getMap(query);
map[0] = map[0] || 0;
map[1] = map[1] || 0;
log.info(`${name} deleted: ${map[1]}, not deleted ${map[0]}`);
}
}
async function runDbDiagnostics() {
await showEntityStat("Notes", `SELECT isDeleted, count(1) FROM notes GROUP BY isDeleted`);
await showEntityStat("Note revisions", `SELECT isErased, count(1) FROM note_revisions GROUP BY isErased`);
await showEntityStat("Branches", `SELECT isDeleted, count(1) FROM branches GROUP BY isDeleted`);
await showEntityStat("Attributes", `SELECT isDeleted, count(1) FROM attributes GROUP BY isDeleted`);
await showEntityStat("API tokens", `SELECT isDeleted, count(1) FROM api_tokens GROUP BY isDeleted`);
}
async runDbDiagnostics() {
await this.showEntityStat("Notes", `SELECT isDeleted, count(1)
FROM notes
GROUP BY isDeleted`);
await this.showEntityStat("Note revisions", `SELECT isErased, count(1)
FROM note_revisions
GROUP BY isErased`);
await this.showEntityStat("Branches", `SELECT isDeleted, count(1)
FROM branches
GROUP BY isDeleted`);
await this.showEntityStat("Attributes", `SELECT isDeleted, count(1)
FROM attributes
GROUP BY isDeleted`);
await this.showEntityStat("API tokens", `SELECT isDeleted, count(1)
FROM api_tokens
GROUP BY isDeleted`);
}
async function runChecks() {
async runChecks() {
let elapsedTimeMs;
await syncMutexService.doExclusively(async () => {
const startTime = new Date();
await runDbDiagnostics();
await this.runDbDiagnostics();
await runAllChecks();
await this.runAllChecks();
elapsedTimeMs = Date.now() - startTime.getTime();
});
if (fixedIssues) {
if (this.fixedIssues) {
ws.refreshTree();
}
if (unrecoveredConsistencyErrors) {
if (this.unrecoveredConsistencyErrors) {
log.info(`Consistency checks failed (took ${elapsedTimeMs}ms)`);
ws.sendMessageToAllClients({type: 'consistency-checks-failed'});
}
else {
} else {
log.info(`All consistency checks passed (took ${elapsedTimeMs}ms)`);
}
}
}
function logFix(message) {
@ -678,11 +650,25 @@ function logError(message) {
log.info("Consistency error: " + message);
}
async function runPeriodicChecks() {
const autoFix = await optionsService.getOptionBool('autoFixConsistencyIssues');
const consistencyChecks = new ConsistencyChecks(autoFix);
await consistencyChecks.runChecks();
}
async function runOnDemandChecks(autoFix) {
const consistencyChecks = new ConsistencyChecks(autoFix);
await consistencyChecks.runChecks();
}
sqlInit.dbReady.then(() => {
setInterval(cls.wrap(runChecks), 60 * 60 * 1000);
setInterval(cls.wrap(runPeriodicChecks), 60 * 60 * 1000);
// kickoff checks soon after startup (to not block the initial load)
setTimeout(cls.wrap(runChecks), 20 * 1000);
setTimeout(cls.wrap(runPeriodicChecks), 20 * 1000);
});
module.exports = {};
module.exports = {
runOnDemandChecks
};