Merge lp:~mandel/ubuntuone-client/clean-fsevents into lp:ubuntuone-client

[Manuel de la Peña]

Refactor that simplifies the way the diff implementations per platform are done so that in future branches is simpler to add the daemon code.

Refactor that simplifies the way the diff implementations per platform are done so that in future branches is simpler to add the daemon code.

Please run tests on windows/linux and mac.

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[Mike McCracken (mikemc)]

really minor stuff:

- filesystem_notifications/windows.py - the docstring refers to 'darwin paths'.

- filesystem_notifications/darwin.py - WatchManager.add_watch doesn't return a value, but in common.py, it's expecting a return. the version in windows.py returns boolean.
-- I looked around and this return value seems like it's never actually used, just passed around a bit and eventually ignored. Still, it's probably worth being consistent.

review: Needs Fixing

[Manuel de la Peña (mandel)]

> really minor stuff:
>
> - filesystem_notifications/windows.py - the docstring refers to 'darwin
> paths'.
>

Left over from moving things around. Fixed!

> - filesystem_notifications/darwin.py - WatchManager.add_watch doesn't return a
> value, but in common.py, it's expecting a return. the version in windows.py
> returns boolean.
> -- I looked around and this return value seems like it's never actually used,
> just passed around a bit and eventually ignored. Still, it's probably worth
> being consistent.

Indeed, I made the changes to make sure both return True.

[Mike McCracken (mikemc)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~mandel/ubuntuone-client/clean-fsevents into lp:ubuntuone-client 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 "+="... yes
che...

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~mandel/ubuntuone-client/clean-fsevents into lp:ubuntuone-client 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 "+="... yes
che...

=== modified file 'tests/platform/filesystem_notifications/test_darwin.py'
--- tests/platform/filesystem_notifications/test_darwin.py	2012-06-28 13:20:01 +0000
+++ tests/platform/filesystem_notifications/test_darwin.py	2012-07-11 15:52:18 +0000
@@ -32,7 +32,6 @@
 import os
 import tempfile
 import thread
-import time
 
 from twisted.internet import defer
 
@@ -41,7 +40,7 @@
 from ubuntuone.platform.filesystem_notifications import (
     darwin as filesystem_notifications,
 )
-from ubuntuone.platform.filesystem_notifications.darwin import (
+from ubuntuone.platform.filesystem_notifications.common import (
     Watch,
     WatchManager,
 )
@@ -54,7 +53,7 @@
 
 # A reverse mapping for the tests
 REVERSE_MACOS_ACTIONS = {}
-for key, value in filesystem_notifications.common.COMMON_ACTIONS.iteritems():
+for key, value in filesystem_notifications.ACTIONS.iteritems():
     REVERSE_MACOS_ACTIONS[value] = key
 
 
@@ -148,16 +147,15 @@
             self.paths_checked.append((path, result))
             return result
 
-        self.patch(filesystem_notifications.Watch, '_path_is_dir',
+        self.patch(Watch, '_path_is_dir',
                    path_is_dir_wrapper)
 
     @defer.inlineCallbacks
-    def _perform_operations(self, path, mask, auto_add, actions,
-                            number_events):
+    def _perform_operations(self, path, mask, actions, number_events):
         """Perform the file operations and returns the recorded events."""
         handler = TestCaseHandler(number_events=number_events)
         manager = WatchManager(handler)
-        yield manager.add_watch(path, mask, auto_add=auto_add)
+        yield manager.add_watch(path, mask)
         # change the logger so that we can check the logs if we wanted
         manager._wdm[0].log.addHandler(self.memento)
         # clean logger later
@@ -169,22 +167,6 @@
         self.addCleanup(manager.stop)
         defer.returnValue(ret)
 
-    def _perform_timed_operations(self, path, mask, auto_add, actions,
-                                  time_out):
-        """Perform the file operations and returns the recorded events."""
-        manager = WatchManager()
-        manager.add_watch(path, mask, auto_add=auto_add)
-        # change the logger so that we can check the logs if we wanted
-        manager._wdm[0].log.addHandler(self.memento)
-        # clean logger later
-        self.addCleanup(manager._wdm[0].log.removeHandler, self.memento)
-        # execution the actions
-        actions()
-        # process the recorded events
-        time.sleep(time_out)
-        events = self.handler.processed_events
-        return events
-
     def _assert_logs(self, events):
         """Assert the debug logs."""
         logs = []
@@ -208,7 +190,7 @@
             os.fsync(fd)
             fd.close()
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
             create_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -230,7 +212,7 @@
             """Action for the test."""
             os.mkdir(dir_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
             create_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -254,7 +236,7 @@
             """Action for the test."""
             os.remove(file_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 remove_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -278,7 +260,7 @@
             """Action for the test."""
             os.rmdir(dir_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 remove_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -304,7 +286,7 @@
             fd.write('test')
             fd.close()
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 write_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -332,7 +314,7 @@
             os.rename(from_file_name, to_file_name)
 
         events = yield self._perform_operations(self.basedir, self.mask,
-                                                False, move_file, 2)
+                                                move_file, 2)
         move_from_event = events[0]
         move_to_event = events[1]
         # first test the move from
@@ -375,7 +357,7 @@
 
         # We need to test that we get a delete operation when moving
         # a file to an unwatched folder
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -405,7 +387,7 @@
 
         # We need to test that we get a delete operation when moving
         # a file from an unwatched folder
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_files, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -433,7 +415,7 @@
             os.rename(from_dir_name, to_dir_name)
 
         events = yield self._perform_operations(self.basedir,
-            self.mask, False, move_file, 2)
+            self.mask, move_file, 2)
         move_from_event = events[0]
         move_to_event = events[1]
         # first test the move from
@@ -476,7 +458,7 @@
 
         # We need to test that we get a delete operation when moving
         # a file to an unwatched folder
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -502,7 +484,7 @@
             """Action for the test."""
             os.rename(from_dir_name, to_dir_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -519,8 +501,8 @@
         handler = TestCaseHandler(number_events=0)
         manager = WatchManager(handler)
         # add a watch that will always exclude all actions
-        manager.add_watch(self.basedir, self.mask, auto_add=True,
-                          exclude_filter=lambda x: True)
+        manager.add_watch(self.basedir, self.mask,
+            exclude_filter=lambda x: True)
         # execution the actions
         file_name = os.path.join(self.basedir, 'test_file_create')
         open(file_name, 'w').close()
@@ -528,21 +510,6 @@
         self.assertEqual(0, len(handler.processed_events))
     test_exclude_filter.skip = "we must rethink this test."
 
-    def test_open_dir_muted(self):
-        """Test that the opening of dirs is ignored."""
-        dir_name = os.path.join(tempfile.mkdtemp(), 'test_dir_open')
-        # create file before we record
-        os.mkdir(dir_name)
-
-        def open_dir():
-            """Action for the test."""
-            os.startfile(dir_name)
-
-        events = self._perform_timed_operations(self.basedir, self.mask, False,
-            open_dir, 2)
-        self.assertEqual(0, len(events))
-    test_open_dir_muted.skip = "we must rethink this test."
-
     def test_ignore_path(self):
         """Test that events from a path are ignored."""
         events = []
@@ -553,13 +520,13 @@
 
         path = '/Users/username/folder'
         child = 'child'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         # ensure that the watch is watching
-        watch._watching = True
+        watch.platform_watch.watching = True
         for file_name in 'abcdef':
             event = FakeFileEvent(256, None, os.path.join(child, file_name))
-            watch._process_events(event)
+            watch.platform_watch._process_events(event)
         self.assertEqual(0, len(events),
                          'All events should have been ignored.')
 
@@ -576,7 +543,7 @@
 
         path = '/Users/username/folder'
         child = 'child'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         paths_not_to_ignore = []
         for file_name in 'abcdef':
@@ -584,9 +551,9 @@
                                   file_name))
             paths_not_to_ignore.append(event)
         # ensure that the watch is watching
-        watch._watching = True
+        watch.platform_watch.watching = True
         for event in paths_not_to_ignore:
-            watch._process_events(event)
+            watch.platform_watch._process_events(event)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'No events should have been ignored.')
 
@@ -603,7 +570,7 @@
 
         child = 'child'
         path = '/Users/username/folder'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         paths_not_to_ignore = []
         paths_to_ignore = []
@@ -615,9 +582,9 @@
             paths_not_to_ignore.append(event)
             expected_events.append(os.path.join(path, valid))
         # ensure that the watch is watching
-        watch._watching = True
+        watch.platform_watch.watching = True
         for event in paths_not_to_ignore:
-            watch._process_events(event)
+            watch.platform_watch._process_events(event)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'Wrong number of events ignored.')
         self.assertTrue(all([event in expected_events for event in events]),
@@ -636,7 +603,7 @@
 
         path = '/Users/username/folder'
         child = 'child'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         watch.remove_ignored_path(os.path.join(path, child))
         paths_not_to_ignore = []
@@ -644,9 +611,9 @@
             event = FakeFileEvent(256, None, os.path.join(child, file_name))
             paths_not_to_ignore.append(event)
         # ensure that the watch is watching
-        watch._watching = True
+        watch.platform_watch.watching = True
         for event in paths_not_to_ignore:
-            watch._process_events(event)
+            watch.platform_watch._process_events(event)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'All events should have been accepted.')
 
@@ -664,7 +631,7 @@
         path = '/Users/username/folder'
         child_a = 'childa'
         child_b = 'childb'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child_a))
         watch.ignore_path(os.path.join(path, child_b))
         watch.remove_ignored_path(os.path.join(path, child_a))
@@ -678,9 +645,9 @@
             paths_not_to_ignore.append(event)
             expected_events.append(os.path.join(path, valid))
         # ensure that the watch is watching
-        watch._watching = True
+        watch.platform_watch.watching = True
         for event in paths_not_to_ignore:
-            watch._process_events(event)
+            watch.platform_watch._process_events(event)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'All events should have been accepted.')
         self.assertTrue(all([event in expected_events for event in events]),
@@ -691,17 +658,18 @@
         def fake_call(*args, **kwargs):
             """Fake call."""
 
-        path = '/Users/username/folder'
-        watch = Watch(1, path, None, True, None)
-        self.assertEqual(watch._process_events, watch.stream.callback)
-        self.assertEqual(watch.stream.paths, [path])
-        self.assertEqual(watch.stream.file_events, True)
+        path = '/Users/username/folder/'
+        watch = Watch(1, path, None)
+        self.assertEqual(watch.platform_watch._process_events,
+            watch.platform_watch.stream.callback)
+        self.assertEqual(watch.platform_watch.stream.paths, [path])
+        self.assertEqual(watch.platform_watch.stream.file_events, True)
 
     def test_watching_property(self):
         """Test that the stopped property returns the stopped deferred."""
         path = '/Users/username/folder'
-        watch = Watch(1, path, None, True, None)
-        self.assertFalse(watch._watching)
+        watch = Watch(1, path, None)
+        self.assertFalse(watch.watching)
 
     def random_error(self, *args):
         """Throw a fake exception."""
@@ -712,7 +680,7 @@
         path = '/Users/username/path/to/not/dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: False)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         self.assertFalse(watch._path_is_dir(path))
 
     def test_is_path_dir_missing_in_subdir(self):
@@ -720,7 +688,7 @@
         path = '/Users/username/path/to/not/dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: False)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         self.assertTrue(watch._path_is_dir(path))
 
@@ -730,7 +698,7 @@
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: True)
         self.patch(os.path, 'isdir', lambda path: True)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         self.assertTrue(watch._path_is_dir(path))
 
@@ -740,7 +708,7 @@
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: True)
         self.patch(os.path, 'isdir', lambda path: False)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         self.assertFalse(watch._path_is_dir(path))
 
@@ -748,7 +716,7 @@
         """Test when we update on a create event and not present."""
         path = '/Users/username/path/to/not/dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._update_subdirs(path, REVERSE_MACOS_ACTIONS[IN_CREATE])
         self.assertTrue(path in watch._subdirs)
 
@@ -756,7 +724,7 @@
         """Test when we update on a create event and is present."""
         path = '/Users/username/path/to/not/dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         old_length = len(watch._subdirs)
         watch._update_subdirs(path, REVERSE_MACOS_ACTIONS[IN_CREATE])
@@ -767,7 +735,7 @@
         """Test when we delete and is not present."""
         path = '/Users/username/path/to/not/dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._update_subdirs(path, REVERSE_MACOS_ACTIONS[IN_DELETE])
         self.assertTrue(path not in watch._subdirs)
 
@@ -775,7 +743,7 @@
         """Test when we delete and is present."""
         path = '/Users/username/path/to/not/dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         watch._update_subdirs(path, REVERSE_MACOS_ACTIONS[IN_DELETE])
         self.assertTrue(path not in watch._subdirs)

=== modified file 'tests/platform/filesystem_notifications/test_windows.py'
--- tests/platform/filesystem_notifications/test_windows.py	2012-06-22 14:17:44 +0000
+++ tests/platform/filesystem_notifications/test_windows.py	2012-07-11 15:52:18 +0000
@@ -51,14 +51,16 @@
     IN_OPEN,
 )
 from ubuntuone.platform.filesystem_notifications import (
-    common,
     windows as filesystem_notifications,
 )
-from ubuntuone.platform.filesystem_notifications.windows import (
+from ubuntuone.platform.filesystem_notifications.common import (
     FilesystemMonitor,
     NotifyProcessor,
     Watch,
     WatchManager,
+)
+from ubuntuone.platform.filesystem_notifications.windows import (
+    ACTIONS,
     FILE_NOTIFY_CHANGE_FILE_NAME,
     FILE_NOTIFY_CHANGE_DIR_NAME,
     FILE_NOTIFY_CHANGE_ATTRIBUTES,
@@ -70,7 +72,7 @@
 
 #create a rever mapping to use it in the tests.
 REVERSE_WINDOWS_ACTIONS = {}
-for key, value in common.COMMON_ACTIONS.iteritems():
+for key, value in ACTIONS.iteritems():
     REVERSE_WINDOWS_ACTIONS[value] = key
 
 
@@ -147,7 +149,7 @@
             # group all events in a single lists which is not what the COM API
             # does.
             str_events = [
-                (common.COMMON_ACTIONS_NAMES[action], path) for action, path in
+                (filesystem_notifications.ACTIONS_NAMES[action], path) for action, path in
                  events]
             self.raw_events.append(str_events)
             return events
@@ -160,17 +162,14 @@
 
         self.patch(filesystem_notifications, 'FILE_NOTIFY_INFORMATION',
                    file_notify_information_wrapper)
-        self.patch(filesystem_notifications.Watch, '_path_is_dir',
-                   path_is_dir_wrapper)
+        self.patch(Watch, '_path_is_dir', path_is_dir_wrapper)
 
     @defer.inlineCallbacks
-    def _perform_operations(self, path, mask, auto_add, actions,
-                            number_events):
+    def _perform_operations(self, path, mask, actions, number_events):
         """Perform the file operations and returns the recorded events."""
         handler = TestCaseHandler(number_events=number_events)
         manager = WatchManager(handler)
-        yield manager.add_watch(os_helper.get_windows_valid_path(path), mask,
-                          auto_add=auto_add)
+        yield manager.add_watch(os_helper.get_windows_valid_path(path), mask)
         # change the logger so that we can check the logs if we wanted
         manager._wdm[0].log.addHandler(self.memento)
         # clean logger later
@@ -182,35 +181,6 @@
         self.addCleanup(manager.stop)
         defer.returnValue(ret)
 
-    def _perform_timed_operations(self, path, mask, auto_add, actions,
-                                  time_out):
-        """Perform the file operations and returns the recorded events."""
-        manager = WatchManager()
-        manager.add_watch(os_helper.get_windows_valid_path(path), mask,
-                          auto_add=auto_add)
-        # change the logger so that we can check the logs if we wanted
-        manager._wdm[0].log.addHandler(self.memento)
-        # clean logger later
-        self.addCleanup(manager._wdm[0].log.removeHandler, self.memento)
-        # execution the actions
-        actions()
-        # process the recorded events
-        time.sleep(time_out)
-        events = self.handler.processed_events
-        return events
-
-    def _assert_logs(self, events):
-        """Assert the debug logs."""
-        logs = []
-        msg = 'Is path %r a dir? %s'
-        logs.extend([msg % data for data in self.paths_checked])
-        msg = 'Got from ReadDirectoryChangesW %r.'
-        logs.extend([msg % actions for actions in self.raw_events])
-        msg = 'Pushing event %r to processor.'
-        logs.extend([msg % e for e in events])
-        for msg in logs:
-            self.assertTrue(self.memento.check_debug(msg))
-
     @defer.inlineCallbacks
     def test_file_create(self):
         """Test that the correct event is returned on a file create."""
@@ -224,7 +194,7 @@
             os.fsync(fd)
             fd.close()
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
             create_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -234,8 +204,6 @@
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_create(self):
@@ -246,7 +214,7 @@
             """Action for the test."""
             os.mkdir(dir_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
             create_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -256,8 +224,6 @@
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_remove(self):
@@ -270,7 +236,7 @@
             """Action for the test."""
             os.remove(file_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 remove_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -280,8 +246,6 @@
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_remove(self):
@@ -294,7 +258,7 @@
             """Action for the test."""
             os.rmdir(dir_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 remove_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -303,8 +267,6 @@
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_write(self):
@@ -320,7 +282,7 @@
             fd.write('test')
             fd.close()
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 write_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -330,8 +292,6 @@
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_moved_to_watched_dir_same_watcher(self):
@@ -348,7 +308,7 @@
             os.rename(from_file_name, to_file_name)
 
         events = yield self._perform_operations(self.basedir, self.mask,
-                                                False, move_file, 2)
+                                                move_file, 2)
         move_from_event = events[0]
         move_to_event = events[1]
         # first test the move from
@@ -374,8 +334,6 @@
         self.assertEqual(0, move_to_event.wd)
         # assert that both cookies are the same
         self.assertEqual(move_from_event.cookie, move_to_event.cookie)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_moved_to_not_watched_dir(self):
@@ -392,7 +350,7 @@
         # while on linux we will have to do some sort of magic like facundo
         # did, on windows we will get a deleted event which is much more
         # cleaner, first time ever windows is nicer!
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -403,8 +361,6 @@
         self.assertEqual(os.path.join(self.basedir, from_file_name),
                          event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_move_from_not_watched_dir(self):
@@ -422,7 +378,7 @@
 
         # while on linux we have to do some magic operations like facundo did
         # on windows we have a created file, hurray!
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_files, 1)
         event = events[0]
         self.assertFalse(event.dir)
@@ -433,8 +389,6 @@
         self.assertEqual(os.path.join(self.basedir, to_file_name),
             event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_moved_to_watched_dir_same_watcher(self):
@@ -450,7 +404,7 @@
             os.rename(from_dir_name, to_dir_name)
 
         events = yield self._perform_operations(self.basedir,
-            self.mask, False, move_file, 2)
+            self.mask, move_file, 2)
         move_from_event = events[0]
         move_to_event = events[1]
         # first test the move from
@@ -475,8 +429,6 @@
         self.assertEqual(0, move_to_event.wd)
         # assert that both cookies are the same
         self.assertEqual(move_from_event.cookie, move_to_event.cookie)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_moved_to_not_watched_dir(self):
@@ -491,7 +443,7 @@
                 'test_dir_moved_to_not_watched_dir'))
 
         # on windows a move to outside a watched dir translates to a remove
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -500,8 +452,6 @@
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_move_from_not_watched_dir(self):
@@ -517,7 +467,7 @@
             """Action for the test."""
             os.rename(from_dir_name, to_dir_name)
 
-        events = yield self._perform_operations(self.basedir, self.mask, False,
+        events = yield self._perform_operations(self.basedir, self.mask,
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
@@ -535,8 +485,7 @@
         manager = WatchManager(handler)
         # add a watch that will always exclude all actions
         manager.add_watch(os_helper.get_windows_valid_path(self.basedir),
-                          self.mask, auto_add=True,
-                          exclude_filter=lambda x: True)
+                          self.mask, exclude_filter=lambda x: True)
         # execution the actions
         file_name = os.path.join(self.basedir, 'test_file_create')
         open(file_name, 'w').close()
@@ -545,21 +494,6 @@
         self.assertEqual(0, len(handler.processed_events))
     test_exclude_filter.skip = "we must rethink this test."
 
-    def test_open_dir_muted(self):
-        """Test that the opening of dirs is ignored."""
-        dir_name = os.path.join(tempfile.mkdtemp(), 'test_dir_open')
-        # create file before we record
-        os.mkdir(dir_name)
-
-        def open_dir():
-            """Action for the test."""
-            os.startfile(dir_name)
-
-        events = self._perform_timed_operations(self.basedir, self.mask, False,
-            open_dir, 2)
-        self.assertEqual(0, len(events))
-    test_open_dir_muted.skip = "we must rethink this test."
-
     def test_ignore_path(self):
         """Test that events from a path are ignored."""
         events = []
@@ -570,14 +504,14 @@
 
         path = u'\\\\?\\C:\\path'  # a valid windows path
         child = u'child'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         paths_to_ignore = []
         for file_name in 'abcdef':
             paths_to_ignore.append((1, os.path.join(child, file_name)))
         # ensure that the watch is watching
         watch._watching = True
-        watch._process_events(paths_to_ignore)
+        watch.platform_watch._process_events(paths_to_ignore)
         self.assertEqual(0, len(events),
                          'All events should have been ignored.')
 
@@ -591,15 +525,15 @@
 
         path = u'\\\\?\\C:\\path'  # a valid windows path
         child = u'child'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         paths_not_to_ignore = []
         for file_name in 'abcdef':
             paths_not_to_ignore.append((1, os.path.join(
                                                 child + file_name, file_name)))
         # ensure that the watch is watching
-        watch._watching = True
-        watch._process_events(paths_not_to_ignore)
+        watch.platform_watch.watching = True
+        watch.platform_watch._process_events(paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'No events should have been ignored.')
 
@@ -613,7 +547,7 @@
 
         child = u'child'
         path = u'\\\\?\\C:\\path\\'  # a valid windows path
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         paths_not_to_ignore = []
         paths_to_ignore = []
@@ -624,8 +558,8 @@
             paths_not_to_ignore.append((1, valid))
             expected_events.append(os.path.join('C:\\path', valid))
         # ensure that the watch is watching
-        watch._watching = True
-        watch._process_events(paths_not_to_ignore)
+        watch.platform_watch.watching = True
+        watch.platform_watch._process_events(paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'Wrong number of events ignored.')
         self.assertTrue(all([event in expected_events for event in events]),
@@ -641,15 +575,15 @@
 
         path = u'\\\\?\\C:\\path'  # a valid windows path
         child = u'child'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child))
         watch.remove_ignored_path(os.path.join(path, child))
         paths_not_to_ignore = []
         for file_name in 'abcdef':
             paths_not_to_ignore.append((1, os.path.join(child, file_name)))
         # ensure that the watch is watching
-        watch._watching = True
-        watch._process_events(paths_not_to_ignore)
+        watch.platform_watch.watching = True
+        watch.platform_watch._process_events(paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'All events should have been accepted.')
 
@@ -664,7 +598,7 @@
         path = u'\\\\?\\C:\\path'  # a valid windows path
         child_a = u'childa'
         child_b = u'childb'
-        watch = Watch(1, path, None, True, fake_processor)
+        watch = Watch(1, path, fake_processor)
         watch.ignore_path(os.path.join(path, child_a))
         watch.ignore_path(os.path.join(path, child_b))
         watch.remove_ignored_path(os.path.join(path, child_a))
@@ -677,8 +611,8 @@
             paths_not_to_ignore.append((1, valid))
             expected_events.append(os.path.join('C:\\path', valid))
         # ensure that the watch is watching
-        watch._watching = True
-        watch._process_events(paths_not_to_ignore)
+        watch.platform_watch.watching = True
+        watch.platform_watch._process_events(paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'All events should have been accepted.')
         self.assertTrue(all([event in expected_events for event in events]),
@@ -694,9 +628,9 @@
             method_args.append((args, kwargs),)
 
         path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None, True, None)
-        yield watch._watch_started_deferred.callback(True)
-        watch._call_deferred(fake_call, None)
+        watch = Watch(1, path, None)
+        yield watch.platform_watch._watch_started_deferred.callback(True)
+        watch.platform_watch._call_deferred(fake_call, None)
         self.assertEqual(0, len(method_args))
 
     def test_call_deferred_not_called(self):
@@ -708,21 +642,21 @@
             method_args.append((args, kwargs),)
 
         path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None, True, None)
-        watch._call_deferred(fake_call, None)
+        watch = Watch(1, path, None)
+        watch.platform_watch._call_deferred(fake_call, None)
         self.assertEqual(1, len(method_args))
 
     def test_started_property(self):
         """Test that the started property returns the started deferred."""
         path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None, True, None)
-        self.assertEqual(watch.started, watch._watch_started_deferred)
+        watch = Watch(1, path, None)
+        self.assertEqual(watch.started, watch.platform_watch._watch_started_deferred)
 
     def test_stopped_property(self):
         """Test that the stopped property returns the stopped deferred."""
         path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None, True, None)
-        self.assertEqual(watch.stopped, watch._watch_stopped_deferred)
+        watch = Watch(1, path, None)
+        self.assertEqual(watch.stopped, watch.platform_watch._watch_stopped_deferred)
 
     def random_error(self, *args):
         """Throw a fake exception."""
@@ -733,7 +667,7 @@
         """An early failure inside the thread should errback the deferred."""
         test_path = self.mktemp("test_directory")
         self.patch(filesystem_notifications, "CreateFileW", self.random_error)
-        watch = Watch(1, test_path, None, True, None)
+        watch = Watch(1, test_path, None)
         d = watch.start_watching()
         yield self.assertFailure(d, FakeException)
 
@@ -743,7 +677,7 @@
         test_path = self.mktemp("test_directory")
         self.patch(filesystem_notifications, "ReadDirectoryChangesW",
                    self.random_error)
-        watch = Watch(1, test_path, None, True, None)
+        watch = Watch(1, test_path, None)
         d = watch.start_watching()
         yield self.assertFailure(d, FakeException)
 
@@ -757,7 +691,7 @@
                    close_called.append)
         self.patch(filesystem_notifications, "ReadDirectoryChangesW",
                    self.random_error)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         d = watch.start_watching()
         yield self.assertFailure(d, FakeException)
         self.assertEqual(len(close_called), 1)
@@ -767,18 +701,18 @@
     def test_stop_watching_fired_when_watch_thread_finishes(self):
         """The deferred returned is fired when the watch thread finishes."""
         test_path = self.mktemp("another_test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         yield watch.start_watching()
-        self.assertNotEqual(watch._watch_handle, None)
+        self.assertNotEqual(watch.platform_watch._watch_handle, None)
         yield watch.stop_watching()
-        self.assertEqual(watch._watch_handle, None)
+        self.assertEqual(watch.platform_watch._watch_handle, None)
 
     def test_is_path_dir_missing_no_subdir(self):
         """Test when the path does not exist and is no a subdir."""
         path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: False)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         self.assertFalse(watch._path_is_dir(path))
 
     def test_is_path_dir_missing_in_subdir(self):
@@ -786,7 +720,7 @@
         path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: False)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         self.assertTrue(watch._path_is_dir(path))
 
@@ -796,7 +730,7 @@
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: True)
         self.patch(os.path, 'isdir', lambda path: True)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         self.assertTrue(watch._path_is_dir(path))
 
@@ -806,7 +740,7 @@
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: True)
         self.patch(os.path, 'isdir', lambda path: False)
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         self.assertFalse(watch._path_is_dir(path))
 
@@ -814,7 +748,7 @@
         """Test when we update on a create event and not present."""
         path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_CREATE])
         self.assertTrue(path in watch._subdirs)
 
@@ -822,7 +756,7 @@
         """Test when we update on a create event and is present."""
         path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         old_length = len(watch._subdirs)
         watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_CREATE])
@@ -833,7 +767,7 @@
         """Test when we delete and is not present."""
         path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_DELETE])
         self.assertTrue(path not in watch._subdirs)
 
@@ -841,7 +775,7 @@
         """Test when we delete and is present."""
         path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
-        watch = Watch(1, test_path, self.mask, True, None)
+        watch = Watch(1, test_path, None)
         watch._subdirs.add(path)
         watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_DELETE])
         self.assertTrue(path not in watch._subdirs)
@@ -856,7 +790,7 @@
         yield super(TestWatchManager, self).setUp()
         self.parent_path = u'\\\\?\\C:\\'  # a valid windows path
         self.path = self.parent_path + u'path'
-        self.watch = Watch(1, self.path, None, True, None)
+        self.watch = Watch(1, self.path, None)
         self.manager = WatchManager(None)
         self.manager._wdm = {1: self.watch}
 
@@ -884,7 +818,7 @@
 
         self.patch(Watch, "stop_watching", fake_stop_watching)
         second_path = self.parent_path + u"second_path"
-        second_watch = Watch(2, second_path, None, True, None)
+        second_watch = Watch(2, second_path, None)
         self.manager._wdm[2] = second_watch
         d = self.manager.stop()
         self.assertFalse(d.called, "Not fired before all watches end")
@@ -928,19 +862,10 @@
         self.manager._wdm = {}
 
         mask = 'bit_mask'
-        auto_add = True
-        self.manager.add_watch(self.path, mask, auto_add=auto_add)
+        self.manager.add_watch(self.path, mask)
         self.assertEqual(1, len(self.manager._wdm))
         self.assertTrue(self.was_called, 'The watch start was not called.')
-        self.assertEqual(self.path + os.path.sep, self.manager._wdm[0]._path)
-        self.assertEqual(mask, self.manager._wdm[0]._mask)
-        self.assertEqual(auto_add, self.manager._wdm[0]._auto_add)
-
-    def test_update_present_watch(self):
-        """Test the update of a present watch."""
-        mask = 'mask'
-        self.assertRaises(NotImplementedError, self.manager.update_watch,
-                                                                 1, mask)
+        self.assertEqual(self.path + os.path.sep, self.manager._wdm[0].path)
 
     def test_get_watch_present_wd(self):
         """Test that the correct path is returned."""
@@ -988,7 +913,8 @@
         self.manager.rm_path(self.path)
         self.assertEqual(self.watch, self.manager._wdm.get(1))
         self.watch._watching = True
-        self.watch._process_events([(1, os.path.join(self.path, 'test'))])
+        self.watch.platform_watch._process_events(
+                [(1, os.path.join(self.path, 'test'))])
         self.assertEqual(0, len(events))
 
     def test_rm_child_path(self):
@@ -1004,11 +930,12 @@
         self.manager.rm_path(child)
         self.assertEqual(self.watch, self.manager._wdm[1])
         # assert that the correct event is ignored
-        self.watch._watching = True
-        self.watch._process_events([(1, os.path.join('child', 'test'))])
+        self.watch.platform_watch.watching = True
+        self.watch.platform_watch._process_events(
+                [(1, os.path.join('child', 'test'))])
         self.assertEqual(0, len(events))
         # assert that other events are not ignored
-        self.watch._process_events([(1, 'test')])
+        self.watch.platform_watch._process_events([(1, 'test')])
         self.assertEqual(1, len(events))
 
 
@@ -1160,9 +1087,9 @@
         """Test that we do indeed ignore the correct paths."""
         not_ignored = 'test'
         ignored = not_ignored + '.lnk'
-        self.assertFalse(self.processor.platform_is_ignored(not_ignored),
+        self.assertFalse(filesystem_notifications.path_is_ignored(not_ignored),
                          'Only links should be ignored.')
-        self.assertTrue(self.processor.platform_is_ignored(ignored),
+        self.assertTrue(filesystem_notifications.path_is_ignored(ignored),
                          'Links should be ignored.')
 
     def test_is_ignored(self):

=== modified file 'ubuntuone/platform/filesystem_notifications/__init__.py'
--- ubuntuone/platform/filesystem_notifications/__init__.py	2012-06-28 16:44:01 +0000
+++ ubuntuone/platform/filesystem_notifications/__init__.py	2012-07-11 15:52:18 +0000
@@ -31,14 +31,10 @@
 import sys
 
 
-if sys.platform == "win32":
-    from ubuntuone.platform.filesystem_notifications import windows
-    FilesystemMonitor = windows.FilesystemMonitor
-    _GeneralINotifyProcessor = windows.NotifyProcessor
-elif sys.platform == "darwin":
-    from ubuntuone.platform.filesystem_notifications import darwin
-    FilesystemMonitor = darwin.FilesystemMonitor
-    _GeneralINotifyProcessor = darwin.NotifyProcessor
+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

=== modified file 'ubuntuone/platform/filesystem_notifications/common.py'
--- ubuntuone/platform/filesystem_notifications/common.py	2012-06-28 16:44:01 +0000
+++ ubuntuone/platform/filesystem_notifications/common.py	2012-07-11 15:52:18 +0000
@@ -30,6 +30,7 @@
 
 import logging
 import os
+import sys
 
 from twisted.internet import defer
 
@@ -44,9 +45,9 @@
     IN_IGNORED,
     IN_ISDIR,
     IN_DELETE,
-    IN_MODIFY as in_modify,
     IN_MOVED_FROM,
-    IN_MOVED_TO)
+    IN_MOVED_TO,
+)
 
 from ubuntuone import logger
 
@@ -56,16 +57,28 @@
     os_path,
 )
 
+if sys.platform == 'darwin':
+    from ubuntuone.platform.filesystem_notifications import darwin
+    source = darwin
+elif sys.platform == 'win32':
+    from ubuntuone.platform.filesystem_notifications import windows
+    source = windows
+else:
+    raise ImportError('Not supported platform')
+
 # a map between the few events that we have on common platforms and those
 # found in pyinotify
-COMMON_ACTIONS = {}
+ACTIONS = source.ACTIONS
 
 # a map of the actions to names so that we have better logs.
-COMMON_ACTIONS_NAMES = {}
-
-# We should have this here, because we use if from other modules that
-# share this, but we need to declare it this way yo avoid flakes issues.
-IN_MODIFY = in_modify
+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 = {
@@ -89,42 +102,50 @@
 class Watch(object):
     """Implement the same functions as pyinotify.Watch."""
 
-    def __init__(self, watch_descriptor, path, mask, auto_add, processor,
-        buf_size=8192):
-        self.log = logging.getLogger('ubuntuone.SyncDaemon.platform.common.' +
-            'filesystem_notifications.Watch')
-        self.log.setLevel(TRACE)
+    def __init__(self, watch_descriptor, path, processor):
+        """Create a new watch."""
+
+        # do ensure that we provide a os.path.sep
+        if not path.endswith(os.path.sep):
+            path += os.path.sep
+        self.path = path
+        self.ignore_paths = []
         self._processor = processor
-        self._buf_size = buf_size
-        self._watching = False
         self._descriptor = watch_descriptor
-        self._auto_add = auto_add
-        self._ignore_paths = []
         self._cookie = None
         self._source_pathname = None
-        self._process_thread = None
-        self._watch_handle = None
         # remember the subdirs we have so that when we have a delete we can
         # check if it was a remove
         self._subdirs = set()
-        # ensure that we work with an abspath and that we can deal with
-        # long paths over 260 chars.
-        if not path.endswith(os.path.sep):
-            path += os.path.sep
-        self._path = os.path.abspath(path)
-        self._mask = mask
-
-    def _process_events_from_filesystem(self, action, file_name, cookie,
-        syncdaemon_path):
+
+        # platform watch used to deal with the platform details
+        self.platform_watch = PlatformWatch(self.path, self.process_events)
+
+        self.log = logging.getLogger('ubuntuone.SyncDaemon.platform.common.' +
+            'filesystem_notifications.Watch')
+        self.log.setLevel(TRACE)
+
+    def process_events(self, action, file_name, cookie, syncdaemon_path):
         """Process the events from the queue."""
+        # do not process events when the watch was stopped
+        if not self.platform_watch.watching:
+            return
+
+        # do not process those events that should be ignored
+        if any([file_name.startswith(path)
+                for path in self.ignore_paths]):
+            return
+
         # map the filesystem events to the pyinotify ones, tis is dirty but
         # makes the multiplatform better, linux was first :P
-        full_dir_path = os.path.join(self._path, file_name)
+        full_dir_path = os.path.join(self.path, file_name)
         is_dir = self._path_is_dir(full_dir_path)
+
         if is_dir:
             # we need to update the list of subdirs that we have
             self._update_subdirs(full_dir_path, action)
-        mask = COMMON_ACTIONS[action]
+
+        mask = ACTIONS[action]
         head, tail = os.path.split(file_name)
         if is_dir:
             mask |= IN_ISDIR
@@ -134,14 +155,14 @@
             'mask': mask,
             'name': tail,
             'path': '.'}
-        # by the way in which the win api fires the events we know for
+        # by the way in which the api fires the events we know for
         # sure that no move events will be added in the wrong order, this
         # is kind of hacky, I dont like it too much
-        if COMMON_ACTIONS[action] == IN_MOVED_FROM:
+        if ACTIONS[action] == IN_MOVED_FROM:
             self._cookie = cookie
             self._source_pathname = tail
             event_raw_data['cookie'] = self._cookie
-        if COMMON_ACTIONS[action] == IN_MOVED_TO:
+        if ACTIONS[action] == IN_MOVED_TO:
             event_raw_data['src_pathname'] = self._source_pathname
             event_raw_data['cookie'] = self._cookie
         event = Event(event_raw_data)
@@ -161,9 +182,9 @@
         The given path is considered to be a path and therefore this
         will not be checked.
         """
-        if COMMON_ACTIONS[event] == IN_CREATE:
+        if ACTIONS[event] == IN_CREATE:
             self._subdirs.add(path)
-        elif COMMON_ACTIONS[event] == IN_DELETE and path in self._subdirs:
+        elif ACTIONS[event] == IN_DELETE and path in self._subdirs:
             self._subdirs.remove(path)
 
     @is_valid_os_path(path_indexes=[1])
@@ -187,51 +208,53 @@
         """Add the path of the events to ignore."""
         if not path.endswith(os.path.sep):
             path += os.path.sep
-        if path.startswith(self._path):
-            path = path[len(self._path):]
-            self._ignore_paths.append(path)
+        if path.startswith(self.path):
+            path = path[len(self.path):]
+            self.ignore_paths.append(path)
 
     @is_valid_os_path(path_indexes=[1])
     def remove_ignored_path(self, path):
         """Reaccept path."""
         if not path.endswith(os.path.sep):
             path += os.path.sep
-        if path.startswith(self._path):
-            path = path[len(self._path):]
-            if path in self._ignore_paths:
-                self._ignore_paths.remove(path)
+        if path.startswith(self.path):
+            path = path[len(self.path):]
+            if path in self.ignore_paths:
+                self.ignore_paths.remove(path)
 
+    @defer.inlineCallbacks
     def start_watching(self):
         """Tell the watch to start processing events."""
-        for current_child in os.listdir(self._path):
-            full_child_path = os.path.join(self._path, current_child)
+        for current_child in os.listdir(self.path):
+            full_child_path = os.path.join(self.path, current_child)
             if os.path.isdir(full_child_path):
                 self._subdirs.add(full_child_path)
         # start to diff threads, one to watch the path, the other to
         # process the events.
         self.log.debug('Start watching path.')
-        self._watching = True
+        yield self.platform_watch.start_watching()
 
     def stop_watching(self):
         """Tell the watch to stop processing events."""
-        self.log.info('Stop watching %s', self._path)
-        self._watching = False
+        self.log.info('Stop watching %s', self.path)
+        self.platform_watch.watching = False
         self._subdirs = set()
-
-    def update(self, mask, auto_add=False):
-        """Update the info used by the watcher."""
-        self.log.debug('update(%s, %s)', mask, auto_add)
-        self._mask = mask
-        self._auto_add = auto_add
-
-    @property
-    def path(self):
-        """Return the patch watched."""
-        return self._path
-
-    @property
-    def auto_add(self):
-        return self._auto_add
+        return self.platform_watch.stop_watching()
+
+    @property
+    def watching(self):
+        """Return if we are watching."""
+        return self.platform_watch.watching
+
+    @property
+    def started(self):
+        """A deferred that will be called when the watch is running."""
+        return self.platform_watch.started
+
+    @property
+    def stopped(self):
+        """A deferred fired when the watch thread has finished."""
+        return self.platform_watch.stopped
 
 
 class WatchManager(object):
@@ -243,25 +266,48 @@
 
     def __init__(self, processor):
         """Init the manager to keep trak of the different watches."""
-        self._processor = processor
         self.log = logging.getLogger('ubuntuone.SyncDaemon.platform.common.'
             + 'filesystem_notifications.WatchManager')
         self.log.setLevel(TRACE)
+        self._processor = processor
+        # use the platform manager to perform the actual actions
+        self.manager = PlatformWatchManager(self.log)
         self._wdm = {}
-        self._wd_count = 0
         self._ignored_paths = []
 
-    def add_watch(self, path, mask, auto_add=False, quiet=True):
-        """Add a new path to be watch.
+    @defer.inlineCallbacks
+    def _add_single_watch(self, path, mask, quiet=True):
+        """A just one watch."""
+        if path in self._ignored_paths:
+            # simply removed it from the filter
+            self._ignored_paths.remove(path)
+            return
+
+        # we need to add a new watch
+        self.log.debug('add_single_watch(%s, %s, %s)', path, mask, quiet)
+
+        # common code that will ensure that we keep track of the watches
+        watch = Watch(len(self._wdm), path, self._processor)
+        self._wdm[len(self._wdm)] = watch
+        yield watch.start_watching()
+
+        # trust that the platform watch manager to do the rest of the start
+        # operations
+        defer.returnValue(self.manager.add_watch(watch))
+
+    @is_valid_os_path(path_indexes=[1])
+    def add_watch(self, path, mask, quiet=True):
+        """Add a new path to be watched.
 
         The method will ensure that the path is not already present.
         """
-        raise NotImplementedError("Not implemented on this platform.")
-
-    def stop(self):
-        """Close the manager and stop all watches."""
-        # Should be implemented for each platform
-        raise NotImplementedError("Not implemented on this platform.")
+        wd = self.get_wd(path)
+        if wd is None:
+            self.log.debug('Adding single watch on %r', path)
+            return self._add_single_watch(path, mask, quiet)
+        else:
+            self.log.debug('Watch already exists on %r', path)
+            return self._wdm[wd].started
 
     def get_watch(self, wd):
         """Return the watch with the given descriptor."""
@@ -274,30 +320,13 @@
             watch = self._wdm[wd]
             yield watch.stop_watching()
             del self._wdm[wd]
+            # trust that the platform watch manager will do the rest of the
+            # operations needed to delete a watch
+            self.manager.del_watch(watch)
             self.log.debug('Watch %s removed.', wd)
         except KeyError, e:
             logging.error(str(e))
 
-    def _add_single_watch(self, path, mask, auto_add=False, quiet=True):
-        if path in self._ignored_paths:
-            # simply removed it from the filter
-            self._ignored_paths.remove(path)
-            return
-        # we need to add a new watch
-        self.log.debug('add_single_watch(%s, %s, %s, %s)', path, mask,
-            auto_add, quiet)
-
-        return self._adding_watch(path, mask, auto_add)
-
-    def _adding_watch(self, path, mask, auto_add):
-        """Add the watch to the dict and start it."""
-        # This should be implemented for each OS
-        raise NotImplementedError("Not implemented on this platform.")
-
-    def update_watch(self, wd, mask=None, rec=False,
-                     auto_add=False, quiet=True):
-        raise NotImplementedError("Not implemented on this platform.")
-
     @is_valid_os_path(path_indexes=[1])
     def get_wd(self, path):
         """Return the watcher that is used to watch the given path."""
@@ -305,8 +334,7 @@
             path = 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 and self._wdm[current_wd].auto_add))
+            if ((watch_path == path or watch_path in path)
                     and path not in self._ignored_paths):
                 return current_wd
 
@@ -323,6 +351,9 @@
             watch = self._wdm[wd]
             yield watch.stop_watching()
             del self._wdm[wd]
+            # trust that the platform watch manager will do the rest of the
+            # operations needed to delete a watch
+            self.manager.rm_watch(watch)
         except KeyError, err:
             self.log.error(str(err))
             if not quiet:
@@ -336,6 +367,16 @@
             self.log.debug('Adding exclude filter for %r', path)
             self._wdm[wd].ignore_path(path)
 
+    @defer.inlineCallbacks
+    def stop(self):
+        """Close the manager and stop all watches."""
+        self.log.debug('Stopping watches.')
+        for current_wd in self._wdm:
+            watch = self._wdm[current_wd]
+            yield self.manager.stop_watch(watch)
+            self.log.debug('Stopping Watch on %r.', watch.path)
+        yield self.manager.stop()
+
 
 class NotifyProcessor(ProcessEvent):
     """Processor that takes care of dealing with the events.
@@ -350,7 +391,7 @@
             GeneralINotifyProcessor)
         self.general_processor = GeneralINotifyProcessor(monitor,
             self.handle_dir_delete, NAME_TRANSLATIONS,
-            self.platform_is_ignored, IN_IGNORED, ignore_config=ignore_config)
+            path_is_ignored, IN_IGNORED, ignore_config=ignore_config)
         self.held_event = None
 
     def rm_from_mute_filter(self, event, paths):
@@ -361,11 +402,6 @@
         """Add an event and path(s) to the mute filter."""
         self.general_processor.add_to_mute_filter(event, paths)
 
-    def platform_is_ignored(self, path):
-        """Should we ignore this path in the current platform.?"""
-        # This should be implemented in each platform
-        raise NotImplementedError("Not implemented on this platform.")
-
     @is_valid_syncdaemon_path(path_indexes=[1])
     def is_ignored(self, path):
         """Should we ignore this path?"""
@@ -552,8 +588,8 @@
         self.log.setLevel(TRACE)
         self.fs = fs
         self.eq = eq
-        # You will need to create the NotifyProcessor and WatchManager
-        # in each OS-specific implementation
+        self._processor = NotifyProcessor(self, ignore_config)
+        self._watch_manager = WatchManager(self._processor)
 
     def add_to_mute_filter(self, event, **info):
         """Add info to mute filter in the processor."""
@@ -579,12 +615,11 @@
         # the logic to check if the watch is already set
         # is all in WatchManager.add_watch
         return self._watch_manager.add_watch(dirpath,
-                             self.filesystem_monitor_mask, auto_add=True)
+            self.filesystem_monitor_mask)
 
     def add_watches_to_udf_ancestors(self, volume):
         """Add a inotify watch to volume's ancestors if it's an UDF."""
-        # Should be implemented in each OS if necessary
-        raise NotImplementedError("Not implemented on this platform.")
+        return defer.succeed(True)
 
     def is_frozen(self):
         """Checks if there's something frozen."""

=== modified file 'ubuntuone/platform/filesystem_notifications/darwin.py'
--- ubuntuone/platform/filesystem_notifications/darwin.py	2012-06-28 17:21:30 +0000
+++ ubuntuone/platform/filesystem_notifications/darwin.py	2012-07-11 15:52:18 +0000
@@ -33,37 +33,57 @@
 import fsevents
 from twisted.internet import defer, reactor
 
-from ubuntuone.platform.filesystem_notifications import common
-
+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
-common.COMMON_ACTIONS = {
-  fsevents.IN_CREATE: common.IN_CREATE,
-  fsevents.IN_DELETE: common.IN_DELETE,
-  fsevents.IN_MODIFY: common.IN_MODIFY,
-  fsevents.IN_MOVED_FROM: common.IN_MOVED_FROM,
-  fsevents.IN_MOVED_TO: common.IN_MOVED_TO,
+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.
-common.COMMON_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',
+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(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
+
+
 # The implementation of the code that is provided as the pyinotify substitute
-class Watch(common.Watch):
+class Watch(object):
     """Implement the same functions as pyinotify.Watch."""
 
-    def __init__(self, watch_descriptor, path, mask, auto_add, processor,
-        buf_size=8192):
-        super(Watch, self).__init__(watch_descriptor, path, mask, auto_add,
-                                    processor, buf_size)
+    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)
@@ -74,97 +94,70 @@
 
     def _process_events_in_main_thread(self, event):
         """Process the events from the queue."""
-        # do not do it if we stop watching and the events are empty
-        if not self._watching:
-            return
-
         action, cookie, file_name = (event.mask, event.cookie, event.name)
-        if any([file_name.startswith(path)
-                    for path in self._ignore_paths]):
-            return
-        syncdaemon_path = os.path.join(self._path, file_name)
-        self._process_events_from_filesystem(action, file_name, cookie,
-                                             syncdaemon_path)
+
+        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)
+        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(common.WatchManager):
+        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, processor):
+    def __init__(self, log):
         """Init the manager to keep track of the different watches."""
-        super(WatchManager, self).__init__(processor)
+        self.log = log
         self.observer = fsevents.Observer()
         self.observer.start()
 
-    def add_watch(self, path, mask, auto_add=False, quiet=True):
-        """Add a new path to be watched.
-
-        The method will ensure that the path is not already present.
-        """
-        if not isinstance(path, str):
-            e = NotImplementedError("No implementation on this platform.")
-            return defer.fail(e)
-        wd = self.get_wd(path)
-        if wd is None:
-            self.log.debug('Adding single watch on %r', path)
-            return self._add_single_watch(path, mask, auto_add, quiet)
-        else:
-            self.log.debug('Watch already exists on %r', path)
-            return self._wdm[wd].started
-
     def __del__(self):
         """Stop the observer."""
         self.observer.stop()
 
+    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):
-        """Close the manager and stop all watches."""
-        self.log.debug('Stopping watches.')
-        for current_wd in self._wdm:
-            self._wdm[current_wd].stop_watching()
-            self.observer.unschedule(self._wdm[current_wd].stream)
-            self.log.debug('Stopping Watch on %r.', self._wdm[current_wd].path)
+        """Stop the manager."""
         self.observer.stop()
 
-    def del_watch(self, wd):
-        """Delete the watch with the given descriptor."""
-        watch = self.get_watch(wd)
+    def del_watch(self, watch):
+        """Delete the watch and clean resources."""
         self.observer.unschedule(watch.stream)
-        return super(WatchManager, self).del_watch(wd)
 
-    def _adding_watch(self, path, mask, auto_add):
+    def add_watch(self, watch):
         """This method perform actually the action of registering the watch."""
-        watch = Watch(self._wd_count, path, mask, auto_add, self._processor)
-        self._wdm[self._wd_count] = watch
-        self._wdm[self._wd_count].start_watching()
-        self.observer.schedule(self._wdm[self._wd_count].stream)
-        self._wd_count += 1
-        return defer.succeed(True)
+        self.observer.schedule(watch.platform_watch.stream)
+        return True
 
-    def rm_watch(self, wd, rec=False, quiet=True):
+    def rm_watch(self, watch):
         """Remove the the watch with the given wd."""
-        watch = self.get_watch(wd)
-        self.observer.unschedule(watch.stream)
-        super(WatchManager, self).del_watch(wd, rec, quiet)
-
-
-class FilesystemMonitor(object):
-    """Empty implementation of FilesystemMonitor"""
-
-
-class NotifyProcessor(object):
-    """Empty implementation of NotifyProcessor"""
+        self.observer.unschedule(watch.platform_watch.stream)

=== modified file 'ubuntuone/platform/filesystem_notifications/windows.py'
--- ubuntuone/platform/filesystem_notifications/windows.py	2012-06-28 16:44:01 +0000
+++ ubuntuone/platform/filesystem_notifications/windows.py	2012-07-11 15:52:18 +0000
@@ -28,7 +28,9 @@
 # files in the program, then also delete it here.
 """File notifications on windows."""
 
+import logging
 import os
+
 from uuid import uuid4
 
 from twisted.internet import defer, reactor
@@ -66,25 +68,31 @@
     get_syncdaemon_valid_path,
 )
 
-from ubuntuone.platform.filesystem_notifications import common
-
-# a map between the few events that we have on common platforms and those
-# found in pyinotify
-common.COMMON_ACTIONS = {
-  1: common.IN_CREATE,
-  2: common.IN_DELETE,
-  3: common.IN_MODIFY,
-  4: common.IN_MOVED_FROM,
-  5: common.IN_MOVED_TO,
+from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
+    IN_CREATE,
+    IN_DELETE,
+    IN_MODIFY,
+    IN_MOVED_FROM,
+    IN_MOVED_TO,
+)
+
+
+# map between windows events and pyinotify
+ACTIONS = {
+    1: IN_CREATE,
+    2: IN_DELETE,
+    3: IN_MODIFY,
+    4: IN_MOVED_FROM,
+    5: IN_MOVED_TO,
 }
 
 # a map of the actions to names so that we have better logs.
-common.COMMON_ACTIONS_NAMES = {
-  1: 'IN_CREATE',
-  2: 'IN_DELETE',
-  3: 'IN_MODIFY',
-  4: 'IN_MOVED_FROM',
-  5: 'IN_MOVED_TO',
+ACTIONS_NAMES = {
+    1: 'IN_CREATE',
+    2: 'IN_DELETE',
+    3: 'IN_MODIFY',
+    4: 'IN_MOVED_FROM',
+    5: 'IN_MOVED_TO',
 }
 
 
@@ -96,20 +104,43 @@
 
 THREADPOOL_MAX = 20
 
-
-class Watch(common.Watch):
+FILESYSTEM_MONITOR_MASK = FILE_NOTIFY_CHANGE_FILE_NAME | \
+    FILE_NOTIFY_CHANGE_DIR_NAME | \
+    FILE_NOTIFY_CHANGE_ATTRIBUTES | \
+    FILE_NOTIFY_CHANGE_SIZE | \
+    FILE_NOTIFY_CHANGE_LAST_WRITE | \
+    FILE_NOTIFY_CHANGE_SECURITY | \
+    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."""
 
-    def __init__(self, watch_descriptor, path, mask, auto_add, processor,
-        buf_size=8192):
-        super(Watch, self).__init__(watch_descriptor, path, mask, auto_add,
-                                    processor, buf_size)
+    def __init__(self, path, process_events, mask=FILESYSTEM_MONITOR_MASK,
+                 buf_size=8192):
+        self.path = os.path.abspath(path)
+        self.process_events = process_events
+        self.watching = False
+        self.log = logging.getLogger('ubuntuone.SyncDaemon.platform.windows.' +
+            'filesystem_notifications.Watch')
+        self.log.setLevel(logging.DEBUG)
+        self._buf_size = buf_size
+        self._mask = mask
+        self.ignore_paths = []
+        self._watch_handle = None
+
         self._wait_stop = CreateEvent(None, 0, 0, None)
         self._overlapped = OVERLAPPED()
         self._overlapped.hEvent = CreateEvent(None, 0, 0, None)
-        # remember the subdirs we have so that when we have a delete we can
-        # check if it was a remove
-        self._subdirs = set()
         # this deferred is fired when the watch has started monitoring
         # a directory from a thread
         self._watch_started_deferred = defer.Deferred()
@@ -118,22 +149,13 @@
 
     def _process_events(self, events):
         """Process the events from the queue."""
-        # do not do it if we stop watching and the events are empty
-        if not self._watching:
-            return
-
         # we transform the events to be the same as the one in pyinotify
         # and then use the proc_fun
         for action, file_name in events:
-            if any([file_name.startswith(path)
-                        for path in self._ignore_paths]):
-                continue
-            # map the windows events to the pyinotify ones, tis is dirty but
-            # makes the multiplatform better, linux was first :P
             syncdaemon_path = get_syncdaemon_valid_path(
-                                        os.path.join(self._path, file_name))
-            self._process_events_from_filesystem(action, file_name,
-                str(uuid4()), syncdaemon_path)
+                                        os.path.join(self.path, file_name))
+            self.process_events(action, file_name, str(uuid4()),
+                    syncdaemon_path)
 
     def _call_deferred(self, f, *args):
         """Executes the deferred call avoiding possible race conditions."""
@@ -151,12 +173,12 @@
     def _watch(self):
         """Watch a path that is a directory."""
         self.log.debug('Adding watch for %r (exists? %r is dir? %r).',
-                       self._path,
-                       os.path.exists(self._path), os.path.isdir(self._path))
+                       self.path,
+                       os.path.exists(self.path), os.path.isdir(self.path))
         # we are going to be using the ReadDirectoryChangesW whihc requires
         # a directory handle and the mask to be used.
         self._watch_handle = CreateFileW(
-            self._path,
+            self.path,
             FILE_LIST_DIRECTORY,
             FILE_SHARE_READ | FILE_SHARE_WRITE,
             None,
@@ -184,7 +206,7 @@
             ReadDirectoryChangesW(
                 handle,
                 buf,
-                self._auto_add,
+                True,  # Always watch children
                 self._mask,
                 self._overlapped,
             )
@@ -204,20 +226,20 @@
             # lets ead the data and store it in the results
             events = FILE_NOTIFY_INFORMATION(buf, data)
             self.log.debug('Got from ReadDirectoryChangesW %r.',
-                    [(common.COMMON_ACTIONS_NAMES[action], path) \
+                    [(ACTIONS_NAMES[action], path) \
                     for action, path in events])
             reactor.callFromThread(self._process_events, events)
 
     def start_watching(self):
         """Tell the watch to start processing events."""
-        super(Watch, self).start_watching()
+        self.watching = True
         reactor.callInThread(self._watch_wrapper)
         return self._watch_started_deferred
 
     def stop_watching(self):
         """Tell the watch to stop processing events."""
-        super(Watch, self).stop_watching()
         SetEvent(self._wait_stop)
+        self.watching = False
         return self.stopped
 
     @property
@@ -231,82 +253,39 @@
         return self._watch_stopped_deferred
 
 
-class WatchManager(common.WatchManager):
-
-    @common.is_valid_os_path(path_indexes=[1])
-    def add_watch(self, path, mask, auto_add=False, quiet=True):
-        """Add a new path to be watch.
-
-        The method will ensure that the path is not already present.
-        """
-        if not isinstance(path, unicode):
-            e = NotImplementedError("No implementation on this platform.")
-            return defer.fail(e)
-        wd = self.get_wd(path)
-        if wd is None:
-            self.log.debug('Adding single watch on %r', path)
-            return self._add_single_watch(path, mask, auto_add, quiet)
-        else:
-            self.log.debug('Watch already exists on %r', path)
-            return self._wdm[wd].started
+class WatchManager(object):
+    """Implement the same functions as pyinotify.WatchManager.
+
+    All paths passed to methods in this class should be windows paths.
+
+    """
+
+    def __init__(self, log):
+        """Create a new instance."""
+        self.log = log
+        self._wd_count = 0
+
+    def del_watch(self, wd):
+        """Delete the watch with the given descriptor."""
+
+    def stop_watch(self, watch):
+        """Stop a watch."""
+        # decrease the number of watches
+        self._wd_count -= 1
+        return watch.stop_watching()
 
     def stop(self):
         """Close the manager and stop all watches."""
         self.log.debug('Stopping watches.')
-        wait_list = []
-        for current_wd in self._wdm:
-            wait_list.append(self._wdm[current_wd].stop_watching())
-            self.log.debug('Stopping Watch on %r.', self._wdm[current_wd].path)
-        return defer.DeferredList(wait_list)
-
-    def _adding_watch(self, path, mask, auto_add):
+        return defer.succeed(True)
+
+    def rm_watch(self, watch):
+        """Stop the Watch."""
+        self._wd_count -= 1
+        return defer.succeed(True)
+
+    def add_watch(self, watch):
         # adjust the number of threads based on the UDFs watched
-        watch = Watch(self._wd_count, path, mask, auto_add, self._processor)
+        self._wd_count += 1
         reactor.suggestThreadPoolSize(THREADPOOL_MAX + self._wd_count + 1)
-        self._wdm[self._wd_count] = watch
-        d = self._wdm[self._wd_count].start_watching()
-        self._wd_count += 1
-        return d
-
-
-class NotifyProcessor(common.NotifyProcessor):
-    """
-    Processor that takes care of dealing with the events.
-
-    Also, they must not be literal paths, that is the \\?\ prefix should not be
-    in the path.
-    """
-
-    @is_valid_syncdaemon_path(path_indexes=[1])
-    def platform_is_ignored(self, path):
-        """Should we ignore this path in the current platform.?"""
-        # don't support links yet
-        if path.endswith('.lnk'):
-            return True
-        return False
-
-
-class FilesystemMonitor(common.FilesystemMonitor):
-    """Manages the signals from filesystem."""
-
-    def __init__(self, eq, fs, ignore_config=None, timeout=1):
-        super(FilesystemMonitor, self).__init__(eq, fs, ignore_config, timeout)
-        self._processor = NotifyProcessor(self, ignore_config)
-        self._watch_manager = WatchManager(self._processor)
-        # the default mask to be used in the watches
-        # added by the FilesystemMonitor class
-        self.filesystem_monitor_mask = FILE_NOTIFY_CHANGE_FILE_NAME | \
-            FILE_NOTIFY_CHANGE_DIR_NAME | \
-            FILE_NOTIFY_CHANGE_ATTRIBUTES | \
-            FILE_NOTIFY_CHANGE_SIZE | \
-            FILE_NOTIFY_CHANGE_LAST_WRITE | \
-            FILE_NOTIFY_CHANGE_SECURITY | \
-            FILE_NOTIFY_CHANGE_LAST_ACCESS
-
-    def add_watches_to_udf_ancestors(self, volume):
-        """Add a inotify watch to volume's ancestors if it's an UDF."""
-        # There is no need to add the watches to the ancestors
-        # so we will always return true. The reason for this is that the
-        # handles that we open stop the user from renaming the ancestors of
-        # the UDF, for a user to do that he has to unsync the udf first
-        return defer.succeed(True)
+        return True

=== modified file 'ubuntuone/platform/os_helper/darwin.py'
--- ubuntuone/platform/os_helper/darwin.py	2012-06-27 13:51:09 +0000
+++ ubuntuone/platform/os_helper/darwin.py	2012-07-11 15:52:18 +0000
@@ -127,8 +127,13 @@
 
 
 def os_path(path_indexes=None):
+    if path_indexes is None:
+        path_indexes = [0]
+
     def decorator(func):
         def wrapped(*args, **kwargs):
+            for i in path_indexes:
+                assert isinstance(args[i], str), 'Path %r should be str.'
             return func(*args, **kwargs)
         return wrapped
     return decorator