Merge lp:~mandel/ubuntuone-client/unify-processors into lp:ubuntuone-client

[Manuel de la Peña]

Move the NotifyProcessor to a multipletform package to simplify the code and remove circular imports.

Move the NotifyProcessor to a multipletform package to simplify the code and remove circular imports.

[Manuel de la Peña (mandel)]

I really wish there was a way to do a bzr mv of partial files.. sorry for the size.

[Diego Sarmentero (diegosarmentero)]

Is there any way to execute the tests that we have on darwin without the need of the deamon?
If i want to check the non-root implementation for example, right now it fails with this branch.

review: Needs Information

[Diego Sarmentero (diegosarmentero)]

Also this seems to break the tests on windows:
Traceback (most recent call last):
  File "X:\ubuntuone-client-mandel2\tests\platform\filesystem_notifications\test_windows.py", line 1093, in test_platform_is_ignored
    self.assertTrue(filesystem_notifications.path_is_ignored(ignored),
exceptions.AttributeError: 'module' object has no attribute 'path_is_ignored'

tests.platform.filesystem_notifications.test_windows.TestNotifyProcessor.test_platform_is_ignored

review: Needs Fixing

[Manuel de la Peña (mandel)]

> Also this seems to break the tests on windows:
> Traceback (most recent call last):
> File "X:\ubuntuone-client-
> mandel2\tests\platform\filesystem_notifications\test_windows.py", line 1093,
> in test_platform_is_ignored
> self.assertTrue(filesystem_notifications.path_is_ignored(ignored),
> exceptions.AttributeError: 'module' object has no attribute 'path_is_ignored'
>
> tests.platform.filesystem_notifications.test_windows.TestNotifyProcessor.test_
> platform_is_ignored

Fixing!

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[Roberto Alsina (ralsina)]

In line 26 of the diff, it uses iteritems, should use items for python 3 compatibility.

review: Needs Fixing

[Roberto Alsina (ralsina)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The prerequisite https://code.launchpad.net/~mandel/ubuntuone-client/fsevents-daemon has not yet been merged into https://code.launchpad.net/~ubuntuone-control-tower/ubuntuone-client/trunk.

[Ubuntu One Auto Pilot (otto-pilot)]

The prerequisite https://code.launchpad.net/~mandel/ubuntuone-client/fsevents-daemon has not yet been merged into https://code.launchpad.net/~ubuntuone-control-tower/ubuntuone-client/trunk.

[lp:~mandel/ubuntuone-client/unify-processors]

1296. By Manuel de la Peña on 2012-07-19

Merged fsevents-daemon into unify-processors.

1297. By Manuel de la Peña on 2012-07-19

Merged fsevents-daemon into unify-processors.

=== modified file 'tests/platform/filesystem_notifications/test_darwin.py'
--- tests/platform/filesystem_notifications/test_darwin.py	2012-07-12 13:51:33 +0000
+++ tests/platform/filesystem_notifications/test_darwin.py	2012-07-19 14:25:25 +0000
@@ -40,10 +40,13 @@
 from contrib.testing.testcase import BaseTwistedTestCase
 from ubuntuone.devtools.handlers import MementoHandler
 from ubuntuone.platform.filesystem_notifications import (
-    darwin as filesystem_notifications,
-)
+    common,
+)
+from ubuntuone.platform.filesystem_notifications.darwin import (
+    fsevents_client as filesystem_notifications,
+)
+from ubuntuone.platform.filesystem_notifications import notify_processor
 from ubuntuone.platform.filesystem_notifications.common import (
-    NotifyProcessor,
     Watch,
     WatchManager,
 )
@@ -60,7 +63,7 @@
 
 # A reverse mapping for the tests
 REVERSE_MACOS_ACTIONS = {}
-for key, value in filesystem_notifications.ACTIONS.iteritems():
+for key, value in common.ACTIONS.items():
     REVERSE_MACOS_ACTIONS[value] = key
 
 
@@ -1030,7 +1033,7 @@
     def setUp(self):
         """set up the diffeent tests."""
         yield super(TestNotifyProcessor, self).setUp()
-        self.processor = NotifyProcessor(None)
+        self.processor = notify_processor.NotifyProcessor(None)
         self.general = FakeGeneralProcessor()
         self.processor.general_processor = self.general
 

=== modified file 'tests/platform/filesystem_notifications/test_linux.py'
--- tests/platform/filesystem_notifications/test_linux.py	2012-06-14 18:22:16 +0000
+++ tests/platform/filesystem_notifications/test_linux.py	2012-07-19 14:25:25 +0000
@@ -37,6 +37,7 @@
 
 from contrib.testing import testcase
 from ubuntuone.syncdaemon import volume_manager
+from ubuntuone.platform.filesystem_notifications import notify_processor
 from ubuntuone.platform.filesystem_notifications import (
     linux as filesystem_notifications,
 )
@@ -71,12 +72,12 @@
 
     def test_processor_shutdown_no_timer(self):
         """Shutdown the processor, no timer."""
-        processor = filesystem_notifications._GeneralINotifyProcessor('mntr')
+        processor = notify_processor.NotifyProcessor('mntr')
         processor.shutdown()
 
     def test_processor_shutdown_timer_inactive(self):
         """Shutdown the processor, timer inactive."""
-        processor = filesystem_notifications._GeneralINotifyProcessor('mntr')
+        processor = notify_processor.NotifyProcessor('mntr')
         d = defer.Deferred()
 
         def shutdown():
@@ -89,7 +90,7 @@
 
     def test_processor_shutdown_timer_active(self):
         """Shutdown the processor, timer going on."""
-        processor = filesystem_notifications._GeneralINotifyProcessor('mntr')
+        processor = notify_processor.NotifyProcessor('mntr')
         processor.timer = reactor.callLater(10, lambda: None)
         processor.shutdown()
         self.assertFalse(processor.timer.active())
@@ -405,7 +406,7 @@
         """When eCryptFS sends CLOSE_WRITE on folders, ignore it"""
         result = []
         monitor = None
-        processor = filesystem_notifications._GeneralINotifyProcessor(monitor)
+        processor = notify_processor.NotifyProcessor(monitor)
         self.patch(processor.general_processor, "push_event", result.append)
 
         fake_event = FakeEvent()
@@ -420,7 +421,7 @@
         """When anything sends CLOSE_WRITE on files, handle it."""
         result = []
         monitor = None
-        processor = filesystem_notifications._GeneralINotifyProcessor(monitor)
+        processor = notify_processor.NotifyProcessor(monitor)
         self.patch(processor.general_processor, "push_event", result.append)
 
         fake_event = FakeEvent()

=== modified file 'tests/platform/filesystem_notifications/test_windows.py'
--- tests/platform/filesystem_notifications/test_windows.py	2012-07-10 20:11:18 +0000
+++ tests/platform/filesystem_notifications/test_windows.py	2012-07-19 14:25:25 +0000
@@ -53,9 +53,9 @@
 from ubuntuone.platform.filesystem_notifications import (
     windows as filesystem_notifications,
 )
+from ubuntuone.platform.filesystem_notifications import notify_processor
 from ubuntuone.platform.filesystem_notifications.common import (
     FilesystemMonitor,
-    NotifyProcessor,
     Watch,
     WatchManager,
 )
@@ -1057,7 +1057,7 @@
     def setUp(self):
         """set up the diffeent tests."""
         yield super(TestNotifyProcessor, self).setUp()
-        self.processor = NotifyProcessor(None)
+        self.processor = notify_processor.NotifyProcessor(None)
         self.general = FakeGeneralProcessor()
         self.processor.general_processor = self.general
 
@@ -1087,9 +1087,10 @@
         """Test that we do indeed ignore the correct paths."""
         not_ignored = 'test'
         ignored = not_ignored + '.lnk'
-        self.assertFalse(filesystem_notifications.path_is_ignored(not_ignored),
+        path_is_ignored = notify_processor.common.path_is_ignored
+        self.assertFalse(path_is_ignored(not_ignored),
                          'Only links should be ignored.')
-        self.assertTrue(filesystem_notifications.path_is_ignored(ignored),
+        self.assertTrue(path_is_ignored(ignored),
                          'Links should be ignored.')
 
     def test_is_ignored(self):

=== modified file 'ubuntuone/platform/filesystem_notifications/__init__.py'
--- ubuntuone/platform/filesystem_notifications/__init__.py	2012-07-10 20:11:18 +0000
+++ ubuntuone/platform/filesystem_notifications/__init__.py	2012-07-19 14:25:25 +0000
@@ -30,12 +30,14 @@
 
 import sys
 
+from ubuntuone.platform.filesystem_notifications import notify_processor
+
+_GeneralINotifyProcessor = notify_processor.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
-    _GeneralINotifyProcessor = linux._GeneralINotifyProcessor

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

=== modified file 'ubuntuone/platform/filesystem_notifications/darwin/fsevents_client.py'
--- ubuntuone/platform/filesystem_notifications/darwin/fsevents_client.py	2012-07-19 14:25:25 +0000
+++ ubuntuone/platform/filesystem_notifications/darwin/fsevents_client.py	2012-07-19 14:25:25 +0000
@@ -61,14 +61,6 @@
 }
 
 
-def path_is_ignored(path):
-    """Should we ignore this path in the current platform.?"""
-    # don't support links yet
-    if os.path.islink(path):
-        return True
-    return False
-
-
 # The implementation of the code that is provided as the pyinotify substitute
 class Watch(object):
     """Implement the same functions as pyinotify.Watch."""

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

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

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

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

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