Merge lp:~mandel/ubuntuone-client/daemon-options into lp:ubuntuone-client

[Manuel de la Peña]

- Provides an extra command line that allows to choose which filemonitor implementation to use with the ubuntuone sync daemon (LP: 1025689).

Provides an extra command line that allows to choose which filemonitor implementation to use with the ubuntuone sync daemon. Right now on Windows and Linux there is only one implementation while on Darwin there are two of them.

The test results should be:

Linux => all pass
Windows => atm one failure (currently present in trunk).
Darwin => tests/platform/filesystem_notifications/test_darwin.py (all pass but got stuck at the end just like trunk).
          tests/platform/filesystem_notifications/test_fsevents_daemon.py (all pass).

[Mike McCracken (mikemc)]

A couple minor things I think should change and a few comments about
importing at the end that you can feel free to argue with...

# typos:
- "test test" in a couple docstrings
- get_filemonitor_class exception strings say "Not active monitor", I think you mean "no active…"?
(or "no available", see below)

# naming issue:
- is_active_monitor is a little confusing in english. It's intended to
tell us if the monitor is usable (ie, installed, for the daemon),
right?
"Is active monitor" sounds like it's telling us if this monitor is
currently active, which it isn't doing.

How about "is_available" or "is_installed" instead?
Since it's a method on the monitor class, I left out "monitor" in
those suggestions intentionally.

-----> up for discussion: lots of assignments in __init__ files from
       submodules that don't seem platform-specific:

I looked at the assignment to get_filemonitor_class, and poked around
a bit - some of this isn't new in this diff, but might be
nice to fix here, instead of adding code that does the same thing:
(Feel free to disagree if you think it's not productive)

# why is get_filemonitor_class being added to the namespace in platform/filesystem_notifications/__init__.py?
it looks like it's never accessed as
filesystem_notifications.get_filemonitor_class, but always as
filesystem_notifications.monitor.get_filemonitor_class, (eg in
platform/__init__.py).

So, that assignment is unnecessary, and

# importing filesystemMonitor - there are a lot of ways to import
  it. I think we could remove the assignments in platform/__init__.py,
  and filesystem_notifications/__init__.py, since it's possible to
  just get it from platform.filesystem_notifications.monitor
  everywhere - we already do this in a few places.

- syncdaemon/event_queue.py imports it from
  platform.filesystem_notifications, while test_eventqueue imports it
  from platform. (seems like those should be the same)

- test_windows and test_darwin import it from
  u.platform.filesystem_notifications.monitor.common, while test_linux
  gets it from platform.filesystem_notifications.

# related to the above: _GeneralINotifyProcessor seems like it's only
  used in test_filesystem_notifications. maybe we should change that and
  remove the assignment in filesystem_notifications/__init__.py:36

review: Needs Fixing

[Manuel de la Peña (mandel)]

> A couple minor things I think should change and a few comments about
> importing at the end that you can feel free to argue with...
>
> # typos:
> - "test test" in a couple docstrings
> - get_filemonitor_class exception strings say "Not active monitor", I think
> you mean "no active…"?
> (or "no available", see below)
>
>

Fixed!

> # naming issue:
> - is_active_monitor is a little confusing in english. It's intended to
> tell us if the monitor is usable (ie, installed, for the daemon),
> right?
> "Is active monitor" sounds like it's telling us if this monitor is
> currently active, which it isn't doing.
>
> How about "is_available" or "is_installed" instead?
> Since it's a method on the monitor class, I left out "monitor" in
> those suggestions intentionally.
>

Fixed !

> -----> up for discussion: lots of assignments in __init__ files from
> submodules that don't seem platform-specific:
>
> I looked at the assignment to get_filemonitor_class, and poked around
> a bit - some of this isn't new in this diff, but might be
> nice to fix here, instead of adding code that does the same thing:
> (Feel free to disagree if you think it's not productive)
>
> # why is get_filemonitor_class being added to the namespace in
> platform/filesystem_notifications/__init__.py?
> it looks like it's never accessed as
> filesystem_notifications.get_filemonitor_class, but always as
> filesystem_notifications.monitor.get_filemonitor_class, (eg in
> platform/__init__.py).
>
> So, that assignment is unnecessary, and
>
> # importing filesystemMonitor - there are a lot of ways to import
> it. I think we could remove the assignments in platform/__init__.py,
> and filesystem_notifications/__init__.py, since it's possible to
> just get it from platform.filesystem_notifications.monitor
> everywhere - we already do this in a few places.
>
> - syncdaemon/event_queue.py imports it from
> platform.filesystem_notifications, while test_eventqueue imports it
> from platform. (seems like those should be the same)
>
> - test_windows and test_darwin import it from
> u.platform.filesystem_notifications.monitor.common, while test_linux
> gets it from platform.filesystem_notifications.
>
> # related to the above: _GeneralINotifyProcessor seems like it's only
> used in test_filesystem_notifications. maybe we should change that and
> remove the assignment in filesystem_notifications/__init__.py:36

Completely agree with this but is maybe better to create a bug and do it in a diff branch to keep things easier, what do you think?

[Diego Sarmentero (diegosarmentero)]

== Python Lint Notices ==

./tests/platform/filesystem_notifications/test_linux.py:
    399: local variable 'is_available' is assigned to but never used
    400: undefined name 'is_availabe'

make: *** [lint] Error 2

review: Needs Fixing

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[Mike McCracken (mikemc)]

A couple more places where s/active/available/ needs to happen:
- the NoActiveMonitorError Exception in monitor/__init__ should be NoAvailableMonitorError

- the assertion messages in filesystem_notifications/test_* say "Should always be active" - should be "always be available".

review: Needs Fixing

[Mike McCracken (mikemc)]

Thanks!

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

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

[lp:~mandel/ubuntuone-client/daemon-options]

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

Merged with parent.

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

Merged with changes from other platforms work.

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

Merged unify-filemonitors into daemon-options.

=== modified file 'bin/ubuntuone-syncdaemon'
--- bin/ubuntuone-syncdaemon	2012-07-02 15:39:40 +0000
+++ bin/ubuntuone-syncdaemon	2012-07-19 14:25:29 +0000
@@ -48,6 +48,7 @@
 
 from ubuntuone.platform import (
     can_write,
+    get_filemonitor_class,
     set_dir_readwrite,
     is_already_running,
     is_root,
@@ -212,6 +213,9 @@
                   "[CONSUMER_KEY:CONSUMER_SECRET:]KEY:SECRET"
             parser.error(msg)
 
+    # check which file monitor to use
+    monitor_class = yield get_filemonitor_class(options.fs_monitor)
+
     main = Main(options.root_dir, options.shares_dir, options.data_dir,
                 partials_dir, host=options.host, port=int(options.port),
                 dns_srv=options.dns_srv, ssl=True,
@@ -224,7 +228,8 @@
                 write_limit=options.bandwidth_throttling_write_limit,
                 throttling_enabled=options.bandwidth_throttling_on,
                 ignore_files=options.ignore,
-                oauth_credentials=oauth_credentials)
+                oauth_credentials=oauth_credentials,
+                monitor_class=monitor_class)
 
     # override the reactor default signal handlers in order to
     # shutdown properly

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

=== modified file 'tests/platform/filesystem_notifications/test_darwin.py'
--- tests/platform/filesystem_notifications/test_darwin.py	2012-07-19 14:25:29 +0000
+++ tests/platform/filesystem_notifications/test_darwin.py	2012-07-19 14:25:29 +0000
@@ -1387,3 +1387,10 @@
 
         self.assertTrue(d1.result, "Should not be called yet.")
         self.assertTrue(d2, "Should not be called yet.")
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor(self):
+        """Test test the is_available_monitor method."""
+        # we should always return true
+        is_available = yield common.FilesystemMonitor.is_available_monitor()
+        self.assertTrue(is_available, 'Should always be available.')

=== modified file 'tests/platform/filesystem_notifications/test_fsevents_daemon.py'
--- tests/platform/filesystem_notifications/test_fsevents_daemon.py	2012-07-19 14:25:29 +0000
+++ tests/platform/filesystem_notifications/test_fsevents_daemon.py	2012-07-19 14:25:29 +0000
@@ -30,10 +30,11 @@
 
 import os
 
-from twisted.internet import defer
+from twisted.internet import defer, protocol
 
 from contrib.testing.testcase import BaseTwistedTestCase
 from ubuntuone.darwin import fsevents
+from ubuntuone.devtools.testcases.txsocketserver import TidyUnixServer
 from ubuntuone.platform.filesystem_notifications.monitor.darwin import (
     fsevents_daemon,
 )
@@ -44,6 +45,20 @@
     IN_MOVED_TO,
 )
 
+class FakeServerProtocol(protocol.Protocol):
+    """A test protocol."""
+
+    def dataReceived(self, data):
+        """Echo the data received."""
+        self.transport.write(data)
+
+
+class FakeServerFactory(protocol.ServerFactory):
+    """A factory for the test server."""
+
+    protocol = FakeServerProtocol
+
+
 class FakeDaemonEvent(object):
     """A fake daemon event."""
 
@@ -56,7 +71,7 @@
 class FakeProcessor(object):
     """A fake processor."""
 
-    def __init__(self):
+    def __init__(self, *args):
         """Create a new instance."""
         self.processed_events = []
 
@@ -68,9 +83,9 @@
 class FakePyInotifyEventsFactory(object):
     """Fake factory."""
 
-    def __init__(self, processor):
+    def __init__(self):
         """Create a new instance."""
-        self.processor = processor
+        self.processor = FakeProcessor()
         self.called = []
         self.watched_paths = []
         self.ignored_paths = []
@@ -369,13 +384,13 @@
     def setUp(self):
         """Set the tests."""
         yield super(FilesystemMonitorTestCase, self).setUp()
-        self.processor = FakeProcessor()
-        self.factory = FakePyInotifyEventsFactory(self.processor)
+        self.patch(fsevents_daemon, 'NotifyProcessor', FakeProcessor)
+        self.factory = FakePyInotifyEventsFactory()
         self.protocol = FakeProtocol()
         self.monitor = fsevents_daemon.FilesystemMonitor(None, None)
+        self.processor = self.monitor._processor
 
         # override default objects
-        self.monitor._processor = self.processor
         self.monitor._factory = self.factory
 
         # patch the connect
@@ -437,3 +452,32 @@
         self.factory.ignored_paths.append(dirpath)
         yield self.monitor.add_watch(dirpath)
         self.assertNotIn('add_path', self.protocol.called)
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor_running(self):
+        """Test the method when it is indeed running."""
+        monitor_cls = fsevents_daemon.FilesystemMonitor
+
+        # start a fake server for the test
+        server = TidyUnixServer()
+        yield server.listen_server(FakeServerFactory)
+        self.addCleanup(server.clean_up)
+
+        # set the path
+        old_socket = fsevents_daemon.DAEMON_SOCKET
+        fsevents_daemon.DAEMON_SOCKET = server.path
+        self.addCleanup(setattr, fsevents_daemon, 'DAEMON_SOCKET', old_socket)
+
+        result = yield monitor_cls.is_available_monitor()
+        self.assertTrue(result)
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor_fail(self):
+        """Test the method when the daemon is not running."""
+        monitor_cls = fsevents_daemon.FilesystemMonitor
+        old_socket = fsevents_daemon.DAEMON_SOCKET
+        fsevents_daemon.DAEMON_SOCKET += 'test'
+        self.addCleanup(setattr, fsevents_daemon, 'DAEMON_SOCKET', old_socket)
+
+        result = yield monitor_cls.is_available_monitor()
+        self.assertFalse(result)

=== modified file 'tests/platform/filesystem_notifications/test_linux.py'
--- tests/platform/filesystem_notifications/test_linux.py	2012-07-19 14:25:29 +0000
+++ tests/platform/filesystem_notifications/test_linux.py	2012-07-19 14:25:29 +0000
@@ -391,6 +391,14 @@
         self.assertEqual(self.monitor._general_watchs, {})
         self.assertEqual(self.monitor._ancestors_watchs, {})
 
+    @defer.inlineCallbacks
+    def test_is_available_monitor(self):
+        """Test test the is_available_monitor method."""
+        # we should always return true
+        monitor_cls = filesystem_notifications.FilesystemMonitor
+        is_available = yield monitor_cls.is_available_monitor()
+        self.assertTrue(is_available, 'Should always be available.')
+
 
 class FakeEvent(object):
     """A fake event."""

=== modified file 'tests/platform/filesystem_notifications/test_windows.py'
--- tests/platform/filesystem_notifications/test_windows.py	2012-07-19 14:25:29 +0000
+++ tests/platform/filesystem_notifications/test_windows.py	2012-07-19 14:25:29 +0000
@@ -1446,3 +1446,10 @@
         # lets ensure that we never added the watches
         self.assertEqual(0, len(monitor._watch_manager._wdm.values()),
                          'No watches should have been added.')
+
+    @defer.inlineCallbacks
+    def test_is_available_monitor(self):
+        """Test test the is_available_monitor method."""
+        # we should always return true
+        is_available = yield FilesystemMonitor.is_available_monitor()
+        self.assertTrue(is_available, 'Should always be available.')

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

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

=== modified file 'ubuntuone/platform/__init__.py'
--- ubuntuone/platform/__init__.py	2012-06-28 10:26:50 +0000
+++ ubuntuone/platform/__init__.py	2012-07-19 14:25:29 +0000
@@ -101,6 +101,12 @@
 stat_path = os_helper.stat_path
 walk = os_helper.walk
 
+# From Monitor
+from ubuntuone.platform.filesystem_notifications import monitor
+
+get_filemonitor_class = monitor.get_filemonitor_class
+FilesystemMonitor = monitor.FilesystemMonitor
+
 # From Logger
 setup_filesystem_logging = logger.setup_filesystem_logging
 get_filesystem_logger = logger.get_filesystem_logger

=== modified file 'ubuntuone/platform/filesystem_notifications/__init__.py'
--- ubuntuone/platform/filesystem_notifications/__init__.py	2012-07-19 14:25:29 +0000
+++ ubuntuone/platform/filesystem_notifications/__init__.py	2012-07-19 14:25:29 +0000
@@ -35,3 +35,4 @@
 
 _GeneralINotifyProcessor = notify_processor.NotifyProcessor
 FilesystemMonitor = monitor.FilesystemMonitor
+get_filemonitor_class = monitor.get_filemonitor_class

=== added directory 'ubuntuone/platform/filesystem_notifications/filesystem_monitor'
=== added file 'ubuntuone/platform/filesystem_notifications/filesystem_monitor/__init__.py'
=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/__init__.py'
--- ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-07-19 14:25:29 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-07-19 14:25:29 +0000
@@ -30,13 +30,66 @@
 
 import sys
 
-if sys.platform in ('win32', 'darwin'):
-    from ubuntuone.platform.filesystem_notifications.monitor import (
-        common,
-    )
-    FilesystemMonitor = common.FilesystemMonitor
+from twisted.internet import defer
+
+DEFAULT_MONITOR = 'default'
+
+
+class NoAvailableMonitorError(Exception):
+    """Raised if there are no available monitors in the system."""
+
+
+if sys.platform == 'win32':
+    from ubuntuone.platform.filesystem_notifications.monitor import (
+        common,
+    )
+
+    FILEMONITOR_IDS = {
+        DEFAULT_MONITOR: common.FilesystemMonitor,
+    }
+
+elif sys.platform == 'darwin':
+    from ubuntuone.platform.filesystem_notifications.monitor import darwin
+    from ubuntuone.platform.filesystem_notifications.monitor import (
+        common,
+    )
+
+    FILEMONITOR_IDS = {
+        DEFAULT_MONITOR: common.FilesystemMonitor,
+        'daemon': darwin.fsevents_daemon.FilesystemMonitor,
+    }
 else:
     from ubuntuone.platform.filesystem_notifications.monitor import (
         linux,
     )
-    FilesystemMonitor = linux.FilesystemMonitor
+
+    FILEMONITOR_IDS = {
+        DEFAULT_MONITOR: linux.FilesystemMonitor,
+    }
+
+# mantain old API
+FilesystemMonitor = FILEMONITOR_IDS[DEFAULT_MONITOR]
+
+
[e-mail]
+def get_filemonitor_class(monitor_id=None):
+    """Return the class to be used."""
+    if monitor_id is None:
+        # use default
+        monitor_id = 'default'
+
+    if monitor_id not in FILEMONITOR_IDS:
+        raise NoAvailableMonitorError(
+                'No available monitor with id "%s"could be found.' % monitor_id)
+
+    # retrieve the correct class and assert it can be used
+    cls = FILEMONITOR_IDS[monitor_id]
+    is_available = yield cls.is_available_monitor()
+
+    if is_available:
+        defer.returnValue(cls)
+    elif not is_available and monitor_id != DEFAULT_MONITOR:
+        cls = yield get_filemonitor_class(DEFAULT_MONITOR)
+        defer.returnValue(cls)
+    else:
+        raise NoAvailableMonitorError('No available monitor could be found.')

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/common.py'
--- ubuntuone/platform/filesystem_notifications/monitor/common.py	2012-07-19 14:25:29 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/common.py	2012-07-19 14:25:29 +0000
@@ -53,6 +53,7 @@
     os_path,
 )
 
+
 if sys.platform == 'darwin':
     from ubuntuone.platform.filesystem_notifications.monitor.darwin import (
         fsevents_client,
@@ -371,6 +372,12 @@
         self._processor = notify_processor.NotifyProcessor(self, ignore_config)
         self._watch_manager = WatchManager(self._processor)
 
+    @classmethod
+    def is_available_monitor(cls):
+        """Return if the monitor can be used in the platform."""
+        # we can always use this monitor
+        return defer.succeed(True)
+
     def add_to_mute_filter(self, event, **info):
         """Add info to mute filter in the processor."""
         self._processor.add_to_mute_filter(event, info)

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py'
--- ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	2012-07-19 14:25:29 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	2012-07-19 14:25:29 +0000
@@ -35,21 +35,29 @@
 
 from twisted.internet import defer, endpoints, reactor
 
+from ubuntu_sso.utils.tcpactivation import (
+    ActivationConfig,
+    ActivationInstance,
+    AlreadyStartedError,
+)
+
 from ubuntuone import logger
 from ubuntuone.darwin import fsevents
+from ubuntuone.platform.filesystem_notifications.notify_processor import (
+    NotifyProcessor,
+)
 from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
     Event,
-    ProcessEvent,
     IN_OPEN,
     IN_CLOSE_NOWRITE,
     IN_CLOSE_WRITE,
     IN_CREATE,
-    IN_IGNORED,
     IN_ISDIR,
     IN_DELETE,
     IN_MOVED_FROM,
     IN_MOVED_TO,
-    IN_MODIFY)
+    IN_MODIFY,
+)
 
 TRACE = logger.TRACE
 
@@ -91,6 +99,36 @@
 # Path to the socket used by the daemon
 DAEMON_SOCKET = '/var/run/ubuntuone_fsevents_daemon'
 
+
+class DescriptionFactory(object):
+    """Factory that provides the server and client descriptions."""
+
+    client_description_pattern = 'unix:path=%s'
+    server_description_pattern = 'unix:%s'
+
+    def __init__(self):
+        """Create a new instance."""
+        self.server = self.server_description_pattern % DAEMON_SOCKET
+        self.client = self.client_description_pattern % DAEMON_SOCKET
+
+
+def get_activation_config():
+    """Get the configuration to activate the sso service."""
+    description = DescriptionFactory()
+    return ActivationConfig(None, None, description)
+
+
[e-mail]
+def is_daemon_running():
+    """Return if the sd is running by trying to get the port."""
+    ai = ActivationInstance(get_activation_config())
+    try:
+        yield ai.get_server_description()
+        defer.returnValue(False)
+    except AlreadyStartedError:
+        defer.returnValue(True)
+
+
 def get_syncdaemon_valid_path(path):
     """Return a valid encoded path."""
     return unicodedata.normalize('NFC', path).encode('utf-8')
@@ -99,7 +137,8 @@
 class PyInotifyEventsFactory(fsevents.FsEventsFactory):
     """Factory that process events and converts them in pyinotify ones."""
 
-    def __init__(self, processor, ignored_events=DARWIN_IGNORED_ACTIONS):
+    def __init__(self, processor,
+            ignored_events=DARWIN_IGNORED_ACTIONS):
         """Create a new instance."""
         # old style class
         fsevents.FsEventsFactory.__init__(self)
@@ -253,218 +292,24 @@
                     self._processor(pyinotify_event)
 
 
-class NotifyProcessor(ProcessEvent):
-    """Mac OS X implementation of NotifyProcessor"""
-
-    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, 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)
-
-    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)
-
-    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 darwin 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}
-        # calculate 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:
-                # we should never get to this point on darwin, never ever!
-                self.release_held_event()
-                self.general_processor.push_event(event)
-        else:
-            # we should never get to this point on darwin, never ever!
-            self.general_processor.log.warn(
-                            'Cookie does not match the previous 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)
-
-    def handle_dir_delete(self, fullpath):
-        """Some special work when a directory is deleted."""
-        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)
-
-    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):
-    """Implementation that allows to receive events from the sustem."""
+    """Implementation that allows to receive events from the system."""
 
     def __init__(self, eq, fs, ignore_config=None, timeout=1):
         self.log = logging.getLogger('ubuntuone.SyncDaemon.FSMonitor')
         self.log.setLevel(TRACE)
+        self._processor = NotifyProcessor(self, ignore_config)
         self.fs = fs
         self.eq = eq
-        self._processor = NotifyProcessor(self, ignore_config)
         self._factory = PyInotifyEventsFactory(self._processor)
         self._protocol = None
 
+    @classmethod
+    def is_available_monitor(cls):
+        """Return if the monitor can be used in the platform."""
+        # can only be used if the daemon is running
+        return is_daemon_running()
+
     @defer.inlineCallbacks
     def _connect_to_daemon(self):
         """Connect to the daemon so that we can receive events."""

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/linux.py'
--- ubuntuone/platform/filesystem_notifications/monitor/linux.py	2012-07-19 14:25:29 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/linux.py	2012-07-19 14:25:29 +0000
@@ -161,6 +161,12 @@
                                             wm, self._inotify_notifier_antr)
         self._ancestors_watchs = {}
 
+    @classmethod
+    def is_available_monitor(cls):
+        """Return if the monitor can be used in the platform."""
+        # we can always use this monitor
+        return defer.succeed(True)
+
     def add_to_mute_filter(self, event, **info):
         """Add info to mute filter in the processor."""
         self._processor.add_to_mute_filter(event, info)

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2012-06-28 10:26:50 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2012-07-19 14:25:29 +0000
@@ -183,13 +183,17 @@
 class EventQueue(object):
     """Manages the events from different sources and distributes them."""
 
-    def __init__(self, fs, ignore_config=None):
+    def __init__(self, fs, ignore_config=None, monitor_class=None):
         self.listener_map = {}
 
         self.log = logging.getLogger('ubuntuone.SyncDaemon.EQ')
         self.fs = fs
 
-        self.monitor = FilesystemMonitor(self, fs, ignore_config)
+        if monitor_class is None:
+            # use the default class returned by platform
+            self.monitor = FilesystemMonitor(self, fs, ignore_config)
+        else:
+            self.monitor = monitor_class(self, fs, ignore_config)
 
         self.dispatching = False
         self.dispatch_queue = collections.deque()

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

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