Merge lp:~mikemc/ubuntuone-control-panel/launchdaemon into lp:ubuntuone-control-panel

[Mike McCracken]

- Darwin: use ServiceManagement API to securely install, check versions, and upgrade root fsevents daemon.

- Darwin: use ServiceManagement API to securely install, check versions, and upgrade root fsevents daemon.

** NOTES ABOUT WHAT IS GOING ON HERE **

This calls a bunch of CoreFoundation APIs using ctypes so the first 140 lines or so of the diff are ctypes boilerplate that sets up the types for the CF functions.

start reading at check_and_install_fsevents_daemon().
This function compares the version of the daemon that's packaged in the app's bundle (at daemon_path) to the version that's installed, if it exists.

If the installed one is the same, we're done. If it's newer, we raise an exception.
If it's older, we remove it. Then we install the new one.

The twist in this method is that we have to get authorization (show a dialog box) once to remove the old job, and then kill that authorization (calling AuthorizationFree with the kAuthorizationFlagDestroyRights flag, to remove it from the cache as well as freeing the authref's memory) before we can get the **same** authorization again to install the new job. This is annoying and I only figured it out via trial and error, one Apple dev rep said it shouldn't be necessary, but it's the only way I could get it to work.

Nothing else is all that tricky, the other functions are just wrapping a CoreFoundation call and checking the error message.

-- about CFShow: I had half a day of unicode annoyance trying to get the error description copied into a printable python string, and gave up and used CFShow. It just prints the description to stdout. It's the CF equivalent of NSLog or 'print'. It's sufficient to get the error messages somewhere readable.

-- About CFRelease(): the rule is that if you call a function that has "create" or "copy" in its name, then you'll need to release its return value. If you call a function that has "get", you don't own it and shouldn't release it.

-- about get_authorization(): the name of the right we request here and the flags we pass are from apple's sample code. If you check their docs, you might notice that SMJobRemove should require a different right. The docs are wrong or at least incomplete. We only need kSMRightBlessPrivilegedHelper.

** notes on testing **

This includes new tests in ubuntuone/controlpanel/utils/tests/test_darwin.py.
Those tests pass for me, but trunk still has some failing tests in share_links.py, which are unrelated.
pylint doesn't work right for me on darwin, but this branch adds no new pyflakes errors.

To IRL-test, talk to mmcc on IRC, or use the bundles I've built.
Building the bundle correctly with code signing - but not using my cert - will require changing the cert CN in the code for the daemon (in a branch not in trunk there) as well as the setup-mac script.

Using my bundles, here's how to test:
(Note that you need to have the line saying 'fs_monitor.default' end with 'daemon' not 'default' in syncdaemon.conf for the code to run the monitor. It'll still try to install either way.)

Test that running the app installs a daemon using this:
% sudo launchctl list com.ubuntu.one.fsevents

remove it with
% sudo launchctl remove com.ubuntu.one.fsevents

then install an old version of the daemon by running an old build of the app. Not the alpha 1, it didn't have this branch. -- Again, talk to me, I have an old one laying around.

Then run the new one again, with U1_DEBUG=1 and look at the log, does it say it found 1.0 and replaced it with 1.1? Then it worked.

Also, does the file sync work? Only version 1.1 of the fsevents daemon correctly sends events to the client.

[Mike McCracken (mikemc)]

If you want to review this before I wake up, here's a signed build with this branch that just uploaded itself: http://ubuntuone.com/4KKHgfhAK46ABkOuvrdZci

[Roberto Alsina (ralsina)]

Tested IRL and read the code. AFAICS it looks good.

review: Approve

[Manuel de la Peña (mandel)]

In the following code:

354 + try:
355 + remove_fsevents_daemon(authRef)
356 + except Exception, e:
357 + logger.exception("Problem removing running daemon: %r" % e)
358 +
359 + AuthorizationFree(authRef, kAuthorizationFlagDestroyRights)

shouldn't the Free be called in a finally clause?

In the InstallDaemonTestCase you can move the following to the setup instead of calling it in each of the tests:

469 + self._patch_and_track(utils.darwin,
470 + [('get_authorization', 'Fake AuthRef'),
471 + ('remove_fsevents_daemon', None),
472 + ('install_fsevents_daemon', None),
473 + ('AuthorizationFree', None)])

review: Needs Fixing

[Mike McCracken (mikemc)]

We just log that exception and don't re-raise it, so no - we will always call that AuthorizationFree.

The repeated patch call is now in setup.

[Manuel de la Peña (mandel)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~mikemc/ubuntuone-control-panel/launchdaemon into lp:ubuntuone-control-panel failed. Below is the output from the failed tests.

*** Running DBus test suite ***
ubuntuone.controlpanel.dbustests.test_dbus_service
  BaseTestCase
    runTest ... [OK]
  DBusServiceMainTestCase
    test_dbus_service_cant_register ... Control panel backend already running.
                                   [OK]
    test_dbus_service_main ... [OK]
  DBusServiceTestCase
    test_cant_register_twice ... [SKIPPED]
    test_dbus_busname_created ... [OK]
    test_error_handler_default ... [OK]
    test_error_handler_with_exception ... [OK]
    test_error_handler_with_failure ... [OK]
    test_error_handler_with_non_string_dict ... [OK]
    test_error_handler_with_string_dict ... [OK]
    test_register_service ... [OK]
  FileSyncTestCase
    test_file_sync_status_changed ... [OK]
    test_file_sync_status_disabled ... [OK]
    test_file_sync_status_disconnected ... [OK]
    test_file_sync_status_error ... [OK]
    test_file_sync_status_idle ... [OK]
    test_file_sync_status_starting ... [OK]
    test_file_sync_status_stopped ... [OK]
    test_file_sync_status_syncing ... [OK]
    test_file_sync_status_unknown ... [OK]
    test_status_changed_handler ... [OK]
    test_status_changed_handler_after_status_requested ... [OK]
    test_status_changed_handler_after_status_requested_twice ... [OK]
  OperationsAuthErrorTestCase
    test_account_info_returned ... [OK]
    test_change_device_settings ... [OK]
    test_change_replication_settings ... [OK]
    test_change_volume_settings ... [OK]
    test_connect_files ... [OK]
    test_devices_info_returned ... [OK]
    test_disable_files ... [OK]
    test_disconnect_files ... [OK]
    test_enable_files ... [OK]
    test_remove_device ... [OK]
    test_replications_info ... [OK]
    test_restart_files ... [OK]
    test_star...

[lp:~mikemc/ubuntuone-control-panel/launchdaemon]

361. By Mike McCracken on 2012-09-28

fix lint errors

=== modified file 'ubuntuone/controlpanel/utils/darwin.py'
--- ubuntuone/controlpanel/utils/darwin.py	2012-08-06 16:47:44 +0000
+++ ubuntuone/controlpanel/utils/darwin.py	2012-09-28 18:45:25 +0000
@@ -20,15 +20,322 @@
 import shutil
 import sys
 
+from ctypes import (
+    byref,
+    CDLL,
+    POINTER,
+    Structure,
+    c_bool,
+    c_char_p,
+    c_double,
+    c_int32,
+    c_long,
+    c_uint32,
+    c_void_p)
+
+from ctypes.util import find_library
+
 from twisted.internet import defer
 
 from dirspec.basedir import save_config_path
 from ubuntuone.controlpanel.logger import setup_logging
 
 logger = setup_logging('utils.darwin')
+
 AUTOUPDATE_BIN_NAME = 'autoupdate-darwin'
 UNINSTALL_BIN_NAME = 'uninstall-darwin'
 
+FSEVENTSD_JOB_LABEL = "com.ubuntu.one.fsevents"
+
+# pylint: disable=C0103
+CFPath = find_library("CoreFoundation")
+CF = CDLL(CFPath)
+
+CFRelease = CF.CFRelease
+CFRelease.restype = None
+CFRelease.argtypes = [c_void_p]
+
+kCFStringEncodingUTF8 = 0x08000100
+
+
+class CFRange(Structure):
+    """CFRange Struct"""
+    _fields_ = [("location", c_long),
+                ("length", c_long)]
+
+CFShow = CF.CFShow
+CFShow.argtypes = [c_void_p]
+CFShow.restype = None
+
+CFStringCreateWithCString = CF.CFStringCreateWithCString
+CFStringCreateWithCString.restype = c_void_p
+CFStringCreateWithCString.argtypes = [c_void_p, c_void_p, c_uint32]
+
+kCFAllocatorDefault = c_void_p()
+
+CFErrorCopyDescription = CF.CFErrorCopyDescription
+CFErrorCopyDescription.restype = c_void_p
+CFErrorCopyDescription.argtypes = [c_void_p]
+
+CFDictionaryGetValue = CF.CFDictionaryGetValue
+CFDictionaryGetValue.restype = c_void_p
+CFDictionaryGetValue.argtypes = [c_void_p, c_void_p]
+
+CFArrayGetValueAtIndex = CF.CFArrayGetValueAtIndex
+CFArrayGetValueAtIndex.restype = c_void_p
+CFArrayGetValueAtIndex.argtypes = [c_void_p, c_uint32]
+
+CFURLCreateWithFileSystemPath = CF.CFURLCreateWithFileSystemPath
+CFURLCreateWithFileSystemPath.restype = c_void_p
+CFURLCreateWithFileSystemPath.argtypes = [c_void_p, c_void_p, c_uint32, c_bool]
+
+CFBundleCopyInfoDictionaryForURL = CF.CFBundleCopyInfoDictionaryForURL
+CFBundleCopyInfoDictionaryForURL.restype = c_void_p
+CFBundleCopyInfoDictionaryForURL.argtypes = [c_void_p]
+
+CFStringGetDoubleValue = CF.CFStringGetDoubleValue
+CFStringGetDoubleValue.restype = c_double
+CFStringGetDoubleValue.argtypes = [c_void_p]
+
+SecurityPath = find_library("Security")
+Security = CDLL(SecurityPath)
+
+AuthorizationCreate = Security.AuthorizationCreate
+AuthorizationCreate.restype = c_int32
+AuthorizationCreate.argtypes = [c_void_p, c_void_p, c_int32, c_void_p]
+
+AuthorizationFree = Security.AuthorizationFree
+AuthorizationFree.restype = c_uint32
+AuthorizationFree.argtypes = [c_void_p, c_uint32]
+
+kAuthorizationFlagDefaults = 0
+kAuthorizationFlagInteractionAllowed = 1 << 0
+kAuthorizationFlagExtendRights = 1 << 1
+kAuthorizationFlagDestroyRights = 1 << 3
+kAuthorizationFlagPreAuthorize = 1 << 4
+
+kAuthorizationEmptyEnvironment = None
+
+errAuthorizationSuccess = 0
+errAuthorizationDenied = -60005
+errAuthorizationCanceled = -60006
+errAuthorizationInteractionNotAllowed = -60007
+
+ServiceManagementPath = find_library("ServiceManagement")
+ServiceManagement = CDLL(ServiceManagementPath)
+
+kSMRightBlessPrivilegedHelper = "com.apple.ServiceManagement.blesshelper"
+kSMRightModifySystemDaemons = "com.apple.ServiceManagement.daemons.modify"
+
+# pylint: disable=E1101
+# c_void_p has no "in_dll" member:
+kSMDomainSystemLaunchd = c_void_p.in_dll(ServiceManagement,
+                                         "kSMDomainSystemLaunchd")
+# pylint: enable=E1101
+
+SMJobBless = ServiceManagement.SMJobBless
+SMJobBless.restype = c_bool
+SMJobBless.argtypes = [c_void_p, c_void_p, c_void_p, POINTER(c_void_p)]
+
+SMJobRemove = ServiceManagement.SMJobRemove
+SMJobRemove.restype = c_bool
+SMJobRemove.argtypes = [c_void_p, c_void_p, c_void_p, c_bool,
+                        POINTER(c_void_p)]
+
+SMJobCopyDictionary = ServiceManagement.SMJobCopyDictionary
+SMJobCopyDictionary.restype = c_void_p
+SMJobCopyDictionary.argtypes = [c_void_p, c_void_p]
+
+
+class AuthorizationItem(Structure):
+    """AuthorizationItem Struct"""
+    _fields_ = [("name", c_char_p),
+                ("valueLength", c_uint32),
+                ("value", c_void_p),
+                ("flags", c_uint32)]
+
+
+class AuthorizationRights(Structure):
+    """AuthorizationRights Struct"""
+    _fields_ = [("count", c_uint32),
+                # * 1 here is specific to our use below
+                ("items", POINTER(AuthorizationItem))]
+
+
+class DaemonInstallException(Exception):
+    """Error securely installing daemon."""
+
+
+class AuthUserCanceledException(Exception):
+    """The user canceled the authorization."""
+
+
+class AuthFailedException(Exception):
+    """The authorization faild for some reason."""
+
+
+class DaemonRemoveException(Exception):
+    """Error removing existing daemon."""
+
+
+class DaemonVersionMismatchException(Exception):
+    """Incompatible version of the daemon found."""
+
+
+def create_cfstr(s):
+    """Creates a CFString from a python string.
+
+    Note - because this is a "create" function, you have to CFRelease
+    the returned string.
+    """
+    return CFStringCreateWithCString(kCFAllocatorDefault,
+                                     s.encode('utf8'),
+                                     kCFStringEncodingUTF8)
+
+
+def get_bundle_version(path_cfstr):
+    """Returns a float version from the plist of the given bundle.
+
+    path_cfstr must be a CFStringRef.
+    """
+    cfurl = CFURLCreateWithFileSystemPath(None,  # use default allocator
+                                          path_cfstr,
+                                          0,  # POSIX style path
+                                          False)
+    plist = CFBundleCopyInfoDictionaryForURL(cfurl)
+    ver_key_cfstr = create_cfstr("CFBundleVersion")
+    version_cfstr = CFDictionaryGetValue(plist, ver_key_cfstr)
+
+    version = CFStringGetDoubleValue(version_cfstr)
+
+    CFRelease(cfurl)
+    CFRelease(plist)
+    CFRelease(ver_key_cfstr)
+
+    return version
+
+
+def get_fsevents_daemon_installed_version():
+    """Returns helper version or None if helper is not installed."""
+
+    label_cfstr = create_cfstr(FSEVENTSD_JOB_LABEL)
+    job_data_cfdict = SMJobCopyDictionary(kSMDomainSystemLaunchd,
+                                          label_cfstr)
+    CFRelease(label_cfstr)
+
+    if job_data_cfdict is not None:
+        key_cfstr = create_cfstr("ProgramArguments")
+        args_cfarray = CFDictionaryGetValue(job_data_cfdict, key_cfstr)
+
+        path_cfstr = CFArrayGetValueAtIndex(args_cfarray, 0)
+        version = get_bundle_version(path_cfstr)
+
+        # only release things "copied" or "created", not "got".
+        CFRelease(job_data_cfdict)
+        CFRelease(key_cfstr)
+        return version
+
+    return None
+
+
+def get_authorization():
+    """Get authorization to remove and/or install daemons."""
+
+    # pylint: disable=W0201
+    authItemBless = AuthorizationItem()
+    authItemBless.name = kSMRightBlessPrivilegedHelper
+    authItemBless.valueLength = 0
+    authItemBless.value = None
+    authItemBless.flags = 0
+
+    authRights = AuthorizationRights()
+    authRights.count = 1
+    authRights.items = (AuthorizationItem * 1)(authItemBless)
+
+    flags = (kAuthorizationFlagDefaults |
+             kAuthorizationFlagInteractionAllowed |
+             kAuthorizationFlagPreAuthorize |
+             kAuthorizationFlagExtendRights)
+
+    authRef = c_void_p()
+
+    status = AuthorizationCreate(byref(authRights),
+                                 kAuthorizationEmptyEnvironment,
+                                 flags,
+                                 byref(authRef))
+
+    if status != errAuthorizationSuccess:
+
+        if status == errAuthorizationInteractionNotAllowed:
+            raise AuthFailedException("Authorization failed: "
+                                      "interaction not allowed.")
+
+        elif status == errAuthorizationDenied:
+            raise AuthFailedException("Authorization failed: auth denied.")
+
+        else:
+            raise AuthUserCanceledException()
+
+    if authRef is None:
+        raise AuthFailedException("No authRef from AuthorizationCreate: %r"
+                                  % status)
+    return authRef
+
+
+def install_fsevents_daemon(authRef):
+    """Call SMJobBless to install daemon.
+
+    No return, raises on error.
+    """
+
+    desc_cfstr = None
+
+    try:
+        error = c_void_p()
+
+        label_cfstr = create_cfstr(FSEVENTSD_JOB_LABEL)
+        ok = SMJobBless(kSMDomainSystemLaunchd,
+                        label_cfstr,
+                        authRef,
+                        byref(error))
+        CFRelease(label_cfstr)
+
+        if not ok:
+            desc_cfstr = CFErrorCopyDescription(error)
+            CFShow(desc_cfstr)
+            raise DaemonInstallException("SMJobBless error (see above)")
+
+    finally:
+        if desc_cfstr:
+            CFRelease(desc_cfstr)
+
+
+def remove_fsevents_daemon(authRef):
+    """Call SMJobRemove to remove daemon.
+
+    No return, raises on error.
+    """
+    desc_cfstr = None
+    try:
+        error = c_void_p()
+
+        label_cfstr = create_cfstr(FSEVENTSD_JOB_LABEL)
+        ok = SMJobRemove(kSMDomainSystemLaunchd,
+                         label_cfstr,
+                         authRef,
+                         True,
+                         byref(error))
+
+        CFRelease(label_cfstr)
+
+        if not ok:
+            desc_cfstr = CFErrorCopyDescription(error)
+            CFShow(desc_cfstr)
+            raise DaemonRemoveException("SMJobRemove error (see above)")
+    finally:
+        if desc_cfstr:
+            CFRelease(desc_cfstr)
+
 
 def add_to_autostart():
     """Add syncdaemon to the session's autostart."""
@@ -50,6 +357,72 @@
     return folders
 
 
+def check_and_install_fsevents_daemon(main_app_dir):
+    """Checks version of running daemon, maybe installs.
+
+    'main_app_dir' is the path to the running app.
+
+    This will securely install the daemon bundled with the running app
+    if there is no currently installed one, or upgrade it if the
+    installed one is old. If the installed one is newer, it raises
+    a DaemonVersionMismatchException.
+    """
+
+    daemon_path = os.path.join(main_app_dir, 'Contents',
+                               'Library', 'LaunchServices',
+                               FSEVENTSD_JOB_LABEL)
+    bundled_version = get_bundle_version(create_cfstr(daemon_path))
+
+    installed_version = get_fsevents_daemon_installed_version()
+
+    if installed_version == bundled_version:
+        logger.info("Current fsevents daemon already installed: version %r" %
+                    installed_version)
+        return
+
+    if installed_version > bundled_version:
+        desc = ("Found newer fsevents daemon:"
+                " installed %r > bundled version %r." %
+                (installed_version, bundled_version))
+        logger.error(desc)
+        raise DaemonVersionMismatchException(desc)
+
+    authRef = get_authorization()
+
+    if (installed_version is not None and
+        installed_version < bundled_version):
+        logger.info("Found installed daemon version %r < %r, removing." %
+                    (installed_version, bundled_version))
+
+        try:
+            remove_fsevents_daemon(authRef)
+        except DaemonRemoveException, e:
+            logger.exception("Problem removing running daemon: %r" % e)
+
+        AuthorizationFree(authRef, kAuthorizationFlagDestroyRights)
+
+    logger.info("Installing daemon version %r" % bundled_version)
+
+    try:
+        authRef = get_authorization()
+        install_fsevents_daemon(authRef)
+
+        installed_version = get_fsevents_daemon_installed_version()
+
+        if installed_version:
+            logger.info("Installed fsevents daemon successfully: version %r" %
+                        installed_version)
+        else:
+            logger.error("Error installing fsevents daemon, see system.log.")
+
+    except DaemonInstallException, e:
+        logger.exception("Exception in fsevents daemon installation: %r" % e)
+        raise e
+
+    finally:
+        AuthorizationFree(authRef, kAuthorizationFlagDestroyRights)
+
+
 def install_config_and_daemons():
     """Install required data files and fsevents daemon.
 
@@ -80,6 +453,8 @@
         if not os.path.exists(dest_path):
             shutil.copyfile(src_path, dest_path)
 
+    check_and_install_fsevents_daemon(main_app_dir)
+
 
 def perform_update():
     """Spawn the autoupdate process and call the stop function."""

=== modified file 'ubuntuone/controlpanel/utils/tests/test_darwin.py'
--- ubuntuone/controlpanel/utils/tests/test_darwin.py	2012-08-06 16:47:44 +0000
+++ ubuntuone/controlpanel/utils/tests/test_darwin.py	2012-09-28 18:45:25 +0000
@@ -19,6 +19,9 @@
 import os
 import sys
 
+from collections import defaultdict
+from functools import partial
+
 from twisted.internet import defer
 
 from ubuntuone.controlpanel import utils
@@ -28,6 +31,28 @@
 # pylint: disable=W0212
 
 
+class CallRecordingTestCase(TestCase):
+    """Base class with multi-call checker."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up call checker."""
+        yield super(CallRecordingTestCase, self).setUp()
+        self._called = defaultdict(list)
+
+    def _patch_and_track(self, module, funcs):
+        """Record calls along with function name."""
+
+        def record_call(fname, retval, *args, **kwargs):
+            """Wrapper for a single function."""
+            self._called[fname].append((args, kwargs))
+            return retval
+
+        for (fname, retval) in funcs:
+            wrapper = partial(record_call, fname, retval)
+            self.patch(module, fname, wrapper)
+
+
 class InstallConfigTestCase(TestCase):
     """Test install_config_and_daemons."""
 
@@ -37,6 +62,10 @@
         yield super(InstallConfigTestCase, self).setUp()
         self._called = []
 
+        self.patch(utils.darwin,
+                   'check_and_install_fsevents_daemon',
+                   lambda _: None)
+
     def _set_called(self, *args, **kwargs):
         """Store 'args' and 'kwargs for test assertions."""
         self._called.append((args, kwargs))
@@ -76,3 +105,200 @@
         """When frozen, we do not copy the conf files if they do exist."""
         self._test_copying_conf_files(True)
         self.assertEqual(self._called, [])
+
+
+class InstallDaemonTestCase(CallRecordingTestCase):
+    """Test fsevents daemon installation."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up patched & tracked calls."""
+        yield super(InstallDaemonTestCase, self).setUp()
+
+        self._patch_and_track(utils.darwin,
+                              [('get_authorization', 'Fake AuthRef'),
+                               ('remove_fsevents_daemon', None),
+                               ('install_fsevents_daemon', None),
+                               ('AuthorizationFree', None)])
+
+    def _patch_versions(self, installed, bundled):
+        """Convenience to patch the version-getting functions."""
+        self.patch(utils.darwin,
+                   "get_bundle_version",
+                   lambda _: bundled)
+        self.patch(utils.darwin,
+                   "get_fsevents_daemon_installed_version",
+                   lambda: installed)
+
+    def test_check_and_install_current_version(self):
+        """Test that we do nothing on current version"""
+
+        self._patch_versions(installed=47.0, bundled=47.0)
+
+        utils.darwin.check_and_install_fsevents_daemon('NOT A REAL DIR')
+
+        self.assertEqual(self._called.keys(), [])
+
+    def test_check_and_install_upgrade(self):
+        """Test removing old daemon and installing new one."""
+
+        self._patch_versions(installed=35.0, bundled=35.1)
+
+        utils.darwin.check_and_install_fsevents_daemon('NOT A REAL DIR')
+
+        self.assertEqual(self._called['get_authorization'],
+                         [((), {}), ((), {})])
+        self.assertEqual(self._called['remove_fsevents_daemon'],
+                         [(('Fake AuthRef',), {})])
+        self.assertEqual(self._called['install_fsevents_daemon'],
+                         [(('Fake AuthRef',), {})])
+        self.assertEqual(self._called['AuthorizationFree'],
+                         [(('Fake AuthRef',
+                            utils.darwin.kAuthorizationFlagDestroyRights), {}),
+                          (('Fake AuthRef',
+                            utils.darwin.kAuthorizationFlagDestroyRights), {})
+                          ])
+
+    def test_check_and_install_mismatch(self):
+        """Test raising when we're older than the daemon."""
+
+        self._patch_versions(installed=102.5, bundled=66.0)
+
+        self.assertRaises(utils.darwin.DaemonVersionMismatchException,
+                          utils.darwin.check_and_install_fsevents_daemon,
+                          'NOT A REAL DIR')
+        self.assertEqual(self._called.keys(), [])
+
+
+class CFCallsTestCase(CallRecordingTestCase):
+    """Test functions that call CoreFoundation API."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up call checker."""
+        yield super(CFCallsTestCase, self).setUp()
+        self._called = defaultdict(list)
+        self.patch(utils.darwin, 'create_cfstr',
+                   lambda s: s)
+        self.patch(utils.darwin, 'CFShow',
+                   lambda _: None)
+        self.patch(utils.darwin, 'kSMDomainSystemLaunchd',
+                   'not a c_void_p')
+
+    def test_remove_daemon_ok(self):
+        """Test that we call SMJobRemove and don't raise when it returns OK."""
+        self._patch_and_track(utils.darwin, [('SMJobRemove', True),
+                                             ('c_void_p', 'notaptr'),
+                                             ('byref', 'not a **'),
+                                             ('CFRelease', 'ignore')])
+
+        utils.darwin.remove_fsevents_daemon('not an authref')
+        self.assertEqual(self._called['SMJobRemove'],
+                         [(('not a c_void_p',
+                            utils.darwin.FSEVENTSD_JOB_LABEL,
+                           'not an authref',
+                           True, 'not a **'), {})])
+        self.assertEqual(self._called['CFRelease'],
+                         [((utils.darwin.FSEVENTSD_JOB_LABEL,), {})])
+
+    def test_remove_daemon_not_ok(self):
+        """Test that we raise when SMJobRemove returns not OK."""
+        self._patch_and_track(utils.darwin, [('SMJobRemove', False),
+                                             ('c_void_p', 'notaptr'),
+                                             ('byref', 'not a **'),
+                                             ('CFRelease', 'ignore'),
+                                             ('CFErrorCopyDescription',
+                                              'Houston, we have a problem')])
+
+        self.assertRaises(utils.darwin.DaemonRemoveException,
+                          utils.darwin.remove_fsevents_daemon,
+                          'not an authref')
+
+    def test_install_daemon_ok(self):
+        """Test that we call SMJobBless and don't raise when it returns OK."""
+        self._patch_and_track(utils.darwin, [('SMJobBless', True),
+                                             ('c_void_p', 'notaptr'),
+                                             ('byref', 'not a **'),
+                                             ('CFRelease', 'ignore')])
+
+        utils.darwin.install_fsevents_daemon('not an authref')
+        self.assertEqual(self._called['SMJobBless'],
+                         [(('not a c_void_p',
+                            utils.darwin.FSEVENTSD_JOB_LABEL,
+                           'not an authref',
+                            'not a **'), {})])
+        self.assertEqual(self._called['CFRelease'],
+                         [((utils.darwin.FSEVENTSD_JOB_LABEL,), {})])
+
+    def test_install_daemon_not_ok(self):
+        """Test that we raise when SMJobBless returns not OK."""
+        self._patch_and_track(utils.darwin, [('SMJobBless', False),
+                                             ('c_void_p', 'notaptr'),
+                                             ('byref', 'not a **'),
+                                             ('CFRelease', 'ignore'),
+                                             ('CFErrorCopyDescription',
+                                              'Houston, we have a problem')])
+
+        self.assertRaises(utils.darwin.DaemonInstallException,
+                          utils.darwin.install_fsevents_daemon,
+                          'not an authref')
+
+    def test_get_bundle_version(self):
+        """Simple test of #calls in get_bundle_version."""
+        # This list includes expected counts. This test is mostly good
+        # to check that we match the number of 'create's with the
+        # number of 'releases', which is 3 (note create_cfstr is
+        # patched in setUp.)
+        to_track = [('CFURLCreateWithFileSystemPath',
+                     'url', 1),
+                    ('CFBundleCopyInfoDictionaryForURL',
+                     'dict', 1),
+                    ('CFDictionaryGetValue', 'val', 1),
+                    ('CFStringGetDoubleValue', 102.5, 1),
+                    ('CFRelease', 'ignore', 3)]
+        self._patch_and_track(utils.darwin, [(n, r) for (n, r, _) in to_track])
+
+        utils.darwin.get_bundle_version("not a cfstr")
+        for (name, _, num) in to_track:
+            self.assertEqual(len(self._called[name]), num)
+
+    def test_get_fsevents_daemon_installed_version_ok(self):
+        """Test that we return the version if the dictionary is there."""
+        to_track = [('SMJobCopyDictionary', 'not none'),
+                    ('CFRelease', 'None'),
+                    ('CFDictionaryGetValue', 'val from dict'),
+                    ('CFArrayGetValueAtIndex', 'val'),
+                    ('get_bundle_version', 1.0)]
+        self._patch_and_track(utils.darwin, to_track)
+        utils.darwin.get_fsevents_daemon_installed_version()
+
+        self.assertEqual(self._called['CFDictionaryGetValue'],
+                         [(('not none', "ProgramArguments"), {})])
+        self.assertEqual(self._called['CFArrayGetValueAtIndex'],
+                         [(('val from dict', 0), {})])
+        self.assertEqual(self._called['get_bundle_version'],
+                         [(('val',), {})])
+
+    def test_get_fsevents_daemon_installed_version_not_found(self):
+        """Test that we return None if the dictionary is not there."""
+        to_track = [('SMJobCopyDictionary', None),
+                    ('CFRelease', 'None'),
+                    ('CFDictionaryGetValue', 'val from dict'),
+                    ('CFArrayGetValueAtIndex', 'val'),
+                    ('get_bundle_version', 1.0)]
+        self._patch_and_track(utils.darwin, to_track)
+        utils.darwin.get_fsevents_daemon_installed_version()
+
+        self.assertTrue('CFDictionaryGetValue' not in self._called.keys())
+        self.assertTrue('CFArrayGetValueAtIndex' not in self._called.keys())
+        self.assertTrue('get_bundle_version' not in self._called.keys())
+
+    def test_get_authorization_ok(self):
+        """Test successful call of AuthorizationCreate does not raise."""
+        to_track = [('c_void_p', 'not void p'),
+                    ('byref', 'not **'),
+                    ('AuthorizationCreate',
+                     utils.darwin.errAuthorizationSuccess)]
+        self._patch_and_track(utils.darwin, to_track)
+        auth_ref = utils.darwin.get_authorization()
+        self.assertEqual(auth_ref, 'not void p')