3.9

1 files changed, 448 insertions, 0 deletions

diff --git a/library/dir_lock.cpp b/library/dir_lock.cpp
new file mode 100644
index 00000000..c5ea37b1
--- /dev/null
+++ b/library/dir_lock.cpp
@@ -0,0 +1,448 @@
+#include "dir_lock.h"
+#include <wx/intl.h>
+#include "../shared/string_conv.h"
+#include "../shared/system_func.h"
+#include <wx/utils.h>
+#include <wx/timer.h>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/thread.hpp>
+#include "../shared/loki/ScopeGuard.h"
+#include <wx/msgdlg.h>
+#include "../shared/system_constants.h"
+#include "../shared/guid.h"
+#include "../shared/file_io.h"
+#include <utility>
+
+#ifdef FFS_WIN
+#include <wx/msw/wrapwin.h> //includes "windows.h"
+#include "../shared/long_path_prefix.h"
+
+#elif defined FFS_LINUX
+#include <sys/stat.h>
+#include <cerrno>
+#endif
+
+using namespace ffs3;
+using namespace std::rel_ops;
+
+
+namespace
+{
+const size_t EMIT_LIFE_SIGN_INTERVAL =  5000; //show life sign;        unit [ms]
+const size_t POLL_LIFE_SIGN_INTERVAL =  6000; //poll for life sign;    unit [ms]
+const size_t DETECT_EXITUS_INTERVAL  = 30000; //assume abandoned lock; unit [ms]
+}
+
+class LifeSigns
+{
+public:
+    LifeSigns(const Zstring& lockfilename) : //throw()!!! siehe SharedDirLock()
+        lockfilename_(lockfilename.c_str()) //ref-counting structure is used by thread: make deep copy!
+    {
+        threadObj = boost::thread(boost::cref(*this)); //localize all thread logic to this class!
+    }
+
+    ~LifeSigns()
+    {
+        threadObj.interrupt(); //thread lifetime is subset of this instances's life
+        threadObj.join();
+    }
+
+    void operator()() const //thread entry
+    {
+        try
+        {
+            while (true)
+            {
+                boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(EMIT_LIFE_SIGN_INTERVAL)); //interruption point!
+
+                //actual work
+                emitLifeSign(); //throw ()
+            }
+        }
+        catch (const std::exception& e) //exceptions must be catched per thread
+        {
+            wxMessageBox(wxString::FromAscii(e.what()), wxString(_("An exception occurred!")) + wxT("(Dirlock)"), wxOK | wxICON_ERROR);
+        }
+    }
+
+    void emitLifeSign() const //try to append one byte...; throw()
+    {
+        const char buffer[1] = {' '};
+
+#ifdef FFS_WIN
+        const HANDLE fileHandle = ::CreateFile(applyLongPathPrefix(lockfilename_).c_str(),
+                                               FILE_APPEND_DATA,
+                                               FILE_SHARE_READ,
+                                               NULL,
+                                               OPEN_EXISTING,
+                                               FILE_ATTRIBUTE_NORMAL,
+                                               NULL);
+        if (fileHandle == INVALID_HANDLE_VALUE)
+            return;
+
+        Loki::ScopeGuard dummy = Loki::MakeGuard(::CloseHandle, fileHandle);
+        (void)dummy; //silence warning "unused variable"
+
+        const DWORD fpLow = ::SetFilePointer(fileHandle, 0, NULL, FILE_END);
+        if (fpLow == INVALID_SET_FILE_POINTER)
+            return;
+
+        DWORD bytesWritten = 0;
+        ::WriteFile(
+            fileHandle,    //__in         HANDLE hFile,
+            buffer,        //__out        LPVOID lpBuffer,
+            1,             //__in         DWORD nNumberOfBytesToRead,
+            &bytesWritten, //__out_opt    LPDWORD lpNumberOfBytesWritten,
+            NULL);         //__inout_opt  LPOVERLAPPED lpOverlapped
+
+#elif defined FFS_LINUX
+        const int fileHandle = ::open(lockfilename_.c_str(), O_WRONLY | O_APPEND); //O_EXCL contains a race condition on NFS file systems: http://linux.die.net/man/2/open
+        if (fileHandle == -1)
+            return;
+
+        Loki::ScopeGuard dummy = Loki::MakeGuard(::close, fileHandle);
+        (void)dummy; //silence warning "unused variable"
+
+        const ssize_t bytesWritten = ::write(fileHandle, buffer, 1);
+        (void)bytesWritten;
+#endif
+    }
+
+private:
+    LifeSigns(const LifeSigns&);            //just be sure this ref-counting Zstring doesn't bite
+    LifeSigns& operator=(const LifeSigns&); //
+
+    boost::thread threadObj;
+    const Zstring lockfilename_; //used by worker thread only! Not ref-counted!
+};
+
+
+namespace
+{
+bool somethingExists(const Zstring& objname) //throw()       check whether any object with this name exists
+{
+#ifdef FFS_WIN
+    return ::GetFileAttributes(applyLongPathPrefix(objname).c_str()) != INVALID_FILE_ATTRIBUTES;
+
+#elif defined FFS_LINUX
+    struct stat fileInfo;
+    return ::lstat(objname.c_str(), &fileInfo) == 0;
+#endif
+}
+
+
+void deleteLockFile(const Zstring& filename) //throw (FileError)
+{
+#ifdef FFS_WIN
+    if (!::DeleteFile(applyLongPathPrefix(filename).c_str()))
+#elif defined FFS_LINUX
+    if (::unlink(filename.c_str()) != 0)
+#endif
+    {
+        wxString errorMessage = wxString(_("Error deleting file:")) + wxT("\n\"") + zToWx(filename) + wxT("\"");
+        throw FileError(errorMessage + wxT("\n\n") + getLastErrorFormatted());
+    }
+}
+
+
+wxULongLong getLockFileSize(const Zstring& filename) //throw (FileError, ErrorNotExisting)
+{
+#ifdef FFS_WIN
+    WIN32_FIND_DATA fileMetaData;
+    const HANDLE searchHandle = ::FindFirstFile(applyLongPathPrefix(filename).c_str(), &fileMetaData);
+    if (searchHandle == INVALID_HANDLE_VALUE)
+    {
+        const DWORD lastError = ::GetLastError();
+        const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + zToWx(filename) + wxT("\"")  +
+                                      wxT("\n\n") + getLastErrorFormatted(lastError);
+        if (lastError == ERROR_FILE_NOT_FOUND)
+            throw ErrorNotExisting(errorMessage);
+        else
+            throw FileError(errorMessage);
+    }
+
+    ::FindClose(searchHandle);
+
+    return wxULongLong(fileMetaData.nFileSizeHigh, fileMetaData.nFileSizeLow);
+
+#elif defined FFS_LINUX
+    struct stat fileInfo;
+    if (::stat(filename.c_str(), &fileInfo) != 0) //follow symbolic links
+    {
+        const int lastError = errno;
+        const wxString errorMessage = wxString(_("Error reading file attributes:")) + wxT("\n\"") + zToWx(filename) + wxT("\"") +
+                                      wxT("\n\n") + getLastErrorFormatted(lastError);
+        if (lastError == ENOENT)
+            throw ErrorNotExisting(errorMessage);
+        else
+            throw FileError(errorMessage);
+    }
+
+    return fileInfo.st_size;
+#endif
+}
+
+
+Zstring deleteAbandonedLockName(const Zstring& lockfilename)
+{
+    const size_t pos = lockfilename.Find(common::FILE_NAME_SEPARATOR, true); //search from end
+
+    return pos == Zstring::npos ? DefaultStr("Del.") + lockfilename :
+
+           Zstring(lockfilename.c_str(), pos + 1) + //include path separator
+           DefaultStr("Del.") +
+           lockfilename.AfterLast(common::FILE_NAME_SEPARATOR); //returns the whole string if ch not found
+}
+
+
+void writeLockId(const Zstring& lockfilename) //throw (FileError)
+{
+    //write GUID at the beginning of the file: this ID is a universal identifier for this lock (no matter what the path is, considering symlinks ,etc.)
+    FileOutputStream lockFile(lockfilename); //throw FileError()
+    util::UniqueId().toStream(lockFile);     //
+}
+
+
+util::UniqueId retrieveLockId(const Zstring& lockfilename) //throw (FileError, ErrorNotExisting)
+{
+    //read GUID from beginning of file
+    FileInputStream lockFile(lockfilename); //throw (FileError, ErrorNotExisting)
+    return util::UniqueId(lockFile);        //
+}
+
+
+void waitOnDirLock(const Zstring& lockfilename, DirLockCallback* callback) //throw (FileError)
+{
+    Zstring infoMsg;
+    infoMsg = wxToZ(_("Waiting while directory is locked (%x)..."));
+    infoMsg.Replace(DefaultStr("%x"), DefaultStr("\"") + lockfilename + DefaultStr("\""));
+    if (callback) callback->updateStatusText(infoMsg);
+    //---------------------------------------------------------------
+    try
+    {
+        const util::UniqueId lockId = retrieveLockId(lockfilename); //throw (FileError, ErrorNotExisting)
+
+        wxULongLong fileSizeOld;
+        wxLongLong lockSilentStart = wxGetLocalTimeMillis();
+
+        while (true)
+        {
+            const wxULongLong fileSizeNew = ::getLockFileSize(lockfilename); //throw (FileError, ErrorNotExisting)
+            const wxLongLong  currentTime  = wxGetLocalTimeMillis();
+
+            if (fileSizeNew != fileSizeOld)
+            {
+                //received life sign from lock
+                fileSizeOld     = fileSizeNew;
+                lockSilentStart = currentTime;
+            }
+            else if (currentTime - lockSilentStart > DETECT_EXITUS_INTERVAL)
+            {
+                DirLock dummy(deleteAbandonedLockName(lockfilename), callback); //throw (FileError)
+
+                //now that the lock is in place check existence again: meanwhile another process may have deleted and created a new lock!
+
+                if (retrieveLockId(lockfilename) != lockId) //throw (FileError, ErrorNotExisting)
+                    return; //another process has placed a new lock, leave scope: the wait for the old lock is technically over...
+
+                if (getLockFileSize(lockfilename) != fileSizeOld) //throw (FileError, ErrorNotExisting)
+                    continue; //belated lifesign
+
+                //---------------------------------------------------------------
+                Zstring infoMsg2 = wxToZ(_("Removing abandoned directory lock (%x)..."));
+                infoMsg2.Replace(DefaultStr("%x"), DefaultStr("\"") + lockfilename + DefaultStr("\""));
+                if (callback) callback->updateStatusText(infoMsg2);
+                //---------------------------------------------------------------
+
+                ::deleteLockFile(lockfilename); //throw (FileError)
+                return;
+            }
+
+            //wait some time...
+            const size_t GUI_CALLBACK_INTERVAL = 100;
+            for (size_t i = 0; i < POLL_LIFE_SIGN_INTERVAL / GUI_CALLBACK_INTERVAL; ++i)
+            {
+                if (callback) callback->requestUiRefresh();
+                wxMilliSleep(GUI_CALLBACK_INTERVAL);
+
+                //show some countdown on abandoned locks
+                if (callback)
+                {
+                    if (currentTime - lockSilentStart > EMIT_LIFE_SIGN_INTERVAL) //one signal missed: it's likely this is an abandoned lock:
+                    {
+                        long remainingSeconds = ((DETECT_EXITUS_INTERVAL - (wxGetLocalTimeMillis() - lockSilentStart)) / 1000).GetLo();
+                        remainingSeconds =  std::max(0L, remainingSeconds);
+
+                        Zstring remSecMsg = wxToZ(_("%x sec"));
+                        remSecMsg.Replace(DefaultStr("%x"), numberToZstring(remainingSeconds));
+                        callback->updateStatusText(infoMsg + DefaultStr(" ") + remSecMsg);
+                    }
+                    else
+                        callback->updateStatusText(infoMsg); //emit a message in any case (might clear other one)
+                }
+            }
+        }
+
+    }
+    catch (const ErrorNotExisting&)
+    {
+        return; //what we are waiting for...
+    }
+}
+
+
+void releaseLock(const Zstring& lockfilename) //throw ()
+{
+    try
+    {
+        ::deleteLockFile(lockfilename);
+    }
+    catch(...) {}
+}
+
+
+bool tryLock(const Zstring& lockfilename) //throw (FileError)
+{
+#ifdef FFS_WIN
+    const HANDLE fileHandle = ::CreateFile(applyLongPathPrefix(lockfilename).c_str(),
+                                           GENERIC_WRITE,
+                                           FILE_SHARE_READ,
+                                           NULL,
+                                           CREATE_NEW,
+                                           FILE_ATTRIBUTE_NORMAL,
+                                           NULL);
+    if (fileHandle == INVALID_HANDLE_VALUE)
+    {
+        if (::GetLastError() == ERROR_FILE_EXISTS)
+            return false;
+        else
+            throw FileError(wxString(_("Error setting directory lock:")) + wxT("\n\"") + zToWx(lockfilename) + wxT("\"") +
+                            wxT("\n\n") + getLastErrorFormatted());
+    }
+    ::CloseHandle(fileHandle);
+
+#elif defined FFS_LINUX
+    //O_EXCL contains a race condition on NFS file systems: http://linux.die.net/man/2/open
+    ::umask(0); //important!
+    const int fileHandle = ::open(lockfilename.c_str(), O_CREAT | O_WRONLY | O_EXCL, S_IRWXU | S_IRWXG | S_IRWXO);
+    if (fileHandle == -1)
+    {
+        if (errno == EEXIST)
+            return false;
+        else
+            throw FileError(wxString(_("Error setting directory lock:")) + wxT("\n\"") + zToWx(lockfilename) + wxT("\"") +
+                            wxT("\n\n") + getLastErrorFormatted());
+    }
+    ::close(fileHandle);
+#endif
+
+    Loki::ScopeGuard guardLockFile = Loki::MakeGuard(::releaseLock, lockfilename);
+
+    //write UUID at the beginning of the file: this ID is a universal identifier for this lock (no matter what the path is, considering symlinks ,etc.)
+    writeLockId(lockfilename); //throw (FileError)
+
+    guardLockFile.Dismiss(); //lockfile created successfully
+    return true;
+}
+}
+
+
+class DirLock::SharedDirLock
+{
+public:
+    SharedDirLock(const Zstring& lockfilename, DirLockCallback* callback = NULL) : //throw (FileError)
+        lockfilename_(lockfilename)
+    {
+        while (!::tryLock(lockfilename))             //throw (FileError)
+            ::waitOnDirLock(lockfilename, callback); //
+
+        emitLifeSigns.reset(new LifeSigns(lockfilename)); //throw()! ownership of lockfile not yet managed!
+    }
+
+    ~SharedDirLock()
+    {
+        emitLifeSigns.reset();
+
+        ::releaseLock(lockfilename_); //throw ()
+    }
+
+private:
+    SharedDirLock(const DirLock&);
+    SharedDirLock& operator=(const DirLock&);
+
+    const Zstring lockfilename_;
+
+    std::auto_ptr<LifeSigns> emitLifeSigns;
+};
+
+
+class DirLock::LockAdmin //administrate all locks of this process to avoid deadlock by recursion
+{
+public:
+    static LockAdmin& instance()
+    {
+        static LockAdmin inst;
+        return inst;
+    }
+
+    //create or retrieve a SharedDirLock
+    boost::shared_ptr<SharedDirLock> retrieve(const Zstring& lockfilename, DirLockCallback* callback) //throw (FileError)
+    {
+        //optimization: check if there is an active(!) lock for "lockfilename"
+        FileToUuidMap::const_iterator iterUuid = fileToUuid.find(lockfilename);
+        if (iterUuid != fileToUuid.end())
+        {
+            const boost::shared_ptr<SharedDirLock>& activeLock = findActive(iterUuid->second); //returns null-lock if not found
+            if (activeLock)
+                return activeLock; //SharedDirLock is still active -> enlarge circle of shared ownership
+        }
+
+        try //actual check based on lock UUID, deadlock prevention: "lockfilename" may be an alternative name for an already active lock
+        {
+            const util::UniqueId lockId = retrieveLockId(lockfilename); //throw (FileError, ErrorNotExisting)
+
+            const boost::shared_ptr<SharedDirLock>& activeLock = findActive(lockId); //returns null-lock if not found
+            if (activeLock)
+            {
+                fileToUuid[lockfilename] = lockId; //perf-optimization: update relation
+                return activeLock;
+            }
+        }
+        catch (const ErrorNotExisting&) {} //let other FileError(s) propagate!
+
+        //not yet in buffer, so create a new directory lock
+        boost::shared_ptr<SharedDirLock> newLock(new SharedDirLock(lockfilename, callback)); //throw (FileError)
+        const util::UniqueId newLockId = retrieveLockId(lockfilename); //throw (FileError, ErrorNotExisting)
+
+        //update registry
+        fileToUuid[lockfilename] = newLockId; //throw()
+        uuidToLock[newLockId]    = newLock;   //
+
+        return newLock;
+    }
+
+private:
+    LockAdmin() {}
+
+    boost::shared_ptr<SharedDirLock> findActive(const util::UniqueId& lockId) //returns null-lock if not found
+    {
+        UuidToLockMap::const_iterator iterLock = uuidToLock.find(lockId);
+        return iterLock != uuidToLock.end() ?
+               iterLock->second.lock() : //try to get shared_ptr; throw()
+               boost::shared_ptr<SharedDirLock>();
+    }
+
+    typedef boost::weak_ptr<SharedDirLock> SharedLock;
+
+    typedef std::map<Zstring, util::UniqueId, LessFilename> FileToUuidMap; //n:1 handle uppper/lower case correctly
+    typedef std::map<util::UniqueId, SharedLock>            UuidToLockMap; //1:1
+
+    FileToUuidMap fileToUuid; //lockname |-> UUID; locks can be referenced by a lockfilename or alternatively a UUID
+    UuidToLockMap uuidToLock; //UUID |-> "shared lock ownership"
+};
+
+
+DirLock::DirLock(const Zstring& lockfilename, DirLockCallback* callback) : //throw (FileError)
+    sharedLock(LockAdmin::instance().retrieve(lockfilename, callback)) {}