Merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0

[dobey]

[Manuel de la Peña]

    - Clean the location of the filemonitor imports (LP:1026212).
    - Provides an extra command line that allows to choose which filemonitor implementation to use with the ubuntuone sync daemon (LP: 1025689).
    - Unify the file monitor implementations to simplify the fact that more than one monitor implementation exists on darwin.
    - Move the NotifyProcessor to a multipletform package to simplify the code and remove circular imports.
    -Added initial inclusion of the file system monitor that will allow to use the fsevents daemon in darwin.

[Mike McCracken]

    - Add test script that fails if reactor is imported from the wrong place (LP: #1030961)
    - Remove unnecessary symbol imports to avoid loading default reactor when not needed (LP: #1029636)

[Eric Casteleijn (thisfred)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0 failed. Below is the output from the failed tests.

/usr/bin/gnome-autogen.sh
checking for autoconf >= 2.53...
  testing autoconf2.50... not found.
  testing autoconf... found 2.69
checking for automake >= 1.10...
  testing automake-1.11... found 1.11.5
checking for libtool >= 1.5...
  testing libtoolize... found 2.4.2
checking for intltool >= 0.30...
  testing intltoolize... found 0.50.2
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.26
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.18
Checking for required M4 macros...
Checking for forbidden M4 macros...
Processing ./configure.ac
Running libtoolize...
libtoolize: putting auxiliary files in `.'.
libtoolize: copying file `./ltmain.sh'
libtoolize: putting macros in AC_CONFIG_MACRO_DIR, `m4'.
libtoolize: copying file `m4/libtool.m4'
libtoolize: copying file `m4/ltoptions.m4'
libtoolize: copying file `m4/ltsugar.m4'
libtoolize: copying file `m4/ltversion.m4'
libtoolize: copying file `m4/lt~obsolete.m4'
Running intltoolize...
Running gtkdocize...
Running aclocal-1.11...
Running autoconf...
Running autoheader...
Running automake-1.11...
Running ./configure --enable-gtk-doc --enable-debug ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking whether make supports nested variables... yes
checking for style of include used by make... GNU
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for library containing strerror... none required
checking for gcc... (cached) gcc
checking whether we are using the GNU C compiler... (cached) yes
checking whether gcc accepts -g... (cached) yes
checking for gcc option to accept ISO C89... (cached) none needed
checking dependency style of gcc... (cached) gcc3
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking how to print strings... printf
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... y...

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0 failed. Below is the output from the failed tests.

/usr/bin/gnome-autogen.sh
checking for autoconf >= 2.53...
  testing autoconf2.50... not found.
  testing autoconf... found 2.69
checking for automake >= 1.10...
  testing automake-1.11... found 1.11.5
checking for libtool >= 1.5...
  testing libtoolize... found 2.4.2
checking for intltool >= 0.30...
  testing intltoolize... found 0.50.2
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.26
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.18
Checking for required M4 macros...
Checking for forbidden M4 macros...
Processing ./configure.ac
Running libtoolize...
libtoolize: putting auxiliary files in `.'.
libtoolize: copying file `./ltmain.sh'
libtoolize: putting macros in AC_CONFIG_MACRO_DIR, `m4'.
libtoolize: copying file `m4/libtool.m4'
libtoolize: copying file `m4/ltoptions.m4'
libtoolize: copying file `m4/ltsugar.m4'
libtoolize: copying file `m4/ltversion.m4'
libtoolize: copying file `m4/lt~obsolete.m4'
Running intltoolize...
Running gtkdocize...
Running aclocal-1.11...
Running autoconf...
Running autoheader...
Running automake-1.11...
Running ./configure --enable-gtk-doc --enable-debug ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking whether make supports nested variables... yes
checking for style of include used by make... GNU
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for library containing strerror... none required
checking for gcc... (cached) gcc
checking whether we are using the GNU C compiler... (cached) yes
checking whether gcc accepts -g... (cached) yes
checking for gcc option to accept ISO C89... (cached) none needed
checking dependency style of gcc... (cached) gcc3
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking how to print strings... printf
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... y...

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0 failed. Below is the output from the failed tests.

/usr/bin/gnome-autogen.sh
checking for autoconf >= 2.53...
  testing autoconf2.50... not found.
  testing autoconf... found 2.69
checking for automake >= 1.10...
  testing automake-1.11... found 1.11.5
checking for libtool >= 1.5...
  testing libtoolize... found 2.4.2
checking for intltool >= 0.30...
  testing intltoolize... found 0.50.2
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.26
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.18
Checking for required M4 macros...
Checking for forbidden M4 macros...
Processing ./configure.ac
Running libtoolize...
libtoolize: putting auxiliary files in `.'.
libtoolize: copying file `./ltmain.sh'
libtoolize: putting macros in AC_CONFIG_MACRO_DIR, `m4'.
libtoolize: copying file `m4/libtool.m4'
libtoolize: copying file `m4/ltoptions.m4'
libtoolize: copying file `m4/ltsugar.m4'
libtoolize: copying file `m4/ltversion.m4'
libtoolize: copying file `m4/lt~obsolete.m4'
Running intltoolize...
Running gtkdocize...
Running aclocal-1.11...
Running autoconf...
Running autoheader...
Running automake-1.11...
Running ./configure --enable-gtk-doc --enable-debug ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking whether make supports nested variables... yes
checking for style of include used by make... GNU
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for library containing strerror... none required
checking for gcc... (cached) gcc
checking whether we are using the GNU C compiler... (cached) yes
checking whether gcc accepts -g... (cached) yes
checking for gcc option to accept ISO C89... (cached) none needed
checking dependency style of gcc... (cached) gcc3
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking how to print strings... printf
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... y...

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0 failed. Below is the output from the failed tests.

/usr/bin/gnome-autogen.sh
checking for autoconf >= 2.53...
  testing autoconf2.50... not found.
  testing autoconf... found 2.69
checking for automake >= 1.10...
  testing automake-1.11... found 1.11.5
checking for libtool >= 1.5...
  testing libtoolize... found 2.4.2
checking for intltool >= 0.30...
  testing intltoolize... found 0.50.2
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.26
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.18
Checking for required M4 macros...
Checking for forbidden M4 macros...
Processing ./configure.ac
Running libtoolize...
libtoolize: putting auxiliary files in `.'.
libtoolize: copying file `./ltmain.sh'
libtoolize: putting macros in AC_CONFIG_MACRO_DIR, `m4'.
libtoolize: copying file `m4/libtool.m4'
libtoolize: copying file `m4/ltoptions.m4'
libtoolize: copying file `m4/ltsugar.m4'
libtoolize: copying file `m4/ltversion.m4'
libtoolize: copying file `m4/lt~obsolete.m4'
Running intltoolize...
Running gtkdocize...
Running aclocal-1.11...
Running autoconf...
Running autoheader...
Running automake-1.11...
Running ./configure --enable-gtk-doc --enable-debug ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking whether make supports nested variables... yes
checking for style of include used by make... GNU
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for library containing strerror... none required
checking for gcc... (cached) gcc
checking whether we are using the GNU C compiler... (cached) yes
checking whether gcc accepts -g... (cached) yes
checking for gcc option to accept ISO C89... (cached) none needed
checking dependency style of gcc... (cached) gcc3
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking how to print strings... printf
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... y...

=== modified file 'Makefile.am'
--- Makefile.am	2012-05-15 13:25:37 +0000
+++ Makefile.am	2012-07-31 17:27:22 +0000
@@ -54,8 +54,9 @@
 test: logging.conf $(clientdefs_DATA) Makefile
 	echo "$(PYTHONPATH)"
 	if test "x$(builddir)" == "x$(srcdir)"; then \
-		PYTHONPATH="$(PYTHONPATH)" u1trial -r $(REACTOR) -p tests/platform/windows,tests/proxy -i "test_windows.py,test_darwin.py" tests || exit 1; \
+		PYTHONPATH="$(PYTHONPATH)" u1trial -r $(REACTOR) -p tests/platform/windows,tests/proxy -i "test_windows.py,test_darwin.py,test_fsevents_daemon.py" tests || exit 1; \
 		PYTHONPATH="$(PYTHONPATH)" u1trial -r qt4 -p tests/platform/windows -i "test_windows.py,test_darwin.py" tests/proxy || exit 1; \
+		PYTHONPATH="$(PYTHONPATH)" $(PYTHON) tests/platform/check_reactor_import.py || exit 1; \
 	fi
 	rm -rf _trial_temp
 

=== modified file 'bin/ubuntuone-syncdaemon'
--- bin/ubuntuone-syncdaemon	2012-07-02 15:39:40 +0000
+++ bin/ubuntuone-syncdaemon	2012-07-31 17:27:22 +0000
@@ -56,6 +56,10 @@
     recursive_move,
     set_application_name,
 )
+from ubuntuone.platform.filesystem_notifications.monitor import (
+    get_filemonitor_class,
+)
+
 from ubuntuone.syncdaemon import logger, config
 from ubuntuone.syncdaemon.config import (
     get_config_files,
@@ -212,6 +216,9 @@
                   "[CONSUMER_KEY:CONSUMER_SECRET:]KEY:SECRET"
             parser.error(msg)
 
+    # check which file monitor to use
+    monitor_class = yield get_filemonitor_class(options.fs_monitor)
+
     main = Main(options.root_dir, options.shares_dir, options.data_dir,
                 partials_dir, host=options.host, port=int(options.port),
                 dns_srv=options.dns_srv, ssl=True,
@@ -224,7 +231,8 @@
                 write_limit=options.bandwidth_throttling_write_limit,
                 throttling_enabled=options.bandwidth_throttling_on,
                 ignore_files=options.ignore,
-                oauth_credentials=oauth_credentials)
+                oauth_credentials=oauth_credentials,
+                monitor_class=monitor_class)
 
     # override the reactor default signal handlers in order to
     # shutdown properly

=== modified file 'data/syncdaemon.conf'
--- data/syncdaemon.conf	2012-06-20 15:19:12 +0000
+++ data/syncdaemon.conf	2012-07-31 17:27:22 +0000
@@ -106,6 +106,11 @@
 memory_pool_limit.parser = int
 memory_pool_limit.help = How many AQ Commands will be kept in memory to execute.
 
+fs_monitor.default = default
+fs_monitor.metavar = MONITOR_TYPE
+fs_monitor.help = Set the file monitor to be used to get the events from the
+    file system.
+
 
 [notifications]
 show_all_notifications.default = True
@@ -130,6 +135,7 @@
 write_limit.metavar = UPLOAD_LIMIT
 write_limit.help = Set the upload limit (bytes/sec).
 
+
 [debug]
 lsprof_file.metavar = FILE
 lsprof_file.help = Profile execution using the lsprof profiler, and write the 

=== modified file 'run-mac-tests'
--- run-mac-tests	2012-06-27 19:48:24 +0000
+++ run-mac-tests	2012-07-31 17:27:22 +0000
@@ -45,3 +45,5 @@
 python $u1trial --reactor=twisted -i "test_linux.py,test_windows.py" -p tests/platform/linux "$MODULE"
 rm -rf _trial_temp
 rm -rf build
+
+python tests/platform/check_reactor_import.py

=== modified file 'run-tests.bat'
--- run-tests.bat	2012-05-16 16:56:41 +0000
+++ run-tests.bat	2012-07-31 17:27:22 +0000
@@ -74,7 +74,7 @@
 COPY windows\clientdefs.py ubuntuone\clientdefs.py
 COPY windows\logging.conf data\logging.conf
 :: execute the tests with a number of ignored linux and mac os only modules
-"%PYTHONEXEPATH%" "%TRIALPATH%" --reactor=twisted -c -p tests\platform\linux -i "test_linux.py,test_darwin.py" %PARAMS% tests
+"%PYTHONEXEPATH%" "%TRIALPATH%" --reactor=twisted -c -p tests\platform\linux -i "test_linux.py,test_darwin.py,test_fsevents_daemon.py" %PARAMS% tests
 
 IF %SKIPLINT% == 1 (
     ECHO Skipping style checks
@@ -82,6 +82,8 @@
 ECHO Performing style checks...
 "%PYTHONEXEPATH%" "%LINTPATH%"
 
+"%PYTHONEXEPATH%" tests\platform\check_reactor_import.py
+
 :: if pep8 is not present, move to the end
 IF EXIST "%PEP8PATH%" (
     "%PEP8PATH%" --repeat ubuntuone

=== added file 'tests/platform/check_reactor_import.py'
--- tests/platform/check_reactor_import.py	1970-01-01 00:00:00 +0000
+++ tests/platform/check_reactor_import.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,74 @@
+#! /usr/bin/python
+#
+# Copyright (C) 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""A script that checks for unintended imports of twisted.internet.reactor."""
+
+# NOTE: the goal of this script is to avoid a bug that affects
+# ubuntuone-control-panel on windows and darwin. Those platforms use
+# the qt4reactor, and will break if the default reactor is installed
+# first. This can happen if a module used by control-panel (such as
+# ubuntuone.platform.credentials), imports reactor.  Only sub-modules
+# that are not used by ubuntuone-control-panel can safely import
+# reactor at module-level.
+
+from __future__ import (unicode_literals, print_function)
+
+import __builtin__
+
+import sys
+import traceback
+
+
+def fake_import(*args, **kwargs):
+    """A wrapper for __import__ that dies when importing reactor."""
+    imp_name_base = args[0]
+
+    if len(args) == 4 and args[3] is not None:
+        imp_names = ["{0}.{1}".format(imp_name_base, sm)
+                     for sm in args[3]]
+    else:
+        imp_names = [imp_name_base]
+
+    for imp_name in imp_names:
+        if 'twisted.internet.reactor' == imp_name:
+            print("ERROR: should not import reactor here:")
+            traceback.print_stack()
+            sys.exit(1)
+
+    r = real_import(*args, **kwargs)
+    return r
+
+
+if __name__ == '__main__':
+
+    real_import = __builtin__.__import__
+    __builtin__.__import__ = fake_import
+
+    subs = ["", ".tools", ".logger", ".credentials"]
+    for module in ["ubuntuone.platform" + p for p in subs]:
+        m = __import__(module)

=== modified file 'tests/platform/filesystem_notifications/test_darwin.py'
--- tests/platform/filesystem_notifications/test_darwin.py	2012-07-12 13:51:33 +0000
+++ tests/platform/filesystem_notifications/test_darwin.py	2012-07-31 17:27:22 +0000
@@ -39,11 +39,14 @@
 
 from contrib.testing.testcase import BaseTwistedTestCase
 from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.platform.filesystem_notifications import (
-    darwin as filesystem_notifications,
-)
-from ubuntuone.platform.filesystem_notifications.common import (
-    NotifyProcessor,
+from ubuntuone.platform.filesystem_notifications.monitor import (
+    common,
+)
+from ubuntuone.platform.filesystem_notifications.monitor.darwin import (
+    fsevents_client as filesystem_notifications,
+)
+from ubuntuone.platform.filesystem_notifications import notify_processor
+from ubuntuone.platform.filesystem_notifications.monitor.common import (
     Watch,
     WatchManager,
 )
@@ -60,7 +63,7 @@
 
 # A reverse mapping for the tests
 REVERSE_MACOS_ACTIONS = {}
-for key, value in filesystem_notifications.ACTIONS.iteritems():
+for key, value in common.ACTIONS.items():
     REVERSE_MACOS_ACTIONS[value] = key
 
 
@@ -1030,7 +1033,7 @@
     def setUp(self):
         """set up the diffeent tests."""
         yield super(TestNotifyProcessor, self).setUp()
-        self.processor = NotifyProcessor(None)
+        self.processor = notify_processor.NotifyProcessor(None)
         self.general = FakeGeneralProcessor()
         self.processor.general_processor = self.general
 
@@ -1384,3 +1387,10 @@
 
         self.assertTrue(d1.result, "Should not be called yet.")
         self.assertTrue(d2, "Should not be called yet.")
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor(self):
+        """Test test the is_available_monitor method."""
+        # we should always return true
+        is_available = yield common.FilesystemMonitor.is_available_monitor()
+        self.assertTrue(is_available, 'Should always be available.')

=== modified file 'tests/platform/filesystem_notifications/test_filesystem_notifications.py'
--- tests/platform/filesystem_notifications/test_filesystem_notifications.py	2012-07-10 20:11:18 +0000
+++ tests/platform/filesystem_notifications/test_filesystem_notifications.py	2012-07-31 17:27:22 +0000
@@ -46,9 +46,7 @@
     remove_dir,
     rename,
 )
-from ubuntuone.platform.filesystem_notifications import (
-    _GeneralINotifyProcessor,
-)
+from ubuntuone.platform.filesystem_notifications import notify_processor
 from ubuntuone.syncdaemon.tritcask import Tritcask
 from ubuntuone.syncdaemon import (
     event_queue,
@@ -62,19 +60,19 @@
 
     def test_filter_none(self):
         """Still works ok even if not receiving a regex to ignore."""
-        p = _GeneralINotifyProcessor(None)
+        p = notify_processor.NotifyProcessor(None)
         self.assertFalse(p.is_ignored("froo.pyc"))
 
     def test_filter_one(self):
         """Filters stuff that matches (or not) this one regex."""
-        p = _GeneralINotifyProcessor(None, ['\A.*\\.pyc\Z'])
+        p = notify_processor.NotifyProcessor(None, ['\A.*\\.pyc\Z'])
         self.assertTrue(p.is_ignored("froo.pyc"))
         self.assertFalse(p.is_ignored("froo.pyc.real"))
         self.assertFalse(p.is_ignored("otherstuff"))
 
     def test_filter_two_simple(self):
         """Filters stuff that matches (or not) these simple regexes."""
-        p = _GeneralINotifyProcessor(None, ['\A.*foo\Z', '\A.*bar\Z'])
+        p = notify_processor.NotifyProcessor(None, ['\A.*foo\Z', '\A.*bar\Z'])
         self.assertTrue(p.is_ignored("blah_foo"))
         self.assertTrue(p.is_ignored("blah_bar"))
         self.assertFalse(p.is_ignored("bar_xxx"))
@@ -83,7 +81,7 @@
 
     def test_filter_two_complex(self):
         """Filters stuff that matches (or not) these complex regexes."""
-        p = _GeneralINotifyProcessor(None,
+        p = notify_processor.NotifyProcessor(None,
                                      ['\A.*foo\Z|\Afoo.*\Z', '\A.*bar\Z'])
         self.assertTrue(p.is_ignored("blah_foo"))
         self.assertTrue(p.is_ignored("blah_bar"))
@@ -98,7 +96,7 @@
         store_call = lambda *args: calls.append(args)
         self.patch(filesystem_notifications, "access", store_call)
         self.patch(filesystem_notifications, "path_exists", lambda _: True)
-        p = _GeneralINotifyProcessor(None)
+        p = notify_processor.NotifyProcessor(None)
         p.is_ignored(sample_path)
         self.assertEqual(calls, [(sample_path,)])
 

=== added file 'tests/platform/filesystem_notifications/test_fsevents_daemon.py'
--- tests/platform/filesystem_notifications/test_fsevents_daemon.py	1970-01-01 00:00:00 +0000
+++ tests/platform/filesystem_notifications/test_fsevents_daemon.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,483 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Tests for the fsevents daemon integration."""
+
+import os
+
+from twisted.internet import defer, protocol
+
+from contrib.testing.testcase import BaseTwistedTestCase
+from ubuntuone.darwin import fsevents
+from ubuntuone.devtools.testcases.txsocketserver import TidyUnixServer
+from ubuntuone.platform.filesystem_notifications.monitor.darwin import (
+    fsevents_daemon,
+)
+from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
+    IN_CREATE,
+    IN_DELETE,
+    IN_MOVED_FROM,
+    IN_MOVED_TO,
+)
+
+class FakeServerProtocol(protocol.Protocol):
+    """A test protocol."""
+
+    def dataReceived(self, data):
+        """Echo the data received."""
+        self.transport.write(data)
+
+
+class FakeServerFactory(protocol.ServerFactory):
+    """A factory for the test server."""
+
+    protocol = FakeServerProtocol
+
+
+class FakeDaemonEvent(object):
+    """A fake daemon event."""
+
+    def __init__(self):
+        self.event_paths = []
+        self.is_directory = False
+        self.event_type = None
+
+
+class FakeProcessor(object):
+    """A fake processor."""
+
+    def __init__(self, *args):
+        """Create a new instance."""
+        self.processed_events = []
+
+    def __call__(self, event):
+        """Process and event."""
+        self.processed_events.append(event)
+
+
+class FakePyInotifyEventsFactory(object):
+    """Fake factory."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.processor = FakeProcessor()
+        self.called = []
+        self.watched_paths = []
+        self.ignored_paths = []
+
+
+class FakeTransport(object):
+    """A fake transport for the protocol."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.called = []
+
+    def loseConnection(self):
+        """"Lost the connection."""
+        self.called.append('loseConnection')
+
+
+class FakeProtocol(object):
+    """A fake protocol object to interact with the daemon."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.called = []
+        self.transport = FakeTransport()
+
+    def remove_user(self):
+        """Remove the user."""
+        self.called.append('remove_user')
+        return defer.succeed(None)
+
+    def remove_path(self, path):
+        """Remove a path."""
+        self.called.extend(['remove_path', path])
+        return defer.succeed(True)
+
+    def add_path(self, path):
+        """Add a path."""
+        self.called.extend(['add_path', path])
+
+class PyInotifyEventsFactoryTestCase(BaseTwistedTestCase):
+    """Test the factory used to receive events."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the diff tests."""
+        yield super(PyInotifyEventsFactoryTestCase, self).setUp()
+        self.processor = FakeProcessor()
+        self.factory = fsevents_daemon.PyInotifyEventsFactory(self.processor)
+
+    def test_path_interesting_not_watched_or_ignored(self):
+        """Test that we do know if the path is not interesting."""
+        path = u'/not/watched/path'
+        self.assertTrue(self.factory.path_is_not_interesting(path))
+
+    def test_path_interesting_watched_not_ignored(self):
+        """Test that we do not know if the path is not interesting."""
+        path = u'/watched/path'
+        self.factory.watched_paths.append(path)
+        self.assertFalse(self.factory.path_is_not_interesting(path))
+
+    def test_path_interesting_watched_but_ignored(self):
+        """Test that we do not know if the path is not interesting."""
+        path = u'/ignored/path'
+        self.factory.watched_paths.append(path)
+        self.factory.ignored_paths.append(path)
+        self.assertTrue(self.factory.path_is_not_interesting(path))
+
+    def test_path_interesting_not_watched_but_ignored(self):
+        """Test that we do not know if the path is not interesting."""
+        path = u'/ignored/path'
+        self.factory.ignored_paths.append(path)
+        self.assertTrue(self.factory.path_is_not_interesting(path))
+
+    def test_is_create_false_rename(self):
+        """Test if we do know when an event is a create."""
+        source_path = u'/other/watched/path'
+        destination_path = u'/watched/path'
+        source_head, _ = os.path.split(source_path)
+        destination_head, _ = os.path.split(destination_path)
+        self.factory.watched_paths.extend([source_head, destination_head])
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        self.assertFalse(self.factory.is_create(event))
+
+    def test_is_create_false_delete(self):
+        """Test if we do know when an event is a create."""
+        source_path = u'/watched/path'
+        destination_path = u'/not/watched/path'
+        source_head, _ = os.path.split(source_path)
+        self.factory.watched_paths.append(source_head)
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        self.assertFalse(self.factory.is_create(event))
+
+    def test_is_create_true(self):
+        """Test is we do know when an event is a create."""
+        source_path = u'/not/watched/path'
+        destination_path = u'/watched/path'
+        destination_head, _ = os.path.split(destination_path)
+        self.factory.watched_paths.append(destination_head)
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        self.assertTrue(self.factory.is_create(event))
+
+    def test_is_delete_false_rename(self):
+        """Test if we do know when an event is a delete."""
+        source_path = u'/other/watched/path'
+        destination_path = u'/watched/path'
+        source_head, _ = os.path.split(source_path)
+        destination_head, _ = os.path.split(destination_path)
+        self.factory.watched_paths.extend([source_head, destination_head])
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        self.assertFalse(self.factory.is_delete(event))
+
+    def test_is_delete_false_create(self):
+        """Test if we do know when an event is a delete."""
+        source_path = u'/not/watched/path'
+        destination_path = u'/watched/path'
+        destination_head, _ = os.path.split(destination_path)
+        self.factory.watched_paths.append(destination_head)
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        self.assertFalse(self.factory.is_delete(event))
+
+    def test_is_delete_true(self):
+        """Test if we do know when an event is a delete."""
+        source_path = u'/watched/path'
+        destination_path = u'/not/watched/path'
+        source_head, _ = os.path.split(source_path)
+        self.factory.watched_paths.append(source_head)
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        self.assertTrue(self.factory.is_delete(event))
+
+    def test_generate_from_event(self):
+        """Test the creation of a fake from event."""
+        cookie = 'cookie'
+        source_path = u'/source/path'
+        destination_path = u'/destination/path'
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        pyinotify_event = self.factory.generate_from_event(event, cookie)
+        self.assertEqual(cookie, pyinotify_event.cookie)
+        self.assertEqual(0, pyinotify_event.wd)
+        self.assertEqual(event.is_directory, pyinotify_event.dir)
+        self.assertEqual(IN_MOVED_FROM, pyinotify_event.mask)
+        self.assertEqual(source_path, pyinotify_event.pathname)
+
+    def test_generate_to_event(self):
+        """Test the creation of a fake to event."""
+        cookie = 'cookie'
+        source_path = u'/source/path'
+        destination_path = u'/destination/path'
+        event = FakeDaemonEvent()
+        event.event_paths.extend([source_path, destination_path])
+        pyinotify_event = self.factory.generate_to_event(event, cookie)
+        self.assertEqual(cookie, pyinotify_event.cookie)
+        self.assertEqual(0, pyinotify_event.wd)
+        self.assertEqual(event.is_directory, pyinotify_event.dir)
+        self.assertEqual(IN_MOVED_TO, pyinotify_event.mask)
+        self.assertEqual(destination_path, pyinotify_event.pathname)
+
+    def test_convert_in_pyinotify_event_no_rename(self):
+        """Test the creation of a no rename event."""
+        event_path = u'/path/of/the/event'
+        for action in fsevents_daemon.DARWIN_ACTIONS:
+            event = FakeDaemonEvent()
+            event.event_paths.append(event_path)
+            event.event_type = action
+            converted_events = self.factory.convert_in_pyinotify_event(event)
+            self.assertEqual(1, len(converted_events))
+            pyinotify_event = converted_events[0]
+            self.assertEqual(0, pyinotify_event.wd)
+            self.assertEqual(event.is_directory, pyinotify_event.dir)
+            self.assertEqual(fsevents_daemon.DARWIN_ACTIONS[action],
+                pyinotify_event.mask)
+            self.assertEqual(event_path, pyinotify_event.pathname)
+
+    def test_convert_in_pyinotify_event_rename_create(self):
+        """Test the creation of a rename which is a create."""
+        source_path = u'/not/watched/path'
+        destination_path = u'/watched/path'
+        head, _ = os.path.split(destination_path)
+        self.factory.watched_paths.append(head)
+        event = FakeDaemonEvent()
+        event.event_type = fsevents.FSE_RENAME
+        event.event_paths.extend([source_path, destination_path])
+        converted_events = self.factory.convert_in_pyinotify_event(event)
+        self.assertEqual(1, len(converted_events))
+        pyinotify_event = converted_events[0]
+        self.assertEqual(0, pyinotify_event.wd)
+        self.assertEqual(event.is_directory, pyinotify_event.dir)
+        self.assertEqual(IN_CREATE, pyinotify_event.mask)
+        self.assertEqual(destination_path, pyinotify_event.pathname)
+
+    def test_convert_in_pyinotify_event_rename_delete(self):
+        """Test the creation of a rename which is a delete."""
+        source_path = u'/watched/path'
+        destination_path = u'/not/watched/path'
+        head, _ = os.path.split(source_path)
+        self.factory.watched_paths.append(head)
+        event = FakeDaemonEvent()
+        event.event_type = fsevents.FSE_RENAME
+        event.event_paths.extend([source_path, destination_path])
+        converted_events = self.factory.convert_in_pyinotify_event(event)
+        self.assertEqual(1, len(converted_events))
+        pyinotify_event = converted_events[0]
+        self.assertEqual(0, pyinotify_event.wd)
+        self.assertEqual(event.is_directory, pyinotify_event.dir)
+        self.assertEqual(IN_DELETE, pyinotify_event.mask)
+        self.assertEqual(source_path, pyinotify_event.pathname)
+
+    def test_convert_in_pyinotify_event_rename(self):
+        """Test the creation of a rename event."""
+        source_path = u'/watched/path1'
+        destination_path = u'/watched/path2'
+        head, _ = os.path.split(source_path)
+        self.factory.watched_paths.append(head)
+        event = FakeDaemonEvent()
+        event.event_type = fsevents.FSE_RENAME
+        event.event_paths.extend([source_path, destination_path])
+        converted_events = self.factory.convert_in_pyinotify_event(event)
+        self.assertEqual(2, len(converted_events))
+        from_event = converted_events[0]
+        to_event = converted_events[1]
+        # assert from event
+        self.assertEqual(0, from_event.wd)
+        self.assertEqual(event.is_directory, from_event.dir)
+        self.assertEqual(IN_MOVED_FROM, from_event.mask)
+        self.assertEqual(source_path, from_event.pathname)
+        # assert to event
+        self.assertEqual(0, to_event.wd)
+        self.assertEqual(event.is_directory, to_event.dir)
+        self.assertEqual(IN_MOVED_TO, to_event.mask)
+        self.assertEqual(destination_path, to_event.pathname)
+        # assert cookie
+        self.assertEqual(from_event.cookie, to_event.cookie)
+
+    def test_process_event_ignored_type(self):
+        """Test processing the event of an ignored type."""
+        for action in fsevents_daemon.DARWIN_IGNORED_ACTIONS:
+            event = FakeDaemonEvent()
+            event.event_type = action
+            self.factory.process_event(event)
+        self.assertEqual(0, len(self.processor.processed_events))
+
+    def test_process_event_dropped(self):
+        """Test processing the drop of the events."""
+        func_called = []
+        event = FakeDaemonEvent()
+        event.event_type = fsevents.FSE_EVENTS_DROPPED
+
+        def fake_events_dropped():
+            """A fake events dropped implementation."""
+            func_called.append('fake_events_dropped')
+
+        self.patch(self.factory, 'events_dropper', fake_events_dropped)
+        self.factory.process_event(event)
+        self.assertIn('fake_events_dropped', func_called)
+
+    def test_process_ignored_path(self):
+        """Test processing events from an ignored path."""
+        event_path = u'/path/of/the/event'
+        head, _ = os.path.split(event_path)
+        self.factory.ignored_paths.append(head)
+        event = FakeDaemonEvent()
+        event.event_paths.append(event_path)
+        event.event_type = fsevents.FSE_CREATE_FILE
+        self.factory.process_event(event)
+        self.assertEqual(0, len(self.processor.processed_events))
+
+    def test_process_not_ignored_path(self):
+        """Test processing events that are not ignored."""
+        event_path = u'/path/of/the/event'
+        head, _ = os.path.split(event_path)
+        self.factory.watched_paths.append(head)
+        event = FakeDaemonEvent()
+        event.event_paths.append(event_path)
+        event.event_type = fsevents.FSE_CREATE_FILE
+        self.factory.process_event(event)
+        self.assertEqual(1, len(self.processor.processed_events))
+        self.assertEqual(event_path,
+                self.processor.processed_events[0].pathname)
+
+
+class FilesystemMonitorTestCase(BaseTwistedTestCase):
+    """Test the notify processor."""
+
+    def fake_connect_to_daemon(self):
+        """A fake connection to daemon call."""
+        self.monitor._protocol = self.protocol
+        defer.succeed(self.protocol)
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the tests."""
+        yield super(FilesystemMonitorTestCase, self).setUp()
+        self.patch(fsevents_daemon, 'NotifyProcessor', FakeProcessor)
+        self.factory = FakePyInotifyEventsFactory()
+        self.protocol = FakeProtocol()
+        self.monitor = fsevents_daemon.FilesystemMonitor(None, None)
+        self.processor = self.monitor._processor
+
+        # override default objects
+        self.monitor._factory = self.factory
+
+        # patch the connect
+        self.patch(fsevents_daemon.FilesystemMonitor, '_connect_to_daemon',
+                self.fake_connect_to_daemon)
+
+    @defer.inlineCallbacks
+    def test_shutdown_protocol(self):
+        """Test shutdown with a protocol."""
+        self.monitor._protocol = self.protocol
+        yield self.monitor.shutdown()
+        self.assertIn('remove_user', self.protocol.called)
+
+    @defer.inlineCallbacks
+    def test_shutdown_no_protocol(self):
+        """Test shutdown without a protocol."""
+        stopped = yield self.monitor.shutdown()
+        self.assertTrue(stopped)
+
+    @defer.inlineCallbacks
+    def test_rm_path_not_root(self):
+        """Test removing a path."""
+        dirpath = '/path/to/remove/'
+        self.factory.watched_paths.append('/path')
+        yield self.monitor.rm_watch(dirpath)
+        self.assertIn(dirpath, self.factory.ignored_paths)
+
+    @defer.inlineCallbacks
+    def test_rm_path_root(self):
+        """Test removing a path that is a root path."""
+        dirpath = '/path/to/remove/'
+        self.factory.watched_paths.append(dirpath)
+        yield self.monitor.rm_watch(dirpath)
+        self.assertIn('remove_path', self.protocol.called)
+        self.assertIn(dirpath, self.protocol.called)
+        self.assertNotIn(dirpath, self.factory.watched_paths)
+
+    @defer.inlineCallbacks
+    def test_add_watch_not_root(self):
+        """Test adding a watch."""
+        dirpath = '/path/to/remove/'
+        self.factory.watched_paths.append('/path')
+        yield self.monitor.add_watch(dirpath)
+        self.assertNotIn('add_path', self.protocol.called)
+
+    @defer.inlineCallbacks
+    def test_add_watch_root(self):
+        """Test adding a watch that is a root."""
+        dirpath = '/path/to/remove/'
+        self.factory.watched_paths.append('/other/path')
+        yield self.monitor.add_watch(dirpath)
+        self.assertIn('add_path', self.protocol.called)
+        self.assertIn(dirpath, self.protocol.called)
+
+    @defer.inlineCallbacks
+    def test_add_watch_ignored(self):
+        """Test adding a watch that was ignored."""
+        dirpath = '/path/to/remove/'
+        self.factory.ignored_paths.append(dirpath)
+        yield self.monitor.add_watch(dirpath)
+        self.assertNotIn('add_path', self.protocol.called)
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor_running(self):
+        """Test the method when it is indeed running."""
+        monitor_cls = fsevents_daemon.FilesystemMonitor
+
+        # start a fake server for the test
+        server = TidyUnixServer()
+        yield server.listen_server(FakeServerFactory)
+        self.addCleanup(server.clean_up)
+
+        # set the path
+        old_socket = fsevents_daemon.DAEMON_SOCKET
+        fsevents_daemon.DAEMON_SOCKET = server.path
+        self.addCleanup(setattr, fsevents_daemon, 'DAEMON_SOCKET', old_socket)
+
+        result = yield monitor_cls.is_available_monitor()
+        self.assertTrue(result)
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor_fail(self):
+        """Test the method when the daemon is not running."""
+        monitor_cls = fsevents_daemon.FilesystemMonitor
+        old_socket = fsevents_daemon.DAEMON_SOCKET
+        fsevents_daemon.DAEMON_SOCKET += 'test'
+        self.addCleanup(setattr, fsevents_daemon, 'DAEMON_SOCKET', old_socket)
+
+        result = yield monitor_cls.is_available_monitor()
+        self.assertFalse(result)

=== modified file 'tests/platform/filesystem_notifications/test_linux.py'
--- tests/platform/filesystem_notifications/test_linux.py	2012-06-14 18:22:16 +0000
+++ tests/platform/filesystem_notifications/test_linux.py	2012-07-31 17:27:22 +0000
@@ -37,8 +37,9 @@
 
 from contrib.testing import testcase
 from ubuntuone.syncdaemon import volume_manager
-from ubuntuone.platform.filesystem_notifications import (
-    linux as filesystem_notifications,
+from ubuntuone.platform.filesystem_notifications import notify_processor
+from ubuntuone.platform.filesystem_notifications.monitor import (
+    linux as filesystem_notifications
 )
 from tests.platform.filesystem_notifications import BaseFSMonitorTestCase
 
@@ -71,12 +72,12 @@
 
     def test_processor_shutdown_no_timer(self):
         """Shutdown the processor, no timer."""
-        processor = filesystem_notifications._GeneralINotifyProcessor('mntr')
+        processor = notify_processor.NotifyProcessor('mntr')
         processor.shutdown()
 
     def test_processor_shutdown_timer_inactive(self):
         """Shutdown the processor, timer inactive."""
-        processor = filesystem_notifications._GeneralINotifyProcessor('mntr')
+        processor = notify_processor.NotifyProcessor('mntr')
         d = defer.Deferred()
 
         def shutdown():
@@ -89,7 +90,7 @@
 
     def test_processor_shutdown_timer_active(self):
         """Shutdown the processor, timer going on."""
-        processor = filesystem_notifications._GeneralINotifyProcessor('mntr')
+        processor = notify_processor.NotifyProcessor('mntr')
         processor.timer = reactor.callLater(10, lambda: None)
         processor.shutdown()
         self.assertFalse(processor.timer.active())
@@ -390,6 +391,14 @@
         self.assertEqual(self.monitor._general_watchs, {})
         self.assertEqual(self.monitor._ancestors_watchs, {})
 
+    @defer.inlineCallbacks
+    def test_is_available_monitor(self):
+        """Test test the is_available_monitor method."""
+        # we should always return true
+        monitor_cls = filesystem_notifications.FilesystemMonitor
+        is_available = yield monitor_cls.is_available_monitor()
+        self.assertTrue(is_available, 'Should always be available.')
+
 
 class FakeEvent(object):
     """A fake event."""
@@ -405,7 +414,7 @@
         """When eCryptFS sends CLOSE_WRITE on folders, ignore it"""
         result = []
         monitor = None
-        processor = filesystem_notifications._GeneralINotifyProcessor(monitor)
+        processor = notify_processor.NotifyProcessor(monitor)
         self.patch(processor.general_processor, "push_event", result.append)
 
         fake_event = FakeEvent()
@@ -420,7 +429,7 @@
         """When anything sends CLOSE_WRITE on files, handle it."""
         result = []
         monitor = None
-        processor = filesystem_notifications._GeneralINotifyProcessor(monitor)
+        processor = notify_processor.NotifyProcessor(monitor)
         self.patch(processor.general_processor, "push_event", result.append)
 
         fake_event = FakeEvent()

=== modified file 'tests/platform/filesystem_notifications/test_windows.py'
--- tests/platform/filesystem_notifications/test_windows.py	2012-07-10 20:11:18 +0000
+++ tests/platform/filesystem_notifications/test_windows.py	2012-07-31 17:27:22 +0000
@@ -50,16 +50,16 @@
     IN_DELETE,
     IN_OPEN,
 )
-from ubuntuone.platform.filesystem_notifications import (
+from ubuntuone.platform.filesystem_notifications.monitor import (
     windows as filesystem_notifications,
 )
-from ubuntuone.platform.filesystem_notifications.common import (
+from ubuntuone.platform.filesystem_notifications import notify_processor
+from ubuntuone.platform.filesystem_notifications.monitor.common import (
     FilesystemMonitor,
-    NotifyProcessor,
     Watch,
     WatchManager,
 )
-from ubuntuone.platform.filesystem_notifications.windows import (
+from ubuntuone.platform.filesystem_notifications.monitor.windows import (
     ACTIONS,
     FILE_NOTIFY_CHANGE_FILE_NAME,
     FILE_NOTIFY_CHANGE_DIR_NAME,
@@ -1057,7 +1057,7 @@
     def setUp(self):
         """set up the diffeent tests."""
         yield super(TestNotifyProcessor, self).setUp()
-        self.processor = NotifyProcessor(None)
+        self.processor = notify_processor.NotifyProcessor(None)
         self.general = FakeGeneralProcessor()
         self.processor.general_processor = self.general
 
@@ -1087,9 +1087,10 @@
         """Test that we do indeed ignore the correct paths."""
         not_ignored = 'test'
         ignored = not_ignored + '.lnk'
-        self.assertFalse(filesystem_notifications.path_is_ignored(not_ignored),
+        path_is_ignored = notify_processor.common.path_is_ignored
+        self.assertFalse(path_is_ignored(not_ignored),
                          'Only links should be ignored.')
-        self.assertTrue(filesystem_notifications.path_is_ignored(ignored),
+        self.assertTrue(path_is_ignored(ignored),
                          'Links should be ignored.')
 
     def test_is_ignored(self):
@@ -1445,3 +1446,10 @@
         # lets ensure that we never added the watches
         self.assertEqual(0, len(monitor._watch_manager._wdm.values()),
                          'No watches should have been added.')
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor(self):
+        """Test test the is_available_monitor method."""
+        # we should always return true
+        is_available = yield FilesystemMonitor.is_available_monitor()
+        self.assertTrue(is_available, 'Should always be available.')

=== modified file 'tests/syncdaemon/test_config.py'
--- tests/syncdaemon/test_config.py	2012-07-17 18:36:13 +0000
+++ tests/syncdaemon/test_config.py	2012-07-31 17:27:22 +0000
@@ -700,6 +700,19 @@
         self.assertEquals(self.cp.get('__main__', 'ignore').value,
                           ['.*\\.pyc', '.*\\.sw[opnx]'])
 
+    def test_fs_monitor_not_default(self):
+        """Test get monitor."""
+        monitor_id = 'my_monitor'
+        conf_file = os.path.join(self.test_root, 'test_new_config.conf')
+        with open_file(conf_file, 'w') as fd:
+            fd.write('[__main__]\n')
+            fd.write('fs_monitor = %s\n' % monitor_id)
+        self.assertTrue(path_exists(conf_file))
+        self.cp.read([conf_file])
+        self.cp.parse_all()
+        self.assertEquals(self.cp.get('__main__', 'fs_monitor').value,
+                monitor_id)
+
     def test_use_trash_default(self):
         """Test default configuration for use_trash."""
         self.cp.parse_all()

=== modified file 'tests/syncdaemon/test_eventqueue.py'
--- tests/syncdaemon/test_eventqueue.py	2012-04-09 20:07:05 +0000
+++ tests/syncdaemon/test_eventqueue.py	2012-07-31 17:27:22 +0000
@@ -37,6 +37,7 @@
 from twisted.trial.unittest import TestCase
 
 from contrib.testing.testcase import BaseTwistedTestCase, FakeVolumeManager
+from ubuntuone.platform.filesystem_notifications.monitor import FilesystemMonitor
 from ubuntuone.syncdaemon import (
     event_queue,
     filesystem_manager,
@@ -406,6 +407,22 @@
         return self.shutdown_d
 
 
+class EventQueueInitTestCase(TestCase):
+    """Test the init of the EQ."""
+
+    def test_default_monitor(self):
+        """Test the init with the default monitor."""
+        eq = event_queue.EventQueue(None)
+        self.assertIsInstance(eq.monitor, FilesystemMonitor)
+        return eq.shutdown()
+
+    def test_passed_monitor(self):
+        """Test the init with a custom monitor."""
+        eq = event_queue.EventQueue(None, monitor_class=FakeMonitor)
+        self.assertIsInstance(eq.monitor, FakeMonitor)
+
+
+
 class EventQueueShutdownTestCase(TestCase):
     """Test the shutdown method in EQ."""
 

=== modified file 'ubuntuone/platform/filesystem_notifications/__init__.py'
--- ubuntuone/platform/filesystem_notifications/__init__.py	2012-07-10 20:11:18 +0000
+++ ubuntuone/platform/filesystem_notifications/__init__.py	2012-07-31 17:27:22 +0000
@@ -28,14 +28,8 @@
 # files in the program, then also delete it here.
 """File System Notification module."""
 
-import sys
-
-
-if sys.platform in ('darwin', 'win32'):
-    from ubuntuone.platform.filesystem_notifications import common
-    FilesystemMonitor = common.FilesystemMonitor
-    _GeneralINotifyProcessor = common.NotifyProcessor
-else:
-    from ubuntuone.platform.filesystem_notifications import linux
-    FilesystemMonitor = linux.FilesystemMonitor
-    _GeneralINotifyProcessor = linux._GeneralINotifyProcessor
+from ubuntuone.platform.filesystem_notifications import (
+    notify_processor,
+)
+
+_GeneralINotifyProcessor = notify_processor.NotifyProcessor

=== added directory 'ubuntuone/platform/filesystem_notifications/filesystem_monitor'
=== added file 'ubuntuone/platform/filesystem_notifications/filesystem_monitor/__init__.py'
=== added directory 'ubuntuone/platform/filesystem_notifications/monitor'
=== added file 'ubuntuone/platform/filesystem_notifications/monitor/__init__.py'
--- ubuntuone/platform/filesystem_notifications/monitor/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,95 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2011-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Filesystem monitors per platform."""
+
+import sys
+
+from twisted.internet import defer
+
+DEFAULT_MONITOR = 'default'
+
+
+class NoAvailableMonitorError(Exception):
+    """Raised if there are no available monitors in the system."""
+
+
+if sys.platform == 'win32':
+    from ubuntuone.platform.filesystem_notifications.monitor import (
+        common,
+    )
+
+    FILEMONITOR_IDS = {
+        DEFAULT_MONITOR: common.FilesystemMonitor,
+    }
+
+elif sys.platform == 'darwin':
+    from ubuntuone.platform.filesystem_notifications.monitor import darwin
+    from ubuntuone.platform.filesystem_notifications.monitor import (
+        common,
+    )
+
+    FILEMONITOR_IDS = {
+        DEFAULT_MONITOR: common.FilesystemMonitor,
+        'daemon': darwin.fsevents_daemon.FilesystemMonitor,
+    }
+else:
+    from ubuntuone.platform.filesystem_notifications.monitor import (
+        linux,
+    )
+
+    FILEMONITOR_IDS = {
+        DEFAULT_MONITOR: linux.FilesystemMonitor,
+    }
+
+# mantain old API
+FilesystemMonitor = FILEMONITOR_IDS[DEFAULT_MONITOR]
+
+
[e-mail]
+def get_filemonitor_class(monitor_id=None):
+    """Return the class to be used."""
+    if monitor_id is None:
+        # use default
+        monitor_id = 'default'
+
+    if monitor_id not in FILEMONITOR_IDS:
+        raise NoAvailableMonitorError(
+                'No available monitor with id "%s"could be found.' % monitor_id)
+
+    # retrieve the correct class and assert it can be used
+    cls = FILEMONITOR_IDS[monitor_id]
+    is_available = yield cls.is_available_monitor()
+
+    if is_available:
+        defer.returnValue(cls)
+    elif not is_available and monitor_id != DEFAULT_MONITOR:
+        cls = yield get_filemonitor_class(DEFAULT_MONITOR)
+        defer.returnValue(cls)
+    else:
+        raise NoAvailableMonitorError('No available monitor could be found.')

=== renamed file 'ubuntuone/platform/filesystem_notifications/common.py' => 'ubuntuone/platform/filesystem_notifications/monitor/common.py'
--- ubuntuone/platform/filesystem_notifications/common.py	2012-07-13 12:39:33 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/common.py	2012-07-31 17:27:22 +0000
@@ -34,15 +34,11 @@
 
 from twisted.internet import defer
 
+from ubuntuone.platform.filesystem_notifications import notify_processor
 from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
     Event,
     WatchManagerError,
-    ProcessEvent,
-    IN_OPEN,
-    IN_CLOSE_NOWRITE,
-    IN_CLOSE_WRITE,
     IN_CREATE,
-    IN_IGNORED,
     IN_ISDIR,
     IN_DELETE,
     IN_MOVED_FROM,
@@ -57,11 +53,14 @@
     os_path,
 )
 
+
 if sys.platform == 'darwin':
-    from ubuntuone.platform.filesystem_notifications import darwin
-    source = darwin
+    from ubuntuone.platform.filesystem_notifications.monitor.darwin import (
+        fsevents_client,
+    )
+    source = fsevents_client
 elif sys.platform == 'win32':
-    from ubuntuone.platform.filesystem_notifications import windows
+    from ubuntuone.platform.filesystem_notifications.monitor import windows
     source = windows
 else:
     raise ImportError('Not supported platform')
@@ -73,27 +72,10 @@
 # a map of the actions to names so that we have better logs.
 ACTIONS_NAMES = source.ACTIONS_NAMES
 
-# ignore paths in the platform, mainly links atm
-path_is_ignored = source.path_is_ignored
-
 # the base class to be use for a platform
 PlatformWatch = source.Watch
 PlatformWatchManager = source.WatchManager
 
-# translates quickly the event and it's is_dir state to our standard events
-NAME_TRANSLATIONS = {
-    IN_OPEN: 'FS_FILE_OPEN',
-    IN_CLOSE_NOWRITE: 'FS_FILE_CLOSE_NOWRITE',
-    IN_CLOSE_WRITE: 'FS_FILE_CLOSE_WRITE',
-    IN_CREATE: 'FS_FILE_CREATE',
-    IN_CREATE | IN_ISDIR: 'FS_DIR_CREATE',
-    IN_DELETE: 'FS_FILE_DELETE',
-    IN_DELETE | IN_ISDIR: 'FS_DIR_DELETE',
-    IN_MOVED_FROM: 'FS_FILE_DELETE',
-    IN_MOVED_FROM | IN_ISDIR: 'FS_DIR_DELETE',
-    IN_MOVED_TO: 'FS_FILE_CREATE',
-    IN_MOVED_TO | IN_ISDIR: 'FS_DIR_CREATE'}
-
 # our logging level
 TRACE = logger.TRACE
 
@@ -330,8 +312,8 @@
     @is_valid_os_path(path_indexes=[1])
     def get_wd(self, path):
         """Return the watcher that is used to watch the given path."""
-        if not path.endswith(os.path.sep):
-            path = path + os.path.sep
+        if not path[-1] == os.path.sep:
+            path += os.path.sep
         for current_wd in self._wdm:
             watch_path = self._wdm[current_wd].path
             if ((watch_path == path or watch_path in path)
@@ -378,207 +360,6 @@
         yield self.manager.stop()
 
 
-class NotifyProcessor(ProcessEvent):
-    """Processor that takes care of dealing with the events.
-
-    This interface will be exposed to syncdaemon, ergo all passed
-    and returned paths must be a sequence of BYTES encoded with utf8.
-    """
-
-    def __init__(self, monitor, ignore_config=None):
-        # XXX: avoid circular imports.
-        from ubuntuone.syncdaemon.filesystem_notifications import (
-            GeneralINotifyProcessor)
-        self.general_processor = GeneralINotifyProcessor(monitor,
-            self.handle_dir_delete, NAME_TRANSLATIONS,
-            path_is_ignored, IN_IGNORED, ignore_config=ignore_config)
-        self.held_event = None
-
-    def rm_from_mute_filter(self, event, paths):
-        """Remove event from the mute filter."""
-        self.general_processor.rm_from_mute_filter(event, paths)
-
-    def add_to_mute_filter(self, event, paths):
-        """Add an event and path(s) to the mute filter."""
-        self.general_processor.add_to_mute_filter(event, paths)
-
-    @is_valid_syncdaemon_path(path_indexes=[1])
-    def is_ignored(self, path):
-        """Should we ignore this path?"""
-        return self.general_processor.is_ignored(path)
-
-    def release_held_event(self, timed_out=False):
-        """Release the event on hold to fulfill its destiny."""
-        self.general_processor.push_event(self.held_event)
-        self.held_event = None
-
-    def process_IN_MODIFY(self, event):
-        """Capture a modify event and fake an open ^ close write events."""
-        # lets ignore dir changes
-        if event.dir:
-            return
-        # on someplatforms we just get IN_MODIFY, lets always fake
-        # an OPEN & CLOSE_WRITE couple
-        raw_open = raw_close = {
-           'wd': event.wd,
-           'dir': event.dir,
-           'name': event.name,
-           'path': event.path}
-        # caculate the open mask
-        raw_open['mask'] = IN_OPEN
-        # create the event using the raw data, then fix the pathname param
-        open_event = Event(raw_open)
-        open_event.pathname = event.pathname
-        # push the open
-        self.general_processor.push_event(open_event)
-        raw_close['mask'] = IN_CLOSE_WRITE
-        close_event = Event(raw_close)
-        close_event.pathname = event.pathname
-        # push the close event
-        self.general_processor.push_event(close_event)
-
-    def process_IN_MOVED_FROM(self, event):
-        """Capture the MOVED_FROM to maybe syntethize FILE_MOVED."""
-        if self.held_event is not None:
-            self.general_processor.log.warn('Lost pair event of %s',
-                                            self.held_event)
-        self.held_event = event
-
-    def _fake_create_event(self, event):
-        """Fake the creation of an event."""
-        # this is the case of a MOVE from an ignored path (links for example)
-        # to a valid path
-        if event.dir:
-            evtname = "FS_DIR_"
-        else:
-            evtname = "FS_FILE_"
-        self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
-        if not event.dir:
-            self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
-                                            path=event.pathname)
-
-    def _fake_delete_create_event(self, event):
-        """Fake the deletion and the creation."""
-        # this is the case of a MOVE from a watch UDF to a diff UDF which
-        # means that we have to copy the way linux works.
-        if event.dir:
-            evtname = "FS_DIR_"
-        else:
-            evtname = "FS_FILE_"
-        m = "Delete because of different shares: %r"
-        self.log.info(m, self.held_event.pathname)
-        self.general_processor.eq_push(evtname + "DELETE",
-                                       path=self.held_event.pathname)
-        self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
-        if not event.dir:
-            self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
-                                            path=event.pathname)
-
-    def process_IN_MOVED_TO(self, event):
-        """Capture the MOVED_TO to maybe syntethize FILE_MOVED."""
-        if self.held_event is not None:
-            if event.cookie == self.held_event.cookie:
-                f_path_dir = os.path.split(self.held_event.pathname)[0]
-                t_path_dir = os.path.split(event.pathname)[0]
-
-                is_from_forreal = not self.is_ignored(self.held_event.pathname)
-                is_to_forreal = not self.is_ignored(event.pathname)
-                if is_from_forreal and is_to_forreal:
-                    f_share_id = self.general_processor.get_path_share_id(
-                        f_path_dir)
-                    t_share_id = self.general_processor.get_path_share_id(
-                        t_path_dir)
-                    if f_share_id != t_share_id:
-                        # if the share_id are != push a delete/create
-                        self._fake_delete_create_event(event)
-                    else:
-                        if event.dir:
-                            evtname = "FS_DIR_"
-                        else:
-                            evtname = "FS_FILE_"
-                        self.general_processor.eq_push(evtname + "MOVE",
-                            path_from=self.held_event.pathname,
-                            path_to=event.pathname)
-                elif is_to_forreal:
-                    # this is the case of a MOVE from something ignored
-                    # to a valid filename
-                    self._fake_create_event(event)
-
-                self.held_event = None
-                return
-            else:
-                self.release_held_event()
-                self.general_processor.push_event(event)
-        else:
-            # We should never get here, I really do not know how we
-            # got here
-            self.general_processor.log.warn(
-                            'Cookie does not match the previoues held event!')
-            self.general_processor.log.warn('Ignoring %s', event)
-
-    def process_default(self, event):
-        """Push the event into the EventQueue."""
-        if self.held_event is not None:
-            self.release_held_event()
-        self.general_processor.push_event(event)
-
-    @is_valid_syncdaemon_path(path_indexes=[1])
-    def handle_dir_delete(self, fullpath):
-        """Some special work when a directory is deleted."""
-        # remove the watch on that dir from our structures, this mainly tells
-        # the monitor to remove the watch which is fowaded to a watch manager.
-        self.general_processor.rm_watch(fullpath)
-
-        # handle the case of move a dir to a non-watched directory
-        paths = self.general_processor.get_paths_starting_with(fullpath,
-            include_base=False)
-
-        paths.sort(reverse=True)
-        for path, is_dir in paths:
-            m = "Pushing deletion because of parent dir move: (is_dir=%s) %r"
-            self.general_processor.log.info(m, is_dir, path)
-            if is_dir:
-                # same as the above remove
-                self.general_processor.rm_watch(path)
-                self.general_processor.eq_push('FS_DIR_DELETE', path=path)
-            else:
-                self.general_processor.eq_push('FS_FILE_DELETE', path=path)
-
-    @is_valid_syncdaemon_path(path_indexes=[1])
-    def freeze_begin(self, path):
-        """Puts in hold all the events for this path."""
-        self.general_processor.freeze_begin(path)
-
-    def freeze_rollback(self):
-        """Unfreezes the frozen path, reseting to idle state."""
-        self.general_processor.freeze_rollback()
-
-    def freeze_commit(self, events):
-        """Unfreezes the frozen path, sending received events if not dirty.
-
-        If events for that path happened:
-            - return True
-        else:
-            - push the here received events, return False
-        """
-        return self.general_processor.freeze_commit(events)
-
-    @property
-    def mute_filter(self):
-        """Return the mute filter used by the processor."""
-        return self.general_processor.filter
-
-    @property
-    def frozen_path(self):
-        """Return the frozen path."""
-        return self.general_processor.frozen_path
-
-    @property
-    def log(self):
-        """Return the logger of the instance."""
-        return self.general_processor.log
-
-
 class FilesystemMonitor(object):
     """Manages the signals from filesystem."""
 
@@ -588,9 +369,15 @@
         self.log.setLevel(TRACE)
         self.fs = fs
         self.eq = eq
-        self._processor = NotifyProcessor(self, ignore_config)
+        self._processor = notify_processor.NotifyProcessor(self, ignore_config)
         self._watch_manager = WatchManager(self._processor)
 
+    @classmethod
+    def is_available_monitor(cls):
+        """Return if the monitor can be used in the platform."""
+        # we can always use this monitor
+        return defer.succeed(True)
+
     def add_to_mute_filter(self, event, **info):
         """Add info to mute filter in the processor."""
         self._processor.add_to_mute_filter(event, info)

=== added directory 'ubuntuone/platform/filesystem_notifications/monitor/darwin'
=== renamed file 'ubuntuone/platform/filesystem_notifications/darwin.py' => 'ubuntuone/platform/filesystem_notifications/monitor/darwin/__init__.py'
--- ubuntuone/platform/filesystem_notifications/darwin.py	2012-07-13 12:39:33 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/darwin/__init__.py	2012-07-31 17:27:22 +0000
@@ -28,132 +28,10 @@
 # files in the program, then also delete it here.
 """Filesystem Notifications module for MAC OS."""
 
-import os
-
-import fsevents
-from twisted.internet import defer, reactor
-
-from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
-    IN_DELETE,
-    IN_CREATE,
-    IN_MODIFY,
-    IN_MOVED_FROM,
-    IN_MOVED_TO,
+from ubuntuone.platform.filesystem_notifications.monitor.darwin import (
+    fsevents_daemon,
 )
 
-# a map between the few events that we have on common platforms and those
-# found in pyinotify
-ACTIONS = {
-    fsevents.IN_CREATE: IN_CREATE,
-    fsevents.IN_DELETE: IN_DELETE,
-    fsevents.IN_MODIFY: IN_MODIFY,
-    fsevents.IN_MOVED_FROM: IN_MOVED_FROM,
-    fsevents.IN_MOVED_TO: IN_MOVED_TO,
-}
-
-# a map of the actions to names so that we have better logs.
-ACTIONS_NAMES = {
-    fsevents.IN_CREATE: 'IN_CREATE',
-    fsevents.IN_DELETE: 'IN_DELETE',
-    fsevents.IN_MODIFY: 'IN_MODIFY',
-    fsevents.IN_MOVED_FROM: 'IN_MOVED_FROM',
-    fsevents.IN_MOVED_TO: 'IN_MOVED_TO',
-}
-
-
-def path_is_ignored(path):
-    """Should we ignore this path in the current platform.?"""
-    # don't support links yet
-    if os.path.islink(path):
-        return True
-    return False
-
-
-# The implementation of the code that is provided as the pyinotify substitute
-class Watch(object):
-    """Implement the same functions as pyinotify.Watch."""
-
-    def __init__(self, path, process_events):
-        """Create a new instance for the given path.
-
-        The process_events parameter is a callback to be executed in the main
-        reactor thread to convert events in pyinotify events and add them to
-        the state machine.
-        """
-        self.path = os.path.abspath(path)
-        self.process_events = process_events
-        self.watching = False
-        self.ignore_paths = []
-        # Create stream with folder to watch
-        self.stream = fsevents.Stream(self._process_events,
-            path, file_events=True)
-
-    def _process_events(self, event):
-        """Receive the filesystem event and move it to the main thread."""
-        reactor.callFromThread(self._process_events_in_main_thread, event)
-
-    def _process_events_in_main_thread(self, event):
-        """Process the events from the queue."""
-        action, cookie, file_name = (event.mask, event.cookie, event.name)
-
-        syncdaemon_path = os.path.join(self.path, file_name)
-        self.process_events(action, file_name, cookie,
-                syncdaemon_path)
-
-    def start_watching(self):
-        """Start watching."""
-        self.watching = True
-        return defer.succeed(self.watching)
-
-    def stop_watching(self):
-        """Stop watching."""
-        self.watching = False
-        return defer.succeed(self.watching)
-
-    # For API compatibility
-    @property
-    def started(self):
-        """A deferred that will be called when the watch is running."""
-        return defer.succeed(self.watching)
-
-    @property
-    def stopped(self):
-        """A deferred fired when the watch thread has finished."""
-        return defer.succeed(self.watching)
-
-
-class WatchManager(object):
-    """Implement the same functions as pyinotify.WatchManager.
-
-    All paths passed to methods in this class should be darwin paths.
-
-    """
-
-    def __init__(self, log):
-        """Init the manager to keep track of the different watches."""
-        self.log = log
-        self.observer = fsevents.Observer()
-        self.observer.start()
-
-    def stop_watch(self, watch):
-        """Stop a given watch."""
-        watch.stop_watching()
-        self.observer.unschedule(watch.platform_watch.stream)
-        return defer.succeed(True)
-
-    def stop(self):
-        """Stop the manager."""
-        self.observer.stop()
-        self.observer.join()
-
-    def del_watch(self, watch):
-        """Delete the watch and clean resources."""
-        self.observer.unschedule(watch.platform_watch.stream)
-
-    def add_watch(self, watch):
-        """This method perform actually the action of registering the watch."""
-        self.observer.schedule(watch.platform_watch.stream)
-        return True
-
-    def rm_watch(self, watch):
-        """Remove the the watch with the given wd."""
+
+FilesystemMonitor = fsevents_daemon.FilesystemMonitor
+NotifyProcessor = fsevents_daemon.NotifyProcessor

=== added file 'ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_client.py'
--- ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_client.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_client.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,151 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Filesystem Notifications module for MAC OS."""
+
+import os
+
+import fsevents
+from twisted.internet import defer, reactor
+
+from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
+    IN_DELETE,
+    IN_CREATE,
+    IN_MODIFY,
+    IN_MOVED_FROM,
+    IN_MOVED_TO,
+)
+
+# a map between the few events that we have on common platforms and those
+# found in pyinotify
+ACTIONS = {
+    fsevents.IN_CREATE: IN_CREATE,
+    fsevents.IN_DELETE: IN_DELETE,
+    fsevents.IN_MODIFY: IN_MODIFY,
+    fsevents.IN_MOVED_FROM: IN_MOVED_FROM,
+    fsevents.IN_MOVED_TO: IN_MOVED_TO,
+}
+
+# a map of the actions to names so that we have better logs.
+ACTIONS_NAMES = {
+    fsevents.IN_CREATE: 'IN_CREATE',
+    fsevents.IN_DELETE: 'IN_DELETE',
+    fsevents.IN_MODIFY: 'IN_MODIFY',
+    fsevents.IN_MOVED_FROM: 'IN_MOVED_FROM',
+    fsevents.IN_MOVED_TO: 'IN_MOVED_TO',
+}
+
+
+# The implementation of the code that is provided as the pyinotify substitute
+class Watch(object):
+    """Implement the same functions as pyinotify.Watch."""
+
+    def __init__(self, path, process_events):
+        """Create a new instance for the given path.
+
+        The process_events parameter is a callback to be executed in the main
+        reactor thread to convert events in pyinotify events and add them to
+        the state machine.
+        """
+        self.path = os.path.abspath(path)
+        self.process_events = process_events
+        self.watching = False
+        self.ignore_paths = []
+        # Create stream with folder to watch
+        self.stream = fsevents.Stream(self._process_events,
+            path, file_events=True)
+
+    def _process_events(self, event):
+        """Receive the filesystem event and move it to the main thread."""
+        reactor.callFromThread(self._process_events_in_main_thread, event)
+
+    def _process_events_in_main_thread(self, event):
+        """Process the events from the queue."""
+        action, cookie, file_name = (event.mask, event.cookie, event.name)
+
+        syncdaemon_path = os.path.join(self.path, file_name)
+        self.process_events(action, file_name, cookie,
+                syncdaemon_path)
+
+    def start_watching(self):
+        """Start watching."""
+        self.watching = True
+        return defer.succeed(self.watching)
+
+    def stop_watching(self):
+        """Stop watching."""
+        self.watching = False
+        return defer.succeed(self.watching)
+
+    # For API compatibility
+    @property
+    def started(self):
+        """A deferred that will be called when the watch is running."""
+        return defer.succeed(self.watching)
+
+    @property
+    def stopped(self):
+        """A deferred fired when the watch thread has finished."""
+        return defer.succeed(self.watching)
+
+
+class WatchManager(object):
+    """Implement the same functions as pyinotify.WatchManager.
+
+    All paths passed to methods in this class should be darwin paths.
+
+    """
+
+    def __init__(self, log):
+        """Init the manager to keep track of the different watches."""
+        self.log = log
+        self.observer = fsevents.Observer()
+        self.observer.start()
+
+    def stop_watch(self, watch):
+        """Stop a given watch."""
+        watch.stop_watching()
+        self.observer.unschedule(watch.platform_watch.stream)
+        return defer.succeed(True)
+
+    def stop(self):
+        """Stop the manager."""
+        self.observer.stop()
+        self.observer.join()
+
+    def del_watch(self, watch):
+        """Delete the watch and clean resources."""
+        self.observer.unschedule(watch.platform_watch.stream)
+
+    def add_watch(self, watch):
+        """This method perform actually the action of registering the watch."""
+        self.observer.schedule(watch.platform_watch.stream)
+        return True
+
+    def rm_watch(self, watch):
+        """Remove the the watch with the given wd."""

=== added file 'ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py'
--- ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,439 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Filesystem notifications based on the fsevents daemon.."""
+
+import logging
+import os
+import unicodedata
+
+from uuid import uuid4
+
+from twisted.internet import defer, endpoints, reactor
+
+from ubuntu_sso.utils.tcpactivation import (
+    ActivationConfig,
+    ActivationInstance,
+    AlreadyStartedError,
+)
+
+from ubuntuone import logger
+from ubuntuone.darwin import fsevents
+from ubuntuone.platform.filesystem_notifications.notify_processor import (
+    NotifyProcessor,
+)
+from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
+    Event,
+    IN_OPEN,
+    IN_CLOSE_NOWRITE,
+    IN_CLOSE_WRITE,
+    IN_CREATE,
+    IN_ISDIR,
+    IN_DELETE,
+    IN_MOVED_FROM,
+    IN_MOVED_TO,
+    IN_MODIFY,
+)
+
+TRACE = logger.TRACE
+
+# map the fsevents actions to those from pyinotify
+DARWIN_ACTIONS = {
+    fsevents.FSE_CREATE_FILE: IN_CREATE,
+    fsevents.FSE_DELETE: IN_DELETE,
+    fsevents.FSE_STAT_CHANGED: IN_MODIFY,
+    fsevents.FSE_CONTENT_MODIFIED: IN_MODIFY,
+    fsevents.FSE_CREATE_DIR: IN_CREATE,
+}
+
+# list of those events from which we do not care
+DARWIN_IGNORED_ACTIONS = (
+    fsevents.FSE_UNKNOWN,
+    fsevents.FSE_INVALID,
+    fsevents.FSE_EXCHANGE,
+    fsevents.FSE_FINDER_INFO_CHANGED,
+    fsevents.FSE_CHOWN,
+    fsevents.FSE_XATTR_MODIFIED,
+    fsevents.FSE_XATTR_REMOVED,
+)
+
+# translates quickly the event and it's is_dir state to our standard events
+NAME_TRANSLATIONS = {
+    IN_OPEN: 'FS_FILE_OPEN',
+    IN_CLOSE_NOWRITE: 'FS_FILE_CLOSE_NOWRITE',
+    IN_CLOSE_WRITE: 'FS_FILE_CLOSE_WRITE',
+    IN_CREATE: 'FS_FILE_CREATE',
+    IN_CREATE | IN_ISDIR: 'FS_DIR_CREATE',
+    IN_DELETE: 'FS_FILE_DELETE',
+    IN_DELETE | IN_ISDIR: 'FS_DIR_DELETE',
+    IN_MOVED_FROM: 'FS_FILE_DELETE',
+    IN_MOVED_FROM | IN_ISDIR: 'FS_DIR_DELETE',
+    IN_MOVED_TO: 'FS_FILE_CREATE',
+    IN_MOVED_TO | IN_ISDIR: 'FS_DIR_CREATE'}
+
+# TODO: This should be in fsevents to be imported!
+# Path to the socket used by the daemon
+DAEMON_SOCKET = '/var/run/ubuntuone_fsevents_daemon'
+
+
+class DescriptionFactory(object):
+    """Factory that provides the server and client descriptions."""
+
+    client_description_pattern = 'unix:path=%s'
+    server_description_pattern = 'unix:%s'
+
+    def __init__(self):
+        """Create a new instance."""
+        self.server = self.server_description_pattern % DAEMON_SOCKET
+        self.client = self.client_description_pattern % DAEMON_SOCKET
+
+
+def get_activation_config():
+    """Get the configuration to activate the sso service."""
+    description = DescriptionFactory()
+    return ActivationConfig(None, None, description)
+
+
[e-mail]
+def is_daemon_running():
+    """Return if the sd is running by trying to get the port."""
+    ai = ActivationInstance(get_activation_config())
+    try:
+        yield ai.get_server_description()
+        defer.returnValue(False)
+    except AlreadyStartedError:
+        defer.returnValue(True)
+
+
+def get_syncdaemon_valid_path(path):
+    """Return a valid encoded path."""
+    return unicodedata.normalize('NFC', path).encode('utf-8')
+
+
+class PyInotifyEventsFactory(fsevents.FsEventsFactory):
+    """Factory that process events and converts them in pyinotify ones."""
+
+    def __init__(self, processor,
+            ignored_events=DARWIN_IGNORED_ACTIONS):
+        """Create a new instance."""
+        # old style class
+        fsevents.FsEventsFactory.__init__(self)
+        self._processor = processor
+        self._ignored_events = ignored_events
+        self.watched_paths = []
+        self.ignored_paths = []
+
+    def events_dropper(self):
+        """Deal with the fact that the daemon dropped events."""
+
+    def path_is_not_interesting(self, path):
+        """Return if the factory is interested in the path."""
+        is_watched = any(path.startswith(watched_path)
+                             for watched_path in self.watched_paths)
+        is_ignored = any(path.startswith(ignored_path)
+                             for ignored_path in self.ignored_paths)
+        return not is_watched or (is_watched and is_ignored)
+
+    def is_create(self, event):
+        """Decide if a rename event should be considered a create."""
+        # is a create if the creation path (first path) is either not watched or
+        # in the ignored paths
+        source_path = get_syncdaemon_valid_path(event.event_paths[0])
+        return self.path_is_not_interesting(source_path)
+
+    def is_delete(self, event):
+        """Decide if a rename event should be considered a delete."""
+        # is a delete if the destination path (second path) is either not
+        # watched or in the ignored paths
+        dest_path = get_syncdaemon_valid_path(event.event_paths[1])
+        return self.path_is_not_interesting(dest_path)
+
+    def generate_from_event(self, event, cookie):
+        """Return a fake from event from a rename one."""
+        source_path = get_syncdaemon_valid_path(event.event_paths[0])
+        mask = IN_MOVED_FROM
+        if event.is_directory:
+            mask |= IN_ISDIR
+        head, tail = os.path.split(source_path)
+        event_raw_data = {
+            'wd': 0,  # we only have one factory
+            'dir': event.is_directory,
+            'mask': mask,
+            'name': tail,
+            'cookie': cookie,
+            'path': '.'}
+        move_from_event = Event(event_raw_data)
+        move_from_event.pathname = source_path
+        return move_from_event
+
+    def generate_to_event(self, event, cookie):
+        """Return a fake to event from a rename one."""
+        source_path = get_syncdaemon_valid_path(event.event_paths[0])
+        destination_path = get_syncdaemon_valid_path(event.event_paths[1])
+        mask = IN_MOVED_TO
+        if event.is_directory:
+            mask |= IN_ISDIR
+        source_head, source_tail = os.path.split(source_path)
+        head, tail = os.path.split(destination_path)
+        event_raw_data = {
+            'wd': 0,  # we only have one factory
+            'dir': event.is_directory,
+            'mask': mask,
+            'name': tail,
+            'cookie': cookie,
+            'src_pathname' : source_tail,
+            'path': '.'}
+        move_to_event = Event(event_raw_data)
+        move_to_event.pathname = destination_path
+        return move_to_event
+
+    def convert_in_pyinotify_event(self, event):
+        """Get an event from the daemon and convert it in a pyinotify one."""
+        # the rename is a special type of event because it has to be either
+        # converted is a pair of events or in a single one (CREATE or DELETE)
+        if event.event_type == fsevents.FSE_RENAME:
+            is_create = self.is_create(event)
+            if is_create or self.is_delete(event):
+                mask = IN_CREATE if is_create else IN_DELETE
+                if event.is_directory:
+                    mask |= IN_ISDIR
+                # a create means that we moved from a not watched path to a
+                # watched one and therefore we are interested in the SECOND
+                # path of the event. A delete means that we moved from a
+                # watched path for a not watched one and we care about the
+                # FIRST path of the event
+                path = event.event_paths[1] if is_create\
+                            else event.event_paths[0]
+                path = get_syncdaemon_valid_path(path)
+                head, tail = os.path.split(path)
+                event_raw_data = {
+                    'wd': 0,  # we only have one factory
+                    'dir': event.is_directory,
+                    'mask': mask,
+                    'name': tail,
+                    'path': '.'}
+                pyinotify_event = Event(event_raw_data)
+                pyinotify_event.pathname = path
+                return [pyinotify_event]
+            else:
+                # we do have a rename within watched paths lets generate to
+                # fake events
+                cookie = str(uuid4())
+                return [self.generate_from_event(event, cookie),
+                        self.generate_to_event(event, cookie)]
+        else:
+            mask = DARWIN_ACTIONS[event.event_type]
+            if event.is_directory:
+                mask |= IN_ISDIR
+            # we do know that we are not dealing with a move which are the only
+            # events that have more than one path
+            path = get_syncdaemon_valid_path(event.event_paths[0])
+            head, tail = os.path.split(path)
+            event_raw_data = {
+                'wd': 0,  # we only have one factory
+                'dir': event.is_directory,
+                'mask': mask,
+                'name': tail,
+                'path': '.'}
+            pyinotify_event = Event(event_raw_data)
+            # FIXME: event deduces the pathname wrong and we need to manually
+            # set it
+            pyinotify_event.pathname = path
+            return [pyinotify_event]
+
+    def _is_ignored_path(self, path):
+        """Returns if the path is ignored."""
+        if not path[-1] == os.path.sep:
+            path += os.path.sep
+
+        is_ignored_child = any(ignored in path for ignored in self.ignored_paths)
+        return path in self.ignored_paths or is_ignored_child
+
+    def process_event(self, event):
+        """Process an event from the fsevent daemon."""
+        if event.event_type in self._ignored_events:
+            # Do nothing because sd does not care about such info
+            return
+        if event.event_type == fsevents.FSE_EVENTS_DROPPED:
+            # this should not be very common but we have to deal with it
+            return self.events_dropper()
+        events = self.convert_in_pyinotify_event(event)
+        for pyinotify_event in events:
+            # assert that the path name is valid
+            if not any([pyinotify_event.pathname.startswith(path)
+                        for path in self.ignored_paths]):
+                # by definition we are being callFromThread so we do know that
+                # the  events are executed in the right order \o/
+                if not self._is_ignored_path(pyinotify_event.pathname):
+                    self._processor(pyinotify_event)
+
+
+class FilesystemMonitor(object):
+    """Implementation that allows to receive events from the system."""
+
+    def __init__(self, eq, fs, ignore_config=None, timeout=1):
+        self.log = logging.getLogger('ubuntuone.SyncDaemon.FSMonitor')
+        self.log.setLevel(TRACE)
+        self._processor = NotifyProcessor(self, ignore_config)
+        self.fs = fs
+        self.eq = eq
+        self._factory = PyInotifyEventsFactory(self._processor)
+        self._protocol = None
+
+    @classmethod
+    def is_available_monitor(cls):
+        """Return if the monitor can be used in the platform."""
+        # can only be used if the daemon is running
+        return is_daemon_running()
+
+    @defer.inlineCallbacks
+    def _connect_to_daemon(self):
+        """Connect to the daemon so that we can receive events."""
+        description = 'unix:path=%s' % DAEMON_SOCKET
+        client = endpoints.clientFromString(reactor, description)
+        self._protocol = yield client.connect(self._factory)
+        # add the user with no paths
+        yield self._protocol.add_user([])
+
+    def add_to_mute_filter(self, event, **info):
+        """Add info to mute filter in the processor."""
+        self._processor.add_to_mute_filter(event, info)
+
+    def rm_from_mute_filter(self, event, **info):
+        """Remove info to mute filter in the processor."""
+        self._processor.rm_from_mute_filter(event, info)
+
+    def shutdown(self):
+        """Prepares the EQ to be closed."""
+        if self._protocol is not None:
+
+            def on_user_removed(data):
+                """We managed to remove the user."""
+                self._protocol.transport.loseConnection()
+                self._protocol = None
+                return True
+
+            def on_user_not_removed(reason):
+                """We did not manage to remove the user."""
+                return True
+
+            d = self._protocol.remove_user()
+            d.addCallback(on_user_removed)
+            d.addErrback(on_user_not_removed)
+            return d
+        return defer.succeed(True)
+
+    @defer.inlineCallbacks
+    def rm_watch(self, dirpath):
+        """Remove watch from a dir."""
+        # in mac os x we are only watching the parent watches, this is an
+        # important details because we will only send a real remove_path to the
+        # daemon if the path is the parent path else we will filter it in the
+        # factory level
+
+        if not dirpath[-1] == os.path.sep:
+            dirpath += os.path.sep
+
+        if dirpath not in self._factory.watched_paths:
+            # we are watching a parent path but we are not a root one
+            # therefore we are going to add it as an ignored path and
+            # return
+            self._factory.ignored_paths.append(dirpath)
+            defer.returnValue(None)
+
+        # if we got to this point we want to remove a root dir, this is an
+        # important detail to take care of. Connect if needed and tell the
+        # daemon to remove the path
+        if self._protocol is None:
+            # we have not yet connected, lets do it!
+            yield self._connect_to_daemon()
+        was_removed = yield self._protocol.remove_path(dirpath)
+        # only remove it if we really removed it
+        if was_removed:
+            self._factory.watched_paths.remove(dirpath)
+
+    @defer.inlineCallbacks
+    def add_watch(self, dirpath):
+        """Add watch to a dir."""
+        if not dirpath[-1] == os.path.sep:
+            dirpath = dirpath + os.path.sep
+
+        # if we are watching a parent dir we can just ensure that it is not ignored
+        if any(dirpath.startswith(watched_path) for watched_path in
+                self._factory.watched_paths):
+            if dirpath in self._factory.ignored_paths:
+                self._factory.ignored_paths.remove(dirpath)
+            defer.returnValue(True)
+
+        if dirpath in self._factory.ignored_paths:
+            self._factory.ignored_paths.remove(dirpath)
+            defer.returnValue(True)
+
+        if self._protocol is None:
+            # we have not yet connected, lets do it!
+            yield self._connect_to_daemon()
+
+        was_added = yield self._protocol.add_path(dirpath)
+        if was_added:
+            self._factory.watched_paths.append(dirpath)
+            defer.returnValue(True)
+
+    def add_watches_to_udf_ancestors(self, volume):
+        """Add a inotify watch to volume's ancestors if it's an UDF."""
+        # On Mac OS X we do no need to add watches to the ancestors because we
+        # will get the events from them with no problem.
+        return defer.succeed(True)
+
+    def is_frozen(self):
+        """Checks if there's something frozen."""
+        return self._processor.frozen_path is not None
+
+    def freeze_begin(self, path):
+        """Puts in hold all the events for this path."""
+        if self._processor.frozen_path is not None:
+            raise ValueError("There's something already frozen!")
+        self._processor.freeze_begin(path)
+
+    def freeze_rollback(self):
+        """Unfreezes the frozen path, reseting to idle state."""
+        if self._processor.frozen_path is None:
+            raise ValueError("Rolling back with nothing frozen!")
+        self._processor.freeze_rollback()
+
+    def freeze_commit(self, events):
+        """Unfreezes the frozen path, sending received events if not dirty.
+
+        If events for that path happened:
+            - return True
+        else:
+            - push the here received events, return False
+        """
+        if self._processor.frozen_path is None:
+            raise ValueError("Committing with nothing frozen!")
+
+        d = defer.execute(self._processor.freeze_commit, events)
+        return d

=== renamed file 'ubuntuone/platform/filesystem_notifications/linux.py' => 'ubuntuone/platform/filesystem_notifications/monitor/linux.py'
--- ubuntuone/platform/filesystem_notifications/linux.py	2012-05-23 13:06:42 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/linux.py	2012-07-31 17:27:22 +0000
@@ -33,8 +33,10 @@
 import os
 
 import pyinotify
-from twisted.internet import abstract, reactor, error, defer
+from twisted.internet import abstract, reactor,  defer
+
 from ubuntuone.platform.os_helper import access
+from ubuntuone.platform.filesystem_notifications import notify_processor
 
 
 # translates quickly the event and it's is_dir state to our standard events
@@ -69,24 +71,6 @@
     pyinotify.IN_MOVE_SELF)
 
 
-def validate_filename(real_func):
-    """Decorator that validates the filename."""
-    def func(self, event):
-        """If valid, executes original function."""
-        try:
-            # validate UTF-8
-            event.name.decode("utf8")
-        except UnicodeDecodeError:
-            dirname = event.path.decode("utf8")
-            self.general_processor.invnames_log.info("%s in %r: path %r",
-                event.maskname, dirname, event.name)
-            self.general_processor.monitor.eq.push('FS_INVALID_NAME',
-                                 dirname=dirname, filename=event.name)
-        else:
-            real_func(self, event)
-    return func
-
-
 class _AncestorsINotifyProcessor(pyinotify.ProcessEvent):
     """inotify's processor when an event happens on an UDFs ancestor."""
     def __init__(self, monitor):
@@ -153,244 +137,6 @@
             self.monitor.rm_watch(ancestor)
 
 
-class _GeneralINotifyProcessor(pyinotify.ProcessEvent):
-    """inotify's processor when a general event happens.
-
-    This class also catchs the MOVEs events, and synthetises a new
-    FS_(DIR|FILE)_MOVE event when possible.
-    """
-    def __init__(self, monitor, ignore_config=None):
-        # XXX: avoid circular imports
-        from ubuntuone.syncdaemon.filesystem_notifications import (
-            GeneralINotifyProcessor,
-        )
-        self.general_processor = GeneralINotifyProcessor(monitor,
-            self.handle_dir_delete, NAME_TRANSLATIONS,
-            self.platform_is_ignored, pyinotify.IN_IGNORED,
-            ignore_config=ignore_config)
-        self.held_event = None
-        self.timer = None
-
-    def shutdown(self):
-        """Shut down the processor."""
-        if self.timer is not None and self.timer.active():
-            self.timer.cancel()
-
-    def rm_from_mute_filter(self, event, paths):
-        """Remove an event and path(s) from the mute filter."""
-        self.general_processor.rm_from_mute_filter(event, paths)
-
-    def add_to_mute_filter(self, event, paths):
-        """Add an event and path(s) to the mute filter."""
-        self.general_processor.add_to_mute_filter(event, paths)
-
-    def on_timeout(self):
-        """Called on timeout."""
-        if self.held_event is not None:
-            self.release_held_event(True)
-
-    def release_held_event(self, timed_out=False):
-        """Release the event on hold to fulfill its destiny."""
-        if not timed_out:
-            try:
-                self.timer.cancel()
-            except error.AlreadyCalled:
-                # self.timeout() was *just* called, do nothing here
-                return
-        self.general_processor.push_event(self.held_event)
-        self.held_event = None
-
-    @validate_filename
-    def process_IN_OPEN(self, event):
-        """Filter IN_OPEN to make it happen only in files."""
-        if not (event.mask & pyinotify.IN_ISDIR):
-            self.general_processor.push_event(event)
-
-    @validate_filename
-    def process_IN_CLOSE_NOWRITE(self, event):
-        """Filter IN_CLOSE_NOWRITE to make it happen only in files."""
-        if not (event.mask & pyinotify.IN_ISDIR):
-            self.general_processor.push_event(event)
-
-    @validate_filename
-    def process_IN_CLOSE_WRITE(self, event):
-        """Filter IN_CLOSE_WRITE to make it happen only in files.
-
-        eCryptFS sends IN_CLOSE_WRITE event for lower directories.
-
-        """
-        if not (event.mask & pyinotify.IN_ISDIR):
-            self.general_processor.push_event(event)
-
-    def process_IN_MOVE_SELF(self, event):
-        """Don't do anything here.
-
-        We just turned this event on because pyinotify does some
-        path-fixing in its internal processing when this happens.
-
-        """
-
-    @validate_filename
-    def process_IN_MOVED_FROM(self, event):
-        """Capture the MOVED_FROM to maybe syntethize FILE_MOVED."""
-        if self.held_event is not None:
-            self.release_held_event()
-
-        self.held_event = event
-        self.timer = reactor.callLater(1, self.on_timeout)
-
-    def platform_is_ignored(self, path):
-        """Should we ignore this path in the current platform.?"""
-        # don't support links yet
-        if os.path.islink(path):
-            return True
-        return False
-
-    def is_ignored(self, path):
-        """Should we ignore this path?"""
-        return self.general_processor.is_ignored(path)
-
-    @validate_filename
-    def process_IN_MOVED_TO(self, event):
-        """Capture the MOVED_TO to maybe syntethize FILE_MOVED."""
-        if self.held_event is not None:
-            if event.cookie == self.held_event.cookie:
-                try:
-                    self.timer.cancel()
-                except error.AlreadyCalled:
-                    # self.timeout() was *just* called, do nothing here
-                    pass
-                else:
-                    f_path_dir = self.held_event.path
-                    f_path = os.path.join(f_path_dir, self.held_event.name)
-                    t_path_dir = event.path
-                    t_path = os.path.join(t_path_dir, event.name)
-
-                    is_from_forreal = not self.is_ignored(f_path)
-                    is_to_forreal = not self.is_ignored(t_path)
-                    if is_from_forreal and is_to_forreal:
-                        f_share_id = self.general_processor.get_path_share_id(
-                            f_path_dir)
-                        t_share_id = self.general_processor.get_path_share_id(
-                            t_path_dir)
-                        if event.dir:
-                            evtname = "FS_DIR_"
-                        else:
-                            evtname = "FS_FILE_"
-                        if f_share_id != t_share_id:
-                            # if the share_id are != push a delete/create
-                            m = "Delete because of different shares: %r"
-                            self.general_processor.log.info(m, f_path)
-                            self.general_processor.eq_push(evtname + "DELETE",
-                                                           path=f_path)
-                            self.general_processor.eq_push(evtname + "CREATE",
-                                                           path=t_path)
-                            if not event.dir:
-                                self.general_processor.eq_push(
-                                            'FS_FILE_CLOSE_WRITE', path=t_path)
-                        else:
-                            self.general_processor.monitor.inotify_watch_fix(
-                                                                f_path, t_path)
-                            self.general_processor.eq_push(evtname + "MOVE",
-                                         path_from=f_path, path_to=t_path)
-                    elif is_to_forreal:
-                        # this is the case of a MOVE from something ignored
-                        # to a valid filename
-                        if event.dir:
-                            evtname = "FS_DIR_"
-                        else:
-                            evtname = "FS_FILE_"
-                        self.general_processor.eq_push(evtname + "CREATE",
-                                                       path=t_path)
-                        if not event.dir:
-                            self.general_processor.eq_push(
-                                            'FS_FILE_CLOSE_WRITE', path=t_path)
-
-                    else:
-                        # this is the case of a MOVE from something valid
-                        # to an ignored filename
-                        if event.dir:
-                            evtname = "FS_DIR_"
-                        else:
-                            evtname = "FS_FILE_"
-                        self.general_processor.eq_push(evtname + "DELETE",
-                                                       path=f_path)
-
-                    self.held_event = None
-                return
-            else:
-                self.release_held_event()
-                self.general_processor.push_event(event)
-        else:
-            # we don't have a held_event so this is a move from outside.
-            # if it's a file move it's atomic on POSIX, so we aren't going to
-            # receive a IN_CLOSE_WRITE, so let's fake it for files
-            self.general_processor.push_event(event)
-            if not event.dir:
-                t_path = os.path.join(event.path, event.name)
-                self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
-                    path=t_path)
-
-    @validate_filename
-    def process_default(self, event):
-        """Push the event into the EventQueue."""
-        if self.held_event is not None:
-            self.release_held_event()
-        self.general_processor.push_event(event)
-
-    def freeze_begin(self, path):
-        """Puts in hold all the events for this path."""
-        self.general_processor.freeze_begin(path)
-
-    def freeze_rollback(self):
-        """Unfreezes the frozen path, reseting to idle state."""
-        self.general_processor.freeze_rollback()
-
-    def freeze_commit(self, events):
-        """Unfreezes the frozen path, sending received events if not dirty.
-
-        If events for that path happened:
-            - return True
-        else:
-            - push the here received events, return False
-        """
-        return self.general_processor.freeze_commit(events)
-
-    def handle_dir_delete(self, fullpath):
-        """Some special work when a directory is deleted."""
-        # remove the watch on that dir from our structures
-        self.general_processor.rm_watch(fullpath)
-
-        # handle the case of move a dir to a non-watched directory
-        paths = self.general_processor.get_paths_starting_with(fullpath,
-            include_base=False)
-
-        paths.sort(reverse=True)
-        for path, is_dir in paths:
-            m = "Pushing deletion because of parent dir move: (is_dir=%s) %r"
-            self.general_processor.log.info(m, is_dir, path)
-            if is_dir:
-                self.general_processor.rm_watch(path)
-                self.general_processor.eq_push('FS_DIR_DELETE', path=path)
-            else:
-                self.general_processor.eq_push('FS_FILE_DELETE', path=path)
-
-    @property
-    def mute_filter(self):
-        """Return the mute filter used by the processor."""
-        return self.general_processor.filter
-
-    @property
-    def frozen_path(self):
-        """Return the frozen path."""
-        return self.general_processor.frozen_path
-
-    @property
-    def log(self):
-        """Return the logger of the instance."""
-        return self.general_processor.log
-
-
 class FilesystemMonitor(object):
     """Manages the signals from filesystem."""
 
@@ -401,7 +147,7 @@
 
         # general inotify
         self._inotify_general_wm = wm = pyinotify.WatchManager()
-        self._processor = _GeneralINotifyProcessor(self, ignore_config)
+        self._processor = notify_processor.NotifyProcessor(self, ignore_config)
         self._inotify_notifier_gral = pyinotify.Notifier(wm, self._processor)
         self._inotify_reader_gral = self._hook_inotify_to_twisted(
                                             wm, self._inotify_notifier_gral)
@@ -415,6 +161,12 @@
                                             wm, self._inotify_notifier_antr)
         self._ancestors_watchs = {}
 
+    @classmethod
+    def is_available_monitor(cls):
+        """Return if the monitor can be used in the platform."""
+        # we can always use this monitor
+        return defer.succeed(True)
+
     def add_to_mute_filter(self, event, **info):
         """Add info to mute filter in the processor."""
         self._processor.add_to_mute_filter(event, info)

=== renamed file 'ubuntuone/platform/filesystem_notifications/windows.py' => 'ubuntuone/platform/filesystem_notifications/monitor/windows.py'
--- ubuntuone/platform/filesystem_notifications/windows.py	2012-07-13 12:39:33 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/windows.py	2012-07-31 17:27:22 +0000
@@ -64,7 +64,6 @@
     WAIT_OBJECT_0)
 
 from ubuntuone.platform.os_helper.windows import (
-    is_valid_syncdaemon_path,
     get_syncdaemon_valid_path,
 )
 
@@ -113,15 +112,6 @@
     FILE_NOTIFY_CHANGE_LAST_ACCESS
 
 
-@is_valid_syncdaemon_path()
-def path_is_ignored(path):
-    """Should we ignore this path in the current platform.?"""
-    # don't support links yet
-    if path.endswith('.lnk'):
-        return True
-    return False
-
-
 class Watch(object):
     """Implement the same functions as pyinotify.Watch."""
 

=== added directory 'ubuntuone/platform/filesystem_notifications/notify_processor'
=== added file 'ubuntuone/platform/filesystem_notifications/notify_processor/__init__.py'
--- ubuntuone/platform/filesystem_notifications/notify_processor/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/filesystem_notifications/notify_processor/__init__.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here
+"""Notify processor diff implementations per platform."""
+
+import sys
+
+if sys.platform in ('win32', 'darwin'):
+    from ubuntuone.platform.filesystem_notifications.notify_processor import (
+        common,
+    )
+    # workaround due to pyflakes :(
+    source = common
+else:
+    from ubuntuone.platform.filesystem_notifications.notify_processor import (
+        linux,
+    )
+    # workaround due to pyflakes :(
+    source = linux
+
+NotifyProcessor = source.NotifyProcessor

=== added file 'ubuntuone/platform/filesystem_notifications/notify_processor/common.py'
--- ubuntuone/platform/filesystem_notifications/notify_processor/common.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/filesystem_notifications/notify_processor/common.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,289 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2011-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Win and darwin implementation."""
+
+import os
+import sys
+
+from ubuntuone.syncdaemon.filesystem_notifications import (
+    GeneralINotifyProcessor,
+)
+from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
+    Event,
+    ProcessEvent,
+    IN_OPEN,
+    IN_CLOSE_NOWRITE,
+    IN_CLOSE_WRITE,
+    IN_CREATE,
+    IN_IGNORED,
+    IN_ISDIR,
+    IN_DELETE,
+    IN_MOVED_FROM,
+    IN_MOVED_TO,
+)
+
+from ubuntuone.platform.os_helper import (
+    is_valid_syncdaemon_path,
+)
+
+if sys.platform == 'win32':
+
+    @is_valid_syncdaemon_path()
+    def win_is_ignored(path):
+        """Should we ignore this path in the current platform.?"""
+        # don't support links yet
+        if path.endswith('.lnk'):
+            return True
+        return False
+
+    # work around for pyflakes :(
+    path_is_ignored = win_is_ignored
+else:
+
+    def unix_is_ignored(path):
+        """Should we ignore this path in the current platform.?"""
+        # don't support links yet
+        if os.path.islink(path):
+            return True
+        return False
+
+    # work around for pyflakes :(
+    path_is_ignored = unix_is_ignored
+
+# translates quickly the event and it's is_dir state to our standard events
+NAME_TRANSLATIONS = {
+    IN_OPEN: 'FS_FILE_OPEN',
+    IN_CLOSE_NOWRITE: 'FS_FILE_CLOSE_NOWRITE',
+    IN_CLOSE_WRITE: 'FS_FILE_CLOSE_WRITE',
+    IN_CREATE: 'FS_FILE_CREATE',
+    IN_CREATE | IN_ISDIR: 'FS_DIR_CREATE',
+    IN_DELETE: 'FS_FILE_DELETE',
+    IN_DELETE | IN_ISDIR: 'FS_DIR_DELETE',
+    IN_MOVED_FROM: 'FS_FILE_DELETE',
+    IN_MOVED_FROM | IN_ISDIR: 'FS_DIR_DELETE',
+    IN_MOVED_TO: 'FS_FILE_CREATE',
+    IN_MOVED_TO | IN_ISDIR: 'FS_DIR_CREATE'}
+
+
+class NotifyProcessor(ProcessEvent):
+    """Processor that takes care of dealing with the events.
+
+    This interface will be exposed to syncdaemon, ergo all passed
+    and returned paths must be a sequence of BYTES encoded with utf8.
+    """
+
+    def __init__(self, monitor, ignore_config=None):
+        self.general_processor = GeneralINotifyProcessor(monitor,
+            self.handle_dir_delete, NAME_TRANSLATIONS,
+            path_is_ignored, IN_IGNORED, ignore_config=ignore_config)
+        self.held_event = None
+
+    def rm_from_mute_filter(self, event, paths):
+        """Remove event from the mute filter."""
+        self.general_processor.rm_from_mute_filter(event, paths)
+
+    def add_to_mute_filter(self, event, paths):
+        """Add an event and path(s) to the mute filter."""
+        self.general_processor.add_to_mute_filter(event, paths)
+
+    @is_valid_syncdaemon_path(path_indexes=[1])
+    def is_ignored(self, path):
+        """Should we ignore this path?"""
+        return self.general_processor.is_ignored(path)
+
+    def release_held_event(self, timed_out=False):
+        """Release the event on hold to fulfill its destiny."""
+        self.general_processor.push_event(self.held_event)
+        self.held_event = None
+
+    def process_IN_MODIFY(self, event):
+        """Capture a modify event and fake an open ^ close write events."""
+        # lets ignore dir changes
+        if event.dir:
+            return
+        # on someplatforms we just get IN_MODIFY, lets always fake
+        # an OPEN & CLOSE_WRITE couple
+        raw_open = raw_close = {
+           'wd': event.wd,
+           'dir': event.dir,
+           'name': event.name,
+           'path': event.path}
+        # caculate the open mask
+        raw_open['mask'] = IN_OPEN
+        # create the event using the raw data, then fix the pathname param
+        open_event = Event(raw_open)
+        open_event.pathname = event.pathname
+        # push the open
+        self.general_processor.push_event(open_event)
+        raw_close['mask'] = IN_CLOSE_WRITE
+        close_event = Event(raw_close)
+        close_event.pathname = event.pathname
+        # push the close event
+        self.general_processor.push_event(close_event)
+
+    def process_IN_MOVED_FROM(self, event):
+        """Capture the MOVED_FROM to maybe syntethize FILE_MOVED."""
+        if self.held_event is not None:
+            self.general_processor.log.warn('Lost pair event of %s',
+                                            self.held_event)
+        self.held_event = event
+
+    def _fake_create_event(self, event):
+        """Fake the creation of an event."""
+        # this is the case of a MOVE from an ignored path (links for example)
+        # to a valid path
+        if event.dir:
+            evtname = "FS_DIR_"
+        else:
+            evtname = "FS_FILE_"
+        self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
+        if not event.dir:
+            self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
+                                            path=event.pathname)
+
+    def _fake_delete_create_event(self, event):
+        """Fake the deletion and the creation."""
+        # this is the case of a MOVE from a watch UDF to a diff UDF which
+        # means that we have to copy the way linux works.
+        if event.dir:
+            evtname = "FS_DIR_"
+        else:
+            evtname = "FS_FILE_"
+        m = "Delete because of different shares: %r"
+        self.log.info(m, self.held_event.pathname)
+        self.general_processor.eq_push(evtname + "DELETE",
+                                       path=self.held_event.pathname)
+        self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
+        if not event.dir:
+            self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
+                                            path=event.pathname)
+
+    def process_IN_MOVED_TO(self, event):
+        """Capture the MOVED_TO to maybe syntethize FILE_MOVED."""
+        if self.held_event is not None:
+            if event.cookie == self.held_event.cookie:
+                f_path_dir = os.path.split(self.held_event.pathname)[0]
+                t_path_dir = os.path.split(event.pathname)[0]
+
+                is_from_forreal = not self.is_ignored(self.held_event.pathname)
+                is_to_forreal = not self.is_ignored(event.pathname)
+                if is_from_forreal and is_to_forreal:
+                    f_share_id = self.general_processor.get_path_share_id(
+                        f_path_dir)
+                    t_share_id = self.general_processor.get_path_share_id(
+                        t_path_dir)
+                    if f_share_id != t_share_id:
+                        # if the share_id are != push a delete/create
+                        self._fake_delete_create_event(event)
+                    else:
+                        if event.dir:
+                            evtname = "FS_DIR_"
+                        else:
+                            evtname = "FS_FILE_"
+                        self.general_processor.eq_push(evtname + "MOVE",
+                            path_from=self.held_event.pathname,
+                            path_to=event.pathname)
+                elif is_to_forreal:
+                    # this is the case of a MOVE from something ignored
+                    # to a valid filename
+                    self._fake_create_event(event)
+
+                self.held_event = None
+                return
+            else:
+                self.release_held_event()
+                self.general_processor.push_event(event)
+        else:
+            # We should never get here, I really do not know how we
+            # got here
+            self.general_processor.log.warn(
+                            'Cookie does not match the previoues held event!')
+            self.general_processor.log.warn('Ignoring %s', event)
+
+    def process_default(self, event):
+        """Push the event into the EventQueue."""
+        if self.held_event is not None:
+            self.release_held_event()
+        self.general_processor.push_event(event)
+
+    @is_valid_syncdaemon_path(path_indexes=[1])
+    def handle_dir_delete(self, fullpath):
+        """Some special work when a directory is deleted."""
+        # remove the watch on that dir from our structures, this mainly tells
+        # the monitor to remove the watch which is fowaded to a watch manager.
+        self.general_processor.rm_watch(fullpath)
+
+        # handle the case of move a dir to a non-watched directory
+        paths = self.general_processor.get_paths_starting_with(fullpath,
+            include_base=False)
+
+        paths.sort(reverse=True)
+        for path, is_dir in paths:
+            m = "Pushing deletion because of parent dir move: (is_dir=%s) %r"
+            self.general_processor.log.info(m, is_dir, path)
+            if is_dir:
+                # same as the above remove
+                self.general_processor.rm_watch(path)
+                self.general_processor.eq_push('FS_DIR_DELETE', path=path)
+            else:
+                self.general_processor.eq_push('FS_FILE_DELETE', path=path)
+
+    @is_valid_syncdaemon_path(path_indexes=[1])
+    def freeze_begin(self, path):
+        """Puts in hold all the events for this path."""
+        self.general_processor.freeze_begin(path)
+
+    def freeze_rollback(self):
+        """Unfreezes the frozen path, reseting to idle state."""
+        self.general_processor.freeze_rollback()
+
+    def freeze_commit(self, events):
+        """Unfreezes the frozen path, sending received events if not dirty.
+
+        If events for that path happened:
+            - return True
+        else:
+            - push the here received events, return False
+        """
+        return self.general_processor.freeze_commit(events)
+
+    @property
+    def mute_filter(self):
+        """Return the mute filter used by the processor."""
+        return self.general_processor.filter
+
+    @property
+    def frozen_path(self):
+        """Return the frozen path."""
+        return self.general_processor.frozen_path
+
+    @property
+    def log(self):
+        """Return the logger of the instance."""
+        return self.general_processor.log

=== added file 'ubuntuone/platform/filesystem_notifications/notify_processor/linux.py'
--- ubuntuone/platform/filesystem_notifications/notify_processor/linux.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/filesystem_notifications/notify_processor/linux.py	2012-07-31 17:27:22 +0000
@@ -0,0 +1,322 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Linux implementation."""
+
+import os
+
+import pyinotify
+from twisted.internet import reactor, error
+
+
+# translates quickly the event and it's is_dir state to our standard events
+NAME_TRANSLATIONS = {
+    pyinotify.IN_OPEN: 'FS_FILE_OPEN',
+    pyinotify.IN_CLOSE_NOWRITE: 'FS_FILE_CLOSE_NOWRITE',
+    pyinotify.IN_CLOSE_WRITE: 'FS_FILE_CLOSE_WRITE',
+    pyinotify.IN_CREATE: 'FS_FILE_CREATE',
+    pyinotify.IN_CREATE | pyinotify.IN_ISDIR: 'FS_DIR_CREATE',
+    pyinotify.IN_DELETE: 'FS_FILE_DELETE',
+    pyinotify.IN_DELETE | pyinotify.IN_ISDIR: 'FS_DIR_DELETE',
+    pyinotify.IN_MOVED_FROM: 'FS_FILE_DELETE',
+    pyinotify.IN_MOVED_FROM | pyinotify.IN_ISDIR: 'FS_DIR_DELETE',
+    pyinotify.IN_MOVED_TO: 'FS_FILE_CREATE',
+    pyinotify.IN_MOVED_TO | pyinotify.IN_ISDIR: 'FS_DIR_CREATE',
+}
+
+# these are the events that will listen from inotify
+INOTIFY_EVENTS_GENERAL = (
+    pyinotify.IN_OPEN |
+    pyinotify.IN_CLOSE_NOWRITE |
+    pyinotify.IN_CLOSE_WRITE |
+    pyinotify.IN_CREATE |
+    pyinotify.IN_DELETE |
+    pyinotify.IN_MOVED_FROM |
+    pyinotify.IN_MOVED_TO |
+    pyinotify.IN_MOVE_SELF)
+INOTIFY_EVENTS_ANCESTORS = (
+    pyinotify.IN_DELETE |
+    pyinotify.IN_MOVED_FROM |
+    pyinotify.IN_MOVED_TO |
+    pyinotify.IN_MOVE_SELF)
+
+from ubuntuone.syncdaemon.filesystem_notifications import (
+    GeneralINotifyProcessor,
+)
+
+
+def validate_filename(real_func):
+    """Decorator that validates the filename."""
+    def func(self, event):
+        """If valid, executes original function."""
+        try:
+            # validate UTF-8
+            event.name.decode("utf8")
+        except UnicodeDecodeError:
+            dirname = event.path.decode("utf8")
+            self.general_processor.invnames_log.info("%s in %r: path %r",
+                event.maskname, dirname, event.name)
+            self.general_processor.monitor.eq.push('FS_INVALID_NAME',
+                                 dirname=dirname, filename=event.name)
+        else:
+            real_func(self, event)
+    return func
+
+
+class NotifyProcessor(pyinotify.ProcessEvent):
+    """inotify's processor when a general event happens.
+
+    This class also catchs the MOVEs events, and synthetises a new
+    FS_(DIR|FILE)_MOVE event when possible.
+    """
+    def __init__(self, monitor, ignore_config=None):
+        self.general_processor = GeneralINotifyProcessor(monitor,
+            self.handle_dir_delete, NAME_TRANSLATIONS,
+            self.platform_is_ignored, pyinotify.IN_IGNORED,
+            ignore_config=ignore_config)
+        self.held_event = None
+        self.timer = None
+
+    def shutdown(self):
+        """Shut down the processor."""
+        if self.timer is not None and self.timer.active():
+            self.timer.cancel()
+
+    def rm_from_mute_filter(self, event, paths):
+        """Remove an event and path(s) from the mute filter."""
+        self.general_processor.rm_from_mute_filter(event, paths)
+
+    def add_to_mute_filter(self, event, paths):
+        """Add an event and path(s) to the mute filter."""
+        self.general_processor.add_to_mute_filter(event, paths)
+
+    def on_timeout(self):
+        """Called on timeout."""
+        if self.held_event is not None:
+            self.release_held_event(True)
+
+    def release_held_event(self, timed_out=False):
+        """Release the event on hold to fulfill its destiny."""
+        if not timed_out:
+            try:
+                self.timer.cancel()
+            except error.AlreadyCalled:
+                # self.timeout() was *just* called, do nothing here
+                return
+        self.general_processor.push_event(self.held_event)
+        self.held_event = None
+
+    @validate_filename
+    def process_IN_OPEN(self, event):
+        """Filter IN_OPEN to make it happen only in files."""
+        if not (event.mask & pyinotify.IN_ISDIR):
+            self.general_processor.push_event(event)
+
+    @validate_filename
+    def process_IN_CLOSE_NOWRITE(self, event):
+        """Filter IN_CLOSE_NOWRITE to make it happen only in files."""
+        if not (event.mask & pyinotify.IN_ISDIR):
+            self.general_processor.push_event(event)
+
+    @validate_filename
+    def process_IN_CLOSE_WRITE(self, event):
+        """Filter IN_CLOSE_WRITE to make it happen only in files.
+
+        eCryptFS sends IN_CLOSE_WRITE event for lower directories.
+
+        """
+        if not (event.mask & pyinotify.IN_ISDIR):
+            self.general_processor.push_event(event)
+
+    def process_IN_MOVE_SELF(self, event):
+        """Don't do anything here.
+
+        We just turned this event on because pyinotify does some
+        path-fixing in its internal processing when this happens.
+
+        """
+
+    @validate_filename
+    def process_IN_MOVED_FROM(self, event):
+        """Capture the MOVED_FROM to maybe syntethize FILE_MOVED."""
+        if self.held_event is not None:
+            self.release_held_event()
+
+        self.held_event = event
+        self.timer = reactor.callLater(1, self.on_timeout)
+
+    def platform_is_ignored(self, path):
+        """Should we ignore this path in the current platform.?"""
+        # don't support links yet
+        if os.path.islink(path):
+            return True
+        return False
+
+    def is_ignored(self, path):
+        """Should we ignore this path?"""
+        return self.general_processor.is_ignored(path)
+
+    @validate_filename
+    def process_IN_MOVED_TO(self, event):
+        """Capture the MOVED_TO to maybe syntethize FILE_MOVED."""
+        if self.held_event is not None:
+            if event.cookie == self.held_event.cookie:
+                try:
+                    self.timer.cancel()
+                except error.AlreadyCalled:
+                    # self.timeout() was *just* called, do nothing here
+                    pass
+                else:
+                    f_path_dir = self.held_event.path
+                    f_path = os.path.join(f_path_dir, self.held_event.name)
+                    t_path_dir = event.path
+                    t_path = os.path.join(t_path_dir, event.name)
+
+                    is_from_forreal = not self.is_ignored(f_path)
+                    is_to_forreal = not self.is_ignored(t_path)
+                    if is_from_forreal and is_to_forreal:
+                        f_share_id = self.general_processor.get_path_share_id(
+                            f_path_dir)
+                        t_share_id = self.general_processor.get_path_share_id(
+                            t_path_dir)
+                        if event.dir:
+                            evtname = "FS_DIR_"
+                        else:
+                            evtname = "FS_FILE_"
+                        if f_share_id != t_share_id:
+                            # if the share_id are != push a delete/create
+                            m = "Delete because of different shares: %r"
+                            self.general_processor.log.info(m, f_path)
+                            self.general_processor.eq_push(evtname + "DELETE",
+                                                           path=f_path)
+                            self.general_processor.eq_push(evtname + "CREATE",
+                                                           path=t_path)
+                            if not event.dir:
+                                self.general_processor.eq_push(
+                                            'FS_FILE_CLOSE_WRITE', path=t_path)
+                        else:
+                            self.general_processor.monitor.inotify_watch_fix(
+                                                                f_path, t_path)
+                            self.general_processor.eq_push(evtname + "MOVE",
+                                         path_from=f_path, path_to=t_path)
+                    elif is_to_forreal:
+                        # this is the case of a MOVE from something ignored
+                        # to a valid filename
+                        if event.dir:
+                            evtname = "FS_DIR_"
+                        else:
+                            evtname = "FS_FILE_"
+                        self.general_processor.eq_push(evtname + "CREATE",
+                                                       path=t_path)
+                        if not event.dir:
+                            self.general_processor.eq_push(
+                                            'FS_FILE_CLOSE_WRITE', path=t_path)
+
+                    else:
+                        # this is the case of a MOVE from something valid
+                        # to an ignored filename
+                        if event.dir:
+                            evtname = "FS_DIR_"
+                        else:
+                            evtname = "FS_FILE_"
+                        self.general_processor.eq_push(evtname + "DELETE",
+                                                       path=f_path)
+
+                    self.held_event = None
+                return
+            else:
+                self.release_held_event()
+                self.general_processor.push_event(event)
+        else:
+            # we don't have a held_event so this is a move from outside.
+            # if it's a file move it's atomic on POSIX, so we aren't going to
+            # receive a IN_CLOSE_WRITE, so let's fake it for files
+            self.general_processor.push_event(event)
+            if not event.dir:
+                t_path = os.path.join(event.path, event.name)
+                self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
+                    path=t_path)
+
+    @validate_filename
+    def process_default(self, event):
+        """Push the event into the EventQueue."""
+        if self.held_event is not None:
+            self.release_held_event()
+        self.general_processor.push_event(event)
+
+    def freeze_begin(self, path):
+        """Puts in hold all the events for this path."""
+        self.general_processor.freeze_begin(path)
+
+    def freeze_rollback(self):
+        """Unfreezes the frozen path, reseting to idle state."""
+        self.general_processor.freeze_rollback()
+
+    def freeze_commit(self, events):
+        """Unfreezes the frozen path, sending received events if not dirty.
+
+        If events for that path happened:
+            - return True
+        else:
+            - push the here received events, return False
+        """
+        return self.general_processor.freeze_commit(events)
+
+    def handle_dir_delete(self, fullpath):
+        """Some special work when a directory is deleted."""
+        # remove the watch on that dir from our structures
+        self.general_processor.rm_watch(fullpath)
+
+        # handle the case of move a dir to a non-watched directory
+        paths = self.general_processor.get_paths_starting_with(fullpath,
+            include_base=False)
+
+        paths.sort(reverse=True)
+        for path, is_dir in paths:
+            m = "Pushing deletion because of parent dir move: (is_dir=%s) %r"
+            self.general_processor.log.info(m, is_dir, path)
+            if is_dir:
+                self.general_processor.rm_watch(path)
+                self.general_processor.eq_push('FS_DIR_DELETE', path=path)
+            else:
+                self.general_processor.eq_push('FS_FILE_DELETE', path=path)
+
+    @property
+    def mute_filter(self):
+        """Return the mute filter used by the processor."""
+        return self.general_processor.filter
+
+    @property
+    def frozen_path(self):
+        """Return the frozen path."""
+        return self.general_processor.frozen_path
+
+    @property
+    def log(self):
+        """Return the logger of the instance."""
+        return self.general_processor.log

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2012-06-28 10:26:50 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2012-07-31 17:27:22 +0000
@@ -38,7 +38,9 @@
 from twisted.internet import defer
 
 from ubuntuone.platform.os_helper import access
-from ubuntuone.platform.filesystem_notifications import FilesystemMonitor
+from ubuntuone.platform.filesystem_notifications.monitor import (
+    FilesystemMonitor,
+)
 
 # these are our internal events, what is inserted into the whole system
 EVENTS = {
@@ -183,13 +185,17 @@
 class EventQueue(object):
     """Manages the events from different sources and distributes them."""
 
-    def __init__(self, fs, ignore_config=None):
+    def __init__(self, fs, ignore_config=None, monitor_class=None):
         self.listener_map = {}
 
         self.log = logging.getLogger('ubuntuone.SyncDaemon.EQ')
         self.fs = fs
 
-        self.monitor = FilesystemMonitor(self, fs, ignore_config)
+        if monitor_class is None:
+            # use the default class returned by platform
+            self.monitor = FilesystemMonitor(self, fs, ignore_config)
+        else:
+            self.monitor = monitor_class(self, fs, ignore_config)
 
         self.dispatching = False
         self.dispatch_queue = collections.deque()

=== modified file 'ubuntuone/syncdaemon/filesystem_manager.py'
--- ubuntuone/syncdaemon/filesystem_manager.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/filesystem_manager.py	2012-07-31 17:27:22 +0000
@@ -744,6 +744,7 @@
                 mdobj = self.fs[mdid]
                 if mdobj["share_id"] == share_id:
                     all_mdobjs.append(_MDObject(**mdobj))
+
         return all_mdobjs
 
     def get_mdobjs_in_dir(self, base_path):

=== modified file 'ubuntuone/syncdaemon/filesystem_notifications.py'
--- ubuntuone/syncdaemon/filesystem_notifications.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/filesystem_notifications.py	2012-07-31 17:27:22 +0000
@@ -44,7 +44,6 @@
 
     def __init__(self, monitor, handle_dir_delete, name_translations,
             platform_is_ignored, ignore_mask, ignore_config=None):
-        super(GeneralINotifyProcessor, self).__init__()
         self.log = logging.getLogger('ubuntuone.SyncDaemon.'
             + 'filesystem_notifications.GeneralProcessor')
         self.log.setLevel(TRACE)

=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2012-06-21 18:58:50 +0000
+++ ubuntuone/syncdaemon/main.py	2012-07-31 17:27:22 +0000
@@ -90,7 +90,7 @@
                  handshake_timeout=30,
                  shares_symlink_name='Shared With Me',
                  read_limit=None, write_limit=None, throttling_enabled=False,
-                 ignore_files=None, oauth_credentials=None):
+                 ignore_files=None, oauth_credentials=None, monitor_class=None):
         self.root_dir = root_dir
         self.shares_dir = shares_dir
         self.shares_dir_link = os.path.join(self.root_dir, shares_symlink_name)
@@ -115,7 +115,8 @@
         self.vm = volume_manager.VolumeManager(self)
         self.fs = filesystem_manager.FileSystemManager(
             data_dir, partials_dir, self.vm, self.db)
-        self.event_q = event_queue.EventQueue(self.fs, ignore_files)
+        self.event_q = event_queue.EventQueue(self.fs, ignore_files,
+                monitor_class=monitor_class)
         self.fs.register_eq(self.event_q)
 
         # subscribe VM to EQ, to be unsubscribed in shutdown