Merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0

[dobey]

[Diego Sarmentero]

    - Some refactoring to support mac os filesystem notifications in the future (LP: #1013323).

[Rodney Dawes]

    - Avoid using ubuntu_sso.xdg_base_directory.
    - Move ubuntuone_log_dir to ubuntuone.platform.logger.
    - Remove ubuntuone.platform.xdg_base_directory.

[Manuel de la Pena]

    - Added the spotlight pattern to the ignore list (LP: #1015137).
    - Do not raise exception in set_application_name so that the sys_init_done signal is pushed
      to the state machine (LP: #1015003).

[Mike McCracken (mikemc)]

ok

review: Approve

[Brian Curtin (brian.curtin)]

review: Approve

[lp:~dobey/ubuntuone-client/update-4-0]

1250. By Diego Sarmentero on 2012-06-25

[Diego Sarmentero]

    - Some refactoring to support mac os filesystem notifications in the future (LP: #1013323).

[Rodney Dawes]

    - Avoid using ubuntu_sso.xdg_base_directory.
    - Move ubuntuone_log_dir to ubuntuone.platform.logger.
    - Remove ubuntuone.platform.xdg_base_directory.

[Manuel de la Pena]

    - Added the spotlight pattern to the ignore list (LP: #1015137).
    - Do not raise exception in set_application_name so that the sys_init_done signal is pushed
      to the state machine (LP: #1015003).

=== modified file 'bin/ubuntuone-syncdaemon'
--- bin/ubuntuone-syncdaemon	2012-04-09 20:07:05 +0000
+++ bin/ubuntuone-syncdaemon	2012-06-25 20:40:24 +0000
@@ -64,7 +64,7 @@
 from ubuntuone.syncdaemon.main import Main
 
 from twisted.internet import reactor, defer
-from ubuntu_sso.xdg_base_directory import (
+from dirspec.basedir import (
     xdg_cache_home,
     xdg_data_home,
 )

=== modified file 'contrib/dump_metadata.py'
--- contrib/dump_metadata.py	2012-04-09 20:07:05 +0000
+++ contrib/dump_metadata.py	2012-06-25 20:40:24 +0000
@@ -44,7 +44,7 @@
     tritcask,
     volume_manager,
 )
-from ubuntu_sso.xdg_base_directory import (
+from dirspec.basedir import (
     xdg_cache_home,
     xdg_data_home,
 )

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2012-05-22 14:07:55 +0000
+++ contrib/testing/testcase.py	2012-06-25 20:40:24 +0000
@@ -197,7 +197,7 @@
 
     cancel_download = cancel_upload = download = upload = make_dir = disconnect
     make_file = move = unlink = list_shares = disconnect
-    list_volumes = create_share = create_udf = inquire_free_space =  disconnect
+    list_volumes = create_share = create_udf = inquire_free_space = disconnect
     inquire_account_info = delete_volume = change_public_access = disconnect
     query_volumes = get_delta = rescan_from_scratch = delete_share = disconnect
     node_is_with_queued_move = cleanup = get_public_files = disconnect
@@ -302,7 +302,7 @@
         mmtree(path): support read-only shares
         makedirs(path): support read-only shares
     """
-    MAX_FILENAME = 32 # some platforms limit lengths of filenames
+    MAX_FILENAME = 32  # some platforms limit lengths of filenames
     tunnel_runner_class = FakeTunnelRunner
 
     def mktemp(self, name='temp'):
@@ -407,7 +407,7 @@
                       self._testMethodName)
         # Patch the user home
         self.home_dir = self.mktemp('ubuntuonehacker')
-        self.patch(platform, "xdg_home", self.home_dir)
+        self.patch(platform, "user_home", self.home_dir)
         self.patch(action_queue.tunnel_runner, "TunnelRunner",
                    self.tunnel_runner_class)
 
@@ -448,7 +448,7 @@
     def __init__(self, root_path):
         """ Creates the instance"""
         self.root = volume_manager.Root(node_id="root_node_id", path=root_path)
-        self.shares = {'':self.root}
+        self.shares = {'': self.root}
         self.udfs = {}
         self.log = logging.getLogger('ubuntuone.SyncDaemon.VM-test')
 
@@ -686,3 +686,7 @@
 skip_if_win32_missing_fs_event = \
     skipIfOS('win32', 'Fails due to missing/out of order FS events, '
                       'see bug #820598.')
+
+skip_if_darwin_missing_fs_event = \
+    skipIfOS('darwin', 'Fails due to missing/out of order FS events, '
+                      'see bug #820598.')

=== modified file 'data/source_ubuntuone-client.py'
--- data/source_ubuntuone-client.py	2012-04-09 20:07:05 +0000
+++ data/source_ubuntuone-client.py	2012-06-25 20:40:24 +0000
@@ -33,7 +33,7 @@
 import apport
 from apport.hookutils import attach_file_if_exists
 import os.path
-from xdg.BaseDirectory import xdg_cache_home, xdg_config_home
+from dirspec.basedir import xdg_cache_home, xdg_config_home
 
 # Paths where things we might want live
 u1_log_path = os.path.join(xdg_cache_home, "ubuntuone", "log")

=== modified file 'data/syncdaemon.conf'
--- data/syncdaemon.conf	2012-06-13 17:09:19 +0000
+++ data/syncdaemon.conf	2012-06-25 20:40:24 +0000
@@ -85,6 +85,7 @@
                  \A\..*\.tmp\Z
                  \A\.~lock\..*#\Z
                  \A\.goutputstream-.*\Z
+                 \A.*-Spotlight\Z
  
 use_trash.default = True
 use_trash.parser = bool

=== modified file 'tests/platform/filesystem_notifications/__init__.py'
--- tests/platform/filesystem_notifications/__init__.py	2012-04-30 15:19:03 +0000
+++ tests/platform/filesystem_notifications/__init__.py	2012-06-25 20:40:24 +0000
@@ -25,3 +25,58 @@
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
 """Platform/File System Notifications test code."""
+
+import logging
+
+from twisted.internet import defer
+
+from ubuntuone.syncdaemon import (
+    event_queue,
+    filesystem_manager,
+)
+from contrib.testing import testcase
+from ubuntuone.devtools.handlers import MementoHandler
+from ubuntuone.syncdaemon.tritcask import Tritcask
+
+
+class BaseFSMonitorTestCase(testcase.BaseTwistedTestCase):
+    """Test the structures where we have the path/watch."""
+
+    timeout = 3
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up."""
+        yield super(BaseFSMonitorTestCase, self).setUp()
+        fsmdir = self.mktemp('fsmdir')
+        partials_dir = self.mktemp('partials_dir')
+        self.root_dir = self.mktemp('root_dir')
+        self.vm = testcase.FakeVolumeManager(self.root_dir)
+        self.tritcask_dir = self.mktemp("tritcask_dir")
+        self.db = Tritcask(self.tritcask_dir)
+        self.fs = filesystem_manager.FileSystemManager(fsmdir, partials_dir,
+                                                       self.vm, self.db)
+        self.fs.create(path=self.root_dir, share_id='', is_dir=True)
+        self.fs.set_by_path(path=self.root_dir,
+                            local_hash=None, server_hash=None)
+        eq = event_queue.EventQueue(self.fs)
+
+        self.deferred = deferred = defer.Deferred()
+
+        class HitMe(object):
+            # class-closure, cannot use self, pylint: disable-msg=E0213
+            def handle_default(innerself, event, **args):
+                deferred.callback(True)
+
+        eq.subscribe(HitMe())
+        self.monitor = eq.monitor
+        self.log_handler = MementoHandler()
+        self.log_handler.setLevel(logging.DEBUG)
+        self.monitor.log.addHandler(self.log_handler)
+
+    @defer.inlineCallbacks
+    def tearDown(self):
+        """Clean up the tests."""
+        self.monitor.shutdown()
+        self.monitor.log.removeHandler(self.log_handler)
+        yield super(BaseFSMonitorTestCase, self).tearDown()

=== modified file 'tests/platform/filesystem_notifications/test_linux.py'
--- tests/platform/filesystem_notifications/test_linux.py	2012-05-23 13:06:42 +0000
+++ tests/platform/filesystem_notifications/test_linux.py	2012-06-25 20:40:24 +0000
@@ -30,23 +30,17 @@
 # files in the program, then also delete it here.
 """Tests for the Event Queue."""
 
-import logging
 import os
 
 from twisted.internet import defer, reactor
 from twisted.trial.unittest import TestCase as PlainTestCase
 
-from ubuntuone.syncdaemon import (
-    event_queue,
-    filesystem_manager,
-)
 from contrib.testing import testcase
-from ubuntuone.devtools.handlers import MementoHandler
 from ubuntuone.syncdaemon import volume_manager
-from ubuntuone.syncdaemon.tritcask import Tritcask
 from ubuntuone.platform.filesystem_notifications import (
     linux as filesystem_notifications,
 )
+from tests.platform.filesystem_notifications import BaseFSMonitorTestCase
 
 # We normally access to private attribs in tests
 # pylint: disable=W0212
@@ -101,50 +95,6 @@
         self.assertFalse(processor.timer.active())
 
 
-
-class BaseFSMonitorTestCase(testcase.BaseTwistedTestCase):
-    """Test the structures where we have the path/watch."""
-
-    timeout = 3
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set up."""
-        yield super(BaseFSMonitorTestCase, self).setUp()
-        fsmdir = self.mktemp('fsmdir')
-        partials_dir = self.mktemp('partials_dir')
-        self.root_dir = self.mktemp('root_dir')
-        self.vm = testcase.FakeVolumeManager(self.root_dir)
-        self.tritcask_dir = self.mktemp("tritcask_dir")
-        self.db = Tritcask(self.tritcask_dir)
-        self.fs = filesystem_manager.FileSystemManager(fsmdir, partials_dir,
-                                                       self.vm, self.db)
-        self.fs.create(path=self.root_dir, share_id='', is_dir=True)
-        self.fs.set_by_path(path=self.root_dir,
-                            local_hash=None, server_hash=None)
-        eq = event_queue.EventQueue(self.fs)
-
-        self.deferred = deferred = defer.Deferred()
-
-        class HitMe(object):
-            # class-closure, cannot use self, pylint: disable-msg=E0213
-            def handle_default(innerself, event, **args):
-                deferred.callback(True)
-
-        eq.subscribe(HitMe())
-        self.monitor = eq.monitor
-        self.log_handler = MementoHandler()
-        self.log_handler.setLevel(logging.DEBUG)
-        self.monitor.log.addHandler(self.log_handler)
-
-    @defer.inlineCallbacks
-    def tearDown(self):
-        """Clean up the tests."""
-        self.monitor.shutdown()
-        self.monitor.log.removeHandler(self.log_handler)
-        yield super(BaseFSMonitorTestCase, self).tearDown()
-
-
 class WatchManagerTests(BaseFSMonitorTestCase):
     """Test the structures where we have the path/watch."""
 
@@ -222,7 +172,8 @@
         self.monitor._general_watchs = {'/path1/foo': 1, '/other': 2}
         self.monitor._ancestors_watchs = {'/foo': 3}
         self.monitor.inotify_watch_fix('/path1/foo', '/path1/new')
-        self.assertEqual(self.monitor._general_watchs, {'/path1/new': 1, '/other': 2})
+        self.assertEqual(self.monitor._general_watchs,
+            {'/path1/new': 1, '/other': 2})
         self.assertEqual(self.monitor._ancestors_watchs, {'/foo': 3})
 
     def test_fix_path_ancestors(self):
@@ -231,7 +182,8 @@
         self.monitor._ancestors_watchs = {'/oth': 1, '/other': 2}
         self.monitor.inotify_watch_fix('/oth', '/baz')
         self.assertEqual(self.monitor._general_watchs, {'/bar': 3})
-        self.assertEqual(self.monitor._ancestors_watchs, {'/baz': 1, '/other': 2})
+        self.assertEqual(self.monitor._ancestors_watchs,
+            {'/baz': 1, '/other': 2})
 
 
 class DynamicHitMe(object):

=== renamed file 'tests/platform/filesystem_notifier/test_windows.py' => 'tests/platform/filesystem_notifications/test_pyinotify_agnostic.py'
--- tests/platform/filesystem_notifier/test_windows.py	2012-05-14 21:24:24 +0000
+++ tests/platform/filesystem_notifications/test_pyinotify_agnostic.py	2012-06-25 20:40:24 +0000
@@ -30,6 +30,8 @@
 # files in the program, then also delete it here.
 """Test for the pyinotify implementation on windows."""
 
+import sys
+
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
 
@@ -51,7 +53,8 @@
         attr = 'attribute'
         self.format[attr] = attr
         value = u'ñoño'
-        expected_result = (attr + value.encode('mbcs', 'replace') +
+        expected_result = (attr + value.encode(
+                           sys.getfilesystemencoding(), 'replace') +
                            self.format['normal'])
         self.assertEqual(expected_result, self.formatter.simple(value, attr))
 

=== removed directory 'tests/platform/filesystem_notifier'
=== removed file 'tests/platform/filesystem_notifier/__init__.py'
--- tests/platform/filesystem_notifier/__init__.py	2012-05-14 19:04:43 +0000
+++ tests/platform/filesystem_notifier/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-# 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.
-"""Platform/File System Notifier (Pyinotify agnostic) test code."""

=== renamed file 'tests/platform/test_xdg_base_directory.py' => 'tests/platform/test_logger.py'
--- tests/platform/test_xdg_base_directory.py	2012-04-09 20:07:05 +0000
+++ tests/platform/test_logger.py	2012-06-25 20:40:24 +0000
@@ -1,7 +1,5 @@
 # -*- coding: utf-8 -*-
 #
-# Authors: Natalia B. Bidart <[e-mail]>
-#
 # Copyright 2011-2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -32,10 +30,10 @@
 
 import os
 
+from dirspec.basedir import xdg_cache_home
 from twisted.trial.unittest import TestCase
 
-from ubuntu_sso import xdg_base_directory
-from ubuntuone.platform.xdg_base_directory import ubuntuone_log_dir
+from ubuntuone.platform.logger import ubuntuone_log_dir
 
 
 class TestBaseDirectory(TestCase):
@@ -43,7 +41,7 @@
 
     def test_ubuntuone_log_dir(self):
         """The ubuntuone_log_dir is correct."""
-        expected = os.path.join(xdg_base_directory.xdg_cache_home,
+        expected = os.path.join(xdg_cache_home,
                                 'ubuntuone', 'log')
         self.assertEqual(expected, ubuntuone_log_dir)
         self.assertTrue(os.path.exists(expected))

=== modified file 'tests/syncdaemon/test_config.py'
--- tests/syncdaemon/test_config.py	2012-04-09 20:07:05 +0000
+++ tests/syncdaemon/test_config.py	2012-06-25 20:40:24 +0000
@@ -36,7 +36,7 @@
 from ConfigParser import ConfigParser
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
-from ubuntu_sso.xdg_base_directory import (
+from dirspec.basedir import (
     xdg_data_home,
     xdg_cache_home,
 )
@@ -562,7 +562,7 @@
     def test_good_value(self):
         """Test the parser using a good value."""
         homedir = os.path.join('', 'home', 'fake')
-        self.patch(platform, 'xdg_home', homedir)
+        self.patch(platform, 'user_home', homedir)
         expected = os.path.join(self.xdg_dir, 'hola', 'mundo')
         actual = self.parser(self.good_value)
         self.assertEqual(expected, actual)

=== modified file 'tests/syncdaemon/test_main.py'
--- tests/syncdaemon/test_main.py	2012-05-22 14:07:55 +0000
+++ tests/syncdaemon/test_main.py	2012-06-25 20:40:24 +0000
@@ -282,7 +282,7 @@
 
     def test_get_homedir(self):
         """The get_homedir returns the root dir."""
-        self.patch(main_mod, "xdg_home", self.home_dir)
+        self.patch(main_mod, "user_home", self.home_dir)
         expected = expand_user('~')
         main = self.build_main()
         self.assertEqual(main.get_homedir(), expected)

=== modified file 'ubuntuone/platform/__init__.py'
--- ubuntuone/platform/__init__.py	2012-05-14 19:04:43 +0000
+++ ubuntuone/platform/__init__.py	2012-06-25 20:40:24 +0000
@@ -31,7 +31,7 @@
 import os
 import sys
 
-from ubuntu_sso.xdg_base_directory import xdg_home
+from dirspec.utils import user_home
 
 # very hackish way to avoid "import *" to satisfy pyflakes
 # and to avoid import ubuntuone.platform.X as source (it wont work)
@@ -62,7 +62,7 @@
     if not path.startswith(tilde) or \
     (len(path) > 1 and path[1:2] != os.path.sep):
         return path
-    result = path.replace('~', xdg_home, 1)
+    result = path.replace('~', user_home, 1)
 
     assert isinstance(result, str)
     try:

=== modified file 'ubuntuone/platform/credentials/__init__.py'
--- ubuntuone/platform/credentials/__init__.py	2012-06-14 16:54:45 +0000
+++ ubuntuone/platform/credentials/__init__.py	2012-06-25 20:40:24 +0000
@@ -1,8 +1,5 @@
 # -*- coding: utf-8 -*-
 #
-# Author: Natalia B. Bidart <[e-mail]>
-# Author: Manuel de la Pena<[e-mail]>
-#
 # Copyright 2011-2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -57,7 +54,7 @@
     CustomRotatingFileHandler,
     log_call,
 )
-from ubuntuone.platform.xdg_base_directory import ubuntuone_log_dir
+from ubuntuone.platform.logger import ubuntuone_log_dir
 
 LOG_LEVEL = logging.DEBUG
 path = os.path.join(ubuntuone_log_dir, 'credentials.log')

=== modified file 'ubuntuone/platform/filesystem_notifications/pyinotify_agnostic.py'
--- ubuntuone/platform/filesystem_notifications/pyinotify_agnostic.py	2012-05-14 20:38:23 +0000
+++ ubuntuone/platform/filesystem_notifications/pyinotify_agnostic.py	2012-06-25 20:40:24 +0000
@@ -1,518 +1,518 @@
-#!/usr/bin/env python
-
-# pyinotify.py - python interface to inotify
-# Copyright (c) 2010 Sebastien Martini <[e-mail]>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-"""Platform agnostic code grabed from pyinotify."""
-import logging
-import os
-import sys
-
-COMPATIBILITY_MODE = False
-
-class PyinotifyError(Exception):
-    """Indicates exceptions raised by a Pyinotify class."""
-    pass
-
-
-class RawOutputFormat:
-    """
-    Format string representations.
-    """
-    def __init__(self, format=None):
-        self.format = format or {}
-
-    def simple(self, s, attribute):
-        if isinstance(s, unicode):
-            s = s.encode('mbcs', 'replace')
-        else:
-            s = str(s)
-        return (self.format.get(attribute, '') + s +
-                self.format.get('normal', ''))
-
-    def punctuation(self, s):
-        """Punctuation color."""
-        return self.simple(s, 'normal')
-
-    def field_value(self, s):
-        """Field value color."""
-        return self.simple(s, 'purple')
-
-    def field_name(self, s):
-        """Field name color."""
-        return self.simple(s, 'blue')
-
-    def class_name(self, s):
-        """Class name color."""
-        return self.format.get('red', '') + self.simple(s, 'bold')
-
-output_format = RawOutputFormat()
-
-
-class EventsCodes:
-    """
-    Set of codes corresponding to each kind of events.
-    Some of these flags are used to communicate with inotify, whereas
-    the others are sent to userspace by inotify notifying some events.
-
-    @cvar IN_ACCESS: File was accessed.
-    @type IN_ACCESS: int
-    @cvar IN_MODIFY: File was modified.
-    @type IN_MODIFY: int
-    @cvar IN_ATTRIB: Metadata changed.
-    @type IN_ATTRIB: int
-    @cvar IN_CLOSE_WRITE: Writtable file was closed.
-    @type IN_CLOSE_WRITE: int
-    @cvar IN_CLOSE_NOWRITE: Unwrittable file closed.
-    @type IN_CLOSE_NOWRITE: int
-    @cvar IN_OPEN: File was opened.
-    @type IN_OPEN: int
-    @cvar IN_MOVED_FROM: File was moved from X.
-    @type IN_MOVED_FROM: int
-    @cvar IN_MOVED_TO: File was moved to Y.
-    @type IN_MOVED_TO: int
-    @cvar IN_CREATE: Subfile was created.
-    @type IN_CREATE: int
-    @cvar IN_DELETE: Subfile was deleted.
-    @type IN_DELETE: int
-    @cvar IN_DELETE_SELF: Self (watched item itself) was deleted.
-    @type IN_DELETE_SELF: int
-    @cvar IN_MOVE_SELF: Self (watched item itself) was moved.
-    @type IN_MOVE_SELF: int
-    @cvar IN_UNMOUNT: Backing fs was unmounted.
-    @type IN_UNMOUNT: int
-    @cvar IN_Q_OVERFLOW: Event queued overflowed.
-    @type IN_Q_OVERFLOW: int
-    @cvar IN_IGNORED: File was ignored.
-    @type IN_IGNORED: int
-    @cvar IN_ONLYDIR: only watch the path if it is a directory (new
-                      in kernel 2.6.15).
-    @type IN_ONLYDIR: int
-    @cvar IN_DONT_FOLLOW: don't follow a symlink (new in kernel 2.6.15).
-                          IN_ONLYDIR we can make sure that we don't watch
-                          the target of symlinks.
-    @type IN_DONT_FOLLOW: int
-    @cvar IN_MASK_ADD: add to the mask of an already existing watch (new
-                       in kernel 2.6.14).
-    @type IN_MASK_ADD: int
-    @cvar IN_ISDIR: Event occurred against dir.
-    @type IN_ISDIR: int
-    @cvar IN_ONESHOT: Only send event once.
-    @type IN_ONESHOT: int
-    @cvar ALL_EVENTS: Alias for considering all of the events.
-    @type ALL_EVENTS: int
-    """
-
-    # The idea here is 'configuration-as-code' - this way, we get
-    # our nice class constants, but we also get nice human-friendly text
-    # mappings to do lookups against as well, for free:
-    FLAG_COLLECTIONS = {'OP_FLAGS': {
-        'IN_ACCESS'        : 0x00000001,  # File was accessed
-        'IN_MODIFY'        : 0x00000002,  # File was modified
-        'IN_ATTRIB'        : 0x00000004,  # Metadata changed
-        'IN_CLOSE_WRITE'   : 0x00000008,  # Writable file was closed
-        'IN_CLOSE_NOWRITE' : 0x00000010,  # Unwritable file closed
-        'IN_OPEN'          : 0x00000020,  # File was opened
-        'IN_MOVED_FROM'    : 0x00000040,  # File was moved from X
-        'IN_MOVED_TO'      : 0x00000080,  # File was moved to Y
-        'IN_CREATE'        : 0x00000100,  # Subfile was created
-        'IN_DELETE'        : 0x00000200,  # Subfile was deleted
-        'IN_DELETE_SELF'   : 0x00000400,  # Self (watched item itself)
-                                          # was deleted
-        'IN_MOVE_SELF'     : 0x00000800,  # Self(watched item itself) was moved
-        },
-                        'EVENT_FLAGS': {
-        'IN_UNMOUNT'       : 0x00002000,  # Backing fs was unmounted
-        'IN_Q_OVERFLOW'    : 0x00004000,  # Event queued overflowed
-        'IN_IGNORED'       : 0x00008000,  # File was ignored
-        },
-                        'SPECIAL_FLAGS': {
-        'IN_ONLYDIR'       : 0x01000000,  # only watch the path if it is a
-                                          # directory
-        'IN_DONT_FOLLOW'   : 0x02000000,  # don't follow a symlink
-        'IN_MASK_ADD'      : 0x20000000,  # add to the mask of an already
-                                          # existing watch
-        'IN_ISDIR'         : 0x40000000,  # event occurred against dir
-        'IN_ONESHOT'       : 0x80000000,  # only send event once
-        },
-                        }
-
-    def maskname(mask):
-        """
-        Returns the event name associated to mask. IN_ISDIR is appended to
-        the result when appropriate. Note: only one event is returned, because
-        only one event can be raised at a given time.
-
-        @param mask: mask.
-        @type mask: int
-        @return: event name.
-        @rtype: str
-        """
-        ms = mask
-        name = '%s'
-        if mask & IN_ISDIR:
-            ms = mask - IN_ISDIR
-            name = '%s|IN_ISDIR'
-        return name % EventsCodes.ALL_VALUES[ms]
-
-    maskname = staticmethod(maskname)
-
-
-# So let's now turn the configuration into code
-EventsCodes.ALL_FLAGS = {}
-EventsCodes.ALL_VALUES = {}
-for flagc, valc in EventsCodes.FLAG_COLLECTIONS.items():
-    # Make the collections' members directly accessible through the
-    # class dictionary
-    setattr(EventsCodes, flagc, valc)
-
-    # Collect all the flags under a common umbrella
-    EventsCodes.ALL_FLAGS.update(valc)
-
-    # Make the individual masks accessible as 'constants' at globals() scope
-    # and masknames accessible by values.
-    for name, val in valc.items():
-        globals()[name] = val
-        EventsCodes.ALL_VALUES[val] = name
-
-
-# all 'normal' events
-ALL_EVENTS = reduce(lambda x, y: x | y, EventsCodes.OP_FLAGS.values())
-EventsCodes.ALL_FLAGS['ALL_EVENTS'] = ALL_EVENTS
-EventsCodes.ALL_VALUES[ALL_EVENTS] = 'ALL_EVENTS'
-
-
-class _Event:
-    """
-    Event structure, represent events raised by the system. This
-    is the base class and should be subclassed.
-
-    """
-    def __init__(self, dict_):
-        """
-        Attach attributes (contained in dict_) to self.
-
-        @param dict_: Set of attributes.
-        @type dict_: dictionary
-        """
-        for tpl in dict_.items():
-            setattr(self, *tpl)
-
-    def __repr__(self):
-        """
-        @return: Generic event string representation.
-        @rtype: str
-        """
-        s = ''
-        for attr, value in sorted(self.__dict__.items(), key=lambda x: x[0]):
-            if attr.startswith('_'):
-                continue
-            if attr == 'mask':
-                value = hex(getattr(self, attr))
-            elif isinstance(value, basestring) and not value:
-                value = "''"
-            s += ' %s%s%s' % (output_format.field_name(attr),
-                              output_format.punctuation('='),
-                              output_format.field_value(value))
-
-        s = '%s%s%s %s' % (output_format.punctuation('<'),
-                           output_format.class_name(self.__class__.__name__),
-                           s,
-                           output_format.punctuation('>'))
-        return s
-
-    def __str__(self):
-        return repr(self)
-
-
-class _RawEvent(_Event):
-    """
-    Raw event, it contains only the informations provided by the system.
-    It doesn't infer anything.
-    """
-    def __init__(self, wd, mask, cookie, name):
-        """
-        @param wd: Watch Descriptor.
-        @type wd: int
-        @param mask: Bitmask of events.
-        @type mask: int
-        @param cookie: Cookie.
-        @type cookie: int
-        @param name: Basename of the file or directory against which the
-                     event was raised in case where the watched directory
-                     is the parent directory. None if the event was raised
-                     on the watched item itself.
-        @type name: string or None
-        """
-        # Use this variable to cache the result of str(self), this object
-        # is immutable.
-        self._str = None
-        # name: remove trailing '\0'
-        d = {'wd': wd,
-             'mask': mask,
-             'cookie': cookie,
-             'name': name.rstrip('\0')}
-        _Event.__init__(self, d)
-        logging.debug(str(self))
-
-    def __str__(self):
-        if self._str is None:
-            self._str = _Event.__str__(self)
-        return self._str
-
-
-class Event(_Event):
-    """
-    This class contains all the useful informations about the observed
-    event. However, the presence of each field is not guaranteed and
-    depends on the type of event. In effect, some fields are irrelevant
-    for some kind of event (for example 'cookie' is meaningless for
-    IN_CREATE whereas it is mandatory for IN_MOVE_TO).
-
-    The possible fields are:
-      - wd (int): Watch Descriptor.
-      - mask (int): Mask.
-      - maskname (str): Readable event name.
-      - path (str): path of the file or directory being watched.
-      - name (str): Basename of the file or directory against which the
-              event was raised in case where the watched directory
-              is the parent directory. None if the event was raised
-              on the watched item itself. This field is always provided
-              even if the string is ''.
-      - pathname (str): Concatenation of 'path' and 'name'.
-      - src_pathname (str): Only present for IN_MOVED_TO events and only in
-              the case where IN_MOVED_FROM events are watched too. Holds the
-              source pathname from where pathname was moved from.
-      - cookie (int): Cookie.
-      - dir (bool): True if the event was raised against a directory.
-
-    """
-    def __init__(self, raw):
-        """
-        Concretely, this is the raw event plus inferred infos.
-        """
-        _Event.__init__(self, raw)
-        self.maskname = EventsCodes.maskname(self.mask)
-        if COMPATIBILITY_MODE:
-            self.event_name = self.maskname
-        try:
-            if self.name:
-                self.pathname = os.path.abspath(os.path.join(self.path,
-                                                             self.name))
-            else:
-                self.pathname = os.path.abspath(self.path)
-        except AttributeError, err:
-            # Usually it is not an error some events are perfectly valids
-            # despite the lack of these attributes.
-            logging.debug(err)
-
-
-class ProcessEventError(PyinotifyError):
-    """
-    ProcessEventError Exception. Raised on ProcessEvent error.
-    """
-    def __init__(self, err):
-        """
-        @param err: Exception error description.
-        @type err: string
-        """
-        PyinotifyError.__init__(self, err)
-
-
-class _ProcessEvent:
-    """
-    Abstract processing event class.
-    """
-    def __call__(self, event):
-        """
-        To behave like a functor the object must be callable.
-        This method is a dispatch method. Its lookup order is:
-          1. process_MASKNAME method
-          2. process_FAMILY_NAME method
-          3. otherwise calls process_default
-
-        @param event: Event to be processed.
-        @type event: Event object
-        @return: By convention when used from the ProcessEvent class:
-                 - Returning False or None (default value) means keep on
-                 executing next chained functors (see chain.py example).
-                 - Returning True instead means do not execute next
-                   processing functions.
-        @rtype: bool
-        @raise ProcessEventError: Event object undispatchable,
-                                  unknown event.
-        """
-        stripped_mask = event.mask - (event.mask & IN_ISDIR)
-        maskname = EventsCodes.ALL_VALUES.get(stripped_mask)
-        if maskname is None:
-            raise ProcessEventError("Unknown mask 0x%08x" % stripped_mask)
-
-        # 1- look for process_MASKNAME
-        meth = getattr(self, 'process_' + maskname, None)
-        if meth is not None:
-            return meth(event)
-        # 2- look for process_FAMILY_NAME
-        meth = getattr(self, 'process_IN_' + maskname.split('_')[1], None)
-        if meth is not None:
-            return meth(event)
-        # 3- default call method process_default
-        return self.process_default(event)
-
-    def __repr__(self):
-        return '<%s>' % self.__class__.__name__
-
-
-class ProcessEvent(_ProcessEvent):
-    """
-    Process events objects, can be specialized via subclassing, thus its
-    behavior can be overriden:
-
-    Note: you should not override __init__ in your subclass instead define
-    a my_init() method, this method will be called automatically from the
-    constructor of this class with its optionals parameters.
-
-      1. Provide specialized individual methods, e.g. process_IN_DELETE for
-         processing a precise type of event (e.g. IN_DELETE in this case).
-      2. Or/and provide methods for processing events by 'family', e.g.
-         process_IN_CLOSE method will process both IN_CLOSE_WRITE and
-         IN_CLOSE_NOWRITE events (if process_IN_CLOSE_WRITE and
-         process_IN_CLOSE_NOWRITE aren't defined though).
-      3. Or/and override process_default for catching and processing all
-         the remaining types of events.
-    """
-    pevent = None
-
-    def __init__(self, pevent=None, **kargs):
-        """
-        Enable chaining of ProcessEvent instances.
-
-        @param pevent: Optional callable object, will be called on event
-                       processing (before self).
-        @type pevent: callable
-        @param kargs: This constructor is implemented as a template method
-                      delegating its optionals keyworded arguments to the
-                      method my_init().
-        @type kargs: dict
-        """
-        self.pevent = pevent
-        self.my_init(**kargs)
-
-    def my_init(self, **kargs):
-        """
-        This method is called from ProcessEvent.__init__(). This method is
-        empty here and must be redefined to be useful. In effect, if you
-        need to specifically initialize your subclass' instance then you
-        just have to override this method in your subclass. Then all the
-        keyworded arguments passed to ProcessEvent.__init__() will be
-        transmitted as parameters to this method. Beware you MUST pass
-        keyword arguments though.
-
-        @param kargs: optional delegated arguments from __init__().
-        @type kargs: dict
-        """
-        pass
-
-    def __call__(self, event):
-        stop_chaining = False
-        if self.pevent is not None:
-            # By default methods return None so we set as guideline
-            # that methods asking for stop chaining must explicitely
-            # return non None or non False values, otherwise the default
-            # behavior will be to accept chain call to the corresponding
-            # local method.
-            stop_chaining = self.pevent(event)
-        if not stop_chaining:
-            return _ProcessEvent.__call__(self, event)
-
-    def nested_pevent(self):
-        return self.pevent
-
-    def process_IN_Q_OVERFLOW(self, event):
-        """
-        By default this method only reports warning messages, you can
-        overredide it by subclassing ProcessEvent and implement your own
-        process_IN_Q_OVERFLOW method. The actions you can take on receiving
-        this event is either to update the variable max_queued_events in order
-        to handle more simultaneous events or to modify your code in order to
-        accomplish a better filtering diminishing the number of raised events.
-        Because this method is defined, IN_Q_OVERFLOW will never get
-        transmitted as arguments to process_default calls.
-
-        @param event: IN_Q_OVERFLOW event.
-        @type event: dict
-        """
-        logging.warning('Event queue overflowed.')
-
-    def process_default(self, event):
-        """
-        Default processing event method. By default does nothing. Subclass
-        ProcessEvent and redefine this method in order to modify its behavior.
-
-        @param event: Event to be processed. Can be of any type of events but
-                      IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW).
-        @type event: Event instance
-        """
-        pass
-
-
-class PrintAllEvents(ProcessEvent):
-    """
-    Dummy class used to print events strings representations. For instance this
-    class is used from command line to print all received events to stdout.
-    """
-    def my_init(self, out=None):
-        """
-        @param out: Where events will be written.
-        @type out: Object providing a valid file object interface.
-        """
-        if out is None:
-            out = sys.stdout
-        self._out = out
-
-    def process_default(self, event):
-        """
-        Writes event string representation to file object provided to
-        my_init().
-
-        @param event: Event to be processed. Can be of any type of events but
-                      IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW).
-        @type event: Event instance
-        """
-        self._out.write(str(event))
-        self._out.write('\n')
-        self._out.flush()
-
-
-class WatchManagerError(Exception):
-    """
-    WatchManager Exception. Raised on error encountered on watches
-    operations.
-
-    """
-    def __init__(self, msg, wmd):
-        """
-        @param msg: Exception string's description.
-        @type msg: string
-        @param wmd: This dictionary contains the wd assigned to paths of the
-                    same call for which watches were successfully added.
-        @type wmd: dict
-        """
-        self.wmd = wmd
-        Exception.__init__(self, msg)
+#!/usr/bin/env python
+
+# pyinotify.py - python interface to inotify
+# Copyright (c) 2010 Sebastien Martini <[e-mail]>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+"""Platform agnostic code grabed from pyinotify."""
+import logging
+import os
+import sys
+
+COMPATIBILITY_MODE = False
+
+class PyinotifyError(Exception):
+    """Indicates exceptions raised by a Pyinotify class."""
+    pass
+
+
+class RawOutputFormat:
+    """
+    Format string representations.
+    """
+    def __init__(self, format=None):
+        self.format = format or {}
+
+    def simple(self, s, attribute):
+        if isinstance(s, unicode):
+            s = s.encode(sys.getfilesystemencoding(), 'replace')
+        else:
+            s = str(s)
+        return (self.format.get(attribute, '') + s +
+                self.format.get('normal', ''))
+
+    def punctuation(self, s):
+        """Punctuation color."""
+        return self.simple(s, 'normal')
+
+    def field_value(self, s):
+        """Field value color."""
+        return self.simple(s, 'purple')
+
+    def field_name(self, s):
+        """Field name color."""
+        return self.simple(s, 'blue')
+
+    def class_name(self, s):
+        """Class name color."""
+        return self.format.get('red', '') + self.simple(s, 'bold')
+
+output_format = RawOutputFormat()
+
+
+class EventsCodes:
+    """
+    Set of codes corresponding to each kind of events.
+    Some of these flags are used to communicate with inotify, whereas
+    the others are sent to userspace by inotify notifying some events.
+
+    @cvar IN_ACCESS: File was accessed.
+    @type IN_ACCESS: int
+    @cvar IN_MODIFY: File was modified.
+    @type IN_MODIFY: int
+    @cvar IN_ATTRIB: Metadata changed.
+    @type IN_ATTRIB: int
+    @cvar IN_CLOSE_WRITE: Writtable file was closed.
+    @type IN_CLOSE_WRITE: int
+    @cvar IN_CLOSE_NOWRITE: Unwrittable file closed.
+    @type IN_CLOSE_NOWRITE: int
+    @cvar IN_OPEN: File was opened.
+    @type IN_OPEN: int
+    @cvar IN_MOVED_FROM: File was moved from X.
+    @type IN_MOVED_FROM: int
+    @cvar IN_MOVED_TO: File was moved to Y.
+    @type IN_MOVED_TO: int
+    @cvar IN_CREATE: Subfile was created.
+    @type IN_CREATE: int
+    @cvar IN_DELETE: Subfile was deleted.
+    @type IN_DELETE: int
+    @cvar IN_DELETE_SELF: Self (watched item itself) was deleted.
+    @type IN_DELETE_SELF: int
+    @cvar IN_MOVE_SELF: Self (watched item itself) was moved.
+    @type IN_MOVE_SELF: int
+    @cvar IN_UNMOUNT: Backing fs was unmounted.
+    @type IN_UNMOUNT: int
+    @cvar IN_Q_OVERFLOW: Event queued overflowed.
+    @type IN_Q_OVERFLOW: int
+    @cvar IN_IGNORED: File was ignored.
+    @type IN_IGNORED: int
+    @cvar IN_ONLYDIR: only watch the path if it is a directory (new
+                      in kernel 2.6.15).
+    @type IN_ONLYDIR: int
+    @cvar IN_DONT_FOLLOW: don't follow a symlink (new in kernel 2.6.15).
+                          IN_ONLYDIR we can make sure that we don't watch
+                          the target of symlinks.
+    @type IN_DONT_FOLLOW: int
+    @cvar IN_MASK_ADD: add to the mask of an already existing watch (new
+                       in kernel 2.6.14).
+    @type IN_MASK_ADD: int
+    @cvar IN_ISDIR: Event occurred against dir.
+    @type IN_ISDIR: int
+    @cvar IN_ONESHOT: Only send event once.
+    @type IN_ONESHOT: int
+    @cvar ALL_EVENTS: Alias for considering all of the events.
+    @type ALL_EVENTS: int
+    """
+
+    # The idea here is 'configuration-as-code' - this way, we get
+    # our nice class constants, but we also get nice human-friendly text
+    # mappings to do lookups against as well, for free:
+    FLAG_COLLECTIONS = {'OP_FLAGS': {
+        'IN_ACCESS'        : 0x00000001,  # File was accessed
+        'IN_MODIFY'        : 0x00000002,  # File was modified
+        'IN_ATTRIB'        : 0x00000004,  # Metadata changed
+        'IN_CLOSE_WRITE'   : 0x00000008,  # Writable file was closed
+        'IN_CLOSE_NOWRITE' : 0x00000010,  # Unwritable file closed
+        'IN_OPEN'          : 0x00000020,  # File was opened
+        'IN_MOVED_FROM'    : 0x00000040,  # File was moved from X
+        'IN_MOVED_TO'      : 0x00000080,  # File was moved to Y
+        'IN_CREATE'        : 0x00000100,  # Subfile was created
+        'IN_DELETE'        : 0x00000200,  # Subfile was deleted
+        'IN_DELETE_SELF'   : 0x00000400,  # Self (watched item itself)
+                                          # was deleted
+        'IN_MOVE_SELF'     : 0x00000800,  # Self(watched item itself) was moved
+        },
+                        'EVENT_FLAGS': {
+        'IN_UNMOUNT'       : 0x00002000,  # Backing fs was unmounted
+        'IN_Q_OVERFLOW'    : 0x00004000,  # Event queued overflowed
+        'IN_IGNORED'       : 0x00008000,  # File was ignored
+        },
+                        'SPECIAL_FLAGS': {
+        'IN_ONLYDIR'       : 0x01000000,  # only watch the path if it is a
+                                          # directory
+        'IN_DONT_FOLLOW'   : 0x02000000,  # don't follow a symlink
+        'IN_MASK_ADD'      : 0x20000000,  # add to the mask of an already
+                                          # existing watch
+        'IN_ISDIR'         : 0x40000000,  # event occurred against dir
+        'IN_ONESHOT'       : 0x80000000,  # only send event once
+        },
+                        }
+
+    def maskname(mask):
+        """
+        Returns the event name associated to mask. IN_ISDIR is appended to
+        the result when appropriate. Note: only one event is returned, because
+        only one event can be raised at a given time.
+
+        @param mask: mask.
+        @type mask: int
+        @return: event name.
+        @rtype: str
+        """
+        ms = mask
+        name = '%s'
+        if mask & IN_ISDIR:
+            ms = mask - IN_ISDIR
+            name = '%s|IN_ISDIR'
+        return name % EventsCodes.ALL_VALUES[ms]
+
+    maskname = staticmethod(maskname)
+
+
+# So let's now turn the configuration into code
+EventsCodes.ALL_FLAGS = {}
+EventsCodes.ALL_VALUES = {}
+for flagc, valc in EventsCodes.FLAG_COLLECTIONS.items():
+    # Make the collections' members directly accessible through the
+    # class dictionary
+    setattr(EventsCodes, flagc, valc)
+
+    # Collect all the flags under a common umbrella
+    EventsCodes.ALL_FLAGS.update(valc)
+
+    # Make the individual masks accessible as 'constants' at globals() scope
+    # and masknames accessible by values.
+    for name, val in valc.items():
+        globals()[name] = val
+        EventsCodes.ALL_VALUES[val] = name
+
+
+# all 'normal' events
+ALL_EVENTS = reduce(lambda x, y: x | y, EventsCodes.OP_FLAGS.values())
+EventsCodes.ALL_FLAGS['ALL_EVENTS'] = ALL_EVENTS
+EventsCodes.ALL_VALUES[ALL_EVENTS] = 'ALL_EVENTS'
+
+
+class _Event:
+    """
+    Event structure, represent events raised by the system. This
+    is the base class and should be subclassed.
+
+    """
+    def __init__(self, dict_):
+        """
+        Attach attributes (contained in dict_) to self.
+
+        @param dict_: Set of attributes.
+        @type dict_: dictionary
+        """
+        for tpl in dict_.items():
+            setattr(self, *tpl)
+
+    def __repr__(self):
+        """
+        @return: Generic event string representation.
+        @rtype: str
+        """
+        s = ''
+        for attr, value in sorted(self.__dict__.items(), key=lambda x: x[0]):
+            if attr.startswith('_'):
+                continue
+            if attr == 'mask':
+                value = hex(getattr(self, attr))
+            elif isinstance(value, basestring) and not value:
+                value = "''"
+            s += ' %s%s%s' % (output_format.field_name(attr),
+                              output_format.punctuation('='),
+                              output_format.field_value(value))
+
+        s = '%s%s%s %s' % (output_format.punctuation('<'),
+                           output_format.class_name(self.__class__.__name__),
+                           s,
+                           output_format.punctuation('>'))
+        return s
+
+    def __str__(self):
+        return repr(self)
+
+
+class _RawEvent(_Event):
+    """
+    Raw event, it contains only the informations provided by the system.
+    It doesn't infer anything.
+    """
+    def __init__(self, wd, mask, cookie, name):
+        """
+        @param wd: Watch Descriptor.
+        @type wd: int
+        @param mask: Bitmask of events.
+        @type mask: int
+        @param cookie: Cookie.
+        @type cookie: int
+        @param name: Basename of the file or directory against which the
+                     event was raised in case where the watched directory
+                     is the parent directory. None if the event was raised
+                     on the watched item itself.
+        @type name: string or None
+        """
+        # Use this variable to cache the result of str(self), this object
+        # is immutable.
+        self._str = None
+        # name: remove trailing '\0'
+        d = {'wd': wd,
+             'mask': mask,
+             'cookie': cookie,
+             'name': name.rstrip('\0')}
+        _Event.__init__(self, d)
+        logging.debug(str(self))
+
+    def __str__(self):
+        if self._str is None:
+            self._str = _Event.__str__(self)
+        return self._str
+
+
+class Event(_Event):
+    """
+    This class contains all the useful informations about the observed
+    event. However, the presence of each field is not guaranteed and
+    depends on the type of event. In effect, some fields are irrelevant
+    for some kind of event (for example 'cookie' is meaningless for
+    IN_CREATE whereas it is mandatory for IN_MOVE_TO).
+
+    The possible fields are:
+      - wd (int): Watch Descriptor.
+      - mask (int): Mask.
+      - maskname (str): Readable event name.
+      - path (str): path of the file or directory being watched.
+      - name (str): Basename of the file or directory against which the
+              event was raised in case where the watched directory
+              is the parent directory. None if the event was raised
+              on the watched item itself. This field is always provided
+              even if the string is ''.
+      - pathname (str): Concatenation of 'path' and 'name'.
+      - src_pathname (str): Only present for IN_MOVED_TO events and only in
+              the case where IN_MOVED_FROM events are watched too. Holds the
+              source pathname from where pathname was moved from.
+      - cookie (int): Cookie.
+      - dir (bool): True if the event was raised against a directory.
+
+    """
+    def __init__(self, raw):
+        """
+        Concretely, this is the raw event plus inferred infos.
+        """
+        _Event.__init__(self, raw)
+        self.maskname = EventsCodes.maskname(self.mask)
+        if COMPATIBILITY_MODE:
+            self.event_name = self.maskname
+        try:
+            if self.name:
+                self.pathname = os.path.abspath(os.path.join(self.path,
+                                                             self.name))
+            else:
+                self.pathname = os.path.abspath(self.path)
+        except AttributeError, err:
+            # Usually it is not an error some events are perfectly valids
+            # despite the lack of these attributes.
+            logging.debug(err)
+
+
+class ProcessEventError(PyinotifyError):
+    """
+    ProcessEventError Exception. Raised on ProcessEvent error.
+    """
+    def __init__(self, err):
+        """
+        @param err: Exception error description.
+        @type err: string
+        """
+        PyinotifyError.__init__(self, err)
+
+
+class _ProcessEvent:
+    """
+    Abstract processing event class.
+    """
+    def __call__(self, event):
+        """
+        To behave like a functor the object must be callable.
+        This method is a dispatch method. Its lookup order is:
+          1. process_MASKNAME method
+          2. process_FAMILY_NAME method
+          3. otherwise calls process_default
+
+        @param event: Event to be processed.
+        @type event: Event object
+        @return: By convention when used from the ProcessEvent class:
+                 - Returning False or None (default value) means keep on
+                 executing next chained functors (see chain.py example).
+                 - Returning True instead means do not execute next
+                   processing functions.
+        @rtype: bool
+        @raise ProcessEventError: Event object undispatchable,
+                                  unknown event.
+        """
+        stripped_mask = event.mask - (event.mask & IN_ISDIR)
+        maskname = EventsCodes.ALL_VALUES.get(stripped_mask)
+        if maskname is None:
+            raise ProcessEventError("Unknown mask 0x%08x" % stripped_mask)
+
+        # 1- look for process_MASKNAME
+        meth = getattr(self, 'process_' + maskname, None)
+        if meth is not None:
+            return meth(event)
+        # 2- look for process_FAMILY_NAME
+        meth = getattr(self, 'process_IN_' + maskname.split('_')[1], None)
+        if meth is not None:
+            return meth(event)
+        # 3- default call method process_default
+        return self.process_default(event)
+
+    def __repr__(self):
+        return '<%s>' % self.__class__.__name__
+
+
+class ProcessEvent(_ProcessEvent):
+    """
+    Process events objects, can be specialized via subclassing, thus its
+    behavior can be overriden:
+
+    Note: you should not override __init__ in your subclass instead define
+    a my_init() method, this method will be called automatically from the
+    constructor of this class with its optionals parameters.
+
+      1. Provide specialized individual methods, e.g. process_IN_DELETE for
+         processing a precise type of event (e.g. IN_DELETE in this case).
+      2. Or/and provide methods for processing events by 'family', e.g.
+         process_IN_CLOSE method will process both IN_CLOSE_WRITE and
+         IN_CLOSE_NOWRITE events (if process_IN_CLOSE_WRITE and
+         process_IN_CLOSE_NOWRITE aren't defined though).
+      3. Or/and override process_default for catching and processing all
+         the remaining types of events.
+    """
+    pevent = None
+
+    def __init__(self, pevent=None, **kargs):
+        """
+        Enable chaining of ProcessEvent instances.
+
+        @param pevent: Optional callable object, will be called on event
+                       processing (before self).
+        @type pevent: callable
+        @param kargs: This constructor is implemented as a template method
+                      delegating its optionals keyworded arguments to the
+                      method my_init().
+        @type kargs: dict
+        """
+        self.pevent = pevent
+        self.my_init(**kargs)
+
+    def my_init(self, **kargs):
+        """
+        This method is called from ProcessEvent.__init__(). This method is
+        empty here and must be redefined to be useful. In effect, if you
+        need to specifically initialize your subclass' instance then you
+        just have to override this method in your subclass. Then all the
+        keyworded arguments passed to ProcessEvent.__init__() will be
+        transmitted as parameters to this method. Beware you MUST pass
+        keyword arguments though.
+
+        @param kargs: optional delegated arguments from __init__().
+        @type kargs: dict
+        """
+        pass
+
+    def __call__(self, event):
+        stop_chaining = False
+        if self.pevent is not None:
+            # By default methods return None so we set as guideline
+            # that methods asking for stop chaining must explicitely
+            # return non None or non False values, otherwise the default
+            # behavior will be to accept chain call to the corresponding
+            # local method.
+            stop_chaining = self.pevent(event)
+        if not stop_chaining:
+            return _ProcessEvent.__call__(self, event)
+
+    def nested_pevent(self):
+        return self.pevent
+
+    def process_IN_Q_OVERFLOW(self, event):
+        """
+        By default this method only reports warning messages, you can
+        overredide it by subclassing ProcessEvent and implement your own
+        process_IN_Q_OVERFLOW method. The actions you can take on receiving
+        this event is either to update the variable max_queued_events in order
+        to handle more simultaneous events or to modify your code in order to
+        accomplish a better filtering diminishing the number of raised events.
+        Because this method is defined, IN_Q_OVERFLOW will never get
+        transmitted as arguments to process_default calls.
+
+        @param event: IN_Q_OVERFLOW event.
+        @type event: dict
+        """
+        logging.warning('Event queue overflowed.')
+
+    def process_default(self, event):
+        """
+        Default processing event method. By default does nothing. Subclass
+        ProcessEvent and redefine this method in order to modify its behavior.
+
+        @param event: Event to be processed. Can be of any type of events but
+                      IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW).
+        @type event: Event instance
+        """
+        pass
+
+
+class PrintAllEvents(ProcessEvent):
+    """
+    Dummy class used to print events strings representations. For instance this
+    class is used from command line to print all received events to stdout.
+    """
+    def my_init(self, out=None):
+        """
+        @param out: Where events will be written.
+        @type out: Object providing a valid file object interface.
+        """
+        if out is None:
+            out = sys.stdout
+        self._out = out
+
+    def process_default(self, event):
+        """
+        Writes event string representation to file object provided to
+        my_init().
+
+        @param event: Event to be processed. Can be of any type of events but
+                      IN_Q_OVERFLOW events (see method process_IN_Q_OVERFLOW).
+        @type event: Event instance
+        """
+        self._out.write(str(event))
+        self._out.write('\n')
+        self._out.flush()
+
+
+class WatchManagerError(Exception):
+    """
+    WatchManager Exception. Raised on error encountered on watches
+    operations.
+
+    """
+    def __init__(self, msg, wmd):
+        """
+        @param msg: Exception string's description.
+        @type msg: string
+        @param wmd: This dictionary contains the wd assigned to paths of the
+                    same call for which watches were successfully added.
+        @type wmd: dict
+        """
+        self.wmd = wmd
+        Exception.__init__(self, msg)

=== modified file 'ubuntuone/platform/logger/__init__.py'
--- ubuntuone/platform/logger/__init__.py	2012-05-16 16:24:23 +0000
+++ ubuntuone/platform/logger/__init__.py	2012-06-25 20:40:24 +0000
@@ -28,8 +28,10 @@
 # files in the program, then also delete it here.
 """Logger module."""
 
+import os
 import sys
 
+from dirspec.basedir import xdg_cache_home
 
 if sys.platform == "win32":
     from ubuntuone.platform.logger import windows
@@ -44,3 +46,8 @@
 
 get_filesystem_logger = source.get_filesystem_logger
 setup_filesystem_logging = source.setup_filesystem_logging
+
+ubuntuone_log_dir = os.path.join(xdg_cache_home, 'ubuntuone', 'log')
+ubuntuone_log_dir = ubuntuone_log_dir.decode('utf-8')
+if not os.path.exists(ubuntuone_log_dir):
+    os.makedirs(ubuntuone_log_dir)

=== modified file 'ubuntuone/platform/os_helper/darwin.py'
--- ubuntuone/platform/os_helper/darwin.py	2012-05-17 12:23:12 +0000
+++ ubuntuone/platform/os_helper/darwin.py	2012-06-25 20:40:24 +0000
@@ -107,4 +107,4 @@
 
 def set_application_name(app_name):
     """Set the name of the application."""
-    raise Exception("This is not the way to do it on OS X")
+    # nothing to be done let the plist take care of it

=== removed directory 'ubuntuone/platform/xdg_base_directory'
=== removed file 'ubuntuone/platform/xdg_base_directory/__init__.py'
--- ubuntuone/platform/xdg_base_directory/__init__.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/platform/xdg_base_directory/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-# Author: Natalia B. Bidart <[e-mail]>
-#
-# 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.
-"""Defines a constant for ubuntuone's log folder based on XDG."""
-
-import os
-
-from ubuntu_sso.xdg_base_directory import xdg_cache_home, native_path
-
-# All usage of the ubuntuone_log_dir is for native access,
-# so we only change it here
-ubuntuone_log_dir = os.path.join(xdg_cache_home, 'ubuntuone', 'log')
-ubuntuone_log_dir = native_path(ubuntuone_log_dir)
-if not os.path.exists(ubuntuone_log_dir):
-    os.makedirs(ubuntuone_log_dir)

=== modified file 'ubuntuone/proxy/logger.py'
--- ubuntuone/proxy/logger.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/proxy/logger.py	2012-06-25 20:40:24 +0000
@@ -36,7 +36,7 @@
     CustomRotatingFileHandler,
 )
 
-from ubuntuone.platform.xdg_base_directory import ubuntuone_log_dir
+from ubuntuone.platform.logger import ubuntuone_log_dir
 
 
 LOGFILENAME = os.path.join(ubuntuone_log_dir, 'proxy.log')

=== modified file 'ubuntuone/status/logger.py'
--- ubuntuone/status/logger.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/status/logger.py	2012-06-25 20:40:24 +0000
@@ -1,8 +1,5 @@
 # ubuntuone.syncdaemon.logger - logging utilities
 #
-# Author: Guillermo Gonzalez <[e-mail]>
-#         Eric Casteleijn <[e-mail]>
-#
 # Copyright 2009-2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -40,7 +37,7 @@
     CustomRotatingFileHandler,
 )
 
-from ubuntuone.platform.xdg_base_directory import ubuntuone_log_dir
+from ubuntuone.platform.logger import ubuntuone_log_dir
 
 
 LOGFILENAME = os.path.join(ubuntuone_log_dir, 'status.log')

=== modified file 'ubuntuone/syncdaemon/config.py'
--- ubuntuone/syncdaemon/config.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/config.py	2012-06-25 20:40:24 +0000
@@ -36,9 +36,8 @@
 
 from ConfigParser import NoOptionError, NoSectionError
 from optparse import OptionParser
-from ubuntu_sso.xdg_base_directory import (
+from dirspec.basedir import (
     load_config_paths,
-    native_path,
     save_config_path,
     xdg_data_home,
     xdg_cache_home,
@@ -83,7 +82,7 @@
 logger = logging.getLogger('ubuntuone.SyncDaemon.config')
 
 # get (and possibly create if don't exists) the user config file
-_user_config_path = os.path.join(native_path(save_config_path('ubuntuone')),
+_user_config_path = os.path.join(save_config_path('ubuntuone'),
                                  CONFIG_FILE)
 
 # module private config instance.
@@ -166,7 +165,6 @@
     """
     config_files = []
     for xdg_config_dir in load_config_paths('ubuntuone'):
-        xdg_config_dir = native_path(xdg_config_dir)
         config_file = os.path.join(xdg_config_dir, CONFIG_FILE)
         if os.path.exists(config_file):
             config_files.append(config_file)

=== modified file 'ubuntuone/syncdaemon/logger.py'
--- ubuntuone/syncdaemon/logger.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/logger.py	2012-06-25 20:40:24 +0000
@@ -1,7 +1,5 @@
 # ubuntuone.syncdaemon.logger - logging utilities
 #
-# Author: Guillermo Gonzalez <[e-mail]>
-#
 # Copyright 2009-2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -45,7 +43,7 @@
     Logger,
     MultiFilter,
 )
-from ubuntuone.platform.xdg_base_directory import ubuntuone_log_dir
+from ubuntuone.platform.logger import ubuntuone_log_dir
 # api compatibility imports
 from ubuntuone import logger
 from ubuntuone.platform import get_filesystem_logger, setup_filesystem_logging

=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2012-05-22 14:07:55 +0000
+++ ubuntuone/syncdaemon/main.py	2012-06-25 20:40:24 +0000
@@ -32,9 +32,9 @@
 import os
 import sys
 
+from dirspec.utils import user_home
 from twisted.internet import defer, reactor, task
 
-from ubuntu_sso.xdg_base_directory import native_path, xdg_home
 from ubuntuone.syncdaemon import (
     action_queue,
     config,
@@ -111,7 +111,7 @@
         self.logger.info("Using %r as root dir", self.root_dir)
         self.logger.info("Using %r as data dir", self.data_dir)
         self.logger.info("Using %r as shares root dir", self.shares_dir)
-        self.db = tritcask.Tritcask(native_path(tritcask_dir))
+        self.db = tritcask.Tritcask(tritcask_dir)
         self.vm = volume_manager.VolumeManager(self)
         self.fs = filesystem_manager.FileSystemManager(
             data_dir, partials_dir, self.vm, self.db)
@@ -266,7 +266,7 @@
 
     def get_homedir(self):
         """Return the home dir point."""
-        return xdg_home
+        return user_home
 
     def get_rootdir(self):
         """Return the base dir/mount point."""