@photostructure/fs-metadata 1.4.0 → 2.0.0

package/src/linux/volume_metadata.cpp

@@ -27,6 +27,10 @@ public:
   }
 
   void Execute() override {
+    if (IsShuttingDown()) {
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       DEBUG_LOG("[LinuxMetadataWorker] starting statvfs for %s",
                 mountPoint.c_str());
@@ -181,4 +185,4 @@ Napi::Value GetVolumeMetadata(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/windows/hidden.cpp

@@ -1,6 +1,7 @@
 // src/windows/hidden.cpp
 #include "hidden.h"
 #include "../common/debug_log.h"
+#include "../common/shutdown.h"
 #include "error_utils.h"
 #include "security_utils.h"
 
@@ -36,14 +37,14 @@ public:
 };
 } // anonymous namespace
 
-class GetHiddenWorker : public Napi::AsyncWorker {
+class GetHiddenWorker : public SafeAsyncWorker {
   const std::string path;
   bool result = false;
   Napi::Promise::Deferred deferred;
 
 public:
   GetHiddenWorker(Napi::Env env, std::string p, Napi::Promise::Deferred def)
-      : Napi::AsyncWorker(env), path(std::move(p)), deferred(def) {}
+      : SafeAsyncWorker(env), path(std::move(p)), deferred(def) {}
 
   void Execute() override {
     try {
@@ -104,17 +105,17 @@ public:
     DEBUG_LOG("[GetHiddenWorker] OnOK called, result=%s",
               result ? "true" : "false");
     Napi::HandleScope scope(Env());
-    deferred.Resolve(Napi::Boolean::New(Env(), result));
+    SafeResolve(deferred, Napi::Boolean::New(Env(), result));
   }
 
   void OnError(const Napi::Error &e) override {
     DEBUG_LOG("[GetHiddenWorker] OnError called with: %s", e.Message().c_str());
     Napi::HandleScope scope(Env());
-    deferred.Reject(e.Value());
+    SafeReject(deferred, e.Value());
   }
 };
 
-class SetHiddenWorker : public Napi::AsyncWorker {
+class SetHiddenWorker : public SafeAsyncWorker {
   const std::string path;
   const bool value;
   Napi::Promise::Deferred deferred;
@@ -122,7 +123,7 @@ class SetHiddenWorker : public Napi::AsyncWorker {
 public:
   SetHiddenWorker(Napi::Env env, std::string p, bool v,
                   Napi::Promise::Deferred def)
-      : Napi::AsyncWorker(env), path(std::move(p)), value(v), deferred(def) {}
+      : SafeAsyncWorker(env), path(std::move(p)), value(v), deferred(def) {}
 
   void Execute() override {
     try {
@@ -144,12 +145,12 @@ public:
 
   void OnOK() override {
     Napi::HandleScope scope(Env());
-    deferred.Resolve(Napi::Boolean::New(Env(), true));
+    SafeResolve(deferred, Napi::Boolean::New(Env(), true));
   }
 
   void OnError(const Napi::Error &e) override {
     Napi::HandleScope scope(Env());
-    deferred.Reject(e.Value());
+    SafeReject(deferred, e.Value());
   }
 };
 
@@ -195,4 +196,4 @@ Napi::Promise SetHiddenAttribute(const Napi::CallbackInfo &info) {
   }
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/windows/volume_metadata.cpp

@@ -154,6 +154,10 @@ private:
   VolumeMetadataOptions options_;
 
   void Execute() override {
+    if (IsShuttingDown()) {
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       // Get drive status first
       DriveStatus status = CheckDriveStatus(mountPoint);
@@ -250,4 +254,4 @@ Napi::Value GetVolumeMetadata(const Napi::CallbackInfo &info) {
   return deferred.Promise();
 }
 
-} // namespace FSMeta
+} // namespace FSMeta

package/src/windows/volume_mount_points.cpp

@@ -2,6 +2,7 @@
 #include "../common/volume_mount_points.h"
 #include "../common/debug_log.h"
 #include "../common/error_utils.h"
+#include "../common/shutdown.h"
 #include "drive_status.h"
 #include "fs_meta.h"
 #include "security_utils.h"
@@ -21,7 +22,7 @@ struct DriveStringsBuffer {
       : buffer(std::make_unique<WCHAR[]>(size)) {}
 };
 
-class GetVolumeMountPointsWorker : public Napi::AsyncWorker {
+class GetVolumeMountPointsWorker : public SafeAsyncWorker {
 
 private:
   Napi::Promise::Deferred deferred_;
@@ -31,10 +32,14 @@ private:
 public:
   GetVolumeMountPointsWorker(const Napi::Promise::Deferred &deferred,
                              uint32_t timeoutMs = 5000)
-      : Napi::AsyncWorker(deferred.Env()), deferred_(deferred),
+      : SafeAsyncWorker(deferred.Env()), deferred_(deferred),
         timeoutMs_(timeoutMs) {}
 
   void Execute() override {
+    if (IsShuttingDown()) {
+      SetError("fs-metadata: shutdown in progress");
+      return;
+    }
     try {
       DEBUG_LOG("[GetVolumeMountPoints] getting logical drive strings size");
       DWORD size = GetLogicalDriveStringsW(0, nullptr);
@@ -74,12 +79,19 @@ public:
       }
 
       // Check all drive statuses in parallel
+      if (IsShuttingDown()) {
+        return;
+      }
       auto statuses = CheckDriveStatus(paths, timeoutMs_);
 
       // Build mount points from results
       mountPoints_.reserve(paths.size());
 
       for (size_t i = 0; i < paths.size(); i++) {
+        if (IsShuttingDown()) {
+          return;
+        }
+
         MountPoint mp;
         mp.mountPoint = paths[i];
         mp.status = DriveStatusToString(statuses[i]);
@@ -115,6 +127,7 @@ public:
   }
 
   void OnOK() override {
+    Napi::HandleScope scope(Env());
     auto env = Env();
     Napi::Array result = Napi::Array::New(env, mountPoints_.size());
 
@@ -122,7 +135,12 @@ public:
       result[i] = mountPoints_[i].ToObject(env);
     }
 
-    deferred_.Resolve(result);
+    SafeResolve(deferred_, result);
+  }
+
+  void OnError(const Napi::Error &error) override {
+    Napi::HandleScope scope(Env());
+    SafeReject(deferred_, error.Value());
   }
 
 }; // class GetVolumeMountPointsWorker
@@ -140,4 +158,4 @@ Napi::Promise GetVolumeMountPoints(const Napi::CallbackInfo &info) {
   worker->Queue();
   return deferred.Promise();
 }
-} // namespace FSMeta
+} // namespace FSMeta