@photostructure/fs-metadata 0.0.1 → 0.1.0

package/src/darwin/volume_metadata.cpp

@@ -1,5 +1,6 @@
 // src/darwin/volume_metadata.cpp
 
+#include "../common/debug_log.h"
 #include "./fs_meta.h"
 
 #include <CoreFoundation/CoreFoundation.h>
@@ -86,37 +87,44 @@ public:
 
 class GetVolumeMetadataWorker : public MetadataWorkerBase {
 public:
-  GetVolumeMetadataWorker(const std::string &path,
+  GetVolumeMetadataWorker(const std::string &mountPoint,
+                          const VolumeMetadataOptions &options,
                           const Napi::Promise::Deferred &deferred)
-      : MetadataWorkerBase(path, deferred) {
-
-    if (path.empty()) {
-      throw FSException("Mount point path cannot be empty");
-    }
-  }
+      : MetadataWorkerBase(mountPoint, deferred), options_(options) {}
 
   void Execute() override {
+    DEBUG_LOG("[GetVolumeMetadataWorker] Executing for mount point: %s",
+              mountPoint.c_str());
     try {
       if (!GetBasicVolumeInfo()) {
         return;
       }
       GetDiskArbitrationInfo();
     } catch (const std::exception &e) {
+      DEBUG_LOG("[GetVolumeMetadataWorker] Exception: %s", e.what());
       SetError(e.what());
     }
   }
 
 private:
+  VolumeMetadataOptions options_;
+
   bool GetBasicVolumeInfo() {
+    DEBUG_LOG("[GetVolumeMetadataWorker] Getting basic volume info for: %s",
+              mountPoint.c_str());
     struct statvfs vfs;
     struct statfs fs;
 
     if (statvfs(mountPoint.c_str(), &vfs) != 0) {
+      DEBUG_LOG("[GetVolumeMetadataWorker] statvfs failed: %s (%d)",
+                strerror(errno), errno);
       SetError(CreateErrorMessage("statvfs", errno));
       return false;
     }
 
     if (statfs(mountPoint.c_str(), &fs) != 0) {
+      DEBUG_LOG("[GetVolumeMetadataWorker] statfs failed: %s (%d)",
+                strerror(errno), errno);
       SetError(CreateErrorMessage("statfs", errno));
       return false;
     }
@@ -138,53 +146,96 @@ private:
     metadata.available = static_cast<double>(blockSize * availBlocks);
     metadata.used = static_cast<double>(blockSize * (totalBlocks - freeBlocks));
 
-    metadata.fileSystem = fs.f_fstypename;
+    metadata.fstype = fs.f_fstypename;
     metadata.mountFrom = fs.f_mntfromname;
     metadata.mountName = fs.f_mntonname;
     metadata.status = "ready";
 
+    DEBUG_LOG("[GetVolumeMetadataWorker] Volume info - size: %f, available: "
+              "%f, used: %f",
+              metadata.size, metadata.available, metadata.used);
     return true;
   }
 
   void GetDiskArbitrationInfo() {
+    DEBUG_LOG("[GetVolumeMetadataWorker] Getting Disk Arbitration info for: %s",
+              mountPoint.c_str());
+
+    // Check if this is a network filesystem
+    if (metadata.fstype == "smbfs" || metadata.fstype == "nfs" ||
+        metadata.fstype == "afpfs" || metadata.fstype == "webdav") {
+      // For network filesystems, we consider them healthy even without DA info
+      metadata.remote = true;
+      metadata.status = "healthy";
+      return;
+    }
+
     CFReleaser<DASessionRef> session(DASessionCreate(kCFAllocatorDefault));
     if (!session.isValid()) {
+      DEBUG_LOG("[GetVolumeMetadataWorker] Failed to create DA session");
       metadata.status = "partial";
+      metadata.error = "Failed to create DA session";
       return;
     }
 
-    // Schedule session with RunLoop
-    DASessionScheduleWithRunLoop(session.get(), CFRunLoopGetCurrent(),
-                                 kCFRunLoopDefaultMode);
-
-    // RAII cleanup for RunLoop scheduling
-    struct RunLoopCleaner {
-      DASessionRef session;
-      explicit RunLoopCleaner(DASessionRef s) : session(s) {}
-      ~RunLoopCleaner() {
-        DASessionUnscheduleFromRunLoop(session, CFRunLoopGetCurrent(),
-                                       kCFRunLoopDefaultMode);
+    try {
+      // RAII cleanup for RunLoop scheduling
+      struct RunLoopCleaner {
+        DASessionRef session;
+        explicit RunLoopCleaner(DASessionRef s) : session(s) {}
+        ~RunLoopCleaner() {
+          DASessionUnscheduleFromRunLoop(session, CFRunLoopGetCurrent(),
+                                         kCFRunLoopDefaultMode);
+        }
+      };
+
+      // Schedule session with RunLoop
+      DASessionScheduleWithRunLoop(session.get(), CFRunLoopGetCurrent(),
+                                   kCFRunLoopDefaultMode);
+
+      auto scopeGuard = std::make_unique<RunLoopCleaner>(session.get());
+
+      CFReleaser<DADiskRef> disk(DADiskCreateFromBSDName(
+          kCFAllocatorDefault, session.get(), metadata.mountFrom.c_str()));
+
+      if (!disk.isValid()) {
+        DEBUG_LOG("[GetVolumeMetadataWorker] Failed to create disk reference");
+        metadata.status = "partial";
+        metadata.error = "Failed to create disk reference";
+        return;
       }
-    } runLoopCleaner(session.get());
 
-    CFReleaser<DADiskRef> disk(DADiskCreateFromBSDName(
-        kCFAllocatorDefault, session.get(), metadata.mountFrom.c_str()));
+      CFReleaser<CFDictionaryRef> description(
+          DADiskCopyDescription(disk.get()));
+      if (!description.isValid()) {
+        DEBUG_LOG("[GetVolumeMetadataWorker] Failed to get disk description");
+        metadata.status = "partial";
+        metadata.error = "Failed to get disk description";
+        return;
+      }
 
-    if (!disk.isValid()) {
-      metadata.status = "partial";
-      return;
+      ProcessDiskDescription(description.get());
+
+      // Only set ready if we got this far without errors
+      if (metadata.status != "partial") {
+        metadata.status = "healthy";
+      }
+    } catch (const std::exception &e) {
+      DEBUG_LOG("[GetVolumeMetadataWorker] Exception: %s", e.what());
+      metadata.status = "error";
+      metadata.error = e.what();
     }
+  }
 
-    CFReleaser<CFDictionaryRef> description(DADiskCopyDescription(disk.get()));
-    if (!description.isValid()) {
+  void ProcessDiskDescription(CFDictionaryRef description) {
+    DEBUG_LOG("[GetVolumeMetadataWorker] Processing disk description");
+    if (!description) {
+      DEBUG_LOG("[GetVolumeMetadataWorker] Invalid disk description");
       metadata.status = "partial";
+      metadata.error = "Invalid disk description";
       return;
     }
 
-    ProcessDiskDescription(description.get());
-  }
-
-  void ProcessDiskDescription(CFDictionaryRef description) {
     // Get volume name/label
     if (CFStringRef volumeName = (CFStringRef)CFDictionaryGetValue(
             description, kDADiskDescriptionVolumeNameKey)) {
@@ -205,29 +256,43 @@ private:
   }
 
   void ProcessNetworkVolume(CFDictionaryRef description) {
+    DEBUG_LOG("[GetVolumeMetadataWorker] Processing network volume");
     CFBooleanRef isNetworkVolume = (CFBooleanRef)CFDictionaryGetValue(
         description, kDADiskDescriptionVolumeNetworkKey);
-
     metadata.remote = CFBooleanGetValue(isNetworkVolume);
+
     CFURLRef url = (CFURLRef)CFDictionaryGetValue(
         description, kDADiskDescriptionVolumePathKey);
     if (!url) {
+      metadata.error = "Invalid URL";
       return;
     }
-
-    CFStringRef urlString = CFURLGetString(url);
-    if (!urlString) {
+    CFReleaser<CFStringRef> urlString(
+        CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle));
+    if (!urlString.isValid()) {
+      metadata.error = std::string("Invalid URL string: ") +
+                       CFStringToString(urlString.get());
       return;
     }
-    metadata.uri = CFStringToString(urlString);
+
+    DEBUG_LOG("[GetVolumeMetadataWorker] URL path: %s",
+              CFStringToString(urlString.get()).c_str());
+    metadata.uri = CFStringToString(urlString.get());
   }
 };
 
-Napi::Value GetVolumeMetadata(const Napi::Env &env,
-                              const std::string &mountPoint,
-                              const Napi::Object &options) {
+Napi::Value GetVolumeMetadata(const Napi::CallbackInfo &info) {
+  auto env = info.Env();
+  DEBUG_LOG("[GetVolumeMetadata] called");
+
+  VolumeMetadataOptions options;
+  if (info.Length() > 0 && info[0].IsObject()) {
+    options = VolumeMetadataOptions::FromObject(info[0].As<Napi::Object>());
+  }
+
   auto deferred = Napi::Promise::Deferred::New(env);
-  auto *worker = new GetVolumeMetadataWorker(mountPoint, deferred);
+  auto *worker =
+      new GetVolumeMetadataWorker(options.mountPoint, options, deferred);
   worker->Queue();
   return deferred.Promise();
 }

package/src/darwin/volume_mount_points.cpp

@@ -1,19 +1,30 @@
 // src/darwin/volume_mount_points.cpp
-
-#include "./fs_meta.h"
+#include "../common/volume_mount_points.h"
+#include "../common/debug_log.h"
+#include "fs_meta.h"
+#include <chrono>
+#include <future>
 #include <sys/mount.h>
-#include <sys/param.h>
-#include <vector>
+#include <unistd.h>
 
 namespace FSMeta {
 
 class GetVolumeMountPointsWorker : public Napi::AsyncWorker {
+private:
+  Napi::Promise::Deferred deferred_;
+  std::vector<MountPoint> mountPoints_;
+  uint32_t timeoutMs_;
+
 public:
-  GetVolumeMountPointsWorker(const Napi::Promise::Deferred &deferred)
-      : Napi::AsyncWorker(deferred.Env()), deferred_(deferred) {}
+  GetVolumeMountPointsWorker(const Napi::Promise::Deferred &deferred,
+                             uint32_t timeoutMs = 5000)
+      : Napi::AsyncWorker(deferred.Env()), deferred_(deferred),
+        timeoutMs_(timeoutMs) {}
 
   void Execute() override {
+    DEBUG_LOG("[GetVolumeMountPointsWorker] Executing");
     try {
+      // Get mount list - this is fast
       struct statfs *mntbufp;
       int count = getmntinfo(&mntbufp, MNT_WAIT);
 
@@ -22,42 +33,90 @@ public:
       }
 
       for (int i = 0; i < count; i++) {
-        MountPoint point;
-        point.mountPoint = mntbufp[i].f_mntonname;
-        point.fstype = mntbufp[i].f_fstypename;
-        mountPoints.push_back(point);
+        MountPoint mp;
+        mp.mountPoint = mntbufp[i].f_mntonname;
+        mp.fstype = mntbufp[i].f_fstypename;
+        mp.error = ""; // Initialize error field
+
+        DEBUG_LOG("[GetVolumeMountPointsWorker] Checking mount point: %s",
+                  mp.mountPoint.c_str());
+
+        try {
+          // Use shared_future to allow multiple gets
+          std::shared_future<bool> future =
+              std::async(std::launch::async, [path = mp.mountPoint]() {
+                return access(path.c_str(), R_OK) == 0;
+              }).share();
+
+          auto status = future.wait_for(std::chrono::milliseconds(timeoutMs_));
+
+          if (status == std::future_status::timeout) {
+            mp.status = "disconnected";
+            mp.error = "Access check timed out";
+            DEBUG_LOG(
+                "[GetVolumeMountPointsWorker] Access check timed out for: %s",
+                mp.mountPoint.c_str());
+          } else if (status == std::future_status::ready) {
+            try {
+              bool isAccessible = future.get();
+              mp.status = isAccessible ? "healthy" : "inaccessible";
+              if (!isAccessible) {
+                mp.error = "Path is not accessible";
+              }
+              DEBUG_LOG("[GetVolumeMountPointsWorker] Access check %s for: %s",
+                        isAccessible ? "succeeded" : "failed",
+                        mp.mountPoint.c_str());
+            } catch (const std::exception &e) {
+              mp.status = "error";
+              mp.error = std::string("Access check failed: ") + e.what();
+              DEBUG_LOG("[GetVolumeMountPointsWorker] Exception: %s", e.what());
+            }
+          } else {
+            mp.status = "error";
+            mp.error = "Unexpected future status";
+            DEBUG_LOG(
+                "[GetVolumeMountPointsWorker] Unexpected future status for: %s",
+                mp.mountPoint.c_str());
+          }
+        } catch (const std::exception &e) {
+          mp.status = "error";
+          mp.error = std::string("Mount point check failed: ") + e.what();
+          DEBUG_LOG("[GetVolumeMountPointsWorker] Exception: %s", e.what());
+        }
+
+        mountPoints_.push_back(std::move(mp));
       }
     } catch (const std::exception &e) {
-      SetError(e.what());
+      SetError(std::string("Failed to process mount points: ") + e.what());
+      DEBUG_LOG("[GetVolumeMountPointsWorker] Exception: %s", e.what());
     }
   }
 
   void OnOK() override {
-    Napi::HandleScope scope(Env());
-    Napi::Array result = Napi::Array::New(Env());
-
-    for (size_t i = 0; i < mountPoints.size(); i++) {
-      Napi::Object point = Napi::Object::New(Env());
-      point.Set("mountPoint", mountPoints[i].mountPoint);
-      point.Set("fstype", mountPoints[i].fstype);
-      result.Set(i, point);
+    DEBUG_LOG("[GetVolumeMountPointsWorker] OnOK");
+    auto env = Env();
+    auto result = Napi::Array::New(env, mountPoints_.size());
+
+    for (size_t i = 0; i < mountPoints_.size(); i++) {
+      result[i] = mountPoints_[i].ToObject(env);
     }
 
     deferred_.Resolve(result);
   }
-
-  void OnError(const Napi::Error &error) override {
-    deferred_.Reject(error.Value());
-  }
-
-private:
-  std::vector<MountPoint> mountPoints;
-  Napi::Promise::Deferred deferred_;
 };
 
-Napi::Value GetVolumeMountPoints(Napi::Env env) {
+Napi::Promise GetVolumeMountPoints(const Napi::CallbackInfo &info) {
+  auto env = info.Env();
+  DEBUG_LOG("[GetVolumeMountPoints] called");
+
   auto deferred = Napi::Promise::Deferred::New(env);
-  auto *worker = new GetVolumeMountPointsWorker(deferred);
+
+  MountPointOptions options;
+  if (info.Length() > 0 && info[0].IsObject()) {
+    options = MountPointOptions::FromObject(info[0].As<Napi::Object>());
+  }
+
+  auto *worker = new GetVolumeMountPointsWorker(deferred, options.timeoutMs);
   worker->Queue();
   return deferred.Promise();
 }

package/src/linux/blkid_cache.cpp

@@ -1,5 +1,7 @@
 // src/linux/blkid_cache.cpp
+
 #include "blkid_cache.h"
+#include "../common/debug_log.h"
 #include <stdexcept>
 
 namespace FSMeta {
@@ -10,19 +12,25 @@ std::mutex BlkidCache::mutex_;
 // Constructor: Initializes the blkid cache with proper error handling
 BlkidCache::BlkidCache() : cache_(nullptr) {
   std::lock_guard<std::mutex> lock(mutex_);
+  DEBUG_LOG("[BlkidCache] initializing cache");
   if (blkid_get_cache(&cache_, nullptr) != 0) {
+    DEBUG_LOG("[BlkidCache] failed to initialize cache");
     throw std::runtime_error("Failed to initialize blkid cache");
   }
+  DEBUG_LOG("[BlkidCache] cache initialized successfully");
 }
 
 // Destructor: Safely releases the blkid cache resource
 BlkidCache::~BlkidCache() {
   if (cache_) {
     std::lock_guard<std::mutex> lock(mutex_);
+    DEBUG_LOG("[BlkidCache] releasing cache");
     try {
       blkid_put_cache(cache_);
       cache_ = nullptr; // Avoid double-release
+      DEBUG_LOG("[BlkidCache] cache released successfully");
     } catch (const std::exception &e) {
+      DEBUG_LOG("[BlkidCache] error releasing cache: %s", e.what());
       // Optional: Log error during cache cleanup
       // std::cerr << "Error while releasing blkid cache: " << e.what()
       //           << std::endl;
@@ -33,6 +41,7 @@ BlkidCache::~BlkidCache() {
 // Accessor for blkid cache
 blkid_cache BlkidCache::get() {
   if (!cache_) {
+    DEBUG_LOG("[BlkidCache] attempted to access uninitialized cache");
     throw std::runtime_error(
         "blkid cache is uninitialized or has been released");
   }

package/src/linux/blkid_cache.h

@@ -1,4 +1,5 @@
 // src/linux/blkid_cache.h
+
 #pragma once
 #include <blkid/blkid.h>
 #include <mutex>

package/src/linux/gio_mount_points.cpp

@@ -0,0 +1,81 @@
+// src/linux/gio_mount_points.cpp
+#ifdef ENABLE_GIO
+
+#include "gio_mount_points.h"
+#include "../common/debug_log.h"
+#include "gio_utils.h"
+#include <gio/gio.h>
+#include <memory>
+#include <stdexcept>
+
+namespace FSMeta {
+namespace gio {
+
+GioMountPointsWorker::GioMountPointsWorker(
+    const Napi::Promise::Deferred &deferred)
+    : Napi::AsyncWorker(deferred.Env()), deferred_(deferred) {}
+
+GioMountPointsWorker::~GioMountPointsWorker() { mountPoints.clear(); }
+
+void GioMountPointsWorker::Execute() {
+  try {
+    DEBUG_LOG("[GioMountPoints] processing mounts");
+
+    MountIterator::forEachMount([this](GMount *mount, GFile *root) {
+      GCharPtr path(g_file_get_path(root));
+      if (path) {
+        GFileInfoPtr info(g_file_query_filesystem_info(
+            root, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, nullptr, nullptr));
+        if (info) {
+          const char *fs_type_str = g_file_info_get_attribute_string(
+              info.get(), G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
+          if (fs_type_str) {
+            GCharPtr fs_type(g_strdup(fs_type_str));
+            DEBUG_LOG("[GioMountPoints] found {mountPoint: %s, fsType: %s}",
+                      path.get(), fs_type.get());
+            MountPoint point{};
+            point.mountPoint = path.get();
+            point.fstype = fs_type.get();
+            mountPoints.push_back(point);
+          }
+        }
+      }
+      return true; // Continue iteration
+    });
+
+    DEBUG_LOG("[GioMountPoints] found %zu mount points", mountPoints.size());
+  } catch (const std::exception &e) {
+    DEBUG_LOG("[GioMountPoints] error: %s", e.what());
+    SetError(e.what());
+  }
+}
+
+void GioMountPointsWorker::OnOK() {
+  Napi::HandleScope scope(Env());
+  Napi::Array result = Napi::Array::New(Env());
+
+  for (size_t i = 0; i < mountPoints.size(); i++) {
+    Napi::Object point = Napi::Object::New(Env());
+    point.Set("mountPoint", mountPoints[i].mountPoint);
+    point.Set("fstype", mountPoints[i].fstype);
+    result.Set(i, point);
+  }
+
+  deferred_.Resolve(result);
+}
+
+void GioMountPointsWorker::OnError(const Napi::Error &error) {
+  deferred_.Reject(error.Value());
+}
+
+Napi::Value GetMountPoints(Napi::Env env) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+  auto *worker = new GioMountPointsWorker(deferred);
+  worker->Queue();
+  return deferred.Promise();
+}
+
+} // namespace gio
+} // namespace FSMeta
+
+#endif // ENABLE_GIO

package/src/linux/{gio_worker.h → gio_mount_points.h}

@@ -1,10 +1,10 @@
-// src/linux/gio_worker.h
+// src/linux/gio_mount_points.h
 
 #pragma once
 
 #ifdef ENABLE_GIO
 
-#include "../common/mount_point.h"
+#include "../common/volume_mount_points.h"
 #include <napi.h>
 #include <string>
 #include <vector>
@@ -12,6 +12,11 @@
 namespace FSMeta {
 namespace gio {
 
+/**
+ * Get mount points asynchronously using GIO
+ */
+Napi::Value GetMountPoints(Napi::Env env);
+
 class GioMountPointsWorker : public Napi::AsyncWorker {
 public:
   explicit GioMountPointsWorker(const Napi::Promise::Deferred &deferred);