feat: delete buffer from cache when released

src/apps/fuse/FuseApp.ts

@@ -56,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/ReadCallback.ts

@@ -17,7 +17,7 @@ export class ReadCallback {
     length: number,
     position: number
   ): Promise<number> {
-    Logger.debug('READING ', length, 'MB FROM ', filePath);
+    // Logger.debug('READING ', length, 'MB FROM ', filePath);
 
     const readResult = await this.offlineDrive.contentsChunkReader.run(
       filePath,

src/apps/fuse/callbacks/ReleaseCallback.ts

@@ -1,16 +1,39 @@
 import { OfflineDriveDependencyContainer } from '../dependency-injection/offline/OfflineDriveDependencyContainer';
+import { VirtualDriveDependencyContainer } from '../dependency-injection/virtual-drive/VirtualDriveDependencyContainer';
 import { NotifyFuseCallback } from './FuseCallback';
 
 export class ReleaseCallback extends NotifyFuseCallback {
-  constructor(private readonly container: OfflineDriveDependencyContainer) {
-    super('Release', { input: true });
+  constructor(
+    private readonly offlineDrive: OfflineDriveDependencyContainer,
+    private readonly virtualDrive: VirtualDriveDependencyContainer
+  ) {
+    super('Release');
   }
 
   async execute(path: string, _fd: number) {
-    const uploadError = await this.container.offlineFileUploader.run(path);
+    const offlineFile = await this.offlineDrive.offlineFileSearcher.run({
+      path,
+    });
 
-    if (uploadError) {
-      return this.left(uploadError);
+    if (offlineFile) {
+      await this.offlineDrive.offlineContentsUploader.run(
+        offlineFile.id,
+        offlineFile.path
+      );
+      return this.right();
+    }
+
+    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.right();
     }
 
     return this.right();

src/apps/fuse/dependency-injection/offline/BoundaryBridge/BoundaryBridgeContainer.ts

@@ -1,7 +1,5 @@
 import { OfflineFileAndContentsCreator } from '../../../../../context/offline-drive/boundaryBridge/application/OfflineFileAndContentsCreator';
-import { OfflineFileUploader } from '../../../../../context/offline-drive/boundaryBridge/application/OfflineFileUploader';
 
 export interface BoundaryBridgeContainer {
   offlineFileAndContentsCreator: OfflineFileAndContentsCreator;
-  offlineFileUploader: OfflineFileUploader
 }

src/apps/fuse/dependency-injection/offline/BoundaryBridge/boundaryBridgeContainerBuilder.ts

@@ -1,5 +1,4 @@
 import { OfflineFileAndContentsCreator } from '../../../../../context/offline-drive/boundaryBridge/application/OfflineFileAndContentsCreator';
-import { OfflineFileUploader } from '../../../../../context/offline-drive/boundaryBridge/application/OfflineFileUploader';
 import { OfflineContentsDependencyContainer } from '../OfflineContents/OfflineDriveDependencyContainer';
 import { OfflineFilesContainer } from '../OfflineFiles/OfflineFilesContainer';
 import { BoundaryBridgeContainer } from './BoundaryBridgeContainer';
@@ -13,13 +12,7 @@ export async function buildBoundaryBridgeContainer(
     offlineContentsContainer.offlineContentsCreator
   );
 
-  const offlineFileUploader = new OfflineFileUploader(
-    offlineFileContainer.offlineFileSearcher,
-    offlineContentsContainer.offlineContentsUploader
-  );
-
   return {
     offlineFileAndContentsCreator,
-    offlineFileUploader,
   };
 }

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

@@ -1,3 +1,4 @@
+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';
@@ -8,4 +9,5 @@ export interface OfflineContentsDependencyContainer {
   offlineContentsAppender: OfflineContentsAppender;
   offlineContentsUploader: OfflineContentsUploader;
   contentsChunkReader: ContentsChunkReader;
+  offlineContentsCacheCleaner: OfflineContentsCacheCleaner;
 }

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

@@ -1,5 +1,6 @@
 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';
@@ -55,10 +56,15 @@ export async function buildOfflineContentsContainer(
   const contentsRepository = new CachedFSContentsRepository();
   const contentsChunkReader = new ContentsChunkReader(contentsRepository);
 
+  const offlineContentsCacheCleaner = new OfflineContentsCacheCleaner(
+    contentsRepository
+  );
+
   return {
     offlineContentsCreator,
     offlineContentsAppender,
     offlineContentsUploader,
     contentsChunkReader,
+    offlineContentsCacheCleaner,
   };
 }

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

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

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

@@ -1,6 +1,7 @@
 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();
 
@@ -17,7 +18,11 @@ export class CachedFSContentsRepository implements ContentsRepository {
     return read;
   }
 
-  forget(_path: string): void {
-    //
+  async forget(path: string): Promise<void> {
+    const deleted = this.buffers.delete(path);
+
+    if (deleted) {
+      Logger.debug(`Buffer from ${basename(path)} deleted from cache`);
+    }
   }
 }