Gemini response:

You have correctly identified that the warning must be originating from within the file access operations in DiskManager.ts, which calls functions in this MetadataLoader.ts file.

After reviewing the code in MetadataLoader.ts, the most likely source of the unclosed file handle warning comes from the exifr library calls, which internally open and read files without guaranteeing the underlying file descriptor is closed in the event of an error.

The fix will involve explicitly telling exifr to use its file handle API so you can manage the resource closure yourself.

🔍 Identifying the Warning Source

The functions causing the issue are the asynchronous file-reading calls that are not wrapped in a resource-guaranteeing try...finally block involving a FileHandle.

1. In `loadPhotoMetadata`

The main suspect is the exifr.parse() call, which opens the file:

// Around Line 293 in loadPhotoMetadata:
        try {
          const exif = await exifr.parse(fullPath, exifrOptions); // <-- Suspect 1
          MetadataLoader.mapMetadata(metadata, exif, true);
        } catch (err) {
          try {
            const m = await sharp(fullPath, {failOnError: false}).metadata();
            MetadataLoader.mapMetadata(metadata, this.mapExifReader(exifReader(m.exif)), true);
          } catch (e) {
            // ignoring errors
          }
        }

If exifr.parse(fullPath, ...) is implemented using fs.promises.open() internally and does not handle the close operation in all scenarios, it leaks the FileHandle.

2. In `loadVideoMetadata`

A similar issue exists in the sidecar loading logic for videos:

// Around Line 159 in loadVideoMetadata:
        for (const sidecarPath of sidecarPaths) {
          if (fs.existsSync(sidecarPath)) {
            const sidecarData: any = await exifr.sidecar(sidecarPath); // <-- Suspect 2
            if (sidecarData !== undefined) {
              // sidecar should not change the video dimension
              MetadataLoader.mapMetadata(metadata, sidecarData, false);
            }
          }
        }

The exifr.sidecar(sidecarPath) call likely has the same resource management deficiency as exifr.parse().

🛠️ The Fix: Use `exifr` with an Explicit `FileHandle`

To comply with the deprecation warning, you must use the fs.promises API to open the file yourself, then pass the resulting FileHandle to exifr.parse(handle, ...) and finally, ensure the handle is closed using try...finally.

Since you are already importing the synchronous fs module, you need to change it to use the asynchronous promises version (fsp) and the FileHandle type.

1. Update Imports

Change the top-level import to use fs.promises and the FileHandle type (which is required for this fix):

// OLD:
import * as fs from 'fs';
// ...
import * as util from 'node:util';
import * as path from 'path';

// NEW:
import * as fs from 'fs'; // Keep for fs.statSync and fs.existsSync
import {promises as fsp, FileHandle} from 'fs'; // <-- ADD THIS
// ...
import * as util from 'node:util';
import * as path from 'path';

2. Implement the Fix in `loadPhotoMetadata`

Wrap the exifr parsing in a try...finally block where you explicitly open and close the file handle.

// Around Line 293 (within the second `try` block in loadPhotoMetadata)

      try {
        let handle: FileHandle | undefined = undefined; // 1. Declare handle
        try {
          // 2. Open the file handle
          handle = await fsp.open(fullPath, 'r');
          // 3. Pass the handle to exifr.parse()
          const exif = await exifr.parse(handle, exifrOptions); 
          MetadataLoader.mapMetadata(metadata, exif, true);
        } catch (err) {
          // You must have a nested try/catch here to handle potential failures
          try {
            const m = await sharp(fullPath, {failOnError: false}).metadata();
            MetadataLoader.mapMetadata(metadata, this.mapExifReader(exifReader(m.exif)), true);
          } catch (e) {
            // ignoring errors
          }
        } finally {
          // 4. Close the handle in finally
          if (handle) {
            await handle.close();
          }
        }

        // ... existing sidecar loading code ...

3. Implement the Fix in `loadVideoMetadata` (Sidecar)

You need the same pattern for the sidecar loading, replacing exifr.sidecar(sidecarPath) with the fsp.open() and exifr.sidecar(handle) pattern.

// Around Line 165 (within the second `try` block in loadVideoMetadata)

        for (const sidecarPath of sidecarPaths) {
          if (fs.existsSync(sidecarPath)) {
            let handle: FileHandle | undefined = undefined; // 1. Declare handle
            try {
              // 2. Open the file handle
              handle = await fsp.open(sidecarPath, 'r');
              // 3. Pass the handle to exifr.sidecar()
              const sidecarData: any = await exifr.sidecar(handle);
              if (sidecarData !== undefined) {
                // sidecar should not change the video dimension
                MetadataLoader.mapMetadata(metadata, sidecarData, false);
                break;
              }
            } finally {
              // 4. Close the handle in finally
              if (handle) {
                await handle.close();
              }
            }
          }
        }

Applying these changes will explicitly close the file handles and eliminate the deprecation warning.

🔍 Identifying the Warning Source

1. In loadPhotoMetadata

2. In loadVideoMetadata

🛠️ The Fix: Use exifr with an Explicit FileHandle

Uh oh!

Memory leaking during indexing job #1070

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions