Kdesktop 1359 vfs functions should return an exit info

src/libcommon/utility/sourcelocation.h

@@ -0,0 +1,81 @@
+/*
+ * Infomaniak kDrive - Desktop
+ * Copyright (C) 2023-2024 Infomaniak Network SA
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#if defined(_WIN32)
+// || defined(__APPLE__) still buggy on macOS
+// https://www.reddit.com/r/cpp/comments/1b1pjii/comment/ksg8efc/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button
+#define SRC_LOC_AVALAIBALE
+#endif
+
+#ifdef SRC_LOC_AVALAIBALE
+#include <source_location>
+#endif // SRC_LOC_AVALAIBALE
+
+#include <filesystem>
+#include <string>
+
+namespace KDC {
+
+class SourceLocation {
+    public:
+        constexpr SourceLocation() = default;
+#ifdef SRC_LOC_AVALAIBALE
+        [[nodiscard]] static consteval SourceLocation currentLoc(
+                const std::source_location& loc = std::source_location::current()) {
+            SourceLocation result;
+            result._line = loc.line();
+            result._fileName = loc.file_name();
+            result._functionName = loc.function_name();
+            return result;
+        }
+#else
+#define currentLoc()                            \
+    currentLocCompatibility(__LINE__, __FILE__, \
+                            "") // Cannot be used as a default argument as it will be evaluated at the definition site.
+        [[nodiscard]] static consteval SourceLocation currentLocCompatibility(uint32_t line, const char* file,
+                                                                              const char* function) {
+            SourceLocation result;
+            result._line = line;
+            result._fileName = file;
+            result._functionName = function;
+            return result;
+        }
+#endif // SRC_LOC_AVALAIBALE
+
+        [[nodiscard]] uint32_t line() const { return _line; }
+        [[nodiscard]] std::string fileName() const { return std::filesystem::path(_fileName).filename().string(); }
+        [[nodiscard]] std::string functionName() const {
+            std::string str(_functionName);
+            auto firstParenthesis = str.find_first_of('(');
+            str = firstParenthesis != std::string::npos
+                          ? str.substr(0, firstParenthesis)
+                          : str; // "namespace::class::function(namespace::args)" -> "namespace::class::function"
+            auto lastColon = str.find_last_of(':');
+            return lastColon != std::string::npos ? str.substr(lastColon + 1) : str; // "namespace::class::function" -> "function"
+        }
+
+    private:
+        uint32_t _line = 0;
+        const char* _fileName = "";
+        const char* _functionName = "";
+};
+
+} // namespace KDC
+// namespace KDC

src/libcommon/utility/types.h

@@ -15,7 +15,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #pragma once
 
 #include <string>
@@ -28,6 +27,7 @@
 #include <variant>
 #include <qdebug.h>
 #include <signal.h>
+#include "sourcelocation.h"
 
 namespace KDC {
 
@@ -230,32 +230,50 @@ enum class ExitCause {
     MoveToTrashFailed,
     InvalidName,
     LiteSyncNotAllowed,
+    NotPlaceHolder,
     NetworkTimeout,
     SocketsDefuncted, // macOS: sockets defuncted by kernel
     NotFound,
     QuotaExceeded,
     FullListParsingError,
     OperationCanceled,
-    ShareLinkAlreadyExists
+    ShareLinkAlreadyExists,
+    InvalidArgument
 };
 std::string toString(ExitCause e);
 
 struct ExitInfo {
         ExitInfo() = default;
-        constexpr ExitInfo(const ExitCode &code, const ExitCause &cause) : _code(code), _cause(cause) {}
-        ExitInfo(const ExitCode &code) : _code(code) {}
+        constexpr ExitInfo(const ExitCode &code, const ExitCause &cause,
+                           const SourceLocation srcLoc = SourceLocation::currentLoc()) :
+            _code(code),
+            _cause(cause), _srcLoc(srcLoc) {}
+
+        ExitInfo(const ExitCode &code, const SourceLocation srcLoc = SourceLocation::currentLoc()) :
+            _code(code), _srcLoc(srcLoc) {}
+
         const ExitCode &code() const { return _code; }
         const ExitCause &cause() const { return _cause; }
         operator ExitCode() const { return _code; }
         operator ExitCause() const { return _cause; }
-        explicit operator std::string() const { return "ExitInfo{" + toString(code()) + ", " + toString(cause()) + "}"; }
+        explicit operator std::string() const {
+            // Example: "ExitInfo{SystemError-NotFound from (file.cpp:42[functionName])}"
+            return "ExitInfo{" + toString(code()) + "-" + toString(cause()) + srcLocStr() + "}";
+        }
         constexpr operator bool() const { return _code == ExitCode::Ok; }
         constexpr explicit operator int() const { return toInt(_code) * 100 + toInt(_cause); }
         constexpr bool operator==(const ExitInfo &other) const { return _code == other._code && _cause == other._cause; }
 
     private:
         ExitCode _code{ExitCode::Unknown};
         ExitCause _cause{ExitCause::Unknown};
+        SourceLocation _srcLoc;
+
+        std::string srcLocStr() const {
+            if (_code == ExitCode::Ok) return "";
+            return " from (" + _srcLoc.fileName() + ":" + std::to_string(_srcLoc.line()) +
+                   (!_srcLoc.functionName().empty() ? "[" + _srcLoc.functionName() + "]" : "");
+        }
 };
 std::string toString(ExitInfo e);
 

src/libcommonserver/CMakeLists.txt

@@ -11,6 +11,8 @@ if (UNIX AND CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
 endif ()
 find_package(libzip 1.10.1 REQUIRED)
 
+set(CMAKE_AUTOMOC TRUE)
+
 add_definitions(-DUNICODE)
 add_definitions(-D_UNICODE)
 
@@ -34,6 +36,9 @@ set(libcommonserver_SRCS
     # Io
     io/filestat.h
     io/iohelper.h io/iohelper.cpp
+    # Vfs
+    vfs.h vfs.cpp
+    plugin.h plugin.cpp
 )
 
 if(APPLE)

src/libcommonserver/vfs.cpp

@@ -32,10 +32,51 @@
 
 using namespace KDC;
 
-Vfs::Vfs(VfsSetupParams &vfsSetupParams, QObject *parent) :
+Vfs::Vfs(const VfsSetupParams &vfsSetupParams, QObject *parent) :
     QObject(parent), _vfsSetupParams(vfsSetupParams), _extendedLog(false), _started(false) {}
 
-Vfs::~Vfs() {}
+void Vfs::starVfsWorkers() {
+    // Start hydration/dehydration workers
+    // !!! Disabled for testing because no QEventLoop !!!
+    if (qApp) {
+        // Start worker threads
+        for (int i = 0; i < nbWorkers; i++) {
+            for (int j = 0; j < s_nb_threads[i]; j++) {
+                auto *workerThread = new QtLoggingThread();
+                _workerInfo[i]._threadList.append(workerThread);
+                auto *worker = new VfsWorker(this, i, j, logger());
+                worker->moveToThread(workerThread);
+                connect(workerThread, &QThread::started, worker, &VfsWorker::start);
+                connect(workerThread, &QThread::finished, worker, &QObject::deleteLater);
+                connect(workerThread, &QThread::finished, workerThread, &QObject::deleteLater);
+                workerThread->start();
+            }
+        }
+    }
+}
+
+Vfs::~Vfs() {
+    // Ask worker threads to stop
+    for (auto &worker: _workerInfo) {
+        worker._mutex.lock();
+        worker._stop = true;
+        worker._mutex.unlock();
+        worker._queueWC.wakeAll();
+    }
+
+    // Force threads to stop if needed
+    for (auto &worker: _workerInfo) {
+        for (QThread *thread: qAsConst(worker._threadList)) {
+            if (thread) {
+                thread->quit();
+                if (!thread->wait(1000)) {
+                    thread->terminate();
+                    thread->wait();
+                }
+            }
+        }
+    }
+}
 
 QString Vfs::modeToString(KDC::VirtualFileMode virtualFileMode) {
     // Note: Strings are used for config and must be stable
@@ -67,13 +108,13 @@ KDC::VirtualFileMode Vfs::modeFromString(const QString &str) {
     return {};
 }
 
-bool Vfs::start(bool &installationDone, bool &activationDone, bool &connectionDone) {
+ExitInfo Vfs::start(bool &installationDone, bool &activationDone, bool &connectionDone) {
     if (!_started) {
-        _started = startImpl(installationDone, activationDone, connectionDone);
-        return _started;
+        ExitInfo exitInfo = startImpl(installationDone, activationDone, connectionDone);
+        _started = exitInfo.code() == ExitCode::Ok;
+        return exitInfo;
     }
-
-    return true;
+    return ExitCode::Ok;
 }
 
 void Vfs::stop(bool unregister) {
@@ -83,34 +124,105 @@ void Vfs::stop(bool unregister) {
     }
 }
 
-VfsOff::VfsOff(VfsSetupParams &vfsSetupParams, QObject *parent) : Vfs(vfsSetupParams, parent) {}
-
-VfsOff::~VfsOff() {}
+ExitInfo Vfs::handleVfsError(const SyncPath &itemPath, const SourceLocation location) const {
+    if (ExitInfo exitInfo = checkIfPathExists(itemPath, true, location); !exitInfo) {
+        return exitInfo;
+    }
+    return defaultVfsError(location);
+}
 
-bool VfsOff::forceStatus(const QString &path, bool isSyncing, int /*progress*/, bool /*isHydrated*/) {
-    KDC::SyncPath fullPath(_vfsSetupParams._localPath / QStr2Path(path));
+ExitInfo Vfs::checkIfPathExists(const SyncPath &itemPath, bool shouldExist, const SourceLocation location) const {
+    if (itemPath.empty()) {
+        LOGW_WARN(logger(), L"Empty path");
+        assert(false && "Empty path in a VFS call");
+        return {ExitCode::SystemError, ExitCause::NotFound, location};
+    }
     bool exists = false;
-    KDC::IoError ioError = KDC::IoError::Success;
-    if (!KDC::IoHelper::checkIfPathExists(fullPath, exists, ioError)) {
-        LOGW_WARN(logger(), L"Error in IoHelper::checkIfPathExists: " << KDC::Utility::formatIoError(fullPath, ioError).c_str());
-        return false;
+    IoError ioError = IoError::Unknown;
+    if (!IoHelper::checkIfPathExists(itemPath, exists, ioError)) {
+        LOGW_WARN(logger(), L"Error in IoHelper::checkIfPathExists: " << Utility::formatIoError(itemPath, ioError));
+        return {ExitCode::SystemError, location};
+    }
+    if (ioError == IoError::AccessDenied) {
+        LOGW_WARN(logger(), L"File access error: " << Utility::formatIoError(itemPath, ioError));
+        return {ExitCode::SystemError, ExitCause::FileAccessError, location};
     }
+    if (exists != shouldExist) {
+        if (shouldExist) {
+            LOGW_DEBUG(logger(), L"File doesn't exist: " << Utility::formatSyncPath(itemPath));
+            return {ExitCode::SystemError, ExitCause::NotFound, location};
+        } else {
+            LOGW_DEBUG(logger(), L"File already exists: " << Utility::formatSyncPath(itemPath));
+            return {ExitCode::SystemError, ExitCause::FileAlreadyExist, location};
+        }
+    }
+    return ExitCode::Ok;
+}
+
+VfsWorker::VfsWorker(Vfs *vfs, int type, int num, log4cplus::Logger logger) :
+    _vfs(vfs), _type(type), _num(num), _logger(logger) {}
 
-    if (!exists) {
-        LOGW_DEBUG(logger(), L"Item does not exist anymore - path=" << Path2WStr(fullPath).c_str());
-        return true;
+void VfsWorker::start() {
+    LOG_DEBUG(logger(), "Worker with type=" << _type << " and num=" << _num << " started");
+
+    WorkerInfo &workerInfo = _vfs->_workerInfo[_type];
+
+    forever {
+        workerInfo._mutex.lock();
+        while (workerInfo._queue.empty() && !workerInfo._stop) {
+            LOG_DEBUG(logger(), "Worker with type=" << _type << " and num=" << _num << " waiting");
+            workerInfo._queueWC.wait(&workerInfo._mutex);
+        }
+
+        if (workerInfo._stop) {
+            workerInfo._mutex.unlock();
+            break;
+        }
+
+        QString path = workerInfo._queue.back();
+        workerInfo._queue.pop_back();
+        workerInfo._mutex.unlock();
+
+        LOG_DEBUG(logger(), "Worker with type=" << _type << " and num=" << _num << " working");
+
+        switch (_type) {
+            case workerHydration:
+                _vfs->hydrate(path);
+                break;
+            case workerDehydration:
+                _vfs->dehydrate(path);
+                break;
+            default:
+                LOG_ERROR(logger(), "Unknown vfs worker type=" << _type);
+                break;
+        }
     }
 
+    LOG_DEBUG(logger(), "Worker with type=" << _type << " and num=" << _num << " ended");
+}
+
+VfsOff::VfsOff(QObject *parent) : Vfs(VfsSetupParams(), parent) {}
+
+VfsOff::VfsOff(VfsSetupParams &vfsSetupParams, QObject *parent) : Vfs(vfsSetupParams, parent) {}
+
+VfsOff::~VfsOff() {}
+
+ExitInfo VfsOff::forceStatus(const SyncPath &pathStd, bool isSyncing, int /*progress*/, bool /*isHydrated*/) {
+    QString path = SyncName2QStr(pathStd.native());
+    KDC::SyncPath fullPath(_vfsSetupParams._localPath / QStr2Path(path));
+    if (ExitInfo exitInfo = checkIfPathExists(fullPath, true); !exitInfo) {
+        return exitInfo;
+    }
     // Update Finder
     LOGW_DEBUG(logger(), L"Send status to the Finder extension for file/directory " << Path2WStr(fullPath).c_str());
     QString status = isSyncing ? "SYNC" : "OK";
     _vfsSetupParams._executeCommand(QString("STATUS:%1:%2").arg(status, path).toStdString().c_str());
 
-    return true;
+    return ExitCode::Ok;
 }
 
-bool VfsOff::startImpl(bool &, bool &, bool &) {
-    return true;
+ExitInfo VfsOff::startImpl(bool &, bool &, bool &) {
+    return ExitCode::Ok;
 }
 
 static QString modeToPluginName(KDC::VirtualFileMode virtualFileMode) {