Get placeholder states

Author: dajimenezriv-internxt

examples/callbacks/notify-fetch-data.callback.ts

@@ -1,10 +1,9 @@
 import { getInfoItem } from "examples/info-items-manager";
 
+import { TFetchDataCallback } from "@/types/callbacks.type";
 import { sleep } from "@/utils";
 
-type TCallback = (data: boolean, path: string, errorHandler?: () => void) => Promise<{ finished: boolean; progress: number }>;
-
-export const fetchDataCallback = async (id: string, callback: TCallback) => {
+export const fetchDataCallback = async (id: string, callback: Parameters<TFetchDataCallback>[1]) => {
   const path = await getInfoItem(id);
 
   let finish = false;

examples/populate.ts

@@ -6,7 +6,9 @@ import { v4 } from "uuid";
 
 import settings from "./settings";
 
-const rootFile1 = join(settings.syncRootPath, v4());
+const rootFileName1 = v4();
+const rootZipFileName = `${v4()}.zip`;
+const rootFile1 = join(settings.syncRootPath, rootFileName1);
 const rootFile2ChangeSize = join(settings.syncRootPath, `change-size-${v4()}.txt`);
 const rootFile3 = join(settings.syncRootPath, `${v4()}.txt`);
 const rootFile3Moved = join(settings.syncRootPath, `moved-${v4()}.txt`);
@@ -22,6 +24,7 @@ execSync(`echo Hello, world! > ${rootFile2ChangeSize}`);
 execSync(`echo Hello, world! >> ${rootFile2ChangeSize}`); // Sync
 execSync(`echo Hello, world! > ${rootFile3}`);
 execSync(`type nul > ${rootFile4}`); // No sync (0 bytes)
+execSync(`cd ${settings.syncRootPath} && tar -cf ${rootZipFileName} ${rootFileName1}`); // Sync
 execSync(`mv ${rootFile3} ${rootFile3Moved}`); // Sync
 execSync(`mkdir ${rootFolder1}`); // Sync
 execSync(`mkdir ${rootFolder2}`); // Cloud (no files inside)

examples/register.ts

@@ -20,14 +20,15 @@ const handlers = { handleAdd, handleHydrate, handleDehydrate, handleChangeSize }
 const notify = { onTaskSuccess: async () => undefined, onTaskProcessing: async () => undefined };
 const queueManager = new QueueManager(handlers, notify, settings.queuePersistPath);
 
-drive.registerSyncRoot(settings.driveName, settings.driveVersion, settings.providerid, callbacks, settings.iconPath);
-drive.connectSyncRoot();
-
-try {
-  initInfoItems();
-  drive.watchAndWait(settings.syncRootPath, queueManager, settings.watcherLogPath);
-} catch (error) {
-  logger.error(error);
-  drive.disconnectSyncRoot();
-  VirtualDrive.unregisterSyncRoot(settings.syncRootPath);
-}
+drive.registerSyncRoot(settings.driveName, settings.driveVersion, settings.providerid, callbacks, settings.iconPath).then(() => {
+  drive.connectSyncRoot();
+  
+  try {
+    initInfoItems();
+    drive.watchAndWait(settings.syncRootPath, queueManager, settings.watcherLogPath);
+  } catch (error) {
+    logger.error(error);
+    drive.disconnectSyncRoot();
+    VirtualDrive.unregisterSyncRoot(settings.syncRootPath);
+  }
+});

src/get-placeholder-states.ts

@@ -0,0 +1,30 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+
+import { isFileInDevice } from "./is-file-in-device";
+import VirtualDrive from "./virtual-drive";
+
+type TProps = {
+  self: VirtualDrive;
+  path: string;
+};
+
+export const getPlaceholderStates = async ({ self, path }: TProps) => {
+  const files = await readdir(path, { withFileTypes: true });
+
+  const promises = files.map(async (file) => {
+    const filePath = join(path, file.name);
+
+    if (file.isDirectory()) {
+      return getPlaceholderStates({ self, path: filePath });
+    } else {
+      const status = self.getPlaceholderState(filePath);
+      if (isFileInDevice(status)) {
+        const id = self.getFileIdentity(filePath);
+        self.watcher.fileInDevice.add(id);
+      }
+    }
+  });
+
+  await Promise.all(promises);
+};

src/is-file-in-device.ts

@@ -0,0 +1,12 @@
+import { PinState, SyncState } from "./types/placeholder.type";
+
+type TProps = {
+  syncState: SyncState;
+  pinState: PinState;
+};
+
+export const isFileInDevice = ({ syncState, pinState }: TProps) => {
+  const inSync = syncState === SyncState.InSync;
+  const isHydrated = pinState === PinState.AlwaysLocal || pinState === PinState.Unspecified;
+  return inSync && isHydrated;
+};

src/types/callbacks.type.ts

@@ -1,8 +1,12 @@
 export type NapiCallbackFunction = (...args: any[]) => any;
 
+export type TFetchDataCallback = (
+  id: string,
+  callback: (data: boolean, path: string, errorHandler?: () => void) => Promise<{ finished: boolean; progress: number }>,
+) => void;
+
 export type InputSyncCallbacks = {
-  // TODO: make it mandatory and add the exact type
-  fetchDataCallback?: NapiCallbackFunction;
+  fetchDataCallback: TFetchDataCallback;
   validateDataCallback?: NapiCallbackFunction;
   cancelFetchDataCallback?: NapiCallbackFunction;
   fetchPlaceholdersCallback?: NapiCallbackFunction;

src/virtual-drive.ts

@@ -1,44 +1,40 @@
 import path, { join, win32 } from "path";
 import fs from "fs";
 import { Watcher } from "./watcher/watcher";
-import { ExtraCallbacks, InputSyncCallbacks } from "./types/callbacks.type";
+import { Callbacks } from "./types/callbacks.type";
 import { Status } from "./types/placeholder.type";
 import { IQueueManager } from "./queue/queueManager";
 
 import { createLogger } from "./logger";
 import { Addon } from "./addon-wrapper";
+import { getPlaceholderStates } from "./get-placeholder-states";
+import winston from "winston";
 
 const addon = new Addon();
 
-type Callbacks = InputSyncCallbacks & ExtraCallbacks;
+const PLACEHOLDER_ATTRIBUTES = {
+  FILE_ATTRIBUTE_READONLY: 0x1,
+  FILE_ATTRIBUTE_HIDDEN: 0x2,
+  FOLDER_ATTRIBUTE_READONLY: 0x1,
+  FILE_ATTRIBUTE_NORMAL: 0x1,
+};
+
 class VirtualDrive {
-  PLACEHOLDER_ATTRIBUTES: { [key: string]: number };
   syncRootPath: string;
-  callbacks?: Callbacks;
-
-  // private watcherBuilder: WatcherBuilder;
-  private watcher: Watcher;
-
-  constructor(syncRootPath: string, loggerPath?: string) {
-    this.PLACEHOLDER_ATTRIBUTES = {
-      FILE_ATTRIBUTE_READONLY: 0x1,
-      FILE_ATTRIBUTE_HIDDEN: 0x2,
-      FOLDER_ATTRIBUTE_READONLY: 0x1,
-      FILE_ATTRIBUTE_NORMAL: 0x1,
-    };
+  callbacks!: Callbacks;
+  watcher = new Watcher();
+  logger: winston.Logger;
 
+  constructor(syncRootPath: string, loggerPath: string) {
     // TODO: getPlaceholderStates in the beginning
 
     this.watcher = new Watcher();
 
-    this.syncRootPath = syncRootPath;
+    this.syncRootPath = this.convertToWindowsPath(syncRootPath);
+    loggerPath = this.convertToWindowsPath(loggerPath);
     this.createSyncRootFolder();
-
-    let pathElements = this.syncRootPath.split("\\\\");
-    pathElements.pop();
-    let parentPath = pathElements.join("\\\\");
-
-    this.addLoggerPath(loggerPath ?? parentPath);
+    this.addLoggerPath(loggerPath);
+    this.logger = createLogger(loggerPath);
   }
 
   addLoggerPath(logPath: string) {
@@ -66,39 +62,6 @@ class VirtualDrive {
     return addon.getPlaceholderWithStatePending();
   }
 
-  getInputSyncCallbacks(): InputSyncCallbacks {
-    if (this.callbacks === undefined) {
-      throw new Error("Callbacks are not defined");
-    }
-
-    const inputSyncCallbackKeys: (keyof InputSyncCallbacks)[] = [
-      "fetchDataCallback",
-      "validateDataCallback",
-      "cancelFetchDataCallback",
-      "fetchPlaceholdersCallback",
-      "cancelFetchPlaceholdersCallback",
-      "notifyFileOpenCompletionCallback",
-      "notifyFileCloseCompletionCallback",
-      "notifyDehydrateCallback",
-      "notifyDehydrateCompletionCallback",
-      "notifyDeleteCallback",
-      "notifyDeleteCompletionCallback",
-      "notifyRenameCallback",
-      "notifyRenameCompletionCallback",
-      "noneCallback",
-    ];
-
-    const result: InputSyncCallbacks = {};
-
-    for (const key of inputSyncCallbackKeys) {
-      if (this.callbacks[key] !== undefined) {
-        result[key] = this.callbacks[key];
-      }
-    }
-
-    return result;
-  }
-
   createSyncRootFolder() {
     if (!fs.existsSync(this.syncRootPath)) {
       fs.mkdirSync(this.syncRootPath, { recursive: true });
@@ -117,8 +80,12 @@ class VirtualDrive {
     return addon.deleteFileSyncRoot({ path: this.fixPath(relativePath) });
   }
 
-  async connectSyncRoot(): Promise<any> {
-    return addon.connectSyncRoot({ callbacks: this.getInputSyncCallbacks() });
+  async connectSyncRoot() {
+    if (this.callbacks === undefined) {
+      throw new Error("Callbacks are not defined");
+    }
+
+    return addon.connectSyncRoot({ callbacks: this.callbacks });
   }
 
   createPlaceholderFile(
@@ -193,11 +160,18 @@ class VirtualDrive {
     this.callbacks = {
       ...callbacks,
       fetchDataCallback: (...args) => {
-        const path = args[0];
-        this.watcher.fileInDevice.add(path);
+        const id = args[0];
+        this.watcher.fileInDevice.add(id);
         return callbacks.fetchDataCallback?.(...args);
       }
     };
+
+    try {
+      await getPlaceholderStates({ self: this, path: this.syncRootPath});
+    } catch (exc) {
+      this.logger.error("getPlaceholderStates", exc)      
+    }
+
     return addon.registerSyncRoot({
       syncRootPath: this.syncRootPath,
       providerName,
@@ -227,7 +201,7 @@ class VirtualDrive {
 
     this.watcher.queueManager = queueManager;
 
-    this.watcher.logger = createLogger(loggerPath);
+    this.watcher.logger = this.logger;
 
     this.watcher.syncRootPath = path;
     this.watcher.options = {
@@ -271,7 +245,7 @@ class VirtualDrive {
         path.basename(fullPath),
         itemId,
         size,
-        this.PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
+        PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
         creationTime,
         lastWriteTime,
         Date.now(),
@@ -304,7 +278,7 @@ class VirtualDrive {
             itemId,
             true,
             size,
-            this.PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
+            PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
             creationTime,
             lastWriteTime,
             Date.now(),
@@ -338,7 +312,7 @@ class VirtualDrive {
               itemId,
               true,
               size,
-              this.PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
+              PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
               creationTime,
               lastWriteTime,
               Date.now(),
@@ -364,7 +338,7 @@ class VirtualDrive {
               itemId,
               true,
               0,
-              this.PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
+              PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
               Date.now(),
               Date.now(),
               Date.now(),
@@ -378,7 +352,7 @@ class VirtualDrive {
           path.basename(fullPath),
           itemId,
           size,
-          this.PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
+          PLACEHOLDER_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL,
           creationTime,
           lastWriteTime,
           Date.now(),

src/virtual-drive.unit.test.ts

@@ -1,9 +1,11 @@
 import fs from "fs";
 import { v4 } from "uuid";
 import { Mock } from "vitest";
+import { mockDeep } from "vitest-mock-extended";
 
 import { addon } from "@/addon";
 
+import { Callbacks } from "./types/callbacks.type";
 import VirtualDrive from "./virtual-drive";
 
 vi.mock("fs");
@@ -138,13 +140,14 @@ describe("VirtualDrive", () => {
       const providerVersion = "1.0.0";
       const providerId = v4();
       const logoPath = "C:\\iconPath";
-      const callbacks = {};
+      const callbacks = mockDeep<Callbacks>();
 
       // Act
+      expect(drive.callbacks).toBe(undefined);
       await drive.registerSyncRoot(providerName, providerVersion, providerId, callbacks, logoPath);
 
       // Assert
-      expect(drive.callbacks).toBe(callbacks);
+      expect(drive.callbacks).not.toBe(undefined);
       expect(addon.registerSyncRoot).toHaveBeenCalledWith(syncRootPath, providerName, providerVersion, providerId, logoPath);
     });
   });