Merge lp:~dobey/ubuntuone-control-panel/update-4-2 into lp:ubuntuone-control-panel/stable-4-2

[dobey]

[Mike McCracken]
    - Remove a debug print statement in the tests that snuck through.
    - Use new SSO API to get platform-appropriate translation function. (LP: 1074116)
    - Add u1 folder to OS X Finder favorites sidebar on first launch.

[Brian Curtin]

    - Add common updater script for mac and windows. (LP: #1087262)

[Brian Curtin (brian.curtin)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntuone-control-panel/update-4-2 into lp:ubuntuone-control-panel/stable-4-2 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]
    t...

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntuone-control-panel/update-4-2 into lp:ubuntuone-control-panel/stable-4-2 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]
    t...

[lp:~dobey/ubuntuone-control-panel/update-4-2]

377. By dobey on 2013-01-10

[Mike McCracken]
    - Remove a debug print statement in the tests that snuck through.
    - Use new SSO API to get platform-appropriate translation function. (LP: 1074116)
    - Add u1 folder to OS X Finder favorites sidebar on first launch.

[Brian Curtin]

    - Add common updater script for mac and windows. (LP: #1087262)

=== added file 'bin/ubuntuone-updater'
--- bin/ubuntuone-updater	1970-01-01 00:00:00 +0000
+++ bin/ubuntuone-updater	2013-01-10 18:07:21 +0000
@@ -0,0 +1,184 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""A script to check the website for new versions of Ubuntu One."""
+
+from __future__ import print_function
+
+try:
+    from urllib.request import urlopen, URLError
+    from urllib.parse import urljoin
+except ImportError:
+    from urllib2 import urlopen, URLError
+    from urlparse import urljoin
+
+import argparse
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import tempfile
+
+from dirspec.utils import get_program_path
+
+
+U1SDTOOL_EXECUTABLE = 'u1sdtool'
+DARWIN_APP_NAMES = {U1SDTOOL_EXECUTABLE: 'U1SDTool.app'}
+
+
+if sys.platform == "darwin":
+    from Cocoa import NSRunningApplication, NSLog
+    # IDs to terminate: Leave syncdaemon off this list, it is
+    # terminated separately.
+    BUNDLE_IDS = ["com.ubuntu.sso.login-qt",
+                  "com.ubuntu.sso.ssl-cert",
+                  "com.ubuntu.sso.login",
+                  "com.ubuntu.one.proxy-tunnel",
+                  "com.ubuntu.one.u1sdtool",
+                  "com.ubuntu.one.updater",
+                  "com.ubuntu.one.controlpanel",
+                  "com.ubuntu.one.menu"]
+
+
+def _do_download(url):
+    """Download a URL and return the data it contains."""
+    resource = urlopen(url)
+    if resource:
+        data = resource.read()
+    return data
+
+
+def _save_download(url, checksum):
+    """Given URL data, save it to a file and return the file name.
+
+    The resource is saved to a file which is the responsibility of callers
+    to cleanup. It was created with tempfile.mkstemp."""
+    data = _do_download(url)
+
+    md5 = hashlib.md5()
+    md5.update(data)
+    if checksum != md5.hexdigest():
+        raise Exception("Checksum mismatch")
+
+    fd, name = tempfile.mkstemp()
+    with os.fdopen(fd, "wb") as fobj:
+        fobj.write(data)
+
+    return name
+
+
+def run_install(url, checksum):
+    try:
+        args = [_save_download(url, checksum)]
+        if sys.platform == 'darwin':
+            args.insert(0, 'open')
+        subprocess.Popen(args)
+    except Exception as exc:
+        print("Unable to install {}: {}".format(url, exc))
+        return False
+    return True
+
+
+def check(args):
+    """Check a URL and return True if a new version is available."""
+    error = (False, "", "")     # Default to no new release.
+
+    try:
+        data = _do_download(args.url)
+    except URLError as err:
+        print("Download failed: {}".format(err))
+        return error
+
+    try:
+        info = json.loads(data)
+        available = info[args.platform][args.release]
+        avail_ver = available["version"]
+        upgrade_available = avail_ver > args.current
+        if upgrade_available:
+            msg = "A new {} version is available at {}."
+            print(msg.format(args.release, available["url"]))
+        elif avail_ver == args.current:
+            print("Version {} is the latest {}.".format(args.current,
+                                                        args.release))
+        else:
+            print("Warning: installed version {} newer than advertised"
+                  " available version {} somehow.".format(args.current,
+                                                          avail_ver))
+
+    except Exception as exc:
+        # Catch everything here.
+        # KeyError is most likely, but we can't let this take us down.
+        print("Exception while reading {}:".format(args.url),
+              exc.__class__, exc.message)
+        return error
+
+    return upgrade_available, available["url"], available["checksum"]
+
+
+def kill_running_processes():
+    """Kill any running u1 processes."""
+    if sys.platform != "darwin":
+        return
+    NSLog("in kill")
+
+    try:
+        u1sdtoolpath = get_program_path(U1SDTOOL_EXECUTABLE,
+                                        app_names=DARWIN_APP_NAMES)
+
+        out = subprocess.check_output([u1sdtoolpath, '-q'])
+        NSLog("u1sdtool said: {}".format(out))
+    except Exception as e:
+        NSLog("exception running {} -q: {}".format(u1sdtoolpath, e))
+
+    for id in BUNDLE_IDS:
+        NSRA = NSRunningApplication
+        apps = NSRA.runningApplicationsWithBundleIdentifier_(id)
+        NSLog("id: {} apps: {}".format(id, apps))
+
+        for app in apps:
+            app.terminate()
+
+
+def main(*args):
+    """Return 1 if the action was successful, 0 if not.
+
+    The default option is to check that an update is available.
+    Adding the --install option will download and run
+    the update if available."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--install", action="store_true")
+    parser.add_argument("--platform", type=str, default=sys.platform)
+    parser.add_argument("--release", type=str, required=True)
+    parser.add_argument("--current", type=int, required=True)
+    parser.add_argument("--url", type=str, required=True)
+
+    args = parser.parse_args()
+
+    new_available, file, checksum = check(args)
+    if not args.install:
+        return 1 if new_available else 0
+
+    if args.install and new_available:
+        installer = urljoin(args.url, file)
+        print("Downloading and installing", installer)
+        kill_running_processes()
+        return 1 if run_install(installer, checksum) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[:]))

=== modified file 'setup.py'
--- setup.py	2012-12-05 22:58:30 +0000
+++ setup.py	2013-01-10 18:07:21 +0000
@@ -193,7 +193,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntuone-control-panel',
-    version='4.1',
+    version='4.1.0',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntuone/controlpanel/__init__.py'
--- ubuntuone/controlpanel/__init__.py	2011-09-06 17:21:56 +0000
+++ ubuntuone/controlpanel/__init__.py	2013-01-10 18:07:21 +0000
@@ -30,4 +30,3 @@
 DBUS_PREFERENCES_IFACE = "com.ubuntuone.controlpanel.Preferences"
 
 WEBSERVICE_BASE_URL = u"https://one.ubuntu.com/api/"
-TRANSLATION_DOMAIN = 'ubuntuone-control-panel'

=== modified file 'ubuntuone/controlpanel/gui/__init__.py'
--- ubuntuone/controlpanel/gui/__init__.py	2012-11-02 13:10:20 +0000
+++ ubuntuone/controlpanel/gui/__init__.py	2013-01-10 18:07:21 +0000
@@ -16,23 +16,21 @@
 
 """The control panel UI for Ubuntu One."""
 
-import gettext
-import sys
+import os
 
 # pylint: disable=W0611
 from ubuntuone.clientdefs import APP_NAME
 # pylint: enable=W0611
 
-from ubuntuone.controlpanel import TRANSLATION_DOMAIN
+from ubuntu_sso.utils.translation import get_gettext
+
 from ubuntuone.controlpanel.backend import UBUNTUONE_LINK
 
-
-TRANSLATION = gettext.translation(TRANSLATION_DOMAIN, fallback=True)
-if sys.version_info < (3,):
-    _ = TRANSLATION.ugettext
-else:
-    _ = TRANSLATION.gettext
-
+source_path = os.path.join(os.path.dirname(__file__),
+                           os.path.pardir, os.path.pardir,
+                           os.path.pardir, 'build', 'mo')
+_ = get_gettext('ubuntuone-control-panel',
+                fallback_path=os.path.abspath(source_path))
 
 ERROR_COLOR = u'red'
 KILOBYTES = 1024

=== modified file 'ubuntuone/controlpanel/gui/qt/gui.py'
--- ubuntuone/controlpanel/gui/qt/gui.py	2012-11-01 19:33:57 +0000
+++ ubuntuone/controlpanel/gui/qt/gui.py	2013-01-10 18:07:21 +0000
@@ -123,7 +123,7 @@
                 logger.info('Performing auto-update.')
                 utils.perform_update()
             else:
-                logger.info('User do not want to update.')
+                logger.info('User does not want to update.')
 
 
 def start(close_callback, minimized=False, with_icon=False, installer=False):

=== modified file 'ubuntuone/controlpanel/gui/qt/main/__init__.py'
--- ubuntuone/controlpanel/gui/qt/main/__init__.py	2012-11-30 18:06:22 +0000
+++ ubuntuone/controlpanel/gui/qt/main/__init__.py	2013-01-10 18:07:21 +0000
@@ -50,7 +50,8 @@
 
 # pylint: enable=C0103
 
-from ubuntuone.controlpanel.utils import install_config_and_daemons
+from ubuntuone.controlpanel.utils import (install_config_and_daemons,
+                                          add_u1_folder_to_favorites)
 
 
 def parser_options():
@@ -136,6 +137,7 @@
     app.setStyleSheet('\n'.join(data))
 
     install_config_and_daemons()
+    add_u1_folder_to_favorites()
 
     if sys.platform == 'darwin':
         with_icon = False

=== modified file 'ubuntuone/controlpanel/utils/__init__.py'
--- ubuntuone/controlpanel/utils/__init__.py	2012-08-03 23:36:46 +0000
+++ ubuntuone/controlpanel/utils/__init__.py	2013-01-10 18:07:21 +0000
@@ -21,7 +21,6 @@
 
 from ubuntuone.controlpanel.logger import setup_logging
 
-
 logger = setup_logging('utils')
 
 DATA_SUFFIX = 'data'
@@ -38,6 +37,7 @@
 if sys.platform == 'win32':
     from ubuntuone.controlpanel.utils import windows
     add_to_autostart = windows.add_to_autostart
+    add_u1_folder_to_favorites = no_op
     are_updates_present = windows.are_updates_present
     default_folders = windows.default_folders
     install_config_and_daemons = no_op
@@ -46,14 +46,16 @@
 elif sys.platform == 'darwin':
     from ubuntuone.controlpanel.utils import darwin
     add_to_autostart = no_op
-    are_updates_present = no_op
+    add_u1_folder_to_favorites = darwin.add_u1_folder_to_favorites
+    are_updates_present = darwin.are_updates_present
     default_folders = darwin.default_folders
     install_config_and_daemons = darwin.install_config_and_daemons
-    perform_update = no_op
+    perform_update = darwin.perform_update
     uninstall_application = no_op
 else:
     from ubuntuone.controlpanel.utils import linux
     add_to_autostart = no_op
+    add_u1_folder_to_favorites = no_op
     are_updates_present = no_op
     default_folders = linux.default_folders
     install_config_and_daemons = no_op

=== added file 'ubuntuone/controlpanel/utils/common.py'
--- ubuntuone/controlpanel/utils/common.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/utils/common.py	2013-01-10 18:07:21 +0000
@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Platform - independent support code for utils."""
+
+import os
+import sys
+
+try:
+    from configparser import (SafeConfigParser, NoSectionError, NoOptionError)
+except ImportError:
+    from ConfigParser import (SafeConfigParser, NoSectionError, NoOptionError)
+
+from twisted.internet import defer
+from twisted.internet.utils import getProcessValue
+from twisted.python import procutils
+
+from dirspec.basedir import load_config_paths
+from dirspec.utils import get_program_path
+
+from ubuntuone.controlpanel.utils import logger
+
+UPDATE_BIN_NAME = 'ubuntuone-updater'
+UPDATE_CONFIG_NAME = 'update.conf'
+DARWIN_APP_NAMES = {UPDATE_BIN_NAME: 'UbuntuOne Updater.app'}
+
+
+def get_bin_cmd(exe_name):
+    """Return list of cmds for an exe from the control panel project."""
+    fallback_dir = os.path.join(os.path.dirname(__file__),
+                                 os.pardir, os.pardir, os.pardir,
+                                 "bin")
+
+    cmd_args = [get_program_path(exe_name,
+                                 fallback_dirs=[fallback_dir],
+                                 app_names=DARWIN_APP_NAMES)]
+
+    # procutils.which('python') returns python.exe on windows:
+    if getattr(sys, 'frozen', None) is None:
+        cmd_args.insert(0, procutils.which('python')[0])
+
+    return cmd_args
+
+
+def get_update_config():
+    """Read the update.conf file and return a triple of
+    the URL, version, and whether updates should be checked."""
+    no_config = (None, None, None, False)
+    url, version, channel, check = no_config
+
+    files = [os.path.join(dir, UPDATE_CONFIG_NAME)
+             for dir in load_config_paths("ubuntuone")]
+
+    conf = SafeConfigParser()
+    read_files = conf.read(files)
+
+    if not read_files:
+        logger.debug(
+            "Unable to find an update.conf file - not checking for updates")
+        return no_config
+
+    try:
+        url = conf.get("Update", "url")
+        version = conf.get("Update", "version_id")
+        channel = conf.get("Update", "channel")
+        check = conf.getint("Update", "check_for_updates")
+    except (NoSectionError, NoOptionError) as e:
+        logger.debug("could not read update.conf - not checking for updates")
+        logger.debug("   (exception was %r)" % e)
+        return no_config
+
+    return url, version, channel, check
+
+
[e-mail]
+def call_updater(custom_call=None, install=False):
+    """Call the Ubuntu One updater."""
+    result = False
+    retcode = None
+    try:
+        updater_cmd = get_bin_cmd(UPDATE_BIN_NAME)
+    except OSError, e:
+        logger.debug("Could not find updater command: %r" % e)
+        defer.returnValue(result)
+
+    url, local_version, channel, should_check = get_update_config()
+
+    if not should_check:
+        logger.debug("ignoring update check")
+        defer.returnValue(result)
+
+    args = ["--url", url,
+            "--current", str(local_version),
+            "--release", channel]
+    if install:
+        args.append("--install")
+
+    exe = updater_cmd[0]
+    args = updater_cmd[1:] + args
+
+    logger.debug("calling %s update process: %r args %r",
+                 "custom" if custom_call else "regular",
+                 exe, args)
+
+    if custom_call:
+        custom_call(exe, args)
+    else:
+        # updater returns 1 if available, zero if not
+        retcode = yield getProcessValue(exe, args)
+        result = retcode == 1
+
+    logger.debug('call_updater: %s, updater cmd: %r, return code: %r,'
+                 ' result: %r', "installing" if install else "checking",
+                 updater_cmd, retcode, result)
+    defer.returnValue(result)

=== modified file 'ubuntuone/controlpanel/utils/darwin.py'
--- ubuntuone/controlpanel/utils/darwin.py	2012-11-29 20:15:08 +0000
+++ ubuntuone/controlpanel/utils/darwin.py	2013-01-10 18:07:21 +0000
@@ -20,6 +20,14 @@
 import shutil
 import sys
 
+from Cocoa import (NSURL, NSUserDefaults)
+from LaunchServices import (
+    kLSSharedFileListFavoriteItems,
+    kLSSharedFileListItemBeforeFirst,
+    LSSharedFileListCreate,
+    LSSharedFileListInsertItemURL,
+    LSSharedFileListItemRef)
+
 from ctypes import (
     byref,
     CDLL,
@@ -39,10 +47,15 @@
 
 from dirspec.basedir import save_config_path
 from ubuntuone.controlpanel.logger import setup_logging
+from ubuntuone.controlpanel.utils.common import call_updater
 from ubuntuone.platform import expand_user
 
 logger = setup_logging('utils.darwin')
 
+ADDED_TO_FINDER_SIDEBAR_ONCE = "ADDED_TO_FINDER_SIDEBAR_ONCE"
+
+LOGO_ICON = "ubuntuone_logo.png"
+
 AUTOUPDATE_BIN_NAME = 'autoupdate-darwin'
 UNINSTALL_BIN_NAME = 'uninstall-darwin'
 
@@ -343,11 +356,37 @@
     # TODO
 
 
+def _get_userdefaults():
+    """Testable wrapper for NSUserDefaults"""
+    # HACK: This is required to avoid trial complaining on tear down
+    # that assigning to native selectors is not supported.
+    return NSUserDefaults.standardUserDefaults()
+
+
+def add_u1_folder_to_favorites():
+    """Add the u1 folder to the favorites sidebar in Finder."""
+    sud = _get_userdefaults()
+    if sud.boolForKey_(ADDED_TO_FINDER_SIDEBAR_ONCE):
+        return
+    else:
+        sud.setBool_forKey_(True, ADDED_TO_FINDER_SIDEBAR_ONCE)
+
+    u1_path = os.path.expanduser("~/Ubuntu%20One/")
+    u1_url = NSURL.URLWithString_("file://localhost" + "%s" % u1_path)
+
+    lst = LSSharedFileListCreate(None,
+                                 kLSSharedFileListFavoriteItems,
+                                 None)
+    item = LSSharedFileListInsertItemURL(lst, kLSSharedFileListItemBeforeFirst,
+                                         None, None, u1_url, {}, [])
+    if not isinstance(item, LSSharedFileListItemRef):
+        logger.debug("Error adding ~/Ubuntu One to finder favorites")
+
+
 @defer.inlineCallbacks
 def are_updates_present():
     """Return if there are updates for Ubuntu One."""
-    result = False
-    # TODO
+    result = yield call_updater(install=False)
     defer.returnValue(result)
 
 
@@ -448,23 +487,35 @@
 
     config_path = save_config_path('ubuntuone')
 
-    conf_filenames = ['syncdaemon.conf',
-                      'logging.conf']
-    for conf_filename in conf_filenames:
+    # Always copy missing files, and for update.conf, overwrite
+    # existing file to reflect current version ID, but only if bundled
+    # version is newer, so we can change the file for testing.
+    conf_filenames = [('syncdaemon.conf', False),
+                      ('logging.conf', False),
+                      ('update.conf', True)]
+    for conf_filename, overwrite_old in conf_filenames:
         src_path = os.path.join(main_app_resources_dir,
                                 conf_filename)
         dest_path = os.path.join(config_path,
                                  conf_filename)
-
+        do_copy = False
         if not os.path.exists(dest_path):
+            do_copy = True
+        else:
+            src_mtime = os.stat(src_path).st_mtime
+            dest_mtime = os.stat(dest_path).st_mtime
+            if overwrite_old and src_mtime >= dest_mtime:
+                do_copy = True
+
+        if do_copy:
             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."""
-    # TODO
+    """Spawn the autoupdate process, which will eventually kill us."""
+    call_updater(install=True)
 
 
 def uninstall_application():

=== added file 'ubuntuone/controlpanel/utils/tests/test_common.py'
--- ubuntuone/controlpanel/utils/tests/test_common.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/utils/tests/test_common.py	2013-01-10 18:07:21 +0000
@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for utility code that's common between darwin and windows."""
+
+from twisted.internet import defer
+
+try:
+    from configparser import SafeConfigParser
+except ImportError:
+    from ConfigParser import SafeConfigParser
+
+from ubuntuone.controlpanel import utils
+from ubuntuone.controlpanel.tests import TestCase
+from ubuntuone.controlpanel.utils import common
+assert(common)
+
+UPDATE_KEY = 'Update'
+URL_KEY = 'url'
+TEST_URL = 'test-url'
+VERSION_ID_KEY = 'version_id'
+TEST_VERSION_ID = '100'
+CHANNEL_KEY = 'channel'
+TEST_CHANNEL = 'test-channel'
+CHECK_KEY = 'check_for_updates'
+TEST_CHECK = '1'
+
+
+class GetPathsTestCase(TestCase):
+    """Test case for get_update_config and get_bin_cmd."""
+
+    TEST_EXE_NAME = 'test-exe'
+    TEST_BIN_CMD_NAME = 'test-bin-cmd-name'
+    TEST_PYTHON_BIN_NAME = 'test-python-bin-name'
+
+    def _run_get_bin_cmd(self, frozen):
+        """Helper func to test get_bin_cmd."""
+        self.patch(utils.common, "get_program_path",
+                   lambda x, **kwargs: self.TEST_BIN_CMD_NAME)
+        self.patch(utils.common, '__file__',
+                   "fake/path/to/utils/common.py")
+        return utils.common.get_bin_cmd(self.TEST_EXE_NAME)
+
+    def test_get_bin_cmd_frozen(self):
+        """Test that we append 'python' from procutils when frozen."""
+        self.patch(utils.common.procutils, "which",
+                   lambda x: [self.TEST_PYTHON_BIN_NAME])
+        rv = self._run_get_bin_cmd(True)
+        self.assertEqual(rv, [self.TEST_PYTHON_BIN_NAME,
+                              self.TEST_BIN_CMD_NAME])
+
+
+class GetUpdateConfigTestCase(TestCase):
+    """Test reading the config file"""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(GetUpdateConfigTestCase, self).setUp()
+
+        self.blank_conf = SafeConfigParser()
+        self.good_conf = SafeConfigParser()
+        self.good_conf.add_section(UPDATE_KEY)
+        self.good_conf.set(UPDATE_KEY, URL_KEY, TEST_URL)
+        self.good_conf.set(UPDATE_KEY, VERSION_ID_KEY,
+                           TEST_VERSION_ID)
+        self.good_conf.set(UPDATE_KEY, CHANNEL_KEY,
+                           TEST_CHANNEL)
+        self.good_conf.set(UPDATE_KEY, CHECK_KEY, TEST_CHECK)
+
+        self.patch(utils.common, 'load_config_paths',
+                   lambda x: 'test/confpath')
+
+    def test_cant_read(self):
+        """Test that we return no_config when we can't read the cfg"""
+        rv = utils.common.get_update_config()
+        self.assertEqual(rv, (None, None, None, False))
+
+    def test_read_bad_file(self):
+        """Test that we return no_config when we read a bad cfg file"""
+        self.patch(utils.common, "SafeConfigParser",
+                   lambda: self.blank_conf)
+
+        self.patch(self.blank_conf, "read", lambda path: True)
+        rv = utils.common.get_update_config()
+        self.assertEqual(rv, (None, None, None, False))
+
+    def test_read_good_file(self):
+        """test that we correctly read a good cfg file"""
+        self.patch(utils.common, "SafeConfigParser",
+                   lambda: self.good_conf)
+
+        self.patch(self.good_conf, "read", lambda path: True)
+        rv = utils.common.get_update_config()
+        self.assertEqual(rv,
+                         (TEST_URL, TEST_VERSION_ID, TEST_CHANNEL, 1))
+
+
+class CallUpdaterTestCase(TestCase):
+    """Test calling the updater."""
+
+    UPDATE_BIN_CMD = ['path/to/updater']
+    BUILDOUT_UPDATE_BIN_CMD = ['python', 'path/to/updater']
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up common data"""
+        yield super(CallUpdaterTestCase, self).setUp()
+
+        self.getProcessValueArgs = []
+        self.custom_call_args = []
+
+        self.call_retval = 0
+
+        def fake_getProcessValue(exe, args):
+            self.getProcessValueArgs.append((exe, args))
+            return self.call_retval
+
+        self.patch(utils.common, 'getProcessValue',
+                   fake_getProcessValue)
+
+    def fake_custom_call(self, exe, args):
+        """Mock custom call"""
+        self.custom_call_args.append((exe, args))
+
+    @defer.inlineCallbacks
+    def _call_call_updater(self, should_check, custom_call, install, frozen):
+        """Helper to test call_udpater"""
+
+        self.patch(utils.common, 'get_update_config',
+                   lambda: (TEST_URL, TEST_VERSION_ID, TEST_CHANNEL,
+                            should_check))
+
+        self.patch(utils.common, 'get_bin_cmd',
+                   lambda x: self.UPDATE_BIN_CMD if frozen
+                   else self.BUILDOUT_UPDATE_BIN_CMD)
+
+        rv = yield utils.common.call_updater(custom_call, install)
+        defer.returnValue(rv)
+
+    @defer.inlineCallbacks
+    def test_do_not_check(self):
+        """Test that we return False when config says don't check """
+
+        rv = yield self._call_call_updater(should_check=False,
+                                           custom_call=None,
+                                           install=False,
+                                           frozen=False)
+        self.assertEqual(rv, False)
+
+    @defer.inlineCallbacks
+    def test_no_updater_cmd(self):
+        """Test that we return False when get_bin_cmd fails."""
+        def raise_in_get_bin_cmd(name):
+            raise OSError()
+
+        self.patch(utils.common, 'get_bin_cmd', raise_in_get_bin_cmd)
+        rv = yield utils.common.call_updater()
+
+        self.assertEqual(rv, False)
+
+    @defer.inlineCallbacks
+    def test_update_check_frozen_nocustom_noinstall(self):
+        """Test update check when frozen."""
+        self.call_retval = 1
+        rv = yield self._call_call_updater(should_check=True,
+                                           custom_call=None,
+                                           install=False,
+                                           frozen=True)
+        self.assertEqual(rv, True)
+        self.assertEqual(self.getProcessValueArgs,
+                         [(self.UPDATE_BIN_CMD[0],
+                          ['--url', TEST_URL,
+                          '--current', TEST_VERSION_ID,
+                           '--release', TEST_CHANNEL])])
+
+    @defer.inlineCallbacks
+    def test_update_check_unfrozen_nocustom_noinstall(self):
+        """Test update check when not frozen."""
+        self.call_retval = 1
+        rv = yield self._call_call_updater(should_check=True,
+                                           custom_call=None,
+                                           install=False,
+                                           frozen=False)
+        self.assertEqual(rv, True)
+        self.assertEqual(self.getProcessValueArgs,
+                         [(self.BUILDOUT_UPDATE_BIN_CMD[0],
+                          [self.BUILDOUT_UPDATE_BIN_CMD[1],
+                           '--url', TEST_URL,
+                          '--current', TEST_VERSION_ID,
+                           '--release', TEST_CHANNEL])])
+
+    @defer.inlineCallbacks
+    def test_update_check_nocustom_install(self):
+        """Test that we send --install when install=True"""
+
+        yield self._call_call_updater(should_check=True,
+                                      custom_call=None,
+                                      install=True,
+                                      frozen=True)
+        self.assertEqual(self.getProcessValueArgs,
+                         [(self.UPDATE_BIN_CMD[0],
+                          ['--url', TEST_URL,
+                          '--current', TEST_VERSION_ID,
+                           '--release', TEST_CHANNEL,
+                           '--install'])])
+
+    @defer.inlineCallbacks
+    def test_update_check_custom_install(self):
+        """Test that we send --install when install=True to the custom call"""
+
+        yield self._call_call_updater(should_check=True,
+                                      custom_call=self.fake_custom_call,
+                                      install=True,
+                                      frozen=True)
+        self.assertEqual(self.custom_call_args,
+                         [(self.UPDATE_BIN_CMD[0],
+                          ['--url', TEST_URL,
+                          '--current', TEST_VERSION_ID,
+                           '--release', TEST_CHANNEL,
+                           '--install'])])

=== modified file 'ubuntuone/controlpanel/utils/tests/test_darwin.py'
--- ubuntuone/controlpanel/utils/tests/test_darwin.py	2012-10-17 17:28:43 +0000
+++ ubuntuone/controlpanel/utils/tests/test_darwin.py	2013-01-10 18:07:21 +0000
@@ -19,7 +19,9 @@
 import os
 import sys
 
-from collections import defaultdict
+from Cocoa import NSURL
+
+from collections import defaultdict, namedtuple
 from functools import partial
 
 from twisted.internet import defer
@@ -56,12 +58,28 @@
 class InstallConfigTestCase(TestCase):
     """Test install_config_and_daemons."""
 
+    APP_PATH = "/path/to/Main.app/"
+    TARGET_PATH = "TARGET_PATH"
+
     @defer.inlineCallbacks
     def setUp(self):
         """Set up multi-call checker."""
         yield super(InstallConfigTestCase, self).setUp()
         self._called = []
 
+        self.non_overwrite_args = [((os.path.join(self.APP_PATH, 'Contents',
+                                                  'Resources',
+                                                  'syncdaemon.conf'),
+                                     os.path.join(self.TARGET_PATH,
+                                                  'syncdaemon.conf')), {}),
+                                   ((os.path.join(self.APP_PATH, 'Contents',
+                                                  'Resources', 'logging.conf'),
+                                     os.path.join(self.TARGET_PATH,
+                                                  'logging.conf')), {})]
+        self.overwrite_args = [((os.path.join(self.APP_PATH, 'Contents',
+                                         'Resources', 'update.conf'),
+                            os.path.join(self.TARGET_PATH,
+                                         'update.conf')), {})]
         self.patch(utils.darwin,
                    'check_and_install_fsevents_daemon',
                    lambda _: None)
@@ -78,34 +96,45 @@
         utils.install_config_and_daemons()
         self.assertEqual(self._called, [])
 
-    def _test_copying_conf_files(self, exists):
+    def _test_copying_conf_files(self, exists, src_mtime=0, dest_mtime=0):
         """Call install_config_and_daemons, parameterize os.path.exists."""
         sys.frozen = 'macosx_app'
         self.addCleanup(delattr, sys, 'frozen')
-        self.patch(utils.darwin, 'save_config_path', lambda x: "TARGET_PATH")
-        self.patch(utils.darwin, '__file__', "/path/to/Main.app/ignore")
+        self.patch(utils.darwin, 'save_config_path',
+                   lambda x: self.TARGET_PATH)
+        self.patch(utils.darwin, '__file__',
+                   os.path.join(self.APP_PATH, "ignore"))
         self.patch(os.path, "exists", lambda x: exists)
         self.patch(utils.darwin.shutil, 'copyfile',
                    self._set_called)
+
+        def fake_stat(path):
+            fakestat = namedtuple('fakestat', ['st_mtime'])
+            if path.startswith(self.APP_PATH):
+                return fakestat(src_mtime)
+            else:
+                return fakestat(dest_mtime)
+
+        self.patch(utils.os, 'stat', fake_stat)
+
         utils.install_config_and_daemons()
 
-    def test_copies_conf_files(self):
+    def test_copies_conf_files_same(self):
         """When frozen, we copy the conf files if they don't exist."""
         self._test_copying_conf_files(False)
-        self.assertEqual(self._called,
-                         [(('/path/to/Main.app/Contents/'
-                           'Resources/syncdaemon.conf',
-                           'TARGET_PATH/syncdaemon.conf'), {}),
-                          (('/path/to/Main.app/Contents/'
-                            'Resources/logging.conf',
-                            'TARGET_PATH/logging.conf'),
-                           {})])
+        self.assertEqual(self._called, self.non_overwrite_args +
+                         self.overwrite_args)
 
-    def test_does_not_copy_conf_files(self):
-        """When frozen, we do not copy the conf files if they do exist."""
-        self._test_copying_conf_files(True)
+    def test_does_not_copy_conf_files_same(self):
+        """frozen: do not copy any files that exist if their mtime is new."""
+        self._test_copying_conf_files(True, src_mtime=0, dest_mtime=1)
         self.assertEqual(self._called, [])
 
+    def test_only_copy_update_exist_same(self):
+        """frz: only copy update.conf if files exist but src mtime newer."""
+        self._test_copying_conf_files(True, src_mtime=1, dest_mtime=0)
+        self.assertEqual(self._called, self.overwrite_args)
+
 
 class InstallDaemonTestCase(CallRecordingTestCase):
     """Test fsevents daemon installation."""
@@ -326,3 +355,63 @@
         """Paths should be bytes, not unicode."""
         is_bytes = [type(n) == type(b'') for n in self.folders]
         self.assertNotIn(False, is_bytes)
+
+
+class MockStandardUserDefaults(object):
+    """Fake user defaults"""
+
+    def __init__(self, keyval):
+        self.keyval = keyval
+        self.setBool_args = []
+
+    def boolForKey_(self, key):
+        return self.keyval
+
+    def setBool_forKey_(self, bval, key):
+        self.setBool_args.append((bval, key))
+
+
+class AddU1FolderToFavoritesTestCase(CallRecordingTestCase):
+    """Test adding folder to favorites."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(AddU1FolderToFavoritesTestCase, self).setUp()
+        self.path = "/Users/a/Ubuntu%20One"
+        self.testurl = NSURL.URLWithString_("file://localhost" +
+                                            self.path)
+
+        self.patch(utils.darwin.os.path, "expanduser",
+                   lambda x: self.path)
+        self.patch(utils.darwin, "LSSharedFileListCreate",
+                   lambda x, y, z: "fake-list")
+        self.patch(utils.darwin, "kLSSharedFileListItemBeforeFirst", 1)
+        self._patch_and_track(utils.darwin, [("LSSharedFileListInsertItemURL",
+                                              None)])
+
+    def test_call_with_home_url_noflag(self):
+        """Test adding correct URL when we haven't before."""
+
+        mock_sud = MockStandardUserDefaults(False)
+        self.patch(utils.darwin, '_get_userdefaults',
+                   lambda: mock_sud)
+
+        utils.darwin.add_u1_folder_to_favorites()
+        self.assertEqual(mock_sud.setBool_args,
+                         [(True, utils.darwin.ADDED_TO_FINDER_SIDEBAR_ONCE)])
+        self.assertEqual(self._called['LSSharedFileListInsertItemURL'],
+                         [(("fake-list", 1, None, None, self.testurl, {}, []),
+                           {})])
+
+    def test_call_with_home_url_yesflag(self):
+        """Test not re-adding URL when we've done it once before."""
+
+        mock_sud = MockStandardUserDefaults(True)
+        self.patch(utils.darwin, '_get_userdefaults',
+                   lambda: mock_sud)
+
+        utils.darwin.add_u1_folder_to_favorites()
+
+        self.assertEqual(mock_sud.setBool_args, [])
+
+        self.assertEqual(self._called['LSSharedFileListInsertItemURL'], [])

=== modified file 'ubuntuone/controlpanel/utils/tests/test_windows.py'
--- ubuntuone/controlpanel/utils/tests/test_windows.py	2012-05-16 14:01:27 +0000
+++ ubuntuone/controlpanel/utils/tests/test_windows.py	2013-01-10 18:07:21 +0000
@@ -23,7 +23,7 @@
 
 from ubuntuone.controlpanel import utils
 from ubuntuone.controlpanel.tests import TestCase
-from ubuntuone.devtools.testcases import skipIfJenkins
+from ubuntuone.devtools.testcases import skipIfJenkins, skipIf
 
 # let me use protected methods
 # pylint: disable=W0212
@@ -65,8 +65,6 @@
         """Prepare for the diff tests."""
         yield super(AutoupdaterTestCase, self).setUp()
         self._base_path = r'path\to\exe'
-        self.auto_update_path = os.path.join(self._base_path,
-                                    utils.windows.AUTOUPDATE_EXE_NAME)
         self.return_from_call = 0
         self.command = None
         self.args = []
@@ -77,9 +75,11 @@
             self.args = args
             return self.return_from_call
 
-        self.patch(utils.windows, 'getProcessValue', fake_execute_process)
-        self.patch(utils.windows, 'get_exe_path',
+        self.patch(utils.common, 'getProcessValue', fake_execute_process)
+        self.patch(utils.windows, 'get_bin_cmd',
                    lambda exe_name: os.path.join(self._base_path, exe_name))
+        self.patch(utils.common, 'get_update_config',
+                   lambda: ("URL", "VERSION", "CHANNEL", "CHECK"))
 
     @defer.inlineCallbacks
     def test_are_updates_present_true(self):
@@ -87,13 +87,15 @@
         # the idea is simple, set the value to be returned from
         # the fake call, assert that we get true and also that
         # we did use the correct parameters.
-        self.return_from_call = 0
+        self.return_from_call = 1
         are_present = yield utils.are_updates_present()
         self.assertTrue(are_present, 'Updates should be present.')
         # lets assert that we did use the correct args
-        expected_args = ('--mode', 'unattended')
+        expected_args = [
+                utils.common.get_bin_cmd(utils.common.UPDATE_BIN_NAME)[1],
+                '--url', 'URL', '--current', 'VERSION',
+                '--release', 'CHANNEL']
         self.assertEqual(expected_args, self.args)
-        self.assertEqual(self.command, self.auto_update_path)
 
     @defer.inlineCallbacks
     def test_are_updates_present_false(self):
@@ -103,16 +105,22 @@
         are_present = yield utils.are_updates_present()
         self.assertFalse(are_present, 'Updates should NOT be present.')
         # lets assert that we did use the correct args
-        expected_args = ('--mode', 'unattended')
+        expected_args = [
+                utils.common.get_bin_cmd(utils.common.UPDATE_BIN_NAME)[1],
+                '--url', 'URL', '--current', 'VERSION',
+                '--release', 'CHANNEL']
         self.assertEqual(expected_args, self.args)
-        self.assertEqual(self.command, self.auto_update_path)
 
     def test_perform_update(self):
         """Test the method that performs the update."""
         self.patch(utils.windows.win32api, 'ShellExecute', self._set_called)
         utils.perform_update()
-        args = (None, 'runas', self.auto_update_path,
-                '--unattendedmodeui none', '', 0)
+        args = [utils.common.get_bin_cmd(utils.common.UPDATE_BIN_NAME)[1],
+                '--url', 'URL', '--current', 'VERSION',
+                '--release', 'CHANNEL', '--install']
+        args = (None, 'runas',
+                utils.common.get_bin_cmd(utils.common.UPDATE_BIN_NAME)[0],
+                ' '.join(args), '', 0)
         self.assertEqual(self._called, (args, {}))
 
 
@@ -247,72 +255,7 @@
         self.test_special_folders(names=('PERSONAL', 'MYMUSIC', 'MYPICTURES'))
 
 
-class GetExePathTestCase(FrozenTestCase):
-    """Test the path calculator when sys is frozen."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the different tests."""
-        yield super(GetExePathTestCase, self).setUp()
-        self.called = []
-        self.exists = True
-
-        def fake_abspath(path):
-            """Fake os.path.abspath."""
-            self.called.append('os.path.abspath')
-            return path
-
-        def fake_dirname(path):
-            """Fake os.path.dirname."""
-            self.called.append('os.path.dirname')
-            return path
-
-        def fake_exists(path):
-            """Fake os.path.exists."""
-            self.called.append('os.path.exists')
-            return self.exists
-
-        # patch the os.path functions used
-        self.patch(utils.windows.os.path, 'abspath', fake_abspath)
-        self.patch(utils.windows.os.path, 'dirname', fake_dirname)
-        self.patch(utils.windows.os.path, 'exists', fake_exists)
-
-    def test_get_exe_path(self):
-        """Test the method used to get the autoupdate."""
-        path = utils.windows.get_exe_path(exe_name=SOME_EXE_NAME)
-
-        self.assertEqual(os.path.join(self.executable, SOME_EXE_NAME), path)
-
-        expected = ['os.path.abspath', 'os.path.dirname', 'os.path.dirname',
-                    'os.path.exists']
-        self.assertEqual(expected, self.called)
-
-    def test_get_exe_path_not_present(self):
-        """Test the method used to get the autoupdate."""
-        self.exists = False
-
-        # called method and assert that we have the correct result
-        path = utils.windows.get_exe_path(exe_name=SOME_EXE_NAME)
-        self.assertTrue(path is None)
-
-
-class GetExePathNotFrozenTestCase(GetExePathTestCase):
-    """Test the path calculator when sys is not frozen."""
-
-    frozen = None
-
-    def test_get_exe_path(self):
-        """Test the method used to get the autoupdate."""
-        self.patch(utils.windows, '__file__', self.executable)
-
-        path = utils.windows.get_exe_path(exe_name=SOME_EXE_NAME)
-        self.assertEqual(os.path.join(self.executable, SOME_EXE_NAME), path)
-
-        expected = ['os.path.dirname', 'os.path.dirname', 'os.path.dirname',
-                    'os.path.exists']
-        self.assertEqual(expected, self.called)
-
-
+@skipIf(not getattr(sys, "frozen", False), "Only applicable when frozen")
 class UninstallApplicationTestCase(FrozenTestCase):
     """Test the uninstall_application helper when sys is frozen."""
 
@@ -327,7 +270,7 @@
         utils.uninstall_application()
 
         exe_name = utils.windows.UNINSTALL_EXE_NAME
-        uninstall_path = utils.windows.get_exe_path(exe_name=exe_name)
+        uninstall_path = utils.common.get_bin_cmd(exe_name=exe_name)[0]
         self.assertEqual(self._called,
             ((None, '', uninstall_path, '--mode win32', '', 0), {}))
 

=== modified file 'ubuntuone/controlpanel/utils/windows.py'
--- ubuntuone/controlpanel/utils/windows.py	2012-04-05 14:52:55 +0000
+++ ubuntuone/controlpanel/utils/windows.py	2013-01-10 18:07:21 +0000
@@ -27,32 +27,15 @@
 from win32com.shell import shell, shellcon
 # pylint: enable=F0401
 from twisted.internet import defer
-from twisted.internet.utils import getProcessValue
 
+from ubuntuone.controlpanel.utils.common import (call_updater, get_bin_cmd)
 from ubuntuone.controlpanel.logger import setup_logging
 
 logger = setup_logging('utils.windows')
-AUTOUPDATE_EXE_NAME = 'autoupdate-windows.exe'
 AUTORUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"
 UNINSTALL_EXE_NAME = 'uninstall.exe'
 
 
-def get_exe_path(exe_name):
-    """Return the path in which the autoupdate command is found."""
-    if getattr(sys, 'frozen', False):
-        exec_path = os.path.abspath(sys.executable)
-    else:
-        exec_path = os.path.dirname(__file__)
-
-    result = None
-    folder = os.path.dirname(os.path.dirname(exec_path))
-    exe_path = os.path.join(folder, exe_name)
-    if os.path.exists(exe_path):
-        result = exe_path
-
-    return result
-
-
 def add_to_autostart():
     """Add syncdaemon to the session's autostart."""
     if getattr(sys, "frozen", False):
@@ -74,19 +57,15 @@
 @defer.inlineCallbacks
 def are_updates_present():
     """Return if there are updates for Ubuntu One."""
-    result = False
-    retcode = None
-    update_path = get_exe_path(exe_name=AUTOUPDATE_EXE_NAME)
-    if update_path is not None:
-        # If there is an update present we will get 0, non-zero otherwise
-        retcode = yield getProcessValue(update_path, args=('--mode',
-            'unattended'), path=os.path.dirname(update_path))
-        result = retcode == 0
-    logger.debug('are_updates_present: update path: %r, return code: %r,'
-                 ' result: %r', update_path, retcode, result)
+    result = yield call_updater(install=False)
     defer.returnValue(result)
 
 
+def call_elevated(exe, args):
+    """ShellExecute wrapper that uses 'runas' to elevate."""
+    win32api.ShellExecute(None, "runas", exe, " ".join(args), "", 0)
+
+
 def default_folders(user_home=None):
     """Return a list of the folders to add by default."""
     # as per http://msdn.microsoft.com/en-us/library/windows/desktop/bb762181,
@@ -112,16 +91,14 @@
 
 
 def perform_update():
-    """Spawn the autoupdate process and call the stop function."""
-    update_path = get_exe_path(exe_name=AUTOUPDATE_EXE_NAME)
-    if update_path is not None:
-        # lets call the updater with the commands that are required,
-        win32api.ShellExecute(None, 'runas', update_path,
-                              '--unattendedmodeui none', '', 0)
+    """Spawn the autoupdate process, which will eventually kill us."""
+    call_updater(call_elevated, install=True)
 
 
 def uninstall_application():
     """Uninstall Ubuntu One."""
-    uninstall_path = get_exe_path(exe_name=UNINSTALL_EXE_NAME)
-    if uninstall_path is not None:
-        win32api.ShellExecute(None, '', uninstall_path, '--mode win32', '', 0)
+    if getattr(sys, "frozen", False):
+        uninstall_path = get_bin_cmd(UNINSTALL_EXE_NAME)[0]
+        if uninstall_path is not None:
+            win32api.ShellExecute(None, '', uninstall_path,
+                                  '--mode win32', '', 0)