@photostructure/fs-metadata 0.0.1

package/src/linux/gio_worker.cpp

@@ -0,0 +1,87 @@
+// src/linux/gio_worker.cpp
+#ifdef ENABLE_GIO
+
+#include "gio_worker.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 {
+    GVolumeMonitor *monitor = g_volume_monitor_get();
+    if (!monitor) {
+      throw std::runtime_error("Failed to get GVolumeMonitor");
+    }
+
+    GList *mounts = g_volume_monitor_get_mounts(monitor);
+    if (!mounts) {
+      return;
+    }
+
+    for (GList *l = mounts; l != nullptr; l = l->next) {
+      GMount *mount = G_MOUNT(l->data);
+      if (!G_IS_MOUNT(mount)) {
+        continue;
+      }
+
+      GFile *root = g_mount_get_root(mount);
+      if (!G_IS_FILE(root)) {
+        continue;
+      }
+
+      char *path = g_file_get_path(root);
+      char *fs_type = g_mount_get_name(mount);
+
+      if (path && fs_type) {
+        MountPoint point{};
+        point.mountPoint = path;
+        point.fstype = fs_type;
+        mountPoints.push_back(point);
+      }
+
+      if (path) {
+        g_free(path);
+      }
+      if (fs_type) {
+        g_free(fs_type);
+      }
+      g_object_unref(root);
+    }
+
+    g_list_free_full(mounts, g_object_unref);
+  } catch (const std::exception &e) {
+    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());
+}
+
+} // namespace gio
+} // namespace FSMeta
+
+#endif // ENABLE_GIO

package/src/linux/gio_worker.h

@@ -0,0 +1,32 @@
+// src/linux/gio_worker.h
+
+#pragma once
+
+#ifdef ENABLE_GIO
+
+#include "../common/mount_point.h"
+#include <napi.h>
+#include <string>
+#include <vector>
+
+namespace FSMeta {
+namespace gio {
+
+class GioMountPointsWorker : public Napi::AsyncWorker {
+public:
+  explicit GioMountPointsWorker(const Napi::Promise::Deferred &deferred);
+  ~GioMountPointsWorker() override; // Add override specifier
+
+  void Execute() override;
+  void OnOK() override;
+  void OnError(const Napi::Error &error) override;
+
+private:
+  std::vector<MountPoint> mountPoints;
+  Napi::Promise::Deferred deferred_;
+};
+
+} // namespace gio
+} // namespace FSMeta
+
+#endif // ENABLE_GIO

package/src/linux/volume_metadata.cpp

@@ -0,0 +1,92 @@
+// src/linux/volume_metadata.cpp
+#include "../common/volume_metadata.h"
+#include "../common/error_utils.h"
+#include "../common/metadata_worker.h"
+#include "blkid_cache.h"
+#include <memory>
+#include <sys/statvfs.h>
+
+#ifdef ENABLE_GIO
+#include "gio_utils.h"
+#endif
+
+namespace FSMeta {
+
+class LinuxMetadataWorker : public MetadataWorkerBase {
+public:
+  LinuxMetadataWorker(const std::string &path,
+                      const VolumeMetadataOptions &options,
+                      const Napi::Promise::Deferred &deferred)
+      : MetadataWorkerBase(path, deferred), options_(options) {}
+
+  void Execute() override {
+    try {
+      struct statvfs vfs;
+      if (statvfs(mountPoint.c_str(), &vfs) != 0) {
+        throw FSException(CreateErrorMessage("statvfs", errno));
+      }
+
+      uint64_t blockSize = vfs.f_frsize ? vfs.f_frsize : vfs.f_bsize;
+      metadata.remote = false;
+      metadata.size = static_cast<double>(blockSize) * vfs.f_blocks;
+      metadata.available = static_cast<double>(blockSize) * vfs.f_bavail;
+      metadata.used =
+          metadata.size - (static_cast<double>(blockSize) * vfs.f_bfree);
+
+#ifdef ENABLE_GIO
+      try {
+        gio::addMountMetadata(mountPoint, metadata);
+      } catch (const std::exception &e) {
+        metadata.status = std::string("GIO warning: ") + e.what();
+      }
+#endif
+
+      if (!options_.device.empty()) {
+        try {
+          BlkidCache cache;
+          char *uuid =
+              blkid_get_tag_value(cache.get(), "UUID", options_.device.c_str());
+          if (uuid) {
+            metadata.uuid = uuid;
+            free(uuid);
+          }
+
+          char *label = blkid_get_tag_value(cache.get(), "LABEL",
+                                            options_.device.c_str());
+          if (label) {
+            metadata.label = label;
+            free(label);
+          }
+        } catch (const std::exception &e) {
+          metadata.status = std::string("Blkid warning: ") + e.what();
+        }
+      }
+    } catch (const std::exception &e) {
+      SetError(e.what());
+    }
+  }
+
+private:
+  VolumeMetadataOptions options_;
+};
+
+Napi::Value GetVolumeMetadata(const Napi::Env &env,
+                              const std::string &mountPoint,
+                              const Napi::Object &options) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+
+  VolumeMetadataOptions opts;
+  opts.timeoutMs =
+      options.Has("timeoutMs")
+          ? options.Get("timeoutMs").As<Napi::Number>().Uint32Value()
+          : 5000;
+  opts.device = options.Has("device")
+                    ? options.Get("device").As<Napi::String>().Utf8Value()
+                    : "";
+
+  auto *worker = new LinuxMetadataWorker(mountPoint, opts, deferred);
+  worker->Queue();
+  return deferred.Promise();
+}
+
+} // namespace FSMeta

package/src/windows/error_utils.h

@@ -0,0 +1,22 @@
+// src/windows/error_utils.h
+#pragma once
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <windows.h>
+
+namespace FSMeta {
+
+class FSException : public std::runtime_error {
+public:
+  explicit FSException(const std::string &message)
+      : std::runtime_error(message) {}
+};
+
+inline std::string CreateErrorMessage(const char *operation, DWORD error) {
+  std::ostringstream oss;
+  oss << operation << " failed with error: " << error;
+  return oss.str();
+}
+
+} // namespace FSMeta

package/src/windows/fs_meta.h

@@ -0,0 +1,43 @@
+// src/windows/fs_meta.h
+#pragma once
+#include "../common/volume_metadata.h"
+#include "../common/volume_mount_points.h"
+#include "./error_utils.h"
+#include <napi.h>
+
+#include <string>
+
+namespace FSMeta {
+
+constexpr size_t ERROR_BUFFER_SIZE = 256;
+constexpr DWORD BUFFER_SIZE = MAX_PATH + 1;
+
+enum DriveStatus {
+  Unknown,
+  Unavailable,
+  Healthy,
+  Disconnected,
+  Error,
+  NoMedia
+};
+
+inline const char *DriveStatusToString(DriveStatus status) {
+  switch (status) {
+  case Unknown:
+    return "unknown";
+  case Unavailable:
+    return "unavailable";
+  case Healthy:
+    return "healthy";
+  case Disconnected:
+    return "disconnected";
+  case Error:
+    return "error";
+  case NoMedia:
+    return "no_media";
+  default:
+    return "unknown";
+  }
+}
+
+} // namespace FSMeta

package/src/windows/volume_metadata.cpp

@@ -0,0 +1,194 @@
+// src/windows/volume_metadata.cpp
+#include "../common/metadata_worker.h"
+#include "../common/mount_point.h"
+#include "./error_utils.h"
+#include "./fs_meta.h"
+#include <iomanip>
+#include <sstream>
+#include <windows.h>
+#include <winnetwk.h>
+
+namespace FSMeta {
+
+inline std::string FormatVolumeUUID(DWORD serialNumber) {
+  std::stringstream ss;
+  ss << std::uppercase << std::hex << std::setfill('0') << std::setw(8)
+     << serialNumber;
+  return ss.str();
+}
+
+inline void ValidatePath(const std::string &path) {
+  if (path.empty() || path.length() >= MAX_PATH) {
+    throw FSException("Invalid path length");
+  }
+}
+
+// Drive status determination with performance optimization
+DriveStatus GetDriveStatus(const std::string &path) {
+  UINT driveType = GetDriveTypeA(path.c_str());
+
+  // First check if drive is accessible
+  std::string mountPoint = path;
+  if (mountPoint.back() != '\\') {
+    mountPoint += '\\';
+  }
+
+  // Use stack-allocated arrays for better performance
+  char volumeName[BUFFER_SIZE] = {0};
+  char fileSystem[BUFFER_SIZE] = {0};
+  DWORD serialNumber = 0;
+  DWORD maxComponentLen = 0;
+  DWORD fsFlags = 0;
+
+  bool isAccessible = GetVolumeInformationA(
+      mountPoint.c_str(), volumeName, BUFFER_SIZE, &serialNumber,
+      &maxComponentLen, &fsFlags, fileSystem, BUFFER_SIZE);
+
+  switch (driveType) {
+  case DRIVE_UNKNOWN:
+    return Unknown;
+  case DRIVE_NO_ROOT_DIR:
+    return Unavailable;
+  case DRIVE_REMOVABLE:
+    return isAccessible ? Healthy : Disconnected;
+  case DRIVE_FIXED:
+    return isAccessible ? Healthy : Error;
+  case DRIVE_REMOTE:
+    if (!isAccessible) {
+      DWORD result =
+          WNetGetConnectionA(path.substr(0, 2).c_str(), nullptr, nullptr);
+      return (result == ERROR_NOT_CONNECTED) ? Disconnected : Error;
+    }
+    return Healthy;
+  case DRIVE_CDROM:
+    return isAccessible ? Healthy : NoMedia;
+  case DRIVE_RAMDISK:
+    return isAccessible ? Healthy : Error;
+  default:
+    return Unknown;
+  }
+}
+
+class GetVolumeMetadataWorker : public FSMeta::MetadataWorkerBase {
+public:
+  GetVolumeMetadataWorker(const std::string &mountPoint,
+                          const Napi::Promise::Deferred &deferred)
+      : MetadataWorkerBase(mountPoint, deferred), mountPoint(mountPoint),
+        deferred_(deferred) // Initialize deferred_ member
+  {
+    ValidatePath(mountPoint); // Use mountPoint instead of path
+  }
+
+  void Execute() override {
+    try {
+      // Get drive status first
+      DriveStatus status = GetDriveStatus(mountPoint);
+      metadata.status = DriveStatusToString(status);
+
+      // If drive is not accessible, skip further checks
+      if (status == Disconnected || status == Unavailable || status == Error ||
+          status == NoMedia) {
+        throw FSException("Unhealthy drive status: " +
+                          std::string(metadata.status));
+      }
+
+      // Use stack-allocated arrays for better performance
+      char volumeName[BUFFER_SIZE] = {0};
+      char fileSystem[BUFFER_SIZE] = {0};
+      DWORD serialNumber = 0;
+      DWORD maxComponentLen = 0;
+      DWORD fsFlags = 0;
+
+      if (!GetVolumeInformationA(mountPoint.c_str(), volumeName, BUFFER_SIZE,
+                                 &serialNumber, &maxComponentLen, &fsFlags,
+                                 fileSystem, BUFFER_SIZE)) {
+        throw FSException(
+            CreateErrorMessage("GetVolumeInformation", GetLastError()));
+      }
+
+      metadata.label = volumeName;
+      metadata.fileSystem = fileSystem;
+      metadata.uuid = FormatVolumeUUID(serialNumber);
+
+      // Get disk space information
+      ULARGE_INTEGER totalBytes;
+      ULARGE_INTEGER freeBytes;
+      ULARGE_INTEGER totalFreeBytes;
+
+      if (!GetDiskFreeSpaceExA(mountPoint.c_str(), &freeBytes, &totalBytes,
+                               &totalFreeBytes)) {
+        throw FSException(
+            CreateErrorMessage("GetDiskFreeSpaceEx", GetLastError()));
+      }
+
+      metadata.size = static_cast<double>(totalBytes.QuadPart);
+      metadata.available = static_cast<double>(freeBytes.QuadPart);
+      metadata.used = metadata.size - metadata.available;
+
+      // Check if drive is remote
+      metadata.remote = (GetDriveTypeA(mountPoint.c_str()) == DRIVE_REMOTE);
+
+      // Get network path if the drive is remote
+      if (metadata.remote) {
+        char remoteName[BUFFER_SIZE] = {0};
+        DWORD length = BUFFER_SIZE;
+        DWORD result = WNetGetConnectionA(mountPoint.substr(0, 2).c_str(),
+                                          remoteName, &length);
+
+        if (result == NO_ERROR) {
+          metadata.mountFrom = remoteName;
+        }
+      }
+    } catch (const std::exception &e) {
+      SetError(e.what());
+    }
+  }
+
+  void OnOK() override
+
+  // TODO: use the base worker's OnOK instead (but currently that results in
+  // incorrect numerical values)
+  {
+    auto env = Env();
+
+    Napi::HandleScope scope(env);
+    Napi::Object result = Napi::Object::New(env);
+
+    result.Set("label", metadata.label.empty()
+                            ? env.Null()
+                            : Napi::String::New(env, metadata.label));
+    result.Set("fileSystem", metadata.fileSystem.empty()
+                                 ? env.Null()
+                                 : Napi::String::New(env, metadata.fileSystem));
+    result.Set("size", Napi::Number::New(env, metadata.size));
+    result.Set("used", Napi::Number::New(env, metadata.used));
+    result.Set("available", Napi::Number::New(env, metadata.available));
+    result.Set("uuid", metadata.uuid.empty()
+                           ? env.Null()
+                           : Napi::String::New(env, metadata.uuid));
+    result.Set("remote", Napi::Boolean::New(env, metadata.remote));
+    result.Set("status", Napi::String::New(env, metadata.status));
+
+    if (!metadata.mountFrom.empty()) {
+      result.Set("mountFrom", Napi::String::New(env, metadata.mountFrom));
+    }
+
+    deferred_.Resolve(result);
+  }
+
+private:
+  std::string mountPoint;
+  Napi::Promise::Deferred deferred_;
+  VolumeMetadata metadata;
+};
+
+Napi::Value GetVolumeMetadata(const Napi::Env &env,
+                              const std::string &mountPoint,
+                              const Napi::Object &options) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+  auto *worker = new GetVolumeMetadataWorker(mountPoint, deferred);
+  worker->Queue();
+  return deferred.Promise();
+}
+
+} // namespace FSMeta

package/src/windows/volume_mount_points.cpp

@@ -0,0 +1,62 @@
+// src/windows/volume_mount_points.cpp
+#include "../common/metadata_worker.h" // Add this include
+#include "./fs_meta.h"
+#include <sstream>
+#include <windows.h>
+#include <winnetwk.h>
+
+namespace FSMeta {
+
+class GetVolumeMountPointsWorker
+    : public MetadataWorkerBase { // Inherit from base class
+public:
+  explicit GetVolumeMountPointsWorker(const Napi::Promise::Deferred &deferred)
+      : MetadataWorkerBase("", deferred) {
+  } // Pass empty mountPoint since we list all
+
+  void Execute() override {
+    try {
+      DWORD length = GetLogicalDriveStringsA(0, nullptr);
+      if (length == 0) {
+        throw FSException(
+            CreateErrorMessage("GetLogicalDriveStrings", GetLastError()));
+      }
+
+      std::vector<char> driveStrings(length);
+      if (GetLogicalDriveStringsA(length, driveStrings.data()) == 0) {
+        throw FSException(
+            CreateErrorMessage("GetLogicalDriveStrings data", GetLastError()));
+      }
+
+      for (const char *drive = driveStrings.data(); *drive;
+           drive += strlen(drive) + 1) {
+        mountPoints.push_back(std::string(drive));
+      }
+    } catch (const std::exception &e) {
+      SetError(e.what());
+    }
+  }
+
+  void OnOK() override {
+    Napi::HandleScope scope(Env());
+    auto result = Napi::Array::New(Env(), mountPoints.size());
+
+    for (size_t i = 0; i < mountPoints.size(); i++) {
+      result.Set(i, Napi::String::New(Env(), mountPoints[i]));
+    }
+
+    deferred_.Resolve(result);
+  }
+
+private:
+  std::vector<std::string> mountPoints;
+};
+
+Napi::Value GetVolumeMountPoints(Napi::Env env) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+  auto *worker = new GetVolumeMountPointsWorker(deferred);
+  worker->Queue();
+  return deferred.Promise();
+}
+
+} // namespace FSMeta