MMVII: FileLock to allow multi procress concurrent writes in same image

Author: Christophe Meynard

MMVII/.gitignore

@@ -28,3 +28,4 @@ src/GeneratedCodes/
 /build/*
 !/build/.keep
 !/build/NoCompile.sh
+/.cache

MMVII/include/MMVII_Sys.h

@@ -5,7 +5,6 @@
 #include <unistd.h>
 #endif
 
-#include "MMVII_AllClassDeclare.h"
 #include "cMMVII_Appli.h"
 
 namespace MMVII
@@ -59,6 +58,29 @@ int GlobParalSysCallByMkF(const std::string & aNameMkF,const std::list<cParamCal
 std::string MMVII_CanonicalRootDirFromExec();
 
 
+class FileLock
+{
+public:
+    FileLock();
+    explicit FileLock(const std::string& name);
+    ~FileLock();
+    bool lock(const std::string& name);
+    void unlock();
+    bool hasLock();
+
+private:
+#ifdef WIN32
+    void *mHandle = nullptr;
+#else
+    int mFd = -1;
+#endif
+    void doLock(const std::string& name);
+    void doUnlock();
+    bool doHasLock();
+};
+
+
+
 };
 
 #endif  //  _MMVII_Sys_H_

MMVII/src/ImagesBase/cGdalApi.h

@@ -1,10 +1,11 @@
 #ifndef CGDALAPI_H
 #define CGDALAPI_H
 
-#include <MMVII_enums.h>
-#include <MMVII_Error.h>
-#include <MMVII_Ptxd.h>
-#include <MMVII_Image2D.h>
+#include "MMVII_Sys.h"
+#include "MMVII_enums.h"
+#include "MMVII_Error.h"
+#include "MMVII_Ptxd.h"
+#include "MMVII_Image2D.h"
 
 #include <string>
 #include <gdal_priv.h>
@@ -97,6 +98,8 @@ class cGdalApi {
 /****************************************************
  * PRIVATE
 *****************************************************/
+
+
 /*******************************************
  * GDalIO
  * Helper class that does the real IO
@@ -162,6 +165,7 @@ class GdalIO {
             mGdalDataset = cGdalApi::OpenDataset(aDF.Name(), aMode==IoMode::Read ? GA_ReadOnly : GA_Update, cGdalApi::eOnError::RaiseError);
         }
 
+        FileLock gdalLock;
         if (aMode == IoMode::Read) {
             if (mGdalNbChan == mNbImg && mNbImg != 0) {
                 GdalReadNtoN(aVecImV2,aRectIm,aRectFile,aDyn);     // file N -> N img channels
@@ -173,6 +177,8 @@ class GdalIO {
                 MMVII_INTERNAL_ERROR("Gdal read: Images vector size: " + std::to_string(mNbImg) + ", file channels: " + std::to_string(mGdalNbChan) + " (" + aName + ")");
             }
         } else {
+            if (! notUpdatable)
+                gdalLock.lock(aName);
             if (mGdalNbChan == mNbImg && mNbImg != 0) {
                 GdalWriteNtoN(aVecImV2,aRectIm,aRectFile,aDyn);     // img N -> N file channels
             } else if (mGdalNbChan != 0 && mNbImg == 1) {
@@ -192,6 +198,7 @@ class GdalIO {
             cGdalApi::CloseDataset(mFinalDataset);
         }
         cGdalApi::CloseDataset(mGdalDataset);
+        gdalLock.unlock();
     }
 
 private:
@@ -200,15 +207,17 @@ class GdalIO {
     class GDalBuffer
     {
     public:
-        GDalBuffer(const cRect2& aRectIm, int nbChan=1)
+        explicit GDalBuffer(const cRect2& aRectIm, int nbChan=1)
             : mBuffer(nbChan)
             , mRectIm(aRectIm)
         {
             auto aSize = sizeof(TypeFile)*aRectIm.Sz().x()*aRectIm.Sz().y();
-            for (auto& aBuf : mBuffer)
+            std::generate(mBuffer.begin(), mBuffer.end(),[aSize](){return static_cast<TypeFile*>(cMemManager::Calloc(1,aSize));});
+/*            for (auto& aBuf : mBuffer)
             {
-                aBuf = (TypeFile*) cMemManager::Calloc(1,aSize);
+                aBuf = static_cast<TypeFile*>(cMemManager::Calloc(1,aSize));
             }
+*/
         }
         ~GDalBuffer()
         {

MMVII/src/Utils/uti_sysdep.cpp

@@ -13,6 +13,7 @@
 
 #if   (THE_MACRO_MMVII_SYS==MMVII_SYS_L)  // Linux
 #  include <unistd.h>
+#  include <fcntl.h>
 #elif (THE_MACRO_MMVII_SYS==MMVII_SYS_W)  // Windows
 #  include <windows.h>
 #  include <process.h>
@@ -166,6 +167,104 @@ int GlobParalSysCallByMkF(const std::string & aNameMkF,const std::list<cParamCal
    }
 }
 
+FileLock::FileLock()
+{
+}
+
+FileLock::FileLock(const std::string& name)
+{
+    lock(name);
+}
+
+FileLock::~FileLock()
+{
+    unlock();
+}
+
+bool FileLock::lock(const std::string& name)
+{
+    if (hasLock())
+        return false;
+    doLock(name);
+    return true;
+}
+
+void FileLock::unlock()
+{
+    if (hasLock())
+        doUnlock();
+}
+
+bool FileLock::hasLock()
+{
+    return doHasLock();
+}
+
+
+#ifdef WIN32
+    void FileLock::doLock(const std::string& fileName)
+    {
+        auto mutexName = std::filesystem::canonical(fileName).wstring();
+        if (mutexName.length() < MAX_PATH) {
+            std::replace( mutexName.begin(), mutexName.end(), '\\', '/');
+        } else {
+            auto key1 = std::hash<std::wstring>{}(mutexName);
+            auto key2 = std::hash<std::wstring>{}(std::wstring(mutexName.rbegin(),mutexName.rend()));
+            std::wstringstream ss;
+            ss << std::hex << std::setw(16) << std::setfill(L'0') << key1 << "/" << key2;
+            mutexName = ss.str();
+        }
+        mHandle = CreateMutexW(NULL, FALSE, mutexName.c_str());
+
+        if (!mHandle) {
+            MMVII_INTERNAL_ERROR("Can't create Mutex on file '" + fileName + "'");
+        }
+        DWORD wait = WaitForSingleObject(mHandle, INFINITE);
+        if (wait != WAIT_OBJECT_0 && wait != WAIT_ABANDONED) {
+            MMVII_INTERNAL_ERROR("Can't wait for Mutex on file '" + fileName + "'");
+        }
+    }
+
+    void FileLock::doUnlock()
+    {
+        ReleaseMutex(mHandle);
+        CloseHandle(mHandle);
+        mHandle = nullptr;
+    }
+
+    bool FileLock::doHasLock()
+    {
+        return mHandle != nullptr;
+    }
+#else
+    void FileLock::doLock(const std::string& fileName)
+    {
+        mFd = open(fileName.c_str(), O_WRONLY | O_CREAT,0666);
+        if (mFd < 0) {
+            MMVII_INTERNAL_ERROR("Can't open for locking: '" + fileName + "'");
+        }
+        auto ret = lockf(mFd, F_LOCK, 0);
+        if (ret < 0) {
+            MMVII_INTERNAL_ERROR("Can't lock file '" + fileName + "'");
+        }
+    }
+
+    void FileLock::doUnlock()
+    {
+        if (lockf(mFd, F_ULOCK, 0))
+            mFd = -1;
+    }
+
+    bool FileLock::doHasLock()
+    {
+        return mFd >= 0;
+    }
+#endif
+
+
+
+
+
 static fs::path MMVII_RawSelfExecName();