src/support/FileMonitor.cpp

   1 /**
   2  * \file FileMonitor.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  * \author Guillaume Munch
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "support/FileMonitor.h"
  15
  16 #include "support/debug.h"
  17 #include "support/FileName.h"
  18 #include "support/qstring_helpers.h"
  19 #include "support/unique_ptr.h"
  20
  21 #include <QFile>
  22 #include <QStringList>
  23 #include <QTimer>
  24
  25 #include <algorithm>
  26
  27 using namespace std;
  28
  29 namespace lyx {
  30 namespace support {
  31
  32
  33 FileSystemWatcher & FileSystemWatcher::instance()
  34 {
  35         // This is thread-safe because QFileSystemWatcher is thread-safe.
  36         static FileSystemWatcher f;
  37         return f;
  38 }
  39
  40
  41 FileSystemWatcher::FileSystemWatcher()
  42         : qwatcher_(make_unique<QFileSystemWatcher>())
  43 {}
  44
  45
  46 shared_ptr<FileMonitorGuard>
  47 FileSystemWatcher::getGuard(FileName const & filename)
  48 {
  49         string const absfilename = filename.absFileName();
  50         weak_ptr<FileMonitorGuard> & wptr = store_[absfilename];
  51         if (shared_ptr<FileMonitorGuard> mon = wptr.lock())
  52                 return mon;
  53         auto mon = make_shared<FileMonitorGuard>(absfilename, qwatcher_.get());
  54         wptr = mon;
  55         return mon;
  56 }
  57
  58
  59 //static
  60 FileMonitorPtr FileSystemWatcher::monitor(FileName const & filename)
  61 {
  62         return make_unique<FileMonitor>(instance().getGuard(filename));
  63 }
  64
  65
  66 //static
  67 ActiveFileMonitorPtr FileSystemWatcher::activeMonitor(FileName const & filename,
  68                                                       int interval)
  69 {
  70         return make_unique<ActiveFileMonitor>(instance().getGuard(filename),
  71                                               filename, interval);
  72 }
  73
  74
  75 //static
  76 void FileSystemWatcher::debug()
  77 {
  78         FileSystemWatcher & f = instance();
  79         QStringList q_files = f.qwatcher_->files();
  80         for (pair<string, weak_ptr<FileMonitorGuard>> pair : f.store_) {
  81                 string const & name = pair.first;
  82                 if (!pair.second.expired()) {
  83                         if (!q_files.contains(toqstr(name)))
  84                                 LYXERR0("Monitored but not QFileSystemWatched (bad): " << name);
  85                         else {
  86                                 //LYXERR0("Monitored and QFileSystemWatched (good): " << name);
  87                         }
  88                 }
  89         }
  90         for (QString const & qname : q_files) {
  91                 string const name = fromqstr(qname);
  92                 weak_ptr<FileMonitorGuard> & wptr = f.store_[name];
  93                 if (wptr.expired())
  94                         LYXERR0("QFileSystemWatched but not monitored (bad): " << name);
  95         }
  96 }
  97
  98
  99 FileMonitorGuard::FileMonitorGuard(string const & filename,
 100                                    QFileSystemWatcher * qwatcher)
 101         : filename_(filename), qwatcher_(qwatcher), exists_(true)
 102 {
 103         QObject::connect(qwatcher, SIGNAL(fileChanged(QString const &)),
 104                          this, SLOT(notifyChange(QString const &)));
 105         if (qwatcher_->files().contains(toqstr(filename)))
 106                 LYXERR0("This file is already being QFileSystemWatched: " << filename
 107                         << ". This should not happen.");
 108         refresh();
 109 }
 110
 111
 112 FileMonitorGuard::~FileMonitorGuard()
 113 {
 114         qwatcher_->removePath(toqstr(filename_));
 115 }
 116
 117
 118 void FileMonitorGuard::refresh()
 119 {
 120         QString const qfilename = toqstr(filename_);
 121         if(!qwatcher_->files().contains(qfilename)) {
 122                 bool exists = QFile(qfilename).exists();
 123 #if (QT_VERSION >= 0x050000)
 124                 if (!exists || !qwatcher_->addPath(qfilename))
 125 #else
 126                 auto add_path = [&]() {
 127                         qwatcher_->addPath(qfilename);
 128                         return qwatcher_->files().contains(qfilename);
 129                 };
 130                 if (!exists || !add_path())
 131 #endif
 132                 {
 133                         if (exists)
 134                                 LYXERR(Debug::FILES,
 135                                        "Could not add path to QFileSystemWatcher: "
 136                                        << filename_);
 137                         QTimer::singleShot(2000, this, SLOT(refresh()));
 138                 } else if (exists && !exists_)
 139                         Q_EMIT fileChanged();
 140                 setExists(exists);
 141         }
 142 }
 143
 144
 145 void FileMonitorGuard::notifyChange(QString const & path)
 146 {
 147         if (path == toqstr(filename_)) {
 148                 Q_EMIT fileChanged();
 149                 // If the file has been modified by delete-move, we are notified of the
 150                 // deletion but we no longer track the file. See
 151                 // <https://bugreports.qt.io/browse/QTBUG-46483> (not a bug).
 152                 refresh();
 153         }
 154 }
 155
 156
 157 FileMonitor::FileMonitor(std::shared_ptr<FileMonitorGuard> monitor)
 158         : monitor_(monitor)
 159 {
 160         QObject::connect(monitor_.get(), SIGNAL(fileChanged()),
 161                          this, SLOT(changed()));
 162         refresh();
 163 }
 164
 165
 166 void FileMonitor::reconnectToFileMonitorGuard()
 167 {
 168         monitor_->setExists(true);
 169         QObject::connect(monitor_.get(), SIGNAL(fileChanged()),
 170                          this, SLOT(changed()));
 171 }
 172
 173
 174 boost::signals2::connection
 175 FileMonitor::connect(sig::slot_type const & slot)
 176 {
 177         return fileChanged_.connect(slot);
 178 }
 179
 180
 181 void FileMonitor::disconnect()
 182 {
 183         fileChanged_.disconnect_all_slots();
 184         QObject::disconnect(this, SIGNAL(fileChanged()));
 185 }
 186
 187
 188 void FileMonitor::changed()
 189 {
 190         // emit boost signal
 191         fileChanged_();
 192         Q_EMIT fileChanged();
 193 }
 194
 195
 196 FileMonitorBlocker FileMonitor::block(int delay)
 197 {
 198         FileMonitorBlocker blocker = blocker_.lock();
 199         if (!blocker)
 200                 blocker_ = blocker = make_shared<FileMonitorBlockerGuard>(this);
 201         blocker->setDelay(delay);
 202         return blocker;
 203 }
 204
 205
 206 FileMonitorBlockerGuard::FileMonitorBlockerGuard(FileMonitor * monitor)
 207         : monitor_(monitor), delay_(0)
 208 {
 209         QObject::disconnect(monitor->monitor_.get(), SIGNAL(fileChanged()),
 210                             monitor, SLOT(changed()));
 211 }
 212
 213
 214 void FileMonitorBlockerGuard::setDelay(int delay)
 215 {
 216         delay_ = max(delay_, delay);
 217 }
 218
 219
 220 FileMonitorBlockerGuard::~FileMonitorBlockerGuard()
 221 {
 222         if (!monitor_)
 223                 return;
 224         // Even if delay_ is 0, the QTimer is necessary. Indeed, the notifications
 225         // from QFileSystemWatcher that we meant to ignore are not going to be
 226         // treated immediately, so we must yield to give us the opportunity to
 227         // ignore them.
 228         QTimer::singleShot(delay_, monitor_, SLOT(reconnectToFileMonitorGuard()));
 229 }
 230
 231
 232 ActiveFileMonitor::ActiveFileMonitor(std::shared_ptr<FileMonitorGuard> monitor,
 233                                      FileName const & filename, int interval)
 234         : FileMonitor(monitor), filename_(filename), interval_(interval),
 235           timestamp_(0), checksum_(0), cooldown_(true)
 236 {
 237         QObject::connect(this, SIGNAL(fileChanged()), this, SLOT(setCooldown()));
 238         QTimer::singleShot(interval_, this, SLOT(clearCooldown()));
 239         if (!filename_.exists())
 240                 return;
 241         timestamp_ = filename_.lastModified();
 242         checksum_ = filename_.checksum();
 243 }
 244
 245
 246 void ActiveFileMonitor::checkModified()
 247 {
 248         if (cooldown_)
 249                 return;
 250
 251         cooldown_ = true;
 252         bool changed = false;
 253         if (!filename_.exists()) {
 254                 changed = timestamp_ || checksum_;
 255                 timestamp_ = 0;
 256                 checksum_ = 0;
 257         } else {
 258                 time_t const new_timestamp = filename_.lastModified();
 259
 260                 if (new_timestamp != timestamp_) {
 261                         timestamp_ = new_timestamp;
 262
 263                         unsigned long const new_checksum = filename_.checksum();
 264                         if (new_checksum != checksum_) {
 265                                 checksum_ = new_checksum;
 266                                 changed = true;
 267                         }
 268                 }
 269         }
 270         if (changed)
 271                 FileMonitor::changed();
 272         QTimer::singleShot(interval_, this, SLOT(clearCooldown()));
 273 }
 274
 275
 276 void ActiveFileMonitor::checkModifiedAsync()
 277 {
 278         if (!cooldown_)
 279                 QTimer::singleShot(0, this, SLOT(checkModified()));
 280 }
 281
 282
 283
 284 } // namespace support
 285 } // namespace lyx
 286
 287 #include "moc_FileMonitor.cpp"