Merge lp:~mandel/ubuntuone-client/fix-fsm into lp:ubuntuone-client

[Manuel de la Peña]

Improve the test coverage for fsm on windows.

Improve the test coverage for fsm on windows.

[lp:~mandel/ubuntuone-client/fix-fsm]

1114. By Manuel de la Peña on 2011-07-29

Merged with trunk.

1115. By Manuel de la Peña on 2011-07-29

Fixed according to the comments from the reviews.

[Natalia Bidart (nataliabidart)]

===============================================================================
[ERROR]
Traceback (most recent call last):
Failure: twisted.internet.defer.TimeoutError: <tests.platform.test_filesystem_notifications.MutedSignalsTests testMethod=test_dir_create> (test_dir_create) still running at 2.0 secs

tests.platform.test_filesystem_notifications.MutedSignalsTests.test_dir_create
===============================================================================
[ERROR]
Traceback (most recent call last):
  File "C:\Python27\lib\site-packages\twisted\internet\base.py", line 793, in runUntilCurrent
    call.func(*call.args, **call.kw)
  File "E:\u1\client\review_fix-fsm\tests\platform\test_filesystem_notifications.py", line 205, in check_filter
    self.assertFalse(self.monitor._processor.mute_filter._cnt)
twisted.trial.unittest.FailTest: None

tests.platform.test_filesystem_notifications.MutedSignalsTests.test_dir_create
tests.platform.test_filesystem_notifications.MutedSignalsTests.test_dir_delete
tests.platform.test_filesystem_notifications.MutedSignalsTests.test_dir_moved_inside
tests.platform.test_filesystem_notifications.MutedSignalsTests.test_file_create_close_write
tests.platform.test_filesystem_notifications.MutedSignalsTests.test_file_delete
tests.platform.test_filesystem_notifications.MutedSignalsTests.test_file_moved_from_conflict
tests.platform.test_filesystem_notifications.MutedSignalsTests.test_file_moved_from_partial
tests.platform.test_filesystem_notifications.MutedSignalsTests.test_file_moved_inside
===============================================================================
[ERROR]
Traceback (most recent call last):
Failure: twisted.internet.defer.TimeoutError: <tests.platform.test_filesystem_notifications.MutedSignalsTests testMethod=test_dir_delete> (test_dir_delete) still running at 2.0 secs

tests.platform.test_filesystem_notifications.MutedSignalsTests.test_dir_delete
===============================================================================
[ERROR]
Traceback (most recent call last):
Failure: twisted.internet.defer.TimeoutError: <tests.platform.test_filesystem_notifications.MutedSignalsTests testMethod=test_dir_moved_inside> (test_dir_moved_inside) still running at 2.0 secs

tests.platform.test_filesystem_notifications.MutedSignalsTests.test_dir_moved_inside
===============================================================================
[ERROR]
Traceback (most recent call last):
Failure: twisted.internet.defer.TimeoutError: <tests.platform.test_filesystem_notifications.MutedSignalsTests testMethod=test_file_create_close_write> (test_file_create_close_write) still running at 2.0 secs

tests.platform.test_filesystem_notifications.MutedSignalsTests.test_file_create_close_write
===============================================================================
[ERROR]
Traceback (most recent call last):
Failure: twisted.internet.defer.TimeoutError: <tests.platform.test_filesystem_notifications.MutedSignalsTests testMethod=test_file_delete> (test_file_delete) still running at 2.0 secs

tests.platform.test_filesystem_notifications.MutedSignalsTests.test_file_delete
=============================================================...

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

Failing tests will be solved in a incoming branch.

review: Approve

[lp:~mandel/ubuntuone-client/fix-fsm]

1116. By Manuel de la Peña on 2011-07-29

Merged with trunk and ensured that the criss-cross does not brake a thing.

[Alejandro J. Cura (alecu)]

Launchpad above complains about conflicts, and bzr complains about criss-cross.
I've just verified with bzr merge and bzr merge --weave, and the results are the same, so the base branch may be off, but the resulting merge is fine.
So I'm approving. Great branch!

review: Approve

=== modified file 'tests/platform/windows/test_filesystem_notifications.py'
--- tests/platform/windows/test_filesystem_notifications.py	2011-07-29 13:32:31 +0000
+++ tests/platform/windows/test_filesystem_notifications.py	2011-07-29 17:34:51 +0000
@@ -21,13 +21,19 @@
 import tempfile
 import thread
 import time
+import itertools
 
 from twisted.internet import defer
 
 from contrib.testing.testcase import BaseTwistedTestCase
 from ubuntuone.platform.windows import os_helper
-from ubuntuone.platform.windows.pyinotify import ProcessEvent
+from ubuntuone.platform.windows.pyinotify import (
+    ProcessEvent,
+    IN_OPEN,
+    IN_CLOSE_WRITE
+)
 from ubuntuone.platform.windows.filesystem_notifications import (
+    NotifyProcessor,
     Watch,
     WatchManager,
     FILE_NOTIFY_CHANGE_FILE_NAME,
@@ -699,3 +705,432 @@
         # assert that other events are not ignored
         self.watch._process_events([(1, 'test')])
         self.assertEqual(1, len(events))
+
+
+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."""
+
+    def setUp(self):
+        """set up the diffeent tests."""
+        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_platform_is_ignored(self):
+        """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),
+                         'Only links should be ignored.')
+        self.assertTrue(self.processor.platform_is_ignored(ignored),
+                         'Links should be ignored.')
+
+    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 wathc, 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 wathc, 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])
 
=== modified file 'ubuntuone/platform/windows/filesystem_notifications.py'
--- ubuntuone/platform/windows/filesystem_notifications.py	2011-07-29 13:32:31 +0000
+++ ubuntuone/platform/windows/filesystem_notifications.py	2011-07-29 17:34:51 +0000
@@ -152,11 +152,6 @@
         # a directory from a thread
         self._watch_started_deferred = defer.Deferred()
 
-    def _is_excluded(self, event):
-        """Return if an event is ignored."""
-        return  event.mask == IN_OPEN | IN_ISDIR
-
-    # XXX: confirm is using this decorator is correct!!! (nessita)
     @is_valid_windows_path(path_indexes=[1])
     def _path_is_dir(self, path):
         """Check if the path is a dir and update the local subdir list."""
@@ -223,9 +218,7 @@
             # the exclude filter returns False, that is, the event will not
             # be excluded
             self.log.debug('Event is %s.', event)
-            if not self._is_excluded(event):
-                self.log.debug('Processing event %r', event)
-                self._processor(event)
+            self._processor(event)
 
     def _watch(self):
         """Watch a path that is a directory."""
@@ -500,6 +493,9 @@
 
     def process_IN_MODIFY(self, event):
         """Capture a modify event and fake an open ^ close write events."""
+        # lets ignore dir changes
+        if event.dir:
+            return
         # on windows we just get IN_MODIFY, lets always fake
         # an OPEN & CLOSE_WRITE couple
         raw_open = raw_close = {
@@ -508,20 +504,13 @@
            'name': event.name,
            'path': event.path}
         # caculate the open mask
-        if event.dir:
-            raw_open['mask'] = IN_OPEN | IN_ISDIR
-        else:
-            raw_open['mask'] = IN_OPEN
+        raw_open['mask'] = IN_OPEN
         # create the event using the raw data, then fix the pathname param
         open_event = Event(raw_open)
         open_event.pathname = event.pathname
         # push the open
         self.general_processor.push_event(open_event)
-        # calculate the close mask
-        if event.dir:
-            raw_close['mask'] = IN_CLOSE_WRITE | IN_ISDIR
-        else:
-            raw_close['mask'] = IN_CLOSE_WRITE
+        raw_close['mask'] = IN_CLOSE_WRITE
         close_event = Event(raw_close)
         close_event.pathname = event.pathname
         # push the close event
@@ -534,6 +523,36 @@
                                             self.held_event)
         self.held_event = event
 
+    def _fake_create_event(self, event):
+        """Fake the creation of an event."""
+        # this is the case of a MOVE from an ignored path (links for example)
+        # to a valid path
+        if event.dir:
+            evtname = "FS_DIR_"
+        else:
+            evtname = "FS_FILE_"
+        self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
+        if not event.dir:
+            self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
+                                            path=event.pathname)
+
+    def _fake_delete_create_event(self, event):
+        """Fake the deletion and the creation."""
+        # this is the case of a MOVE from a watch UDF to a diff UDF which
+        # means that we have to copy the way linux works.
+        if event.dir:
+            evtname = "FS_DIR_"
+        else:
+            evtname = "FS_FILE_"
+        m = "Delete because of different shares: %r"
+        self.log.info(m, self.held_event.pathname)
+        self.general_processor.eq_push(evtname + "DELETE",
+                                       path=self.held_event.pathname)
+        self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
+        if not event.dir:
+            self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
+                                            path=event.pathname)
+
     def process_IN_MOVED_TO(self, event):
         """Capture the MOVED_TO to maybe syntethize FILE_MOVED."""
         if self.held_event is not None:
@@ -548,37 +567,21 @@
                         f_path_dir)
                     t_share_id = self.general_processor.get_path_share_id(
                         t_path_dir)
-                    if event.dir:
-                        evtname = "FS_DIR_"
-                    else:
-                        evtname = "FS_FILE_"
                     if f_share_id != t_share_id:
                         # if the share_id are != push a delete/create
-                        m = "Delete because of different shares: %r"
-                        self.log.info(m, self.held_event.pathname)
-                        self.general_processor.eq_push(
-                            evtname + "DELETE", path=self.held_event.pathname)
-                        self.general_processor.eq_push(
-                            evtname + "CREATE", path=event.pathname)
-                        if not event.dir:
-                            self.general_processor.eq_push(
-                                'FS_FILE_CLOSE_WRITE', path=event.pathname)
+                        self._fake_delete_create_event(event)
                     else:
+                        if event.dir:
+                            evtname = "FS_DIR_"
+                        else:
+                            evtname = "FS_FILE_"
                         self.general_processor.eq_push(evtname + "MOVE",
                             path_from=self.held_event.pathname,
                             path_to=event.pathname)
                 elif is_to_forreal:
                     # this is the case of a MOVE from something ignored
                     # to a valid filename
-                    if event.dir:
-                        evtname = "FS_DIR_"
-                    else:
-                        evtname = "FS_FILE_"
-                    self.general_processor.eq_push(evtname + "CREATE",
-                        path=event.pathname)
-                    if not event.dir:
-                        self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
-                            path=event.pathname)
+                    self._fake_create_event(event)
 
                 self.held_event = None
                 return
@@ -601,7 +604,8 @@
     @is_valid_syncdaemon_path(path_indexes=[1])
     def handle_dir_delete(self, fullpath):
         """Some special work when a directory is deleted."""
-        # remove the watch on that dir from our structures
+        # remove the watch on that dir from our structures, this mainly tells
+        # the monitor to remove the watch which is fowaded to a watch manager.
         self.general_processor.rm_watch(fullpath)
 
         # handle the case of move a dir to a non-watched directory
@@ -613,6 +617,7 @@
             m = "Pushing deletion because of parent dir move: (is_dir=%s) %r"
             self.general_processor.log.info(m, is_dir, path)
             if is_dir:
+                # same as the above remove
                 self.general_processor.rm_watch(path)
                 self.general_processor.eq_push('FS_DIR_DELETE', path=path)
             else:
@@ -661,10 +666,6 @@
         self.log.setLevel(TRACE)
         self.fs = fs
         self.eq = eq
-        # XXX: We need to find a decent time for the time out, is 0.2 seconds
-        # too little?
-        self.timeout = timeout
-        # general inotify
         self._processor = NotifyProcessor(self, ignore_config)
         self._watch_manager = WatchManager(self._processor)
 
@@ -697,12 +698,6 @@
             self._watch_manager.add_watch(dirpath, FILESYSTEM_MONITOR_MASK,
                 auto_add=True)
 
-    @windowspath(path_indexes=[1])
-    def has_watch(self, dirpath):
-        """Check if a dirpath is watched."""
-        wd = self._watch_manager.get_wd(dirpath)
-        return wd is not None
-
     def is_frozen(self):
         """Checks if there's something frozen."""
         return self._processor.frozen_path is not None