Refactor cancel fetch data

.github/workflows/publish-npm.yml

@@ -19,17 +19,23 @@ jobs:
           node-version: 20
 
       - name: Create .npmrc file
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           echo "@internxt:registry=https://npm.pkg.github.com/" > .npmrc
-          echo "//npm.pkg.github.com/:_authToken=${{ secrets.GITHUB_TOKEN }}" >> .npmrc
+          echo "//npm.pkg.github.com/:_authToken=$GITHUB_TOKEN >> .npmrc
 
       - name: Publish package to github
         run: npm publish --scope=@internxt --access public
 
       - name: Create .npmrc file
+        shell: bash
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
         run: |
           echo "registry=https://registry.npmjs.org/" > .npmrc
-          echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" >> .npmrc
+          echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> .npmrc
 
       - name: Publish package to npm
         run: npm publish --scope=@internxt --access public

binding.gyp

@@ -21,7 +21,6 @@
         "native-src/placeholders_interface/Planceholders.cpp",
         "native-src/sync_root_interface/SyncRoot.cpp",
         "native-src/sync_root_interface/Utilities.cpp",
-        "native-src/sync_root_interface/callbacks/Callbacks.cpp",
         "native-src/sync_root_interface/callbacks/CancelFetchData/CancelFetchDataCallback.cpp",
         "native-src/sync_root_interface/callbacks/FetchData/FetchData.cpp",
         "native-src/sync_root_interface/callbacks/FetchData/FileCopierWithProgress.cpp",

include/sync_root_interface/Utilities.h

@@ -3,7 +3,6 @@
 class Utilities
 {
 public:
-    static void AddFolderToSearchIndexer(_In_ LPCWSTR folder);
     static void ApplyTransferStateToFile(_In_ LPCWSTR fullPath, _In_ CF_CALLBACK_INFO &callbackInfo, UINT64 total, UINT64 completed);
     static std::wstring GetErrorMessageCloudFiles(HRESULT hr);
 

include/sync_root_interface/callbacks/Callbacks.h

@@ -2,8 +2,6 @@
 
 #include <CallbacksContext.h>
 
-void register_threadsafe_callbacks(napi_env env, InputSyncCallbacks input);
-
 // Fetch Data Callback
 void register_threadsafe_fetch_data_callback(const std::string &resource_name, napi_env env, InputSyncCallbacks input);
 void CALLBACK fetch_data_callback_wrapper(_In_ CONST CF_CALLBACK_INFO *callbackInfo, _In_ CONST CF_CALLBACK_PARAMETERS *callbackParameters);

native-src/sync_root_interface/SyncRoot.cpp

@@ -6,9 +6,6 @@
 #include <iostream>
 #include <vector>
 
-namespace fs = std::filesystem;
-// variable to disconect
-CF_CONNECTION_KEY gloablConnectionKey;
 std::map<std::wstring, CF_CONNECTION_KEY> connectionMap;
 
 void SyncRoot::HydrateFile(const wchar_t *filePath)
@@ -58,8 +55,8 @@ void SyncRoot::HydrateFile(const wchar_t *filePath)
 
 HRESULT SyncRoot::ConnectSyncRoot(const wchar_t *syncRootPath, InputSyncCallbacks syncCallbacks, napi_env env, CF_CONNECTION_KEY *connectionKey)
 {
-    Utilities::AddFolderToSearchIndexer(syncRootPath);
-    register_threadsafe_callbacks(env, syncCallbacks);
+    register_threadsafe_fetch_data_callback("FetchDataThreadSafe", env, syncCallbacks);
+    register_threadsafe_cancel_fetch_data_callback("CancelFetchDataThreadSafe", env, syncCallbacks);
 
     CF_CALLBACK_REGISTRATION callbackTable[] = {
         {CF_CALLBACK_TYPE_FETCH_DATA, fetch_data_callback_wrapper},

native-src/sync_root_interface/Utilities.cpp

@@ -5,43 +5,8 @@
 #include "Utilities.h"
 #include <Logger.h>
 
-#define MSSEARCH_INDEX L"SystemIndex"
 DEFINE_PROPERTYKEY(PKEY_StorageProviderTransferProgress, 0xE77E90DF, 0x6271, 0x4F5B, 0x83, 0x4F, 0x2D, 0xD1, 0xF2, 0x45, 0xDD, 0xA4, 4);
 
-void Utilities::AddFolderToSearchIndexer(_In_ PCWSTR folder)
-{
-    HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
-    if (FAILED(hr))
-    {
-        wprintf(L"Failed to initialize COM library. Error code = %08x\n", hr);
-        return;
-    }
-
-    std::wstring url(L"file:///");
-    url.append(folder);
-
-    try
-    {
-        winrt::com_ptr<ISearchManager> searchManager;
-        winrt::check_hresult(CoCreateInstance(__uuidof(CSearchManager), NULL, CLSCTX_SERVER, __uuidof(&searchManager), searchManager.put_void()));
-
-        winrt::com_ptr<ISearchCatalogManager> searchCatalogManager;
-        winrt::check_hresult(searchManager->GetCatalog(MSSEARCH_INDEX, searchCatalogManager.put()));
-
-        winrt::com_ptr<ISearchCrawlScopeManager> searchCrawlScopeManager;
-        winrt::check_hresult(searchCatalogManager->GetCrawlScopeManager(searchCrawlScopeManager.put()));
-
-        winrt::check_hresult(searchCrawlScopeManager->AddDefaultScopeRule(url.data(), TRUE, FOLLOW_FLAGS::FF_INDEXCOMPLEXURLS));
-        winrt::check_hresult(searchCrawlScopeManager->SaveAll());
-
-        // wprintf(L"Succesfully called AddFolderToSearchIndexer on \"%s\"\n", url.data());
-    }
-    catch (...)
-    {
-        wprintf(L"Failed on call to AddFolderToSearchIndexer for \"%s\" with %08x\n", url.data(), static_cast<HRESULT>(winrt::to_hresult()));
-    }
-}
-
 void Utilities::ApplyTransferStateToFile(_In_ PCWSTR fullPath, _In_ CF_CALLBACK_INFO &callbackInfo, UINT64 total, UINT64 completed)
 {
     Logger::getInstance().log("ApplyTransferStateToFile", LogLevel::INFO);

native-src/sync_root_interface/callbacks/CancelFetchData/CancelFetchDataCallback.cpp

@@ -7,20 +7,25 @@
 #include <mutex>
 #include <filesystem>
 
-napi_threadsafe_function g_cancel_delete_fetch_data_threadsafe_callback = nullptr;
+napi_threadsafe_function g_cancel_fetch_data_threadsafe_callback = nullptr;
 
-inline std::mutex mtx;
-inline std::condition_variable cv;
-inline bool ready = false;
+struct CallbackContext {
+    std::mutex mtx;
+    std::condition_variable cv;
+    bool ready = false;
+};
 
-struct CancelFetchDataArgs
-{
+struct CancelFetchDataArgs {
     std::wstring fileIdentityArg;
+    CallbackContext* context;
+
+    CancelFetchDataArgs(const std::wstring& fileId, CallbackContext* ctx) 
+        : fileIdentityArg(fileId), context(ctx) {}
 };
 
 void setup_global_tsfn_cancel_fetch_data(napi_threadsafe_function tsfn)
 {
-    g_cancel_delete_fetch_data_threadsafe_callback = tsfn;
+    g_cancel_fetch_data_threadsafe_callback = tsfn;
 }
 
 void notify_cancel_fetch_data_call(napi_env env, napi_value js_callback, void *context, void *data)
@@ -43,23 +48,27 @@ void notify_cancel_fetch_data_call(napi_env env, napi_value js_callback, void *c
     {
         fprintf(stderr, "Failed to call JS function.\n");
         Logger::getInstance().log("Failed to call JS function in cancelFetchCallback.", LogLevel::ERROR);
-        return;
     }
 
-    cv.notify_one();
+    {
+        std::lock_guard<std::mutex> lock(args->context->mtx);
+        args->context->ready = true;
+    }
+
+    args->context->cv.notify_one();
     delete args;
 }
 
 void register_threadsafe_cancel_fetch_data_callback(const std::string &resource_name, napi_env env, InputSyncCallbacks input)
 {
-    std::u16string converted_resource_name = std::u16string(resource_name.begin(), resource_name.end());
+    std::u16string converted_resource_name(resource_name.begin(), resource_name.end());
 
     napi_value resource_name_value;
     napi_create_string_utf16(env, converted_resource_name.c_str(), NAPI_AUTO_LENGTH, &resource_name_value);
 
     napi_threadsafe_function tsfn_cancel_fetch_data;
     napi_value cancel_fetch_data_value;
-    napi_status status_ref = napi_get_reference_value(env, input.cancel_fetch_data_callback_ref, &cancel_fetch_data_value);
+    napi_get_reference_value(env, input.cancel_fetch_data_callback_ref, &cancel_fetch_data_value);
 
     napi_status status = napi_create_threadsafe_function(
         env,
@@ -76,47 +85,44 @@ void register_threadsafe_cancel_fetch_data_callback(const std::string &resource_
 
     if (status != napi_ok)
     {
-        fprintf(stderr, "Failed to create threadsafe function.\n");
+        napi_throw_error(env, nullptr, "Failed to create cancel fetch data threadsafe function");
         return;
     }
+
     setup_global_tsfn_cancel_fetch_data(tsfn_cancel_fetch_data);
 }
 
 void CALLBACK cancel_fetch_data_callback_wrapper(
     _In_ CONST CF_CALLBACK_INFO *callbackInfo,
     _In_ CONST CF_CALLBACK_PARAMETERS *callbackParameters)
 {
-    printf("fetch_data_callback_wrapper\n");
+    printf("cancel_fetch_data_callback_wrapper called\n");
 
     LPCVOID fileIdentity = callbackInfo->FileIdentity;
     DWORD fileIdentityLength = callbackInfo->FileIdentityLength;
 
     const wchar_t *wchar_ptr = static_cast<const wchar_t *>(fileIdentity);
     std::wstring fileIdentityStr(wchar_ptr, fileIdentityLength / sizeof(wchar_t));
 
-    if (g_cancel_delete_fetch_data_threadsafe_callback == nullptr)
+    if (g_cancel_fetch_data_threadsafe_callback == nullptr)
     {
         wprintf(L"Callback fetch_data_callback_wrapper called but g_fetch_data_threadsafe_callback is null\n");
         return;
     }
+
+    CallbackContext context;
+    CancelFetchDataArgs *args = new CancelFetchDataArgs(fileIdentityStr, &context);
 
-    CancelFetchDataArgs *args = new CancelFetchDataArgs();
-    args->fileIdentityArg = fileIdentityStr;
-
-    napi_status status = napi_call_threadsafe_function(g_cancel_delete_fetch_data_threadsafe_callback, args, napi_tsfn_blocking);
+    napi_call_threadsafe_function(g_cancel_fetch_data_threadsafe_callback, args, napi_tsfn_blocking);
 
-    if (status != napi_ok)
     {
-        wprintf(L"Callback called unsuccessfully.\n");
-    };
+        std::unique_lock<std::mutex> lock(context.mtx);
+        auto timeout = std::chrono::seconds(30);
 
-    {
-        std::unique_lock<std::mutex> lock(mtx);
-        while (!ready)
-        {
-            cv.wait(lock);
+        if (context.cv.wait_for(lock, timeout, [&context] { return context.ready; })) {
+            wprintf(L"Cancel fetch completed\n");
+        } else {
+            wprintf(L"Cancel fetch timed out\n");
         }
     }
-
-    ready = false;
-}
+}