ZFileSystemWatcher.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZFileSystemWatcher.cpp
 * Created on: 10/26/2015
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <QtQml>
#include "ZFileSystemWatcher.h"

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZFileSystemWatcher)

ZFileSystemWatcher::ZFileSystemWatcher(QObject *parent) :
    QObject(parent), m_lock(QMutex::Recursive), m_restoreDeletedFiles(false)
{
    connect(&m_watcher, &QFileSystemWatcher::fileChanged,
            this, &ZFileSystemWatcher::onFileChanged);
    connect(&m_watcher, &QFileSystemWatcher::directoryChanged,
            this, &ZFileSystemWatcher::directoryChanged);
}

void ZFileSystemWatcher::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterType<ZFileSystemWatcher>("org.zuble.qml", 1, 0, "ZFileSystemWatcher");
}


bool ZFileSystemWatcher::addPath(const QString &file)
{
    ZBL_SLOT_BEGIN_TRY
    QMutexLocker lock(&m_lock);

    zFileWatcherMap::iterator it = m_paths.find(file);

    int fileReferenceCount = -1;
    bool ret = false;

    if(it == m_paths.end())
    {
        fileReferenceCount = 1;
        ret = m_watcher.addPath(file);
        if(ret)
            m_paths.insert(file, fileReferenceCount);
        else
            zCritical() << "Zuble can't watch file path: " << file;
    }
    else
    {
        fileReferenceCount = it.value();
        fileReferenceCount++;
        m_paths.insert(file, fileReferenceCount);
        ret = true;
    }

    ZBL_SLOT_END_RETURN(ret,  false,
    Z_FAC_JS, ZFileSystemWatcher::addPath, addPath failed)
}

QStringList ZFileSystemWatcher::addPaths(const QStringList &files)
{
    QStringList failedPaths;

    ZBL_SLOT_BEGIN_TRY
    QMutexLocker lock(&m_lock);

    const int fileCount = files.count();

    for(int i=0; i<fileCount; i++)
    {
        if(!addPath(files.at(i)))
            failedPaths.append(files.at(i));
    }

    ZBL_SLOT_END_RETURN(failedPaths,  failedPaths,
    Z_FAC_JS, ZFileSystemWatcher::addPaths, addPaths failed)
}

bool ZFileSystemWatcher::removePath(const QString &file)
{
    ZBL_SLOT_BEGIN_TRY
    QMutexLocker lock(&m_lock);

    zFileWatcherMap::iterator it = m_paths.find(file);

    int fileReferenceCount = -1;
    bool ret = true;

    if(it != m_paths.end())
    {
        fileReferenceCount = it.value();

        if(fileReferenceCount == 1)
        {
            ret = m_watcher.removePath(file);
        }
        else
        {
            fileReferenceCount--;
            m_paths.insert(file, fileReferenceCount);
        }
    }

    ZBL_SLOT_END_RETURN(ret,  false,
    Z_FAC_JS, ZFileSystemWatcher::removePath, removePath failed)
}

QStringList ZFileSystemWatcher::removePaths(const QStringList &files)
{
    QStringList failedPaths;

    ZBL_SLOT_BEGIN_TRY
    QMutexLocker lock(&m_lock);

    const int fileCount = files.count();

    for(int i=0; i<fileCount; i++)
    {
        if(!removePath(files.at(i)))
            failedPaths.append(files.at(i));
    }

    ZBL_SLOT_END_RETURN(failedPaths,  failedPaths,
    Z_FAC_JS, ZFileSystemWatcher::removePaths, removePaths failed)
}

QStringList ZFileSystemWatcher::files() const
{
    ZBL_SLOT_BEGIN_TRY
    QMutexLocker lock(const_cast<QMutex*>(&m_lock));
    ZBL_SLOT_END_RETURN(m_watcher.files(),  QStringList(),
    Z_FAC_JS, ZFileSystemWatcher::files, files failed)
}

QStringList ZFileSystemWatcher::directories() const
{
    ZBL_SLOT_BEGIN_TRY
    QMutexLocker lock(const_cast<QMutex*>(&m_lock));
    ZBL_SLOT_END_RETURN(m_watcher.directories(),  QStringList(),
    Z_FAC_JS, ZFileSystemWatcher::directories, directories failed)
}

bool ZFileSystemWatcher::getRestoreDeletedFiles()
{
    QMutexLocker lock(const_cast<QMutex*>(&m_lock));

    return m_restoreDeletedFiles;
}

void ZFileSystemWatcher::setRestoreDeletedFiles(bool restoreFiles)
{
    QMutexLocker lock(const_cast<QMutex*>(&m_lock));

    m_restoreDeletedFiles = restoreFiles;
}

bool ZFileSystemWatcher::waitForFileCreation(const QString &path)
{
    zFileWatcherMap::const_iterator i = m_paths.find(path);

    if(i == m_paths.end())
        return false;

    static const int max_iterations = 300; // 3 second timeout

    for(int iterations = 0; !QFile::exists(path); iterations++)
    {
        if(iterations > max_iterations)
        {
            zCritical() << "ERROR: ZFileSystemWatcher timed out waiting for creation of file: "
                        << path;

            m_paths.remove(path);
            return false;
        }
        QThread::msleep(10);
    }
    return true;
}

void ZFileSystemWatcher::onFileChanged(const QString& path)
{
    {
        QMutexLocker lock(const_cast<QMutex*>(&m_lock));

        if(m_restoreDeletedFiles)
        {
            if(waitForFileCreation(path))
                m_watcher.addPath(path);
        }
    }
    emit fileChanged(path);
}

} // Zbl