Merge lp:keeper/devel into lp:keeper

[dobey]

This is just to merge what's in devel (which has apparently already mostly been released to zesty/xenial+overlay), into trunk. Only missing piece from release is for the UAL API/ABI change.

[lp:keeper/devel]

130. By dobey on 2017-02-27

Update the changelog for Ken's change, and to keep the already released version when releasing to trunk.
Fix comment starter removed in a previous change.

Approved by unity-api-1-bot, Charles Kerr.

[Charles Kerr (charlesk)]

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-08-26 09:30:11 +0000
+++ CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -272,7 +272,7 @@
 include(CTest)
 enable_testing()
 
-include(EnableCoverageReport)
+find_package(CoverageReport)
 
 add_subdirectory(data)
 add_subdirectory(src)

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2016-08-10 07:43:36 +0000
+++ data/CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -6,6 +6,12 @@
   FOLDER_BACKUP_EXEC
   ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}/folder-backup.sh
 )
+
+set(
+  FOLDER_RESTORE_EXEC
+  ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}/folder-restore.sh
+)
+
 configure_file(
   ${HELPER_REGISTRY_FILENAME}.in
   ${HELPER_REGISTRY_FILENAME}

=== modified file 'data/helper-registry.json.in'
--- data/helper-registry.json.in	2016-08-09 04:20:33 +0000
+++ data/helper-registry.json.in	2017-02-27 19:05:17 +0000
@@ -4,5 +4,10 @@
             "@FOLDER_BACKUP_EXEC@",
             "${subtype}"
         ]
-    }
+        ,
+        "restore-urls": [
+            "@FOLDER_RESTORE_EXEC@",
+            "${subtype}"
+        ]
+     }
 }

=== modified file 'debian/changelog'
--- debian/changelog	2016-09-15 19:20:14 +0000
+++ debian/changelog	2017-02-27 19:05:17 +0000
@@ -1,3 +1,17 @@
+keeper (0.1.1-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Ken Vandine ]
+  * Update to handle the API/ABI break in ubuntu-app-launch.
+
+ -- Rodney Dawes <[e-mail]>  Mon, 27 Feb 2017 13:46:45 -0500
+
+keeper (0.1.0+17.04.20170213.1-0ubuntu1) zesty; urgency=medium
+
+  [ Charles Kerr, Xavi Garcia, Xavi Garcia Mena ]
+  * Adds integration tests for restore and restore cancellation.
+
+ -- Xavi Garcia <[e-mail]>  Mon, 13 Feb 2017 08:57:47 +0000
+
 keeper (0.1.0+16.10.20160915.3-0ubuntu1) yakkety; urgency=medium
 
   * Initial release. 

=== modified file 'debian/control'
--- debian/control	2016-08-26 08:48:05 +0000
+++ debian/control	2017-02-27 19:05:17 +0000
@@ -9,7 +9,7 @@
 # for building the code:
                libarchive-dev (>= 3.1.2),
                libproperties-cpp-dev,
-               libubuntu-app-launch2-dev (>= 0.9),
+               libubuntu-app-launch3-dev,
                storage-framework-client-dev,
                libclick-0.4-dev,
                uuid-dev,
@@ -45,6 +45,8 @@
 Depends: ${shlibs:Depends}, 
          ${misc:Depends},
          systemd | systemd-shim,
+         tar,
+         xz-utils
 Description: Backup Tool
  A backup/restore utility for Ubuntu
 
@@ -53,6 +55,8 @@
 Depends: ${shlibs:Depends},
          ${misc:Depends},
          systemd | systemd-shim,
+         tar,
+         xz-utils
 Description: Backup Tool
  A backup/restore utility for Ubuntu (client application)
 

=== modified file 'debian/keeper.install'
--- debian/keeper.install	2016-08-10 07:43:36 +0000
+++ debian/keeper.install	2017-02-27 19:05:17 +0000
@@ -1,6 +1,8 @@
 /usr/lib/*/keeper/folder-backup.sh
+/usr/lib/*/keeper/folder-restore.sh
 /usr/lib/*/keeper/keeper-service
-/usr/lib/*/keeper/keeper-tar-create
+/usr/lib/*/keeper/keeper-tar
+/usr/lib/*/keeper/keeper-untar
 /usr/lib/*/ubuntu-app-launch/backup-helper/exec-tool
 /usr/share/keeper/helper-registry.json
 /usr/share/dbus-1/services/com.canonical.keeper.service

=== modified file 'include/client/client.h'
--- include/client/client.h	2016-09-06 18:28:45 +0000
+++ include/client/client.h	2017-02-27 19:05:17 +0000
@@ -19,10 +19,13 @@
 
 #pragma once
 
+#include "keeper-errors.h"
+
 #include <QObject>
 #include <QScopedPointer>
 #include <QStringList>
 #include <QVariant>
+#include "keeper-items.h"
 
 struct KeeperClientPrivate;
 
@@ -53,14 +56,22 @@
 
     Q_INVOKABLE QString getBackupName(QString uuid);
     Q_INVOKABLE void enableBackup(QString uuid, bool enabled);
-    Q_INVOKABLE void startBackup();
+    Q_INVOKABLE void startBackup(QString const & storage);
+
+    Q_INVOKABLE void enableRestore(QString uuid, bool enabled);
+    Q_INVOKABLE void startRestore(QString const & storage);
+
+    Q_INVOKABLE void cancel();
 
 // C++
 public:
-    QMap<QString, QVariantMap> getBackupChoices() const;
-    void startBackup(QStringList const& uuids) const;
+    keeper::Items getBackupChoices(keeper::Error & error) const;
+    keeper::Items getRestoreChoices(QString const & storage, keeper::Error & error) const;
+    void startBackup(QStringList const& uuids, QString const & storage) const;
+    void startRestore(QStringList const& uuids, QString const & storage) const;
 
-    QMap<QString, QVariantMap> getState() const;
+    keeper::Items getState() const;
+    QStringList getStorageAccounts() const;
 
 Q_SIGNALS:
     void statusChanged();
@@ -68,6 +79,9 @@
     void readyToBackupChanged();
     void backupBusyChanged();
 
+    void taskStatusChanged(QString const & displayName, QString const & status, double percentage, keeper::Error error);
+    void finished();
+
 private Q_SLOTS:
     void stateUpdated();
 

=== added file 'include/client/keeper-errors.h'
--- include/client/keeper-errors.h	1970-01-01 00:00:00 +0000
+++ include/client/keeper-errors.h	2017-02-27 19:05:17 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia Mena <[e-mail]>
+ */
+
+#pragma once
+
+#include <QDBusArgument>
+#include <QMetaType>
+
+namespace keeper
+{
+
+enum class Error
+{
+    OK,
+    UNKNOWN,
+    HELPER_READ,
+    HELPER_WRITE,
+    HELPER_INACTIVITY_DETECTED,
+    HELPER_SOCKET,
+    HELPER_START_TIMEOUT,
+    NO_HELPER_INFORMATION_IN_REGISTRY,
+    HELPER_BAD_URL,
+    MANIFEST_STORAGE,
+    COMMITTING_DATA,
+
+    CREATING_REMOTE_DIR,
+    CREATING_REMOTE_FILE,
+    READING_REMOTE_FILE,
+    REMOTE_DIR_NOT_EXISTS,
+    NO_REMOTE_ACCOUNTS,
+    NO_REMOTE_ROOTS,
+    ACCOUNT_NOT_FOUND
+};
+
+Error convert_from_dbus_variant(const QVariant & value, bool *conversion_ok = nullptr);
+} // namespace keeper
+
+QDBusArgument &operator<<(QDBusArgument &argument, keeper::Error value);
+const QDBusArgument &operator>>(const QDBusArgument &argument, keeper::Error &val);
+
+Q_DECLARE_METATYPE(keeper::Error)

=== added file 'include/client/keeper-items.h'
--- include/client/keeper-items.h	1970-01-01 00:00:00 +0000
+++ include/client/keeper-items.h	2017-02-27 19:05:17 +0000
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia Mena <[e-mail]>
+ */
+
+#pragma once
+
+#include "client/keeper-errors.h"
+
+#include <QJsonObject>
+
+typedef QMap<QString, QVariantMap> QVariantDictMap;
+
+namespace keeper
+{
+
+class Item : public QVariantMap
+{
+public:
+    Item();
+    ~Item();
+    explicit Item(QVariantMap const & values);
+
+    // keys
+    static QString const UUID_KEY;
+    static QString const TYPE_KEY;
+    static QString const SUBTYPE_KEY;
+    static QString const NAME_KEY;
+    static QString const PACKAGE_KEY;
+    static QString const TITLE_KEY;
+    static QString const VERSION_KEY;
+    static QString const FILE_NAME_KEY;
+    static QString const DIR_NAME_KEY;
+    static QString const DISPLAY_NAME_KEY;
+    static QString const STATUS_KEY;
+    static QString const ERROR_KEY;
+    static QString const PERCENT_DONE_KEY;
+    static QString const SPEED_KEY;
+
+    // values
+    static QString const FOLDER_VALUE;
+    static QString const SYSTEM_DATA_VALUE;
+    static QString const APPLICATION_VALUE;
+
+
+    // methods created for convenience
+    bool has_property(QString const & property) const;
+    template<typename T> T get_property(QString const & property, bool * valid) const;
+    QVariant get_property_value(QString const & property) const;
+    void set_property_value(QString const& property, QVariant const& value);
+
+    // checks that the item is valid
+    bool is_valid() const;
+
+    // predefined properties
+    QString get_uuid(bool *valid = nullptr) const;
+    QString get_type(bool *valid = nullptr) const;
+    QString get_display_name(bool *valid = nullptr) const;
+    QString get_dir_name(bool *valid = nullptr) const;
+    QString get_status(bool *valid = nullptr) const;
+    double get_percent_done(bool *valid = nullptr) const;
+    keeper::Error get_error(bool *valid = nullptr) const;
+    QString get_file_name(bool *valid = nullptr) const;
+
+    // d-bus
+    static void registerMetaType();
+};
+
+class Items : public QMap<QString, Item>
+{
+public:
+    Items();
+    ~Items();
+    explicit Items(Error error);
+
+    QStringList get_uuids() const;
+
+    // d-bus
+    static void registerMetaType();
+
+private:
+    Error error_ = Error::OK;
+};
+
+} // namespace keeper
+
+Q_DECLARE_METATYPE(keeper::Item)
+Q_DECLARE_METATYPE(keeper::Items)

=== modified file 'include/helper/backup-helper.h'
--- include/helper/backup-helper.h	2016-09-15 16:02:54 +0000
+++ include/helper/backup-helper.h	2017-02-27 19:05:17 +0000
@@ -53,6 +53,7 @@
     int get_helper_socket() const;
     QString to_string(Helper::State state) const override;
     void set_state(State) override;
+    QString get_uploader_committed_file_name() const;
 protected:
     void on_helper_finished() override;
 

=== modified file 'include/helper/data-dir-registry.h'
--- include/helper/data-dir-registry.h	2016-08-09 05:44:25 +0000
+++ include/helper/data-dir-registry.h	2017-02-27 19:05:17 +0000
@@ -39,6 +39,8 @@
 
     QStringList get_backup_helper_urls(Metadata const& metadata) override;
 
+    QStringList get_restore_helper_urls(Metadata const& metadata) override;
+
 private:
     class Impl;
     friend class Impl;

=== modified file 'include/helper/helper.h'
--- include/helper/helper.h	2016-09-15 16:02:54 +0000
+++ include/helper/helper.h	2017-02-27 19:05:17 +0000
@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include <client/keeper-errors.h>
 #include <util/attributes.h>
 
 #include <QObject>
@@ -64,11 +65,12 @@
     virtual void start(QStringList const& urls);
     virtual void stop();
 
-    static constexpr int MAX_UAL_WAIT_TIME = 5000;
+    static constexpr int MAX_UAL_WAIT_TIME = 10000;
 
 Q_SIGNALS:
     void state_changed(Helper::State);
     void percent_done_changed(float);
+    void error(keeper::Error error);
 
 protected:
     Helper(QString const & appid, const clock_func& clock=default_clock, QObject *parent=nullptr);

=== modified file 'include/helper/metadata.h'
--- include/helper/metadata.h	2016-09-06 18:51:30 +0000
+++ include/helper/metadata.h	2017-02-27 19:05:17 +0000
@@ -19,42 +19,21 @@
 
 #pragma once
 
+#include "client/keeper-items.h"
+#include <QJsonObject>
 #include <QMap>
 #include <QString>
 
 /**
- * Information about a backup
+ * Information about a backup or restore item
  */
-class Metadata
+class Metadata : public keeper::Item
 {
 public:
 
     Metadata();
+    explicit Metadata(QJsonObject const & json_object);
     Metadata(QString const& uuid, QString const& display_name);
 
-    // metadata keys
-    static QString const TYPE_KEY;
-    static QString const SUBTYPE_KEY;
-    static QString const NAME_KEY;
-    static QString const PACKAGE_KEY;
-    static QString const TITLE_KEY;
-    static QString const VERSION_KEY;
-
-    // metadata values
-    static QString const FOLDER_VALUE;
-    static QString const SYSTEM_DATA_VALUE;
-    static QString const APPLICATION_VALUE;
-
-    QString uuid() const { return uuid_; }
-    QString display_name() const { return display_name_; }
-    bool get_property(QString const& property_name, QString& setme_value) const;
-    void set_property(QString const& property_name, QString const& value);
-
-    QMap<QString,QString> get_public_properties() const;
-
-private:
-
-    QString uuid_;
-    QString display_name_;
-    QMap<QString,QString> properties_{};
+    QJsonObject json() const;
 };

=== modified file 'include/helper/registry.h'
--- include/helper/registry.h	2016-08-08 04:56:35 +0000
+++ include/helper/registry.h	2017-02-27 19:05:17 +0000
@@ -30,6 +30,7 @@
     Q_DISABLE_COPY(HelperRegistry)
 
     virtual QStringList get_backup_helper_urls(Metadata const& task) =0;
+    virtual QStringList get_restore_helper_urls(Metadata const& task) =0;
 
 protected:
     HelperRegistry() =default;

=== added file 'include/helper/restore-helper.h'
--- include/helper/restore-helper.h	1970-01-01 00:00:00 +0000
+++ include/helper/restore-helper.h	2017-02-27 19:05:17 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ *     Charles Kerr <[e-mail]>
+ */
+
+#pragma once
+
+#include "storage-framework/downloader.h"
+#include "helper/helper.h" // parent class
+#include "helper/registry.h"
+
+#include <QObject>
+#include <QScopedPointer>
+#include <QString>
+
+#include <memory>
+
+class RestoreHelperPrivate;
+class RestoreHelper final: public Helper
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(RestoreHelper)
+
+public:
+    RestoreHelper(
+        QString const & appid,
+        clock_func const & clock=Helper::default_clock,
+        QObject * parent=nullptr
+    );
+    virtual ~RestoreHelper();
+    Q_DISABLE_COPY(RestoreHelper)
+
+    static constexpr int MAX_INACTIVITY_TIME = 15000;
+
+    void set_downloader(std::shared_ptr<Downloader> const& downloader);
+
+    void start(QStringList const& urls) override;
+    void stop() override;
+    int get_helper_socket() const;
+    QString to_string(Helper::State state) const override;
+    void set_state(State) override;
+protected:
+    void on_helper_finished() override;
+
+private:
+    QScopedPointer<RestoreHelperPrivate> const d_ptr;
+};

=== modified file 'src/cli/CMakeLists.txt'
--- src/cli/CMakeLists.txt	2016-09-06 01:31:59 +0000
+++ src/cli/CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -5,6 +5,9 @@
 
 set(CLI_SOURCES
   main.cpp
+  command-line.cpp
+  command-line-client.cpp
+  command-line-client-view.cpp
 )
 
 add_executable(
@@ -19,6 +22,7 @@
   util
   qdbus-stubs
   ${SERVICE_DEVEL_SF_DEPS_LIBRARIES}
+  ${KEEPER_CLIENT_LIB}
   Qt5::Core
   Qt5::DBus
 )

=== added file 'src/cli/command-line-client-view.cpp'
--- src/cli/command-line-client-view.cpp	1970-01-01 00:00:00 +0000
+++ src/cli/command-line-client-view.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ */
+#include "command-line-client-view.h"
+
+#include <client/client.h>
+
+#include <iostream>
+#include <iomanip>
+
+CommandLineClientView::CommandLineClientView(QObject * parent)
+    : QObject(parent)
+{
+    connect(&timer_status_, &QTimer::timeout, this, &CommandLineClientView::show_info);
+
+    // TODO see if we can do this in a better way
+    // This line is for the global progress status and percentage
+    std::cout << std::endl;
+}
+
+void CommandLineClientView::progress_changed(double percentage)
+{
+    percentage_ = percentage * 100;
+}
+
+void CommandLineClientView::status_changed(QString const & status)
+{
+    if (status_ != status)
+    {
+        status_ = status;
+    }
+}
+
+void CommandLineClientView::add_task(QString const & display_name, QString const & initial_status, double initial_percentage)
+{
+    tasks_strings_[display_name] = get_task_string(display_name, initial_status, initial_percentage, keeper::Error::OK);
+    // TODO see if we can do this in a better way
+    // We add a line per each backup task
+    std::cout << std::endl;
+}
+
+void CommandLineClientView::clear_all_tasks()
+{
+    tasks_strings_.clear();
+}
+
+void CommandLineClientView::start_printing_tasks()
+{
+    timer_status_.start(300);
+}
+
+void CommandLineClientView::clear_all()
+{
+    timer_status_.stop();
+    std::cout << std::endl;
+}
+
+void CommandLineClientView::print_sections(QStringList const & sections)
+{
+    for (auto const & section : sections)
+    {
+        std::cout << section.toStdString() << std::endl;
+    }
+}
+
+void CommandLineClientView::print_error_message(QString const & error_message)
+{
+    std::cerr << error_message.toStdString() << std::endl;
+}
+
+void CommandLineClientView::show_info()
+{
+    // TODO Revisit this code to see if we can do this in a different way
+    // Maybe using ncurses?
+
+    // Rewind to the beginning
+    std::cout << '\r' << std::flush;
+    // For every backup task we go up 1 line
+    for (auto i = 0; i < tasks_strings_.size(); ++i)
+    {
+        std::cout << "\e[A";
+    }
+    // print the tasks
+    for (auto iter = tasks_strings_.begin(); iter != tasks_strings_.end(); ++iter)
+    {
+        std::cout << (*iter).toStdString() << std::setfill(' ') << std::endl;
+    }
+    std::cout << '\r' << std::fixed << std::setw(30) << status_.toStdString()  << std::setprecision(3)
+              << std::setfill(' ') << "  " << percentage_ << " %  " << get_next_spin_char() << "       " << std::flush;
+}
+
+char CommandLineClientView::get_next_spin_char()
+{
+    char cursor[4]={'/','-','\\','|'};
+    auto ret = cursor[spin_value_];
+    spin_value_ = (spin_value_ + 1) % 4;
+    return ret;
+}
+
+QString CommandLineClientView::get_task_string(QString const & displayName, QString const & status, double percentage, keeper::Error error)
+{
+
+    if (error == keeper::Error::OK)
+        return QStringLiteral("%1    %2 %    %3").arg(displayName, 15).arg((percentage * 100), 10, 'f', 2, ' ').arg(status, -15);
+    else
+        return QStringLiteral("%1    %2 %    %3 %4").arg(displayName, 15).arg((percentage * 100), 10, 'f', 2, ' ').arg(status, -15).arg(get_error_string(error));
+}
+
+QString CommandLineClientView::get_error_string(keeper::Error error)
+{
+    QString ret;
+    switch(error)
+    {
+        case keeper::Error::UNKNOWN:
+            ret = QStringLiteral("Unknown error");
+            break;
+        case keeper::Error::HELPER_BAD_URL:
+            ret = QStringLiteral("Bad URL for keeper helper");
+            break;
+        case keeper::Error::HELPER_INACTIVITY_DETECTED:
+            ret = QStringLiteral("Inactivity detected in task");
+            break;
+        case keeper::Error::HELPER_START_TIMEOUT:
+            ret = QStringLiteral("Task failed to start");
+            break;
+        case keeper::Error::HELPER_READ:
+            ret = QStringLiteral("Read error");
+            break;
+        case keeper::Error::HELPER_SOCKET:
+            ret = QStringLiteral("Error creating internal socket");
+            break;
+        case keeper::Error::HELPER_WRITE:
+            ret = QStringLiteral("Write error");
+            break;
+        case keeper::Error::MANIFEST_STORAGE:
+            ret = QStringLiteral("Error storing manifest file");
+            break;
+        case keeper::Error::NO_HELPER_INFORMATION_IN_REGISTRY:
+            ret = QStringLiteral("No helper information in registry");
+            break;
+        case keeper::Error::OK:
+            ret = QStringLiteral("Success");
+            break;
+        case keeper::Error::COMMITTING_DATA:
+            ret = QStringLiteral("Error uploading data");
+            break;
+        case keeper::Error::CREATING_REMOTE_DIR:
+            ret = QStringLiteral("Error creating remote directory");
+            break;
+        case keeper::Error::CREATING_REMOTE_FILE:
+            ret = QStringLiteral("Error creating remote file");
+            break;
+        case keeper::Error::READING_REMOTE_FILE:
+            ret = QStringLiteral("Error reading remote file");
+            break;
+        case keeper::Error::REMOTE_DIR_NOT_EXISTS:
+            ret = QStringLiteral("Remote directory does not exist");
+            break;
+        case keeper::Error::NO_REMOTE_ACCOUNTS:
+            ret = QStringLiteral("No remote accounts were found");
+            break;
+        case keeper::Error::NO_REMOTE_ROOTS:
+            ret = QStringLiteral("No remote root accounts were found");
+            break;
+        case keeper::Error::ACCOUNT_NOT_FOUND:
+            ret = QStringLiteral("The storage account was not found");
+            break;
+    }
+    return ret;
+}
+
+void CommandLineClientView::on_task_state_changed(QString const & displayName, QString const & status, double percentage, keeper::Error error)
+{
+    auto iter = tasks_strings_.find(displayName);
+    if (iter != tasks_strings_.end())
+    {
+        tasks_strings_[displayName] = get_task_string(displayName, status, percentage, error);
+    }
+}

=== added file 'src/cli/command-line-client-view.h'
--- src/cli/command-line-client-view.h	1970-01-01 00:00:00 +0000
+++ src/cli/command-line-client-view.h	2017-02-27 19:05:17 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ */
+#pragma once
+
+#include <client/keeper-errors.h>
+
+#include <QMap>
+#include <QObject>
+#include <QTimer>
+
+class CommandLineClientView : public QObject
+{
+    Q_OBJECT
+public:
+    explicit CommandLineClientView(QObject * parent = nullptr);
+    ~CommandLineClientView() = default;
+
+    Q_DISABLE_COPY(CommandLineClientView)
+
+    void progress_changed(double percentage);
+    void status_changed(QString const & status);
+
+    void add_task(QString const & display_name, QString const & initial_status, double initial_percentage);
+    void clear_all_tasks();
+    void start_printing_tasks();
+    void clear_all();
+    void print_sections(QStringList const & sections);
+    void print_error_message(QString const & error_message);
+    QString get_error_string(keeper::Error error);
+
+public Q_SLOTS:
+    void show_info();
+    void on_task_state_changed(QString const & displayName, QString const & status, double percentage, keeper::Error error);
+
+private:
+    char get_next_spin_char();
+    QString get_task_string(QString const & displayName, QString const & status, double percentage, keeper::Error error);
+
+    QString status_;
+    QTimer timer_status_;
+    double percentage_ = 0.0;
+    int spin_value_ = 0;
+    QMap<QString, QString> tasks_strings_;
+};

=== added file 'src/cli/command-line-client.cpp'
--- src/cli/command-line-client.cpp	1970-01-01 00:00:00 +0000
+++ src/cli/command-line-client.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ */
+#include "command-line-client.h"
+#include "command-line-client-view.h"
+
+#include <client/client.h>
+
+#include <QCoreApplication>
+#include <QDebug>
+
+#include <iostream>
+#include <iomanip>
+
+CommandLineClient::CommandLineClient(QObject * parent)
+    : QObject(parent)
+    , keeper_client_(new KeeperClient(this))
+    , view_(new CommandLineClientView(this))
+{
+    connect(keeper_client_.data(), &KeeperClient::statusChanged, this, &CommandLineClient::on_status_changed);
+    connect(keeper_client_.data(), &KeeperClient::progressChanged, this, &CommandLineClient::on_progress_changed);
+    connect(keeper_client_.data(), &KeeperClient::finished, this, &CommandLineClient::on_keeper_client_finished);
+    connect(keeper_client_.data(), &KeeperClient::taskStatusChanged, view_.data(), &CommandLineClientView::on_task_state_changed);
+}
+
+CommandLineClient::~CommandLineClient() = default;
+
+void CommandLineClient::run_list_sections(bool remote, QString const & storage)
+{
+    keeper::Items choices_values;
+    keeper::Error error;
+    if(!remote)
+    {
+        choices_values = keeper_client_->getBackupChoices(error);
+        check_for_choices_error(error);
+        list_backup_sections(choices_values);
+    }
+    else
+    {
+        choices_values = keeper_client_->getRestoreChoices(storage, error);
+        check_for_choices_error(error);
+        list_restore_sections(choices_values);
+    }
+}
+
+void CommandLineClient::run_list_storage_accounts()
+{
+    list_storage_accounts(keeper_client_->getStorageAccounts());
+}
+
+void CommandLineClient::run_backup(QStringList & sections, QString const & storage)
+{
+    auto unhandled_sections = sections;
+    keeper::Error error;
+    auto choices_values = keeper_client_->getBackupChoices(error);
+    check_for_choices_error(error);
+    QStringList uuids;
+
+    auto uuids_choices = choices_values.get_uuids();
+    for(auto iter = uuids_choices.begin(); iter != uuids_choices.end() && unhandled_sections.size(); ++iter)
+    {
+        const auto& values = choices_values[(*iter)];
+
+        if (values.is_valid() && values.get_type() == keeper::Item::FOLDER_VALUE)
+        {
+
+            auto display_name = values.get_display_name();
+            auto index = unhandled_sections.indexOf(display_name);
+            if (index != -1)
+            {
+                // we have to backup this section
+                uuids << (*iter);
+                unhandled_sections.removeAt(index);
+                view_->add_task(display_name, "waiting", 0.0);
+            }
+        }
+    }
+
+    if (!unhandled_sections.isEmpty())
+    {
+        QString error_message("The following sections were not found: \n");
+        for (auto const & section : unhandled_sections)
+        {
+            error_message += QStringLiteral("\t %1 \n").arg(section);
+        }
+        view_->print_error_message(error_message);
+        exit(1);
+    }
+
+    for (auto const & uuid: uuids)
+    {
+        keeper_client_->enableBackup(uuid, true);
+    }
+    keeper_client_->startBackup(storage);
+    view_->start_printing_tasks();
+}
+
+void CommandLineClient::run_restore(QStringList & sections, QString const & storage)
+{
+    auto unhandled_sections = sections;
+    keeper::Error error;
+
+    auto choices_values = keeper_client_->getRestoreChoices(storage, error);
+    check_for_choices_error(error);
+    QStringList uuids;
+
+    auto uuids_choices = choices_values.get_uuids();
+    for(auto iter = uuids_choices.begin(); iter != uuids_choices.end(); ++iter)
+    {
+        const auto& values = choices_values[(*iter)];
+
+        if (values.is_valid() && values.get_type() == keeper::Item::FOLDER_VALUE)
+        {
+            auto display_name = values.get_display_name();
+            auto dir_name = values.get_dir_name();
+
+            auto section_name = QStringLiteral("%1:%2").arg(display_name).arg(dir_name);
+            auto index = unhandled_sections.indexOf(section_name);
+            if (index != -1)
+            {
+                // we have to restore this section
+                uuids << (*iter);
+                unhandled_sections.removeAt(index);
+                view_->add_task(display_name, "waiting", 0.0);
+            }
+        }
+    }
+    if (!unhandled_sections.isEmpty())
+    {
+        QString error_message("The following sections were not found: \n");
+        for (auto const & section : unhandled_sections)
+        {
+            error_message += QStringLiteral("\t %1 \n").arg(section);
+        }
+        view_->print_error_message(error_message);
+        exit(1);
+    }
+
+    for (auto const & uuid: uuids)
+    {
+        keeper_client_->enableRestore(uuid, true);
+    }
+    keeper_client_->startRestore(storage);
+    view_->start_printing_tasks();
+}
+
+void CommandLineClient::run_cancel() const
+{
+    keeper_client_->cancel();
+}
+
+void CommandLineClient::list_backup_sections(keeper::Items const & choices_values)
+{
+    QStringList sections;
+    for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
+    {
+        if ((*iter).is_valid() && (*iter).get_type() == keeper::Item::FOLDER_VALUE)
+        {
+            sections << (*iter).get_display_name();
+        }
+    }
+    view_->print_sections(sections);
+}
+
+void CommandLineClient::list_restore_sections(keeper::Items const & choices_values)
+{
+    QMap<QString, QList<keeper::Item>> values_per_dir;
+
+    for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
+    {
+        if ((*iter).is_valid() && (*iter).get_type() == keeper::Item::FOLDER_VALUE)
+        {
+            auto dir_name = (*iter).get_dir_name();
+            if (!dir_name.isEmpty())
+            {
+                values_per_dir[dir_name].push_back((*iter));
+            }
+        }
+    }
+
+    QStringList sections;
+    for(auto iter = values_per_dir.begin(); iter != values_per_dir.end(); ++iter)
+    {
+        for(auto iter_items = (*iter).begin(); iter_items != (*iter).end(); ++iter_items)
+        {
+            const auto& values = (*iter_items);
+            sections << QStringLiteral("%1:%2").arg(values.get_display_name()).arg(iter.key());
+        }
+        sections << "";
+    }
+    view_->print_sections(sections);
+}
+
+void CommandLineClient::list_storage_accounts(QStringList const & accounts)
+{
+    view_->print_sections(accounts);
+}
+
+void CommandLineClient::on_progress_changed()
+{
+    view_->progress_changed(keeper_client_->progress());
+}
+
+void CommandLineClient::on_status_changed()
+{
+    view_->status_changed(keeper_client_->status());
+}
+
+void CommandLineClient::on_keeper_client_finished()
+{
+    QCoreApplication::processEvents();
+    view_->show_info();
+    view_->clear_all();
+    QCoreApplication::exit(0);
+}
+
+bool CommandLineClient::find_choice_value(QVariantMap const & choice, QString const & id, QVariant & value)
+{
+    auto iter = choice.find(id);
+    if (iter == choice.end())
+        return false;
+    value = (*iter);
+    return true;
+}
+
+void CommandLineClient::check_for_choices_error(keeper::Error error)
+{
+    if (error != keeper::Error::OK)
+    {
+        // an error occurred
+        auto error_message = QStringLiteral("Error obtaining keeper choices: %1").arg(view_->get_error_string(error));
+        view_->print_error_message(error_message);
+        return;
+    }
+}

=== added file 'src/cli/command-line-client.h'
--- src/cli/command-line-client.h	1970-01-01 00:00:00 +0000
+++ src/cli/command-line-client.h	2017-02-27 19:05:17 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ */
+#pragma once
+
+#include <QMap>
+#include <QObject>
+#include <QScopedPointer>
+#include <QTimer>
+#include "../../include/client/keeper-items.h"
+
+class KeeperClient;
+class CommandLineClientView;
+
+class CommandLineClient : public QObject
+{
+    Q_OBJECT
+public:
+    explicit CommandLineClient(QObject * parent = nullptr);
+    ~CommandLineClient();
+
+    Q_DISABLE_COPY(CommandLineClient)
+
+    void run_list_sections(bool remote, QString const & storage = "");
+    void run_list_storage_accounts();
+    void run_backup(QStringList & sections, QString const & storage);
+    void run_restore(QStringList & sections, QString const & storage);
+    void run_cancel() const;
+
+private Q_SLOTS:
+    void on_progress_changed();
+    void on_status_changed();
+    void on_keeper_client_finished();
+
+private:
+    bool find_choice_value(QVariantMap const & choice, QString const & id, QVariant & value);
+    void list_backup_sections(keeper::Items const & choices);
+    void list_restore_sections(keeper::Items const & choices);
+    void list_storage_accounts(QStringList const & accounts);
+    void check_for_choices_error(keeper::Error error);
+    QScopedPointer<KeeperClient> keeper_client_;
+    QScopedPointer<CommandLineClientView> view_;
+};

=== added file 'src/cli/command-line.cpp'
--- src/cli/command-line.cpp	1970-01-01 00:00:00 +0000
+++ src/cli/command-line.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ */
+#include "command-line.h"
+
+#include <QCommandLineParser>
+#include <QDebug>
+
+#include <iostream>
+
+namespace
+{
+    // arguments
+    constexpr const char ARGUMENT_LIST_SECTIONS[]         = "list-sections";
+    constexpr const char ARGUMENT_LIST_STORAGE_ACCOUNTS[] = "list-storage-configs";
+    constexpr const char ARGUMENT_BACKUP[]                = "backup";
+    constexpr const char ARGUMENT_RESTORE[]               = "restore";
+
+    // argument descriptions
+    constexpr const char ARGUMENT_LIST_SECTIONS_DESCRIPTION[]         = "List the sections available to backup";
+    constexpr const char ARGUMENT_LIST_STORAGE_ACCOUNTS_DESCRIPTION[] = "List the available storage accounts";
+    constexpr const char ARGUMENT_BACKUP_DESCRIPTION[]                = "Starts a backup";
+    constexpr const char ARGUMENT_RESTORE_DESCRIPTION[]               = "Starts a restore";
+
+    // options
+    constexpr const char OPTION_STORAGE[]          = "storage";
+    constexpr const char OPTION_SECTIONS[]         = "sections";
+
+    // option descriptions
+    constexpr const char OPTION_STORAGE_DESCRIPTION[]          = "Defines the available storage to use. Pass 'default' to use the default one";
+    constexpr const char OPTION_SECTIONS_DESCRIPTION[]         = "Lists the sections to backup or restore";
+}
+
+CommandLineParser::CommandLineParser()
+    : parser_(new QCommandLineParser)
+{
+    parser_->setApplicationDescription("Keeper command line client");
+    parser_->addHelpOption();
+    parser_->addVersionOption();
+    parser_->addPositionalArgument(ARGUMENT_LIST_SECTIONS, QCoreApplication::translate("main", ARGUMENT_LIST_SECTIONS_DESCRIPTION));
+    parser_->addPositionalArgument(ARGUMENT_LIST_STORAGE_ACCOUNTS, QCoreApplication::translate("main", ARGUMENT_LIST_STORAGE_ACCOUNTS_DESCRIPTION));
+    parser_->addPositionalArgument(ARGUMENT_BACKUP, QCoreApplication::translate("main", ARGUMENT_BACKUP_DESCRIPTION));
+    parser_->addPositionalArgument(ARGUMENT_RESTORE, QCoreApplication::translate("main", ARGUMENT_RESTORE_DESCRIPTION));
+}
+
+bool CommandLineParser::parse(QStringList const & arguments, QCoreApplication const & app, CommandLineParser::CommandArgs & cmd_args)
+{
+    parser_->parse(arguments);
+    const QStringList args = parser_->positionalArguments();
+    if (!check_number_of_args(args))
+    {
+        return false;
+    }
+
+    if (args.size() == 1)
+    {
+        // if something fails at the process call the process exists
+        if (args.at(0) == ARGUMENT_LIST_SECTIONS)
+        {
+            return handle_list_sections(app, cmd_args);
+        }
+        else if (args.at(0) == ARGUMENT_LIST_STORAGE_ACCOUNTS)
+        {
+            return handle_list_storage_accounts(app, cmd_args);
+        }
+        else if (args.at(0) == ARGUMENT_BACKUP)
+        {
+            return handle_backup(app, cmd_args);
+        }
+        else if (args.at(0) == ARGUMENT_RESTORE)
+        {
+            return handle_restore(app, cmd_args);
+        }
+        else
+        {
+            std::cerr << "Bad argument." << std::endl;
+            std::cerr << parser_->errorText().toStdString() << std::endl;
+            exit(1);
+        }
+    }
+    else
+    {
+        qDebug() << "More or none arguments";
+        // maybe we have the version or help options
+        parser_->process(app);
+    }
+
+    return false;
+}
+
+bool CommandLineParser::handle_list_sections(QCoreApplication const & app, CommandLineParser::CommandArgs & cmd_args)
+{
+    parser_->clearPositionalArguments();
+    parser_->addPositionalArgument(ARGUMENT_LIST_SECTIONS, QCoreApplication::translate("main", ARGUMENT_LIST_SECTIONS_DESCRIPTION));
+
+    parser_->addOptions({
+            {{"r", OPTION_STORAGE},
+                QCoreApplication::translate("main", OPTION_STORAGE_DESCRIPTION),
+                QCoreApplication::translate("main", OPTION_STORAGE_DESCRIPTION)
+            },
+        });
+    parser_->process(app);
+
+    // it didn't exit... we're good
+    cmd_args.sections.clear();
+    cmd_args.storage.clear();
+    if (parser_->isSet(OPTION_STORAGE))
+    {
+        cmd_args.cmd = CommandLineParser::Command::LIST_REMOTE_SECTIONS;
+        cmd_args.storage = get_storage_string(parser_->value(OPTION_STORAGE));
+    }
+    else
+    {
+        cmd_args.cmd = CommandLineParser::Command::LIST_LOCAL_SECTIONS;
+    }
+
+    return true;
+}
+
+bool CommandLineParser::handle_list_storage_accounts(QCoreApplication const & app, CommandArgs & cmd_args)
+{
+    parser_->process(app);
+    // it didn't exit... we're good
+    cmd_args.sections.clear();
+    cmd_args.storage.clear();
+    cmd_args.cmd = CommandLineParser::Command::LIST_STORAGE_ACCOUNTS;
+
+    return true;
+}
+
+bool CommandLineParser::handle_backup(QCoreApplication const & app, CommandLineParser::CommandArgs & cmd_args)
+{
+    parser_->clearPositionalArguments();
+    parser_->addPositionalArgument(ARGUMENT_BACKUP, QCoreApplication::translate("main", ARGUMENT_BACKUP_DESCRIPTION));
+
+    parser_->addOptions({
+            {{"s", OPTION_SECTIONS},
+                QCoreApplication::translate("main", OPTION_SECTIONS_DESCRIPTION),
+                QCoreApplication::translate("main", OPTION_SECTIONS_DESCRIPTION)
+            },
+            {{"r", OPTION_STORAGE},
+                QCoreApplication::translate("main", OPTION_STORAGE_DESCRIPTION),
+                QCoreApplication::translate("main", OPTION_STORAGE_DESCRIPTION)
+            },
+        });
+    parser_->process(app);
+
+    // it didn't exit... we're good
+    cmd_args.sections.clear();
+    cmd_args.storage.clear();
+    cmd_args.cmd = CommandLineParser::Command::BACKUP;
+    if (!parser_->isSet(OPTION_SECTIONS))
+    {
+        std::cerr << "You need to specify some sections to run a backup." << std::endl;
+        return false;
+    }
+    if (parser_->isSet(OPTION_STORAGE))
+    {
+        cmd_args.storage = get_storage_string(parser_->value(OPTION_STORAGE));
+    }
+    cmd_args.sections = parser_->value(OPTION_SECTIONS).split(',');
+
+    return true;
+}
+
+bool CommandLineParser::handle_restore(QCoreApplication const & app, CommandLineParser::CommandArgs & cmd_args)
+{
+    parser_->clearPositionalArguments();
+    parser_->addPositionalArgument(ARGUMENT_RESTORE, QCoreApplication::translate("main", ARGUMENT_RESTORE_DESCRIPTION));
+
+    parser_->addOptions({
+            {{"s", OPTION_SECTIONS},
+                QCoreApplication::translate("main", OPTION_SECTIONS_DESCRIPTION),
+                QCoreApplication::translate("main", OPTION_SECTIONS_DESCRIPTION)
+            },
+            {{"r", OPTION_STORAGE},
+                QCoreApplication::translate("main", OPTION_STORAGE_DESCRIPTION),
+                QCoreApplication::translate("main", OPTION_STORAGE_DESCRIPTION)
+            },
+        });
+    parser_->process(app);
+
+    // it didn't exit... we're good
+    cmd_args.sections.clear();
+    cmd_args.storage.clear();
+    cmd_args.cmd = CommandLineParser::Command::RESTORE;
+    if (!parser_->isSet(OPTION_SECTIONS))
+    {
+        std::cerr << "You need to specify some sections to run a restore." << std::endl;
+        return false;
+    }
+    if (parser_->isSet(OPTION_STORAGE))
+    {
+        cmd_args.storage = get_storage_string(parser_->value(OPTION_STORAGE));
+    }
+    cmd_args.sections = parser_->value(OPTION_SECTIONS).split(',');
+
+    return true;
+}
+
+bool CommandLineParser::check_number_of_args(QStringList const & args)
+{
+    if (args.size() > 1)
+    {
+        std::cerr << "Please, pass only one argument." << std::endl;
+        std::cerr << parser_->helpText().toStdString() << std::endl;
+        return false;
+    }
+    return true;
+}
+
+QString CommandLineParser::get_storage_string(QString const & value)
+{
+    if (value == "default")
+    {
+        return QString();
+    }
+    return value;
+}

=== added file 'src/cli/command-line.h'
--- src/cli/command-line.h	1970-01-01 00:00:00 +0000
+++ src/cli/command-line.h	2017-02-27 19:05:17 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ */
+#pragma once
+
+#include <QCoreApplication>
+#include <QSharedPointer>
+
+class QCommandLineParser;
+
+class CommandLineParser
+{
+public:
+    Q_ENUMS(Command)
+    enum class Command {LIST_LOCAL_SECTIONS, LIST_REMOTE_SECTIONS, LIST_STORAGE_ACCOUNTS, BACKUP, RESTORE};
+    struct CommandArgs
+    {
+        Command cmd;
+        QStringList sections;
+        QString storage;
+    };
+
+    CommandLineParser();
+    ~CommandLineParser() = default;
+    Q_DISABLE_COPY(CommandLineParser)
+
+    bool parse(QStringList const & arguments, QCoreApplication const & app, CommandArgs & cmd_args);
+
+private:
+    bool handle_list_sections(QCoreApplication const & app, CommandArgs & cmd_args);
+    bool handle_list_storage_accounts(QCoreApplication const & app, CommandArgs & cmd_args);
+    bool handle_backup(QCoreApplication const & app, CommandArgs & cmd_args);
+    bool handle_restore(QCoreApplication const & app, CommandArgs & cmd_args);
+
+    bool check_number_of_args(QStringList const & args);
+
+    QString get_storage_string(QString const & value);
+
+    QSharedPointer<QCommandLineParser> parser_;
+};

=== modified file 'src/cli/main.cpp'
--- src/cli/main.cpp	2016-08-30 14:16:19 +0000
+++ src/cli/main.cpp	2017-02-27 19:05:17 +0000
@@ -17,9 +17,12 @@
  *     Charles Kerr <[e-mail]>
  *     Xavi Garcia <[e-mail]>
  */
+#include "command-line.h"
+#include "command-line-client.h"
 
 #include <dbus-types.h>
 #include <util/logging.h>
+#include "util/unix-signal-handler.h"
 
 #include <keeper_user_interface.h>
 
@@ -29,6 +32,8 @@
 #include <libintl.h>
 #include <cstdlib>
 #include <ctime>
+#include <iostream>
+
 
 int
 main(int argc, char **argv)
@@ -37,60 +42,49 @@
 
     QCoreApplication app(argc, argv);
     DBusTypes::registerMetaTypes();
-//    Variant::registerMetaTypes();
     std::srand(unsigned(std::time(nullptr)));
 
+    util::UnixSignalHandler handler([]{
+        CommandLineClient client;
+        client.run_cancel();
+    });
+    handler.setupUnixSignalHandlers();
+
     // boilerplate locale
     bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
     setlocale(LC_ALL, "");
     bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
     textdomain(GETTEXT_PACKAGE);
 
-    if (argc == 2 && QString("--print-address") == argv[1])
-    {
-        qDebug() << QDBusConnection::sessionBus().baseService();
-    }
-
-    qDebug() << "Argc =" << argc;
-    if (argc == 2 && QString("--use-uuids") == argv[1])
-    {
-        QScopedPointer<DBusInterfaceKeeperUser> user_iface(new DBusInterfaceKeeperUser(
-                                                                DBusTypes::KEEPER_SERVICE,
-                                                                DBusTypes::KEEPER_USER_PATH,
-                                                                QDBusConnection::sessionBus()
-                                                            ) );
-        QDBusReply<QVariantDictMap> choices = user_iface->call("GetBackupChoices");
-        if (!choices.isValid())
-        {
-            qWarning() << "Error getting backup choices:" << choices.error().message();
-        }
-
-        QStringList uuids;
-        auto choices_values = choices.value();
-        for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
-        {
-            const auto& values = iter.value();
-            auto iter_values = values.find("type");
-            if (iter_values != values.end())
-            {
-                if (iter_values.value().toString() == "folder")
-                {
-                    qDebug() << "Adding uuid" << iter.key() << "with type:" << "folder";
-                    uuids << iter.key();
-                }
-            }
-        }
-
-        QDBusReply<void> backup_reply = user_iface->call("StartBackup", uuids);
-
-        if (!backup_reply.isValid())
-        {
-            qWarning() << "Error starting backup:" << backup_reply.error().message();
-        }
-    }
-    else
-    {
-        qWarning() << "FIXME";
+    QCoreApplication::setApplicationName("keeper");
+    QCoreApplication::setApplicationVersion("1.0");
+
+    CommandLineParser parser;
+    CommandLineClient client;
+    CommandLineParser::CommandArgs cmd_args;
+    if (parser.parse(QCoreApplication::arguments(), app, cmd_args))
+    {
+        switch(cmd_args.cmd)
+        {
+            case CommandLineParser::Command::LIST_LOCAL_SECTIONS:
+                client.run_list_sections(false);
+                exit(0);
+                break;
+            case CommandLineParser::Command::LIST_STORAGE_ACCOUNTS:
+                client.run_list_storage_accounts();
+                exit(0);
+                break;
+            case CommandLineParser::Command::LIST_REMOTE_SECTIONS:
+                client.run_list_sections(true, cmd_args.storage);
+                exit(0);
+                break;
+            case CommandLineParser::Command::BACKUP:
+                client.run_backup(cmd_args.sections, cmd_args.storage);
+                break;
+            case CommandLineParser::Command::RESTORE:
+                client.run_restore(cmd_args.sections, cmd_args.storage);
+                break;
+        };
     }
 
 

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2016-08-26 09:30:11 +0000
+++ src/client/CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -1,8 +1,24 @@
 add_subdirectory(qml-plugin)
 
 set(
+  KEEPER_ERRORS_LIB
+  keeper-errors-lib
+)
+
+add_library(
+  ${KEEPER_ERRORS_LIB}
+  STATIC
+  keeper-errors.cpp
+  ${CMAKE_SOURCE_DIR}/include/client/keeper-errors.h
+  ${CMAKE_SOURCE_DIR}/include/client/keeper-items.h
+  items.cpp
+)
+
+set(
   CLIENT_HEADERS
   ${CMAKE_SOURCE_DIR}/include/client/client.h
+  ${CMAKE_SOURCE_DIR}/include/client/keeper-errors.h
+  ${CMAKE_SOURCE_DIR}/include/client/keeper-items.h
 )
 
 add_library(
@@ -11,8 +27,14 @@
   ${CLIENT_HEADERS}
 )
 
+set_target_properties(${KEEPER_CLIENT_LIB} PROPERTIES
+  AUTOMOC TRUE
+  LINK_FLAGS "-Wl,--no-undefined"
+)
+
 target_link_libraries(
   ${KEEPER_CLIENT_LIB}
+  ${KEEPER_ERRORS_LIB}
   qdbus-stubs
   Qt5::Core
   Qt5::DBus

=== modified file 'src/client/client.cpp'
--- src/client/client.cpp	2016-08-26 08:48:05 +0000
+++ src/client/client.cpp	2017-02-27 19:05:17 +0000
@@ -22,34 +22,100 @@
 #include <client/client.h>
 
 #include <qdbus-stubs/keeper_user_interface.h>
+#include <qdbus-stubs/DBusPropertiesInterface.h>
+#include <qdbus-stubs/dbus-types.h>
 
 struct KeeperClientPrivate final
 {
     Q_DISABLE_COPY(KeeperClientPrivate)
 
-    KeeperClientPrivate(QObject* parent)
+    enum class TasksMode { IDLE_MODE, BACKUP_MODE, RESTORE_MODE };
+
+    explicit KeeperClientPrivate(QObject* /* parent */)
         : userIface(new DBusInterfaceKeeperUser(
                           DBusTypes::KEEPER_SERVICE,
                           DBusTypes::KEEPER_USER_PATH,
                           QDBusConnection::sessionBus()
-                          )),
-        status(""),
-        progress(0),
-        readyToBackup(false),
-        backupBusy(false),
-        stateTimer(parent)
+                          ))
+        , propertiesIface(new DBusPropertiesInterface(
+                           DBusTypes::KEEPER_SERVICE,
+                           DBusTypes::KEEPER_USER_PATH,
+                           QDBusConnection::sessionBus()
+                         ))
     {
     }
 
     ~KeeperClientPrivate() = default;
 
+    struct TaskStatus
+    {
+        QString status;
+        double percentage;
+    };
+
+    static bool stateIsFinal(QString const & stateString)
+    {
+        return (stateString == "complete" || stateString == "cancelled" || stateString == "failed");
+    }
+
+    bool checkAllTasksFinished(keeper::Items const & state) const
+    {
+        bool ret = true;
+        for (auto iter = state.begin(); ret && (iter != state.end()); ++iter)
+        {
+            auto statusString = (*iter).get_status();
+            ret = stateIsFinal(statusString);
+        }
+        return ret;
+    }
+
+    static keeper::Items getValue(QDBusMessage const & message, keeper::Error & error)
+    {
+        if (message.errorMessage().isEmpty())
+        {
+            if (message.arguments().count() != 1)
+            {
+                error = keeper::Error::UNKNOWN;
+                return keeper::Items();
+            }
+
+            auto value = message.arguments().at(0);
+            if (value.typeName() != QStringLiteral("QDBusArgument"))
+            {
+                error = keeper::Error::UNKNOWN;
+                return keeper::Items();
+            }
+            auto dbus_arg = value.value<QDBusArgument>();
+            error = keeper::Error::OK;
+            keeper::Items ret;
+            dbus_arg >> ret;
+            return ret;
+        }
+        if (message.arguments().count() != 2)
+        {
+            error = keeper::Error::UNKNOWN;
+            return keeper::Items();
+        }
+
+        // pick up the error
+        bool valid;
+        error = keeper::convert_from_dbus_variant(message.arguments().at(1), &valid);
+        if (!valid)
+        {
+            error = keeper::Error::UNKNOWN;
+        }
+        return keeper::Items();
+    }
+
     QScopedPointer<DBusInterfaceKeeperUser> userIface;
+    QScopedPointer<DBusPropertiesInterface> propertiesIface;
     QString status;
-    QMap<QString, QVariantMap> backups;
-    double progress;
-    bool readyToBackup;
-    bool backupBusy;
-    QTimer stateTimer;
+    keeper::Items backups;
+    double progress = 0;
+    bool readyToBackup = false;
+    bool backupBusy = false;
+    QMap<QString, TaskStatus> taskStatus;
+    TasksMode mode = TasksMode::IDLE_MODE;
 };
 
 KeeperClient::KeeperClient(QObject* parent) :
@@ -60,13 +126,15 @@
 
     // Store backups list locally with an additional "enabled" pair to keep track enabled states
     // TODO: We should be listening to a backupChoicesChanged signal to keep this list updated
-    d->backups = getBackupChoices();
+    keeper::Error error;
+    d->backups = getBackupChoices(error);
+
     for(auto iter = d->backups.begin(); iter != d->backups.end(); ++iter)
     {
         iter.value()["enabled"] = false;
     }
 
-    connect(&d->stateTimer, &QTimer::timeout, this, &KeeperClient::stateUpdated);
+    connect(d->propertiesIface.data(), &DBusPropertiesInterface::PropertiesChanged, this, &KeeperClient::stateUpdated);
 }
 
 KeeperClient::~KeeperClient() = default;
@@ -77,7 +145,7 @@
     for(auto iter = d->backups.begin(); iter != d->backups.end(); ++iter)
     {
         // TODO: We currently only support "folder" type backups
-        if (iter.value().value("type").toString() == "folder")
+        if (iter.value().get_type() == keeper::Item::FOLDER_VALUE)
         {
             returnList.append(iter.key());
         }
@@ -120,17 +188,19 @@
         }
     }
 
+    d->taskStatus[uuid] = KeeperClientPrivate::TaskStatus{"", 0.0};
+
     Q_EMIT readyToBackupChanged();
 }
 
-void KeeperClient::startBackup()
+void KeeperClient::enableRestore(QString uuid, bool enabled)
 {
-    // TODO: Instead of polling for state, we should be listening to a stateChanged signal
-    if (!d->stateTimer.isActive())
-    {
-        d->stateTimer.start(200);
-    }
+    // Until we re-design the client we treat restores as backups
+    enableBackup(uuid, enabled);
+}
 
+void KeeperClient::startBackup(QString const & storage)
+{
     // Determine which backups are enabled, and start only those
     QStringList backupList;
     for(auto iter = d->backups.begin(); iter != d->backups.end(); ++iter)
@@ -143,8 +213,9 @@
 
     if (!backupList.empty())
     {
-        startBackup(backupList);
+        startBackup(backupList, storage);
 
+        d->mode = KeeperClientPrivate::TasksMode::BACKUP_MODE;
         d->status = "Preparing Backup...";
         Q_EMIT statusChanged();
         d->backupBusy = true;
@@ -152,27 +223,60 @@
     }
 }
 
+void KeeperClient::startRestore(QString const & storage)
+{
+    // Determine which restores are enabled, and start only those
+    QStringList restoreList;
+    for(auto iter = d->backups.begin(); iter != d->backups.end(); ++iter)
+    {
+        if (iter.value().value("enabled").toBool())
+        {
+            restoreList.append(iter.key());
+        }
+    }
+
+    if (!restoreList.empty())
+    {
+        startRestore(restoreList, storage);
+
+        d->mode = KeeperClientPrivate::TasksMode::RESTORE_MODE;
+        d->status = "Preparing Restore...";
+        Q_EMIT statusChanged();
+        d->backupBusy = true;
+        Q_EMIT backupBusyChanged();
+    }
+}
+
+void KeeperClient::cancel()
+{
+    QDBusReply<void> cancelReply = d->userIface->call("Cancel");
+
+    if (!cancelReply.isValid())
+    {
+        qWarning() << "Error canceling" << cancelReply.error().message();
+    }
+}
+
 QString KeeperClient::getBackupName(QString uuid)
 {
-    return d->backups.value(uuid).value("display-name").toString();
-}
-
-QMap<QString, QVariantMap> KeeperClient::getBackupChoices() const
-{
-    QDBusReply<QMap<QString, QVariantMap>> choices = d->userIface->call("GetBackupChoices");
-
-    if (!choices.isValid())
-    {
-        qWarning() << "Error getting backup choices:" << choices.error().message();
-        return QMap<QString, QVariantMap>();
-    }
-
-    return choices.value();
-}
-
-void KeeperClient::startBackup(const QStringList& uuids) const
-{
-    QDBusReply<void> backupReply = d->userIface->call("StartBackup", uuids);
+    return d->backups.value(uuid).get_display_name();
+}
+
+keeper::Items KeeperClient::getBackupChoices(keeper::Error & error) const
+{
+    QDBusMessage choices = d->userIface->call("GetBackupChoices");
+    return KeeperClientPrivate::getValue(choices, error);
+}
+
+keeper::Items KeeperClient::getRestoreChoices(QString const & storage, keeper::Error & error) const
+{
+    QDBusMessage choices = d->userIface->call("GetRestoreChoices", storage);
+    return KeeperClientPrivate::getValue(choices, error);
+}
+
+void KeeperClient::startBackup(const QStringList& uuids, QString const & storage) const
+{
+    QDBusReply<void> backupReply = d->userIface->call("StartBackup", uuids, storage);
 
     if (!backupReply.isValid())
     {
@@ -180,51 +284,110 @@
     }
 }
 
-QMap<QString, QVariantMap> KeeperClient::getState() const
+void KeeperClient::startRestore(const QStringList& uuids, QString const & storage) const
+{
+    QDBusReply<void> backupReply = d->userIface->call("StartRestore", uuids, storage);
+
+    if (!backupReply.isValid())
+    {
+        qWarning() << "Error starting restore:" << backupReply.error().message();
+    }
+}
+
+keeper::Items KeeperClient::getState() const
 {
     return d->userIface->state();
 }
 
+QStringList KeeperClient::getStorageAccounts() const
+{
+     QDBusPendingReply<QStringList> accountsReply = d->userIface->call("GetStorageAccounts");
+
+     accountsReply.waitForFinished();
+     if (!accountsReply.isValid())
+     {
+         qWarning() << "Error retrieving storage accounts:" << accountsReply.error().message();
+     }
+
+     return accountsReply.value();
+}
+
 void KeeperClient::stateUpdated()
 {
     auto states = getState();
 
     if (!states.empty())
     {
-        // Calculate current total progress
-        // TODO: May be better to monitor each backup's progress separately instead of total
-        //       to avoid irregular jumps in progress between larger and smaller backups
+        for (auto const & uuid : d->taskStatus.keys())
+        {
+            auto iter_state = states.find(uuid);
+            if (iter_state == states.end())
+            {
+                qWarning() << "State for uuid: " << uuid << " was not found";
+            }
+            keeper::Item keeper_item((*iter_state));
+            auto progress = keeper_item.get_percent_done();
+            auto status = keeper_item.get_status();
+            auto keeper_error = keeper_item.get_error();
+
+            auto current_state = d->taskStatus[uuid];
+            if (current_state.status != status || current_state.percentage < progress)
+            {
+                d->taskStatus[uuid].status = status;
+                d->taskStatus[uuid].percentage = progress;
+                Q_EMIT(taskStatusChanged(keeper_item.get_display_name(), status, progress, keeper_error));
+            }
+        }
+
         double totalProgress = 0;
         for (auto const& state : states)
         {
-            totalProgress += state.value("percent-done").toDouble();
+            keeper::Item keeper_item(state);
+            totalProgress += keeper_item.get_percent_done();
         }
 
         d->progress = totalProgress / states.count();
         Q_EMIT progressChanged();
 
+        auto allTasksFinished = d->checkAllTasksFinished(states);
         // Update backup status
+        QString statusString;
+        if (d->mode == KeeperClientPrivate::TasksMode::BACKUP_MODE)
+        {
+            statusString = QStringLiteral("Backup");
+        }
+        else if (d->mode == KeeperClientPrivate::TasksMode::RESTORE_MODE)
+        {
+            statusString = QStringLiteral("Restore");
+        }
         if (d->progress > 0 && d->progress < 1)
         {
-            d->status = "Backup In Progress...";
-            Q_EMIT statusChanged();
-
-            d->backupBusy = true;
-            Q_EMIT backupBusyChanged();
-        }
-        else if (d->progress >= 1)
-        {
-            d->status = "Backup Complete";
+            d->status = statusString + QStringLiteral(" In Progress...");
+            Q_EMIT statusChanged();
+
+            d->backupBusy = true;
+            Q_EMIT backupBusyChanged();
+        }
+        else if (d->progress >= 1 && !allTasksFinished)
+        {
+            d->status = statusString + QStringLiteral(" Finishing...");
+            Q_EMIT statusChanged();
+
+            d->backupBusy = true;
+            Q_EMIT backupBusyChanged();
+        }
+        else if (allTasksFinished)
+        {
+            d->status = statusString + QStringLiteral(" Complete");
             Q_EMIT statusChanged();
 
             d->backupBusy = false;
             Q_EMIT backupBusyChanged();
+        }
 
-            // Stop state timer
-            if (d->stateTimer.isActive())
-            {
-                d->stateTimer.stop();
-            }
+        if (d->checkAllTasksFinished(states))
+        {
+            Q_EMIT(finished());
         }
     }
 }

=== added file 'src/client/items.cpp'
--- src/client/items.cpp	1970-01-01 00:00:00 +0000
+++ src/client/items.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia Mena <[e-mail]>
+ */
+
+#include "client/keeper-items.h"
+
+#include <QtDBus>
+#include <QVariantMap>
+
+namespace keeper
+{
+// json keys
+constexpr const char PROPERTIES_KEY[]   = "properties";
+
+// keys
+const QString Item::UUID_KEY = QStringLiteral("uuid");
+const QString Item::TYPE_KEY = QStringLiteral("type");
+const QString Item::SUBTYPE_KEY = QStringLiteral("subtype");
+const QString Item::NAME_KEY = QStringLiteral("name");
+const QString Item::PACKAGE_KEY = QStringLiteral("package");
+const QString Item::TITLE_KEY = QStringLiteral("title");
+const QString Item::VERSION_KEY = QStringLiteral("version");
+const QString Item::FILE_NAME_KEY = QStringLiteral("file-name");
+const QString Item::DIR_NAME_KEY = QStringLiteral("dir-name");
+const QString Item::DISPLAY_NAME_KEY = QStringLiteral("display-name");
+const QString Item::STATUS_KEY = QStringLiteral("action");
+const QString Item::ERROR_KEY = QStringLiteral("error");
+const QString Item::PERCENT_DONE_KEY = QStringLiteral("percent-done");
+const QString Item::SPEED_KEY = QStringLiteral("speed");
+
+
+// values
+const QString Item::FOLDER_VALUE = QStringLiteral("folder");
+const QString Item::SYSTEM_DATA_VALUE = QStringLiteral("system-data");
+const QString Item::APPLICATION_VALUE = QStringLiteral("application");
+
+Item::Item() = default;
+
+Item::Item(QVariantMap const & values)
+    : QVariantMap(values)
+{
+}
+
+Item::~Item() = default;
+
+QVariant Item::get_property_value(QString const & property) const
+{
+    auto iter = this->find(property);
+    if (iter != this->end())
+    {
+        return (*iter);
+    }
+    else
+    {
+        return QVariant();
+    }
+}
+
+void Item::set_property_value(QString const& property, QVariant const& value)
+{
+    this->insert(property, value);
+}
+
+template<typename T> T Item::get_property(QString const & property, bool * valid) const
+{
+    auto it = this->find(property);
+
+    if (it == this->end())
+    {
+        if (valid != nullptr)
+            *valid = false;
+
+        return T{};
+    }
+
+    if (valid != nullptr)
+        *valid = true;
+
+    return it->value<T>();
+}
+
+bool Item::is_valid()const
+{
+    // check for required properties
+    for (auto& property : {TYPE_KEY, DISPLAY_NAME_KEY})
+        if (!this->has_property(property))
+            return false;
+
+    return true;
+}
+
+bool Item::has_property(QString const & property) const
+{
+    return this->contains(property);
+}
+
+QString Item::get_uuid(bool *valid) const
+{
+    return get_property<QString>(UUID_KEY, valid);
+}
+
+QString Item::get_type(bool *valid) const
+{
+    return get_property<QString>(TYPE_KEY, valid);
+}
+
+QString Item::get_display_name(bool *valid) const
+{
+    return get_property<QString>(DISPLAY_NAME_KEY, valid);
+}
+
+QString Item::get_dir_name(bool *valid) const
+{
+    return get_property<QString>(DIR_NAME_KEY, valid);
+}
+
+QString Item::get_status(bool *valid) const
+{
+    return get_property<QString>(STATUS_KEY, valid);
+}
+
+double Item::get_percent_done(bool *valid) const
+{
+    return get_property<double>(PERCENT_DONE_KEY, valid);
+}
+
+keeper::Error Item::get_error(bool *valid) const
+{
+    auto it = this->find(ERROR_KEY);
+
+    // if no error was sent, things must be OK
+    if (it == this->end())
+    {
+        return keeper::Error::OK;
+    }
+
+    return keeper::convert_from_dbus_variant(*it, valid);
+}
+
+QString Item::get_file_name(bool *valid) const
+{
+    return get_property<QString>(FILE_NAME_KEY, valid);
+}
+
+void Item::registerMetaType()
+{
+    qRegisterMetaType<Item>("Item");
+
+    qDBusRegisterMetaType<Item>();
+}
+
+/////
+// Items
+/////
+
+
+Items::Items() =default;
+
+Items::~Items() =default;
+
+
+Items::Items(Error error)
+    : error_{error}
+{
+}
+
+QStringList Items::get_uuids() const
+{
+    return this->keys();
+}
+
+void Items::registerMetaType()
+{
+    qRegisterMetaType<Items>("Items");
+
+    qDBusRegisterMetaType<Items>();
+
+    Item::registerMetaType();
+}
+
+} // namespace keeper

=== added file 'src/client/keeper-errors.cpp'
--- src/client/keeper-errors.cpp	1970-01-01 00:00:00 +0000
+++ src/client/keeper-errors.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ */
+
+#include <client/keeper-errors.h>
+
+#include <QDebug>
+
+QDBusArgument &operator<<(QDBusArgument &argument, keeper::Error value)
+{
+    argument.beginStructure();
+    argument << static_cast<int>(value);
+    argument.endStructure();
+    return argument;
+}
+
+const QDBusArgument &operator>>(const QDBusArgument &argument, keeper::Error &val)
+{
+    int int_val;
+    argument.beginStructure();
+    argument >> int_val;
+    val = static_cast<keeper::Error>(int_val);
+    argument.endStructure();
+    return argument;
+}
+
+namespace keeper
+{
+Error convert_from_dbus_variant(const QVariant & value, bool *conversion_ok)
+{
+    if (value.typeName() != QStringLiteral("QDBusArgument"))
+    {
+        qWarning() << Q_FUNC_INFO
+                   << " Error converting dbus QVariant to Error, expected type is [ QDBusArgument ] and current type is: ["
+                   << value.typeName() << "]";
+        if (conversion_ok)
+            *conversion_ok = false;
+        return Error(keeper::Error::UNKNOWN);
+    }
+    auto dbus_arg = value.value<QDBusArgument>();
+
+    if (dbus_arg.currentSignature() != "(i)")
+    {
+        qWarning() << Q_FUNC_INFO
+                   << " Error converting dbus QVariant to Error, expected signature is \"(i)\" and current signature is: \""
+                   << dbus_arg.currentSignature() << "\"";
+        if (conversion_ok)
+            *conversion_ok = false;
+        return Error(keeper::Error::UNKNOWN);
+    }
+    Error ret;
+    dbus_arg >> ret;
+
+    if (conversion_ok)
+        *conversion_ok = true;
+
+    return ret;
+}
+}

=== modified file 'src/client/qml-plugin/CMakeLists.txt'
--- src/client/qml-plugin/CMakeLists.txt	2016-08-26 09:30:11 +0000
+++ src/client/qml-plugin/CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -6,7 +6,7 @@
 add_definitions(-DKEEPER_MAJOR=${KEEPER_MAJOR})
 add_definitions(-DKEEPER_MINOR=${KEEPER_MINOR})
 
-include(QmlPlugins)
+find_package(QmlPlugins)
 
 find_package(Qt5Quick REQUIRED)
 

=== modified file 'src/helper/CMakeLists.txt'
--- src/helper/CMakeLists.txt	2016-09-06 01:31:59 +0000
+++ src/helper/CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -18,6 +18,21 @@
     ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}
 )
 
+set(
+  FOLDER_RESTORE
+  folder-restore.sh
+)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/${FOLDER_RESTORE}.in
+  ${CMAKE_CURRENT_BINARY_DIR}/${FOLDER_RESTORE}
+)
+
+install(
+  PROGRAMS
+    ${CMAKE_CURRENT_BINARY_DIR}/${FOLDER_RESTORE}
+  DESTINATION
+    ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}
+)
 
 #
 # the library
@@ -30,7 +45,7 @@
 
 include(FindPkgConfig)
 pkg_check_modules(BACKUP_HELPER_DEPENDENCIES REQUIRED
-  ubuntu-app-launch-2
+  ubuntu-app-launch-3
   properties-cpp
 )
 
@@ -48,10 +63,12 @@
   ${HELPER_LIB}
   STATIC
   backup-helper.cpp
+  restore-helper.cpp
   data-dir-registry.cpp
   helper.cpp
   metadata.cpp
   ${CMAKE_SOURCE_DIR}/include/helper/backup-helper.h
+  ${CMAKE_SOURCE_DIR}/include/helper/restore-helper.h
   ${CMAKE_SOURCE_DIR}/include/helper/data-dir-registry.h
   ${CMAKE_SOURCE_DIR}/include/helper/helper.h
   ${CMAKE_SOURCE_DIR}/include/helper/registry.h

=== modified file 'src/helper/backup-helper.cpp'
--- src/helper/backup-helper.cpp	2016-09-12 15:13:33 +0000
+++ src/helper/backup-helper.cpp	2017-02-27 19:05:17 +0000
@@ -62,8 +62,8 @@
         int rc = socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, fds);
         if (rc == -1)
         {
-            // TODO throw exception.
-            qWarning() << "BackupHelperPrivate: error creating socket pair to communicate with helper ";
+            qWarning() <<  QStringLiteral("Error creating socket to communicate with helper");;
+            Q_EMIT(q_ptr->error(keeper::Error::HELPER_SOCKET));
             return;
         }
 
@@ -139,9 +139,14 @@
                     &Uploader::commit_finished,
                     std::function<void(bool)>{[this](bool success){
                         qDebug() << "Commit finished";
-                        uploader_.reset();
                         if (!success)
+                        {
                             write_error_ = true;
+                            Q_EMIT(q_ptr->error(keeper::Error::COMMITTING_DATA));
+                        }
+                        else
+                            uploader_committed_file_name_ = uploader_->file_name();
+                        uploader_.reset();
                         check_for_done();
                     }}
                 );
@@ -162,12 +167,18 @@
         check_for_done();
     }
 
+    QString get_uploader_committed_file_name() const
+    {
+        return uploader_committed_file_name_;
+    }
+
 private:
 
     void on_inactivity_detected()
     {
         stop_inactivity_timer();
         qWarning() << "Inactivity detected in the helper...stopping it";
+        Q_EMIT(q_ptr->error(keeper::Error::HELPER_INACTIVITY_DETECTED));
         stop();
     }
 
@@ -180,7 +191,6 @@
     {
         n_uploaded_ += n;
         q_ptr->record_data_transferred(n);
-        qDebug("n_read %zu n_uploaded %zu (newly uploaded %zu)", size_t(n_read_), size_t(n_uploaded_), size_t(n));
         process_more();
         check_for_done();
     }
@@ -201,10 +211,10 @@
                 if (n > 0) {
                     n_read_ += n;
                     upload_buffer_.append(readbuf, int(n));
-                    qDebug("upload_buffer_.size() is %zu after reading %zu from helper", size_t(upload_buffer_.size()), size_t(n));
                 }
                 else if (n < 0) {
                     read_error_ = true;
+                    Q_EMIT(q_ptr->error(keeper::Error::HELPER_READ));
                     stop();
                     return;
                 }
@@ -214,13 +224,13 @@
             const auto n = socket->write(upload_buffer_);
             if (n > 0) {
                 upload_buffer_.remove(0, int(n));
-                qDebug("upload_buffer_.size() is %zu after writing %zu to cloud", size_t(upload_buffer_.size()), size_t(n));
                 continue;
             }
             else {
                 if (n < 0) {
                     write_error_ = true;
                     qWarning() << "Write error:" << socket->errorString();
+                    Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
                     stop();
                 }
                 break;
@@ -251,6 +261,10 @@
         {
             if (!q_ptr->is_helper_running())
             {
+                if (n_uploaded_ > q_ptr->expected_size())
+                {
+                    Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
+                }
                 q_ptr->set_state(Helper::State::FAILED);
             }
         }
@@ -289,6 +303,7 @@
     bool write_error_ = false;
     bool cancelled_ = false;
     ConnectionHelper connections_;
+    QString uploader_committed_file_name_;
 };
 
 /***
@@ -352,14 +367,21 @@
 {
     Q_D(BackupHelper);
 
-    qDebug() << Q_FUNC_INFO;
+    Helper::set_state(state);
     d->on_state_changed(state);
-    Helper::set_state(state);
 }
 
 void BackupHelper::on_helper_finished()
 {
     Q_D(BackupHelper);
+
     Helper::on_helper_finished();
     d->on_helper_finished();
 }
+
+QString BackupHelper::get_uploader_committed_file_name() const
+{
+    Q_D(const BackupHelper);
+
+    return d->get_uploader_committed_file_name();
+}

=== modified file 'src/helper/data-dir-registry.cpp'
--- src/helper/data-dir-registry.cpp	2016-08-10 02:29:17 +0000
+++ src/helper/data-dir-registry.cpp	2017-02-27 19:05:17 +0000
@@ -49,15 +49,27 @@
 
     QStringList get_backup_helper_urls(Metadata const& task)
     {
+        return get_helper_urls(task, "backup");
+    }
+
+    QStringList get_restore_helper_urls(Metadata const& task)
+    {
+        return get_helper_urls(task, "restore");
+    }
+
+private:
+
+    QStringList get_helper_urls(Metadata const& task, QString const & prop)
+    {
         QStringList ret;
 
-        QString type;
-        if (task.get_property(Metadata::TYPE_KEY, type))
+        auto type = task.get_type();
+        if (!type.isEmpty())
         {
-            auto it = registry_.find(std::make_pair(type,QStringLiteral("backup")));
+            auto it = registry_.find(std::make_pair(type,prop));
             if (it == registry_.end())
             {
-                qCritical() << "can't get backup helper urls for unhandled type" << type;
+                qCritical() << "can't get " << prop << " helper urls for unhandled type" << type;
             }
             else
             {
@@ -73,30 +85,28 @@
         return ret;
     }
 
-private:
-
     // replace "${key}" with task.get_property("key")
     QStringList perform_url_substitution(Metadata const& task, QStringList const& urls_in)
     {
         std::array<QString,6> keys = {
-            Metadata::TYPE_KEY,
-            Metadata::SUBTYPE_KEY,
-            Metadata::NAME_KEY,
-            Metadata::PACKAGE_KEY,
-            Metadata::TITLE_KEY,
-            Metadata::VERSION_KEY
+            keeper::Item::TYPE_KEY,
+            keeper::Item::SUBTYPE_KEY,
+            keeper::Item::NAME_KEY,
+            keeper::Item::PACKAGE_KEY,
+            keeper::Item::TITLE_KEY,
+            keeper::Item::VERSION_KEY
         };
 
         QStringList urls {urls_in};
 
         for (auto const& key : keys)
         {
-            QString after;
-            if (task.get_property(key, after))
+            QVariant after = task.get_property_value(key);
+            if (after.isValid())
             {
                 QString before = QStringLiteral("${%1}").arg(key);
                 for (auto& url : urls)
-                    url.replace(before, after);
+                    url.replace(before, after.toString());
             }
         }
 
@@ -139,6 +149,10 @@
              *         "backup-urls": [
              *             "/path/to/helper.sh",
              *             "${subtype}"
+             *         ],
+             *         "restore-urls": [
+             *             "/path/to/helper.sh",
+             *             "${subtype}"
              *         ]
              *     }
              * }
@@ -156,25 +170,37 @@
             if (error.error != QJsonParseError::NoError)
                 qCritical() << path << "parse error at offset" << error.offset << error.errorString();
 
-            auto obj = doc.object();
+            const auto obj = doc.object();
             for (auto tit=obj.begin(), tend=obj.end(); tit!=tend; ++tit)
             {
                 auto const type = tit.key();
-                auto& info = registry_[std::make_pair(type,QStringLiteral("backup"))];
-
                 auto const props = tit.value().toObject();
-                auto const urls_jsonval = props["backup-urls"];
+
+                auto const &urls_jsonval = props["backup-urls"];
                 if (urls_jsonval.isArray())
                 {
+                    auto& info = registry_[std::make_pair(type,QStringLiteral("backup"))];
                     for (auto url_jsonval : urls_jsonval.toArray())
                     {
                         info.urls.push_back(url_jsonval.toString());
                     }
+                    qDebug() << "loaded" << type << "backup urls from" << path;
+                    for(auto const& url : info.urls)
+                        qDebug() << "\turl:" << url;
                 }
 
-                qDebug() << "loaded" << type << "backup urls from" << path;
-                for(auto const& url : info.urls)
-                    qDebug() << "\turl:" << url;
+                auto const &urls_jsonval_restore = props["restore-urls"];
+                if (urls_jsonval_restore.isArray())
+                {
+                    auto& info = registry_[std::make_pair(type,QStringLiteral("restore"))];
+                    for (auto url_jsonval : urls_jsonval_restore.toArray())
+                    {
+                        info.urls.push_back(url_jsonval.toString());
+                    }
+                    qDebug() << "loaded" << type << "restore urls from" << path;
+                    for(auto const& url : info.urls)
+                        qDebug() << "\turl:" << url;
+                }
             }
         }
     }
@@ -198,3 +224,9 @@
 {
     return impl_->get_backup_helper_urls(task);
 }
+
+QStringList
+DataDirRegistry::get_restore_helper_urls(Metadata const& task)
+{
+    return impl_->get_restore_helper_urls(task);
+}

=== modified file 'src/helper/folder-backup.sh.in'
--- src/helper/folder-backup.sh.in	2016-08-10 05:01:08 +0000
+++ src/helper/folder-backup.sh.in	2017-02-27 19:05:17 +0000
@@ -20,4 +20,4 @@
 #
 
 echo $PWD
-find ./ -type f -print0 | @CMAKE_INSTALL_FULL_PKGLIBEXECDIR@/keeper-tar-create -a /com/canonical/keeper/helper
+find ./ -type f -print0 | @CMAKE_INSTALL_FULL_PKGLIBEXECDIR@/keeper-tar -a /com/canonical/keeper/helper

=== added file 'src/helper/folder-restore.sh.in'
--- src/helper/folder-restore.sh.in	1970-01-01 00:00:00 +0000
+++ src/helper/folder-restore.sh.in	2017-02-27 19:05:17 +0000
@@ -0,0 +1,23 @@
+#!/bin/bash
+#
+# Copyright (C) 2016 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/>.
+#
+# Authors:
+#   Xavi Garcia <[e-mail]>
+#   Charles Kerr <[e-mail]>
+#
+
+echo $PWD
+@CMAKE_INSTALL_FULL_PKGLIBEXECDIR@/keeper-untar -a /com/canonical/keeper/helper

=== modified file 'src/helper/helper.cpp'
--- src/helper/helper.cpp	2016-09-12 15:13:33 +0000
+++ src/helper/helper.cpp	2017-02-27 19:05:17 +0000
@@ -75,7 +75,6 @@
     uint32_t
     speed_bytes_per_second(uint64_t now, unsigned int interval_msec=HISTORY_MSEC) const
     {
-qDebug() << "now" << now << "cache_time" << cache_time << "interval_msec" << interval_msec;
         if (cache_time != now)
         {
             auto i = newest;
@@ -88,22 +87,18 @@
                     break;
 
                 bytes += transfers[i].size;
-qDebug() << "i" << i << "transfers[i] .date" << transfers[i].date << ".size" << transfers[i].size << "sum" << bytes;
 
                 if (--i == -1) {
                     i = HISTORY_SIZE - 1; // circular history
-qDebug() << "circular history";
                 }
 
                 if (i == newest) {
-qDebug() << "i" << i << "transfers[i] .date" << transfers[i].date << ".size" << transfers[i].size << "sum" << bytes;
                     break; // we've come all the way around
                 }
             }
 
             cache_val = uint32_t((bytes * 1000u) / interval_msec);
             cache_time = now;
-qDebug() << "cache_val" << cache_val << "cache_time" << cache_time;
         }
 
         return cache_val;
@@ -170,7 +165,10 @@
         {
             qDebug() << "changing state of helper" << static_cast<void*>(this) << "from" << q_ptr->to_string(state_) << "to" << q_ptr->to_string(state);
             state_ = state;
-            q_ptr->state_changed(state);
+            QMetaObject::invokeMethod(q_ptr,
+                                      "state_changed",
+                                      Qt::QueuedConnection,
+                                      Q_ARG(Helper::State, state));
         }
     }
 
@@ -337,7 +335,6 @@
 
         if (is_noteworthy)
         {
-            qDebug() << "emitting percent-done-changed" << percent_done_;
             Q_EMIT(q_ptr->percent_done_changed(percent_done_));
             last_notified_percent_done_ = percent_done_;
         }
@@ -356,7 +353,8 @@
 
     void on_max_time_waiting_for_ual_started()
     {
-        qDebug() << "Max time reached waiting for UAL to start";
+        qWarning() << "Maximum time reached waiting for the helper to start.";
+        Q_EMIT(q_ptr->error(keeper::Error::HELPER_START_TIMEOUT));
         q_ptr->set_state(Helper::State::FAILED);
         stop_wait_for_ual_timer();
     }

=== modified file 'src/helper/metadata.cpp'
--- src/helper/metadata.cpp	2016-09-06 18:51:30 +0000
+++ src/helper/metadata.cpp	2017-02-27 19:05:17 +0000
@@ -19,63 +19,58 @@
 
 #include "helper/metadata.h"
 
-///
-///
-
-// Metadata keys
-const QString Metadata::TYPE_KEY = QStringLiteral("type");
-const QString Metadata::SUBTYPE_KEY = QStringLiteral("subtype");
-const QString Metadata::NAME_KEY = QStringLiteral("name");
-const QString Metadata::PACKAGE_KEY = QStringLiteral("package");
-const QString Metadata::TITLE_KEY = QStringLiteral("title");
-const QString Metadata::VERSION_KEY = QStringLiteral("version");
-
-// Metadata values
-const QString Metadata::FOLDER_VALUE = QStringLiteral("folder");
-const QString Metadata::SYSTEM_DATA_VALUE = QStringLiteral("system-data");
-const QString Metadata::APPLICATION_VALUE = QStringLiteral("application");
+#include <QDebug>
+#include <QJsonArray>
+#include <QJsonDocument>
+
+///
+///
+
+// JSON Keys
+namespace
+{
+    constexpr const char PROPERTIES_KEY[]   = "properties";
+}
 
 ///
 ///
 
 Metadata::Metadata()
-    : uuid_()
-    , display_name_()
-    , properties_()
-{
+    : keeper::Item()
+{
+}
+
+Metadata::Metadata(QJsonObject const & json)
+    : keeper::Item()
+{
+    auto properties = json[PROPERTIES_KEY].toObject();
+    for (auto const & key : properties.keys())
+    {
+        this->insert(key, properties[key].toString());
+    }
 }
 
 Metadata::Metadata(QString const& uuid, QString const& display_name)
-    : uuid_(uuid)
-    , display_name_(display_name)
-    , properties_()
-{
-}
-
-bool
-Metadata::get_property(QString const& property_name, QString& setme) const
-{
-    auto it = properties_.constFind(property_name);
-    const bool found = it != properties_.end();
-
-    if (found)
-        setme = it.value();
-
-    return found;
-}
-
-void
-Metadata::set_property(QString const& property_name, QString const& value)
-{
-    properties_.insert(property_name, value);
-}
-
-QMap<QString,QString>
-Metadata::get_public_properties() const
-{
-    // they're all public so far...
-    auto ret = properties_;
-    ret.insert(QStringLiteral("uuid"), uuid_);
-    ret.insert(QStringLiteral("display-name"), display_name_);
+    : keeper::Item()
+{
+    this->insert(keeper::Item::UUID_KEY, uuid);
+    this->insert(keeper::Item::DISPLAY_NAME_KEY, display_name);
+}
+
+QJsonObject
+Metadata::json() const
+{
+    QJsonArray json_properties;
+    QJsonObject properties_obj;
+    for (auto iter = this->begin(); iter != this->end(); ++iter)
+    {
+        properties_obj[iter.key()] = (*iter).toString();
+    }
+
+    QJsonObject ret
+    {
+        { PROPERTIES_KEY, properties_obj }
+    };
+
     return ret;
 }

=== added file 'src/helper/restore-helper.cpp'
--- src/helper/restore-helper.cpp	1970-01-01 00:00:00 +0000
+++ src/helper/restore-helper.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *     Xavi Garcia <[e-mail]>
+ *     Charles Kerr <[e-mail]>
+ */
+
+#include "util/connection-helper.h"
+#include "helper/restore-helper.h"
+#include "service/app-const.h" // HELPER_TYPE
+
+#include <QByteArray>
+#include <QDebug>
+#include <QLocalSocket>
+#include <QMap>
+#include <QObject>
+#include <QString>
+#include <QTimer>
+#include <QVector>
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <functional> // std::bind()
+
+
+class RestoreHelperPrivate
+{
+public:
+
+    explicit RestoreHelperPrivate(
+        RestoreHelper* backup_helper
+    )
+        : q_ptr(backup_helper)
+    {
+        // listen for inactivity from storage framework
+        QObject::connect(&timer_, &QTimer::timeout,
+            std::bind(&RestoreHelperPrivate::on_inactivity_detected, this)
+        );
+
+        // fire up the sockets
+        int fds[2];
+        int rc = socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, fds);
+        if (rc == -1)
+        {
+            qWarning() <<  QStringLiteral("Error creating socket to communicate with helper");;
+            Q_EMIT(q_ptr->error(keeper::Error::HELPER_SOCKET));
+            return;
+        }
+
+        // helper socket is for the client.
+        // We don't use a QLocalSocket here as it buffers data and it makes the helper miss packets.
+        helper_socket_ = fds[1];
+
+        write_socket_.setSocketDescriptor(fds[0], QLocalSocket::ConnectedState, QIODevice::WriteOnly);
+    }
+
+    ~RestoreHelperPrivate() = default;
+
+    Q_DISABLE_COPY(RestoreHelperPrivate)
+
+    void start(QStringList const& urls)
+    {
+        q_ptr->Helper::start(urls);
+        reset_inactivity_timer();
+    }
+
+    void set_downloader(std::shared_ptr<Downloader> const& downloader)
+    {
+        n_read_ = 0;
+        n_uploaded_ = 0;
+        read_error_ = false;
+        write_error_ = false;
+        cancelled_ = false;
+
+        q_ptr->set_expected_size(downloader->file_size());
+        downloader_ = downloader;
+
+        connections_.remember(QObject::connect(
+            &write_socket_, &QLocalSocket::bytesWritten,
+            std::bind(&RestoreHelperPrivate::on_data_uploaded, this, std::placeholders::_1)
+        ));
+
+        // listen for data ready to read
+        QObject::connect(downloader_->socket().get(), &QLocalSocket::readyRead,
+            std::bind(&RestoreHelperPrivate::on_ready_read, this)
+        );
+
+        // TODO investigate why UAL takes so long to call the helper started callback
+        // At this point we are sure that the helper started, as it is the helper
+        // the ones that asks for a downloader socket.
+        q_ptr->Helper::on_helper_started();
+
+        // maybe there's data already to be read
+        process_more();
+
+        reset_inactivity_timer();
+    }
+
+    void stop()
+    {
+        write_socket_.disconnectFromServer();
+        cancelled_ = true;
+        q_ptr->Helper::stop();
+    }
+
+    int get_helper_socket() const
+    {
+        return helper_socket_;
+    }
+
+    QString to_string(Helper::State state) const
+    {
+        return state == Helper::State::STARTED
+            ? QStringLiteral("restoring")
+            : q_ptr->Helper::to_string(state);
+    }
+
+    void on_state_changed(Helper::State state)
+    {
+        switch (state)
+        {
+            case Helper::State::CANCELLED:
+            case Helper::State::FAILED:
+                qDebug() << "cancelled/failed, calling downloader_.reset()";
+                downloader_.reset();
+                break;
+
+            case Helper::State::DATA_COMPLETE: {
+                qDebug() << "Restore helper finished, calling downloader_.finish()";
+                write_socket_.disconnectFromServer();
+                downloader_->finish();
+                downloader_.reset();
+                break;
+            }
+
+            //case Helper::State::NOT_STARTED:
+            //case Helper::State::STARTED:
+            default:
+                break;
+        }
+    }
+
+    void on_helper_finished()
+    {
+        stop_inactivity_timer();
+        check_for_done();
+    }
+
+private:
+
+    void on_inactivity_detected()
+    {
+        stop_inactivity_timer();
+        qWarning() << "Inactivity detected in the helper...stopping it";
+        Q_EMIT(q_ptr->error(keeper::Error::HELPER_INACTIVITY_DETECTED));
+        stop();
+    }
+
+    void on_ready_read()
+    {
+        process_more();
+    }
+
+    void on_data_uploaded(qint64 n)
+    {
+        n_uploaded_ += n;
+        q_ptr->record_data_transferred(n);
+        process_more();
+        check_for_done();
+    }
+
+    void process_more()
+    {
+        if (!downloader_)
+            return;
+
+        char readbuf[UPLOAD_BUFFER_MAX_];
+        auto socket = downloader_->socket();
+        while(socket->bytesAvailable() || upload_buffer_.size())
+        {
+            if (socket->bytesAvailable())
+            {
+                // try to fill the upload buf
+                int max_bytes = UPLOAD_BUFFER_MAX_ - upload_buffer_.size();
+                if (max_bytes > 0) {
+                    const auto n = socket->read(readbuf, max_bytes);
+                    if (n > 0) {
+                        n_read_ += n;
+                        upload_buffer_.append(readbuf, int(n));
+                    }
+                    else if (n < 0) {
+                        read_error_ = true;
+                        qDebug() << "Read error in restore helper: " << socket->errorString();
+                        Q_EMIT(q_ptr->error(keeper::Error::HELPER_READ));
+                        stop();
+                        check_for_done();
+                        return;
+                    }
+                }
+            }
+
+            if (upload_buffer_.size())
+            {
+                // try to empty the upload buf
+                const auto n = write_socket_.write(upload_buffer_);
+                if (n > 0) {
+                    upload_buffer_.remove(0, int(n));
+                    continue;
+                }
+                else {
+                    if (n < 0) {
+                        write_error_ = true;
+                        qWarning() << "Write error:" << write_socket_.errorString();
+                        Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
+                        stop();
+                        check_for_done();
+                    }
+                    break;
+                }
+            }
+        }
+
+        reset_inactivity_timer();
+    }
+
+    void reset_inactivity_timer()
+    {
+        static constexpr int MAX_TIME_WAITING_FOR_DATA {RestoreHelper::MAX_INACTIVITY_TIME};
+        timer_.start(MAX_TIME_WAITING_FOR_DATA);
+    }
+
+    void stop_inactivity_timer()
+    {
+        timer_.stop();
+    }
+
+    void check_for_done()
+    {
+        if (cancelled_)
+        {
+            q_ptr->set_state(Helper::State::CANCELLED);
+        }
+        else if (read_error_ || write_error_ || n_uploaded_ > q_ptr->expected_size())
+        {
+            if (!q_ptr->is_helper_running())
+            {
+                if (n_uploaded_ > q_ptr->expected_size())
+                {
+                    Q_EMIT(q_ptr->error(keeper::Error::HELPER_WRITE));
+                }
+                q_ptr->set_state(Helper::State::FAILED);
+            }
+        }
+        else if (n_uploaded_ == q_ptr->expected_size())
+        {
+            if (downloader_)
+            {
+                if (q_ptr->is_helper_running())
+                {
+                    // only in the case that the helper process finished we move to the next state
+                    // this is to prevent to start the next task too early
+                    q_ptr->set_state(Helper::State::DATA_COMPLETE);
+                    stop_inactivity_timer();
+                }
+            }
+            else
+                q_ptr->set_state(Helper::State::COMPLETE);
+        }
+    }
+
+    /***
+    ****
+    ***/
+
+    static constexpr int UPLOAD_BUFFER_MAX_ {1024*16};
+
+    RestoreHelper * const q_ptr;
+    QTimer timer_;
+    std::shared_ptr<Downloader> downloader_;
+    int helper_socket_ = -1;
+    QLocalSocket write_socket_;
+    QByteArray upload_buffer_;
+    qint64 n_read_ = 0;
+    qint64 n_uploaded_ = 0;
+    bool read_error_ = false;
+    bool write_error_ = false;
+    bool cancelled_ = false;
+    ConnectionHelper connections_;
+};
+
+/***
+****
+***/
+
+RestoreHelper::RestoreHelper(
+    QString const & appid,
+    clock_func const & clock,
+    QObject * parent
+)
+    : Helper(appid, clock, parent)
+    , d_ptr(new RestoreHelperPrivate(this))
+{
+}
+
+RestoreHelper::~RestoreHelper() =default;
+
+void
+RestoreHelper::start(QStringList const& url)
+{
+    Q_D(RestoreHelper);
+
+    d->start(url);
+}
+
+void
+RestoreHelper::stop()
+{
+    Q_D(RestoreHelper);
+
+    d->stop();
+}
+
+void
+RestoreHelper::set_downloader(std::shared_ptr<Downloader> const& downloader)
+{
+    Q_D(RestoreHelper);
+
+    d->set_downloader(downloader);
+}
+
+int
+RestoreHelper::get_helper_socket() const
+{
+    Q_D(const RestoreHelper);
+
+    return d->get_helper_socket();
+}
+
+QString
+RestoreHelper::to_string(Helper::State state) const
+{
+    Q_D(const RestoreHelper);
+
+    return d->to_string(state);
+}
+
+void
+RestoreHelper::set_state(Helper::State state)
+{
+    Q_D(RestoreHelper);
+
+    Helper::set_state(state);
+    d->on_state_changed(state);
+}
+
+void RestoreHelper::on_helper_finished()
+{
+    Q_D(RestoreHelper);
+
+    Helper::on_helper_finished();
+    d->on_helper_finished();
+}

=== modified file 'src/qdbus-stubs/CMakeLists.txt'
--- src/qdbus-stubs/CMakeLists.txt	2016-08-10 05:41:26 +0000
+++ src/qdbus-stubs/CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -67,6 +67,7 @@
   ${user_xml}
   PROPERTIES
   CLASSNAME DBusInterfaceKeeperUser
+  INCLUDE "client/keeper-items.h"
 )
 
 qt5_add_dbus_interface(
@@ -84,6 +85,23 @@
   KeeperUserAdaptor
 )
 
+set(
+  properties_xml
+  "org.freedesktop.DBus.Properties.xml"
+)
+
+set_source_files_properties(
+  "${properties_xml}"
+  PROPERTIES
+  NO_NAMESPACE YES
+  CLASSNAME DBusPropertiesInterface
+)
+
+qt5_add_dbus_interface(
+  interface_files
+  ${properties_xml}
+  DBusPropertiesInterface
+)
 #
 #
 
@@ -101,5 +119,5 @@
 
 target_link_libraries(
   ${STUBS_LIB}
-  backup-helper
+  keeper-errors-lib
 )

=== modified file 'src/qdbus-stubs/com.canonical.keeper.User.xml'
--- src/qdbus-stubs/com.canonical.keeper.User.xml	2016-07-28 19:44:52 +0000
+++ src/qdbus-stubs/com.canonical.keeper.User.xml	2017-02-27 19:05:17 +0000
@@ -5,7 +5,7 @@
   <interface name="com.canonical.keeper.User">
 
     <method name="GetBackupChoices">
-      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantDictMap"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="keeper::Items"/>
       <arg direction="out" name="backups" type="a{sa{sv}}">
         <doc:doc>
         <doc:summary>A list of backup possibilities for the user to choose from</doc:summary>
@@ -32,10 +32,32 @@
         </doc:description>
         </doc:doc>
       </arg>
+      <arg direction="in" name="storage" type="s">
+        <doc:doc>
+        <doc:summary>The storage identifier</doc:summary>
+        <doc:description>
+        <doc:para>Because keeper supports multiple storage providers the user can define
+                  which is the storage provider to use.
+                  If the passed storage id is an empty string the default storage provider
+                  will be used.</doc:para>
+        </doc:description>
+        </doc:doc>
+      </arg>
     </method>
 
     <method name="GetRestoreChoices">
-      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantDictMap"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="keeper::Items"/>
+      <arg direction="in" name="storage" type="s">
+        <doc:doc>
+        <doc:summary>The storage identifier</doc:summary>
+        <doc:description>
+        <doc:para>Because keeper supports multiple storage providers the user can define
+                  which is the storage provider to use.
+                  If the passed storage id is an empty string the default storage provider
+                  will be used.</doc:para>
+        </doc:description>
+        </doc:doc>
+      </arg>
       <arg direction="out" name="backups" type="a{sa{sv}}">
         <doc:doc>
         <doc:summary>The backups which already exist and can be restored</doc:summary>
@@ -62,10 +84,21 @@
         </doc:description>
         </doc:doc>
       </arg>
+      <arg direction="in" name="storage" type="s">
+        <doc:doc>
+        <doc:summary>The storage identifier</doc:summary>
+        <doc:description>
+        <doc:para>Because keeper supports multiple storage providers the user can define
+                  which is the storage provider to use.
+                  If the passed storage id is an empty string the default storage provider
+                  will be used.</doc:para>
+        </doc:description>
+        </doc:doc>
+      </arg>
     </method>
 
     <property name="State" type="a{sa{sv}}" access="read">
-      <annotation name="org.qtproject.QtDBus.QtTypeName" value="QVariantDictMap"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName" value="keeper::Items"/>
       <doc:doc>
         <doc:description>
           <doc:para>Provides state information so the user interface can show
@@ -86,6 +119,17 @@
       </doc:doc>
     </property>
 
+    <method name="GetStorageAccounts">
+      <arg direction="out" name="accounts" type="as">
+        <doc:doc>
+        <doc:summary>The list of available storage accounts.</doc:summary>
+        <doc:description>
+        <doc:para>An array of the available accounts to choose from to backup/restore</doc:para>
+        </doc:description>
+        </doc:doc>
+      </arg>
+    </method>
+
     <method name="Cancel">
       <doc:doc>
       <doc:summary>Cancels the current backup or restore actions.</doc:summary>

=== modified file 'src/qdbus-stubs/dbus-types.h'
--- src/qdbus-stubs/dbus-types.h	2016-07-14 15:31:11 +0000
+++ src/qdbus-stubs/dbus-types.h	2017-02-27 19:05:17 +0000
@@ -22,7 +22,8 @@
 #include <QtCore>
 #include <QString>
 #include <QVariantMap>
-#include <helper/helper.h>
+#include <client/keeper-errors.h>
+#include "client/keeper-items.h"
 
 typedef QMap<QString, QVariantMap> QVariantDictMap;
 Q_DECLARE_METATYPE(QVariantDictMap)
@@ -36,10 +37,13 @@
     {
         qRegisterMetaType<QVariantDictMap>("QVariantDictMap");
         qRegisterMetaType<QStringMap>("QStringMap");
+        qRegisterMetaType<keeper::Error>("keeper::Error");
 
         qDBusRegisterMetaType<QVariantDictMap>();
         qDBusRegisterMetaType<QStringMap>();
-        Helper::registerMetaTypes();
+        qDBusRegisterMetaType<keeper::Error>();
+
+        keeper::Items::registerMetaType();
     }
 
     constexpr const char KEEPER_SERVICE[] = "com.canonical.keeper";

=== added file 'src/qdbus-stubs/org.freedesktop.DBus.Properties.xml'
--- src/qdbus-stubs/org.freedesktop.DBus.Properties.xml	1970-01-01 00:00:00 +0000
+++ src/qdbus-stubs/org.freedesktop.DBus.Properties.xml	2017-02-27 19:05:17 +0000
@@ -0,0 +1,27 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+                      "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="org.freedesktop.DBus.Properties">
+    <method name="Get">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="s" name="property_name" direction="in"/>
+      <arg type="v" name="value" direction="out"/>
+    </method>
+    <method name="GetAll">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="a{sv}" name="properties" direction="out"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
+    </method>
+    <method name="Set">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="s" name="property_name" direction="in"/>
+      <arg type="v" name="value" direction="in"/>
+    </method>
+    <signal name="PropertiesChanged">
+      <arg type="s" name="interface_name"/>
+      <arg type="a{sv}" name="changed_properties"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
+      <arg type="as" name="invalidated_properties"/>
+    </signal>
+  </interface>
+</node>

=== modified file 'src/service/CMakeLists.txt'
--- src/service/CMakeLists.txt	2016-09-06 01:31:59 +0000
+++ src/service/CMakeLists.txt	2017-02-27 19:05:17 +0000
@@ -15,6 +15,9 @@
   task-manager.cpp
   keeper-task.cpp
   keeper-task-backup.cpp
+  keeper-task-restore.cpp
+  manifest.cpp
+  metadata-provider.h
 )
 add_library(
   ${SERVICE_LIB}
@@ -46,6 +49,7 @@
   storage-framework
   util
   qdbus-stubs
+  keeper-errors-lib
 )
 
 target_link_libraries(

=== modified file 'src/service/backup-choices.cpp'
--- src/service/backup-choices.cpp	2016-09-05 18:38:36 +0000
+++ src/service/backup-choices.cpp	2017-02-27 19:05:17 +0000
@@ -45,22 +45,30 @@
     }
 }
 
-BackupChoices::BackupChoices() =default;
+BackupChoices::BackupChoices(QObject *parent)
+    : MetadataProvider(parent)
+{
+}
 
 BackupChoices::~BackupChoices() =default;
 
 QVector<Metadata>
 BackupChoices::get_backups() const
 {
-    QVector<Metadata> ret;
+    return backups_;
+}
 
+void
+BackupChoices::get_backups_async(QString const & /*storage*/)
+{
+    backups_.clear();
     //
     //  System Data
     //
     {
         Metadata m(generate_new_uuid(), "System Data"); // FIXME: how to i18n in a Qt DBus service?
-        m.set_property(Metadata::TYPE_KEY, Metadata::SYSTEM_DATA_VALUE);
-        ret.push_back(m);
+        m.set_property_value(Metadata::TYPE_KEY, Metadata::SYSTEM_DATA_VALUE);
+        backups_.push_back(m);
     }
 
     //
@@ -112,13 +120,13 @@
                     display_name = QStringLiteral("%1 (%2)").arg(display_name).arg(version.toString());
 
                 Metadata m(generate_new_uuid(), display_name);
-                m.set_property(Metadata::PACKAGE_KEY, name.toString());
-                m.set_property(Metadata::TYPE_KEY, Metadata::APPLICATION_VALUE);
+                m.set_property_value(Metadata::PACKAGE_KEY, name.toString());
+                m.set_property_value(Metadata::TYPE_KEY, Metadata::APPLICATION_VALUE);
 
                 if (version != QJsonValue::Undefined)
-                    m.set_property(Metadata::VERSION_KEY, version.toString());
+                    m.set_property_value(Metadata::VERSION_KEY, version.toString());
 
-                ret.push_back(m);
+                backups_.push_back(m);
             }
         }
     }
@@ -146,11 +154,11 @@
         {
             const auto keystr = generate_new_uuid();
             Metadata m(keystr, name);
-            m.set_property(Metadata::TYPE_KEY, Metadata::FOLDER_VALUE);
-            m.set_property(Metadata::SUBTYPE_KEY, locations.front());
-            ret.push_back(m);
+            m.set_property_value(Metadata::TYPE_KEY, Metadata::FOLDER_VALUE);
+            m.set_property_value(Metadata::SUBTYPE_KEY, locations.front());
+            backups_.push_back(m);
         }
     }
 
-    return ret;
+    Q_EMIT(finished(keeper::Error::OK));
 }

=== modified file 'src/service/backup-choices.h'
--- src/service/backup-choices.h	2016-09-05 18:38:36 +0000
+++ src/service/backup-choices.h	2017-02-27 19:05:17 +0000
@@ -27,7 +27,8 @@
 class BackupChoices: public MetadataProvider
 {
 public:
-    BackupChoices();
+    explicit BackupChoices(QObject *parent = nullptr);
     virtual ~BackupChoices();
     QVector<Metadata> get_backups() const override;
+    void get_backups_async(QString const & storage = "") override;
 };

=== modified file 'src/service/keeper-helper.cpp'
--- src/service/keeper-helper.cpp	2016-08-10 02:06:08 +0000
+++ src/service/keeper-helper.cpp	2017-02-27 19:05:17 +0000
@@ -44,8 +44,11 @@
 
 QDBusUnixFileDescriptor KeeperHelper::StartRestore()
 {
-    // TODO get the file descriptor of the item in storage framework
-    return QDBusUnixFileDescriptor();
+    // pass it back to Keeper to do the work
+    Q_ASSERT(calledFromDBus());
+    auto bus = connection();
+    auto& msg = message();
+    return keeper_.StartRestore(bus, msg);
 }
 
 void KeeperHelper::UpdateStatus(const QString &app_id, const QString &status, double percentage)

=== modified file 'src/service/keeper-task-backup.cpp'
--- src/service/keeper-task-backup.cpp	2016-09-06 20:08:14 +0000
+++ src/service/keeper-task-backup.cpp	2017-02-27 19:05:17 +0000
@@ -31,7 +31,7 @@
     Q_DECLARE_PUBLIC(KeeperTaskBackup)
 public:
     KeeperTaskBackupPrivate(KeeperTask * keeper_task,
-                            KeeperTask::TaskData const & task_data,
+                            KeeperTask::TaskData & task_data,
                             QSharedPointer<HelperRegistry> const & helper_registry,
                             QSharedPointer<StorageFrameworkClient> const & storage)
         : KeeperTaskPrivate(keeper_task, task_data, helper_registry, storage)
@@ -50,33 +50,52 @@
         qDebug() << "Initializing a backup helper";
         helper_.reset(new BackupHelper(DEKKO_APP_ID), [](Helper *h){h->deleteLater();});
         qDebug() << "Helper " <<  static_cast<void*>(helper_.data()) << " was created";
+        QObject::connect(helper_.data(), &Helper::error, [this](keeper::Error error){ error_ = error;});
     }
 
-    void ask_for_uploader(quint64 n_bytes)
+    void ask_for_uploader(quint64 n_bytes, QString const & dir_name)
     {
         qDebug() << "asking storage framework for a socket";
 
         helper_->set_expected_size(n_bytes);
 
+        const auto file_name = QString("%1.keeper").arg(task_data_.metadata.get_display_name());
+
         connections_.connect_future(
-            storage_->get_new_uploader(n_bytes),
+            storage_->get_new_uploader(n_bytes, dir_name, file_name),
             std::function<void(std::shared_ptr<Uploader> const&)>{
                 [this](std::shared_ptr<Uploader> const& uploader){
-                    qDebug("calling helper.set_storage_framework_socket(socket=%d)", int(uploader->socket()->socketDescriptor()));
-                    qDebug() << "Helper is " <<  static_cast<void*>(helper_.data());
-                    auto backup_helper = qSharedPointerDynamicCast<BackupHelper>(helper_);
-                    backup_helper->set_uploader(uploader);
-                    Q_EMIT(q_ptr->task_socket_ready(backup_helper->get_helper_socket()));
+                    auto fd {-1};
+                    if (uploader) {
+                        auto backup_helper = qSharedPointerDynamicCast<BackupHelper>(helper_);
+                        backup_helper->set_uploader(uploader);
+                        fd = backup_helper->get_helper_socket();
+                        qDebug("emitting task_socket_ready(socket=%d)", fd);
+                        Q_EMIT(q_ptr->task_socket_ready(fd));
+                    }
+                    else
+                    {
+                        error_ = storage_->get_last_error();
+                        qDebug("Emitting task_socket_error(error=%d)", static_cast<int>(error_));
+                        Q_EMIT(q_ptr->task_socket_error(error_));
+                    }
                 }
             }
         );
     }
 
+    QString get_file_name() const
+    {
+        auto backup_helper = qSharedPointerDynamicCast<BackupHelper>(helper_);
+        return backup_helper->get_uploader_committed_file_name();
+    }
+
 private:
     ConnectionHelper connections_;
+    QString file_name_;
 };
 
-KeeperTaskBackup::KeeperTaskBackup(TaskData const & task_data,
+KeeperTaskBackup::KeeperTaskBackup(TaskData & task_data,
            QSharedPointer<HelperRegistry> const & helper_registry,
            QSharedPointer<StorageFrameworkClient> const & storage,
            QObject *parent)
@@ -89,17 +108,27 @@
 QStringList KeeperTaskBackup::get_helper_urls() const
 {
     Q_D(const KeeperTaskBackup);
+
     return d->get_helper_urls();
 }
 
 void KeeperTaskBackup::init_helper()
 {
     Q_D(KeeperTaskBackup);
+
     d->init_helper();
 }
 
-void KeeperTaskBackup::ask_for_uploader(quint64 n_bytes)
+void KeeperTaskBackup::ask_for_uploader(quint64 n_bytes, QString const & dir_name)
 {
     Q_D(KeeperTaskBackup);
-    d->ask_for_uploader(n_bytes);
+
+    d->ask_for_uploader(n_bytes, dir_name);
+}
+
+QString KeeperTaskBackup::get_file_name() const
+{
+    Q_D(const KeeperTaskBackup);
+
+    return d->get_file_name();
 }

=== modified file 'src/service/keeper-task-backup.h'
--- src/service/keeper-task-backup.h	2016-09-06 02:13:34 +0000
+++ src/service/keeper-task-backup.h	2017-02-27 19:05:17 +0000
@@ -29,7 +29,7 @@
     Q_DECLARE_PRIVATE(KeeperTaskBackup)
 public:
 
-    KeeperTaskBackup(TaskData const & task_data,
+    KeeperTaskBackup(TaskData & task_data,
                QSharedPointer<HelperRegistry> const & helper_registry,
                QSharedPointer<StorageFrameworkClient> const & storage,
                QObject *parent = nullptr);
@@ -37,7 +37,9 @@
 
     Q_DISABLE_COPY(KeeperTaskBackup)
 
-    void ask_for_uploader(quint64 n_bytes);
+    void ask_for_uploader(quint64 n_bytes, QString const & dir_name);
+
+    QString get_file_name() const;
 
 protected:
     QStringList get_helper_urls() const override;

=== added file 'src/service/keeper-task-restore.cpp'
--- src/service/keeper-task-restore.cpp	1970-01-01 00:00:00 +0000
+++ src/service/keeper-task-restore.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *   Xavi Garcia <[e-mail]>
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include "util/connection-helper.h"
+#include "storage-framework/storage_framework_client.h"
+#include "helper/restore-helper.h"
+#include "service/app-const.h" // DEKKO_APP_ID
+#include "service/keeper-task-restore.h"
+#include "service/keeper-task.h"
+#include "service/private/keeper-task_p.h"
+
+namespace sf = unity::storage::qt::client;
+
+class KeeperTaskRestorePrivate : public KeeperTaskPrivate
+{
+    Q_DECLARE_PUBLIC(KeeperTaskRestore)
+public:
+    KeeperTaskRestorePrivate(KeeperTask * keeper_task,
+                             KeeperTask::TaskData & task_data,
+                             QSharedPointer<HelperRegistry> const & helper_registry,
+                             QSharedPointer<StorageFrameworkClient> const & storage)
+        : KeeperTaskPrivate(keeper_task, task_data, helper_registry, storage)
+    {
+    }
+
+    ~KeeperTaskRestorePrivate() = default;
+
+    QStringList get_helper_urls() const
+    {
+        return helper_registry_->get_restore_helper_urls(task_data_.metadata);
+    }
+
+    void init_helper()
+    {
+        helper_.reset(new RestoreHelper(DEKKO_APP_ID), [](Helper *h){h->deleteLater();});
+        qDebug() << "Helper " <<  static_cast<void*>(helper_.data()) << " was created";
+    }
+
+    void ask_for_downloader()
+    {
+        qDebug() << "asking storage framework for a socket for reading";
+
+        auto file_name = task_data_.metadata.get_file_name();
+        if (file_name.isEmpty())
+        {
+            qWarning() << "ERROR: the restore task does not provide a valid file name to read from.";
+            return;
+        }
+
+        auto dir_name = task_data_.metadata.get_dir_name();
+        if (dir_name.isEmpty())
+        {
+            qWarning() << "ERROR: the restore task does not provide a valid directory name.";
+            return;
+        }
+
+        // extract the dir_name.
+        connections_.connect_future(
+            storage_->get_new_downloader(dir_name, file_name),
+            std::function<void(std::shared_ptr<Downloader> const&)>{
+                [this](std::shared_ptr<Downloader> const& downloader){
+                    auto fd {-1};
+                    if (downloader) {
+                        auto restore_helper = qSharedPointerDynamicCast<RestoreHelper>(helper_);
+                        restore_helper->set_downloader(downloader);
+                        fd = restore_helper->get_helper_socket();
+                        Q_EMIT(q_ptr->task_socket_ready(fd));
+                    }
+                    else
+                    {
+                        error_ = storage_->get_last_error();
+                        qDebug("Emitting task_socket_error(error=%d)", static_cast<int>(error_));
+                        Q_EMIT(q_ptr->task_socket_error(error_));
+                    }
+                }
+            }
+        );
+    }
+
+private:
+    ConnectionHelper connections_;
+};
+
+KeeperTaskRestore::KeeperTaskRestore(TaskData & task_data,
+                                     QSharedPointer<HelperRegistry> const & helper_registry,
+                                     QSharedPointer<StorageFrameworkClient> const & storage,
+                                     QObject *parent)
+    : KeeperTask(*new KeeperTaskRestorePrivate(this, task_data, helper_registry, storage), parent)
+{
+}
+
+KeeperTaskRestore::~KeeperTaskRestore() = default;
+
+QStringList KeeperTaskRestore::get_helper_urls() const
+{
+    Q_D(const KeeperTaskRestore);
+
+    return d->get_helper_urls();
+}
+
+void KeeperTaskRestore::init_helper()
+{
+    Q_D(KeeperTaskRestore);
+
+    d->init_helper();
+}
+
+void KeeperTaskRestore::ask_for_downloader()
+{
+    Q_D(KeeperTaskRestore);
+
+    d->ask_for_downloader();
+}

=== added file 'src/service/keeper-task-restore.h'
--- src/service/keeper-task-restore.h	1970-01-01 00:00:00 +0000
+++ src/service/keeper-task-restore.h	2017-02-27 19:05:17 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *   Xavi Garcia <[e-mail]>
+ *   Charles Kerr <[e-mail]>
+ */
+#pragma once
+
+#include "keeper-task.h"
+
+class KeeperTaskRestorePrivate;
+
+class KeeperTaskRestore : public KeeperTask
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(KeeperTaskRestore)
+public:
+
+    KeeperTaskRestore(TaskData & task_data,
+               QSharedPointer<HelperRegistry> const & helper_registry,
+               QSharedPointer<StorageFrameworkClient> const & storage,
+               QObject *parent = nullptr);
+    virtual ~KeeperTaskRestore();
+
+    Q_DISABLE_COPY(KeeperTaskRestore)
+
+    void ask_for_downloader();
+
+protected:
+    QStringList get_helper_urls() const override;
+    void init_helper() override;
+
+};

=== modified file 'src/service/keeper-task.cpp'
--- src/service/keeper-task.cpp	2016-09-13 08:47:14 +0000
+++ src/service/keeper-task.cpp	2017-02-27 19:05:17 +0000
@@ -28,13 +28,14 @@
 #include <QString>
 
 KeeperTaskPrivate::KeeperTaskPrivate(KeeperTask * keeper_task,
-                  KeeperTask::TaskData const & task_data,
+                  KeeperTask::TaskData & task_data,
                   QSharedPointer<HelperRegistry> const & helper_registry,
                   QSharedPointer<StorageFrameworkClient> const & storage)
     : q_ptr(keeper_task)
     , task_data_(task_data)
     , helper_registry_(helper_registry)
     , storage_(storage)
+    , error_(keeper::Error::OK)
 {
 }
 
@@ -49,8 +50,8 @@
     if (urls.isEmpty())
     {
         task_data_.action = helper_->to_string(Helper::State::FAILED);
-        task_data_.error = "no helper information in registry";
-        qWarning() << "ERROR: uuid: " << task_data_.metadata.uuid() << " has no url";
+        error_ = keeper::Error::HELPER_BAD_URL;
+        qWarning() << QStringLiteral("Error: uuid %1 has no url").arg(task_data_.metadata.get_uuid());
         calculate_and_notify_state(Helper::State::FAILED);
         return false;
     }
@@ -65,6 +66,10 @@
         std::bind(&KeeperTaskPrivate::on_helper_percent_done_changed, this, std::placeholders::_1)
     );
 
+    QObject::connect(helper_.data(), &Helper::error, [this](keeper::Error error){
+        error_ = error;
+    });
+
     helper_->start(urls);
     return true;
 }
@@ -120,22 +125,28 @@
 {
     QVariantMap ret;
 
-    auto const uuid = task_data_.metadata.uuid();
-
-    ret.insert(QStringLiteral("action"), task_data_.action);
-
-    ret.insert(QStringLiteral("display-name"), task_data_.metadata.display_name());
+    auto const uuid = task_data_.metadata.get_uuid();
+
+    ret.insert(keeper::Item::STATUS_KEY, task_data_.action);
+    ret.insert(keeper::Item::DISPLAY_NAME_KEY, task_data_.metadata.get_display_name());
 
     auto const speed = helper_->speed();
-    ret.insert(QStringLiteral("speed"), int32_t(speed));
+    ret.insert(keeper::Item::SPEED_KEY, int32_t(speed));
 
     auto const percent_done = helper_->percent_done();
-    ret.insert(QStringLiteral("percent-done"), double(percent_done));
-
-    if (task_data_.action == "failed")
-        ret.insert(QStringLiteral("error"), task_data_.error);
-
-    ret.insert(QStringLiteral("uuid"), uuid);
+    ret.insert(keeper::Item::PERCENT_DONE_KEY, double(percent_done));
+
+    if (task_data_.action == "failed" || task_data_.action == "cancelled")
+    {
+        auto error = error_;
+        if (task_data_.error != keeper::Error::OK)
+        {
+            error = task_data_.error;
+        }
+        ret.insert(keeper::Item::ERROR_KEY, QVariant::fromValue(error));
+    }
+
+    ret.insert(keeper::Item::UUID_KEY, uuid);
 
     QJsonDocument doc(QJsonObject::fromVariantMap(ret));
     qDebug() << QString(doc.toJson(QJsonDocument::Compact));
@@ -145,29 +156,60 @@
 
 void KeeperTaskPrivate::calculate_and_notify_state(Helper::State state)
 {
+    recalculate_task_state();
+    Q_EMIT(q_ptr->task_state_changed(state));
+}
+
+void KeeperTaskPrivate::recalculate_task_state()
+{
     state_ = calculate_task_state();
-    Q_EMIT(q_ptr->task_state_changed(state));
+}
+
+void KeeperTaskPrivate::cancel()
+{
+    if (helper_)
+    {
+        helper_->stop();
+    }
 }
 
 QVariantMap KeeperTaskPrivate::get_initial_state(KeeperTask::TaskData const &td)
 {
     QVariantMap ret;
 
-    auto const uuid = td.metadata.uuid();
+    auto const uuid = td.metadata.get_uuid();
 
-    ret.insert(QStringLiteral("action"), td.action);
+    ret.insert(keeper::Item::STATUS_KEY, td.action);
 
     // TODO review this when we add the restore tasks.
     // TODO we maybe have different fields
-    ret.insert(QStringLiteral("display-name"), td.metadata.display_name());
-    ret.insert(QStringLiteral("speed"), 0);
-    ret.insert(QStringLiteral("percent-done"), double(0.0));
-    ret.insert(QStringLiteral("uuid"), uuid);
+    ret.insert(keeper::Item::DISPLAY_NAME_KEY, td.metadata.get_display_name());
+    ret.insert(keeper::Item::SPEED_KEY, 0);
+    ret.insert(keeper::Item::PERCENT_DONE_KEY, double(0.0));
+    ret.insert(keeper::Item::UUID_KEY, uuid);
 
     return ret;
 }
 
-KeeperTask::KeeperTask(TaskData const & task_data,
+QString KeeperTaskPrivate::to_string(Helper::State state)
+{
+    if (helper_)
+    {
+        return helper_->to_string(state);
+    }
+    else
+    {
+        qWarning() << "Asking for the string of a state when the helper is not initialized yet";
+        return "bug";
+    }
+}
+
+keeper::Error KeeperTaskPrivate::error() const
+{
+    return error_;
+}
+
+KeeperTask::KeeperTask(TaskData & task_data,
                        QSharedPointer<HelperRegistry> const & helper_registry,
                        QSharedPointer<StorageFrameworkClient> const & storage,
                        QObject *parent)
@@ -188,16 +230,47 @@
 bool KeeperTask::start()
 {
     Q_D(KeeperTask);
+
     return d->start();
 }
 
 QVariantMap KeeperTask::state() const
 {
     Q_D(const KeeperTask);
+
     return d->state();
 }
 
+void KeeperTask::recalculate_task_state()
+{
+    Q_D(KeeperTask);
+
+    return d->recalculate_task_state();
+}
+
+
 QVariantMap KeeperTask::get_initial_state(KeeperTask::TaskData const &td)
 {
     return KeeperTaskPrivate::get_initial_state(td);
 }
+
+void KeeperTask::cancel()
+{
+    Q_D(KeeperTask);
+
+    return d->cancel();
+}
+
+QString KeeperTask::to_string(Helper::State state)
+{
+    Q_D(KeeperTask);
+
+    return d->to_string(state);
+}
+
+keeper::Error KeeperTask::error() const
+{
+    Q_D(const KeeperTask);
+
+    return d->error();
+}

=== modified file 'src/service/keeper-task.h'
--- src/service/keeper-task.h	2016-09-07 17:07:23 +0000
+++ src/service/keeper-task.h	2017-02-27 19:05:17 +0000
@@ -20,6 +20,7 @@
 
 #pragma once
 
+#include "client/keeper-errors.h"
 #include "helper/metadata.h"
 #include "helper/backup-helper.h"
 #include "helper/helper.h"
@@ -40,11 +41,11 @@
     struct TaskData
     {
         QString action;
-        QString error;
+        keeper::Error error;
         Metadata metadata;
     };
 
-    KeeperTask(TaskData const & task_data,
+    KeeperTask(TaskData & task_data,
                QSharedPointer<HelperRegistry> const & helper_registry,
                QSharedPointer<StorageFrameworkClient> const & storage,
                QObject *parent = nullptr);
@@ -54,12 +55,19 @@
 
     bool start();
     QVariantMap state() const;
+    void recalculate_task_state();
 
     static QVariantMap get_initial_state(KeeperTask::TaskData const &td);
 
+    void cancel();
+
+    QString to_string(Helper::State state);
+
+    keeper::Error error() const;
 Q_SIGNALS:
     void task_state_changed(Helper::State state);
     void task_socket_ready(int socket_descriptor);
+    void task_socket_error(keeper::Error error);
 
 protected:
     KeeperTask(KeeperTaskPrivate & d, QObject *parent = nullptr);

=== modified file 'src/service/keeper-user.cpp'
--- src/service/keeper-user.cpp	2016-09-07 16:35:26 +0000
+++ src/service/keeper-user.cpp	2017-02-27 19:05:17 +0000
@@ -33,75 +33,67 @@
 
 KeeperUser::~KeeperUser() =default;
 
-namespace
-{
-    QVariantMap strings_to_variants(const QMap<QString,QString>& strings)
-    {
-        QVariantMap variants;
-
-        for (auto it=strings.begin(), end=strings.end(); it!=end; ++it)
-            variants.insert(it.key(), QVariant::fromValue(it.value()));
-
-        return variants;
-    }
-
-    QVariantDictMap choices_to_variant_dict_map(const QVector<Metadata>& choices)
-    {
-        QVariantDictMap ret;
-
-        for (auto const& metadata : choices)
-            ret.insert(metadata.uuid(), strings_to_variants(metadata.get_public_properties()));
-
-        return ret;
-    }
-}
-
-QVariantDictMap
+keeper::Items
 KeeperUser::GetBackupChoices()
 {
-    return choices_to_variant_dict_map(keeper_.get_backup_choices());
+    auto bus = connection();
+    auto& msg = message();
+    return keeper_.get_backup_choices_var_dict_map(bus, msg);
 }
 
 void
-KeeperUser::StartBackup (const QStringList& keys)
+KeeperUser::StartBackup (const QStringList& keys, QString const & storage)
 {
     Q_ASSERT(calledFromDBus());
 
-    auto const unhandled = keeper_.start_tasks(keys);
-
-    if (!unhandled.empty())
-    {
-        QString text = QStringLiteral("unhandled uuids:");
-        for (auto const& uuid : unhandled)
-            text += ' ' + uuid;
-        connection().send(message().createErrorReply(QDBusError::InvalidArgs, text));
-    }
+    auto bus = connection();
+    auto& msg = message();
+    keeper_.start_tasks(keys, storage, bus, msg);
 }
 
 void
 KeeperUser::Cancel()
 {
-    // FIXME: writeme
-
-    qDebug() << "hello world";
+    keeper_.cancel();
 }
 
-QVariantDictMap
-KeeperUser::GetRestoreChoices()
+keeper::Items
+KeeperUser::GetRestoreChoices(QString const & storage)
 {
-    return choices_to_variant_dict_map(keeper_.get_restore_choices());
+    Q_ASSERT(calledFromDBus());
+
+    auto bus = connection();
+    auto& msg = message();
+    return keeper_.get_restore_choices(storage, bus, msg);
 }
 
 void
-KeeperUser::StartRestore (const QStringList& keys)
+KeeperUser::StartRestore (const QStringList& keys, QString const & storage)
 {
-    // FIXME: writeme
+    Q_ASSERT(calledFromDBus());
 
-    qDebug() << keys;
+    auto bus = connection();
+    auto& msg = message();
+    // if we start a restore right after a backup the uuid
+    // will be found as a backup uuid.
+    // Just clear the backup cache to avoid that.
+    keeper_.invalidate_choices_cache();
+    keeper_.start_tasks(keys, storage, bus, msg);
 }
 
-QVariantDictMap
+keeper::Items
 KeeperUser::get_state() const
 {
     return keeper_.get_state();
 }
+
+QStringList
+KeeperUser::GetStorageAccounts()
+{
+    Q_ASSERT(calledFromDBus());
+
+    auto bus = connection();
+    auto& msg = message();
+
+    return keeper_.get_storage_accounts(bus, msg);
+}

=== modified file 'src/service/keeper-user.h'
--- src/service/keeper-user.h	2016-09-05 18:38:36 +0000
+++ src/service/keeper-user.h	2017-02-27 19:05:17 +0000
@@ -37,11 +37,11 @@
     virtual ~KeeperUser();
     Q_DISABLE_COPY(KeeperUser)
 
-    Q_PROPERTY(QVariantDictMap State
+    Q_PROPERTY(keeper::Items State
                READ get_state
                NOTIFY state_changed)
 
-    QVariantDictMap get_state() const;
+    keeper::Items get_state() const;
 
 Q_SIGNALS:
 
@@ -49,14 +49,16 @@
 
 public Q_SLOTS:
 
-    QVariantDictMap GetBackupChoices();
-    void StartBackup(const QStringList&);
+    keeper::Items GetBackupChoices();
+    void StartBackup(const QStringList&, QString const & storage);
 
-    QVariantDictMap GetRestoreChoices();
-    void StartRestore(const QStringList&);
+    keeper::Items GetRestoreChoices(QString const & storage);
+    void StartRestore(const QStringList&, QString const & storage);
 
     void Cancel();
 
+    QStringList GetStorageAccounts();
+
 private:
 
     Keeper& keeper_;

=== modified file 'src/service/keeper.cpp'
--- src/service/keeper.cpp	2016-09-07 16:35:26 +0000
+++ src/service/keeper.cpp	2017-02-27 19:05:17 +0000
@@ -32,78 +32,232 @@
 #include <QVector>
 
 #include <algorithm> // std::find_if
-
-class KeeperPrivate
-{
+#include <unistd.h>
+
+namespace
+{
+//    QVariantMap strings_to_variants(const QMap<QString,QString>& strings)
+//    {
+//        QVariantMap variants;
+//
+//        for (auto it=strings.begin(), end=strings.end(); it!=end; ++it)
+//            variants.insert(it.key(), QVariant::fromValue(it.value()));
+//
+//        return variants;
+//    }
+
+    keeper::Items choices_to_variant_dict_map(QVector<Metadata> const & choices)
+    {
+        keeper::Items ret;
+
+        for (auto const& metadata : choices)
+        {
+            keeper::Item value(metadata);
+            ret.insert(metadata.get_uuid(), value);
+        }
+
+        return ret;
+    }
+}
+
+class KeeperPrivate : public QObject
+{
+    Q_OBJECT
 public:
 
     KeeperPrivate(Keeper* keeper,
                   const QSharedPointer<HelperRegistry>& helper_registry,
                   const QSharedPointer<MetadataProvider>& backup_choices,
-                  const QSharedPointer<MetadataProvider>& restore_choices)
-        : q_ptr(keeper)
+                  const QSharedPointer<MetadataProvider>& restore_choices,
+                  QObject *parent = nullptr)
+        : QObject(parent)
+        , q_ptr(keeper)
         , storage_(new StorageFrameworkClient())
         , helper_registry_(helper_registry)
         , backup_choices_(backup_choices)
         , restore_choices_(restore_choices)
         , task_manager_{helper_registry, storage_}
     {
+        QObject::connect(&task_manager_, &TaskManager::finished,
+            std::bind(&KeeperPrivate::on_task_manager_finished, this)
+        );
     }
 
+    enum class ChoicesType { BACKUP_CHOICES, RESTORES_CHOICES };
+
     ~KeeperPrivate() =default;
 
     Q_DISABLE_COPY(KeeperPrivate)
 
-    QStringList start_tasks(QStringList const & uuids)
+    void start_tasks(QStringList const & uuids,
+                     QString const & storage,
+                     QDBusConnection bus,
+                     QDBusMessage const & msg)
     {
-        auto unhandled = QSet<QString>::fromList(uuids);
-
         auto get_tasks = [](const QVector<Metadata>& pool, QStringList const& keys){
             QMap<QString,Metadata> tasks;
             for (auto const& key : keys) {
-                auto it = std::find_if(pool.begin(), pool.end(), [key](Metadata const & m){return m.uuid()==key;});
+                auto it = std::find_if(pool.begin(), pool.end(), [key](Metadata const & m){return m.get_uuid()==key;});
                 if (it != pool.end())
                     tasks[key] = *it;
             }
             return tasks;
         };
 
-        auto tasks = get_tasks(get_backup_choices(), uuids);
-        if (!tasks.empty())
-        {
-            if (task_manager_.start_backup(tasks.values()))
-                unhandled.subtract(QSet<QString>::fromList(tasks.keys()));
+        // async part
+        qDebug() << "Looking for backup options....";
+        connections_.connect_oneshot(
+            this,
+            &KeeperPrivate::backup_choices_ready,
+            std::function<void()>{[this, uuids, msg, bus, get_tasks, storage](){
+                auto tasks = get_tasks(cached_backup_choices_, uuids);
+                if (!tasks.empty())
+                {
+                    auto unhandled = QSet<QString>::fromList(uuids);
+                    if (task_manager_.start_backup(tasks.values(), storage))
+                        unhandled.subtract(QSet<QString>::fromList(tasks.keys()));
+
+                    check_for_unhandled_tasks_and_reply(unhandled, bus, msg);
+                }
+                else // restore
+                {
+                    qDebug() << "Looking for restore options....";
+                    connections_.connect_oneshot(
+                        this,
+                        &KeeperPrivate::restore_choices_ready,
+                        std::function<void(keeper::Error)>{[this, uuids, msg, bus, get_tasks, storage](keeper::Error error){
+                            qDebug() << "Choices ready";
+                            auto unhandled = QSet<QString>::fromList(uuids);
+                            if (error == keeper::Error::OK)
+                            {
+                                auto restore_tasks = get_tasks(cached_restore_choices_, uuids);
+                                qDebug() << "After getting tasks...";
+                                if (!restore_tasks.empty() && task_manager_.start_restore(restore_tasks.values(), storage))
+                                    unhandled.subtract(QSet<QString>::fromList(restore_tasks.keys()));
+                            }
+                            check_for_unhandled_tasks_and_reply(unhandled, bus, msg);
+                        }}
+                    );
+                    get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES);
+                }
+            }}
+        );
+
+        get_choices(backup_choices_, KeeperPrivate::ChoicesType::BACKUP_CHOICES);
+        msg.setDelayedReply(true);
+    }
+
+    void emit_choices_ready(ChoicesType type, keeper::Error error)
+    {
+        switch(type)
+        {
+        case KeeperPrivate::ChoicesType::BACKUP_CHOICES:
+            Q_EMIT(backup_choices_ready(error));
+            break;
+        case KeeperPrivate::ChoicesType::RESTORES_CHOICES:
+            Q_EMIT(restore_choices_ready(error));
+            break;
+        }
+    }
+
+    void get_choices(const QSharedPointer<MetadataProvider> & provider, ChoicesType type, QString const & storage = "")
+    {
+        bool check_empty = (type == KeeperPrivate::ChoicesType::BACKUP_CHOICES)
+                            ? cached_backup_choices_.isEmpty() : cached_restore_choices_.isEmpty();
+        if (check_empty)
+        {
+            connections_.connect_oneshot(
+                provider.data(),
+                &MetadataProvider::finished,
+                std::function<void(keeper::Error)>{[this, provider, type](keeper::Error error){
+                    qDebug() << "Get choices finished";
+                    if (error == keeper::Error::OK)
+                    {
+                        switch (type)
+                        {
+                        case KeeperPrivate::ChoicesType::BACKUP_CHOICES:
+                            cached_backup_choices_ = provider->get_backups();
+                            break;
+                        case KeeperPrivate::ChoicesType::RESTORES_CHOICES:
+                            cached_restore_choices_ = provider->get_backups();
+                            break;
+                        }
+                    }
+                    emit_choices_ready(type, error);
+                }}
+            );
+            provider->get_backups_async(storage);
         }
         else
         {
-            tasks = get_tasks(get_restore_choices(), uuids);
-            if (!tasks.empty() && task_manager_.start_restore(tasks.values()))
-                unhandled.subtract(QSet<QString>::fromList(tasks.keys()));
+            emit_choices_ready(type, keeper::Error::OK);
         }
-
-        if (!unhandled.empty())
-            qWarning() << "skipped tasks" << unhandled;
-
-        return QStringList::fromSet(unhandled);
-    }
-
-    QVector<Metadata> get_backup_choices() const
-    {
-        if (cached_backup_choices_.isEmpty())
-            cached_backup_choices_ = backup_choices_->get_backups();
-
-        return cached_backup_choices_;
-    }
-
-    QVector<Metadata> get_restore_choices() const
-    {
-        if (cached_restore_choices_.isEmpty())
-            cached_restore_choices_ = restore_choices_->get_backups();
-
-        return cached_restore_choices_;
-    }
-
-    QVariantDictMap get_state() const
+    }
+
+    keeper::Items get_backup_choices_var_dict_map(QDBusConnection bus,
+                                                  QDBusMessage const & msg)
+    {
+        connections_.connect_oneshot(
+            this,
+            &KeeperPrivate::backup_choices_ready,
+            std::function<void(keeper::Error)>{[this, msg, bus](keeper::Error error){
+                qDebug() << "Backup choices are ready";
+                if (error == keeper::Error::OK)
+                {
+                    // reply now to the dbus call
+                    auto reply = msg.createReply();
+                    reply << QVariant::fromValue(choices_to_variant_dict_map(cached_backup_choices_));
+                    bus.send(reply);
+                }
+                else
+                {
+                    auto message = QStringLiteral("Error obtaining backup choices, keeper returned error: %1").arg(static_cast<int>(error));
+                    qWarning() << message;
+                    auto reply = msg.createErrorReply(QDBusError::Failed, message);
+                    reply << QVariant::fromValue(error);
+                    bus.send(reply);
+                }
+            }}
+        );
+        get_choices(backup_choices_, KeeperPrivate::ChoicesType::BACKUP_CHOICES);
+        msg.setDelayedReply(true);
+        return keeper::Items();
+    }
+
+    keeper::Items get_restore_choices_var_dict_map(QString const & storage,
+                                                   QDBusConnection bus,
+                                                   QDBusMessage const & msg)
+    {
+        qDebug() << "Getting restores for storage " << storage << " --------------------------------";
+        cached_restore_choices_.clear();
+        connections_.connect_oneshot(
+            this,
+            &KeeperPrivate::restore_choices_ready,
+            std::function<void(keeper::Error)>{[this, msg, bus](keeper::Error error){
+                qDebug() << "Restore choices are ready";
+                if (error == keeper::Error::OK)
+                {
+                    // reply now to the dbus call
+                    auto reply = msg.createReply();
+                    reply << QVariant::fromValue(choices_to_variant_dict_map(cached_restore_choices_));
+                    bus.send(reply);
+                }
+                else
+                {
+                    auto message = QStringLiteral("Error obtaining restore choices, keeper returned error: %1").arg(static_cast<int>(error));
+                    qWarning() << message;
+                    auto reply = msg.createErrorReply(QDBusError::Failed, message);
+                    reply << QVariant::fromValue(error);
+                    bus.send(reply);
+                }
+            }}
+        );
+        get_choices(restore_choices_, KeeperPrivate::ChoicesType::RESTORES_CHOICES, storage);
+        msg.setDelayedReply(true);
+        return keeper::Items();
+    }
+
+    keeper::Items get_state() const
     {
         return task_manager_.get_state();
     }
@@ -127,7 +281,18 @@
             }
         );
 
-        qDebug() << "Asking for an storage framework socket to the task manager";
+        connections_.connect_oneshot(
+            &task_manager_,
+            &TaskManager::socket_error,
+            std::function<void(keeper::Error)>{
+                [bus,msg](keeper::Error error){
+                    qDebug("BackupManager returned socket error: %d", static_cast<int>(error));
+                    bus.send(msg.createErrorReply(QDBusError::InvalidArgs, "Error obtaining remote backup socket"));
+                }
+            }
+        );
+
+        qDebug() << "Asking for a storage framework socket from the task manager";
         task_manager_.ask_for_uploader(n_bytes);
 
         // tell the caller that we'll be responding async
@@ -135,7 +300,102 @@
         return QDBusUnixFileDescriptor(0);
     }
 
+
+    QDBusUnixFileDescriptor start_restore(QDBusConnection bus,
+                                          QDBusMessage const & msg)
+    {
+        qDebug() << "Keeper::StartRestore()";
+
+        connections_.connect_oneshot(
+            &task_manager_,
+            &TaskManager::socket_ready,
+            std::function<void(int)>{
+                [bus,msg](int fd){
+                    qDebug("RestoreManager returned socket %d", fd);
+                    auto reply = msg.createReply();
+                    reply << QVariant::fromValue(QDBusUnixFileDescriptor(fd));
+                    close(fd);
+                    bus.send(reply);
+                }
+            }
+        );
+
+        connections_.connect_oneshot(
+            &task_manager_,
+            &TaskManager::socket_error,
+            std::function<void(keeper::Error)>{
+                [bus,msg](keeper::Error error){
+                    qDebug("RestoreManager returned socket error: %d", static_cast<int>(error));
+                    bus.send(msg.createErrorReply(QDBusError::InvalidArgs, "Error obtaining remote restore socket"));
+                }
+            }
+        );
+
+        qDebug() << "Asking for a storage framework socket from the task manager";
+        task_manager_.ask_for_downloader();
+
+        // tell the caller that we'll be responding async
+        msg.setDelayedReply(true);
+        return QDBusUnixFileDescriptor(0);
+    }
+
+    void cancel()
+    {
+        task_manager_.cancel();
+    }
+
+    void invalidate_choices_cache()
+    {
+        cached_backup_choices_.clear();
+    }
+
+    QStringList get_storage_accounts(QDBusConnection bus,
+                                     QDBusMessage const & msg)
+    {
+        connections_.connect_future(
+            storage_->get_accounts(),
+            std::function<void(QStringList const &)>{
+                [this, msg, bus](QStringList const& accounts){
+                    qDebug() << "get_storage_accounts() finished";
+                    // reply now to the dbus call
+                    auto reply = msg.createReply();
+                    reply << QVariant::fromValue(accounts);
+                    bus.send(reply);
+                }
+            }
+        );
+        msg.setDelayedReply(true);
+        return QStringList();
+    }
+
+Q_SIGNALS:
+    void backup_choices_ready(keeper::Error error);
+    void restore_choices_ready(keeper::Error error);
+
 private:
+    void on_task_manager_finished()
+    {
+        // force a backup choices regeneration to avoid repeating uuids
+        // between backups
+        invalidate_choices_cache();
+    }
+
+    void check_for_unhandled_tasks_and_reply(QSet<QString> const & unhandled,
+                                   QDBusConnection bus,
+                                   QDBusMessage const & msg )
+    {
+        if (!unhandled.empty())
+        {
+            qWarning() << "skipped tasks" << unhandled;
+            QString text = QStringLiteral("unhandled uuids:");
+            for (auto const& uuid : unhandled)
+                text += ' ' + uuid;
+            bus.send(msg.createErrorReply(QDBusError::InvalidArgs, text));
+        }
+
+        auto reply = msg.createReply();
+        bus.send(reply);
+    }
 
     Keeper * const q_ptr;
     QSharedPointer<StorageFrameworkClient> storage_;
@@ -160,12 +420,15 @@
 
 Keeper::~Keeper() = default;
 
-QStringList
-Keeper::start_tasks(QStringList const & uuids)
+void
+Keeper::start_tasks(QStringList const & uuids,
+                    QString const & storage,
+                    QDBusConnection bus,
+                    QDBusMessage const & msg)
 {
     Q_D(Keeper);
 
-    return d->start_tasks(uuids);
+    d->start_tasks(uuids, storage, bus, msg);
 }
 
 QDBusUnixFileDescriptor
@@ -178,26 +441,66 @@
     return d->start_backup(bus, msg, n_bytes);
 }
 
-QVector<Metadata>
-Keeper::get_backup_choices()
-{
-    Q_D(Keeper);
-
-    return d->get_backup_choices();
-}
-
-QVector<Metadata>
-Keeper::get_restore_choices()
-{
-    Q_D(Keeper);
-
-    return d->get_restore_choices();
-}
-
-QVariantDictMap
+QDBusUnixFileDescriptor
+Keeper::StartRestore(QDBusConnection bus,
+                     QDBusMessage const & msg)
+{
+    Q_D(Keeper);
+
+    return d->start_restore(bus, msg);
+}
+
+keeper::Items
+Keeper::get_backup_choices_var_dict_map(QDBusConnection bus,
+                                        QDBusMessage const & msg)
+{
+    Q_D(Keeper);
+
+    return d->get_backup_choices_var_dict_map(bus, msg);
+}
+
+keeper::Items
+Keeper::get_restore_choices(QString const & storage,
+                            QDBusConnection bus,
+                            QDBusMessage const & msg)
+{
+    Q_D(Keeper);
+
+    return d->get_restore_choices_var_dict_map(storage, bus, msg);
+}
+
+keeper::Items
 Keeper::get_state() const
 {
     Q_D(const Keeper);
 
     return d->get_state();
 }
+
+void
+Keeper::cancel()
+{
+    Q_D(Keeper);
+
+    return d->cancel();
+}
+
+void
+Keeper::invalidate_choices_cache()
+{
+    Q_D(Keeper);
+
+    d->invalidate_choices_cache();
+}
+
+QStringList
+Keeper::get_storage_accounts(QDBusConnection bus,
+                             QDBusMessage const & message)
+{
+    Q_D(Keeper);
+
+    return d->get_storage_accounts(bus,message);
+}
+
+
+#include "keeper.moc"

=== modified file 'src/service/keeper.h'
--- src/service/keeper.h	2016-09-07 16:47:55 +0000
+++ src/service/keeper.h	2017-02-27 19:05:17 +0000
@@ -52,16 +52,30 @@
 
     virtual ~Keeper();
 
-    QVector<Metadata> get_backup_choices();
-    QVector<Metadata> get_restore_choices();
+    keeper::Items get_backup_choices_var_dict_map(QDBusConnection bus, QDBusMessage const & msg);
+    keeper::Items get_restore_choices(QString const & storage, QDBusConnection bus, QDBusMessage const & msg);
 
     QDBusUnixFileDescriptor StartBackup(QDBusConnection,
                                         QDBusMessage const & message,
                                         quint64 nbytes);
 
-    QStringList start_tasks(QStringList const & uuids);
-
-    QVariantDictMap get_state() const;
+
+    QDBusUnixFileDescriptor StartRestore(QDBusConnection,
+                                        QDBusMessage const & message);
+
+    void start_tasks(QStringList const & uuids,
+                     QString const & storage,
+                     QDBusConnection bus,
+                     QDBusMessage const & msg);
+
+    keeper::Items get_state() const;
+
+    void cancel();
+
+    void invalidate_choices_cache();
+
+    QStringList get_storage_accounts(QDBusConnection,
+                                     QDBusMessage const & message);
 
 private:
     QScopedPointer<KeeperPrivate> const d_ptr;

=== modified file 'src/service/main.cpp'
--- src/service/main.cpp	2016-08-10 05:41:26 +0000
+++ src/service/main.cpp	2017-02-27 19:05:17 +0000
@@ -20,6 +20,7 @@
 
 #include "dbus-types.h"
 #include "helper/data-dir-registry.h"
+#include "helper/helper.h"
 #include "service/backup-choices.h"
 #include "service/restore-choices.h"
 #include "service/keeper.h"
@@ -45,7 +46,7 @@
 
     QCoreApplication app(argc, argv);
     DBusTypes::registerMetaTypes();
-//    Variant::registerMetaTypes();
+    Helper::registerMetaTypes();
     std::srand(unsigned(std::time(nullptr)));
 
     util::UnixSignalHandler handler([]{

=== added file 'src/service/manifest.cpp'
--- src/service/manifest.cpp	1970-01-01 00:00:00 +0000
+++ src/service/manifest.cpp	2017-02-27 19:05:17 +0000
@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2016 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/>.
+ *
+ * Authors:
+ *   Xavi Garcia Mena <[e-mail]>
+ */
+
+#include "manifest.h"
+
+#include "storage-framework/storage_framework_client.h"
+#include "util/connection-helper.h"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QSharedPointer>
+#include <QVector>
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+namespace sf = unity::storage::qt::client;
+
+// JSON Keys
+namespace
+{
+    constexpr const char ENTRIES_KEY[] = "entries";
+    constexpr const char MANIFEST_FILE_NAME[] = "manifest.json";
+}
+
+/***
+****
+***/
+
+class ManifestPrivate
+{
+public:
+    ManifestPrivate(QSharedPointer<StorageFrameworkClient> const & storage, QString const & dir, Manifest * manifest)
+        : q_ptr{manifest}
+        , storage_{storage}
+        , dir_{dir}
+    {
+    }
+
+    ~ManifestPrivate() = default;
+
+    Q_DISABLE_COPY(ManifestPrivate)
+
+    void add_entry(Metadata const & entry)
+    {
+        entries_.push_back(entry);
+    }
+
+    void store()
+    {
+        qDebug() << "Metadata asking storage framework for a socket";
+        auto json_data = to_json();
+        auto n_bytes = json_data.size();
+
+        connections_.connect_future(
+            storage_->get_new_uploader(n_bytes, dir_, MANIFEST_FILE_NAME),
+            std::function<void(std::shared_ptr<Uploader> const&)>{
+                [this, json_data](std::shared_ptr<Uploader> const& uploader){
+                    qDebug() << "Manifest uploader is" << static_cast<void*>(uploader.get());
+                    if (uploader)
+                    {
+                        auto socket = uploader->socket();
+                        socket->write(json_data);
+                        connections_.connect_oneshot(
+                            uploader.get(),
+                            &Uploader::commit_finished,
+                            std::function<void(bool)>{[this, uploader](bool success){
+                                qDebug() << "Metadata commit finished";
+                                if (!success)
+                                {
+                                    finish_with_error(QStringLiteral("Error committing manifest file to storage-framework"));
+                                }
+                                else
+                                {
+                                    uploader_committed_file_name_ = uploader->file_name();
+                                    finish();
+                                }
+                            }}
+                        );
+                        uploader->commit();
+                    }
+                    else
+                    {
+                        finish_with_error(QStringLiteral("Error retrieving uploader for manifest file from storage-framework"));
+                    }
+                }
+            }
+        );
+    }
+
+    void read()
+    {
+        connections_.connect_future(
+            storage_->get_new_downloader(dir_, MANIFEST_FILE_NAME),
+            std::function<void(std::shared_ptr<Downloader> const&)>{
+                [this](std::shared_ptr<Downloader> const& downloader){
+                    if (downloader)
+                    {
+                        auto socket = downloader->socket();
+                        if (socket->atEnd())
+                        {
+                            if (!socket->waitForReadyRead(5000))
+                            {
+                                qWarning() << "Manifest socket was not ready to read after timeout";
+                            }
+                        }
+                        auto json_content = socket->readAll();
+                        from_json(json_content);
+                        downloader->finish();
+                        finish();
+                    }
+                    else
+                    {
+                        finish_with_error(QStringLiteral("Error retrieving downloader for manifest file from storage-framework"));
+                    }
+                }
+            }
+        );
+    }
+
+    QVector<Metadata> get_entries()
+    {
+        return entries_;
+    }
+
+    QString error() const
+    {
+        return error_string_;
+    }
+
+    QByteArray to_json() const
+    {
+        QJsonArray json_array;
+        for (auto metadata : entries_)
+        {
+            json_array.append(metadata.json());
+        }
+        QJsonObject json_root;
+        json_root[ENTRIES_KEY] = json_array;
+        QJsonDocument doc(json_root);
+
+        return doc.toJson(QJsonDocument::Compact);
+    }
+
+    void from_json(QByteArray const & json)
+    {
+        auto doc_read = QJsonDocument::fromJson(json);
+
+        auto json_read_root = doc_read.object();
+        auto items = json_read_root[ENTRIES_KEY].toArray();
+
+        QVector<Metadata> read_metadata;
+        for( auto iter = items.begin(); iter != items.end(); ++iter)
+        {
+            entries_.push_back(Metadata((*iter).toObject()));
+        }
+    }
+
+private:
+
+    void finish_with_error(QString const & message)
+    {
+        error_string_ = message;
+        Q_EMIT(q_ptr->finished(false));
+    }
+
+    void finish()
+    {
+        error_string_ = "";
+        Q_EMIT(q_ptr->finished(true));
+    }
+
+    Manifest * const q_ptr;
+    QSharedPointer<StorageFrameworkClient> storage_;
+    QString dir_;
+
+    QVector<Metadata> entries_;
+    QString error_string_;
+    QString uploader_committed_file_name_;
+
+    ConnectionHelper connections_;
+};
+
+/***
+****
+***/
+
+Manifest::Manifest(QSharedPointer<StorageFrameworkClient> const & storage, QString const & dir, QObject * parent)
+    : QObject (parent)