Merge lp:~xavi-garcia-mena/keeper/command-line-client-plus-bugs into lp:keeper/devel

[Xavi Garcia]

Changes to command line client and some bugs fixed.

Changes to command line client and some bugs fixed.

This branch changes the command line client to follow the design specs and to show the status of each active task.

The command line client has a separated class for the view, so changing HOW we show the results should be independent of the rest of the code.

It also fixed the following issues:
- Bug when getting downloader, some variables needed to be captured.
- Avoid setting current state for last task until manifest is stored.
- When task manager finishes all tasks we clear the backup choices cache. We do this to avoid repeating uuids in between backups. So if we start 2 backups the uuids now are different. They were equal previously and that created issues when obtaining the restore options, as they are identified by uuid.

What's missing:

* Command line library:
- We need to change the code style to follow the rest of the project's code.

- The library is oriented to the qml app, and only for backups, so some re-design will be necessary.

- We need to add the start restore functionality. Obtaining the restore choices is already done.

* Command line client:
- The output now is using special escape characters. We should investigate if there's something cleaner. (That would mean changes only in the view class)

- Add restore functionality

- Completely follow the specs. For example now the storage is unique and it only uses the option --storage to identify that we want to list the available options in the storage (restore options). To do this we need to change the storage framework client class in order to choose from different accounts and/or storages.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:146
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/145/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1220/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1227/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/145/rebuild

review: Needs Fixing (continuous-integration)

[lp:~xavi-garcia-mena/keeper/command-line-client-plus-bugs]

123. By Xavi Garcia on 2016-12-01

conflict resolved

[Xavi Garcia (xavi-garcia-mena)]

It also fixes the dependency issues and undefined symbols that the client library had.

[unity-api-1-bot (unity-api-1-bot)]

FAILED: Continuous integration, rev:146
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/146/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/1224/console
    FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1231/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/146/rebuild

review: Needs Fixing (continuous-integration)

[unity-api-1-bot (unity-api-1-bot)]

PASSED: Continuous integration, rev:123
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/147/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/1225
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1232
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1015
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1015/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1015
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1015/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1015
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1015/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1015
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1015/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1015
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1015/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1015
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1015/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/147/rebuild

review: Approve (continuous-integration)

[lp:~xavi-garcia-mena/keeper/command-line-client-plus-bugs]

124. By Xavi Garcia on 2016-12-05

Added restore in command line client, added restore in backup registry with empty folder helper

125. By Xavi Garcia on 2016-12-05

Added folder-restore.sh.in

126. By Xavi Garcia on 2016-12-05

fixed debian packaging

127. By Xavi Garcia on 2016-12-05

Fix cppcheck test in zesty

[Charles Kerr (charlesk)]

Some optional suggestions inline, no blockers. LGTM.

review: Approve

[lp:~xavi-garcia-mena/keeper/command-line-client-plus-bugs]

128. By Xavi Garcia on 2016-12-16

Suggested changes in review

[Xavi Garcia (xavi-garcia-mena)]

Thanks for the review, Charles!

I've changed the code following your suggestions.

I only kept the "return true" statement in those two methods as the intention is to add more flags and options in the future...

[unity-api-1-bot (unity-api-1-bot)]

PASSED: Continuous integration, rev:128
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/154/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build/1275
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/1282
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1063
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=xenial+overlay/1063/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1063
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=amd64,release=zesty/1063/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1063
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=xenial+overlay/1063/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1063
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=armhf,release=zesty/1063/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1063
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=xenial+overlay/1063/artifact/output/*zip*/output.zip
    SUCCESS: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1063
        deb: https://jenkins.canonical.com/unity-api-1/job/build-2-binpkg/arch=i386,release=zesty/1063/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/154/rebuild

review: Approve (continuous-integration)

[Michi Henning (michihenning)]

Asking out of curiosity:

"When task manager finishes all tasks we clear the backup choices cache. We do this to avoid repeating uuids in between backups."

That sounded strange to me. I mean, what sort of UUID generator comes up with same UUID twice?

[Xavi Garcia (xavi-garcia-mena)]

Hi Michi,

We clear the cache of uuids because if we run a backup twice we don't repeat the same UUID.
If the cache is not empty we don't recalculate the UUIDs, we need that in between calls to list-sections and backup as we need the UUIDs to be the same after asking for the list of available sections to backup and the moment when we run that backup. (the backup is triggered passing a list of uuids)

But, if we don't clean the uuids when the backup finishes and the user triggers a second backup, the uuids are the same, which is a problem when trying to restore as we'll have 2 backups with the same uuid.

makes sense?

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2016-08-10 07:43:36 +0000
+++ data/CMakeLists.txt	2016-12-16 09:34:32 +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 'debian/keeper.install'
--- debian/keeper.install	2016-08-10 07:43:36 +0000
+++ debian/keeper.install	2016-12-16 09:34:32 +0000
@@ -1,4 +1,5 @@
 /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/*/ubuntu-app-launch/backup-helper/exec-tool

=== modified file 'include/client/client.h'
--- include/client/client.h	2016-09-06 18:28:45 +0000
+++ include/client/client.h	2016-12-16 09:34:32 +0000
@@ -55,10 +55,15 @@
     Q_INVOKABLE void enableBackup(QString uuid, bool enabled);
     Q_INVOKABLE void startBackup();
 
+    Q_INVOKABLE void enableRestore(QString uuid, bool enabled);
+    Q_INVOKABLE void startRestore();
+
 // C++
 public:
     QMap<QString, QVariantMap> getBackupChoices() const;
+    QMap<QString, QVariantMap> getRestoreChoices() const;
     void startBackup(QStringList const& uuids) const;
+    void startRestore(QStringList const& uuids) const;
 
     QMap<QString, QVariantMap> getState() const;
 
@@ -68,6 +73,9 @@
     void readyToBackupChanged();
     void backupBusyChanged();
 
+    void taskStatusChanged(QString const & displayName, QString const & status, double percentage);
+    void finished();
+
 private Q_SLOTS:
     void stateUpdated();
 

=== modified file 'src/cli/CMakeLists.txt'
--- src/cli/CMakeLists.txt	2016-09-06 01:31:59 +0000
+++ src/cli/CMakeLists.txt	2016-12-16 09:34:32 +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	2016-12-16 09:34:32 +0000
@@ -0,0 +1,128 @@
+/*
+ * 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);
+    // 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)
+{
+
+    return QStringLiteral("%1    %2 %    %3").arg(displayName, 15).arg((percentage * 100), 10, 'f', 2, ' ').arg(status, -15);
+}
+
+void CommandLineClientView::on_task_state_changed(QString const & displayName, QString const & status, double percentage)
+{
+    auto iter = tasks_strings_.find(displayName);
+    if (iter != tasks_strings_.end())
+    {
+        tasks_strings_[displayName] = get_task_string(displayName, status, percentage);
+    }
+}

=== 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	2016-12-16 09:34:32 +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 <[e-mail]>
+ */
+#pragma once
+
+#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);
+
+public Q_SLOTS:
+    void show_info();
+    void on_task_state_changed(QString const & displayName, QString const & status, double percentage);
+
+private:
+    char get_next_spin_char();
+    QString get_task_string(QString const & displayName, QString const & status, double percentage);
+
+    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	2016-12-16 09:34:32 +0000
@@ -0,0 +1,247 @@
+/*
+ * 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)
+{
+    QMap<QString, QVariantMap> choices_values;
+    if(!remote)
+    {
+        choices_values = keeper_client_->getBackupChoices();
+        list_backup_sections(choices_values);
+    }
+    else
+    {
+        choices_values = keeper_client_->getRestoreChoices();
+        list_restore_sections(choices_values);
+    }
+}
+
+void CommandLineClient::run_backup(QStringList & sections)
+{
+    auto unhandled_sections = sections;
+    auto choices_values = keeper_client_->getBackupChoices();
+    QStringList uuids;
+    for(auto iter = choices_values.begin(); iter != choices_values.end() && unhandled_sections.size(); ++iter)
+    {
+        const auto& values = iter.value();
+        auto iter_values = values.find("type");
+        if (iter_values != values.end())
+        {
+            if (iter_values.value() == "folder")
+            {
+                auto iter_display_name = values.find("display-name");
+                if (iter_display_name != values.end())
+                {
+                    auto index = unhandled_sections.indexOf((*iter_display_name).toString());
+                    if (index != -1)
+                    {
+                        // we have to backup this section
+                        uuids << iter.key();
+                        unhandled_sections.removeAt(index);
+                        view_->add_task((*iter_display_name).toString(), "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();
+    view_->start_printing_tasks();
+}
+
+void CommandLineClient::run_restore(QStringList & sections)
+{
+    auto unhandled_sections = sections;
+    auto choices_values = keeper_client_->getRestoreChoices();
+    QStringList uuids;
+    for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
+    {
+        const auto& values = iter.value();
+
+        QVariant choice_value;
+        auto has_type = find_choice_value(values, "type", choice_value);
+        if (has_type && choice_value == "folder")
+        {
+            QVariant display_name;
+            auto has_display_name = find_choice_value(values, "display-name", display_name);
+            if (!has_display_name)
+                continue;
+
+            QVariant dir_name;
+            auto has_dir_name = find_choice_value(values, "dir-name", dir_name);
+            if (!has_dir_name)
+                continue;
+
+            auto section_name = QStringLiteral("%1:%2").arg(display_name.toString()).arg(dir_name.toString());
+            auto index = unhandled_sections.indexOf(section_name);
+            if (index != -1)
+            {
+                // we have to restore this section
+                uuids << iter.key();
+                unhandled_sections.removeAt(index);
+                view_->add_task(display_name.toString(), "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();
+    view_->start_printing_tasks();
+}
+
+void CommandLineClient::list_backup_sections(QMap<QString, QVariantMap> const & choices_values)
+{
+    QStringList sections;
+    for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
+    {
+        const auto& values = iter.value();
+
+        QVariant choice_value;
+        auto has_type = find_choice_value(values, "type", choice_value);
+        if (has_type && choice_value == "folder")
+        {
+            auto has_display_name = find_choice_value(values, "display-name", choice_value);
+            if (has_display_name)
+            {
+                 sections << choice_value.toString();
+            }
+        }
+    }
+    view_->print_sections(sections);
+}
+
+void CommandLineClient::list_restore_sections(QMap<QString, QVariantMap> const & choices_values)
+{
+    QMap<QString, QList<QVariantMap>> values_per_dir;
+
+    for(auto iter = choices_values.begin(); iter != choices_values.end(); ++iter)
+    {
+        const auto& values = iter.value();
+
+        QVariant choice_value;
+        auto has_type = find_choice_value(values, "type", choice_value);
+        if (has_type && choice_value == "folder")
+        {
+            auto has_dir_name = find_choice_value(values, "dir-name", choice_value);
+            if (!has_dir_name)
+                continue;
+            values_per_dir[choice_value.toString()].push_back(values);
+        }
+    }
+
+    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);
+
+            QVariant choice_value;
+            auto has_type = find_choice_value(values, "type", choice_value);
+            if (has_type && choice_value == "folder")
+            {
+                auto has_display_name = find_choice_value(values, "display-name", choice_value);
+                if (has_display_name)
+                {
+                    sections << QStringLiteral("%1:%2").arg(choice_value.toString()).arg(iter.key());
+                }
+            }
+        }
+        sections << "";
+    }
+    view_->print_sections(sections);
+}
+
+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;
+}

=== 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	2016-12-16 09:34:32 +0000
@@ -0,0 +1,53 @@
+/*
+ * 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>
+
+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);
+    void run_backup(QStringList & sections);
+    void run_restore(QStringList & sections);
+
+private Q_SLOTS:
+    void on_progress_changed();
+    void on_status_changed();
+    void on_keeper_client_finished();
+
+private:
+    static bool find_choice_value(QVariantMap const & choice, QString const & id, QVariant & value);
+    void list_backup_sections(QMap<QString, QVariantMap> const & choices);
+    void list_restore_sections(QMap<QString, QVariantMap> const & choices);
+    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	2016-12-16 09:34:32 +0000
@@ -0,0 +1,188 @@
+/*
+ * 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_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_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[]          = "Lists the available sections stored at the storage";
+    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_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_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)},
+        });
+    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;
+    }
+    else
+    {
+        cmd_args.cmd = CommandLineParser::Command::LIST_LOCAL_SECTIONS;
+    }
+
+    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)
+            },
+        });
+    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;
+    }
+    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)
+            },
+        });
+    parser_->process(app);
+
+    // it didn't exit... we're good
+    cmd_args.sections = QStringList();
+    cmd_args.storage = QString();
+    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;
+    }
+    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;
+}

=== added file 'src/cli/command-line.h'
--- src/cli/command-line.h	1970-01-01 00:00:00 +0000
+++ src/cli/command-line.h	2016-12-16 09:34:32 +0000
@@ -0,0 +1,52 @@
+/*
+ * 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, 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_backup(QCoreApplication const & app, CommandArgs & cmd_args);
+    bool handle_restore(QCoreApplication const & app, CommandArgs & cmd_args);
+
+    bool check_number_of_args(QStringList const & args);
+
+    QSharedPointer<QCommandLineParser> parser_;
+};

=== modified file 'src/cli/main.cpp'
--- src/cli/main.cpp	2016-11-22 09:37:40 +0000
+++ src/cli/main.cpp	2016-12-16 09:34:32 +0000
@@ -17,6 +17,8 @@
  *     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>
@@ -29,6 +31,8 @@
 #include <libintl.h>
 #include <cstdlib>
 #include <ctime>
+#include <iostream>
+
 
 int
 main(int argc, char **argv)
@@ -37,7 +41,6 @@
 
     QCoreApplication app(argc, argv);
     DBusTypes::registerMetaTypes();
-//    Variant::registerMetaTypes();
     std::srand(unsigned(std::time(nullptr)));
 
     // boilerplate locale
@@ -46,51 +49,31 @@
     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_REMOTE_SECTIONS:
+                client.run_list_sections(true);
+                exit(0);
+                break;
+            case CommandLineParser::Command::BACKUP:
+                client.run_backup(cmd_args.sections);
+                break;
+            case CommandLineParser::Command::RESTORE:
+                client.run_restore(cmd_args.sections);
+                break;
+        };
     }
 
 

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2016-08-26 09:30:11 +0000
+++ src/client/CMakeLists.txt	2016-12-16 09:34:32 +0000
@@ -11,6 +11,11 @@
   ${CLIENT_HEADERS}
 )
 
+set_target_properties(${KEEPER_CLIENT_LIB} PROPERTIES
+  AUTOMOC TRUE
+  LINK_FLAGS "-Wl,--no-undefined"
+)
+
 target_link_libraries(
   ${KEEPER_CLIENT_LIB}
   qdbus-stubs

=== modified file 'src/client/client.cpp'
--- src/client/client.cpp	2016-08-26 08:48:05 +0000
+++ src/client/client.cpp	2016-12-16 09:34:32 +0000
@@ -22,34 +22,62 @@
 #include <client/client.h>
 
 #include <qdbus-stubs/keeper_user_interface.h>
+#include <qdbus-stubs/DBusPropertiesInterface.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");
+    }
+
+    static bool checkAllTasksFinished(QMap<QString, QVariantMap> const & state)
+    {
+        bool ret = true;
+        for (auto iter = state.begin(); ret && (iter != state.end()); ++iter)
+        {
+            auto statusString = (*iter).value("action").toString();
+            ret = stateIsFinal(statusString);
+        }
+        return ret;
+    }
+
     QScopedPointer<DBusInterfaceKeeperUser> userIface;
+    QScopedPointer<DBusPropertiesInterface> propertiesIface;
     QString status;
     QMap<QString, QVariantMap> backups;
-    double progress;
-    bool readyToBackup;
-    bool backupBusy;
-    QTimer stateTimer;
+    QMap<QString, QVariantMap> restores;
+    double progress = 0;
+    bool readyToBackup = false;
+    bool backupBusy = false;
+    QMap<QString, TaskStatus> task_status;
+    TasksMode mode = TasksMode::IDLE_MODE;
 };
 
 KeeperClient::KeeperClient(QObject* parent) :
@@ -66,7 +94,7 @@
         iter.value()["enabled"] = false;
     }
 
-    connect(&d->stateTimer, &QTimer::timeout, this, &KeeperClient::stateUpdated);
+    connect(d->propertiesIface.data(), &DBusPropertiesInterface::PropertiesChanged, this, &KeeperClient::stateUpdated);
 }
 
 KeeperClient::~KeeperClient() = default;
@@ -120,17 +148,19 @@
         }
     }
 
+    d->task_status[uuid] = KeeperClientPrivate::TaskStatus{"", 0.0};
+
     Q_EMIT readyToBackupChanged();
 }
 
+void KeeperClient::enableRestore(QString uuid, bool enabled)
+{
+    // Until we re-design the client we treat restores as backups
+    enableBackup(uuid, enabled);
+}
+
 void KeeperClient::startBackup()
 {
-    // TODO: Instead of polling for state, we should be listening to a stateChanged signal
-    if (!d->stateTimer.isActive())
-    {
-        d->stateTimer.start(200);
-    }
-
     // Determine which backups are enabled, and start only those
     QStringList backupList;
     for(auto iter = d->backups.begin(); iter != d->backups.end(); ++iter)
@@ -145,6 +175,7 @@
     {
         startBackup(backupList);
 
+        d->mode = KeeperClientPrivate::TasksMode::BACKUP_MODE;
         d->status = "Preparing Backup...";
         Q_EMIT statusChanged();
         d->backupBusy = true;
@@ -152,6 +183,30 @@
     }
 }
 
+void KeeperClient::startRestore()
+{
+    // 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);
+
+        d->mode = KeeperClientPrivate::TasksMode::RESTORE_MODE;
+        d->status = "Preparing Restore...";
+        Q_EMIT statusChanged();
+        d->backupBusy = true;
+        Q_EMIT backupBusyChanged();
+    }
+}
+
 QString KeeperClient::getBackupName(QString uuid)
 {
     return d->backups.value(uuid).value("display-name").toString();
@@ -170,6 +225,20 @@
     return choices.value();
 }
 
+QMap<QString, QVariantMap> KeeperClient::getRestoreChoices() const
+{
+    QDBusPendingReply<QMap<QString, QVariantMap>> choices = d->userIface->call("GetRestoreChoices");
+
+    choices.waitForFinished();
+    if (!choices.isValid())
+    {
+        qWarning() << "Error getting restore 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);
@@ -180,6 +249,16 @@
     }
 }
 
+void KeeperClient::startRestore(const QStringList& uuids) const
+{
+    QDBusReply<void> backupReply = d->userIface->call("StartRestore", uuids);
+
+    if (!backupReply.isValid())
+    {
+        qWarning() << "Error starting restore:" << backupReply.error().message();
+    }
+}
+
 QMap<QString, QVariantMap> KeeperClient::getState() const
 {
     return d->userIface->state();
@@ -191,9 +270,26 @@
 
     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->task_status.keys())
+        {
+            auto iter_state = states.find(uuid);
+            if (iter_state == states.end())
+            {
+                qWarning() << "State for uuid: " << uuid << " was not found";
+            }
+            auto state = (*iter_state);
+            double progress = state.value("percent-done").toDouble();
+            auto status = state.value("action").toString();
+
+            auto current_state = d->task_status[uuid];
+            if (current_state.status != status || current_state.percentage < progress)
+            {
+                d->task_status[uuid].status = status;
+                d->task_status[uuid].percentage = progress;
+                Q_EMIT(taskStatusChanged(state.value("display-name").toString(), status, progress));
+            }
+        }
+
         double totalProgress = 0;
         for (auto const& state : states)
         {
@@ -203,28 +299,45 @@
         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());
         }
     }
 }

=== modified file 'src/helper/CMakeLists.txt'
--- src/helper/CMakeLists.txt	2016-11-11 14:50:06 +0000
+++ src/helper/CMakeLists.txt	2016-12-16 09:34:32 +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

=== 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	2016-12-16 09:34:32 +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
+# TODO, please place here your restore helper code.

=== modified file 'src/helper/restore-helper.cpp'
--- src/helper/restore-helper.cpp	2016-11-22 09:37:40 +0000
+++ src/helper/restore-helper.cpp	2016-12-16 09:34:32 +0000
@@ -100,6 +100,11 @@
             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();
 

=== modified file 'src/qdbus-stubs/CMakeLists.txt'
--- src/qdbus-stubs/CMakeLists.txt	2016-08-10 05:41:26 +0000
+++ src/qdbus-stubs/CMakeLists.txt	2016-12-16 09:34:32 +0000
@@ -84,6 +84,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
+)
 #
 #
 
@@ -99,7 +116,7 @@
   ${adaptor_files}
 )
 
-target_link_libraries(
-  ${STUBS_LIB}
-  backup-helper
-)
+#target_link_libraries(
+#  ${STUBS_LIB}
+#  backup-helper
+#)

=== 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	2016-12-16 09:34:32 +0000
@@ -22,7 +22,6 @@
 #include <QtCore>
 #include <QString>
 #include <QVariantMap>
-#include <helper/helper.h>
 
 typedef QMap<QString, QVariantMap> QVariantDictMap;
 Q_DECLARE_METATYPE(QVariantDictMap)
@@ -39,7 +38,7 @@
 
         qDBusRegisterMetaType<QVariantDictMap>();
         qDBusRegisterMetaType<QStringMap>();
-        Helper::registerMetaTypes();
+//        Helper::registerMetaTypes();
     }
 
     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	2016-12-16 09:34:32 +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/keeper.cpp'
--- src/service/keeper.cpp	2016-11-22 09:37:40 +0000
+++ src/service/keeper.cpp	2016-12-16 09:34:32 +0000
@@ -75,6 +75,9 @@
         , 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 };
@@ -213,6 +216,7 @@
     QVariantDictMap get_restore_choices_var_dict_map(QDBusConnection bus,
                                                      QDBusMessage const & msg)
     {
+        cached_restore_choices_.clear();
         connections_.connect_oneshot(
             this,
             &KeeperPrivate::restore_choices_ready,
@@ -306,6 +310,13 @@
 
 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(QSet<QString> const & unhandled,
                                    QDBusConnection bus,
                                    QDBusMessage const & msg )

=== modified file 'src/service/main.cpp'
--- src/service/main.cpp	2016-08-10 05:41:26 +0000
+++ src/service/main.cpp	2016-12-16 09:34:32 +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([]{

=== modified file 'src/service/task-manager.cpp'
--- src/service/task-manager.cpp	2016-11-21 11:09:07 +0000
+++ src/service/task-manager.cpp	2016-12-16 09:34:32 +0000
@@ -111,6 +111,7 @@
         // notify the initial state once for all tasks
         notify_state_changed();
         remaining_tasks_.clear();
+        Q_EMIT(q_ptr->finished());
     }
 
 private:
@@ -172,17 +173,18 @@
             set_current_task_action(task_->to_string(Helper::State::FAILED));
         }
         active_manifest_.reset();
+
+        Q_EMIT(q_ptr->finished());
     }
 
     void on_helper_state_changed(Helper::State state)
     {
         auto backup_task_ = qSharedPointerDynamicCast<KeeperTaskBackup>(task_);
         auto& td = task_data_[current_task_];
-        update_task_state(td);
 
         // for the last completed backup task we delay updating the
         // state until the manifest file is stored
-        if (remaining_tasks_.size() || state != Helper::State::COMPLETE)
+        if (remaining_tasks_.size() || (state != Helper::State::COMPLETE && state != Helper::State::FAILED))
             update_task_state(td);
 
         if (state == Helper::State::COMPLETE || state == Helper::State::FAILED)
@@ -213,6 +215,10 @@
                     );
                     active_manifest_->store();
                 }
+                else
+                {
+                    update_task_state(td);
+                }
             }
         }
     }

=== modified file 'src/service/task-manager.h'
--- src/service/task-manager.h	2016-11-21 11:09:07 +0000
+++ src/service/task-manager.h	2016-12-16 09:34:32 +0000
@@ -65,6 +65,7 @@
 Q_SIGNALS:
     void socket_ready(int reply);
     void state_changed();
+    void finished();
 
 private:
     QScopedPointer<TaskManagerPrivate> const d_ptr;

=== modified file 'src/storage-framework/storage_framework_client.cpp'
--- src/storage-framework/storage_framework_client.cpp	2016-11-24 14:48:35 +0000
+++ src/storage-framework/storage_framework_client.cpp	2016-12-16 09:34:32 +0000
@@ -168,7 +168,7 @@
             connection_helper_.connect_future(
                 get_keeper_folder(root, dir_name, false),
                 std::function<void(sf::Folder::SPtr const&)>{
-                    [this, fi, file_name](sf::Folder::SPtr const& keeper_root){
+                    [this, fi, file_name, root](sf::Folder::SPtr const& keeper_root){
                         if (!keeper_root)
                         {
                             qWarning() << "Error accessing keeper root folder";
@@ -183,12 +183,12 @@
                             connection_helper_.connect_future(
                                 get_storage_framework_file(keeper_root, file_name),
                                 std::function<void(sf::File::SPtr const&)>{
-                                    [this, fi](sf::File::SPtr const& sf_file){
+                                    [this, fi, root, keeper_root](sf::File::SPtr const& sf_file){
                                         if (sf_file) {
                                             connection_helper_.connect_future(
                                                 sf_file->create_downloader(),
                                                 std::function<void(sf::Downloader::SPtr const&)>{
-                                                    [this, fi, sf_file](sf::Downloader::SPtr const& sf_downloader){
+                                                    [this, fi, sf_file, keeper_root, root](sf::Downloader::SPtr const& sf_downloader){
                                                         std::shared_ptr<Downloader> ret;
                                                         if (sf_downloader)
                                                         {

=== modified file 'tests/unit/helper/CMakeLists.txt'
--- tests/unit/helper/CMakeLists.txt	2016-09-27 11:22:15 +0000
+++ tests/unit/helper/CMakeLists.txt	2016-12-16 09:34:32 +0000
@@ -28,6 +28,7 @@
 target_link_libraries(
   ${SPEED_TEST}
   ${UNIT_TEST_LIBRARIES}
+  storage-framework
   Qt5::Core
   Qt5::DBus
   Qt5::Test

=== modified file 'tests/unit/manifest/CMakeLists.txt'
--- tests/unit/manifest/CMakeLists.txt	2016-10-06 14:53:44 +0000
+++ tests/unit/manifest/CMakeLists.txt	2016-12-16 09:34:32 +0000
@@ -27,6 +27,7 @@
 target_link_libraries(
   ${MANIFEST_TEST}
   ${UNIT_TEST_LIBRARIES}
+  backup-helper
   Qt5::Core
   Qt5::DBus
   Qt5::Test

=== modified file 'tests/unit/metadata-providers/CMakeLists.txt'
--- tests/unit/metadata-providers/CMakeLists.txt	2016-07-31 17:20:13 +0000
+++ tests/unit/metadata-providers/CMakeLists.txt	2016-12-16 09:34:32 +0000
@@ -11,6 +11,9 @@
 target_link_libraries(
   ${TEST_NAME}
   ${UNIT_TEST_LIBRARIES}
+  storage-framework
+  backup-helper
+  ${SERVICE_DEVEL_SF_DEPS_LIBRARIES}
   Qt5::Core
   Qt5::DBus
   Qt5::Test