~ubuntu-branches/ubuntu/natty/ubuntuone-control-panel/natty

# -*- coding: utf-8 -*-

# Authors: Alejandro J. Cura <alecu@canonical.com>

# Authors: Natalia B. Bidart <nataliabidart@canonical.com>

#

# Copyright 2010 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/>.

"""Client to use other DBus services."""

import dbus.service

import ubuntu_sso

from twisted.internet import defer

from ubuntuone.clientdefs import APP_NAME

from ubuntuone.platform.linux import dbus_interface as sd_dbus_iface

from ubuntuone.platform.linux.tools import SyncDaemonTool

from ubuntuone.controlpanel.logger import setup_logging

logger = setup_logging('dbus_client')

class CredentialsError(Exception):

    """No credentials could be retrieved."""

class VolumesError(Exception):

    """An operation over a volume failed."""

def no_op(*a):

    """Do nothing"""

def get_sso_proxy():

    """Get a DBus proxy for credentials management."""

    bus = dbus.SessionBus()

    obj = bus.get_object(bus_name=ubuntu_sso.DBUS_BUS_NAME,

                         object_path=ubuntu_sso.DBUS_CREDENTIALS_PATH,

                         follow_name_owner_changes=True)

    proxy = dbus.Interface(object=obj,

                           dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)

    return proxy

def get_credentials():

    """Get the credentials from the ubuntu-sso-client."""

    d = defer.Deferred()

    proxy = get_sso_proxy()

    def found_credentials(app_name, creds):

        """Credentials have been found."""

        if app_name == APP_NAME:

            logger.info('credentials were found! (%r).', APP_NAME)

            d.callback(creds)

    def credentials_error(app_name, error_dict=None):

        """No credentials could be retrieved."""

        if app_name == APP_NAME:

            if error_dict is None:

                error_dict = {'error_message': 'Credentials were not found.',

                              'detailed_error': ''}

            logger.error('credentials error (%r, %r).', app_name, error_dict)

            error = CredentialsError(app_name, error_dict)

            d.errback(error)

    foundsig = proxy.connect_to_signal("CredentialsFound", found_credentials)

    notfoundsig = proxy.connect_to_signal("CredentialsNotFound",

                                          credentials_error)

    errorsig = proxy.connect_to_signal("CredentialsError", credentials_error)

    logger.debug('calling get_credentials.')

    proxy.find_credentials(APP_NAME, {'': ''},

                           reply_handler=no_op, error_handler=d.errback)

    def cleanup_signals(result):

        """Remove signals after use."""

        foundsig.remove()

        notfoundsig.remove()

        errorsig.remove()

        return result

    d.addBoth(cleanup_signals)

    return d

def clear_credentials():

    """Clear the credentials using the ubuntu-sso-client."""

    d = defer.Deferred()

    proxy = get_sso_proxy()

    def credentials_cleared(app_name):

        """Credentials have been cleared."""

        logger.debug('credentials were cleared for app_name %r.', app_name)

        if app_name == APP_NAME:

            logger.info('credentials were cleared! (%r).', APP_NAME)

            d.callback(app_name)

    def credentials_error(app_name, error_dict=None):

        """No credentials could be retrieved."""

        if app_name == APP_NAME:

            logger.error('credentials error (%r, %r).', app_name, error_dict)

            error = CredentialsError(app_name, error_dict)

            d.errback(error)

    clearedsig = proxy.connect_to_signal("CredentialsCleared",

                                         credentials_cleared)

    errorsig = proxy.connect_to_signal("CredentialsError", credentials_error)

    logger.warning('calling clear_credentials.')

    proxy.clear_credentials(APP_NAME, {'': ''},

                            reply_handler=no_op, error_handler=d.errback)

    def cleanup_signals(result):

        """Remove signals after use."""

        clearedsig.remove()

        errorsig.remove()

        return result

    d.addBoth(cleanup_signals)

    return d

def get_syncdaemon_proxy(object_path, dbus_interface):

    """Get a DBus proxy for syncdaemon at 'object_path':'dbus_interface'."""

    logger.debug('get_syncdaemon_proxy: object_path %r, dbus_interface %r',

                 object_path, dbus_interface)

    bus = dbus.SessionBus()

    obj = bus.get_object(bus_name=sd_dbus_iface.DBUS_IFACE_NAME,

                         object_path=object_path,

                         follow_name_owner_changes=True)

    proxy = dbus.Interface(object=obj, dbus_interface=dbus_interface)

    return proxy

def get_config_syncdaemon_proxy():

    """Get a DBus proxy for syncdaemon config calls."""

    return get_syncdaemon_proxy("/config",

                                sd_dbus_iface.DBUS_IFACE_CONFIG_NAME)

def get_folders_syncdaemon_proxy():

    """Get a DBus proxy for syncdaemon folders calls."""

    return get_syncdaemon_proxy("/folders",

                                sd_dbus_iface.DBUS_IFACE_FOLDERS_NAME)

def get_status_syncdaemon_proxy():

    """Get a DBus proxy for syncdaemon status calls."""

    return get_syncdaemon_proxy("/status",

                                sd_dbus_iface.DBUS_IFACE_STATUS_NAME)

def get_throttling_limits():

    """Get the speed limits from the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    proxy.get_throttling_limits(reply_handler=d.callback,

                                error_handler=d.errback)

    return d

def set_throttling_limits(limits):

    """Set the speed limits on the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    download = int(limits["download"])

    upload = int(limits["upload"])

    proxy.set_throttling_limits(download, upload,

                                reply_handler=lambda: d.callback("ok"),

                                error_handler=d.errback)

    return d

def bandwidth_throttling_enabled():

    """Get the state of throttling in the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    proxy.bandwidth_throttling_enabled(reply_handler=d.callback,

                                       error_handler=d.errback)

    return d

def enable_bandwidth_throttling():

    """Enable the speed limits in the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    proxy.enable_bandwidth_throttling(reply_handler=lambda: d.callback("ok"),

                                      error_handler=d.errback)

    return d

def disable_bandwidth_throttling():

    """Disable the speed limits in the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    proxy.disable_bandwidth_throttling(reply_handler=lambda: d.callback("ok"),

                                       error_handler=d.errback)

    return d

def show_all_notifications_enabled():

    """Get the state of show_all_notifications in the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    proxy.show_all_notifications_enabled(reply_handler=d.callback,

                                         error_handler=d.errback)

    return d

def enable_show_all_notifications():

    """Enable show_all_notifications in the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    proxy.enable_show_all_notifications(reply_handler=lambda: d.callback("ok"),

                                        error_handler=d.errback)

    return d

def disable_show_all_notifications():

    """Disable show_all_notifications in the syncdaemon."""

    d = defer.Deferred()

    proxy = get_config_syncdaemon_proxy()

    handler = lambda: d.callback("ok")

    proxy.disable_show_all_notifications(reply_handler=handler,

                                         error_handler=d.errback)

    return d

def get_root_dir():

    """Retrieve the root information from syncdaemon."""

    d = defer.Deferred()

    proxy = get_syncdaemon_proxy("/", sd_dbus_iface.DBUS_IFACE_SYNC_NAME)

    proxy.get_rootdir(reply_handler=d.callback, error_handler=d.errback)

    return d

def get_shares_dir():

    """Retrieve the shares information from syncdaemon."""

    d = defer.Deferred()

    proxy = get_syncdaemon_proxy("/", sd_dbus_iface.DBUS_IFACE_SYNC_NAME)

    proxy.get_sharesdir(reply_handler=d.callback, error_handler=d.errback)

    return d

def get_shares_dir_link():

    """Retrieve the shares information from syncdaemon."""

    d = defer.Deferred()

    proxy = get_syncdaemon_proxy("/", sd_dbus_iface.DBUS_IFACE_SYNC_NAME)

    proxy.get_sharesdir_link(reply_handler=d.callback, error_handler=d.errback)

    return d

def get_folders():

    """Retrieve the folders information from syncdaemon."""

    d = defer.Deferred()

    proxy = get_folders_syncdaemon_proxy()

    proxy.get_folders(reply_handler=d.callback, error_handler=d.errback)

    return d

def create_folder(path):

    """Create a new folder through syncdaemon."""

    d = defer.Deferred()

    proxy = get_folders_syncdaemon_proxy()

    sig = proxy.connect_to_signal('FolderCreated', d.callback)

    cb = lambda path, error: d.errback(VolumesError(path, error))

    esig = proxy.connect_to_signal('FolderCreateError', cb)

    proxy.create(path, reply_handler=no_op, error_handler=d.errback)

    def cleanup_signals(result):

        """Remove signals after use."""

        sig.remove()

        esig.remove()

        return result

    d.addBoth(cleanup_signals)

    return d

def subscribe_folder(folder_id):

    """Subscribe to 'folder_id'."""

    d = defer.Deferred()

    proxy = get_folders_syncdaemon_proxy()

    sig = proxy.connect_to_signal('FolderSubscribed', d.callback)

    cb = lambda info, error: d.errback(VolumesError(info['id'], error))

    esig = proxy.connect_to_signal('FolderSubscribeError', cb)

    proxy.subscribe(folder_id, reply_handler=no_op, error_handler=no_op)

    def cleanup_signals(result):

        """Remove signals after use."""

        sig.remove()

        esig.remove()

        return result

    d.addBoth(cleanup_signals)

    return d

def unsubscribe_folder(folder_id):

    """Unsubscribe 'folder_id'."""

    d = defer.Deferred()

    proxy = get_folders_syncdaemon_proxy()

    sig = proxy.connect_to_signal('FolderUnSubscribed', d.callback)

    cb = lambda info, error: d.errback(VolumesError(info['id'], error))

    esig = proxy.connect_to_signal('FolderUnSubscribeError', cb)

    proxy.unsubscribe(folder_id, reply_handler=no_op, error_handler=no_op)

    def cleanup_signals(result):

        """Remove signals after use."""

        sig.remove()

        esig.remove()

        return result

    d.addBoth(cleanup_signals)

    return d

@defer.inlineCallbacks

def get_shares():

    """Retrieve the shares information from syncdaemon."""

    result = yield SyncDaemonTool(bus=dbus.SessionBus()).get_shares()

    defer.returnValue(result)

@defer.inlineCallbacks

def subscribe_share(share_id):

    """Subscribe to 'share_id'."""

    try:

        yield SyncDaemonTool(bus=dbus.SessionBus()).subscribe_share(share_id)

    except Exception, e:

        raise VolumesError(share_id, e)

@defer.inlineCallbacks

def unsubscribe_share(share_id):

    """Unsubscribe 'share_id'."""

    try:

        yield SyncDaemonTool(bus=dbus.SessionBus()).unsubscribe_share(share_id)

    except Exception, e:

        raise VolumesError(share_id, e)

def get_current_status():

    """Retrieve the current status from syncdaemon."""

    d = defer.Deferred()

    proxy = get_status_syncdaemon_proxy()

    proxy.current_status(reply_handler=d.callback, error_handler=d.errback)

    return d

def set_status_changed_handler(handler):

    """Connect 'handler' with syncdaemon's StatusChanged signal."""

    proxy = get_status_syncdaemon_proxy()

    sig = proxy.connect_to_signal('StatusChanged', handler)

    return proxy, sig

def files_sync_enabled():

    """Get if file sync service is enabled."""

    enabled = SyncDaemonTool(bus=None).is_files_sync_enabled()

    return defer.succeed(enabled)

@defer.inlineCallbacks

def set_files_sync_enabled(enabled):

    """Set the file sync service to be 'enabled'."""

    yield SyncDaemonTool(bus=dbus.SessionBus()).enable_files_sync(enabled)

@defer.inlineCallbacks

def connect_file_sync():

    """Connect the file sync service."""

    yield SyncDaemonTool(bus=dbus.SessionBus()).connect()

@defer.inlineCallbacks

def disconnect_file_sync():

    """Disconnect the file sync service."""

    yield SyncDaemonTool(bus=dbus.SessionBus()).disconnect()

@defer.inlineCallbacks

def start_file_sync():

    """Start the file sync service."""

    yield SyncDaemonTool(bus=dbus.SessionBus()).start()

@defer.inlineCallbacks

def stop_file_sync():

    """Stop the file sync service."""

    yield SyncDaemonTool(bus=dbus.SessionBus()).quit()