Mercurial > hg > easyhg

changeset 588:9b300409c184 easyhg_v1.2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge from branch "fswatcher"
author Chris Cannam
date Wed, 14 Mar 2012 12:14:50 +0000
parents f3a61f28896e (current diff) 4ed384ea7f39 (diff)
children 1b67f8008ea4
files
diffstat 4 files changed, 235 insertions(+), 45 deletions(-) [+]
line wrap: on
line diff
--- a/easyhg.pro	Wed Mar 07 15:25:33 2012 +0000
+++ b/easyhg.pro	Wed Mar 14 12:14:50 2012 +0000
@@ -4,13 +4,15 @@
 TEMPLATE = app
 TARGET = EasyMercurial
 
-# We use the 10.4 SDK and Carbon for all 32-bit OS/X,
-# and 10.6 with Cocoa for all 64-bit
+# We use the 10.5 SDK and Carbon for all 32-bit OS/X,
+# and 10.6 with Cocoa for all 64-bit. (Since EasyHg 1.2,
+# we can sadly no longer build for 10.4 because we need
+# the FSEvents API)
 macx-g++40 {
     # Note, to use the 10.4 SDK on 10.6+ you need qmake -spec macx-g++40
-    QMAKE_MAC_SDK = /Developer/SDKs/MacOSX10.4u.sdk
-    QMAKE_CFLAGS += -mmacosx-version-min=10.4
-    QMAKE_CXXFLAGS += -mmacosx-version-min=10.4
+    QMAKE_MAC_SDK = /Developer/SDKs/MacOSX10.5.sdk
+    QMAKE_CFLAGS += -mmacosx-version-min=10.5
+    QMAKE_CXXFLAGS += -mmacosx-version-min=10.5
     CONFIG += x86 ppc 
 }
 macx-g++ {
@@ -109,7 +111,7 @@
 
 macx-* {
     SOURCES += src/common_osx.mm
-    LIBS += -framework Foundation
+    LIBS += -framework CoreServices -framework Foundation
     ICON = easyhg-icon.icns
 }
 
--- a/src/fswatcher.cpp	Wed Mar 07 15:25:33 2012 +0000
+++ b/src/fswatcher.cpp	Wed Mar 14 12:14:50 2012 +0000
@@ -15,15 +15,20 @@
     COPYING included with this distribution for more information.
 */
 
+#include <QMutexLocker>
+#include <QDir>
+
+#ifdef Q_OS_MAC
+// Must include this before debug.h
+#include <CoreServices/CoreServices.h>
+#endif
+
 #include "fswatcher.h"
 #include "debug.h"
 
-#include <QMutexLocker>
-#include <QDir>
-
 #include <deque>
 
-//#define DEBUG_FSWATCHER 1
+#define DEBUG_FSWATCHER 1
 
 /*
  * Watching the filesystem is trickier than it seems at first glance.
@@ -45,16 +50,59 @@
  * directory to learn whether the set of files in it _excluding_ files
  * matching our ignore patterns differs from the previous scan, and
  * ignore the change if it doesn't.
+ *
+ */
+
+/*
+ * 20120312 -- Another complication. The documentation for
+ * QFileSystemWatcher says:
+ *
+ *     On Mac OS X 10.4 [...] an open file descriptor is required for
+ *     each monitored file. [...] This means that addPath() and
+ *     addPaths() will fail if your process tries to add more than 256
+ *     files or directories to the file system monitor [...] Mac OS X
+ *     10.5 and up use a different backend and do not suffer from this
+ *     issue.
+ * 
+ * Unfortunately, the last sentence above is not true:
+ * http://qt.gitorious.org/qt/qt/commit/6d1baf9979346d6f15da81a535becb4046278962
+ * ("Removing the usage of FSEvents-based backend for now as it has a
+ * few bugs...").  It can't be restored without hacking the Qt source,
+ * which we don't want to do in this context. The commit log doesn't
+ * make clear how serious the bugs were -- an example is given but it
+ * doesn't indicate whether it's an edge case or a common case and
+ * whether the result was a crash or failure to notify.
+ *
+ * This means the Qt class uses kqueue instead on OS/X, but that
+ * doesn't really work for us -- it can only monitor 256 files (or
+ * whatever the fd ulimit is set to, but that's the default) and it
+ * doesn't notify if a file within a directory is modified unless the
+ * metadata changes. The main limitation of FSEvents is that it only
+ * notifies with directory granularity, but that might be OK for us so
+ * long as notifications are actually provoked by file changes as
+ * well. (In OS/X 10.7 there appear to be file-level notifications
+ * too, but that doesn't help us.)
+ *
+ * One other problem with FSEvents is that the API only exists on OS/X
+ * 10.5 or newer -- on older versions we would have no option but to
+ * use kqueue via QFileSystemWatcher. But we can't ship a binary
+ * linked with the FSEvents API to run on 10.4 without some fiddling,
+ * and I'm not really keen to do that either.  That may be our cue to
+ * drop 10.4 support for EasyMercurial.
  */
 
 FsWatcher::FsWatcher() :
     m_lastToken(0),
     m_lastCounter(0)
 {
+#ifdef Q_OS_MAC
+    m_stream = 0; // create when we have a path
+#else
     connect(&m_watcher, SIGNAL(directoryChanged(QString)),
 	    this, SLOT(fsDirectoryChanged(QString)));
     connect(&m_watcher, SIGNAL(fileChanged(QString)),
 	    this, SLOT(fsFileChanged(QString)));
+#endif
 }
 
 FsWatcher::~FsWatcher()
@@ -66,6 +114,24 @@
 {
     QMutexLocker locker(&m_mutex);
     if (m_workDirPath == path) return;
+    clearWatchedPaths();
+    m_workDirPath = path;
+    addWorkDirectory(path);
+    debugPrint();
+}
+
+void
+FsWatcher::clearWatchedPaths()
+{
+#ifdef Q_OS_MAC
+    FSEventStreamRef stream = (FSEventStreamRef)m_stream;
+    if (stream) {
+        FSEventStreamStop(stream);
+        FSEventStreamInvalidate(stream);
+        FSEventStreamRelease(stream);
+    }
+    m_stream = 0;
+#else
     // annoyingly, removePaths prints a warning if given an empty list
     if (!m_watcher.directories().empty()) {
         m_watcher.removePaths(m_watcher.directories());
@@ -73,40 +139,60 @@
     if (!m_watcher.files().empty()) {
         m_watcher.removePaths(m_watcher.files());
     }
-    m_workDirPath = path;
-    addWorkDirectory(path);
-    debugPrint();
+#endif
 }
 
-void
-FsWatcher::setTrackedFilePaths(QStringList paths)
+#ifdef Q_OS_MAC
+static void
+fsEventsCallback(ConstFSEventStreamRef streamRef,
+                 void *clientCallBackInfo,
+                 size_t numEvents,
+                 void *paths,
+                 const FSEventStreamEventFlags eventFlags[],
+                 const FSEventStreamEventId eventIDs[])
 {
-    QMutexLocker locker(&m_mutex);
-
-    QSet<QString> alreadyWatched = 
-	QSet<QString>::fromList(m_watcher.files());
-
-    foreach (QString path, paths) {
-        path = m_workDirPath + QDir::separator() + path;
-        if (!alreadyWatched.contains(path)) {
-            m_watcher.addPath(path);
-        } else {
-            alreadyWatched.remove(path);
-        }
+    FsWatcher *watcher = reinterpret_cast<FsWatcher *>(clientCallBackInfo);
+    const char *const *cpaths = reinterpret_cast<const char *const *>(paths);
+    for (size_t i = 0; i < numEvents; ++i) {
+        std::cerr << "path " << i << " = " << cpaths[i] << std::endl;
+        watcher->fsDirectoryChanged(QString::fromLocal8Bit(cpaths[i]));
     }
-
-    // Remove the remaining paths, those that were being watched
-    // before but that are not in the list we were given
-    foreach (QString path, alreadyWatched) {
-        m_watcher.removePath(path);
-    }
-
-    debugPrint();
 }
+#endif
 
 void
 FsWatcher::addWorkDirectory(QString path)
 {
+#ifdef Q_OS_MAC
+
+    CFStringRef cfPath = CFStringCreateWithCharacters
+        (0, reinterpret_cast<const UniChar *>(path.unicode()),
+         path.length());
+
+    CFArrayRef cfPaths = CFArrayCreate(0, (const void **)&cfPath, 1, 0);
+
+    FSEventStreamContext ctx = { 0, 0, 0, 0, 0 };
+    ctx.info = this;
+
+    FSEventStreamRef stream =
+        FSEventStreamCreate(kCFAllocatorDefault,
+                            &fsEventsCallback,
+                            &ctx,
+                            cfPaths,
+                            kFSEventStreamEventIdSinceNow,
+                            1.0, // latency, seconds
+                            kFSEventStreamCreateFlagNone);
+
+    m_stream = stream;
+    
+    FSEventStreamScheduleWithRunLoop(stream,
+                                     CFRunLoopGetCurrent(),
+                                     kCFRunLoopDefaultMode);
+
+    if (!FSEventStreamStart(stream)) {
+        std::cerr << "ERROR: FsWatcher::addWorkDirectory: Failed to start FSEvent stream" << std::endl;
+    }
+#else
     // QFileSystemWatcher will refuse to add a file or directory to
     // its watch list that it is already watching -- fine -- but it
     // prints a warning when this happens, which we wouldn't want.  So
@@ -137,6 +223,48 @@
             }
         }
     }
+#endif
+}
+
+void
+FsWatcher::setTrackedFilePaths(QStringList paths)
+{
+#ifdef Q_OS_MAC
+
+    // FSEvents will notify when any file in the directory changes,
+    // but we need to be able to check whether the file change was
+    // meaningful to us if it didn't result in any files being added
+    // or removed -- and we have to do that by examining timestamps on
+    // the files we care about
+    foreach (QString p, paths) {
+        m_trackedFileUpdates[p] = QDateTime::currentDateTime();
+    }
+
+#else
+
+    QMutexLocker locker(&m_mutex);
+
+    QSet<QString> alreadyWatched = 
+	QSet<QString>::fromList(m_watcher.files());
+
+    foreach (QString path, paths) {
+        path = m_workDirPath + QDir::separator() + path;
+        if (!alreadyWatched.contains(path)) {
+            m_watcher.addPath(path);
+        } else {
+            alreadyWatched.remove(path);
+        }
+    }
+
+    // Remove the remaining paths, those that were being watched
+    // before but that are not in the list we were given
+    foreach (QString path, alreadyWatched) {
+        m_watcher.removePath(path);
+    }
+
+    debugPrint();
+
+#endif
 }
 
 void
@@ -181,29 +309,40 @@
 void
 FsWatcher::fsDirectoryChanged(QString path)
 {
+    bool haveChanges = false;
+
     {
 	QMutexLocker locker(&m_mutex);
 
 	if (shouldIgnore(path)) return;
 
         QSet<QString> files = scanDirectory(path);
+
         if (files == m_dirContents[path]) {
+
 #ifdef DEBUG_FSWATCHER
             std::cerr << "FsWatcher: Directory " << path << " has changed, but not in a way that we are monitoring" << std::endl;
 #endif
-            return;
+
+#ifdef Q_OS_MAC
+            haveChanges = manuallyCheckTrackedFiles();
+#endif
+
         } else {
+
 #ifdef DEBUG_FSWATCHER
             std::cerr << "FsWatcher: Directory " << path << " has changed" << std::endl;
 #endif
             m_dirContents[path] = files;
+            size_t counter = ++m_lastCounter;
+            m_changes[path] = counter;
+            haveChanges = true;
         }
-
-        size_t counter = ++m_lastCounter;
-        m_changes[path] = counter;
     }
 
-    emit changed();
+    if (haveChanges) {
+        emit changed();
+    }
 }
 
 void
@@ -215,7 +354,7 @@
         // We don't check whether the file matches an ignore pattern,
         // because we are only notified for file changes if we are
         // watching the file explicitly, i.e. the file is in the
-        // tracked file paths list. So we never want to ignore them
+        // tracked file paths list. So we never want to ignore these
 
 #ifdef DEBUG_FSWATCHER
         std::cerr << "FsWatcher: Tracked file " << path << " has changed" << std::endl;
@@ -228,6 +367,38 @@
     emit changed();
 }
 
+#ifdef Q_OS_MAC
+bool
+FsWatcher::manuallyCheckTrackedFiles()
+{
+    bool foundChanges = false;
+
+    for (PathTimeMap::iterator i = m_trackedFileUpdates.begin();
+         i != m_trackedFileUpdates.end(); ++i) {
+
+        QString path = i.key();
+        QDateTime prevUpdate = i.value();
+
+        QFileInfo fi(path);
+        QDateTime currUpdate = fi.lastModified();
+
+        if (currUpdate > prevUpdate) {
+
+#ifdef DEBUG_FSWATCHER
+            std::cerr << "FsWatcher: Tracked file " << path << " has been changed since last check" << std::endl;
+#endif
+            i.value() = currUpdate;
+            
+            size_t counter = ++m_lastCounter;
+            m_changes[path] = counter;
+            foundChanges = true;
+        }
+    }
+    
+    return foundChanges;
+}
+#endif
+
 bool
 FsWatcher::shouldIgnore(QString path)
 {
@@ -266,8 +437,6 @@
             files.insert(entry);
         }
     }
-//    std::cerr << "scanDirectory:" << std::endl;
-//    foreach (QString f, files) std::cerr << f << std::endl;
     return files;
 }
 
@@ -275,8 +444,10 @@
 FsWatcher::debugPrint()
 {
 #ifdef DEBUG_FSWATCHER
+#ifndef Q_OS_MAC
     std::cerr << "FsWatcher: Now watching " << m_watcher.directories().size()
               << " directories and " << m_watcher.files().size()
               << " files" << std::endl;
 #endif
+#endif
 }
--- a/src/fswatcher.h	Wed Mar 07 15:25:33 2012 +0000
+++ b/src/fswatcher.h	Wed Mar 14 12:14:50 2012 +0000
@@ -24,8 +24,14 @@
 #include <QSet>
 #include <QHash>
 #include <QMap>
+#include <QDateTime>
 #include <QStringList>
+
+#ifndef Q_OS_MAC
+// We don't use QFileSystemWatcher on OS/X.
+// See comments at top of fswatcher.cpp for an explanation.
 #include <QFileSystemWatcher>
+#endif
 
 class FsWatcher : public QObject
 {
@@ -87,12 +93,15 @@
      */
     void changed();
 
-private slots:
+public slots:
     void fsDirectoryChanged(QString);
     void fsFileChanged(QString);
 
 private:
     // call with lock already held
+    void clearWatchedPaths();
+
+    // call with lock already held
     void addWorkDirectory(QString path);
 
     // call with lock already held
@@ -142,7 +151,15 @@
     QString m_workDirPath;
     int m_lastToken;
     size_t m_lastCounter;
+
+#ifdef Q_OS_MAC
+    void *m_stream;
+    typedef QMap<QString, QDateTime> PathTimeMap;
+    PathTimeMap m_trackedFileUpdates;
+    bool manuallyCheckTrackedFiles();
+#else
     QFileSystemWatcher m_watcher;
+#endif
 };
 
 #endif
--- a/src/mainwindow.cpp	Wed Mar 07 15:25:33 2012 +0000
+++ b/src/mainwindow.cpp	Wed Mar 14 12:14:50 2012 +0000
@@ -1,4 +1,4 @@
-/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+ /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
 
 /*
     EasyMercurial