Merge lp:~diegosarmentero/ubuntuone-client/darwin4-fsevents into lp:ubuntuone-client

[Diego Sarmentero]

- Filesystem Notifications complete for darwin (LP: #1013323).

Now you can execute:
./run-mac-tests tests/platform/filesystem_notifications/

[lp:~diegosarmentero/ubuntuone-client/darwin4-fsevents]

1292. By Diego Sarmentero on 2012-07-03

removing unnecesary line

1293. By Diego Sarmentero on 2012-07-03

reverting

[Alejandro J. Cura (alecu)]

The branch looks mostly fine.

A few questions, though:

 * Why is test_file_moved_from_partial skipped? I think this is a critical operation that should be tested.

 * Why is there a test that still uses time.sleep? As mentioned in previous branches we should not be using sleep at all in tests.

And some fixes needed, too:

It looks wrong to import fsevents in /platform/filesystem_notifications/__init__.py, so please, move each platform specific definition of EVENT_CODES to ubuntuone.platform.filesystem_notifications.windows and .darwin

---

Lines 827 and 828 are duplicated.

---

Please move the logic in these few lines to a function, add some unit tests for it, and use it from both places:

837 + index = 0
838 + if not self._path.endswith(os.path.sep):
839 + index = 1
840 + path = path[len(self._path) + index:]

review: Needs Information

[lp:~diegosarmentero/ubuntuone-client/darwin4-fsevents]

1294. By Diego Sarmentero on 2012-07-10

merge

1295. By Diego Sarmentero on 2012-07-10

fixing darwin tests

[Manuel de la Peña (mandel)]

The diff is misleading because it should depend on lp:~mandel/ubuntuone-client/clean-fsevents. Diego can you do a resummit with the correct dependency so that we are not scared regading the size :)

[lp:~diegosarmentero/ubuntuone-client/darwin4-fsevents]

1296. By Diego Sarmentero on 2012-07-11

removing time.sleep

1297. By Diego Sarmentero on 2012-07-12

adding join on stop

1298. By Diego Sarmentero on 2012-07-12

moving patch to setUp

1299. By Diego Sarmentero on 2012-07-12

reverting

Unmerged revisions

=== 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-10 21:28:20 +0000
@@ -33,7 +33,9 @@
 import tempfile
 import thread
 import time
+import itertools
 
+import fsevents
 from twisted.internet import defer
 
 from contrib.testing.testcase import BaseTwistedTestCase
@@ -41,20 +43,25 @@
 from ubuntuone.platform.filesystem_notifications import (
     darwin as filesystem_notifications,
 )
-from ubuntuone.platform.filesystem_notifications.darwin import (
+from ubuntuone.platform.filesystem_notifications.common import (
+    NotifyProcessor,
     Watch,
     WatchManager,
 )
 from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
     EventsCodes,
     ProcessEvent,
+    IN_CLOSE_WRITE,
     IN_CREATE,
     IN_DELETE,
+    IN_OPEN,
 )
+from tests.platform.filesystem_notifications import BaseFSMonitorTestCase
+
 
 # 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
 
 
@@ -136,6 +143,7 @@
         yield super(TestWatch, self).setUp()
         self.basedir = self.mktemp('test_root')
         self.mask = None
+        self.stream = None
         self.memento = MementoHandler()
         self.memento.setLevel(logging.DEBUG)
         self.raw_events = []
@@ -148,16 +156,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 +176,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 +199,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 +221,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 +245,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 +269,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 +295,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 +323,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 +366,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 +396,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 +424,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 +467,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 +493,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 +510,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 +519,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 +529,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 +552,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 +560,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 +579,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 +591,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 +612,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 +620,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 +640,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 +654,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 +667,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 +689,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 +697,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 +707,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 +717,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 +725,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 +733,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 +744,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 +752,636 @@
         """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)
+
+
+class TestWatchManager(BaseTwistedTestCase):
+    """Test the watch manager."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set each of the tests."""
+        yield super(TestWatchManager, self).setUp()
+        self.parent_path = '/Users/username/'
+        self.path = self.parent_path + 'path'
+        self.watch = Watch(1, self.path, None)
+        self.manager = WatchManager(None)
+        self.manager._wdm = {1: self.watch}
+
+    @defer.inlineCallbacks
+    def test_stop(self):
+        """Test that the different watches are stopped."""
+        self.was_called = False
+
+        def fake_stop_watching(watch):
+            """Fake stop watch."""
+            self.was_called = True
+            return defer.succeed(True)
+
+        self.patch(Watch, "stop_watching", fake_stop_watching)
+        self.patch(self.manager.manager.observer, "unschedule", lambda x: None)
+        yield self.manager.stop()
+        self.assertTrue(self.was_called, 'The watch stop should be called.')
+
+    def test_stop_multiple(self):
+        """The watches should became watching=False and the observer stopped."""
+        self.patch(self.manager.manager.observer, "unschedule", lambda x: None)
+        second_path = self.parent_path + "second_path"
+        second_watch = Watch(2, second_path, None)
+        second_watch._watching = True
+        self.manager._wdm[2] = second_watch
+        self.manager.stop()
+        self.assertFalse(second_watch.platform_watch.watching)
+        self.assertEqual(second_watch._subdirs, set())
+        # Give time to the thread to be finished.
+        time.sleep(0.5)
+        self.assertFalse(self.manager.manager.observer.is_alive())
+
+    def test_get_present_watch(self):
+        """Test that we can get a Watch using is wd."""
+        self.assertEqual(self.watch, self.manager.get_watch(1))
+
+    def test_get_missing_watch(self):
+        """Test that we get an error when trying to get a missing wd."""
+        self.assertRaises(KeyError, self.manager.get_watch, (1,))
+
+    @defer.inlineCallbacks
+    def test_delete_present_watch(self):
+        """Test that we can remove a present watch."""
+        self.was_called = False
+
+        def stop_watching():
+            """Fake stop watch."""
+            self.was_called = True
+            return defer.succeed(True)
+
+        def fake_unschedule(s):
+            """Fake function that should receive a Stream object."""
+            self.stream = s
+
+        self.patch(self.manager.manager.observer, "unschedule",
+            fake_unschedule)
+
+        self.watch.stop_watching = stop_watching
+        yield self.manager.del_watch(1)
+        self.assertIsInstance(self.stream, fsevents.Stream)
+        self.assertRaises(KeyError, self.manager.get_watch, (1,))
+
+    def test_add_single_watch(self):
+        """Test the addition of a new single watch."""
+        self.was_called = False
+
+        def fake_start_watching(*args):
+            """Fake start watch."""
+            self.was_called = True
+
+        self.patch(Watch, "start_watching", fake_start_watching)
+        self.manager._wdm = {}
+
+        mask = 'bit_mask'
+        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)
+
+    def test_get_watch_present_wd(self):
+        """Test that the correct path is returned."""
+        self.assertEqual(self.path + os.path.sep, self.manager.get_path(1))
+
+    def test_get_watch_missing_wd(self):
+        """Test that the correct path is returned."""
+        self.manager._wdm = {}
+        self.assertEqual(None, self.manager.get_path(1))
+
+    def test_get_wd_exact_path(self):
+        """Test the wd is returned when there is a watch for the path."""
+        self.assertEqual(1, self.manager.get_wd(self.path))
+
+    def test_get_wd_child_path(self):
+        """Test the wd is returned when we have a child path."""
+        child = os.path.join(self.path, 'child')
+        self.assertEqual(1, self.manager.get_wd(child))
+
+    def test_get_wd_unwatched(self):
+        """A watch on an unwatched path returns None."""
+        self.assertEqual(None, self.manager.get_wd(self.parent_path))
+
+    def test_rm_present_wd(self):
+        """Test the removal of a present watch."""
+        self.patch(self.watch, "stop_watching", lambda: None)
+        self.patch(self.manager.manager.observer, "unschedule", lambda x: None)
+        self.manager.rm_watch(1)
+        self.assertEqual(None, self.manager._wdm.get(1))
+
+    def test_rm_root_path(self):
+        """Test the removal of a root path."""
+        events = []
+
+        def fake_processor(event):
+            """Memorize the processed events."""
+            events.append(event.pathname)
+
+        self.watch._processor = fake_processor
+        self.manager.rm_path(self.path)
+        self.assertEqual(self.watch, self.manager._wdm.get(1))
+        self.watch._watching = True
+        event = FakeFileEvent(256, None, os.path.join(self.path, 'test'))
+        self.watch.platform_watch._process_events(event)
+        self.assertEqual(0, len(events))
+
+    def test_rm_child_path(self):
+        """Test the removal of a child path."""
+        events = []
+
+        def fake_processor(event):
+            """Memorize the processed events."""
+            events.append(event.pathname)
+
+        self.patch(filesystem_notifications.reactor, 'callFromThread',
+            lambda x, e: x(e))
+
+        self.watch._processor = fake_processor
+        child = os.path.join(self.path, 'child')
+        self.manager.rm_path(child)
+        self.assertEqual(self.watch, self.manager._wdm[1])
+        # assert that the correct event is ignored
+        self.watch.platform_watch.watching = True
+        event = FakeFileEvent(256, None, os.path.join('child', 'test'))
+        self.watch.platform_watch._process_events(event)
+        self.assertEqual(0, len(events))
+        # assert that other events are not ignored
+        event2 = FakeFileEvent(256, None, 'test')
+        self.watch.platform_watch._process_events(event2)
+        self.assertEqual(1, len(events))
+
+
+class TestWatchManagerAddWatches(BaseTwistedTestCase):
+    """Test the watch manager."""
+    timeout = 5
+
+    def test_add_watch_twice(self):
+        """Adding a watch twice succeeds when the watch is running."""
+        self.patch(Watch, "start_watching", lambda self: None)
+        manager = WatchManager(None)
+        # no need to stop watching because start_watching is fake
+
+        path = '/Users/username/path'
+        mask = 'fake bit mask'
+        d1 = manager.add_watch(path, mask)
+        d2 = manager.add_watch(path, mask)
+
+        self.assertTrue(d1.result, "Should not be called yet.")
+        self.assertFalse(d2.result, "Should not be called yet.")
+
+
+class FakeEvent(object):
+    """Fake event."""
+
+    def __init__(self, wd=0, dir=True, name=None, path=None, pathname=None,
+                 cookie=None):
+        """Create fake event."""
+        self.dir = dir
+        self.wd = wd
+        self.name = name
+        self.path = path
+        self.pathname = pathname
+        self.cookie = cookie
+
+
+class FakeLog(object):
+    """A fake log that is used by the general processor."""
+
+    def __init__(self):
+        """Create the fake."""
+        self.called_methods = []
+
+    def info(self, *args):
+        """Fake the info call."""
+        self.called_methods.append(('info', args))
+
+
+class FakeGeneralProcessor(object):
+    """Fake implementation of the general processor."""
+
+    def __init__(self):
+        """Create the fake."""
+        self.called_methods = []
+        self.paths_to_return = []
+        self.log = FakeLog()
+        self.share_id = None
+        self.ignore = False
+
+    def rm_from_mute_filter(self, event, paths):
+        """Fake rm_from_mute_filter."""
+        self.called_methods.append(('rm_from_mute_filter', event, paths))
+
+    def add_to_mute_filter(self, event, paths):
+        """Fake add_to_move_filter."""
+        self.called_methods.append(('add_to_mute_filter', event, paths))
+
+    def is_ignored(self, path):
+        """Fake is_ignored."""
+        self.called_methods.append(('is_ignored', path))
+        return self.ignore
+
+    def push_event(self, event):
+        """Fake push event."""
+        self.called_methods.append(('push_event', event))
+
+    def eq_push(self, event, path=None, path_to=None, path_from=None):
+        """Fake event to push event."""
+        self.called_methods.append(('eq_push', event, path, path_to,
+                                    path_from))
+
+    def get_paths_starting_with(self, fullpath, include_base=False):
+        """Fake get_paths_starting_with."""
+        self.called_methods.append(('get_paths_starting_with', fullpath,
+                                    include_base))
+        return self.paths_to_return
+
+    def get_path_share_id(self, path):
+        """Fake get_path_share_id."""
+        self.called_methods.append(('get_path_share_id', path))
+        return self.share_id
+
+    def rm_watch(self, path):
+        """Fake the remove watch."""
+        self.called_methods.append(('rm_watch', path))
+
+    def freeze_begin(self, path):
+        """Fake freeze_begin"""
+        self.called_methods.append(('freeze_begin', path))
+
+    def freeze_rollback(self):
+        """Fake rollback."""
+        self.called_methods.append(('freeze_rollback',))
+
+    def freeze_commit(self, path):
+        """Fake freeze commit."""
+        self.called_methods.append(('freeze_commit', path))
+
+
+class TestNotifyProcessor(BaseTwistedTestCase):
+    """Test the notify processor."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """set up the diffeent tests."""
+        yield super(TestNotifyProcessor, self).setUp()
+        self.processor = NotifyProcessor(None)
+        self.general = FakeGeneralProcessor()
+        self.processor.general_processor = self.general
+
+    def test_rm_from_mute_filter(self):
+        """Test that we remove the event from the mute filter."""
+        event = 'event'
+        paths = 'paths'
+        self.processor.rm_from_mute_filter(event, paths)
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('rm_from_mute_filter',
+                         self.general.called_methods[0][0])
+        self.assertEqual(event, self.general.called_methods[0][1])
+        self.assertEqual(paths, self.general.called_methods[0][2])
+
+    def test_add_to_mute_filter(self):
+        """Test that we add the path to the mute filter."""
+        event = 'event'
+        paths = 'paths'
+        self.processor.add_to_mute_filter(event, paths)
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('add_to_mute_filter',
+                         self.general.called_methods[0][0])
+        self.assertEqual(event, self.general.called_methods[0][1])
+        self.assertEqual(paths, self.general.called_methods[0][2])
+
+    def test_is_ignored(self):
+        """Test that we do ensure that the path is ignored."""
+        path = 'path'
+        self.processor.is_ignored(path)
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('is_ignored',
+                         self.general.called_methods[0][0])
+        self.assertEqual(path, self.general.called_methods[0][1])
+
+    def test_release_held_event(self):
+        """Test that we do release the held event."""
+        event = 'event'
+        # set the held event to assert that is pushed
+        self.processor.held_event = event
+        self.processor.release_held_event()
+        self.assertEqual('push_event',
+                         self.general.called_methods[0][0])
+        self.assertEqual(event, self.general.called_methods[0][1])
+
+    def test_process_IN_MODIFY_dir(self):
+        """Test that the modify works as exepcted with dirs."""
+        event = FakeEvent(dir=True)
+        self.processor.process_IN_MODIFY(event)
+        # no method should be called
+        self.assertEqual(0, len(self.general.called_methods))
+
+    def test_process_IN_MODIFY_file(self):
+        """Test that the modify works as expected with files."""
+        event = FakeEvent(dir=False, wd=0, name='name',
+                          path='path', pathname='pathname')
+        self.processor.process_IN_MODIFY(event)
+        # we should be getting two different method, and open and a close
+        self.assertEqual(2, len(self.general.called_methods))
+        self.assertEqual('push_event',
+                         self.general.called_methods[0][0])
+        self.assertEqual('push_event',
+                         self.general.called_methods[1][0])
+        self.assertEqual(event.dir, self.general.called_methods[0][1].dir)
+        self.assertEqual(event.wd, self.general.called_methods[0][1].wd)
+        self.assertEqual(event.name, self.general.called_methods[0][1].name)
+        self.assertEqual(event.path, self.general.called_methods[0][1].path)
+        self.assertEqual(event.pathname,
+                         self.general.called_methods[0][1].pathname)
+        self.assertEqual(IN_OPEN,
+                         self.general.called_methods[0][1].mask)
+        self.assertEqual(event.dir, self.general.called_methods[1][1].dir)
+        self.assertEqual(event.wd, self.general.called_methods[1][1].wd)
+        self.assertEqual(event.name, self.general.called_methods[1][1].name)
+        self.assertEqual(event.path, self.general.called_methods[1][1].path)
+        self.assertEqual(event.pathname,
+                         self.general.called_methods[1][1].pathname)
+        self.assertEqual(IN_CLOSE_WRITE,
+                         self.general.called_methods[1][1].mask)
+
+    def test_process_IN_MOVED_FROM(self):
+        """Test that the in moved from works as expected."""
+        event = FakeEvent(dir=False, wd=0, name='name',
+                          path='path', pathname='pathname')
+        self.processor.process_IN_MOVED_FROM(event)
+        self.assertEqual(event, self.processor.held_event)
+
+    def test_process_IN_MOVED_TO_dir(self):
+        """Test that the in moved to works as expected."""
+        event = FakeEvent(wd=0, dir=True, name='name', path='path',
+                          pathname=os.path.join('test', 'pathname'),
+                          cookie='cookie')
+        held_event = FakeEvent(wd=0, dir=True, name='hname', path='hpath',
+                               pathname=os.path.join('test', 'hpathname'),
+                               cookie='cookie')
+        self.general.share_id = 'my_share_id'
+        self.processor.held_event = held_event
+        self.processor.process_IN_MOVED_TO(event)
+        self.assertEqual(5, len(self.general.called_methods))
+        # assert that the ignores are called
+        self.assertEqual('is_ignored', self.general.called_methods[0][0])
+        self.assertEqual(held_event.pathname,
+                         self.general.called_methods[0][1])
+        self.assertEqual('is_ignored', self.general.called_methods[1][0])
+        self.assertEqual(event.pathname, self.general.called_methods[1][1])
+        # assert that we do request the share_id
+        self.assertEqual('get_path_share_id',
+                         self.general.called_methods[2][0])
+        self.assertEqual(os.path.split(event.pathname)[0],
+                         self.general.called_methods[2][1],
+                         'Get the share_id for event')
+        self.assertEqual('get_path_share_id',
+                         self.general.called_methods[3][0])
+        self.assertEqual(os.path.split(held_event.pathname)[0],
+                         self.general.called_methods[3][1],
+                         'Get the share_id for held event.')
+
+        self.assertEqual('eq_push', self.general.called_methods[4][0])
+        self.assertEqual('FS_DIR_MOVE', self.general.called_methods[4][1])
+        self.assertEqual(event.pathname, self.general.called_methods[4][3])
+        self.assertEqual(held_event.pathname,
+                         self.general.called_methods[4][4])
+
+    def test_process_IN_MOVED_TO_file(self):
+        """Test that the in moved to works as expected."""
+        event = FakeEvent(wd=0, dir=False, name='name', path='path',
+                          pathname=os.path.join('test', 'pathname'),
+                          cookie='cookie')
+        held_event = FakeEvent(wd=0, dir=False, name='hname', path='hpath',
+                               pathname=os.path.join('test', 'hpathname'),
+                               cookie='cookie')
+        self.general.share_id = 'my_share_id'
+        self.processor.held_event = held_event
+        self.processor.process_IN_MOVED_TO(event)
+        self.assertEqual(5, len(self.general.called_methods))
+        # assert that the ignores are called
+        self.assertEqual('is_ignored', self.general.called_methods[0][0])
+        self.assertEqual(held_event.pathname,
+                         self.general.called_methods[0][1])
+        self.assertEqual('is_ignored', self.general.called_methods[1][0])
+        self.assertEqual(event.pathname, self.general.called_methods[1][1])
+        # assert that we do request the share_id
+        self.assertEqual('get_path_share_id',
+                         self.general.called_methods[2][0])
+        self.assertEqual(os.path.split(event.pathname)[0],
+                         self.general.called_methods[2][1],
+                         'Get the share_id for event')
+        self.assertEqual('get_path_share_id',
+                         self.general.called_methods[3][0])
+        self.assertEqual(os.path.split(held_event.pathname)[0],
+                         self.general.called_methods[3][1],
+                         'Get the share_id for held event.')
+
+        self.assertEqual('eq_push', self.general.called_methods[4][0])
+        self.assertEqual('FS_FILE_MOVE', self.general.called_methods[4][1])
+        self.assertEqual(event.pathname, self.general.called_methods[4][3])
+        self.assertEqual(held_event.pathname,
+                         self.general.called_methods[4][4])
+
+    def test_fake_create_event_dir(self):
+        """Test that the in moved to works as expected."""
+        event = FakeEvent(wd=0, dir=True, name='name', path='path',
+                          pathname='pathname')
+        self.processor._fake_create_event(event)
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('eq_push', self.general.called_methods[0][0])
+        self.assertEqual('FS_DIR_CREATE', self.general.called_methods[0][1])
+        self.assertEqual(event.pathname, self.general.called_methods[0][2])
+
+    def test_fake_create_event_file(self):
+        """Test that the in moved to works as expected."""
+        event = FakeEvent(wd=0, dir=False, name='name', path='path',
+                          pathname='pathname')
+        self.processor._fake_create_event(event)
+        self.assertEqual(2, len(self.general.called_methods))
+        self.assertEqual('eq_push', self.general.called_methods[0][0])
+        self.assertEqual('FS_FILE_CREATE', self.general.called_methods[0][1])
+        self.assertEqual(event.pathname, self.general.called_methods[0][2])
+        self.assertEqual('eq_push', self.general.called_methods[1][0])
+        self.assertEqual('FS_FILE_CLOSE_WRITE',
+                         self.general.called_methods[1][1])
+        self.assertEqual(event.pathname, self.general.called_methods[1][2])
+
+    def test_fake_delete_create_event_dir(self):
+        """Test that we do fake a delete and a later delete."""
+        event = FakeEvent(wd=0, dir=True, name='name', path='path',
+                          pathname='pathname')
+        held_event = FakeEvent(wd=0, dir=True, name='hname', path='hpath',
+                               pathname='hpathname')
+        self.processor.held_event = held_event
+        self.processor._fake_delete_create_event(event)
+        self.assertEqual(2, len(self.general.called_methods))
+        self.assertEqual('eq_push', self.general.called_methods[0][0])
+        self.assertEqual('FS_DIR_DELETE', self.general.called_methods[0][1])
+        self.assertEqual(held_event.pathname,
+                         self.general.called_methods[0][2])
+        self.assertEqual('eq_push', self.general.called_methods[1][0])
+        self.assertEqual('FS_DIR_CREATE', self.general.called_methods[1][1])
+        self.assertEqual(event.pathname, self.general.called_methods[1][2])
+
+    def test_fake_delete_create_event_file(self):
+        """Test that we do fake a delete and a later delete."""
+        event = FakeEvent(wd=0, dir=False, name='name', path='path',
+                          pathname='pathname')
+        held_event = FakeEvent(wd=0, dir=False, name='hname', path='hpath',
+                               pathname='hpathname')
+        self.processor.held_event = held_event
+        self.processor._fake_delete_create_event(event)
+        self.assertEqual(3, len(self.general.called_methods))
+        self.assertEqual('eq_push', self.general.called_methods[0][0])
+        self.assertEqual('FS_FILE_DELETE', self.general.called_methods[0][1])
+        self.assertEqual(held_event.pathname,
+                         self.general.called_methods[0][2])
+        self.assertEqual('eq_push', self.general.called_methods[1][0])
+        self.assertEqual('FS_FILE_CREATE', self.general.called_methods[1][1])
+        self.assertEqual(event.pathname, self.general.called_methods[1][2])
+        self.assertEqual('eq_push', self.general.called_methods[2][0])
+        self.assertEqual('FS_FILE_CLOSE_WRITE',
+                         self.general.called_methods[2][1])
+        self.assertEqual(event.pathname, self.general.called_methods[2][2])
+
+    def test_process_default_no_held(self):
+        """Test that the process default works as expected."""
+        event = 'event'
+        self.processor.process_default(event)
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('push_event',
+                         self.general.called_methods[0][0])
+        self.assertEqual(event,
+                         self.general.called_methods[0][1])
+
+    def test_process_default_with_held(self):
+        """Test that the process default works as expected."""
+        event = 'event'
+        held_event = 'held_event'
+        self.processor.held_event = held_event
+        self.processor.process_default(event)
+        self.assertEqual(2, len(self.general.called_methods))
+        self.assertEqual('push_event',
+                         self.general.called_methods[0][0])
+        self.assertEqual(held_event,
+                         self.general.called_methods[0][1])
+        self.assertEqual('push_event',
+                         self.general.called_methods[1][0])
+        self.assertEqual(event,
+                         self.general.called_methods[1][1])
+
+    def test_handle_dir_delete_files(self):
+        """Test that the handle dir delete works as expected."""
+        path = 'path'
+        present_files = 'abcde'
+        # create files and dirs to be returned from the get paths
+        for file_name in present_files:
+            self.general.paths_to_return.append((file_name, False))
+        self.processor.handle_dir_delete(path)
+        # there are calls for, rm the watch, get paths and then one per file
+        self.assertEqual(len(present_files) + 2,
+                         len(self.general.called_methods))
+        rm_call = self.general.called_methods.pop(0)
+        self.assertEqual('rm_watch', rm_call[0])
+        self.assertEqual(path, rm_call[1])
+        paths_call = self.general.called_methods.pop(0)
+        self.assertEqual('get_paths_starting_with', paths_call[0])
+        self.assertEqual(path, paths_call[1])
+        self.assertFalse(paths_call[2])
+        # we need to push the delete events in reverse order because we want
+        # to delete children before we delete parents
+        present_files = present_files[::-1]
+        for i, called_method in enumerate(self.general.called_methods):
+            self.assertEqual('eq_push', called_method[0])
+            self.assertEqual('FS_FILE_DELETE', called_method[1])
+            self.assertEqual(present_files[i], called_method[2])
+
+    def test_handle_dir_delete_dirs(self):
+        """Test that the handle dir delete works as expected."""
+        path = 'path'
+        present_files = 'abcde'
+        # create files and dirs to be returned from the get paths
+        for file_name in present_files:
+            self.general.paths_to_return.append((file_name, True))
+        self.processor.handle_dir_delete(path)
+        # there are calls for, rm the watch, get paths and then one per file
+        self.assertEqual(2 * len(present_files) + 2,
+                         len(self.general.called_methods))
+        rm_call = self.general.called_methods.pop(0)
+        self.assertEqual('rm_watch', rm_call[0])
+        self.assertEqual(path, rm_call[1])
+        paths_call = self.general.called_methods.pop(0)
+        self.assertEqual('get_paths_starting_with', paths_call[0])
+        self.assertEqual(path, paths_call[1])
+        self.assertFalse(paths_call[2])
+        # we need to push the delete events in reverse order because we want
+        # to delete children before we delete parents
+        present_files = present_files[::-1]
+
+        # from http://docs.python.org/library/itertools.html#recipes
+        def grouper(n, iterable, fillvalue=None):
+            "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
+            args = [iter(iterable)] * n
+            return itertools.izip_longest(fillvalue=fillvalue, *args)
+
+        for i, called_methods in enumerate(grouper(2,
+                                           self.general.called_methods)):
+            rm_call = called_methods[0]
+            self.assertEqual('rm_watch', rm_call[0])
+            self.assertEqual(present_files[i], rm_call[1])
+            push_call = called_methods[1]
+            self.assertEqual('eq_push', push_call[0])
+            self.assertEqual('FS_DIR_DELETE', push_call[1])
+            self.assertEqual(present_files[i], push_call[2])
+
+    def test_freeze_begin(self):
+        """Test that the freeze being works as expected."""
+        path = 'path'
+        self.processor.freeze_begin(path)
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('freeze_begin',
+                         self.general.called_methods[0][0])
+        self.assertEqual(path, self.general.called_methods[0][1])
+
+    def test_freeze_rollback(self):
+        """Test that the freeze rollback works as expected."""
+        self.processor.freeze_rollback()
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('freeze_rollback',
+                         self.general.called_methods[0][0])
+
+    def test_freeze_commit(self):
+        """Test that the freeze commit works as expected."""
+        path = 'path'
+        self.processor.freeze_commit(path)
+        self.assertEqual(1, len(self.general.called_methods))
+        self.assertEqual('freeze_commit',
+                         self.general.called_methods[0][0])
+        self.assertEqual(path, self.general.called_methods[0][1])
+
+
+class FilesystemMonitorTestCase(BaseFSMonitorTestCase):
+    """Tests for the FilesystemMonitor."""
+
+    def test_add_watch_twice(self):
+        """Check the deferred returned by a second add_watch."""
+        self.patch(Watch, "start_watching", lambda self: None)
+        self.patch(Watch, "started", lambda self: True)
+        manager = WatchManager(None)
+        # no need to stop watching because start_watching is fake
+
+        path = '/Users/username/path'
+        mask = 'fake bit mask'
+        d1 = manager.add_watch(path, mask)
+        d2 = manager.add_watch(path, mask)
+
+        self.assertTrue(d1.result, "Should not be called yet.")
+        self.assertTrue(d2, "Should not be called yet.")

=== modified file 'tests/platform/filesystem_notifications/test_filesystem_notifications.py'
--- tests/platform/filesystem_notifications/test_filesystem_notifications.py	2012-06-28 10:26:50 +0000
+++ tests/platform/filesystem_notifications/test_filesystem_notifications.py	2012-07-10 21:28:20 +0000
@@ -39,6 +39,7 @@
     BaseTwistedTestCase,
     FakeVolumeManager,
     skip_if_win32_missing_fs_event,
+    skip_if_darwin_missing_fs_event,
 )
 from ubuntuone.platform import (
     remove_file,
@@ -264,6 +265,7 @@
         mute_filter = self.monitor._processor.mute_filter
         return sum(len(x) for x in mute_filter._cnt.values())
 
+    @skip_if_darwin_missing_fs_event
     @skip_if_win32_missing_fs_event
     @defer.inlineCallbacks
     def test_file_open(self):
@@ -281,6 +283,7 @@
         test_result = yield self._deferred
         defer.returnValue(test_result)
 
+    @skip_if_darwin_missing_fs_event
     @skip_if_win32_missing_fs_event
     @defer.inlineCallbacks
     def test_file_close_nowrite(self):
@@ -298,6 +301,7 @@
         test_result = yield self._deferred
         defer.returnValue(test_result)
 
+    @skip_if_darwin_missing_fs_event
     @defer.inlineCallbacks
     def test_file_create_close_write(self):
         """Test receiving the create and close_write signals on files."""
@@ -423,6 +427,7 @@
         test_result = yield self._deferred
         defer.returnValue(test_result)
 
+    @skip_if_darwin_missing_fs_event
     @defer.inlineCallbacks
     def test_file_moved_from_partial(self):
         """Test the handling of the FILE_MOVE event when source is partial."""

=== 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-10 21:28:20 +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):
@@ -1394,7 +1321,7 @@
         for file_name in present_files:
             self.general.paths_to_return.append((file_name, False))
         self.processor.handle_dir_delete(path)
-        # there are calls for, rm the wathc, get paths and then one per file
+        # there are calls for, rm the watch, get paths and then one per file
         self.assertEqual(len(present_files) + 2,
                          len(self.general.called_methods))
         rm_call = self.general.called_methods.pop(0)
@@ -1420,7 +1347,7 @@
         for file_name in present_files:
             self.general.paths_to_return.append((file_name, True))
         self.processor.handle_dir_delete(path)
-        # there are calls for, rm the wathc, get paths and then one per file
+        # there are calls for, rm the watch, get paths and then one per file
         self.assertEqual(2 * len(present_files) + 2,
                          len(self.general.called_methods))
         rm_call = self.general.called_methods.pop(0)

=== 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-10 21:28:20 +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-10 21:28:20 +0000
@@ -30,6 +30,7 @@
 
 import logging
 import os
+import sys
 
 from twisted.internet import defer
 
@@ -44,9 +45,10 @@
     IN_IGNORED,
     IN_ISDIR,
     IN_DELETE,
-    IN_MODIFY as in_modify,
+    IN_MODIFY,
     IN_MOVED_FROM,
-    IN_MOVED_TO)
+    IN_MOVED_TO,
+)
 
 from ubuntuone import logger
 
@@ -56,16 +58,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 +103,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 +156,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 +183,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 +209,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 +267,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 +321,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 +335,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 +352,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 +368,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 +392,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 +403,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 +589,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 +616,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-10 21:28:20 +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(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,69 @@
 
     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)
-        self.observer.unschedule(watch.stream)
-        return super(WatchManager, self).del_watch(wd)
+    def del_watch(self, watch):
+        """Delete the watch and clean resources."""
+        self.observer.unschedule(watch.platform_watch.stream)
 
-    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"""

=== 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-10 21:28:20 +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 darwin 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-10 21:28:20 +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