reindexing sensitivity?

[rhatguy]

Is there a write up somewhere around what the different levels of reindexing sensitivity mean? I.E. what changes if I select low, medium, or high?

[bpatrik]

This is the relevant code part:

pigallery2/src/backend/model/database/sql/GalleryManager.ts

Lines 36 to 92 in bae5559

	public async listDirectory(relativeDirectoryName: string,
	knownLastModified?: number,
	knownLastScanned?: number): Promise<ParentDirectoryDTO> {
	const directoryPath = GalleryManager.parseRelativeDirePath(relativeDirectoryName);
	const connection = await SQLConnection.getConnection();
	const stat = fs.statSync(path.join(ProjectPath.ImageFolder, relativeDirectoryName));
	const lastModified = DiskMangerWorker.calcLastModified(stat);
	const dir = await this.selectParentDir(connection, directoryPath.name, directoryPath.parent);
	if (dir && dir.lastScanned != null) {
	// If it seems that the content did not changed, do not work on it
	if (knownLastModified && knownLastScanned
	&& lastModified === knownLastModified &&
	dir.lastScanned === knownLastScanned) {
	if (Config.Server.Indexing.reIndexingSensitivity === ReIndexingSensitivity.low) {
	return null;
	}
	if (Date.now() - dir.lastScanned <= Config.Server.Indexing.cachedFolderTimeout &&
	Config.Server.Indexing.reIndexingSensitivity === ReIndexingSensitivity.medium) {
	return null;
	}
	}
	if (dir.lastModified !== lastModified) {
	Logger.silly(LOG_TAG, 'Reindexing reason: lastModified mismatch: known: '
	+ dir.lastModified + ', current:' + lastModified);
	const ret = await ObjectManagers.getInstance().IndexingManager.indexDirectory(relativeDirectoryName);
	for (const subDir of ret.directories) {
	if (!subDir.preview) { // if sub directories does not have photos, so cannot show a preview, try get one from DB
	await this.fillPreviewForSubDir(connection, subDir);
	}
	}
	return ret;
	}
	// not indexed since a while, index it in a lazy manner
	if ((Date.now() - dir.lastScanned > Config.Server.Indexing.cachedFolderTimeout &&
	Config.Server.Indexing.reIndexingSensitivity >= ReIndexingSensitivity.medium) ||
	Config.Server.Indexing.reIndexingSensitivity >= ReIndexingSensitivity.high) {
	// on the fly reindexing
	Logger.silly(LOG_TAG, 'lazy reindexing reason: cache timeout: lastScanned: '
	+ (Date.now() - dir.lastScanned) + 'ms ago, cachedFolderTimeout:' + Config.Server.Indexing.cachedFolderTimeout);
	ObjectManagers.getInstance().IndexingManager.indexDirectory(relativeDirectoryName).catch(console.error);
	}
	await this.fillParentDir(connection, dir);
	return dir;
	}
	// never scanned (deep indexed), do it and return with it
	Logger.silly(LOG_TAG, 'Reindexing reason: never scanned');
	return ObjectManagers.getInstance().IndexingManager.indexDirectory(relativeDirectoryName);
	}

Its something like:

• low: only re-indexes if it detects a folder change
• medium: re-indexes every now and then
• high: re-indexes at every request asynchronously (= returns with whatever is in the DB but refreshes the DB after that)

low should be fine for most of the use-cases