[PB-1907] feat: cache file contents (#472)

* chore: extract upload logic to application service

* chore: use offlineFileUploader service

* feat: read chunks from cached files

* feat: delete buffer from cache when released

* chore: remove dead code

src/apps/fuse/FuseApp.ts

@@ -37,7 +37,10 @@ export class FuseApp {
       this.fuseContainer.offlineDriveContainer
     );
     const open = new OpenCallback(this.fuseContainer.virtualDriveContainer);
-    const read = new ReadCallback(this.fuseContainer.virtualDriveContainer);
+    const read = new ReadCallback(
+      this.fuseContainer.virtualDriveContainer,
+      this.fuseContainer.offlineDriveContainer
+    );
     const renameOrMove = new RenameOrMoveCallback(
       this.fuseContainer.virtualDriveContainer
     );
@@ -53,7 +56,8 @@ export class FuseApp {
     );
     const write = new WriteCallback(this.fuseContainer.offlineDriveContainer);
     const release = new ReleaseCallback(
-      this.fuseContainer.offlineDriveContainer
+      this.fuseContainer.offlineDriveContainer,
+      this.fuseContainer.virtualDriveContainer
     );
 
     return {

src/apps/fuse/callbacks/FuseErrors.ts

@@ -11,8 +11,8 @@ export class FuseError extends Error {
 }
 
 export class FuseNoSuchFileOrDirectoryError extends FuseError {
-  constructor() {
-    super(FuseCodes.ENOENT, 'No such file or directory');
+  constructor(readonly path: string) {
+    super(FuseCodes.ENOENT, `No such file or directory <${path}>`);
   }
 }
 

src/apps/fuse/callbacks/GetAttributesCallback.ts

@@ -26,11 +26,11 @@ export class GetAttributesCallback extends FuseCallback<GetAttributesCallbackDat
   }
 
   protected left(
-    error: FuseError
+    error: FuseNoSuchFileOrDirectoryError
   ): Either<FuseError, GetAttributesCallbackData> {
     // When the OS wants to check if a node exists will try to get the attributes of it
     // so not founding them is not an error
-    Logger.info(`Attributes of ${this.name}:.`);
+    Logger.info(`No attributes found for ${error.path}`);
     return left(error);
   }
 
@@ -88,6 +88,6 @@ export class GetAttributesCallback extends FuseCallback<GetAttributesCallbackDat
       });
     }
 
-    return this.left(new FuseNoSuchFileOrDirectoryError());
+    return this.left(new FuseNoSuchFileOrDirectoryError(path));
   }
 }

src/apps/fuse/callbacks/OpenCallback.ts

@@ -12,7 +12,7 @@ export class OpenCallback extends FuseCallback<number> {
     const file = await this.container.filesSearcher.run({ path });
 
     if (!file) {
-      return this.left(new FuseNoSuchFileOrDirectoryError());
+      return this.left(new FuseNoSuchFileOrDirectoryError(path));
     }
 
     try {

src/apps/fuse/callbacks/ReadCallback.ts

@@ -1,31 +1,36 @@
 import Logger from 'electron-log';
-import fs from 'fs/promises';
 import { VirtualDriveDependencyContainer } from '../dependency-injection/virtual-drive/VirtualDriveDependencyContainer';
+import { OfflineDriveDependencyContainer } from '../dependency-injection/offline/OfflineDriveDependencyContainer';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const fuse = require('@gcas/fuse');
 
 export class ReadCallback {
-  constructor(private readonly container: VirtualDriveDependencyContainer) {}
+  constructor(
+    private readonly virtualDrive: VirtualDriveDependencyContainer,
+    private readonly offlineDrive: OfflineDriveDependencyContainer
+  ) {}
 
   private async read(
     filePath: string,
     buffer: Buffer,
     length: number,
     position: number
   ): Promise<number> {
-    // Logger.debug('READING FILE FROM ', filePath, length, position);
-
-    const data = await fs.readFile(filePath);
+    const readResult = await this.offlineDrive.contentsChunkReader.run(
+      filePath,
+      length,
+      position
+    );
 
-    if (position >= data.length) {
-      Logger.debug('READ DONE');
+    if (!readResult.isPresent()) {
       return 0;
     }
 
-    const part = data.slice(position, position + length);
-    part.copy(buffer); // write the result of the read to the result buffer
-    return part.length; // number of bytes read
+    const chunk = readResult.get();
+
+    chunk.copy(buffer); // write the result of the read to the result buffer
+    return chunk.length; // number of bytes read
   }
 
   async execute(
@@ -36,14 +41,14 @@ export class ReadCallback {
     pos: number,
     cb: (code: number, params?: any) => void
   ) {
-    const file = await this.container.filesSearcher.run({ path });
+    const file = await this.virtualDrive.filesSearcher.run({ path });
 
     if (!file) {
       cb(fuse.ENOENT);
       return;
     }
 
-    const filePath = this.container.relativePathToAbsoluteConverter.run(
+    const filePath = this.virtualDrive.relativePathToAbsoluteConverter.run(
       file.contentsId
     );
 

src/apps/fuse/callbacks/ReleaseCallback.ts

@@ -1,28 +1,41 @@
 import { OfflineDriveDependencyContainer } from '../dependency-injection/offline/OfflineDriveDependencyContainer';
+import { VirtualDriveDependencyContainer } from '../dependency-injection/virtual-drive/VirtualDriveDependencyContainer';
 import { NotifyFuseCallback } from './FuseCallback';
-import { FuseIOError } from './FuseErrors';
 
 export class ReleaseCallback extends NotifyFuseCallback {
-  constructor(private readonly container: OfflineDriveDependencyContainer) {
+  constructor(
+    private readonly offlineDrive: OfflineDriveDependencyContainer,
+    private readonly virtualDrive: VirtualDriveDependencyContainer
+  ) {
     super('Release');
   }
 
   async execute(path: string, _fd: number) {
-    const file = await this.container.offlineFileSearcher.run({ path });
+    const offlineFile = await this.offlineDrive.offlineFileSearcher.run({
+      path,
+    });
 
-    if (!file) {
+    if (offlineFile) {
+      await this.offlineDrive.offlineContentsUploader.run(
+        offlineFile.id,
+        offlineFile.path
+      );
       return this.right();
     }
 
-    try {
-      await this.container.offlineContentsUploader.run(file.id, file.path);
-      return this.right();
-    } catch (err: unknown) {
-      if (err instanceof Error) {
-        return this.left(new FuseIOError());
-      }
+    const virtualFile = await this.virtualDrive.filesSearcher.run({ path });
+
+    if (virtualFile) {
+      const contentsPath =
+        this.virtualDrive.relativePathToAbsoluteConverter.run(
+          virtualFile.contentsId
+        );
+
+      await this.offlineDrive.offlineContentsCacheCleaner.run(contentsPath);
 
-      return this.left(new FuseIOError());
+      return this.right();
     }
+
+    return this.right();
   }
 }

src/apps/fuse/callbacks/RenameOrMoveCallback.ts

@@ -36,6 +36,6 @@ export class RenameOrMoveCallback extends NotifyFuseCallback {
       return this.right();
     }
 
-    return this.left(new FuseNoSuchFileOrDirectoryError());
+    return this.left(new FuseNoSuchFileOrDirectoryError(src));
   }
 }

src/apps/fuse/callbacks/TrashFileCallback.ts

@@ -15,7 +15,7 @@ export class TrashFileCallback extends NotifyFuseCallback {
     });
 
     if (!file) {
-      return this.left(new FuseNoSuchFileOrDirectoryError());
+      return this.left(new FuseNoSuchFileOrDirectoryError(path));
     }
 
     try {

src/apps/fuse/dependency-injection/offline/OfflineContents/OfflineDriveDependencyContainer.ts

@@ -1,3 +1,5 @@
+import { OfflineContentsCacheCleaner } from '../../../../../context/offline-drive/contents/application/OfflineContentsCacheCleaner';
+import { ContentsChunkReader } from '../../../../../context/offline-drive/contents/application/ContentsChunkReader';
 import { OfflineContentsAppender } from '../../../../../context/offline-drive/contents/application/OfflineContentsAppender';
 import { OfflineContentsCreator } from '../../../../../context/offline-drive/contents/application/OfflineContentsCreator';
 import { OfflineContentsUploader } from '../../../../../context/offline-drive/contents/application/OfflineContentsUploader';
@@ -6,4 +8,6 @@ export interface OfflineContentsDependencyContainer {
   offlineContentsCreator: OfflineContentsCreator;
   offlineContentsAppender: OfflineContentsAppender;
   offlineContentsUploader: OfflineContentsUploader;
+  contentsChunkReader: ContentsChunkReader;
+  offlineContentsCacheCleaner: OfflineContentsCacheCleaner;
 }

src/apps/fuse/dependency-injection/offline/OfflineContents/offlineContentsContainerBuilder.ts

@@ -1,8 +1,11 @@
+import { ContentsChunkReader } from '../../../../../context/offline-drive/contents/application/ContentsChunkReader';
 import { OfflineContentsAppender } from '../../../../../context/offline-drive/contents/application/OfflineContentsAppender';
+import { OfflineContentsCacheCleaner } from '../../../../../context/offline-drive/contents/application/OfflineContentsCacheCleaner';
 import { OfflineContentsCreator } from '../../../../../context/offline-drive/contents/application/OfflineContentsCreator';
 import { OfflineContentsUploader } from '../../../../../context/offline-drive/contents/application/OfflineContentsUploader';
 import { EnvironmentOfflineContentsManagersFactory } from '../../../../../context/offline-drive/contents/infrastructure/EnvironmentRemoteFileContentsManagersFactory';
 import { NodeFSOfflineContentsRepository } from '../../../../../context/offline-drive/contents/infrastructure/NodeFSOfflineContentsRepository';
+import { CachedFSContentsRepository } from '../../../../../context/offline-drive/contents/infrastructure/cache/CachedFSContentsRepository';
 import { MainProcessUploadProgressTracker } from '../../../../../context/shared/infrastructure/MainProcessUploadProgressTracker';
 import { FuseAppDataLocalFileContentsDirectoryProvider } from '../../../../../context/virtual-drive/shared/infrastructure/LocalFileContentsDirectoryProviders/FuseAppDataLocalFileContentsDirectoryProvider';
 import { DependencyInjectionEventBus } from '../../../../fuse/dependency-injection/common/eventBus';
@@ -50,9 +53,18 @@ export async function buildOfflineContentsContainer(
 
   const offlineContentsCreator = new OfflineContentsCreator(repository);
 
+  const contentsRepository = new CachedFSContentsRepository();
+  const contentsChunkReader = new ContentsChunkReader(contentsRepository);
+
+  const offlineContentsCacheCleaner = new OfflineContentsCacheCleaner(
+    contentsRepository
+  );
+
   return {
     offlineContentsCreator,
     offlineContentsAppender,
     offlineContentsUploader,
+    contentsChunkReader,
+    offlineContentsCacheCleaner,
   };
 }

src/apps/fuse/index.ts

@@ -5,18 +5,11 @@ import eventBus from '../main/event-bus';
 import { FuseApp } from './FuseApp';
 import path from 'path';
 import { FuseDependencyContainerFactory } from './dependency-injection/FuseDependencyContainerFactory';
-import { HydrationApi } from '../hydration-api/HydrationApi';
 import { getRootVirtualDrive } from '../main/virtual-root-folder/service';
 
 let fuseApp: FuseApp;
 
 async function startFuseApp() {
-  const api = new HydrationApi();
-
-  await api.start({
-    debug: false,
-  });
-
   const root = getRootVirtualDrive();
 
   Logger.debug('ROOT FOLDER: ', root);

src/context/offline-drive/contents/application/ContentsChunkReader.ts

@@ -0,0 +1,22 @@
+import { Optional } from '../../../../shared/types/Optional';
+import { ContentsRepository } from '../domain/ContentsRepository';
+
+export class ContentsChunkReader {
+  constructor(private readonly repository: ContentsRepository) {}
+
+  async run(
+    contentsPath: string,
+    length: number,
+    position: number
+  ): Promise<Optional<Buffer>> {
+    const data = await this.repository.read(contentsPath);
+
+    if (position >= data.length) {
+      return Optional.empty();
+    }
+
+    const chunk = data.slice(position, position + length);
+
+    return Optional.of(chunk);
+  }
+}

src/context/offline-drive/contents/application/OfflineContentsCacheCleaner.ts

@@ -0,0 +1,9 @@
+import { ContentsRepository } from '../domain/ContentsRepository';
+
+export class OfflineContentsCacheCleaner {
+  constructor(private readonly repository: ContentsRepository) {}
+
+  run(contentsPath: string): Promise<void> {
+    return this.repository.forget(contentsPath);
+  }
+}

src/context/offline-drive/contents/domain/ContentsRepository.ts

@@ -0,0 +1,5 @@
+export interface ContentsRepository {
+  read(path: string): Promise<Buffer>;
+
+  forget(path: string): Promise<void>;
+}

src/context/offline-drive/contents/infrastructure/cache/CachedFSContentsRepository.ts

@@ -0,0 +1,28 @@
+import { ContentsRepository } from '../../domain/ContentsRepository';
+import fs from 'fs/promises';
+import Logger from 'electron-log';
+import { basename } from 'path';
+export class CachedFSContentsRepository implements ContentsRepository {
+  private buffers: Map<string, Buffer> = new Map();
+
+  async read(path: string): Promise<Buffer> {
+    const cached = this.buffers.get(path);
+
+    if (cached) {
+      return cached;
+    }
+
+    const read = await fs.readFile(path);
+    this.buffers.set(path, read);
+
+    return read;
+  }
+
+  async forget(path: string): Promise<void> {
+    const deleted = this.buffers.delete(path);
+
+    if (deleted) {
+      Logger.debug(`Buffer from ${basename(path)} deleted from cache`);
+    }
+  }
+}

src/shared/types/Optional.ts

@@ -0,0 +1,23 @@
+export class Optional<T> {
+  private constructor(private readonly value: T | undefined) {}
+
+  static of<T>(value: T): Optional<T> {
+    return new Optional(value);
+  }
+
+  static empty<T>(): Optional<T> {
+    return new Optional<T>(undefined);
+  }
+
+  get(): T {
+    if (!this.value) {
+      throw new Error('Element not found');
+    }
+
+    return this.value;
+  }
+
+  isPresent(): boolean {
+    return this.value !== undefined;
+  }
+}

tests/context/offline-drive/boundaryBridge/__mocks__/GivenFileOfflineFileSearcher.ts

@@ -0,0 +1,16 @@
+import { OfflineFileSearcher } from '../../../../../src/context/offline-drive/files/application/OfflineFileSearcher';
+import {
+  OfflineFile,
+  OfflineFileAttributes,
+} from '../../../../../src/context/offline-drive/files/domain/OfflineFile';
+import { OfflineFileRepository } from '../../../../../src/context/offline-drive/files/domain/OfflineFileRepository';
+
+export class GivenFileOfflineFileSearcher extends OfflineFileSearcher {
+  constructor(private readonly file: OfflineFile) {
+    super({} as OfflineFileRepository);
+  }
+
+  async run(_partial: Partial<OfflineFileAttributes>) {
+    return this.file;
+  }
+}

tests/context/offline-drive/boundaryBridge/__mocks__/NoFileOfflineFileSearcher.ts

@@ -0,0 +1,13 @@
+import { OfflineFileSearcher } from '../../../../../src/context/offline-drive/files/application/OfflineFileSearcher';
+import { OfflineFileAttributes } from '../../../../../src/context/offline-drive/files/domain/OfflineFile';
+import { OfflineFileRepository } from '../../../../../src/context/offline-drive/files/domain/OfflineFileRepository';
+
+export class NoFileOfflineFileSearcher extends OfflineFileSearcher {
+  constructor() {
+    super({} as OfflineFileRepository);
+  }
+
+  async run(_partial: Partial<OfflineFileAttributes>) {
+    return undefined;
+  }
+}